| 導購 | 订阅 | 在线投稿
分享
 
 
 

socket編程原理

來源:互聯網  2008-06-01 02:08:26  評論

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)

數字話音

無連接

不可靠的數據報

有確認的數據報

請求-應答

電子郵件(E-mail)

電子郵件中的挂號信

網絡數據庫查詢

順序

在網絡傳輸中,兩個連續報文在端-端通信中可能經過不同路徑,這樣到達目的地時的順序可能會與發送時不同。「順序」是指接收數據順序與發送數據順序相同。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. 向服務器發服務請求報文,等待並接收應答;繼續提出請求......

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*/

u_short sin_port; /*16位端口號,網絡字節順序*/

struct in_addr sin_addr; /*32位IP地址,網絡字節順序*/

char sin_zero[8]; /*保留*/

}

有關bind()的具體描述參看5.2.2。

3.3 建立套接字連接──connect()與accept()

這兩個系統調用用于完成一個完整相關的建立,其中connect()用于建立連接。無連接的套接字進程也可以調用connect(),但這時在進程之間沒有實際的報文交換,調用將從本地操作系統直接返回。這樣做的優點是程序員不必爲每一數據指定目的地址,而且假如收到的一個數據報,其目的端口未與任何套接字建立「連接」,便能判定該端靠紀紀可操作。而accept()用于使服務器等待來自某客戶進程的實際連接。

connect()的調用格式如下:

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

參數s是欲建立連接的本地套接字描述符。參數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);

參數s爲本地套接字描述符,在用做accept()調用的參數前應該先調用過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(....)) < 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與客戶的套接字建立相關,子進程啓動後,關閉繼續下來的主服務器的initsockid,並利用新的 newsockid與客戶通信。主服務器的initsockid可繼續等待新的客戶連接請求。由于在Unix等搶先多任務系統中,在系統調度下,多個進程可以同時進行。因此,使用並發服務器可以使服務器進程在同一時間可以有多個子進程和不同的客戶程序連接、通信。鑰紀紀戶程序看來,服務器可以同時並發地處理多個客戶的請求,這就是並發服務器名稱的來由。

面向連接服務器也可以是重複服務器,其結構如下:

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);

}

重複服務器在一個時間只能和一個客戶程序建立連接,它對多個客戶程序的處理是采用循環的方式重複進行,因此叫重複服務器。並發服務器和重複服務器各有利弊:並發服務器可以改善客戶程序的響應速度,但它增加了系統調度的開銷;重複服務器正好與其相反,因此用戶在決定是使用並發服務器還是重複服務器時,要根據應用的實際情考網考網來定。

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 指定。flags 指定傳輸控制方式,如是否發送帶外數據等。假如沒有錯誤發生,send()返回總共發送的字節數。否則它返回SOCKET_ERROR。

有關send()的具體描述參看5.2.19。

recv()調用用于鑰紀紀數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 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);

}

/* 使用任意端口命名套接字 */

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);

}

/* 找出指定的端口號並打印出來 */

length = sizeof(server);

if (getsockname(sock, (struct sockaddr *)&server, &length) < 0) {

perror(「getting socket name」);

exit(1);

}

printf(「socket port #%d

」, 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

」);

else

printf(「-->%s

」, buf);

}while (rval != 0);

closesocket(msgsock);

} while (TRUE);

/* 因爲這個程序已經有了一個無限循環,所以套接字「sock」從來不顯式關閉。然而,當進程被殺死或正常終止時,所有套接字都將自動地被關閉。*/

exit(0);

}

客戶方程序:

/* File Name: streamc.c */

#include

#include

#define DATA 「half a league, half a league ...」

/* 這個程序建立套接字,然後與命令行給出的套接字連接;連接結束時,在連接上發送

一個消息,然後關閉套接字。命令行的格式是:streamc 主機名 端口號

端口號要與服務器程序的端口號相同 */

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

」, 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結構,獲取服務端口號。客戶程序使用。

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

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

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; /* 端口號 */

} 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) */

/* 此函數用于需要被動套接字的服務器程序,它除了獲取服務信息外,還建立

一個被動套接字。*/

{

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 簡單服務器程序示例

/* File Name: server.c */

/* 這是一個很簡單的重複服務器程序,它初始化好被動套接字後,循環等待接收連接。假如接收到連接,它顯示數據套接字序號和客戶端的IP地址;假如數據套接字上有數據到來,它接收數據並顯示該連接的數據套接字序號和接收到的字符串。*/

#include "tcpsock.h"

main(argc, argv)

int argc;

char **argv;

{

struct in_addr sin_addr;

int retcode, i;

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")) < 0) {

printf("InitPassiveSock: error code = %d

", retcode);

exit(-1);

}

while (1) {

retcode = QuerySocketsMsg(); /* 查詢網絡消息 */

if (SockMsg.AcceptNum == 1) { /* 有外來連接等待接收?*/

retcode = AcceptConnection(&sin_addr);

printf("retcode = %d, IP = %s

", retcode, inet_ntoa(sin_addr.s_addr));

}

else if (SockMsg.AcceptNum == -1) /* 主套接字錯誤?*/

printf("Daemon Sockets error.

");

for (i=0; i

if ((retcode = RecvPacket(SockMsg.ReadQueue[i], buf, 32)) > 0)

printf("sockno %d Recv string = %s

", SockMsg.ReadQueue[i], buf);

else /* 返回數據長度爲零,指示連接中斷,關閉套接字。*/

CloseConnection(SockMsg.ReadQueue[i]);

}

} /* end while */

}

2.5.4 簡單客戶程序示例

/* File Name: client.c */

/* 客戶程序在執行時,先初始化數據結構,然後等待用戶輸入命令。它識別四個命令:

conn(ect): 和服務器建立連接;

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"); /* 運行服務器程序的主機的IP地址 */

if ((retcode = InitSocketsStruct("TestService")) < 0) { /* 初始化數據結構 */

printf("InitSocketsStruct: error code = %d

", retcode);

exit(1);

}

while (1) {

printf(">");

gets(cmd_buf);

if (!strncmp(cmd_buf, "conn", 4)) {

retcode = CreateConnection(&sin_addr); /* 建立連接 */

printf("return code: %d

", retcode);

}

else if(!strncmp(cmd_buf, "send", 4)) {

printf("Sockets Number:");

scanf("%d", &sockno1);

retcode = SendPacket(sockno1, buf, 26); /* 發送數據 */

printf("return code: %d

", retcode, sizeof(buf));

}

else if (!strncmp(cmd_buf, "close", 4)) {

printf("Sockets Number:");

scanf("%d", &sockno1);

retcode = CloseConnection(sockno1); /* 關閉連接 */

printf("return code: %d

", retcode);

}

else if (!strncmp(cmd_buf, "quit", 4))

exit(0);

else

putchar('

  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) 數字話音 無連接 不可靠的數據報 有確認的數據報 請求-應答 電子郵件(E-mail) 電子郵件中的挂號信 網絡數據庫查詢 順序 在網絡傳輸中,兩個連續報文在端-端通信中可能經過不同路徑,這樣到達目的地時的順序可能會與發送時不同。「順序」是指接收數據順序與發送數據順序相同。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. 向服務器發服務請求報文,等待並接收應答;繼續提出請求...... 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*/ u_short sin_port; /*16位端口號,網絡字節順序*/ struct in_addr sin_addr; /*32位IP地址,網絡字節順序*/ char sin_zero[8]; /*保留*/ } 有關bind()的具體描述參看5.2.2。 3.3 建立套接字連接──connect()與accept() 這兩個系統調用用于完成一個完整相關的建立,其中connect()用于建立連接。無連接的套接字進程也可以調用connect(),但這時在進程之間沒有實際的報文交換,調用將從本地操作系統直接返回。這樣做的優點是程序員不必爲每一數據指定目的地址,而且假如收到的一個數據報,其目的端口未與任何套接字建立「連接」,便能判定該端靠紀紀可操作。而accept()用于使服務器等待來自某客戶進程的實際連接。 connect()的調用格式如下: int PASCAL FAR connect(SOCKET s, const struct sockaddr FAR * name, int namelen); 參數s是欲建立連接的本地套接字描述符。參數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); 參數s爲本地套接字描述符,在用做accept()調用的參數前應該先調用過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(....)) < 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與客戶的套接字建立相關,子進程啓動後,關閉繼續下來的主服務器的initsockid,並利用新的 newsockid與客戶通信。主服務器的initsockid可繼續等待新的客戶連接請求。由于在Unix等搶先多任務系統中,在系統調度下,多個進程可以同時進行。因此,使用並發服務器可以使服務器進程在同一時間可以有多個子進程和不同的客戶程序連接、通信。鑰紀紀戶程序看來,服務器可以同時並發地處理多個客戶的請求,這就是並發服務器名稱的來由。 面向連接服務器也可以是重複服務器,其結構如下: 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); } 重複服務器在一個時間只能和一個客戶程序建立連接,它對多個客戶程序的處理是采用循環的方式重複進行,因此叫重複服務器。並發服務器和重複服務器各有利弊:並發服務器可以改善客戶程序的響應速度,但它增加了系統調度的開銷;重複服務器正好與其相反,因此用戶在決定是使用並發服務器還是重複服務器時,要根據應用的實際情考網考網來定。 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 指定。flags 指定傳輸控制方式,如是否發送帶外數據等。假如沒有錯誤發生,send()返回總共發送的字節數。否則它返回SOCKET_ERROR。 有關send()的具體描述參看5.2.19。 recv()調用用于鑰紀紀數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 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); } /* 使用任意端口命名套接字 */ 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); } /* 找出指定的端口號並打印出來 */ length = sizeof(server); if (getsockname(sock, (struct sockaddr *)&server, &length) < 0) { perror(「getting socket name」); exit(1); } printf(「socket port #%d 」, 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 」); else printf(「-->%s 」, buf); }while (rval != 0); closesocket(msgsock); } while (TRUE); /* 因爲這個程序已經有了一個無限循環,所以套接字「sock」從來不顯式關閉。然而,當進程被殺死或正常終止時,所有套接字都將自動地被關閉。*/ exit(0); } 客戶方程序: /* File Name: streamc.c */ #include #include #define DATA 「half a league, half a league ...」 /* 這個程序建立套接字,然後與命令行給出的套接字連接;連接結束時,在連接上發送 一個消息,然後關閉套接字。命令行的格式是:streamc 主機名 端口號 端口號要與服務器程序的端口號相同 */ 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 」, 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結構,獲取服務端口號。客戶程序使用。 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 #include #include #include #include #include #include #include #include #include #include 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; /* 端口號 */ } 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) */ /* 此函數用于需要被動套接字的服務器程序,它除了獲取服務信息外,還建立 一個被動套接字。*/ { 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 簡單服務器程序示例 /* File Name: server.c */ /* 這是一個很簡單的重複服務器程序,它初始化好被動套接字後,循環等待接收連接。假如接收到連接,它顯示數據套接字序號和客戶端的IP地址;假如數據套接字上有數據到來,它接收數據並顯示該連接的數據套接字序號和接收到的字符串。*/ #include "tcpsock.h" main(argc, argv) int argc; char **argv; { struct in_addr sin_addr; int retcode, i; 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")) < 0) { printf("InitPassiveSock: error code = %d ", retcode); exit(-1); } while (1) { retcode = QuerySocketsMsg(); /* 查詢網絡消息 */ if (SockMsg.AcceptNum == 1) { /* 有外來連接等待接收?*/ retcode = AcceptConnection(&sin_addr); printf("retcode = %d, IP = %s ", retcode, inet_ntoa(sin_addr.s_addr)); } else if (SockMsg.AcceptNum == -1) /* 主套接字錯誤?*/ printf("Daemon Sockets error. "); for (i=0; i if ((retcode = RecvPacket(SockMsg.ReadQueue[i], buf, 32)) > 0) printf("sockno %d Recv string = %s ", SockMsg.ReadQueue[i], buf); else /* 返回數據長度爲零,指示連接中斷,關閉套接字。*/ CloseConnection(SockMsg.ReadQueue[i]); } } /* end while */ } 2.5.4 簡單客戶程序示例 /* File Name: client.c */ /* 客戶程序在執行時,先初始化數據結構,然後等待用戶輸入命令。它識別四個命令: conn(ect): 和服務器建立連接; 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"); /* 運行服務器程序的主機的IP地址 */ if ((retcode = InitSocketsStruct("TestService")) < 0) { /* 初始化數據結構 */ printf("InitSocketsStruct: error code = %d ", retcode); exit(1); } while (1) { printf(">"); gets(cmd_buf); if (!strncmp(cmd_buf, "conn", 4)) { retcode = CreateConnection(&sin_addr); /* 建立連接 */ printf("return code: %d ", retcode); } else if(!strncmp(cmd_buf, "send", 4)) { printf("Sockets Number:"); scanf("%d", &sockno1); retcode = SendPacket(sockno1, buf, 26); /* 發送數據 */ printf("return code: %d ", retcode, sizeof(buf)); } else if (!strncmp(cmd_buf, "close", 4)) { printf("Sockets Number:"); scanf("%d", &sockno1); retcode = CloseConnection(sockno1); /* 關閉連接 */ printf("return code: %d ", retcode); } else if (!strncmp(cmd_buf, "quit", 4)) exit(0); else putchar('
󰈣󰈤
 
 
 
>>返回首頁<<
 
 
 
 
 熱帖排行
 
王朝網路微信公眾號
微信掃碼關註本站公眾號 wangchaonetcn
 
 
靜靜地坐在廢墟上,四周的荒凉一望無際,忽然覺得,淒涼也很美
© 2005- 王朝網路 版權所有