1 問題的引入
UNIX系統的I/O指令集，是從Maltics和早期系統中的指令演變出來的，其模式為開啟一讀/寫一關閉（open-write-read- close）。當一個使用者進程進行I/O操作時，它首先呼叫「開啟」以獲得對指定檔案或裝置的使用權，並傳回稱為檔案描述符的整數數，以描述使用者在開啟的檔案或裝置上進行I/O操作的進程。然後這個用戶進程多次呼叫「讀/寫」以傳輸資料。當所有的傳輸操作完成後，使用者程序關閉調用，通知作業系統已經完成了對某一物件的使用。
TCP/ip協定被整合到UNIX核心時，相當於在UNIX系統引入了一種新型的I/O操作。 UNIX用戶程序與網路協定的交互作用比用戶程序與傳統的I/O設備相互作用複雜得多。首先，進行網路操作的兩個流程鑰紀紀同機器上，如何建立它們之間的連結？其次，網路協定存在多種，如何建立一種通用機制以支援多種協定？這些都是網頁應用程式介面所要解決的問題。
在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協定引入了下列幾個概念。
埠
網路中可以命名和定址的通訊埠，是作業系統可分配的資源。
依照OSI七層協定的描述，傳輸層與網路層在功能上的最大差異在於傳輸層提供進程通訊能力。從這個意義上講，網路通訊的最終位址就不僅僅是主機位址了，還包括可以描述進程的某種識別碼。為此，TCP/IP協定提出了協定連接埠（protocol port，簡稱連接埠）的概念，用於標識通訊的進程。
埠是一種抽象的軟體結構（包括一些資料結構和I/O緩衝區）。應用程式（即進程）透過系統呼叫與某個連接埠建立連線（binding）後，傳輸層傳給該連接埠的資料都會被對應進程所接收，對應進程傳送給傳輸層的資料都會透過該連接埠輸出。在TCP/IP協定的實現中，端靠紀紀作類似於一般的I/O操作，進程獲取一個端口，相當於獲取本地唯一的I/O文件，可以用一般的讀寫原語訪問之。
類似於檔案描述符，每個連接埠都擁有一個叫做連接埠號碼（port number）的整數型標識符，用於區別不同連接埠。由於TCP/IP傳輸層的兩個協定TCP和UDP是完全獨立的兩個軟體模組，因此各自的端口號也相互獨立，如TCP有一個255號端口，UDP也可以有一個255號端口，二者並不衝突。
連接埠號碼的分配是一個重要問題。有兩種基本分配方式：第一種叫做全域分配，這是一種集中控制方式，由一個公認的中心機構根據使用者需求進行統一分配，並將結果公佈於眾。第二種是本地分配，又稱動態連接，即進程需要訪問傳輸層服務時，向本地操作系統提出申請，操作系統返回一個本地唯一的端口號，進程再通過合適的系統調用將自己與該端口號聯繫起來（綁紮）。 TCP/IP連接埠號碼的分配中綜合了上述兩種方式。 TCP/IP將連接埠號碼分為兩部分，少量的作為保留端口，以全域方式分配給服務進程。因此，每一個標準伺服器都擁有一個全域公認的連接埠（即周知口，well-known port），即使鑰紀紀同機器上，其連接埠號碼也相同。剩餘的為自由端口，以本地方式進行分配。 TCP和UDP都規定，小於256的連接埠號碼才能保留連接埠。
位址
網路通訊中通訊的兩個進程分別鑰紀紀同的機器上。在互連網絡中，兩台機器可能位湧紀紀同的網絡，這些網絡透過網絡互連設備（網關，網橋，路由器等）連接。因此需要三級尋址：
1. 某一主機可與多個網路相連，必須指定一特定網路位址；
2. 網路上每一台主機應有其唯一的位址；
3. 每一主機上的每一進程應有在該主機上的唯一識別碼。
通常主機位址由網路ID和主機ID組成，在TCP/IP協定中以32位元整數值表示；TCP和UDP皆使用16位元連接埠號碼標識使用者進程。
網路位元組順序
不同的電腦存放多位元組值的順序不同，有的機器在起始位址存放低位元組（低價先存），有的存高位元組（高價先存）。為確保資料的正確性，在網路協定中須指定網路位元組順序。 TCP/IP協定使用16位元整數和32位元整數的高價先存格式，它們都包含在協定頭檔中。
連接
兩個進程間的通訊鏈路稱為連接。連接在目紀紀表現為一些緩衝區和一組協議機制，在外部表現出比無連接高的可靠性。
半相關
綜上所述，網絡中用一個三元組可以在全局唯一標誌一個進程：
（協議，本地地址，本地端口號）
這樣一個三元組，叫做一個半相關（half-association），它指定連接的每半部。
全相關
一個完整的網間進程通訊需要由兩個進程組成，且只能使用同一種高層協定。也就是說，不可能通訊的一端用TCP協議，而另一端則用UDP協定。因此一個完整的網間通訊需要一個五元組來標識：
（協議，本地地址，本地端口號，遠地地址，遠地端口號）
這樣一個五元組，叫做一個相關（association） ，即兩個協定相同的半相關才能組合成一個適當的相關，或完全指定組成一連接。
2.2 服務方式
在網路分層結構中，各層之間是嚴格單向依靠的，各層次的分工和協作集中體現在相量紀紀之間的界面。 「服務」是描述相量紀紀之間關係的抽象概念，即網絡中各層向緊鄰上層提供的一組操作。下層是服務提供者，上層是請求服務的使用者。服務的表現形式是原語（primitive），如係統呼叫或函式庫函數。系統呼叫是作業系統核心提供給網路應用程式或高層協定的服務原語。網路中的n層總是要提供n+1層比n-1層更完整的服務，否則n層就沒有存在的價值。
在OSI的術語中，網絡層及其以下各層又稱為通信子網，只提供點到點通信，沒有程序或進程的概念。而傳輸層實現的是「端對端」通信，引進網間進程通信概念，同時也要解決差錯控制，流量控制，數據排序（報文排序），連接治理等問題，為此提供不同的服務方式：
面向連接（虛電路）或無連接
面向連接服務是電話系統服務模式的抽象，即每一次完整的數據傳輸都要經過建立連接，使用連接，終止連接的過程。在資料傳輸過程中，各資料分組不攜帶目的位址，而使用連接號碼（connect ID）。本質上，連接是一個管道，收發資料不但順序一致，而且內容相同。 TCP協定提供面向連線的虛擬電路。
無連線服務是郵政系統服務的抽象，每個分組都攜帶完整的目的地址，各分組在系統中獨立傳送。無連線服務無法保證分組的先後順序，不進行分組出錯的恢復與重傳，不保證傳輸的可靠性。 UDP協定提供無連線的資料報服務。
以下舉出這兩種服務的類型及應用中的例子：
服務類型
服務
例子
面向連接
可靠的報文流
的字節流
可靠的報文流
的字節流
可靠的訊息傳遞（FTP）
遠端登入（Telnet）
數位話音
無連線
不可靠的資料封包
有確認的資料封包 掛號信
網路資料庫查詢
順序
在網路傳輸中，兩個連續封包在端－端通訊中可能經過不同路徑，這樣到達目的地時的順序可能會與傳送時不同。 「順序」是指接收資料順序與發送資料順序相同。 TCP協定提供這項服務。
錯誤控制
保證應用程式接收的資料無錯誤的一種機制。檢查錯誤的方法一般是採用檢驗「檢查和（Checksum）」的方法。而確保傳送無錯誤的方法是雙方採用確認應答技術。 TCP協定提供這項服務。
流控制
在資料傳輸過程中控制資料傳輸速率的一種機制，以確保資料不會被遺失。 TCP協定提供這項服務。
位元組流
位元組流方式指的是僅將傳輸中的訊息視為一個位元組序列，而沒有提供資料流的任何邊界。 TCP協定提供位元組流服務。
封包
接收者要保存發送方的封包邊界。 UDP協定提供報文服務。
全雙工/半雙工
端－端間資料同時以兩個方向/一個方向傳送。
快取/帶外資料
在位元組流服務中，由於沒有封包邊界，使用者程序在某個時刻可以讀取或寫任意數量的位元組。為確保傳輸正確或採用有流控制的協定時，都要進行快取。但對某些非凡的需求，如互動式應用程序，又會要求取消這種快取。
在資料傳送過程中，希望不透過常規傳輸方式傳送給使用者以便及時處理的某一類訊息，如UNIX系統的中斷鍵（Delete或Control-c）、終端流控制符（Control-s和Control -q），稱為帶外資料。邏輯上看，好像用戶程序使用了一個獨立的通道傳輸這些資料。此通道與每對連接的流相聯繫。由於Berkeley Software Distribution中對帶外資料的實作與RFC 1122中規定的Host Agreement不一致,為了將互通中的問題減到最小，應用程式編寫者除非與現有服務互通時要求帶外資料外，最好不使用它。
2.3 客戶/伺服器模式
在TCP/IP網路應用中，通訊的兩個進程間相互作用的主要模式是客戶/伺服器模式（Client/Server model），即客戶向伺服器發出服務請求，伺服器接收到請求後，提供相應的服務。客戶/伺服器模式的建立基於以下兩點：首先，建立網路的起因是網路中軟硬體資源、運算能力和資訊不均等，需要共享，從而造就擁有眾多資源的主機提供服務，資源較少的客戶請求服務這一非對等作用。其次，網間進程通訊完全是異步的，相互通訊的進程間既不存在父子關係，又不共享記憶體緩衝區，因此需要一種機制為希望通訊的進程間建立聯繫，為二者的資料交換提供同步，這就是基湧紀紀戶/伺服器模式的TCP/IP。
客戶/伺服器模式鑰紀紀作過程中採取的是主動請求方式：
首先伺服器方要先啟動，並根據請求提供相應服務：
1. 打開一通訊通道並告知本地主機，它願意在某一公認地址上（周知口，如FTP為21）接收客戶請求；
2. 等待客戶請求到達該端口；
3. 接收到重複服務請求，處理該請求並發送應答信號。接收到並發服務請求，要啟動新進程來處理這個客戶請求（如UNIX系統中用fork、exec）。新進程處理此客戶請求，並不需要對其它請求作出應答。服務完成後，關閉此新程序與客戶的通訊鏈路，並終止。
4. 返回第二步，等待另一個客戶要求。
5. 關閉伺服器
客戶方：
1. 開啟一條通訊頻道，並連接伺服器所在主機的特定連接埠；
2. 向伺服器發送服務要求封包，等待並接收連接埠；
2. 向伺服器發送服務要求封包，等待並接收連接埠；請求......
3. 請求結束後關閉通訊通道並終止。
從上方所描述流程可知：
1. 顧客與伺服器程序的功能是不對稱的，因此編碼不同。
2. 服務進程一般是先湧紀紀戶請求而啟動的。只要係統運行，該服務程序一直存在，直到正常或強迫終止。
2.4 套接字類型
TCP/IP的socket提供下列三種類型套接字。
串流式套接字（SOCK_STREAM）
提供了一個面向連接、可靠的資料傳輸服務，資料無錯誤、無重複地發送，且按發送順序接收。內設流量控制，避免資料流超限；資料被視為位元組流，無長度限制。檔案傳送協定（FTP）即使用串流套接字。
資料報式套接字（SOCK_DGRAM）
提供了一個無連線服務。資料包以獨立包形式被發送，不提供無錯保證，
資料可能遺失或重複，且接收順序混亂。網路檔案系統（NFS）使用資料報式套接字。
原始式套接字（SOCK_RAW）
此介面答應對較低層協議，如IP、ICMP直接存取。常用於檢驗新的協定實現或存取現有服務中配置的新設備。
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()系統呼叫實際上指定了相關五元組中的「協定」這一元。
有關socket()的具體描述參考5.2.23。
3.2 指定本地位址－bind()
當一個套接字用socket()創建後，存在一個名字空間(位址族),但它沒有被命名。 bind()將套接字位址（包括本機主機位址和本機連接埠位址）與所建立的套接字號碼連結起來，即將名字賦予套接字，以指定本地半相關。其呼叫格式如下：
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*/
short sin_family; /*AF_INET*/
連接埠號碼，網路位元組順序*/
struct in_addr sin_addr; /*32位元IP位址，網路位元組順序*/
char sin_zero[8]; /*保留*/
}的具體描述參考5.2.2。
3.3 建立套接字連接－connect()與accept()
這兩個系統呼叫用於完成一個完整相關的建立，其中connect()用於建立連接。無連線的套接字進程也可以呼叫connect()，但此時在進程之間沒有實際的封包交換，呼叫將從本機作業系統直接傳回。這樣做的優點是程式設計師不必為每一資料指定目的地址，而且假如收到的一個資料報，其目的端口未與任何套接字建立“連接”，便能判定該端靠紀紀可操作。而accept()用於使伺服器等待來自某客戶程序的實際連線。
connect()的呼叫格式如下：
int PASCAL FAR connect(SOCKET s, const struct sockaddr FAR * name, int namelen);
。參數name指出說明對方套接字位址結構的指標。對方套接字位址長度由namelen說明。
假如沒有錯誤發生，connect()回傳0。否則返回值SOCKET_ERROR。在面向連接的協定中，該呼叫導致本機系統和外部系統之間連接實際建立。
由於位址族總被包含在套接字位址結構的前兩個位元組中，並透過socket()呼叫與某個協定族相關。因此bind()和connect()無須協定作為參數。
有關connect()的具體描述參考5.2.4。
accept()的呼叫格式如下：
SOCKET PASCAL FAR accept(SOCKET s, struct sockaddr FAR* addr, int FAR* addrlen);
參數描述為本地用字符描述)呼叫的參數前應該先呼叫過listen()。 addr 指向客戶方套接字位址結構的指針，用來接收連接實體的位址。 addr的確切格式由套接字建立時建立的位址族決定。 addrlen 為客戶方套接字位址的長度（位元組數）。假如沒有錯誤發生， accept()傳回SOCKET類型的值，表示接收到的套接字的描述符。否則回傳值INVALID_SOCKET。
accept()用於面向連線伺服器。參數addr和addrlen存放客戶方的地址資訊。在呼叫前，參數addr 指向一個初始值為空的位址結構，而addrlen 的初始值為0；呼叫accept()後，伺服器等待從編號為s的套接字上接受客戶連線請求，而連線請求是由客戶方的connect ()呼叫發出的。當有連線請求到達時，accept()呼叫將請求連線佇列上的第一個客戶方套接字位址及長度放入addr 和addrlen，並建立一個與s有相同特性的新套接字號。新的套接字可用於處理伺服器並發請求。
有關accept()的具體描述參考5.2.1。
四個套接字系統調用，socket()、bind()、connect()、accept()，可以完成一個完全五元相關的建立。 socket ()指定五元組中的協定元，它的用法與是否為客戶或伺服器、是否面向連線無關。 bind()指定五元組中的本地二元，即本地主機位址和連接埠號，其用法與是否面向連接有關：在伺服器方，無論是否面向連接，均要呼叫bind()；鑰紀紀戶方，若採用面向連接，則可以不呼叫bind()，而透過connect()自動完成。若採用無連接，客戶方必須使用bind()以獲得一個唯一的位址。
以上討論僅對客戶/伺服器模式而言，實際上套接字的使用是非常靈活的，唯一需遵循的原則是進程通信之前，必須建立完整的相關。
3.4 監聽連線－listen()
此呼叫用於連接伺服器，表示它願意接收連線。 listen()需在accept()之前調用，其調用格式如下：
int PASCAL FAR listen(SOCKET s, int backlog);
參數s標識一個本地已建立、尚未連接的套接字號，伺服器願意從它上面接收請求。 backlog表示請求連線佇列的最大長度，用於限制排隊請求的個數，目前答應的最大值為5。假如沒有錯誤發生，listen()回傳0。否則它返回SOCKET_ERROR。
listen()在執行呼叫過程中可為沒有呼叫過bind()的套接字s完成所必須的連接，並建立長度為backlog的請求連接佇列。
呼叫listen()是伺服器接收一個連線請求的四個步驟中的第三步驟。它在調用socket()分配一個流套接字，且調用bind()給s賦於一個名字之後調用，而且一定要在accept()之前調用。
有關listen()的具體描述參考5.2.13。
2.3節中提到鑰紀紀戶/伺服器模式中，有兩種類型的服務：重複服務和並發服務。 accept()呼叫為實現並發服務提供了極大方便，因為它要傳回一個新的套接字號，其典型結構為：
int initsockid, newsockid;
if ((initsockid = socket(... .))
error(“can't create socket”);
if (bind(initsockid,....)
error(“bind error”);list (initsockid , 5)
error(“listen error”);
for (; {
newsockid = accept(initsockid, ...) /* 阻塞*/
error(“accept error“);
if (fork() == 0){ /* 子程序*/
closesocket(initsockid);
do(ockid); (0);
}
closesocket(newsockid); /* 父流程*/
}
這段程式執行的結果是newsockid與客戶的套接字建立相關，子進程啟動後，關閉繼續下來的主伺服器的initsockid,並利用新的 newsockid與客戶通訊。主伺服器的initsockid可繼續等待新的客戶連線請求。由於在Unix等搶先多任務系統中，在系統調度下，多個進程可以同時進行。因此，使用並發伺服器可以使伺服器進程在同一時間可以有多個子進程和不同的客戶程式連接、通訊。鑰紀紀戶程式看來，伺服器可以同時並發地處理多個客戶的請求，這就是並發伺服器名稱的來由。
面向連線伺服器也可以是重複伺服器，其架構如下：
int initsockid, newsockid;
if ((initsockid = socket(....))
error(" cant create) ”);
if (bind(initsockid,....)
error(“bind error”);
if (listen(initsockid,5)
if (listen(initsockid,5)
for (; {
newsockid = accept(initsockid, ...) /* 阻塞*/
if (newsockid error(“acacidceptor"); /* 處理請求*/
closesocket(newsockid);
}
重複伺服器在一個時間只能和一個客戶程式建立連接，它對多個客戶程式的處理是採用循環的方式重複進行，因此叫重複伺服器。要依照應用的實際情考網考網來設定。 ()。 char FAR *buf, int len, int flags);
參數s為已連接的本地套接字描述符。 ，如是否發送帶外資料等。用於鑰紀紀數s指定的已連接的數據報或流套接字上接收輸入數據，格式如下：
int PASCAL FAR recv(SOCKET s, char FAR *buf, int len, int flags) ;
參數s 為已連接的套接字描述子。 buf指向接收輸入資料緩衝區的指針，其長度由len 指定。 flags 指定傳輸控制方式，如是否接收帶外資料等。假如沒有錯誤發生，recv()會傳回總共接收的位元組數。如果連線被關閉，返回0。否則它返回SOCKET_ERROR。
有關recv()的具體描述參考5.2.16。
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指向要偵測是否出錯的套接字描述符集合的指標。 timeout指向select()函數等待的最大時間，假如設為NULL則為阻塞操作。 select()傳回包含在fd_set結構中已預備好的套接字描述符的總數目，或是發生錯誤則傳回SOCKET_ERROR。
有關select()的具體描述參考5.2.18。
3.7 關閉套接字－closesocket()
closesocket()關閉套接字s，並釋放分配給該套接字的資源；假如s涉及一個打開的TCP連接，則該連接被釋放。 closesocket()的呼叫格式如下：
BOOL PASCAL FAR closesocket(SOCKET s);
參數s待關閉的套接字描述符。假如沒有錯誤發生，closesocket()回傳0。否則返回值SOCKET_ERROR。
有關closesocket()的具體描述參考5.2.3。
2.4 典型套接字調用過程舉例
如前所述，TCP/IP協定的應用一般採用客戶/伺服器模式，因此在實際應用中，必須有客戶和伺服器兩個進程，並且首先啟動伺服器，其係統調用時序圖如下。
面向連線的協定（如TCP）的套接字系統呼叫如圖2.1所示：
伺服器必須先啟動，直到它執行完accept()調用，進入等待狀態後，方能接收客戶請求。如果客戶在先前啟動，則connect()將傳回出錯代碼，連線不成功。
圖2.1 連線導向的套接字系統呼叫時序圖
無連線協定的套接字呼叫如圖2.2所示：
圖2.2 無連線協定的套接字呼叫時序圖
圖
伺服器也必須先啟動，否則客戶要求傳不到服務流程。無連線客戶不呼叫connect()。因此在資料發送之前，客戶與伺服器之間尚未建立完全相關，但各自透過socket()和bind()建立了半相關。發送資料時，發送方除指定本機套接字號外，還需指定接收方套接字號，從而在資料收發過程中動態地建立了全相關。
實例
本實例使用面向連接協議的客戶/服務器模式，其流程如圖2.3所示：
圖2.3 面向連接的應用程序流程圖
服務器方程序：
/* File Name: streams.c */
#include
#include
#define TRUE 1
/* 這個程式建立一個套接字，然後開始無限循環；每當它透過循環接收到一個連接，則每當它透過循環接收到一個連接，則每當它開始無限循環；列印出一個訊息。當連線斷開，或接收到終止訊息，則此連線結束，程式再接收一個新的連線。指令列的格式是：streams */
main(
{
int sock, length;
struct sockaddr_in shd ms;
char buf[1024];
int rval, len;
/* 建立套接字*/
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock
exit(1);
}
/* 用任意連接埠命名套接字*/
server.sin_family = AF_INET; NYif
server.sin_family = AF_INET； sockaddr *)&server, sizeof(server))
perror(“binding stream socket”);
exit(1);
}
exit(1);
}
exit(1);
}
*/
length = sizeof(server);
if (getsockname(sock, (struct sockaddr *)&server, &length)
perror(“getting socketname”);
}
printf(“socket port #%d
”, ntohs(server.sin_port));
/* 開始接收連線*/
list sockaddr);
do {
msgsock = accept(sock, (struct sockaddr *)&tcpaddr, (int *)&len);
if (msgsock == -1) *)&len);
if (msgsock == -1) *)&len);
if (msgsock == -1) ); else do{
memset(buf, 0, sizeof(buf));
if ((rval = recv(msgsock, buf, 1024))
perror「reading (rval == 0)
printf(“ending connection
”);
else
printf(“-->%s
”, buf); (msgsock);
} while (TRUE);
/* 因為這個程式已經有了一個無限循環，所以套接字「sock」從來不明確關閉。然而，當進程被殺死或正常終止時，所有套接字都將自動地關閉。 */
exit(0);
}
客戶程式：
/* File Name: streamc.c */
#include league ...”
/* 這個程式建立套接字，然後與命令列給出的套接字連接；連接結束時，在連接上發送
一個訊息，然後關閉套接字。命令列的格式為：streamc 主機名稱連接埠號碼
連接埠號碼要與伺服器程式的連接埠號碼相同*/
main(argc, argv)
int argc;
char *argv
int argc;
char *argv
int sock;
struct sockaddr_in server;
struct hostent *hp, *gethostbyname( ;
char buf[1024]; 🜎 _STREAM, 0);
if (sock
perror(“opening stream socket”);
exit(1);
}
/* 使用指令列中指定的名字連接套接字*/
server.sin_family = AF_INET;
hp = gethostname(argimmo[1]; hp == 0) {
fprintf(stderr, “%s: unknown host
”, argv[1]);
exit(2);
}
exit(2);
}
, ( char*)hp->h_addr, hp->h_length);
sever.sin_port = htons(atoi(argv[2]));
if (connect(sock, (struct sockaddr)&server,
if (connect(sock, (struct sockaddr)&server, sockaddr*server) ))
perror(“connecting stream socket”);
exit(3);
}
if (send(s
}
if (send(s, DATA, ize) “sending on stream socket”);
closesocket(sock);
exit(0);
}
2.5 一個
}
2.5 一個
}
實例。從這個例子我們可以看出，使用socket程式設計幾乎有一個模式，即所有的程式幾乎毫無例外地以相同的順序呼叫相同的函數。因此我們可以設想，設計一個中間層，它向上提供幾個簡單的函數，程序只要調用這幾個函數就可以實現普通情考網考網下的數據傳輸，程序設計者不必太多地關心socket程序設計的細節。
本節我們將介紹一個通用的網路程式接口，它向上層提供幾個簡單的函數，程式設計者只要使用這幾個函數就可以完成絕大多數情考網考網下的網路資料傳輸。這些函數將socket編程和上層隔離開來，它使用面向連接的流式套接字，採用非阻塞的工作機制，程序只要調用這些函數查詢網絡訊息並作出相應的響應即可。這些函數包括：
l InitSocketsStruct：初始化socket結構，取得服務連接埠號碼。客戶程序使用。
l InitPassiveSock：初始化socket結構，取得服務埠號，建立主套接字。伺服器程式使用。
l CloseMainSock：關閉主套接字。伺服器程式使用。
l CreateConnection：建立連線。客戶程序使用。
l AcceptConnection：接收連線。伺服器程式使用。
l CloseConnection：關閉連線。
l QuerySocketsMsg：查詢套接字訊息。
l SendPacket：傳送資料。
l RecvPacket：接收資料。
2.5.1 頭檔
/* File Name: tcpsock.h */
/* 頭檔包括socket程式常用到的系統頭檔（本例所給的是SCO Unix下的頭文件，其它版本的Unix的頭文件可能略有不同），並定義了我們自己的兩個資料結構及其實例變量，以及我們提供的函數說明。 */
#include
#include
#include
#include
#include
.clude
#include
#include
#include
#include
#include
#include
#include
typedef struct SocketsMsg{ /* 套接字詞結構*/？ / * 有外來資料等待讀取的連線數*/
int ReadQueue[32]; /* 有外來資料等待讀取的連線佇列*/
int WriteNum; /* 可以傳送資料的連線數*/
int WriteQueue[32]; /* 可以傳送資料的連線佇列*/
int ExceptNum; /* 有例外的連線數*/
int ExceptQueue[32]; /* 有例外的連線佇列/ SocketsMsg;
typedef struct Sockets { /* 套接字結構*/
int DaemonSock; /* 主套接字*/
*
int SockNum /* 主機套接字數
]; /* 資料套接字數組*/
fd_set readfds, writefds, exceptfds; /* 要被偵測的可讀、可寫入、例外的套接字集合*/
int Port; /* 連接埠號碼* /
} Sockets;
Sockets Mysock; /* 全域變數*/
SocketsMsg SockMsg;
void CloseMainSock() ;
int CreateConnection(struct in_addr *sin_addr);
int AcceptConnection(struct in_addr *IPaddr);
int CloseConnection(int Sockno);
🜎 , 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 succeed then return 1, else return error code (
/* 此函數用於只需要主動套接字的客戶程序，它用來獲取服務資訊。服務的定義
在/etc/services檔案*/
{
struct servent *servrec;
struct sockaddr_in serv_addr;
) {
return(-1);
}
bzero((char *)&Mysock, sizeof(Sockets));
Mysock.Port = servservo-> port / Network
return(1);
}
int InitPassiveSock(char * servicename)
/* Initialize Passive Socket. If succeed then return 1, se*用於需要被動套接字的伺服器程序，它除了獲取服務資訊外，還建立
一個被動套接字。 */
{
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; / Network/p if((mainsock = socket(AF_INET, SOCK_STREAM, 0))
return(-2);
}
bzero((charchar)); sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); /* 任意網路介面*/
serv_addr.sin_port = servrec->s_pport
* r , sizeof(serv_addr))
close(mainsock);
return(-3);
}
if (listen(sock, 5)
if (listen(mainsock) listen(mainsock接字變成被動套接字，預備好接收連線*/
close(mainsock);
return(-4);
}
/* Set s socketas as Non this
if (ioctl(mainsock, FIONBIO, &flag) == -1) {
close(mainsock);
return(-5);
}
return(-5);
}
mainsock , &Mysock.readfds); /* 申明對主套接字「可讀」感愛好*/
FD_SET(mainsock, &Mysock.exceptfds); /* 申明對主套接字上例外事件感*/
ds); /* 申明對主套接字上例外事件感*/
return(1);
}
void CloseMainSock()
/* 關閉主套接字，並清除對它上面事件的申明。在程式結束前關閉主套接字是個好習慣*/
{
close(Mysock.DaemonSock);
FD_CLR(My .DaemonSock, &Mysock.readfLR
FD_CLR(My exceptfds);
}
int CreateConnection(struct in_addr *sin_addr)
/* Create a Connection to remote host which IP address is insin_addr.
if succeed return the socket number which indicates this connection,
else return error code (
{
struct sockaddr_in server
{
struct sockaddr_in server
{
struct sockaddr_in server
{
！
if ((tmpsock = socket(AF_INET, SOCK_STREAM, 0))
return(-1);
server.sin_family = AF_INET;. sin_addr.s_addr = sin_addr->s_addr;
/* Set this socket as a Non-blocking socket. */
if (ioctl(tmpsock, FIONBIO, &that) ;
return(-2);
}
return(-2);
}
return(-2);
}
return(-2);
}
/* Connect to the server. */
if (connect()com if ((errno != EWOULDBLOCK) && (errno != EINPROGRESS)) {
/* 假如錯誤代碼是EWOULDBLOCK和EINPROGRESS，則不用關閉套接字，因為系統將在之後繼續為套接字建立連接，連接是否建立成功可用select()函數來偵測套接字是否「可寫」來確定。 */
close(tmpsock);
return(-3); /* Connect error. */
}
}
sock. writefds);
FD_SET(tmpsock, &Mysock. exceptfds);
i = 0;
while (Mysock.Sockets[i] != 0) i++; /* 尋找空白套接字位置*/ ) {
close(tmpsock);
回(-4); /* 連接太多*/
}
Mysock.Sockets[i] = 885; );
}
int AcceptConnection(struct in_addr *IPaddr)
/* 接受連線。如果成功，傳回資料套接字號，否則回傳-1。 */
{
int newsock, len, flag=1, i;
struct sockaddr_in addr;
len = sizeof(addr); ((newsock = Accept(Mysock.DaemonSock, &addr, &len)) == -1)
return(-1); /* 接受錯誤。 */
/* 設定此套接字為非阻塞套接字。 */
ioctl(newsock, FIONBIO, &flag);
FD_SET(newsock, &Mysock.readfds);
FD_SET(newsock,Mysock.wds);
FD_SET(newsock,Mysock.wds);
/* 傳回參數中的IP位址。 */
IPaddr->s_addr = addr.sin_addr.s_addr;
i = 0;
while (Mysock.Sockets[i] != 03) i++ /* if (i >= 64) {
close(newsock);
返回(-4); /* 太多連接*/
}
Mysock.Sockets[ ;
回傳(i);
}
int CloseConnection(int Sockno)
/* 關閉Sockno 所指示的連線。 */
{
int 重新編碼；
if ((Sockno >= 64) (Sockno = close(Mysock.Sockets[Sockno]);
FD_CLR(Mysock.Sockets[Sockno], &Mysock.readfds);
FD_CLR(Mysock.Sockets[Sockno]
FD_CLR(Mysock.Sockets[Sockno],Mysock。 [Sockno], &Mysock. exceptfds);
Mysock.Sockets[Sockno] = 0;
Mysock.SockNum--;
)（重新編碼）；
/ * 查詢套接字訊息。如果成功返回訊息號，否則返回-1。
struct SockMsg 中儲存的訊息資訊。 */
{
fd_set rfds、wfds、efds；
int 重新編碼，我；
struct timevalds
efds = Mysock . exceptfds;
TimeOut.tv_sec = 0; /* 立即返回，不阻塞。 */
TimeOut.tv_usec = 0;
bzero((char *)&SockMsg, sizeof(SockMsg));
if ((retcode = select(SockMsg));
if ((retcode = select(64,rfds &wn==f), &w &w== 0,w &w==f) )
return(0);
if (FD_ISSET(Mysock.DaemonSock, &rfds))
SockMsg.AcceptNum = 1; /* 有些客戶端呼叫伺服器。 */
for (i=0; i
{
if ((Mysock.Sockets[i] > 0) && (_ISSET(Mysock.SFD i], &rfds)))
SockMsg.ReadQueue[SockMsg.ReadNum++] = i;
}
for (i=0; iif ((Mysock.Sockets[i] > 0) && (FD_ISSET(Mysock.套接字[i]，&wfds)))
SockMsg.WriteQueue[SockMsg.WriteNum++] = i; (FD_ISSET(Mysock.DaemonSock, &efds))
SockMsg.AcceptNum = -1; /* 伺服器套接字錯誤。 */
for (i=0; i
{
if ((Mysock.Sockets[i] > 0) &My& (FD_ISSET(i)ock.Sockets[i ], &efds)))
SockMsg.ExceptQueue[SockMsg.ExceptNum++] = i;
}
回傳（重複編碼）；
}
回
/* 發送資料包。如果成功回傳發送資料的數量，否則回傳-1 */
{
int actlen;
if ((Sockno >= 64) (Sockno = 64) (Sockno = 64) (Sockno
return(0);
if ((actlen = send(Mysock.Sockets[Sockno], buf, len, 0))
return(-1); ;
}
int RecvPacket(int Sockno, void *buf, int size)
/* 接收封包。如果成功回傳接收資料的數量，否則如果連線
被對方關閉則回傳0，否則回傳0-errno */
{
int actlen;
if ((Sockno >= 64) (Sockno
return(05); Mysock.Sockets[Sockno], buf, size, 0))
return(0-errno);
return(actlen); /* actlen是接收的資料長度，假如對方為零，指示連線被對方為零，指示連線被對方關閉。 */
}
2.5.3 簡單服務器程序示例
/* File Name: server.c */
/* 這是一個很簡單的重複服務器程序，它初始化好被動套接字後，循環等待接收連線。假如接收到連接，它顯示資料套接字序號和客戶端的IP位址；假如資料套接字上有資料到來，它接收資料並顯示該連接的資料套接字序號和接收到的字串。 */
#include "tcpsock.h"
main(argc, argv)
int argc;
char **argv;
.
char buf[32];
/* 對於伺服器程序，它經常處於無限循環狀態，只有在用戶主動kill該進程或系統關機時，它才結束。對於使用kill強行終止的伺服器程序，由於主套接字沒有關閉，資源沒有主動釋放，可能會對隨後的伺服器程式重新啟動產生影響。因此，主動關閉主套接字是一個好的變成習慣。下面的語句讓程式在接收到SIGINT、SIGQUIT和SIGTERM等訊號時先執行CloseMainSock()函式關閉主套接字，然後再結束程式。因此，在使用 kill強行終止伺服器程序時，應該先使用kill -2 PID給伺服器程式一個訊息使其關閉主套接字，然後在用kill -9 PID強行結束該程序。 */
(void) signal(SIGINT, CloseMainSock);
(void) signal(SIGQUIT, CloseMainSock);
(void) signal(SIGTERM, CloseMainSock);
if ((retcode = InitPassiveSock("TestService "))
printf("InitPassiveSock: error code = %d
", retcode);
exit(-1);
} ); /* 查詢網路訊息*/
if (SockMsg.AcceptNum == 1) { /* 有外來連線等待接收？ */
retcode = AcceptConnection(&sin_addr);
printf("retcode = %d, IP = %s
", retcode, inet_ntoa(sin_addr.s_addr)）); = -1) /* 主套接字錯誤？ */
printf("Daemon Sockets error.
");
for (i=0; i
if ((retcode = RecvPacket(SockMsg.ReadQueue[i], bufuf, 32)) ("sockno %d Recv string = %s
", SockMsg.ReadQueue[i], buf);
else /* 回傳資料長度為零，指示連線中斷，關閉套接字。 .ReadQueue[i]);
}
} /* end while */
}
2.5.4 簡單客戶程式範例
/
2.5.4 簡單客戶程式範例
/時，先初始化資料結構，然後等待使用者輸入指令。連線；
quit: 退出客戶程式。
*/
#include "tcpsock.h"
main(argc, argv)
char cmd_buf[16];
struct in_addr sin_addr;
int sockno1, retcode;
char *buf = "This is a string for test.";addr. 249"); /* 執行伺服器程式的主機的IP位址*/
if ((retcode = InitSocketsStruct("TestService"))
printf("InitSockets % % d
", retcode);
exit(1);
}
while (1) {
printf(">"); "conn", 4)) {
retcode = CreateConnection(&sin_addr); /* 建立連線*/
printf("return code: %d
", retcode); nc cmd_buf, "send", 4)) {
printf("Sockets Number:");
scanf("%d", &sockno1);
retcode = SendPacket(sockno1);
retcode = SendPacket(sockno1) 寄放資料; */
printf("return code: %d
", retcode, sizeof(buf));
}
else if (!strncmp(cmd_buf, "close
else if (!strncmp(cmd_buf, "close", 4) {closeprintf("Sockets Number:");
scanf("%d", &sockno1);
retcode = CloseConnection(sockno1); /* 關閉連線*/
print("return : %* 關閉連線*/
print("returncode: %* );
}
else if (!strncmp(cmd_buf, "quit", 4))
exit(0);
else
文章請關注PHP中文網（m.sbmmt.com）！
