目錄：?

什么是?socket？...?1

Internet?套接字的兩種類型...?1

網絡理論...?2

結構體...?2

本機轉換...?3

IP?地址和如何處理它們...?4

socket()函數...?4

bind()函數...?4

connect()程序...?5

listen()函數...?6

accept()函數...?6

send() and recv()?7

sendto()?和 recvfrom()函數...?7

close()和shutdown()函數...?8

getpeername()函數...?8

gethostname()函數...?8

域名服務（DNS）...?8

客戶-服務器背景知識...?9

簡單的服務器...?9

簡單的客戶程序...?10

數據包 Sockets?11

阻塞...?13

select()--多路同步 I/O..?13

--------------------------------------------------------------------------------?

什么是?socket？

你經常聽到人們談論著 “socket”，或許你還不知道它的確切含義。現在讓我告訴你：它是使用標準Unix?文件描述符?(file descriptor)?和其它程序通訊的方式。什么？你也許聽到一些Unix高手(hacker)這樣說過：“呀，Unix中的一切就是文件！”那個家伙也許正在說到一個事實：Unix?程序在執行任何形式的?I/O?的時候，程序是在讀或者寫一個文件描述符。一個文件描述符只是一個和打開的文件相關聯的整數。但是(注意后面的話)，這個文件可能是一個網絡連接，?FIFO，管道，終端，磁盤上的文件或者什么其它的東西。Unix?中所有的東西就是文件！所以，你想和Internet上別的程序通訊的時候，你將要使用到文件描述符。你必須理解剛才的話。現在你腦海中或許冒出這樣的念頭：“那么我從哪里得到網絡通訊的文件描述符呢？”，這個問題無論如何我都要回答：你利用系統調用?socket()，它返回套接字描述符?(socket descriptor)，然后你再通過它來進行send()和?recv()調用。 “但是...”，你可能有很大的疑惑，“如果它是個文件描述符，那么為什 么不用一般調用read()和write()來進行套接字通訊？”簡單的答案是：“你可以使用！”。詳細的答案是：“你可以，但是使用send()和recv()讓你更好的控制數據傳輸。”?
存在這樣一個情況：在我們的世界上，有很多種套接字。有DARPA Internet?地址?(Internet?套接字)，本地節點的路徑名?(Unix套接字)，CCITT X.25地址?(你可以將X.25?套接字完全忽略)。也許在你的Unix?機器上還有其它的。我們在這里只講第一種：Internet?套接字。

Internet?套接字的兩種類型?
　　什么意思？有兩種類型的Internet?套接字？是的。不，我在撒謊。其實還有很多，但是我可不想嚇著你。我們這里只講兩種。除了這些,?我打算另外介紹的?"Raw Sockets"?也是非常強大的，很值得查閱。?
那么這兩種類型是什么呢？一種是"Stream Sockets"（流格式），另外一種是"Datagram Sockets"（數據包格式）。我們以后談到它們的時候也會用到?"SOCK_STREAM"?和?"SOCK_DGRAM"。數據報套接字有時也叫“無連接套接字”(如果你確實要連接的時候可以用connect()。)?流式套接字是可靠的雙向通訊的數據流。如果你向套接字按順序輸出“1，2”，那么它們將按順序“1，2”到達另一邊。它們是無錯誤的傳遞的，有自己的錯誤控制，在此不討論。?
有什么在使用流式套接字？你可能聽說過?telnet，不是嗎？它就使用流式套接字。你需要你所輸入的字符按順序到達，不是嗎？同樣，WWW瀏覽器使用的?HTTP?協議也使用它們來下載頁面。實際上，當你通過端口80 telnet到一個?WWW?站點，然后輸入 “GET pagename” 的時候，你也可以得到?HTML?的內容。為什么流式套接字可以達到高質量的數據傳輸？這是因為它使用了“傳輸控制協議?(The Transmission Control Protocol)”，也叫 “TCP”?(請參考?RFC-793?獲得詳細資料。)TCP?控制你的數據按順序到達并且沒有錯誤。你也許聽到 “TCP” 是因為聽到過 “TCP/IP”。這里的?IP?是指“Internet?協議”(請參考?RFC-791。) IP?只是處理?Internet?路由而已。

那么數據報套接字呢？為什么它叫無連接呢？為什么它是不可靠的呢？有這樣的一些事實：如果你發送一個數據報，它可能會到達，它可能次序顛倒了。如果它到達，那么在這個包的內部是無錯誤的。數據報也使用?IP?作路由，但是它不使用?TCP。它使用“用戶數據報協議?(User Datagram Protocol)”，也叫 “UDP”?(請參考?RFC-768。)為什么它們是無連接的呢？主要是因為它并不象流式套接字那樣維持一個連接。你只要建立一個包，構造一個有目標信息的IP?頭，然后發出去。無需連接。它們通常使用于傳輸包-包信息。簡單的應用程序有：tftp, bootp等等。?
你也許會想：“假如數據丟失了這些程序如何正常工作？”我的朋友，每個程序在?UDP?上有自己的協議。例如，tftp?協議每發出的一個被接受到包，收到者必須發回一個包來說“我收到了！”?(一個“命令正確應答”也叫“ACK” 包)。如果在一定時間內(例如5秒)，發送方沒有收到應答，它將重新發送，直到得到?ACK。這一ACK過程在實現?SOCK_DGRAM?應用程序的時候非常重要。

網絡理論?
　　既然我剛才提到了協議層，那么現在是討論網絡究竟如何工作和一些關于?SOCK_DGRAM?包是如何建立的例子。當然，你也可以跳過這一段， 如果你認為已經熟悉的話。現在是學習數據封裝?(Data Encapsulation)?的時候了！它非常非常重 要。它重要性重要到你在網絡課程學（圖1：數據封裝）習中無論如何也得也得掌握它。主要 的內容是：一個包，先是被第一個協議(在這里是TFTP )在它的報頭（也許是報尾）包裝(“封裝”)，然后，整個數據(包括?TFTP?頭)被另外一個協議?(在這里是?UDP )封裝，然后下一個( IP )，一直重復下去，直到硬件(物理)?層(?這里是以太網?)。當另外一臺機器接收到包，硬件先剝去以太網頭，內核剝去IP和UDP?頭，TFTP程序再剝去TFTP頭，最后得到數據。現在我們終于講到聲名狼藉的網絡分層模型?(Layered Network Model)。這種網絡模型在描述網絡系統上相對其它模型有很多優點。例如， 你可以寫一個套接字程序而不用關心數據的物理傳輸(串行口，以太網，連接單元接口?(AUI)?還是其它介質)，因為底層的程序會為你處理它們。實際 的網絡硬件和拓撲對于程序員來說是透明的。不說其它廢話了，我現在列出整個層次模型。如果你要參加網絡考試，可一定要記住：

應用層?(Application)

表示層?(Presentation)

會話層?(Session)

傳輸層(Transport)

網絡層(Network)

數據鏈路層(Data Link)

物理層(Physical)

物理層是硬件(串口，以太網等等)。應用層是和硬件層相隔最遠的--它 是用戶和網絡交互的地方。這個模型如此通用，如果你想，你可以把它作為修車指南。把它對應 到?Unix，結果是：?
應用層(Application Layer) (telnet, ftp,等等)傳輸層(Host-to-Host Transport Layer) (TCP, UDP)Internet層(Internet Layer) (IP和路由)網絡訪問層?(Network Access Layer) (網絡層，數據鏈路層和物理層)

現在，你可能看到這些層次如何協調來封裝原始的數據了。?
看看建立一個簡單的數據包有多少工作？哎呀，你將不得不使用?"cat"?來建立數據包頭！這僅僅是個玩笑。對于流式套接字你要作的是?send()?發送數據。對于數據報式套接字，你按照你選擇的方式封裝數據然后使用sendto()。內核將為你建立傳輸層和?Internet?層，硬件完成網絡訪問層。 這就是現代科技。現在結束我們的網絡理論速成班。哦，忘記告訴你關于路由的事情了。但是我不準備談它，如果你真的關心，那么參考?IP RFC。

結構體?
　　終于談到編程了。在這章，我將談到被套接字用到的各種數據類型。因為它們中的一些內容很重要了。首先是簡單的一個：socket描述符。它是下面的類型：int?
僅僅是一個常見的?int。從現在起，事情變得不可思議了，而你所需做的就是繼續看下去。注 意這樣的事實：有兩種字節排列順序：重要的字節?(有時叫?"octet"，即八位位組)?在前面，或者不重要的字節在前面。前一種叫“網絡字節順序?(Network Byte Order)”。有些機器在內部是按照這個順序儲存數據，而另外 一些則不然。當我說某數據必須按照?NBO?順序，那么你要調用函數(例如?htons() )來將它從本機字節順序?(Host Byte Order)?轉換過來。如果我沒有 提到?NBO，那么就讓它保持本機字節順序。我的第一個結構(在這個技術手冊TM中)--struct sockaddr.。這個結構 為許多類型的套接字儲存套接字地址信息：?
struct sockaddr {?
　　?unsigned short sa_family; /*?地址家族, AF_xxx */?
　　?char sa_data[14]; /*14字節協議地址*/?
　　?};?
sa_family?能夠是各種各樣的類型，但是在這篇文章中都是?"AF_INET"。?sa_data包含套接字中的目標地址和端口信息。這好像有點 不明智。?
為了處理struct sockaddr，程序員創造了一個并列的結構：?struct sockaddr_in ("in"?代表?"Internet"。)?
struct sockaddr_in {?
short int sin_family; /*?通信類型?*/?
unsigned short int sin_port; /*?端口?*/?
struct in_addr sin_addr; /* Internet?地址?*/?
unsigned char sin_zero[8]; /*?與sockaddr結構的長度相同*/?
　　?};?
用這個數據結構可以輕松處理套接字地址的基本元素。注意?sin_zero (它被加入到這個結構，并且長度和?struct sockaddr?一樣)?應該使用函數?bzero()?或?memset()?來全部置零。 同時，這一重要的字節，一個指向sockaddr_in結構體的指針也可以被指向結構體sockaddr并且代替它。這樣的話即使?socket()?想要的是?struct sockaddr *，你仍然可以使用?struct sockaddr_in，并且在最后轉換。同時，注意?sin_family?和?struct sockaddr?中的?sa_family?一致并能夠設置為?"AF_INET"。最后，sin_port和?sin_addr?必須是網絡字節順序?(Network Byte Order)！你也許會反對道："但是，怎么讓整個數據結構?struct in_addr sin_addr?按照網絡字節順序呢?"?要知道這個問題的答案，我們就要仔細的看一看這 個數據結構：?struct in_addr,?有這樣一個聯合?(unions)：?
/* Internet?地址?(一個與歷史有關的結構) */?
　　?struct in_addr {?
　　?unsigned long s_addr;?
　　?};?
它曾經是個最壞的聯合，但是現在那些日子過去了。如果你聲明?"ina"?是數據結構?struct sockaddr_in?的實例，那么?"ina.sin_addr.s_addr"?就儲 存4字節的?IP?地址(使用網絡字節順序)。如果你不幸的系統使用的還是恐怖的聯合?struct in_addr?，你還是可以放心4字節的?IP?地址并且和上面 我說的一樣(這是因為使用了“#define”。)

本機轉換?
　　我們現在到了新的章節。我們曾經講了很多網絡到本機字節順序的轉換，現在可以實踐了！你能夠轉換兩種類型：?short (兩個字節)和?long (四個字節)。這個函數對于變量類型?unsigned?也適用。假設你想將?short?從本機字節順序轉 換為網絡字節順序。用?"h"?表示?"本機?(host)"，接著是?"to"，然后用?"n"?表 示?"網絡?(network)"，最后用?"s"?表示?"short"：?h-to-n-s,?或者?htons() ("Host to Network Short")。?
太簡單了...?
如果不是太傻的話，你一定想到了由"n"，"h"，"s"，和?"l"形成的正確 組合，例如這里肯定沒有stolh() ("Short to Long Host")?函數，不僅在這里 沒有，所有場合都沒有。但是這里有：?
htons()--"Host to Network Short"?
　　htonl()--"Host to Network Long"?
　　ntohs()--"Network to Host Short"?
　　ntohl()--"Network to Host Long"?
現在，你可能想你已經知道它們了。你也可能想：“如果我想改變?char?的順序要怎么辦呢?” 但是你也許馬上就想到，“用不著考慮的”。你也許會想到：我的?68000?機器已經使用了網絡字節順序，我沒有必要去調用?htonl()轉換?IP?地址。你可能是對的，但是當你移植你的程序到別的機器上的時候，你的程序將失敗。可移植性！這里是?Unix?世界！記住：在你將數據放到網絡上的時候，確信它們是網絡字節順序的。?
最后一點：為什么在數據結構?struct sockaddr_in?中，?sin_addr?和?sin_port?需要轉換為網絡字節順序，而sin_family?需不需要呢??答案是：?sin_addr?和?sin_port?分別封裝在包的?IP?和?UDP?層。因此，它們必須要 是網絡字節順序。但是?sin_family?域只是被內核?(kernel)?使用來決定在數 據結構中包含什么類型的地址，所以它必須是本機字節順序。同時，?sin_family?沒有發送到網絡上，它們可以是本機字節順序。

IP?地址和如何處理它們?
現在我們很幸運，因為我們有很多的函數來方便地操作?IP?地址。沒有必要用手工計算它們，也沒有必要用"<<"操作來儲存成長整字型。首先，假設你已經有了一個sockaddr_in結構體ina，你有一個IP地址"132.241.5.10"要儲存在其中，你就要用到函數inet_addr(),將IP地址從 點數格式轉換成無符號長整型。使用方法如下：?
ina.sin_addr.s_addr = inet_addr("132.241.5.10");?
注意，inet_addr()返回的地址已經是網絡字節格式，所以你無需再調用 函數htonl()。?
我們現在發現上面的代碼片斷不是十分完整的，因為它沒有錯誤檢查。 顯而易見，當inet_addr()發生錯誤時返回-1。記住這些二進制數字？(無符號數)-1僅僅和IP地址255.255.255.255相符合！這可是廣播地址！大錯特 錯！記住要先進行錯誤檢查。?
好了，現在你可以將IP地址轉換成長整型了。有沒有其相反的方法呢？ 它可以將一個in_addr結構體輸出成點數格式？這樣的話，你就要用到函數?inet_ntoa()("ntoa"的含義是"network to ascii")，就像這樣：?
printf("%s",inet_ntoa(ina.sin_addr));?
它將輸出IP地址。需要注意的是inet_ntoa()將結構體in-addr作為一個參數，不是長整形。同樣需要注意的是它返回的是一個指向一個字符的 指針。它是一個由inet_ntoa()控制的靜態的固定的指針，所以每次調用inet_ntoa()，它就將覆蓋上次調用時所得的IP地址。例如：?
char *a1, *a2;?
.?
.?
a1 = inet_ntoa(ina1.sin_addr); /*?這是198.92.129.1 */?
a2 = inet_ntoa(ina2.sin_addr); /*?這是132.241.5.10 */?
printf("address 1: %sn",a1);?
printf("address 2: %sn",a2);?
輸出如下：?
address 1: 132.241.5.10?
address 2: 132.241.5.10?
假如你需要保存這個IP地址，使用strcopy()函數來指向你自己的字符指針。?
上面就是關于這個主題的介紹。稍后，你將學習將一個類 似"wintehouse.gov"的字符串轉換成它所對應的IP地址(查閱域名服務,稍后)。

socket()函數?
我想我不能再不提這個了－下面我將討論一下socket()系統調用。?
下面是詳細介紹：?
#include <sys/types.h>?
#include <sys/socket.h>?
int socket(int domain, int type, int protocol);?
但是它們的參數是什么??首先，domain?應該設置成?"AF_INET"，就 象上面的數據結構struct sockaddr_in?中一樣。然后，參數?type?告訴內核 是?SOCK_STREAM?類型還是?SOCK_DGRAM?類型。最后，把?protocol設置為?"0"。(注意：有很多種?domain、type，我不可能一一列出了，請看?socket()?的?man幫助。當然，還有一個"更好"的方式去得到?protocol。同 時請查閱?getprotobyname()?的?man?幫助。)?
socket()?只是返回你以后在系統調用種可能用到的?socket?描述符，或 者在錯誤的時候返回-1。全局變量?errno?中將儲存返回的錯誤值。(請參考?perror()?的?man?幫助。)

bind()函數?
　　一旦你有一個套接字，你可能要將套接字和機器上的一定的端口關聯起來。(如果你想用listen()來偵聽一定端口的數據，這是必要一步--MUD?告 訴你說用命令?"telnet x.y.z 6969"。)如果你只想用?connect()，那么這個步 驟沒有必要。但是無論如何，請繼續讀下去。?
這里是系統調用?bind()?的大概：?
#include <sys/types.h>?
#include <sys/socket.h>?
int bind(int sockfd, struct sockaddr *my_addr, int addrlen);?
sockfd?是調用?socket?返回的文件描述符。my_addr?是指向數據結構?struct sockaddr?的指針，它保存你的地址(即端口和?IP?地址)?信息。?addrlen?設置為?sizeof(struct sockaddr)。?
簡單得很不是嗎??再看看例子：?
#include <string.h>?
#include <sys/types.h>?
#include <sys/socket.h>?
#define MYPORT 3490?
main()?
　　?{?
　　?int sockfd;?
　　?struct sockaddr_in my_addr;?
sockfd = socket(AF_INET, SOCK_STREAM, 0); /*需要錯誤檢查?*/?
my_addr.sin_family = AF_INET; /* host byte order */?
　　?my_addr.sin_port = htons(MYPORT); /* short, network byte order */?
　　?my_addr.sin_addr.s_addr = inet_addr("132.241.5.10");?
　　?bzero(&(my_addr.sin_zero),; /* zero the rest of the struct */?
/* don't forget your error checking for bind(): */?
　　?bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr));?
　　這里也有要注意的幾件事情。my_addr.sin_port?是網絡字節順序，?my_addr.sin_addr.s_addr?也是的。另外要注意到的事情是因系統的不同， 包含的頭文件也不盡相同，請查閱本地的?man?幫助文件。?
在?bind()?主題中最后要說的話是，在處理自己的?IP?地址和/或端口的 時候，有些工作是可以自動處理的。?
my_addr.sin_port = 0; /*?隨機選擇一個沒有使用的端口?*/?
　　my_addr.sin_addr.s_addr = INADDR_ANY; /*?使用自己的IP地址?*/?
通過將0賦給?my_addr.sin_port，你告訴?bind()?自己選擇合適的端 口。同樣，將?my_addr.sin_addr.s_addr?設置為?INADDR_ANY，你告訴 它自動填上它所運行的機器的?IP?地址。如果你一向小心謹慎，那么你可能注意到我沒有將?INADDR_ANY?轉換為網絡字節順序！這是因為我知道內部的東西：INADDR_ANY?實際上就 是?0！即使你改變字節的順序，0依然是0。但是完美主義者說應該處處一致，INADDR_ANY或許是12呢？你的代碼就不能工作了，那么就看下面 的代碼：?
my_addr.sin_port = htons(0); /*?隨機選擇一個沒有使用的端口?*/?
my_addr.sin_addr.s_addr = htonl(INADDR_ANY);/*?使用自己的IP地址?*/?
你或許不相信，上面的代碼將可以隨便移植。我只是想指出，既然你 所遇到的程序不會都運行使用htonl的INADDR_ANY。?
bind()?在錯誤的時候依然是返回-1，并且設置全局錯誤變量errno。?
在你調用?bind()?的時候，你要小心的另一件事情是：不要采用小于?1024的端口號。所有小于1024的端口號都被系統保留！你可以選擇從1024?到65535的端口(如果它們沒有被別的程序使用的話)。 你要注意的另外一件小事是：有時候你根本不需要調用它。如果你使 用?connect()?來和遠程機器進行通訊，你不需要關心你的本地端口號(就象你在使用?telnet?的時候)，你只要簡單的調用?connect()?就可以了，它會檢查套接字是否綁定端口，如果沒有，它會自己綁定一個沒有使用的本地端 口。

connect()程序?
　　現在我們假設你是個?telnet?程序。你的用戶命令你得到套接字的文件 描述符。你聽從命令調用了socket()。下一步，你的用戶告訴你通過端口?23(標準?telnet?端口)連接到"132.241.5.10"。你該怎么做呢??幸運的是，你正在閱讀?connect()--如何連接到遠程主機這一章。你可不想讓你的用戶失望。?connect()?系統調用是這樣的：?
#include <sys/types.h>?
#include <sys/socket.h>?
int connect(int sockfd, struct sockaddr *serv_addr, int addrlen);?
sockfd?是系統調用?socket()?返回的套接字文件描述符。serv_addr?是 保存著目的地端口和?IP?地址的數據結構?struct sockaddr。addrlen?設置 為?sizeof(struct sockaddr)。?
想知道得更多嗎？讓我們來看個例子：?
#include <string.h>?
#include <sys/types.h>?
#include <sys/socket.h>?
#define DEST_IP "132.241.5.10"?
　　#define DEST_PORT 23?
main()?
　　?{?
int sockfd;?
struct sockaddr_in dest_addr; /*?目的地址*/?
sockfd = socket(AF_INET, SOCK_STREAM, 0); /*?錯誤檢查?*/?
dest_addr.sin_family = AF_INET; /* host byte order */?
dest_addr.sin_port = htons(DEST_PORT); /* short, network byte order */?
dest_addr.sin_addr.s_addr = inet_addr(DEST_IP);?
bzero(&(dest_addr.sin_zero),; /* zero the rest of the struct */?
/* don't forget to error check the connect()! */?
connect(sockfd, (struct sockaddr *)&dest_addr, sizeof(struct sockaddr));?
　　?.?
　　?.?
　　?.?
　　再一次，你應該檢查?connect()?的返回值--它在錯誤的時候返回-1，并 設置全局錯誤變量?errno。同時，你可能看到，我沒有調用?bind()。因為我不在乎本地的端口號。 我只關心我要去那。內核將為我選擇一個合適的端口號，而我們所連接的 地方也自動地獲得這些信息。一切都不用擔心。

listen()函數?
　　是換換內容得時候了。假如你不希望與遠程的一個地址相連，或者說，僅僅是將它踢開，那你就需要等待接入請求并且用各種方法處理它們。處 理過程分兩步：首先，你聽--listen()，然后，你接受--accept() (請看下面的 內容)。?
除了要一點解釋外，系統調用?listen?也相當簡單。?
int listen(int sockfd, int backlog);?
sockfd?是調用?socket()?返回的套接字文件描述符。backlog?是在進入 隊列中允許的連接數目。什么意思呢??進入的連接是在隊列中一直等待直到你接受?(accept()?請看下面的文章)連接。它們的數目限制于隊列的允許。 大多數系統的允許數目是20，你也可以設置為5到10。和別的函數一樣，在發生錯誤的時候返回-1，并設置全局錯誤變量?errno。你可能想象到了，在你調用?listen()?前你或者要調用?bind()?或者讓內核隨便選擇一個端口。如果你想偵聽進入的連接，那么系統調用的順序可 能是這樣的：?
socket();?
　　bind();?
listen();?
　　/* accept()?應該在這?*/?
因為它相當的明了，我將在這里不給出例子了。(在?accept()?那一章的 代碼將更加完全。)真正麻煩的部分在?accept()。

accept()函數?
　　準備好了，系統調用?accept()?會有點古怪的地方的！你可以想象發生 這樣的事情：有人從很遠的地方通過一個你在偵聽?(listen())?的端口連接?(connect())?到你的機器。它的連接將加入到等待接受?(accept())?的隊列 中。你調用?accept()?告訴它你有空閑的連接。它將返回一個新的套接字文件描述符！這樣你就有兩個套接字了，原來的一個還在偵聽你的那個端口， 新的在準備發送?(send())?和接收?( recv())?數據。這就是這個過程！函數是這樣定義的：?
#include <sys/socket.h>?
int accept(int sockfd, void *addr, int *addrlen);?
sockfd?相當簡單，是和?listen()?中一樣的套接字描述符。addr?是個指 向局部的數據結構?sockaddr_in?的指針。這是要求接入的信息所要去的地方（你可以測定那個地址在那個端口呼叫你）。在它的地址傳遞給?accept?之 前，addrlen?是個局部的整形變量，設置為?sizeof(struct sockaddr_in)。?accept?將不會將多余的字節給?addr。如果你放入的少些，那么它會通過改?
變?addrlen?的值反映出來。?
同樣，在錯誤時返回-1，并設置全局錯誤變量?errno。?
現在是你應該熟悉的代碼片段。?
#include <string.h>?
#include <sys/socket.h>?
#include <sys/types.h>?
#define MYPORT 3490 /*用戶接入端口*/?
#define BACKLOG 10 /*?多少等待連接控制*/?
main()?
　　?{?
　　int sockfd, new_fd; /* listen on sock_fd, new connection on new_fd */?
　　struct sockaddr_in my_addr; /*?地址信息?*/?
　　struct sockaddr_in their_addr; /* connector's address information */?
　　int sin_size;?
sockfd = socket(AF_INET, SOCK_STREAM, 0); /*?錯誤檢查*/?
my_addr.sin_family = AF_INET; /* host byte order */?
　　my_addr.sin_port = htons(MYPORT); /* short, network byte order */?
　　my_addr.sin_addr.s_addr = INADDR_ANY; /* auto-fill with my IP */?
　　bzero(&(my_addr.sin_zero),; /* zero the rest of the struct */?
/* don't forget your error checking for these calls: */?
　　bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr));?
listen(sockfd, BACKLOG);?
sin_size = sizeof(struct sockaddr_in);?
　　new_fd = accept(sockfd, &their_addr, &sin_size);?
　　?.?
　　?.?
　　?.?
注意，在系統調用?send()?和?recv()?中你應該使用新的套接字描述符?new_fd。如果你只想讓一個連接進來，那么你可以使用?close()?去關閉原來的文件描述符?sockfd?來避免同一個端口更多的連接。

send() and recv()函數?
　　這兩個函數用于流式套接字或者數據報套接字的通訊。如果你喜歡使 用無連接的數據報套接字，你應該看一看下面關于sendto()?和?recvfrom()?的章節。?
send()?是這樣的：?
int send(int sockfd, const void *msg, int len, int flags);?
sockfd?是你想發送數據的套接字描述符(或者是調用?socket()?或者是?accept()?返回的。)msg?是指向你想發送的數據的指針。len?是數據的長度。 把?flags?設置為?0?就可以了。(詳細的資料請看?send()?的?man page)。?
這里是一些可能的例子：?
char *msg = "Beej was here!";?
　　int len, bytes_sent;?
　　.?
　　.?
　　len = strlen(msg);?
　　bytes_sent = send(sockfd, msg, len, 0);?
　　.?
　　.?
　　.?
send()?返回實際發送的數據的字節數--它可能小于你要求發送的數 目！ 注意，有時候你告訴它要發送一堆數據可是它不能處理成功。它只是發送它可能發送的數據，然后希望你能夠發送其它的數據。記住，如果?send()?返回的數據和?len?不匹配，你就應該發送其它的數據。但是這里也有個好消息：如果你要發送的包很小(小于大約?1K)，它可能處理讓數據一 次發送完。最后要說得就是，它在錯誤的時候返回-1，并設置?errno。?
recv()?函數很相似：?
int recv(int sockfd, void *buf, int len, unsigned int flags);?
sockfd?是要讀的套接字描述符。buf?是要讀的信息的緩沖。len?是緩 沖的最大長度。flags?可以設置為0。(請參考recv()?的?man page。) recv()?返回實際讀入緩沖的數據的字節數。或者在錯誤的時候返回-1， 同時設置errno。?
很簡單，不是嗎??你現在可以在流式套接字上發送數據和接收數據了。 你現在是?Unix?網絡程序員了！

sendto()?和?recvfrom()函數?
　　“這很不錯啊”，你說，“但是你還沒有講無連接數據報套接字呢？” 沒問題，現在我們開始這個內容。?
既然數據報套接字不是連接到遠程主機的，那么在我們發送一個包之 前需要什么信息呢??不錯，是目標地址！看看下面的：?
int sendto(int sockfd, const void *msg, int len, unsigned int flags,?
　　const struct sockaddr *to, int tolen);?
你已經看到了，除了另外的兩個信息外，其余的和函數?send()?是一樣 的。?to?是個指向數據結構?struct sockaddr?的指針，它包含了目的地的?IP?地址和端口信息。tolen?可以簡單地設置為?sizeof(struct sockaddr)。 和函數?send()?類似，sendto()?返回實際發送的字節數(它也可能小于 你想要發送的字節數！)，或者在錯誤的時候返回?-1。?
相似的還有函數?recv()?和?recvfrom()。recvfrom()?的定義是這樣的：?
int recvfrom(int sockfd, void *buf, int len, unsigned int flags,?　struct sockaddr *from, int *fromlen);?
又一次，除了兩個增加的參數外，這個函數和?recv()?也是一樣的。from?是一個指向局部數據結構?struct sockaddr?的指針，它的內容是源機器的?IP?地址和端口信息。fromlen?是個?int?型的局部指針，它的初始值為sizeof(struct sockaddr)。函數調用返回后，fromlen?保存著實際儲存在?from?中的地址的長度。?
recvfrom()?返回收到的字節長度，或者在發生錯誤后返回?-1。?
記住，如果你用?connect()?連接一個數據報套接字，你可以簡單的調 用?send()?和?recv()?來滿足你的要求。這個時候依然是數據報套接字，依然使用?UDP，系統套接字接口會為你自動加上了目標和源的信息。

close()和shutdown()函數?
　　你已經整天都在發送?(send())?和接收?(recv())?數據了，現在你準備關 閉你的套接字描述符了。這很簡單，你可以使用一般的?Unix?文件描述符 的?close()?函數：?
　　close(sockfd);?
它將防止套接字上更多的數據的讀寫。任何在另一端讀寫套接字的企 圖都將返回錯誤信息。?
如果你想在如何關閉套接字上有多一點的控制，你可以使用函數?shutdown()。它允許你將一定方向上的通訊或者雙向的通訊(就象close()一 樣)關閉，你可以使用：?
int shutdown(int sockfd, int how);?
sockfd?是你想要關閉的套接字文件描述復。how?的值是下面的其中之 一：?
　　0?– 不允許接受?
　　1?– 不允許發送?
　　2?– 不允許發送和接受(和?close()?一樣)?
shutdown()?成功時返回?0，失敗時返回?-1(同時設置?errno。)?如果在無連接的數據報套接字中使用shutdown()，那么只不過是讓?send()?和?recv()?不能使用(記住你在數據報套接字中使用了?connect?后 是可以使用它們的)。

getpeername()函數?
　　這個函數太簡單了。?
它太簡單了，以至我都不想單列一章。但是我還是這樣做了。 函數?getpeername()?告訴你在連接的流式套接字上誰在另外一邊。函數是這樣的：?
#include <sys/socket.h>?
int getpeername(int sockfd, struct sockaddr *addr, int *addrlen);?
sockfd?是連接的流式套接字的描述符。addr?是一個指向結構?struct sockaddr (或者是?struct sockaddr_in)?的指針，它保存著連接的另一邊的信息。addrlen?是一個?int?型的指針，它初始化為?sizeof(struct sockaddr)。函數在錯誤的時候返回?-1，設置相應的?errno。 一旦你獲得它們的地址，你可以使用?inet_ntoa()?或者?gethostbyaddr()?來打印或者獲得更多的信息。但是你不能得到它的帳號。(如果它運行著愚蠢的守護進程，這是可能的，但是它的討論已經超出了本文的范圍，請參考?RFC-1413?以獲得更多的信息。)

gethostname()函數?
　　甚至比?getpeername()?還簡單的函數是?gethostname()。它返回你程 序所運行的機器的主機名字。然后你可以使用?gethostbyname()?以獲得你 的機器的?IP?地址。?
　　下面是定義：?
　　#include <unistd.h>?
int gethostname(char *hostname, size_t size);?
參數很簡單：hostname?是一個字符數組指針，它將在函數返回時保存?
主機名。size是hostname?數組的字節長度。?
函數調用成功時返回?0，失敗時返回?-1，并設置?errno。

域名服務（DNS）?
　　如果你不知道?DNS?的意思，那么我告訴你，它代表域名服務(Domain Name Service)。它主要的功能是：你給它一個容易記憶的某站點的地址，它給你?IP?地址(然后你就可以使用?bind(), connect(), sendto()?或者其它 函數)?。當一個人輸入：?
　　?$ telnet whitehouse.gov?
telnet?能知道它將連接?(connect())?到?"198.137.240.100"。?
但是這是如何工作的呢??你可以調用函數?gethostbyname()：?
#include <netdb.h>?
　　struct hostent *gethostbyname(const char *name);?
很明白的是，它返回一個指向?struct hostent?的指針。這個數據結構 是這樣的：?
　　?struct hostent {?
　　?char *h_name;?
　　?char **h_aliases;?
　　?int h_addrtype;?
　　?int h_length;?
　　?char **h_addr_list;?
　　?};?
　　?#define h_addr h_addr_list[0]?
這里是這個數據結構的詳細資料：?
struct hostent:?
　　h_name?– 地址的正式名稱。?
　　h_aliases?– 空字節-地址的預備名稱的指針。?
　　h_addrtype?–地址類型;?通常是AF_INET。?
　　h_length?– 地址的比特長度。?
　　h_addr_list?– 零字節-主機網絡地址指針。網絡字節順序。?
　　h_addr - h_addr_list中的第一地址。?
gethostbyname()?成功時返回一個指向結構體?hostent?的指針，或者 是個空?(NULL)?指針。(但是和以前不同，不設置errno，h_errno?設置錯 誤信息。請看下面的?herror()。)?
但是如何使用呢??有時候（我們可以從電腦手冊中發現），向讀者灌輸 信息是不夠的。這個函數可不象它看上去那么難用。?
這里是個例子：?
#include <stdio.h>?
　　#include <stdlib.h>?
　　#include <errno.h>?
　　#include <netdb.h>?
　　#include <sys/types.h>?
　　#include <netinet/in.h>?
int main(int argc, char *argv[])?
　　?{?
　　?struct hostent *h;?
if (argc != 2) { /*?檢查命令行?*/?
　　?fprintf(stderr,"usage: getip addressn");?
　　?exit(1);?
　　?}?
if ((h=gethostbyname(argv[1])) == NULL) { /*?取得地址信息?*/?
　　?herror("gethostbyname");?
　　?exit(1);?
　　?}?
printf("Host name : %sn", h->h_name);?
　　printf("IP Address : %sn",inet_ntoa(*((struct in_addr *)h->h_addr)));?
return 0;?
　　?}?
在使用?gethostbyname()?的時候，你不能用?perror()?打印錯誤信息?(因為?errno?沒有使用)，你應該調用?herror()。?
相當簡單，你只是傳遞一個保存機器名的字符串(例如?"whitehouse.gov")?給?gethostbyname()，然后從返回的數據結構?struct hostent?中獲取信息。?
唯一也許讓人不解的是輸出?IP?地址信息。h->h_addr?是一個?char *， 但是?inet_ntoa()?需要的是?struct in_addr。因此，我轉換?h->h_addr?成?struct in_addr *，然后得到數據。

客戶-服務器背景知識?
　　這里是個客戶--服務器的世界。在網絡上的所有東西都是在處理客戶進程和服務器進程的交談。舉個telnet?的例子。當你用?telnet (客戶)通過23?號端口登陸到主機，主機上運行的一個程序(一般叫?telnetd，服務器)激活。它處理這個連接，顯示登陸界面，等等。

圖2：客戶機和服務器的關系?
圖?2?說明了客戶和服務器之間的信息交換。?
注意，客戶--服務器之間可以使用SOCK_STREAM、SOCK_DGRAM?或者其它(只要它們采用相同的)。一些很好的客戶--服務器的例子有?telnet/telnetd、?ftp/ftpd?和?bootp/bootpd。每次你使用?ftp?的時候，在遠 端都有一個?ftpd?為你服務。?
一般，在服務端只有一個服務器，它采用?fork()?來處理多個客戶的連 接。基本的程序是：服務器等待一個連接，接受?(accept())?連接，然后?fork()?一個子進程處理它。這是下一章我們的例子中會講到的。

簡單的服務器?
　　這個服務器所做的全部工作是在流式連接上發送字符串?"Hello, World!n"。你要測試這個程序的話，可以在一臺機器上運行該程序，然后 在另外一機器上登陸：?
　　?$ telnet remotehostname 3490?
remotehostname?是該程序運行的機器的名字。?
服務器代碼：?
#include <stdio.h>?
　　#include <stdlib.h>?
　　#include <errno.h>?
　　#include <string.h>?
　　#include <sys/types.h>?
　　#include <netinet/in.h>?
　　#include <sys/socket.h>?
　　#include <sys/wait.h>?
#define MYPORT 3490 /*定義用戶連接端口*/?
#define BACKLOG 10 /*多少等待連接控制*/?
main()?
　　?{?
　　?int sockfd, new_fd; /* listen on sock_fd, new connection on new_fd?
*/?
　　?struct sockaddr_in my_addr; /* my address information */?
　　?struct sockaddr_in their_addr; /* connector's address information */?
　　?int sin_size;?
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {?
　　?perror("socket");?
　　?exit(1);?
　　?}?

my_addr.sin_family = AF_INET; /* host byte order */?
　　?my_addr.sin_port = htons(MYPORT); /* short, network byte order */?
　　?my_addr.sin_addr.s_addr = INADDR_ANY; /* auto-fill with my IP */?
　　?bzero(&(my_addr.sin_zero),; /* zero the rest of the struct */?

if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct?
sockaddr))== -1) {?
　　?perror("bind");?
　　?exit(1);?
　　?}?
if (listen(sockfd, BACKLOG) == -1) {?
　　?perror("listen");?
　　?exit(1);?
　　?}?

while(1) { /* main accept() loop */?
　　?sin_size = sizeof(struct sockaddr_in);?
　　?if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr,?
　　?&sin_size)) == -1) {?
　　?perror("accept");?
　　?continue;?
　　?}?
　　?printf("server: got connection from %sn",?
　　?inet_ntoa(their_addr.sin_addr));?
　　?if (!fork()) { /* this is the child process */?
　　?if (send(new_fd, "Hello, world!n", 14, 0) == -1)?
　　?perror("send");?
　　?close(new_fd);?
　　?exit(0);?
　　?}?
　　?close(new_fd); /* parent doesn't need this */?
while(waitpid(-1,NULL,WNOHANG) > 0); /* clean up child processes */?
　　?}?
　　?}?
如果你很挑剔的話，一定不滿意我所有的代碼都在一個很大的main()?函數中。如果你不喜歡，可以劃分得更細點。?
你也可以用我們下一章中的程序得到服務器端發送的字符串。

簡單的客戶程序?
　　這個程序比服務器還簡單。這個程序的所有工作是通過?3490?端口連接到命令行中指定的主機，然后得到服務器發送的字符串。?
客戶代碼:?
#include <stdio.h>?
　　#include <stdlib.h>?
　　#include <errno.h>?
　　#include <string.h>?
　　#include <sys/types.h>?
　　#include <netinet/in.h>?
　　#include <sys/socket.h>?
　　#include <sys/wait.h>?
#define PORT 3490 /*?客戶機連接遠程主機的端口?*/?
#define MAXDATASIZE 100 /*?每次可以接收的最大字節?*/?
int main(int argc, char *argv[])?
　　?{?
　　?int sockfd, numbytes;?
　　?char buf[MAXDATASIZE];?
　　?struct hostent *he;?
　　?struct sockaddr_in their_addr; /* connector's address information */?
if (argc != 2) {?
　　?fprintf(stderr,"usage: client hostnamen");?
　　?exit(1);?
　　?}?
if ((he=gethostbyname(argv[1])) == NULL) { /* get the host info */?
　　?herror("gethostbyname");?
　　?exit(1);?
　　?}?

if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {?
　　?perror("socket");?
　　?exit(1);?
　　?}?

their_addr.sin_family = AF_INET; /* host byte order */?
　　their_addr.sin_port = htons(PORT); /* short, network byte order */?
　　their_addr.sin_addr = *((struct in_addr *)he->h_addr);?
　　bzero(&(their_addr.sin_zero),; /* zero the rest of the struct */?
if (connect(sockfd, (struct sockaddr *)&their_addr,sizeof(struct?
sockaddr)) == -1) {?
　　?perror("connect");?
　　?exit(1);?
　　?}?
if ((numbytes=recv(sockfd, buf, MAXDATASIZE, 0)) == -1) {?
　　?perror("recv");?
　　?exit(1);?
　　?}?
buf[numbytes] = '';?
printf("Received: %s",buf);?
close(sockfd);?
return 0;?
　　?}?
注意，如果你在運行服務器之前運行客戶程序，connect()?將返回?"Connection refused"?信息，這非常有用。

數據包?Sockets?
　　我不想講更多了，所以我給出代碼?talker.c?和?listener.c。?
listener?在機器上等待在端口?4590?來的數據包。talker?發送數據包到 一定的機器，它包含用戶在命令行輸入的內容。?
這里就是?listener.c：?
#include <stdio.h>?
　　#include <stdlib.h>?
　　#include <errno.h>?
　　#include <string.h>?
　　#include <sys/types.h>?
　　#include <netinet/in.h>?
　　#include <sys/socket.h>?
　　#include <sys/wait.h>?
#define MYPORT 4950 /* the port users will be sending to */?
#define MAXBUFLEN 100?
main()?
　　?{?
　　?int sockfd;?
　　?struct sockaddr_in my_addr; /* my address information */?
　　?struct sockaddr_in their_addr; /* connector's address information */?
　　?int addr_len, numbytes;?
　　?char buf[MAXBUFLEN];?
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {?
　　?perror("socket");?
　　?exit(1);?
　　?}?
my_addr.sin_family = AF_INET; /* host byte order */?
　　?my_addr.sin_port = htons(MYPORT); /* short, network byte order */?
　　?my_addr.sin_addr.s_addr = INADDR_ANY; /* auto-fill with my IP */?
　　?bzero(&(my_addr.sin_zero),; /* zero the rest of the struct */?
if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr))?

　　?== -1) {?
　　?perror("bind");?
　　?exit(1);?
　　?}?
addr_len = sizeof(struct sockaddr);?
　　?if ((numbytes=recvfrom(sockfd, buf, MAXBUFLEN, 0,?
　　?(struct sockaddr *)&their_addr, &addr_len)) == -1) {?
　　?perror("recvfrom");?
　　?exit(1);?
　　?}?
printf("got packet from %sn",inet_ntoa(their_addr.sin_addr));?
　　?printf("packet is %d bytes longn",numbytes);?
　　?buf[numbytes] = '';?
　　?printf("packet contains "%s"n",buf);?
close(sockfd);?
　　?}?
注意在我們的調用?socket()，我們最后使用了?SOCK_DGRAM。同時， 沒有必要去使用?listen()?或者?accept()。我們在使用無連接的數據報套接 字！?
下面是?talker.c：?
#include <stdio.h>?
　　#include <stdlib.h>?
　　#include <errno.h>?
　　#include <string.h>?
　　#include <sys/types.h>?
　　#include <netinet/in.h>?
　　#include <sys/socket.h>?
　　#include <sys/wait.h>?
#define MYPORT 4950 /* the port users will be sending to */?
int main(int argc, char *argv[])?
　　?{?
　　?int sockfd;?
　　?struct sockaddr_in their_addr; /* connector's address information */?
　　?struct hostent *he;?
　　?int numbytes;?

if (argc != 3) {?
　　?fprintf(stderr,"usage: talker hostname messagen");?
　　?exit(1);?
　　?}?

if ((he=gethostbyname(argv[1])) == NULL) { /* get the host info */?
　　?herror("gethostbyname");?
　　?exit(1);?
　　?}?

if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {?
　　?perror("socket");?
　　?exit(1);?
　　?}?

their_addr.sin_family = AF_INET; /* host byte order */?
　　?their_addr.sin_port = htons(MYPORT); /* short, network byte order?
*/?
　　?their_addr.sin_addr = *((struct in_addr *)he->h_addr);?
　　?bzero(&(their_addr.sin_zero),; /* zero the rest of the struct */?
if ((numbytes=sendto(sockfd, argv[2], strlen(argv[2]), 0,?
　　?(struct sockaddr *)&their_addr, sizeof(struct sockaddr))) == -1) {?
　　?perror("sendto");?
　　?exit(1);?
　　?}?
printf("sent %d bytes to?
%sn",numbytes,inet_ntoa(their_addr.sin_addr));?
close(sockfd);?
return 0;?
　　?}?
這就是所有的了。在一臺機器上運行?listener，然后在另外一臺機器上 運行?talker。觀察它們的通訊！?
除了一些我在上面提到的數據套接字連接的小細節外，對于數據套接 字，我還得說一些，當一個講話者呼叫connect()函數時并指定接受者的地址時，從這點可以看出，講話者只能向connect()函數指定的地址發送和接受信息。因此，你不需要使用sendto()和recvfrom()，你完全可以用send()?和recv()代替。

阻塞?
　　阻塞，你也許早就聽說了。"阻塞"是?"sleep"?的科技行話。你可能注意到前面運行的?listener?程序，它在那里不停地運行，等待數據包的到來。實際在運行的是它調用?recvfrom()，然后沒有數據，因此?recvfrom()說"?阻塞?(block)"，直到數據的到來。?
很多函數都利用阻塞。accept()?阻塞，所有的?recv*()?函數阻塞。它 們之所以能這樣做是因為它們被允許這樣做。當你第一次調用?socket()?建立套接字描述符的時候，內核就將它設置為阻塞。如果你不想套接字阻塞，你就要調用函數?fcntl()：?
#include <unistd.h>?
　　#include <fontl.h>?
　　?.?
　　?.?
　　?sockfd = socket(AF_INET, SOCK_STREAM, 0);?
　　?fcntl(sockfd, F_SETFL, O_NONBLOCK);?
　　?.?
　　?.?
　　通過設置套接字為非阻塞，你能夠有效地"詢問"套接字以獲得信息。如果你嘗試著從一個非阻塞的套接字讀信息并且沒有任何數據，它不允許阻 塞--它將返回?-1?并將?errno?設置為?EWOULDBLOCK。?
但是一般說來，這種詢問不是個好主意。如果你讓你的程序在忙等狀 態查詢套接字的數據，你將浪費大量的?CPU?時間。更好的解決之道是用下一章講的?select()?去查詢是否有數據要讀進來。

select()--多路同步?I/O?
　　雖然這個函數有點奇怪，但是它很有用。假設這樣的情況：你是個服務器，你一邊在不停地從連接上讀數據，一邊在偵聽連接上的信息。 沒問題，你可能會說，不就是一個?accept()?和兩個?recv()?嗎??這么 容易嗎，朋友??如果你在調用?accept()?的時候阻塞呢??你怎么能夠同時接受?recv()?數據??“用非阻塞的套接字啊！” 不行！你不想耗盡所有的?CPU?吧??那么，該如何是好??
select()?讓你可以同時監視多個套接字。如果你想知道的話，那么它就 會告訴你哪個套接字準備讀，哪個又準備寫，哪個套接字又發生了例外?(exception)。?
閑話少說，下面是?select()：?
#include <sys/time.h>?
　　#include <sys/types.h>?
　　#include <unistd.h>?
int select(int numfds, fd_set *readfds, fd_set *writefds,fd_set?
*exceptfds, struct timeval *timeout);?
這個函數監視一系列文件描述符，特別是?readfds、writefds?和?exceptfds。如果你想知道你是否能夠從標準輸入和套接字描述符?sockfd?讀入數據，你只要將文件描述符?0?和?sockfd?加入到集合?readfds?中。參 數numfds?應該等于最高的文件描述符的值加1。在這個例子中，你應該 設置該值為?sockfd+1。因為它一定大于標準輸入的文件描述符?(0)。 當函數?select()?返回的時候，readfds?的值修改為反映你選擇的哪個文件描述符可以讀。你可以用下面講到的宏?FD_ISSET()?來測試。 在我們繼續下去之前，讓我來講講如何對這些集合進行操作。每個集合類型都是?fd_set。下面有一些宏來對這個類型進行操作：?
FD_ZERO(fd_set *set)?– 清除一個文件描述符集合?
　　FD_SET(int fd, fd_set *set) -?添加fd到集合?
　　FD_CLR(int fd, fd_set *set)?– 從集合中移去fd?
　　FD_ISSET(int fd, fd_set *set)?– 測試fd是否在集合中?
最后，是有點古怪的數據結構?struct timeval。有時你可不想永遠等待別人發送數據過來。也許什么事情都沒有發生的時候你也想每隔96秒在終 端上打印字符串?"Still Going..."。這個數據結構允許你設定一個時間，如果時間到了，而?select()?還沒有找到一個準備好的文件描述符，它將返回讓你繼續處理。?
數據結構?struct timeval?是這樣的：?
struct timeval {?
　　?int tv_sec; /* seconds */?
　　?int tv_usec; /* microseconds */?
　　?};?
只要將?tv_sec?設置為你要等待的秒數，將?tv_usec?設置為你要等待的微秒數就可以了。是的，是微秒而不是毫秒。1,000微秒等于1毫秒，1,000?毫秒等于1秒。也就是說，1秒等于1,000,000微秒。為什么用符號?"usec"呢??字母?"u"?很象希臘字母?Mu，而?Mu?表示?"微"?的意思。當然，函數 返回的時候?timeout?可能是剩余的時間，之所以是可能，是因為它依賴于 你的?Unix?操作系統。?
哈！我們現在有一個微秒級的定時器！別計算了，標準的?Unix?系統 的時間片是100毫秒，所以無論你如何設置你的數據結構?struct timeval，你都要等待那么長的時間。?
還有一些有趣的事情：如果你設置數據結構?struct timeval?中的數據為?0，select()?將立即超時，這樣就可以有效地輪詢集合中的所有的文件描述符。如果你將參數?timeout?賦值為?NULL，那么將永遠不會發生超時，即一直等到第一個文件描述符就緒。最后，如果你不是很關心等待多長時間，那么就把它賦為?NULL?吧。?
下面的代碼演示了在標準輸入上等待?2.5?秒：?
#include <sys/time.h>?
　　#include <sys/types.h>?
　　#include <unistd.h>?
#define STDIN 0 /* file descriptor for standard input */?
main()?
　　?{?
　　struct timeval tv;?
　　fd_set readfds;?
tv.tv_sec = 2;?
　　tv.tv_usec = 500000;?
FD_ZERO(&readfds);?
　　FD_SET(STDIN, &readfds);?
/* don't care about writefds and exceptfds: */?
　　select(STDIN+1, &readfds, NULL, NULL, &tv);?
if (FD_ISSET(STDIN, &readfds))?
　　printf("A key was pressed!n");?
　　else?
　　printf("Timed out.n");?
　　}?
如果你是在一個?line buffered?終端上，那么你敲的鍵應該是回車?(RETURN)，否則無論如何它都會超時。?
現在，你可能回認為這就是在數據報套接字上等待數據的方式--你是對 的：它可能是。有些?Unix?系統可以按這種方式，而另外一些則不能。你 在嘗試以前可能要先看看本系統的?man page?了。?
最后一件關于?select()?的事情：如果你有一個正在偵聽?(listen())?的套 接字，你可以通過將該套接字的文件描述符加入到?readfds?集合中來看是否有新的連接。?
這就是我關于函數select()?要講的所有的東西。