Select的函數格式(我所說的是Unix系統下的伯克利socket編程，和windows下的有區別，一會兒說明)：
int select(int maxfdp,fd_set *readfds,fd_set *writefds,fd_set *errorfds,struct timeval *timeout);
先說明兩個結構體：
第一，struct fd_set可以理解為一個集合，這個集合中存放的是文件描述符(file descriptor)，即文件句柄，這可以是我們所說的普通意義的文件，當然Unix下任何設備、管道、FIFO等都是文件形式，全部包括在內，所以毫無疑問一個socket就是一個文件，socket句柄就是一個文件描述符。fd_set集合可以通過一些宏由人為來操作，比如清空集合 FD_ZERO(fd_set *)，將一個給定的文件描述符加入集合之中FD_SET(int ,fd_set *)，將一個給定的文件描述符從集合中刪除FD_CLR(int ,fd_set*)，檢查集合中指定的文件描述符是否可以讀寫FD_ISSET(int ,fd_set* )。一會兒舉例說明。
第二，struct timeval是一個大家常用的結構，用來代表時間值，有兩個成員，一個是秒數，另一個是毫秒數。
具體解釋select的參數：
int maxfdp是一個整數值，是指集合中所有文件描述符的范圍，即所有文件描述符的最大值加1，不能錯！在Windows中這個參數的值無所謂，可以設置不正確。
fd_set *readfds是指向fd_set結構的指針，這個集合中應該包括文件描述符，我們是要監視這些文件描述符的讀變化的，即我們關心是否可以從這些文件中讀取數據了，如果這個集合中有一個文件可讀，select就會返回一個大于0的值，表示有文件可讀，如果沒有可讀的文件，則根據timeout參數再判斷是否超時，若超出timeout的時間，select返回0，若發生錯誤返回負值。可以傳入NULL值，表示不關心任何文件的讀變化。
fd_set *writefds是指向fd_set結構的指針，這個集合中應該包括文件描述符，我們是要監視這些文件描述符的寫變化的，即我們關心是否可以向這些文件中寫入數據了，如果這個集合中有一個文件可寫，select就會返回一個大于0的值，表示有文件可寫，如果沒有可寫的文件，則根據timeout參數再判斷是否超時，若超出timeout的時間，select返回0，若發生錯誤返回負值。可以傳入NULL值，表示不關心任何文件的寫變化。
fd_set *errorfds同上面兩個參數的意圖，用來監視文件錯誤異常。
struct timeval* timeout是select的超時時間，這個參數至關重要，它可以 使select處于三種狀態， 第一， 若將NULL以形參傳入，即不傳入時間結構，就是將select置于阻塞狀態，一定等到監視文件描述符集合中某個文件描述符發生變化為止； 第二， 若將時間值設為0秒0毫秒，就變成一個純粹的非阻塞函數，不管文件描述符是否有變化，都立刻返回繼續執行，文件無變化返回0，有變化返回一個正值； 第三， timeout的值大于0，這就是等待的超時時間，即 select在timeout時間內阻塞，超時時間之內有事件到來就返回了，否則在超時后不管怎樣一定返回，返回值同上述。
返回值：
負值：select錯誤 正值：某些文件可讀寫或出錯 0：等待超時，沒有可讀寫或錯誤的文件
在有了select后可以寫出像樣的網絡程序來！舉個簡單的例子，就是從網絡上接受數據寫入一個文件中。
例子：
main()
{
int sock;
FILE *fp;
struct fd_set fds;
struct timeval timeout={3,0}; //select等待3秒，3秒輪詢，要非阻塞就置0
char buffer[256]={0}; //256字節的接收緩沖區
/* 假定已經建立UDP連接，具體過程不寫，簡單，當然TCP也同理，主機ip和port都已經給定，要寫的文件已經打開
sock=socket(...);
bind(...);
fp=fopen(...); */
while(1)
{
FD_ZERO(&fds); //每次循環都要清空集合，否則不能檢測描述符變化
FD_SET(sock,&fds); //添加描述符
FD_SET(fp,&fds); //同上
maxfdp=sock>fp?sock+1:fp+1; //描述符最大值加1
switch(select(maxfdp,&fds,&fds,NULL,&timeout)) //select使用
{
case -1: exit(-1);break; //select錯誤，退出程序
case 0:break; //再次輪詢
default:
if(FD_ISSET(sock,&fds)) //測試sock是否可讀，即是否網絡上有數據
{
recvfrom(sock,buffer,256,.....);//接受網絡數據
if(FD_ISSET(fp,&fds)) //測試文件是否可寫
fwrite(fp,buffer...);//寫入文件
buffer清空;
}// end if break;
}// end switch
}//end while
}//end main
----------------------------------------------------------
Linux select()詳解
Linux select()詳解 ? ??? select系統調用是用來讓我們的程序監視多個文件句柄(file descriptor)的狀態變化的。程序會停在select這里等待，直到被監視的文件句柄有某一個或多個發生了狀態改變。
??? 文件在句柄在Linux里很多，如果你man某個函數，在函數返回值部分說到成功后有一個文件句柄被創建的都是的，如man socket可以看到“On success, a file descriptor for the new socket is returned.”而man 2 open可以看到“open() and creat() return the new file descriptor”，其實文件句柄就是一個整數，看socket函數的聲明就明白了：
??? int socket(int domain, int type, int protocol);
當然，我們最熟悉的句柄是0、1、2三個，0是標準輸入，1是標準輸出，2是標準錯誤輸出。0、1、2是整數表示的，對應的FILE *結構的表示就是stdin、stdout、stderr，0就是stdin，1就是stdout，2就是stderr。
比如下面這兩段代碼都是從標準輸入讀入9個字節字符：
#include <stdio.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char ** argv)
{
??????? char buf[10] = "";
??????? read(0, buf, 9); /* 從標準輸入 0 讀入字符 */
??????? fprintf(stdout, "%s\n", buf); /* 向標準輸出 stdout 寫字符 */
??????? return 0;
}
/* **上面和下面的代碼都可以用來從標準輸入讀用戶輸入的9個字符** */
#include <stdio.h>
#include <unistd.h>
#include <string.h>
int main(int argc, char ** argv)
{
??????? char buf[10] = "";
??????? fread(buf, 9, 1, stdin); /* 從標準輸入 stdin 讀入字符 */
??????? write(1, buf, strlen(buf));
??????? return 0;
}
?? 繼續上面說的 select，就是用來監視某個或某些句柄的狀態變化的。select函數原型如下：
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
函數的最后一個參數timeout顯然是一個超時時間值，其類型是struct timeval *，即一個struct timeval結構的變量的指針，所以我們在程序里要申明一個struct timeval tv;然后把變量tv的地址&tv傳遞給select函數。struct timeval結構如下：
struct timeval {
???????????? long??? tv_sec;???????? /* seconds */
???????????? long??? tv_usec;??????? /* microseconds */
???????? };
?? 第2、3、4三個參數是一樣的類型： fd_set *，即我們在程序里要申明幾個fd_set類型的變量，比如rdfds, wtfds, exfds，然后把這個變量的地址&rdfds, &wtfds, &exfds 傳遞給select函數。這三個參數都是一個句柄的集合，第一個rdfds是用來保存這樣的句柄的：當句柄的狀態變成可讀的時系統就會告訴select函數返回，同理第二個wtfds是指有句柄狀態變成可寫的時系統就會告訴select函數返回，同理第三個參數exfds是特殊情況，即句柄上有特殊情況發生時系統會告訴select函數返回。特殊情況比如對方通過一個socket句柄發來了緊急數據。如果我們程序里只想檢測某個socket是否有數據可讀，我們可以這樣：
fd_set rdfds; /* 先申明一個 fd_set 集合來保存我們要檢測的 socket句柄 */
struct timeval tv; /* 申明一個時間變量來保存時間 */
int ret; /* 保存返回值 */
FD_ZERO(&rdfds); /* 用select函數之前先把集合清零 */
FD_SET(socket, &rdfds); /* 把要檢測的句柄socket加入到集合里 */
tv.tv_sec = 1;
tv.tv_usec = 500; /* 設置select等待的最大時間為1秒加500毫秒 */
ret = select(socket + 1, &rdfds, NULL, NULL, &tv); /* 檢測我們上面設置到集合rdfds里的句柄是否有可讀信息 */
if(ret < 0) perror("select");/* 這說明select函數出錯 */
else if(ret == 0) printf("超時\n"); /* 說明在我們設定的時間值1秒加500毫秒的時間內，socket的狀態沒有發生變化 */
else { /* 說明等待時間還未到1秒加500毫秒，socket的狀態發生了變化 */
??? printf("ret=%d\n", ret); /* ret這個返回值記錄了發生狀態變化的句柄的數目，由于我們只監視了socket這一個句柄，所以這里一定ret=1，如果同時有多個句柄發生變化返回的就是句柄的總和了 */
??? /* 這里我們就應該從socket這個句柄里讀取數據了，因為select函數已經告訴我們這個句柄里有數據可讀 */
??? if(FD_ISSET(socket, &rdfds)) { /* 先判斷一下socket這外被監視的句柄是否真的變成可讀的了 */
??????? /* 讀取socket句柄里的數據 */
??????? recv(...);
??? }
}
?? 注意select函數的第一個參數，是所有加入集合的句柄值的最大那個值還要加1。比如我們創建了3個句柄：
/************關于本文檔********************************************
*filename: Linux網絡編程一步一步學-select詳解
*purpose: 詳細說明select的用法
*wrote by: zhoulifa( zhoulifa@163.com) 周立發( http://zhoulifa.bokee.com)
Linux愛好者 Linux知識傳播者 SOHO族 開發者 最擅長C語言
*date time:2007-02-03 19:40
*Note: 任何人可以任意復制代碼并運用這些文檔，當然包括你的商業用途
* 但請遵循GPL
*Thanks to:Google
*Hope:希望越來越多的人貢獻自己的力量，為科學技術發展出力
* 科技站在巨人的肩膀上進步更快！感謝有開源前輩的貢獻！
*********************************************************************/
int sa, sb, sc;
sa = socket(...); /* 分別創建3個句柄并連接到服務器上 */
connect(sa,...);
sb = socket(...);
connect(sb,...);
sc = socket(...);
connect(sc,...);
FD_SET(sa, &rdfds);/* 分別把3個句柄加入讀監視集合里去 */
FD_SET(sb, &rdfds);
FD_SET(sc, &rdfds);
?? 在使用select函數之前，一定要找到3個句柄中的最大值是哪個，我們一般定義一個變量來保存最大值，取得最大socket值如下：
int maxfd = 0;
if(sa > maxfd) maxfd = sa;
if(sb > maxfd) maxfd = sb;
if(sc > maxfd) maxfd = sc;
?? 然后調用select函數：
ret = select(maxfd + 1, &rdfds, NULL, NULL, &tv); /* 注意是最大值還要加1 */
?? 同樣的道理，如果我們要檢測用戶是否按了鍵盤進行輸入，我們就應該把標準輸入0這個句柄放到select里來檢測，如下：
FD_ZERO(&rdfds);
FD_SET(0, &rdfds);
tv.tv_sec = 1;
tv.tv_usec = 0;
ret = select(1, &rdfds, NULL, NULL, &tv); /* 注意是最大值還要加1 */
if(ret < 0) perror("select");/* 出錯 */
else if(ret == 0) printf("超時\n"); /* 在我們設定的時間tv內，用戶沒有按鍵盤 */
else { /* 用戶有按鍵盤，要讀取用戶的輸入 */
??? scanf("%s", buf);
}----------------------------------------------------------
Linux select學習筆記
select系統調用是用來讓我們的程序監視多個文件描述符(file descrīptor)的狀態變化的。程序會停在select這里等待，直到被監視的文件描述符有某一個或多個發生了狀態改變。select()的機制中提供一fd_set的數據結構，實際上是一long類型的數組， 每一個數組元素都能與一打開的文件描述符（不管是Socket描述符,還是其他 文件或命名管道或設備描述符）建立聯系，建立聯系的工作由程序員完成， 當調用select()時，由內核根據IO狀態修改fd_set的內容，由此來通知執 行了select()的進程哪一Socket或文件可讀，
select函數原型如下：
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
函數的最后一個參數timeout顯然是一個超時時間值，其類型是struct timeval *，即一個struct timeval結構的變量的指針，所以我們在程序里要申明一個struct timeval tv;然后把變量tv的地址&tv傳遞給select函數。struct timeval結構如下：
struct timeval {
long? ?tv_sec;??? ?/* seconds */
long? ?tv_usec;??? /* microseconds */
};
第2、3、4三個參數的類型是一樣的： fd_set *，即我們在程序里要申明幾個fd_set類型的變量，比如定義了rfds, wfds, efds。
另外關于fd_set類型的變量，還有一組標準的宏定義來處理此類變量：
FD_ZERO(fd_set *fdset)：清空fdset與所有文件描述符的聯系。
FD_SET(int fd, fd_set *fdset)：建立文件描述符fd與fdset的聯系。
FD_CLR(int fd, fd_set *fdset)：清除文件描述符fd與fdset的聯系。
FD_ISSET(int fd, fd_set *fdset)：檢查fd_set聯系的文件描述符fd是否可讀寫，>0表示可讀寫。
（關于fd_set及相關宏的定義見/usr/include/sys/types.h）定義的這三個參數都是描述符的集合，第一個rfds是用來保存這樣的描述符的：當描述符的狀態變成可讀的時系統就會告訴select函數返回，第二個wfds是指有描述符狀態變成可寫的時系統就會告訴select函數返回，第三個參數efds是特殊情況，即描述符上有特殊情況發生時系統會告訴select函數返回。下面以一個輸入為例來說明：
int fd1, fd2;???????? /* 在定義兩個描述符*/
fd1 = socket(...); ???/* 創建socket連接*/
fd2 = open(“/dev/tyS0”,O_RDWR); /* 打開一個串口*/
FD_ZERO(&rfds); ??????/* 用select函數之前先把集合清零 */
FD_SET(fd1, &rfds);?? /* 分別把2個描述符加入讀監視集合里去 */
FD_SET(fd2, &rfds);
int maxfd = 0;
maxfd = (fd1>fd2)?(fd1+1):(fd2+1); ??????????/* 注意是最大值還要加1 */
ret = select(maxfd, &rfds, NULL, NULL, &tv); /*然后調用select函數*/
這樣就可以使用一個開關語句（switch語句）來判斷到底是哪一個輸入源在輸入數據。具體判斷如下：
switch（ret）{
case -1：perror("select");/* 這說明select函數出錯 */
case 0：printf("超時\n"); /* 說明在設定的時間內，socket的狀態沒有發生變化 */
default：
if（FD_ISSET(fd1, &rfds)） 處理函數1（）；/*socket有數據來*/
if（FD_ISSET(fd2, &rfds)） 處理函數2（）；/*ttyS0有數據來*/
}
?
以下來自網絡搜索：
Linux下select調用的過程:
1.用戶層應用程序調用select(),底層調用poll())
2.核心層調用sys_select() ------> do_select()
最終調用文件描述符fd對應的struct file類型變量的struct file_operations *f_op的poll函數。
poll指向的函數返回當前可否讀寫的信息。
1)如果當前可讀寫，返回讀寫信息。
2)如果當前不可讀寫，則阻塞進程，并等待驅動程序喚醒，重新調用poll函數，或超時返回。
3.驅動需要實現poll函數。
當驅動發現有數據可以讀寫時，通知核心層，核心層重新調用poll指向的函數查詢信息。
poll_wait(filp,&wait_q,wait) // 此處將當前進程加入到等待隊列中，但并不阻塞
在中斷中使用wake_up_interruptible(&wait_q)喚醒等待隊列
----------------------------------------------------------
Socket編程中select()的妙用
?
用過 WinSock API 網友們知道：WinSock 編程中有一很方便的地方便是其
息驅動機制，不管是底層 API 的 WSAAsyncSelect() 還是 MFC 的異步Socket類：
CAsyncSocket，都提供了諸如 FD_ACCEPT、FD_READ、FD_CLOSE 之類的消息
供編程人員捕捉并處理。FD_ACCEPT 通知進程有客戶方Socket請求連接，
FD_READ通知進程本地Socket有東東可讀，FD_CLOSE通知進程對方Socket已
關閉。那么，BSD Socket 是不是真的相形見拙呢？
?
非也！ 'cause cpu love unix so.
?
BSD UNIX中有一系統調用芳名select()完全可以提供類似的消息驅動機制。
cpu鄭重宣布：WinSock的WSAAsyncSeclet()不過是此select()的fork版！
?
bill也是fork出來的嘛，xixi.
?
select()的機制中提供一fd_set的數據結構，實際上是一long類型的數組，
每一個數組元素都能與一打開的文件句柄（不管是Socket句柄,還是其他
文件或命名管道或設備句柄）建立聯系，建立聯系的工作由程序員完成，
當調用select()時，由內核根據IO狀態修改fd_set的內容，由此來通知執
行了select()的進程哪一Socket或文件可讀，下面具體解釋：
?
#include? <sys/types.h>
#include? <sys/times.h>
#include? <sys/select.h>
?
int select(nfds, readfds, writefds, exceptfds, timeout)
int nfds;
fd_set *readfds, *writefds, *exceptfds;
struct timeval *timeout;
?
ndfs：select監視的文件句柄數，視進程中打開的文件數而定,一般設為呢要監視各文件
????? 中的最大文件號加一。
readfds：select監視的可讀文件句柄集合。
writefds: select監視的可寫文件句柄集合。
exceptfds：select監視的異常文件句柄集合。
timeout：本次select()的超時結束時間。（見/usr/sys/select.h，
??????? 可精確至百萬分之一秒！）
?
當readfds或writefds中映象的文件可讀或可寫或超時，本次select()
就結束返回。程序員利用一組系統提供的宏在select()結束時便可判
斷哪一文件可讀或可寫。對Socket編程特別有用的就是readfds。
幾只相關的宏解釋如下：
?
FD_ZERO(fd_set *fdset)：清空fdset與所有文件句柄的聯系。
FD_SET(int fd, fd_set *fdset)：建立文件句柄fd與fdset的聯系。
FD_CLR(int fd, fd_set *fdset)：清除文件句柄fd與fdset的聯系。
FD_ISSET(int fd, fdset *fdset)：檢查fdset聯系的文件句柄fd是否
??????????????????????????????? 可讀寫，>0表示可讀寫。
（關于fd_set及相關宏的定義見/usr/include/sys/types.h）
?
這樣，你的socket只需在有東東讀的時候才讀入，大致如下：
?
...
int???? sockfd;
fd_set? fdR;
struct? timeval timeout = ..;
...
for(;;) {
??????? FD_ZERO(&fdR);
??????? FD_SET(sockfd, &fdR);
??????? switch (select(sockfd + 1, &fdR, NULL, &timeout)) {
??????????????? case -1:
??????????????????????? error handled by u;
??????????????? case 0:
??????????????????????? timeout hanled by u;
??????????????? default:
??????????????????????? if (FD_ISSET(sockfd)) {
??????????????????????????????? now u read or recv something;
??????????????????????????????? /* if sockfd is father and?
??????????????????????????????? server socket, u can now
??????????????????????????????? accept() */
??????????????????????? }
??????? }
}
?
所以一個FD_ISSET(sockfd)就相當通知了sockfd可讀。
至于struct timeval在此的功能，請man select。不同的timeval設置
使使select()表現出超時結束、無超時阻塞和輪詢三種特性。由于
timeval可精確至百萬分之一秒，所以Windows的SetTimer()根本不算
什么。你可以用select()做一個超級時鐘。
?
FD_ACCEPT的實現？依然如上，因為客戶方socket請求連接時，會發送
連接請求報文，此時select()當然會結束，FD_ISSET(sockfd)當然大
于零，因為有報文可讀嘛！至于這方面的應用，主要在于服務方的父
Socket，你若不喜歡主動accept()，可改為如上機制來accept()。
?
至于FD_CLOSE的實現及處理，頗費了一堆cpu處理時間，未完待續。
?
--
討論關于利用select()檢測對方Socket關閉的問題：
?
仍然是本地Socket有東東可讀，因為對方Socket關閉時，會發一個關閉連接
通知報文，會馬上被select()檢測到的。關于TCP的連接（三次握手）和關
閉（二次握手）機制，敬請參考有關TCP/IP的書籍。
?
不知是什么原因，UNIX好象沒有提供通知進程關于Socket或Pipe對方關閉的
信號，也可能是cpu所知有限。總之，當對方關閉，一執行recv()或read()，
馬上回返回-1，此時全局變量errno的值是115，相應的sys_errlist[errno]
為"Connect refused"（請參考/usr/include/sys/errno.h）。所以，在上
篇的for(;;)...select()程序塊中，當有東西可讀時，一定要檢查recv()或
read()的返回值，返回-1時要作出關斷本地Socket的處理，否則select()會
一直認為有東西讀，其結果曾幾令cpu傷心欲斷針腳。不信你可以試試：不檢
查recv()返回結果，且將收到的東東（實際沒收到）寫至標準輸出...
在有名管道的編程中也有類似問題出現。具體處理詳見拙作：發布一個有用
的Socket客戶方原碼。
?
至于主動寫Socket時對方突然關閉的處理則可以簡單地捕捉信號SIGPIPE并作
出相應關斷本地Socket等等的處理。SIGPIPE的解釋是：寫入無讀者方的管道。
在此不作贅述，請詳man signal。
?
以上是cpu在作tcp/ip數據傳輸實驗積累的經驗，若有錯漏，請狂炮擊之。
?
唉，昨天在hacker區被一幫孫子轟得差點兒沒短路。ren cpu(奔騰的心) z80
?
補充關于select在異步(非阻塞)connect中的應用,剛開始搞socket編程的時候
我一直都用阻塞式的connect,非阻塞connect的問題是由于當時搞proxy scan
而提出的呵呵
通過在網上與網友們的交流及查找相關FAQ,總算知道了怎么解決這一問題.同樣
用select可以很好地解決這一問題.大致過程是這樣的:
?
1.將打開的socket設為非阻塞的,可以用fcntl(socket, F_SETFL, O_NDELAY)完
成(有的系統用FNEDLAY也可).
?
2.發connect調用,這時返回-1,但是errno被設為EINPROGRESS,意即connect仍舊
在進行還沒有完成.
?
3.將打開的socket設進被監視的可寫(注意不是可讀)文件集合用select進行監視,
如果可寫,用
??????? getsockopt(socket, SOL_SOCKET, SO_ERROR, &error, sizeof(int));
來得到error的值,如果為零,則connect成功.
?
在許多unix版本的proxyscan程序你都可以看到類似的過程,另外在solaris精華
區->編程技巧中有一個通用的帶超時參數的connect模塊.?
?
?
?
?
端口號常識:
? ? 端口號被從1 開始分配。
? ? 通常端口號超出255 的部分被本地主機保留為私有用途。
? ? 1到255 之間的號碼被用于遠程應用程序所請求的進程和網絡服務。
? ? 每個網絡通信循環地進出主計算機的TCP 應用層。它被兩個所連接的號碼唯一地識別。這兩個號碼合起來叫做套接字.
? ?? ???組成套接字的這兩個號碼就是機器的IP 地址和TCP 軟件所使用的端口號。
套接字的三種類型
? ? 流式套接字（SOCK_STREAM），數據報套接字（SOCK_DGRAM）及原始套接字(RAW)。
??流式套接字（SOCK_STREAM）
? ? 流式的套接字可以提供可靠的、面向連接的通訊流。
? ? 如果你通過流式套接字發送了順序的數據：“1”、“２”。那么數據到達遠程時候的順序也是“１”、“２”。
? ? Telnet 應用程序、BBS服務、以及系統的遠程登陸都是通過Telnet 協議連接的。Telnet 就是一個流式連接。你是否希望你在Telnet 應用程序上輸入的字符（或漢字）在到達遠程應用程序的時候是以你輸入的順序到達的？答案應該是肯定的吧。
? ? 還有WWW 瀏覽器，它使用的HTTP 協議也是通過流式套接字來獲取網頁的。事實上，如果你Telnet 到一個Web Site 的80 端口上，然后輸入 “GET 網頁路徑名”然后按兩下回車（或者是兩下Ctrl+回車）然后你就得到了“網頁路徑名”所代表的網頁！
??數據報套接字（SOCK_DGRAM）
? ? 數據報套接字定義了一種無連接的服務，數據通過相互獨立的報文進行傳輸，是無序的，并且不保證可靠，無差錯。
? ?? ? 如果你發送了一個數據報，它可能不會到達。
? ?? ? 它可能會以不同的順序到達。
? ?? ? 如果它到達了，它包含的數據中可能存在錯誤。
? ?? ? 數據報套接字也使用IP，但是它不使用TCP，它使用使用者數據報協議UDP（User Datagram Protocol 可以參考RFC 768）
? ?為什么說它們是“無連接”的呢？因為它（UDP）不像流式套接字那樣維護一個打開的連接，你只需要把數據打成一個包，把遠程的IP 貼上去，然后把這個包發送出去。這個過程是不需要建立連接的。
? ?? ? UDP 的應用例子有： tftp, bootp 等。
? ?那么，數據包既然會丟失，怎樣能保證程序能夠正常工作呢？
? ?? ? 事實上，每個使用UDP的程序都要有自己的對數據進行確認的協議。
? ?? ?? ???比如， TFTP 協議定義了對于每一個發送出去的數據包，遠程在接受到之后都要回送一個數據包告訴本地程序：“我已經拿到了！”（一個 “ACK” 包）。如果數據包發的送者在5 秒內沒有的得到回應，它就會重新發送這個數據包直到數據包接受者回送了 “ACK” 信號。這些知識對編寫一個使用UDP 協議的程序員來說是非常必要的。
? ?無連接服務器一般都是面向事務處理的，一個請求一個應答就完成了客戶程序與服務程序之間的相互作用。
? ?面向連接服務器處理的請求往往比較復雜，不是一來一去的請求應答所能解決的，而且往往是并發服務器
? ?套接字工作過程如下:
? ?? ?? ?服務器首先啟動
? ?? ?? ?通過調用socket()建立一個套接字，
? ?? ?? ?然后調用bind()將該套接字和本地網絡地址聯系在一起，
? ?? ?? ?再調用listen()使套接字做好偵聽的準備，并規定它的請求隊列的長度,
? ?? ?? ?之后就調用accept()來接收連接。
? ?? ?? ?客戶在建立套接字
? ?? ?? ?然后就可調用connect()和服務器建立連接。
? ?? ?? ?客戶機和服務器之間就可以通過調用read()和write()來發送和接收數據。
? ?? ?? ?最后，待數據傳送結束后，雙方調用close()關閉套接字。
對流式套接字你所需要做的只是調用send() 函數來發送數據。而對于數據報套接字，你需要自己加個信息頭，然后調用sendto() 函數把數據發送出去
??原始套接字
? ???原始套接字主要用于一些協議的開發，可以進行比較底層的操作。它功能強大，但是沒有上面介紹的兩種套接字使用方便，一般的程序也涉及不到原始套接字
套接字結構
struct sockaddr
這個結構用來存儲套接字地址。
數據定義：
struct sockaddr
{
? ? unsigned short sa_family;??/* address族, AF_xxx */
? ? char sa_data[14];? ?? ?? ?? ???/* 14 bytes的協議地址 */
};
sa_family??一般來說，都是 “AF_INET”。
sa_data? ? 包含了一些遠程電腦的地址、端口和套接字的數目，它里面的數據是雜溶在一切的。
為了處理struct sockaddr， 程序員建立了另外一個相似的結構struct sockaddr_in (“in” 代表 “Internet”):
struct sockaddr_in
{
? ?short? ???int? ?? ? sin_family;? ?? ?? ???/* Internet地址族 */
? ?unsigned??short int sin_port;? ?? ? /* 端口號 */
? ?struct? ? in_addr? ?sin_addr;? ?? ?? ?/* Internet地址 */
? ?unsigned??char? ?? ?sin_zero[8];? ?/* 添0（和struct sockaddr一樣大小）*/
};
注意:
? ? 1)這個結構提供了方便的手段來訪問socket address（struct sockaddr）結構中的每一個元素。
? ? 2)sin_zero[8] 是為了是兩個結構在內存中具有相同的尺寸
? ?? ?? ?? ?? ?? ?要把sin_zero 全部設成零值（使用bzero()或memset()函數）。
? ? 3)一個指向struct sockaddr_in 的指針可以聲明指向一個sturct sockaddr 的結構。所以雖然socket() 函數需要一個structaddr * ，你也可以給他一個sockaddr_in * 。
? ? 4)在struct??sockaddr_in 中，sin_family 相當于 在struct sockaddr 中的sa_family，需要設成 “AF_INET”。
? ? 5)一定要保證sin_port 和sin_addr 必須是網絡字節順序（見下節）！
2．struct in_addr??( 因特網地址 (a structure for historical reasons) )
? ?struct in_addr
? ?{
? ?? ? unsigned long s_addr;
? ?};
? ?如果你聲明了一個 "ina" 作為一個struct sockaddr_in 的結構， 那么“ina.sin_addr.s_addr”就是4 個字節的IP 地址（按網絡字節順序排放）。
? ?需要注意的是，即使你的系統仍然使用聯合而不是結構來表示struct in_addr，你仍然可以用上面的方法得到4 個字節的IP 地址（一些 #defines 幫了你的忙）
網絡字節順序
? ?因為每一個機器內部對變量的字節存儲順序不同（有的系統是高位在前，底位在后，而有的系統是底位在前，高位在后），而網絡傳輸的數據大家是一定要統一順序的。
? ?所以對與內部字節表示順序和網絡字節順序不同的機器，就一定要對數據進行轉換（比如IP 地址的表示，端口號的表示）。
? ?但是內部字節順序和網絡字節順序相同的機器該怎么辦呢？是這樣的：它們也要調用轉換函數，但是真正轉換還是不轉換是由系統函數自己來決定的。
? ?有關的轉化函數
? ?? ?我們通常使用的有兩種數據類型：短型（兩個字節）和長型（四個字節）。
? ?? ?下面介紹的這些轉換函數對于這兩類的無符號整型變量都可以進行正確的轉換。
? ?? ?如果你想將一個短型數據從主機字節順序轉換到網絡字節順序的話，有這樣一個函數htons：
? ?? ?? ?它是以“h”開頭的（代表“主機”）；
? ?? ?? ?緊跟著它的是“to”，代表“轉換到”；
? ?? ?? ?然后是“n”代表“網絡”；
? ?? ?? ?最后是“s”，代表“短型數據”。
? ?? ?? ?H-to-n-s，就是htons() 函數（可以使用Hostto Network Short 來助記）
? ?? ?你可以使用 “n”，“h”，“to”，“s”，“l”的任意組合.當然，你要在可能的情況下進行組合。比如，系統是沒有stolh() 函數的（Short to Long Host?）。
? ?? ???下面給出套接字字節轉換程序的列表：
? ?? ?? ? htons()——“Host to Network Short” 主機字節順序轉換為網絡字節順序（對無符號短型進行操作4 bytes）
? ?? ?? ? htonl()——“Host to Network Long” 主機字節順序轉換為網絡字節順序（對無符號長型進行操作8 bytes）
? ?? ?? ? ntohs()——“Network to Host Short “ 網絡字節順序轉換為主機字節順序（對無符號短型進行操作4 bytes）
? ?? ?? ? ntohl()——“Network to Host Long “ 網絡字節順序轉換為主機字節順序（對無符號長型進行操作8 bytes）
? ???在struct sockaddr_in 中的sin_addr 和sin_port 他們的字節順序都是網絡字節順序，而sin_family 卻不是網絡字節順序的。為什么呢？
? ?? ???這個是因為sin_addr 和sin_port 是從IP 和UDP 協議層取出來的數據，而在IP 和UDP協議層，是直接和網絡相關的，所以，它們必須使用網絡字節順序。
? ?? ???然而， sin_family 域只是內核用來判斷struct sockaddr_in 是存儲的什么類型的數據，并且， sin_family 永遠也不會被發送到網絡上，所以可以使用主機字節順序來存儲
socket() 函數
? ?
? ?/**
? ?*
? ?* 取得套接字描述符！（記得我們以前說過的嗎？它其實就是一個文件描述符）
? ?*
? ?* domain? ?需要被設置為 “AF_INET”，就像上面的struct sockaddr_in。
? ?* type? ???參數告訴內核這個socket 是什么類型，“SOCK_STREAM”或是“SOCK_DGRAM”。
? ?* protocol 通常為0
? ?*
? ?* return? ?如果發生錯誤，socket()函數返回 –1 。全局變量errno 將被設置為錯誤代碼。
? ?*
? ?*/
? ?#include
? ?#include
? ?int socket（int domain , int type , int protocol）
? ?示例:
? ?if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
? ?{
? ?? ???perror("create sock");
? ?? ???return -1;
? ?}
? ?else
? ?{
? ?? ?// printf("socket created...\n");
? ?}
bind() 函數
/**
*
* 為套接字綁定一個端口號
*
* 當你需要進行端口監聽listen()操作，等待接受一個連入請求的時候，
* 一般都需要經過這一步。比如網絡泥巴(MUD)，Telnet a.b.c.d 4000
*
* 如果你只是想進行連接一臺服務器，也就是進行connect() 操作的時候，這一步并不是必須的。
*
*
* sockfd? ? 是由socket()函數返回的套接字描述符
* my_addr? ?是一個指向struct sockaddr 的指針，包含有關你的地址的信息：名稱、端口和IP 地址。
* addrlen? ?可以設置為sizeof(struct sockaddr)
*
* return? ? 調用錯誤的時候，返回 -1 作為錯誤發生的標志。errno 的值為錯誤代碼。
*
*/
#include
#include
int bind (int sockfd , struct sockaddr *my_addr , int addrlen) ;
示例:
#include
#include
#include
#define??MYPORT 4000
main()
{
??int sockfd ;
??struct sockaddr_in my_addr ;
??sockfd? ?? ?? ?? ?? ?? ?= socket(AF_INET, SOCK_STREAM, 0); /* 在你自己的程序中要進行錯誤檢查！! */
??my_addr.sin_family? ?? ?= AF_INET ;? ?? ???/* 主機字節順序 */
??my_addr.sin_port? ?? ???= htons(MYPORT);? ?/* 網絡字節順序，短整型 */
??my_addr.sin_addr.s_addr = inet_addr("166.111.69.52") ;
??bzero(&(my_addr.sin_zero), 8);? ?? ?? ?? ? /* 將整個結構剩余部分數據設為0 */
??bind (sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr));??/* 不要忘記在你自己的程序中加入判斷bind 錯誤的代碼！！ */
??注意：
? ? my_addr.sin_port? ?? ?? ?是網絡字節順序, 短整型
? ? my_addr.sin_addr.s_addr??也是網絡字節順序。
??最后，bind()可以在程序中自動獲取你自己的IP 地址和端口。
? ? my_addr.sin_port = 0 ;? ?? ?? ?? ?? ???/* 隨機選擇一個端口 */
? ? my_addr.sin_addr.s_addr = INADDR_ANY ; /* 使用自己的地址 */
? ? 如上，通過設置my_addr.sin_port 為0，bind()可以知道你要它幫你選擇合適的端口；
? ? 通過設置my_addr.sin_addr.s_addr 為INADDR_ANY，bind()知道你要它將s_addr 填充為運行這個進程的機器的IP。
? ? 這一切都可以要求bind()來自動的幫助你完成。
? ? 如果你注意到了一些細節的話，你可能會發現我并沒有將INADDR_ANY 轉換為網絡字節順序！是這樣的，INADDR_ANY的值為0，0 就是0，無論用什么順序排列位的順序，它都是不變的。
? ? 有讀者會想了，因為我用的INADDR_ANY 是一個#define，那么如果將我的程序移植到另外一個系統，假如那里的INADDR_ANY是這樣定義的：
? ?? ? #define INADDR_ANY 100，
? ?? ? 那么我的程序不是就會不運行了嗎？那么下面這段代碼就OK 了:
? ?? ? my_addr.sin_port = htons(0);? ?? ?? ?? ?? ?? ? /* 隨機選擇一個未用的端口 */
? ?? ? my_addr.sin_addr.s_addr = htonl(INADDR_ANY) ;??/* 使用自己的IP地址 */
? ? 現在我們已經是這么的嚴謹，對于任何數值的INADDR_ANY調用bind 的時候就都不會有麻煩了。
? ?另外一件必須指出的事情是：
? ?? ? 當你調用bind()的時候，不要把端口數設置的過小！小于1024 的所有端口都是保留下來作為系統使用端口的，沒有root 權利無法使用。你可以使用1024 以上的任何端口，一直到65535 ：你所可能使用的最大的端口號（當然，你還要保證你所希望使用的端口沒有被其他程序所使用）。
? ?最后注意有關bind()的是：
? ?? ? 有時候你并不一定要調用bind()來建立網絡連接。比如你只是想連接到一個遠程主機上面進行通訊，你并不在乎你究竟是用的自己機器上的哪個端口進行通訊（比如Telnet），那么你可以簡單的直接調用connect()函數，connect()將自動尋找出本地機器上的一個未使用的端口，然后調用 bind()來將其socket 綁定到那個端口上。
connect() 函數
/*
*
* sockfd? ???套接字文件描述符，由socket()函數返回的
* serv_addr??是一個存儲遠程計算機的IP 地址和端口信息的結構
* addrlen? ? 應該是sizeof(struct sockaddr)
*
* return? ???如果發生了錯誤（比如無法連接到遠程主機，或是遠程主機的指定端口無法進行連接等）它將會返回錯誤值 -1
*? ?? ?? ?? ?全局變量errno將會存儲錯誤代碼
*
*
*/
#include
#include
int connect (int sockfd, struct sockaddr *serv_addr, int addrlen);
示例:
#include
#include
#include
#define DEST_IP “166.111.69.52”
#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 ;
? ?/* 網絡字節順序，短整型 */
? ?dest_addr.sin_port = htons(DEST_PORT(;
? ?dest_addr.sin_addr.s_addr = inet_addr(DEST_IP);
? ?/* 將剩下的結構中的空間置0 */
? ?bzero(&(dest_addr.sin_zero), 8）;
? ?/* 不要忘記在你的代碼中對connect()進行錯誤檢查！！ */
? ?connect(sockfd, (struct sockaddr *)&dest_addr, sizeof(struct sockaddr));
? ?注意我們沒有調用bind()函數。基本上，我們并不在乎我們本地用什么端口來通訊，是不是？我們在乎的是我們連到哪臺主機上的哪個端口上。Linux 內核自動為我們選擇了一個沒有被使用的本地端口。
listen() 函數
/*
*
* 等待別人連接，進行系統偵聽請求
* 當有人連接你的時候，你有兩步需要做：
*? ???通過listen()函數等待連接請求
*? ???然后使用accept()函數來處理
*
* 那么我們需要指定本地端口了，因為我們是等待別人的連接。所以，在listen()函數調用之前，我們需要使用bind() 函數來指定使用本地的哪一個端口數值
* 如果你想在一個端口上接受外來的連接請求的話，那么函數的調用順序為：
*??socket();
*??bind();
*??listen();
*
* sockfd? ? 是一個套接字描述符，由socket()系統調用獲得
* backlog? ?是未經過處理的連接請求隊列可以容納的最大數目(每一個連入請求都要進入一個連入請求隊列，等待listen 的程序調用accept()函數來接受這個連接。當系統還沒有調用accept()函數的時候，如果有很多連接，那么本地能夠等待的最大數目就是 backlog 的數值。你可以將其設成5 到10 之間的數值(推薦))
*
*
* return? ? 錯誤返回-1, 并設置全局錯誤代碼變量errno
*/
#include
int listen(int sockfd, int backlog);
accept()函數
/*
* 當調用它的時候，大致過程是下面這樣的：
*? ???有人從很遠很遠的地方嘗試調用connect()來連接你的機器上的某個端口（當然是你已經在listen()的）
*? ???他的連接將被listen 加入等待隊列等待accept()函數的調用
*? ???你調用accept()函數，告訴他你準備連接
*
* sockfd? ?是正在listen() 的一個套接字描述符
* addr? ???一般是一個指向struct sockaddr_in 結構的指針；里面存儲著遠程連接過來的計算機的信息（比如遠程計算機的IP 地址和端口）
* addrlen??是一個本地的整型數值，在它的地址傳給accept() 前它的值應該是sizeof(struct sockaddr_in)；accept()不會在addr 中存儲多余addrlen bytes 大小的數據。如果accept()函數在addr 中存儲的數據量不足addrlen，則accept()函數會改變addrlen 的值來反應這個情況。
*
*
* return? ?accept()函數將回返回一個新的套接字描述符，這個描述符就代表了這個連接
*? ?? ?? ? 這時候你有了兩個套接字描述符:
*? ?? ?? ?? ? 返回給你的那個就是和遠程計算機的連接, 這時候你所得到的那個新的套接字描述符就可以進行send()操作和recv()操作了。
*? ?? ?? ?? ? 而第一個套接字描述符仍然在你的機器上原來的那個端口上listen()
*
*? ?? ?? ? -1 來表明調用失敗，同時全局變量errno 將會存儲錯誤代碼
*/
#include
int accept(int sockfd, void *addr, int *addrlen);
示例:
#include
#include
#include
/* 用戶連接的端口號 */
#define MYPORT 4000
/* 等待隊列中可以存儲多少個未經過accept()處理的連接 */
#define BACKLOG 10
main()
{
? ?/* 用來監聽網絡連接的套接字sock_fd，用戶連入的套接字使用new_fd */
? ?int sockfd, new_fd ;
? ?/* 本地的地址信息 */
? ?struct sockaddr_in my_addr ;
? ?/* 連接者的地址信息 */
? ?struct sockaddr_in their_addr ;
? ?int sin_size;
? ?/* 記得在自己的程序中這部分要進行錯誤檢查！ */
? ?sockfd = socket(AF_INET, SOCK_STREAM, 0) ;
? ?/* 主機字節順序 */
? ?my_addr.sin_family = AF_INET ;
? ?/* 網絡字節順序，短整型 */
? ?my_addr.sin_port = htons(MYPORT) ;
? ?/* 自動賦值為自己的IP */
? ?my_addr.sin_addr.s_addr = INADDR_ANY ;
? ?/* 將結構中未使用部分全部清零 */
? ?bzero(&(my_addr.sin_zero), 8) ;
? ?/* 不要忘記在你自己的程序中下面的程序調用需要進行錯誤檢測！！*/
? ?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()函數
/*
*
*??這兩個函數是最基本的，通過連接的套接字流進行通訊的函數
*??如果你想使用無連接的使用者數據報的話，請參sendto() 和recvfrom() 函數。
*
*??sockfd 是代表你與遠程程序連接的套接字描述符。
*??msg? ? 是一個指針，指向你想發送的信息的地址。
*??len? ? 是你想發送信息的長度
*??flags??發送標記。一般都設為0（你可以查看send 的man pages 來獲得其他的參數值并且明白各個參數所代表的含義）
*??
*??return??函數在調用后會返回它真正發送數據的長度
*? ?? ?? ? -1??如果發生錯誤，錯誤代碼存儲在全局變量errno
*
*/
#include
#include
int send(int sockfd, const void *msg, int len, int flags);
示例:
char *msg = "Hello! World! ";
int len, bytes_sent;
len = strlen(msg);
bytes_sent = send(sockfd, msg, len, 0);
注意：
? ?send() 所發送的數據可能少于你給它的參數所指定的長度！
? ?因為如果你給send()的參數中包含的數據的長度遠遠大于send()所能一次發送的數據，則send()函數只發送它所能發送的最大數據長度，然后它相信你會把剩下的數據再次調用它來進行第二次發送。
? ?所以，記住如果send()函數的返回值小于len 的話，則你需要再次發送剩下的數據。
? ?幸運的是，如果包足夠小（小于1K），那么send()一般都會一次發送光的。
recv()函數
/*
*
*??sockfd??是你要讀取數據的套接字描述符
*??buf? ???是一個指針，指向你能存儲數據的內存緩存區域
*??len? ???是緩存區的最大尺寸
*??flags? ?是recv() 函數的一個標志，一般都為0 （具體的其他數值和含義請參考recv()的man pages）
*
*
*??返回? ? 它所真正收到的數據的長度（也就是存到buf 中數據的長度）
*
*? ?? ?? ? -1? ? 則代表發生了錯誤（比如網絡以外中斷、對方關閉了套接字連接等），全局變量errno 里面存儲了錯誤代碼
*/
#include
#include
int recv(int sockfd, void *buf, int len, unsigned int flags）;
sendto() 和recvfrom() 函數
/*
* 這兩個函數是進行無連接的UDP 通訊時使用的。
* 使用這兩個函數，則數據會在沒有建立過任何連接的網絡上傳輸。因為數據報套接字無法對遠程主機進行連接
*
* sockfd??是代表你與遠程程序連接的套接字描述符
* msg? ???是一個指針，指向你想發送的信息的地址
* len? ???是你想發送信息的長度
* flags? ?發送標記。一般都設為0 (你可以查看send 的man pages 來獲得其他的參數值并且明白各個參數所代表的含義)
* to? ?? ?是一個指向struct sockaddr 結構的指針，里面包含了遠程主機的IP 地址和端口數據
* tolen? ?只是指出了struct sockaddr 在內存中的大小sizeof(struct sockaddr)
*
* return??sendto()返回它所真正發送的字節數（當然也和send()一樣，它所真正發送的字節數可能小于你所給它的數據的字節數）
*? ?? ?? ?-1 表示出錯? ?同時全局變量errno 存儲了錯誤代碼
*/
#include
#include
int sendto(int sockfd, const void *msg, int len, unsigned int flags, const struct sockaddr *to, int tolen);
recvfrom()函數
/*
*
* sockfd??是你要讀取數據的套接字描述符
* buf? ???是一個指針，指向你能存儲數據的內存緩存區域
* len? ???是緩存區的最大尺寸
* flags? ?是recv() 函數的一個標志，一般都為0 （具體的其他數值和含義請參考recv()的man pages）
* from? ? 是一個本地指針，指向一個struct sockaddr 的結構（里面存有源IP 地址和端口數）
* fromlen 是一個指向一個int 型數據的指針，它的大小應該是sizeof (struct sockaddr)．當函數返回的時候，formlen 指向的數據是form 指向的struct sockaddr 的實際大小．
*? ?? ?? ?如果一個信息大得緩沖區都放不下，那么附加信息將被砍掉。該調用可以立即返回,也可以永久的等待。這取決于你把flags 設置成什么類型。你甚至可以設置超時(timeout)值。
*
*
* return??返回它接收到的字節數，如果發生了錯誤，它就返回–1 ，全局變量errno存儲了錯誤代碼
*
*/
#include
#include
int recvfrom(int sockfd, void *buf, int len, unsigned int flags, struct sockaddr *from, int *fromlen);
注意：
? ?如果你使用cnnect()連接到了一個數據報套接字的服務器程序上，那么你就可以使用send() 和recv() 函數來傳輸你的數據．
? ?不要以為你在使用一個流式的套接字，你所使用的仍然是一個使用者數據報的套接字，只不過套接字界面在send() 和recv()的時候自動幫助你加上了目標地址，目標端口的信息．
close()和shutdown()函數
/*
* 程序進行網絡傳輸完畢后，你需要關閉這個套接字描述符所表示的連接。實現這個非常簡單，只需要使用標準的關閉文件的函數：close()。
* 執行close()之后，套接字將不會在允許進行讀操作和寫操作。任何有關對套接字描述符進行讀和寫的操作都會接收到一個錯誤。
*
*/
close(sockfd);
/*
* 如果你想對網絡套接字的關閉進行進一步的操作的話，你可以使用函數shutdown()
* 它允許你進行單向的關閉操作，或是全部禁止掉。
*
* 如果你在一個未連接的數據報套接字上使用shutdown() 函數，它將什么也不做．
*
* sockfd 是一個你所想關閉的套接字描述符
* how 可以取下面的值。
*? ???0 表示不允許以后數據的接收操；
*? ???1 表示不允許以后數據的發送操作；
*? ???2 表示和close()一樣，不允許以后的任何操作（包括接收，發送數據）
*
* return??0 執行成功
*? ?? ???-1 執行失敗, 全局變量errno 中存儲了錯誤代碼．
*? ?
*/
#include
int shutdown(int sockfd, int how);
setsockopt() 和getsockopt() 函數
Linux 所提供的socket 庫含有一個錯誤（bug）。
??此錯誤表現為你不能為一個套接字重新啟用同一個端口號，即使在你正常關閉該套接字以后。
??例如，比方說，你編寫一個服務器在一個套接字上等待的程序．服務器打開套接字并在其上偵聽是沒有問題的。無論如何，總有一些原因（不管是正常還是非正常的結束程序）使你的程序需要重新啟動。然而重啟動后你就不能把它綁定在原來那個端口上了。從bind()系統調用返回的錯誤代碼總是報告說你試圖連接的端口已經被別的進程所綁定。
??問題就是Linux 內核在一個綁定套接字的進程結束后從不把端口標記為未用。在大多數Linux/UNIX 系統中，端口可以被一個進程重復使用，甚至可以被其它進程使用。
??在Linux 中繞開這個問題的辦法是，當套接字已經打開但尚未有連接的時候用setsockopt()系統調用在其上設定選項（options）。
??setsockopt() 調用設置選項而getsockopt()從給定的套接字取得選項。
這里是這些調用的語法：
/*
*
*
* sockfd 必須是一個已打開的套接字
* level 是函數所使用的協議標準（protocol level）（TCP/IP 協議使用IPPROTO_TCP，套接字標準的選項實用SOL_SOCKET）
* name 選項在套接字說明書中（man page）有詳細說明
* value 指向為getsockopt()函數所獲取的值，setsockopt()函數所設置的值的地址
* optlen 指針指向一個整數，該整數包含參數以字節計算的長度
*
*
*
*
*
*/
#include
#include
int getsockopt(int sockfd, int level, int name, char *value, int *optlen);
int setsockopt(int sockfd, int level, int name, char *value, int *optlen);
當你打開一個套接字時必須同時用下面的代碼段來調用setsockopt()函數：
/* 設定參數數值 */
opt = 1;
len = sizeof(opt);
/* 設置套接字屬性 */
setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,&len);
getpeername()函數
/*
* 這個函數可以取得一個已經連接上的套接字的遠程信息（比如IP 地址和端口），告訴你在遠程和你連接的究竟是誰
*
* 當你擁有了遠程連接用戶的IP 地址，你就可以使用inet_ntoa() 或gethostbyaddr()來輸出信息或是做進一步的處理
*
* sockfd??是你想取得遠程信息的那個套接字描述符
* addr? ? 是一個指向struct sockaddr （或是struct sockaddr_in）的指針
* addrlen 是一個指向int 的指針，應該賦于sizeof(struct sockaddr)的大小
*
*
* return??錯誤，函數將返回 –1 ，并且錯誤代碼儲存在全局變量errno 中
*
*/
#include
int getpeername(int sockfd, struct sockaddr *addr, int *addrlen);
gethostname()函數
/*
* 可以取得本地主機的信息,它返回正在執行它的計算機的名字
* 返回的這個名字可以被gethostbyname()函數使用，由此可以得到本地主機的IP 地址
*
* hostname??是一個指向字符數組的指針，當函數返回的時候，它里面的數據就是本地的主機的名字
* size? ?? ?是hostname 指向的數組的長度
*
*
* return? ? 成功執行，它返回0
*? ?? ?? ???錯誤，則返回–1，全局變量errno 中存儲著錯誤代碼
*
*/
#include
int gethostname(char *hostname, size_t size);
gethostbyname()函數
/*
*
* 網絡地址是以網絡字節順序存儲的
*
*
* return? ? 成功則返回指向結構struct hostent的指針
*
? ?? ?? ?? ?#define h_addr h_addr_list[0]? ? //h_addr 是 h_addr_list 數組的第一個成員
? ?? ?? ?? ?struct hostent
? ?? ?? ?? ?{
? ?? ?? ?? ?? ?char *h_name;? ?? ? //是這個主機的正式名稱
? ?? ?? ?? ?? ?char **h_aliases;? ?//是一個以NULL（空字符）結尾的數組，里面存儲了主機的備用名稱
? ?? ?? ?? ?? ?int??h_addrtype;? ? //是返回地址的類型，一般來說是“AF_INET”
? ?? ?? ?? ?? ?int??h_length;? ?? ?//是地址的字節長度
? ?? ?? ?? ?? ?char **h_addr_list; //是一個以0 結尾的數組，存儲了主機的網絡地址
? ?? ?? ?? ?};
*
*
*? ?? ?? ???如果發生錯誤，它將會返回NULL（但是errno 并不代表錯誤代碼，h_errno 中存儲的才識錯誤代碼。參考下面的herror()函數
*/
struct hostent *gethostbyname(const char *name);
五種I/O 模式
----------------------------------------
在Linux/UNIX 下，有下面這五種I/O 操作方式：
? ?阻塞I/O
? ?非阻塞I/O
? ?I/O 多路復用
? ?信號驅動I/O（SIGIO）
? ?異步I/O
程序進行輸入操作有兩步：
? ?等待有數據可以讀
? ?將數據從系統內核中拷貝到程序的數據區。
對于一個對套接字的輸入操作:
? ???第一步一般來說是,等待數據從網絡上傳到本地,當數據包到達的時候，數據將會從網絡層拷貝到內核的緩存中；
? ???第二步是從內核中把數據拷貝到程序的數據區中
.阻塞I/O 模式
? ???簡單的說，阻塞就是＂睡眠＂的同義詞
? ?? ?? ?如你運行上面的listener 的時候，它只不過是簡單的在那里等待接收數據。它調用recvfrom()函數，但是那個時候（listener 調用recvfrom()函數的時候），它并沒有數據可以接收．所以recvfrom()函數阻塞在那里（也就是程序停在recvfrom()函數處睡大覺）直到有數據傳過來阻塞．你應該明白它的意思。
? ???阻塞I/O 模式是最普遍使用的I/O 模式。大部分程序使用的都是阻塞模式的I/O 。
? ???缺省的，一個套接字建立后所處于的模式就是阻塞I/O 模式。
? ???對于一個UDP 套接字來說，數據就緒的標志比較簡單：
? ?? ?? ?已經收到了一整個數據報
? ?? ?? ?沒有收到。
? ???而TCP 這個概念就比較復雜，需要附加一些其他的變量
? ?? ?? ?一個進程調用recvfrom ，然后系統調用并不返回知道有數據報到達本地系統，然后系統將數據拷貝到進程的緩存中。
? ?? ???（如果系統調用收到一個中斷信號，則它的調用會被中斷）我們稱這個進程在調用recvfrom 一直到從recvfrom 返回這段時間是阻塞的。
? ?? ?? ?當recvfrom正常返回時，我們的進程繼續它的操作。
.非阻塞模式I/O
? ? 當我們將一個套接字設置為非阻塞模式，我們相當于告訴了系統內核：“當我請求的I/O 操作不能夠馬上完成，你想讓我的進程進行休眠等待的時候，不要這么做，請馬上返回一個錯誤給我。”
? ?
? ? 如我們開始對recvfrom 的三次調用，因為系統還沒有接收到網絡數據，所以內核馬上返回一個EWOULDBLOCK的錯誤。
? ? 第四次我們調用recvfrom 函數，一個數據報已經到達了，內核將它拷貝到我們的應用程序的緩沖區中，然后recvfrom 正常返回，我們就可以對接收到的數據進行處理了。
??
? ? 當一個應用程序使用了非阻塞模式的套接字，它需要使用一個循環來不聽的測試是否一個文件描述符有數據可讀（稱做polling）。
? ? 應用程序不停的polling 內核來檢查是否I/O操作已經就緒。這將是一個極浪費CPU 資源的操作。這種模式使用中不是很普遍
.I/O 多路復用 select()
? ? 在使用I/O 多路技術的時候，我們調用select()函數和poll()函數，在調用它們的時候阻塞，而不是我們來調用recvfrom（或recv）的時候阻塞。
? ? 當我們調用select 函數阻塞的時候，select 函數等待數據報套接字進入讀就緒狀態。當select 函數返回的時候，也就是套接字可以讀取數據的時候。這時候我們就可以調用recvfrom函數來將數據拷貝到我們的程序緩沖區中。
? ? 和阻塞模式相比較，select()和poll()并沒有什么高級的地方，而且，在阻塞模式下只需要調用一個函數：讀取或發送，在使用了多路復用技術后，我們需要調用兩個函數了：先調用select()函數或poll()函數，然后才能進行真正的讀寫。
? ?
? ? 多路復用的高級之處在于，它能同時等待多個文件描述符，而這些文件描述符（套接字描述符）其中的任意一個進入讀就緒狀態，select()函數就可以返回
? ? 假設我們運行一個網絡客戶端程序，要同時處理套接字傳來的網絡數據又要處理本地的標準輸入輸出。在我們的程序處于阻塞狀態等待標準輸入的數據的時候，假如服務器端的程序被kill（或是自己Down 掉了），那么服務器程端的TCP 協議會給客戶端（我們這端）的TCP 協議發送一個FIN 數據代表終止連接。但是我們的程序阻塞在等待標準輸入的數據上，在它讀取套接字數據之前（也許是很長一段時間），它不會看見結束標志．我們就不能夠使用阻塞模式的套接字。
? ? I/O多路技術一般在下面這些情況中被使用：
? ?? ? 當一個客戶端需要同時處理多個文件描述符的輸入輸出操作的時候（一般來說是標準的輸入輸出和網絡套接字）， I/O 多路復用技術將會有機會得到使用。
? ?? ? 當程序需要同時進行多個套接字的操作的時候。
? ?? ? 如果一個TCP 服務器程序同時處理正在偵聽網絡連接的套接字和已經連接好的套接字。
? ?? ? 如果一個服務器程序同時使用TCP 和UDP 協議。
? ?? ? 如果一個服務器同時使用多種服務并且每種服務可能使用不同的協議（比如inetd就是這樣的）。
??
? ? I/O 多路服用技術并不只局限與網絡程序應用上。幾乎所有的程序都可以找到應用I/O多路復用的地方。
fcntl()函數
? ???簡單的說，阻塞就是＂睡眠＂的同義詞.
? ???如你運行上面的listener 的時候，它只不過是簡單的在那里等待接收數據。它調用recvfrom()函數，但是那個時候（listener 調用recvfrom()函數的時候），它并沒有數據可以接收．所以recvfrom()函數阻塞在那里（也就是程序停在recvfrom()函數處睡大覺）直到有數據傳過來阻塞．你應該明白它的意思。
? ???當你一開始建立一個套接字描述符的時候，系統內核就被設置為阻塞狀態。如果你不想你的套接字描述符是處于阻塞狀態的，那么你可以使用函數fcntl()。
? ???#include
? ???#include
? ???int fcntl (int fd, int cmd, long arg）;
示例:
? ???sockfd = socket（AF_INET, SOCK_STREAM, 0）;
? ???fcntl（sockfd, F_SETFL, O_NONBLOCK）;
? ???這樣將一個套接字設置為無阻塞模式后，你可以對套接字描述符進行有效的“檢測”．
? ???如果你嘗試從一個沒有接收到任何數據的無阻塞模式的套接字描述符那里讀取數據，那么讀取函數會馬上返回–1 代表發生錯誤，全局變量errno 中的值為EWOULDBLOCK。
? ???一般來說，這種無阻塞模式在某些情況下不是一個好的選擇。假如你的程序一直沒有接收到傳過來的數據，那么你的程序就會進行不停的循環來檢查是否有數據到來，浪費了大量的CPU 時間，而這些CPU 時間本來可以做其他事情的。
? ???另外一個比較好的檢測套接字描述符的方法是調用select()函數
套接字選擇項select()函數
/*
*
*??這個技術有一點點奇怪但是它對我們的程序確是非常有用的。
*??假想一下下面的情況：
*? ?? ?你寫的服務器程序想監聽客戶端的連接，但是你同時又想從你以前已經建立過的連接中來讀取數據。
*??你可能會說：“沒有問題，我不就是需要使用一個accept()函數和一對兒recv()函數嗎？”。
*??不要這么著急，你要想想，當你調用accept()函數阻塞的時候，你還能調用recv()函數嗎？
*??“使用非阻塞套接字！”你可能會這么說。是的，你可以。但是如果你又不想浪費寶貴的CPU 時間，該怎么辦呢？
*??Select()函數可以幫助你同時監視許多套接字。它會告訴你哪一個套接字已經可以讀取數據，
*??哪個套接字已經可以寫入數據，甚至你可以知道哪個套接字出現了錯誤，如果你想知道的話。
*
*??
*
* 當select()函數返回的時候，readfds 將會被修改用來告訴你哪一個文件描述符你可以用來讀取數據。
*
* numfds? ?? ?? ?是readfds，writefds，exceptfds 中fd 集合中文件描述符中最大的數字加上1 也就是sockfd+1（因為標準輸入的文件描述符的值為0 ，所以其他任何的文件描述符都會比標準輸入的文件描述符大）。
*
* readfds? ?? ???中的fd 集合將由select 來監視是否可以讀取,如果你想知道是是否可以從標準輸入和一些套接字（sockfd）中讀取數據，你就可以把文件描述符和sockfd 加入readfds 中。
* writefds? ?? ? 中的fds 集合將由select 來監視是否可以寫入
* exceptfds? ?? ?中的fds 集合將由select 來監視是否有例外發生
* struct timeval 超時設置。
*? ?? ?? ?? ?? ?? ???一般來說，如果沒有任何文件描述符滿足你的要求，你的程序是不想永遠等下去的．也許每隔1 分鐘你就想在屏幕上輸出信息：“hello！”。
*? ?? ?? ?? ?? ? 這個代表時間的結構將允許你定義一個超時。
*? ?? ?? ?? ?? ? 在調用select()函數中，如果時間超過timeval 參數所代表的時間長度，
*? ?? ?? ?? ?? ? 而還沒有文件描述符滿足你的要求，那么select()函數將回返回，允許你進行下面的操作。
*? ?? ?? ?? ?? ? 只需要將tv_sec 設置為你想等待的秒數，然后設置tv_usec 為想等待的微秒數
*? ?? ?? ?? ?? ? (真正的時間就是tv_sec 所表示的秒數加上tv_usec 所表示的微秒數）．注意，是微秒（百萬分之一）而不是毫秒．
*? ?? ?? ?? ?? ? 一秒有1,000 毫秒，一毫秒有1,000 微秒。所以，一秒有1,000,000 微秒．
*? ?? ?? ?? ?? ? 這個timeval 結構定義如下：
*? ?? ?? ?? ?? ? struct timeval
*? ?? ?? ?? ?? ? {
*? ?? ?? ?? ?? ?? ???int tv_sec ;? ?//秒數
*? ?? ?? ?? ?? ?? ???int tv_usec ;??//微秒
*? ?? ?? ?? ?? ? };
*? ?? ?? ?? ?? ? 我們擁有了一個以微秒為單位的記時器！但是因為Linux 和UNIX 一樣，最小的時間片是100 微秒，所以不管你將tv_usec 設置的多小，實質上記時器的最小單位是100微秒．
*
*? ?? ?? ?? ?? ? 如果你將struct timeval 設置為0，則select()函數將會立即返回，同時返回在你的集合中的文件描述符的狀態。
*
*? ?? ?? ?? ?? ? 如果你將timeout 這個參數設置為NULL，則select()函數進入阻塞狀態，除了等待到文件描述符的狀態變化，否則select()函數不會返回。
*
*
* return? ?? ???當select()函數返回的時候，timeval 中的時間將會被設置為執行為select()后還剩下的時間。
*
*
*
*/
#include
#include
#include
int select(int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
使用FD_ISSET() 宏，你可以選出select()函數執行的結果。
在進行更深的操作前，我們來看一看怎樣處理這些fd_sets。下面這些宏可以是專門進行這類操作的：
??FD_ZERO(fd_set *set)? ?? ?? ???將一個文件描述符集合清零
??FD_SET(int fd, fd_set *set)? ? 將文件描述符fd 加入集合set 中。
??FD_CLR(int fd, fd_set *set)? ? 將文件描述符fd 從集合set 中刪除．
??FD_ISSET(int fd, fd_set *set)??測試文件描述符fd 是否存在于文件描述符set 中．
下面這段代碼演示了從標準輸入等待輸入等待2.5 秒．
#include
#include
#include
/* 標準輸入的文件描述符數值 */
#define STDIN 0
main()
{
? ?fd_set readfds;
? ?struct timeval tv;
? ?/* 設置等待時間為2 秒零500,000 微秒 */
? ?tv.tv_sec??= 2;
? ?tv.tv_usec = 500000;
? ?FD_ZERO(&readfds);
? ?FD_SET(STDIN, &readfds);
? ?/* 因為我們只想等待輸入，所以將writefds 和execeptfds 設為NULL */
? ?/* 程序將會在這里等待2 秒零500,000 微秒，除非在這段時間中標準輸入有操作 */
? ?select(STDIN+1, &readfds, NULL, NULL, &tv);
? ?/* 測試ST
Socket編程知識必學
/*
*
* Author: cnscn
* HOME:??
http://www.cnscn.org
* 整理自《Linux網絡編程》
*/
端口號常識:
? ? 端口號被從1 開始分配。
? ? 通常端口號超出255 的部分被本地主機保留為私有用途。
? ? 1到255 之間的號碼被用于遠程應用程序所請求的進程和網絡服務。
? ? 每個網絡通信循環地進出主計算機的TCP 應用層。它被兩個所連接的號碼唯一地識別。這兩個號碼合起來叫做套接字.
? ?? ???組成套接字的這兩個號碼就是機器的IP 地址和TCP 軟件所使用的端口號。
套接字的三種類型
? ? 流式套接字（SOCK_STREAM），數據報套接字（SOCK_DGRAM）及原始套接字(RAW)。
??流式套接字（SOCK_STREAM）
? ? 流式的套接字可以提供可靠的、面向連接的通訊流。
? ? 如果你通過流式套接字發送了順序的數據：“1”、“２”。那么數據到達遠程時候的順序也是“１”、“２”。
? ? Telnet 應用程序、BBS服務、以及系統的遠程登陸都是通過Telnet 協議連接的。Telnet 就是一個流式連接。你是否希望你在Telnet 應用程序上輸入的字符（或漢字）在到達遠程應用程序的時候是以你輸入的順序到達的？答案應該是肯定的吧。
? ? 還有WWW 瀏覽器，它使用的HTTP 協議也是通過流式套接字來獲取網頁的。事實上，如果你Telnet 到一個Web Site 的80 端口上，然后輸入 “GET 網頁路徑名”然后按兩下回車（或者是兩下Ctrl+回車）然后你就得到了“網頁路徑名”所代表的網頁！
??數據報套接字（SOCK_DGRAM）
? ? 數據報套接字定義了一種無連接的服務，數據通過相互獨立的報文進行傳輸，是無序的，并且不保證可靠，無差錯。
? ?? ? 如果你發送了一個數據報，它可能不會到達。
? ?? ? 它可能會以不同的順序到達。
? ?? ? 如果它到達了，它包含的數據中可能存在錯誤。
? ?? ? 數據報套接字也使用IP，但是它不使用TCP，它使用使用者數據報協議UDP（User Datagram Protocol 可以參考RFC 768）
? ?為什么說它們是“無連接”的呢？因為它（UDP）不像流式套接字那樣維護一個打開的連接，你只需要把數據打成一個包，把遠程的IP 貼上去，然后把這個包發送出去。這個過程是不需要建立連接的。
? ?? ? UDP 的應用例子有： tftp, bootp 等。
? ?那么，數據包既然會丟失，怎樣能保證程序能夠正常工作呢？
? ?? ? 事實上，每個使用UDP的程序都要有自己的對數據進行確認的協議。
? ?? ?? ???比如， TFTP 協議定義了對于每一個發送出去的數據包，遠程在接受到之后都要回送一個數據包告訴本地程序：“我已經拿到了！”（一個 “ACK” 包）。如果數據包發的送者在5 秒內沒有的得到回應，它就會重新發送這個數據包直到數據包接受者回送了 “ACK” 信號。這些知識對編寫一個使用UDP 協議的程序員來說是非常必要的。
? ?無連接服務器一般都是面向事務處理的，一個請求一個應答就完成了客戶程序與服務程序之間的相互作用。
? ?面向連接服務器處理的請求往往比較復雜，不是一來一去的請求應答所能解決的，而且往往是并發服務器
? ?套接字工作過程如下:
? ?? ?? ?服務器首先啟動
? ?? ?? ?通過調用socket()建立一個套接字，
? ?? ?? ?然后調用bind()將該套接字和本地網絡地址聯系在一起，
? ?? ?? ?再調用listen()使套接字做好偵聽的準備，并規定它的請求隊列的長度,
? ?? ?? ?之后就調用accept()來接收連接。
? ?? ?? ?客戶在建立套接字
? ?? ?? ?然后就可調用connect()和服務器建立連接。
? ?? ?? ?客戶機和服務器之間就可以通過調用read()和write()來發送和接收數據。
? ?? ?? ?最后，待數據傳送結束后，雙方調用close()關閉套接字。
對流式套接字你所需要做的只是調用send() 函數來發送數據。而對于數據報套接字，你需要自己加個信息頭，然后調用sendto() 函數把數據發送出去
??原始套接字
? ???原始套接字主要用于一些協議的開發，可以進行比較底層的操作。它功能強大，但是沒有上面介紹的兩種套接字使用方便，一般的程序也涉及不到原始套接字
套接字結構
struct sockaddr
這個結構用來存儲套接字地址。
數據定義：
struct sockaddr
{
? ? unsigned short sa_family;??/* address族, AF_xxx */
? ? char sa_data[14];? ?? ?? ?? ???/* 14 bytes的協議地址 */
};
sa_family??一般來說，都是 “AF_INET”。
sa_data? ? 包含了一些遠程電腦的地址、端口和套接字的數目，它里面的數據是雜溶在一切的。
為了處理struct sockaddr， 程序員建立了另外一個相似的結構struct sockaddr_in (“in” 代表 “Internet”):
struct sockaddr_in
{
? ?short? ???int? ?? ? sin_family;? ?? ?? ???/* Internet地址族 */
? ?unsigned??short int sin_port;? ?? ? /* 端口號 */
? ?struct? ? in_addr? ?sin_addr;? ?? ?? ?/* Internet地址 */
? ?unsigned??char? ?? ?sin_zero[8];? ?/* 添0（和struct sockaddr一樣大小）*/
};
注意:
? ? 1)這個結構提供了方便的手段來訪問socket address（struct sockaddr）結構中的每一個元素。
? ? 2)sin_zero[8] 是為了是兩個結構在內存中具有相同的尺寸
? ?? ?? ?? ?? ?? ?要把sin_zero 全部設成零值（使用bzero()或memset()函數）。
? ? 3)一個指向struct sockaddr_in 的指針可以聲明指向一個sturct sockaddr 的結構。所以雖然socket() 函數需要一個structaddr * ，你也可以給他一個sockaddr_in * 。
? ? 4)在struct??sockaddr_in 中，sin_family 相當于 在struct sockaddr 中的sa_family，需要設成 “AF_INET”。
? ? 5)一定要保證sin_port 和sin_addr 必須是網絡字節順序（見下節）！
2．struct in_addr??( 因特網地址 (a structure for historical reasons) )
? ?struct in_addr
? ?{
? ?? ? unsigned long s_addr;
? ?};
? ?如果你聲明了一個 "ina" 作為一個struct sockaddr_in 的結構， 那么“ina.sin_addr.s_addr”就是4 個字節的IP 地址（按網絡字節順序排放）。
? ?需要注意的是，即使你的系統仍然使用聯合而不是結構來表示struct in_addr，你仍然可以用上面的方法得到4 個字節的IP 地址（一些 #defines 幫了你的忙）
網絡字節順序
? ?因為每一個機器內部對變量的字節存儲順序不同（有的系統是高位在前，底位在后，而有的系統是底位在前，高位在后），而網絡傳輸的數據大家是一定要統一順序的。
? ?所以對與內部字節表示順序和網絡字節順序不同的機器，就一定要對數據進行轉換（比如IP 地址的表示，端口號的表示）。
? ?但是內部字節順序和網絡字節順序相同的機器該怎么辦呢？是這樣的：它們也要調用轉換函數，但是真正轉換還是不轉換是由系統函數自己來決定的。
? ?有關的轉化函數
? ?? ?我們通常使用的有兩種數據類型：短型（兩個字節）和長型（四個字節）。
? ?? ?下面介紹的這些轉換函數對于這兩類的無符號整型變量都可以進行正確的轉換。
? ?? ?如果你想將一個短型數據從主機字節順序轉換到網絡字節順序的話，有這樣一個函數htons：
? ?? ?? ?它是以“h”開頭的（代表“主機”）；
? ?? ?? ?緊跟著它的是“to”，代表“轉換到”；
? ?? ?? ?然后是“n”代表“網絡”；
? ?? ?? ?最后是“s”，代表“短型數據”。
? ?? ?? ?H-to-n-s，就是htons() 函數（可以使用Hostto Network Short 來助記）
? ?? ?你可以使用 “n”，“h”，“to”，“s”，“l”的任意組合.當然，你要在可能的情況下進行組合。比如，系統是沒有stolh() 函數的（Short to Long Host?）。
? ?? ???下面給出套接字字節轉換程序的列表：
? ?? ?? ? htons()——“Host to Network Short” 主機字節順序轉換為網絡字節順序（對無符號短型進行操作4 bytes）
? ?? ?? ? htonl()——“Host to Network Long” 主機字節順序轉換為網絡字節順序（對無符號長型進行操作8 bytes）
? ?? ?? ? ntohs()——“Network to Host Short “ 網絡字節順序轉換為主機字節順序（對無符號短型進行操作4 bytes）
? ?? ?? ? ntohl()——“Network to Host Long “ 網絡字節順序轉換為主機字節順序（對無符號長型進行操作8 bytes）
? ???在struct sockaddr_in 中的sin_addr 和sin_port 他們的字節順序都是網絡字節順序，而sin_family 卻不是網絡字節順序的。為什么呢？
? ?? ???這個是因為sin_addr 和sin_port 是從IP 和UDP 協議層取出來的數據，而在IP 和UDP協議層，是直接和網絡相關的，所以，它們必須使用網絡字節順序。
? ?? ???然而， sin_family 域只是內核用來判斷struct sockaddr_in 是存儲的什么類型的數據，并且， sin_family 永遠也不會被發送到網絡上，所以可以使用主機字節順序來存儲
socket() 函數
? ?
? ?/**
? ?*
? ?* 取得套接字描述符！（記得我們以前說過的嗎？它其實就是一個文件描述符）
? ?*
? ?* domain? ?需要被設置為 “AF_INET”，就像上面的struct sockaddr_in。
? ?* type? ???參數告訴內核這個socket 是什么類型，“SOCK_STREAM”或是“SOCK_DGRAM”。
? ?* protocol 通常為0
? ?*
? ?* return? ?如果發生錯誤，socket()函數返回 –1 。全局變量errno 將被設置為錯誤代碼。
? ?*
? ?*/
? ?#include
? ?#include
? ?int socket（int domain , int type , int protocol）
? ?示例:
? ?if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
? ?{
? ?? ???perror("create sock");
? ?? ???return -1;
? ?}
? ?else
? ?{
? ?? ?// printf("socket created...\n");
? ?}
bind() 函數
/**
*
* 為套接字綁定一個端口號
*
* 當你需要進行端口監聽listen()操作，等待接受一個連入請求的時候，
* 一般都需要經過這一步。比如網絡泥巴(MUD)，Telnet a.b.c.d 4000
*
* 如果你只是想進行連接一臺服務器，也就是進行connect() 操作的時候，這一步并不是必須的。
*
*
* sockfd? ? 是由socket()函數返回的套接字描述符
* my_addr? ?是一個指向struct sockaddr 的指針，包含有關你的地址的信息：名稱、端口和IP 地址。
* addrlen? ?可以設置為sizeof(struct sockaddr)
*
* return? ? 調用錯誤的時候，返回 -1 作為錯誤發生的標志。errno 的值為錯誤代碼。
*
*/
#include
#include
int bind (int sockfd , struct sockaddr *my_addr , int addrlen) ;
示例:
#include
#include
#include
#define??MYPORT 4000
main()
{
??int sockfd ;
??struct sockaddr_in my_addr ;
??sockfd? ?? ?? ?? ?? ?? ?= socket(AF_INET, SOCK_STREAM, 0); /* 在你自己的程序中要進行錯誤檢查！! */
??my_addr.sin_family? ?? ?= AF_INET ;? ?? ???/* 主機字節順序 */
??my_addr.sin_port? ?? ???= htons(MYPORT);? ?/* 網絡字節順序，短整型 */
??my_addr.sin_addr.s_addr = inet_addr("166.111.69.52") ;
??bzero(&(my_addr.sin_zero), 8);? ?? ?? ?? ? /* 將整個結構剩余部分數據設為0 */
??bind (sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr));??/* 不要忘記在你自己的程序中加入判斷bind 錯誤的代碼！！ */
??注意：
? ? my_addr.sin_port? ?? ?? ?是網絡字節順序, 短整型
? ? my_addr.sin_addr.s_addr??也是網絡字節順序。
??最后，bind()可以在程序中自動獲取你自己的IP 地址和端口。
? ? my_addr.sin_port = 0 ;? ?? ?? ?? ?? ???/* 隨機選擇一個端口 */
? ? my_addr.sin_addr.s_addr = INADDR_ANY ; /* 使用自己的地址 */
? ? 如上，通過設置my_addr.sin_port 為0，bind()可以知道你要它幫你選擇合適的端口；
? ? 通過設置my_addr.sin_addr.s_addr 為INADDR_ANY，bind()知道你要它將s_addr 填充為運行這個進程的機器的IP。
? ? 這一切都可以要求bind()來自動的幫助你完成。
? ? 如果你注意到了一些細節的話，你可能會發現我并沒有將INADDR_ANY 轉換為網絡字節順序！是這樣的，INADDR_ANY的值為0，0 就是0，無論用什么順序排列位的順序，它都是不變的。
? ? 有讀者會想了，因為我用的INADDR_ANY 是一個#define，那么如果將我的程序移植到另外一個系統，假如那里的INADDR_ANY是這樣定義的：
? ?? ? #define INADDR_ANY 100，
? ?? ? 那么我的程序不是就會不運行了嗎？那么下面這段代碼就OK 了:
? ?? ? my_addr.sin_port = htons(0);? ?? ?? ?? ?? ?? ? /* 隨機選擇一個未用的端口 */
? ?? ? my_addr.sin_addr.s_addr = htonl(INADDR_ANY) ;??/* 使用自己的IP地址 */
? ? 現在我們已經是這么的嚴謹，對于任何數值的INADDR_ANY調用bind 的時候就都不會有麻煩了。
? ?另外一件必須指出的事情是：
? ?? ? 當你調用bind()的時候，不要把端口數設置的過小！小于1024 的所有端口都是保留下來作為系統使用端口的，沒有root 權利無法使用。你可以使用1024 以上的任何端口，一直到65535 ：你所可能使用的最大的端口號（當然，你還要保證你所希望使用的端口沒有被其他程序所使用）。
? ?最后注意有關bind()的是：
? ?? ? 有時候你并不一定要調用bind()來建立網絡連接。比如你只是想連接到一個遠程主機上面進行通訊，你并不在乎你究竟是用的自己機器上的哪個端口進行通訊（比如Telnet），那么你可以簡單的直接調用connect()函數，connect()將自動尋找出本地機器上的一個未使用的端口，然后調用 bind()來將其socket 綁定到那個端口上。
connect() 函數
/*
*
* sockfd? ???套接字文件描述符，由socket()函數返回的
* serv_addr??是一個存儲遠程計算機的IP 地址和端口信息的結構
* addrlen? ? 應該是sizeof(struct sockaddr)
*
* return? ???如果發生了錯誤（比如無法連接到遠程主機，或是遠程主機的指定端口無法進行連接等）它將會返回錯誤值 -1
*? ?? ?? ?? ?全局變量errno將會存儲錯誤代碼
*
*
*/
#include
#include
int connect (int sockfd, struct sockaddr *serv_addr, int addrlen);
示例:
#include
#include
#include
#define DEST_IP “166.111.69.52”
#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 ;
? ?/* 網絡字節順序，短整型 */
? ?dest_addr.sin_port = htons(DEST_PORT(;
? ?dest_addr.sin_addr.s_addr = inet_addr(DEST_IP);
? ?/* 將剩下的結構中的空間置0 */
? ?bzero(&(dest_addr.sin_zero), 8）;
? ?/* 不要忘記在你的代碼中對connect()進行錯誤檢查！！ */
? ?connect(sockfd, (struct sockaddr *)&dest_addr, sizeof(struct sockaddr));
? ?注意我們沒有調用bind()函數。基本上，我們并不在乎我們本地用什么端口來通訊，是不是？我們在乎的是我們連到哪臺主機上的哪個端口上。Linux 內核自動為我們選擇了一個沒有被使用的本地端口。
listen() 函數
/*
*
* 等待別人連接，進行系統偵聽請求
* 當有人連接你的時候，你有兩步需要做：
*? ???通過listen()函數等待連接請求
*? ???然后使用accept()函數來處理
*
* 那么我們需要指定本地端口了，因為我們是等待別人的連接。所以，在listen()函數調用之前，我們需要使用bind() 函數來指定使用本地的哪一個端口數值
* 如果你想在一個端口上接受外來的連接請求的話，那么函數的調用順序為：
*??socket();
*??bind();
*??listen();
*
* sockfd? ? 是一個套接字描述符，由socket()系統調用獲得
* backlog? ?是未經過處理的連接請求隊列可以容納的最大數目(每一個連入請求都要進入一個連入請求隊列，等待listen 的程序調用accept()函數來接受這個連接。當系統還沒有調用accept()函數的時候，如果有很多連接，那么本地能夠等待的最大數目就是 backlog 的數值。你可以將其設成5 到10 之間的數值(推薦))
*
*
* return? ? 錯誤返回-1, 并設置全局錯誤代碼變量errno
*/
#include
int listen(int sockfd, int backlog);
accept()函數
/*
* 當調用它的時候，大致過程是下面這樣的：
*? ???有人從很遠很遠的地方嘗試調用connect()來連接你的機器上的某個端口（當然是你已經在listen()的）
*? ???他的連接將被listen 加入等待隊列等待accept()函數的調用
*? ???你調用accept()函數，告訴他你準備連接
*
* sockfd? ?是正在listen() 的一個套接字描述符
* addr? ???一般是一個指向struct sockaddr_in 結構的指針；里面存儲著遠程連接過來的計算機的信息（比如遠程計算機的IP 地址和端口）
* addrlen??是一個本地的整型數值，在它的地址傳給accept() 前它的值應該是sizeof(struct sockaddr_in)；accept()不會在addr 中存儲多余addrlen bytes 大小的數據。如果accept()函數在addr 中存儲的數據量不足addrlen，則accept()函數會改變addrlen 的值來反應這個情況。
*
*
* return? ?accept()函數將回返回一個新的套接字描述符，這個描述符就代表了這個連接
*? ?? ?? ? 這時候你有了兩個套接字描述符:
*? ?? ?? ?? ? 返回給你的那個就是和遠程計算機的連接, 這時候你所得到的那個新的套接字描述符就可以進行send()操作和recv()操作了。
*? ?? ?? ?? ? 而第一個套接字描述符仍然在你的機器上原來的那個端口上listen()
*
*? ?? ?? ? -1 來表明調用失敗，同時全局變量errno 將會存儲錯誤代碼
*/
#include
int accept(int sockfd, void *addr, int *addrlen);
示例:
#include
#include
#include
/* 用戶連接的端口號 */
#define MYPORT 4000
/* 等待隊列中可以存儲多少個未經過accept()處理的連接 */
#define BACKLOG 10
main()
{
? ?/* 用來監聽網絡連接的套接字sock_fd，用戶連入的套接字使用new_fd */
? ?int sockfd, new_fd ;
? ?/* 本地的地址信息 */
? ?struct sockaddr_in my_addr ;
? ?/* 連接者的地址信息 */
? ?struct sockaddr_in their_addr ;
? ?int sin_size;
? ?/* 記得在自己的程序中這部分要進行錯誤檢查！ */
? ?sockfd = socket(AF_INET, SOCK_STREAM, 0) ;
? ?/* 主機字節順序 */
? ?my_addr.sin_family = AF_INET ;
? ?/* 網絡字節順序，短整型 */
? ?my_addr.sin_port = htons(MYPORT) ;
? ?/* 自動賦值為自己的IP */
? ?my_addr.sin_addr.s_addr = INADDR_ANY ;
? ?/* 將結構中未使用部分全部清零 */
? ?bzero(&(my_addr.sin_zero), 8) ;
? ?/* 不要忘記在你自己的程序中下面的程序調用需要進行錯誤檢測！！*/
? ?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()函數
/*
*
*??這兩個函數是最基本的，通過連接的套接字流進行通訊的函數
*??如果你想使用無連接的使用者數據報的話，請參sendto() 和recvfrom() 函數。
*
*??sockfd 是代表你與遠程程序連接的套接字描述符。
*??msg? ? 是一個指針，指向你想發送的信息的地址。
*??len? ? 是你想發送信息的長度
*??flags??發送標記。一般都設為0（你可以查看send 的man pages 來獲得其他的參數值并且明白各個參數所代表的含義）
*??
*??return??函數在調用后會返回它真正發送數據的長度
*? ?? ?? ? -1??如果發生錯誤，錯誤代碼存儲在全局變量errno
*
*/
#include
#include
int send(int sockfd, const void *msg, int len, int flags);
示例:
char *msg = "Hello! World! ";
int len, bytes_sent;
len = strlen(msg);
bytes_sent = send(sockfd, msg, len, 0);
注意：
? ?send() 所發送的數據可能少于你給它的參數所指定的長度！
? ?因為如果你給send()的參數中包含的數據的長度遠遠大于send()所能一次發送的數據，則send()函數只發送它所能發送的最大數據長度，然后它相信你會把剩下的數據再次調用它來進行第二次發送。
? ?所以，記住如果send()函數的返回值小于len 的話，則你需要再次發送剩下的數據。
? ?幸運的是，如果包足夠小（小于1K），那么send()一般都會一次發送光的。
recv()函數
/*
*
*??sockfd??是你要讀取數據的套接字描述符
*??buf? ???是一個指針，指向你能存儲數據的內存緩存區域
*??len? ???是緩存區的最大尺寸
*??flags? ?是recv() 函數的一個標志，一般都為0 （具體的其他數值和含義請參考recv()的man pages）
*
*
*??返回? ? 它所真正收到的數據的長度（也就是存到buf 中數據的長度）
*
*? ?? ?? ? -1? ? 則代表發生了錯誤（比如網絡以外中斷、對方關閉了套接字連接等），全局變量errno 里面存儲了錯誤代碼
*/
#include
#include
int recv(int sockfd, void *buf, int len, unsigned int flags）;
sendto() 和recvfrom() 函數
/*
* 這兩個函數是進行無連接的UDP 通訊時使用的。
* 使用這兩個函數，則數據會在沒有建立過任何連接的網絡上傳輸。因為數據報套接字無法對遠程主機進行連接
*
* sockfd??是代表你與遠程程序連接的套接字描述符
* msg? ???是一個指針，指向你想發送的信息的地址
* len? ???是你想發送信息的長度
* flags? ?發送標記。一般都設為0 (你可以查看send 的man pages 來獲得其他的參數值并且明白各個參數所代表的含義)
* to? ?? ?是一個指向struct sockaddr 結構的指針，里面包含了遠程主機的IP 地址和端口數據
* tolen? ?只是指出了struct sockaddr 在內存中的大小sizeof(struct sockaddr)
*
* return??sendto()返回它所真正發送的字節數（當然也和send()一樣，它所真正發送的字節數可能小于你所給它的數據的字節數）
*? ?? ?? ?-1 表示出錯? ?同時全局變量errno 存儲了錯誤代碼
*/
#include
#include
int sendto(int sockfd, const void *msg, int len, unsigned int flags, const struct sockaddr *to, int tolen);
recvfrom()函數
/*
*
* sockfd??是你要讀取數據的套接字描述符
* buf? ???是一個指針，指向你能存儲數據的內存緩存區域
* len? ???是緩存區的最大尺寸
* flags? ?是recv() 函數的一個標志，一般都為0 （具體的其他數值和含義請參考recv()的man pages）
* from? ? 是一個本地指針，指向一個struct sockaddr 的結構（里面存有源IP 地址和端口數）
* fromlen 是一個指向一個int 型數據的指針，它的大小應該是sizeof (struct sockaddr)．當函數返回的時候，formlen 指向的數據是form 指向的struct sockaddr 的實際大小．
*? ?? ?? ?如果一個信息大得緩沖區都放不下，那么附加信息將被砍掉。該調用可以立即返回,也可以永久的等待。這取決于你把flags 設置成什么類型。你甚至可以設置超時(timeout)值。
*
*
* return??返回它接收到的字節數，如果發生了錯誤，它就返回–1 ，全局變量errno存儲了錯誤代碼
*
*/
#include
#include
int recvfrom(int sockfd, void *buf, int len, unsigned int flags, struct sockaddr *from, int *fromlen);
注意：
? ?如果你使用cnnect()連接到了一個數據報套接字的服務器程序上，那么你就可以使用send() 和recv() 函數來傳輸你的數據．
? ?不要以為你在使用一個流式的套接字，你所使用的仍然是一個使用者數據報的套接字，只不過套接字界面在send() 和recv()的時候自動幫助你加上了目標地址，目標端口的信息．
close()和shutdown()函數
/*
* 程序進行網絡傳輸完畢后，你需要關閉這個套接字描述符所表示的連接。實現這個非常簡單，只需要使用標準的關閉文件的函數：close()。
* 執行close()之后，套接字將不會在允許進行讀操作和寫操作。任何有關對套接字描述符進行讀和寫的操作都會接收到一個錯誤。
*
*/
close(sockfd);
/*
* 如果你想對網絡套接字的關閉進行進一步的操作的話，你可以使用函數shutdown()
* 它允許你進行單向的關閉操作，或是全部禁止掉。
*
* 如果你在一個未連接的數據報套接字上使用shutdown() 函數，它將什么也不做．
*
* sockfd 是一個你所想關閉的套接字描述符
* how 可以取下面的值。
*? ???0 表示不允許以后數據的接收操；
*? ???1 表示不允許以后數據的發送操作；
*? ???2 表示和close()一樣，不允許以后的任何操作（包括接收，發送數據）
*
* return??0 執行成功
*? ?? ???-1 執行失敗, 全局變量errno 中存儲了錯誤代碼．
*? ?
*/
#include
int shutdown(int sockfd, int how);
setsockopt() 和getsockopt() 函數
Linux 所提供的socket 庫含有一個錯誤（bug）。
??此錯誤表現為你不能為一個套接字重新啟用同一個端口號，即使在你正常關閉該套接字以后。
??例如，比方說，你編寫一個服務器在一個套接字上等待的程序．服務器打開套接字并在其上偵聽是沒有問題的。無論如何，總有一些原因（不管是正常還是非正常的結束程序）使你的程序需要重新啟動。然而重啟動后你就不能把它綁定在原來那個端口上了。從bind()系統調用返回的錯誤代碼總是報告說你試圖連接的端口已經被別的進程所綁定。
??問題就是Linux 內核在一個綁定套接字的進程結束后從不把端口標記為未用。在大多數Linux/UNIX 系統中，端口可以被一個進程重復使用，甚至可以被其它進程使用。
??在Linux 中繞開這個問題的辦法是，當套接字已經打開但尚未有連接的時候用setsockopt()系統調用在其上設定選項（options）。
??setsockopt() 調用設置選項而getsockopt()從給定的套接字取得選項。
這里是這些調用的語法：
/*
*
*
* sockfd 必須是一個已打開的套接字
* level 是函數所使用的協議標準（protocol level）（TCP/IP 協議使用IPPROTO_TCP，套接字標準的選項實用SOL_SOCKET）
* name 選項在套接字說明書中（man page）有詳細說明
* value 指向為getsockopt()函數所獲取的值，setsockopt()函數所設置的值的地址
* optlen 指針指向一個整數，該整數包含參數以字節計算的長度
*
*
*
*
*
*/
#include
#include
int getsockopt(int sockfd, int level, int name, char *value, int *optlen);
int setsockopt(int sockfd, int level, int name, char *value, int *optlen);
當你打開一個套接字時必須同時用下面的代碼段來調用setsockopt()函數：
/* 設定參數數值 */
opt = 1;
len = sizeof(opt);
/* 設置套接字屬性 */
setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&opt,&len);
getpeername()函數
/*
* 這個函數可以取得一個已經連接上的套接字的遠程信息（比如IP 地址和端口），告訴你在遠程和你連接的究竟是誰
*
* 當你擁有了遠程連接用戶的IP 地址，你就可以使用inet_ntoa() 或gethostbyaddr()來輸出信息或是做進一步的處理
*
* sockfd??是你想取得遠程信息的那個套接字描述符
* addr? ? 是一個指向struct sockaddr （或是struct sockaddr_in）的指針
* addrlen 是一個指向int 的指針，應該賦于sizeof(struct sockaddr)的大小
*
*
* return??錯誤，函數將返回 –1 ，并且錯誤代碼儲存在全局變量errno 中
*
*/
#include
int getpeername(int sockfd, struct sockaddr *addr, int *addrlen);
gethostname()函數
/*
* 可以取得本地主機的信息,它返回正在執行它的計算機的名字
* 返回的這個名字可以被gethostbyname()函數使用，由此可以得到本地主機的IP 地址
*
* hostname??是一個指向字符數組的指針，當函數返回的時候，它里面的數據就是本地的主機的名字
* size? ?? ?是hostname 指向的數組的長度
*
*
* return? ? 成功執行，它返回0
*? ?? ?? ???錯誤，則返回–1，全局變量errno 中存儲著錯誤代碼
*
*/
#include
int gethostname(char *hostname, size_t size);
gethostbyname()函數
/*
*
* 網絡地址是以網絡字節順序存儲的
*
*
* return? ? 成功則返回指向結構struct hostent的指針
*
? ?? ?? ?? ?#define h_addr h_addr_list[0]? ? //h_addr 是 h_addr_list 數組的第一個成員
? ?? ?? ?? ?struct hostent
? ?? ?? ?? ?{
? ?? ?? ?? ?? ?char *h_name;? ?? ? //是這個主機的正式名稱
? ?? ?? ?? ?? ?char **h_aliases;? ?//是一個以NULL（空字符）結尾的數組，里面存儲了主機的備用名稱
? ?? ?? ?? ?? ?int??h_addrtype;? ? //是返回地址的類型，一般來說是“AF_INET”
? ?? ?? ?? ?? ?int??h_length;? ?? ?//是地址的字節長度
? ?? ?? ?? ?? ?char **h_addr_list; //是一個以0 結尾的數組，存儲了主機的網絡地址
? ?? ?? ?? ?};
*
*
*? ?? ?? ???如果發生錯誤，它將會返回NULL（但是errno 并不代表錯誤代碼，h_errno 中存儲的才識錯誤代碼。參考下面的herror()函數
*/
struct hostent *gethostbyname(const char *name);
五種I/O 模式
----------------------------------------
在Linux/UNIX 下，有下面這五種I/O 操作方式：
? ?阻塞I/O
? ?非阻塞I/O
? ?I/O 多路復用
? ?信號驅動I/O（SIGIO）
? ?異步I/O
程序進行輸入操作有兩步：
? ?等待有數據可以讀
? ?將數據從系統內核中拷貝到程序的數據區。
對于一個對套接字的輸入操作:
? ???第一步一般來說是,等待數據從網絡上傳到本地,當數據包到達的時候，數據將會從網絡層拷貝到內核的緩存中；
? ???第二步是從內核中把數據拷貝到程序的數據區中
.阻塞I/O 模式
? ???簡單的說，阻塞就是＂睡眠＂的同義詞
? ?? ?? ?如你運行上面的listener 的時候，它只不過是簡單的在那里等待接收數據。它調用recvfrom()函數，但是那個時候（listener 調用recvfrom()函數的時候），它并沒有數據可以接收．所以recvfrom()函數阻塞在那里（也就是程序停在recvfrom()函數處睡大覺）直到有數據傳過來阻塞．你應該明白它的意思。
? ???阻塞I/O 模式是最普遍使用的I/O 模式。大部分程序使用的都是阻塞模式的I/O 。
? ???缺省的，一個套接字建立后所處于的模式就是阻塞I/O 模式。
? ???對于一個UDP 套接字來說，數據就緒的標志比較簡單：
? ?? ?? ?已經收到了一整個數據報
? ?? ?? ?沒有收到。
? ???而TCP 這個概念就比較復雜，需要附加一些其他的變量
? ?? ?? ?一個進程調用recvfrom ，然后系統調用并不返回知道有數據報到達本地系統，然后系統將數據拷貝到進程的緩存中。
? ?? ???（如果系統調用收到一個中斷信號，則它的調用會被中斷）我們稱這個進程在調用recvfrom 一直到從recvfrom 返回這段時間是阻塞的。
? ?? ?? ?當recvfrom正常返回時，我們的進程繼續它的操作。
.非阻塞模式I/O
? ? 當我們將一個套接字設置為非阻塞模式，我們相當于告訴了系統內核：“當我請求的I/O 操作不能夠馬上完成，你想讓我的進程進行休眠等待的時候，不要這么做，請馬上返回一個錯誤給我。”
? ?
? ? 如我們開始對recvfrom 的三次調用，因為系統還沒有接收到網絡數據，所以內核馬上返回一個EWOULDBLOCK的錯誤。
? ? 第四次我們調用recvfrom 函數，一個數據報已經到達了，內核將它拷貝到我們的應用程序的緩沖區中，然后recvfrom 正常返回，我們就可以對接收到的數據進行處理了。
??
? ? 當一個應用程序使用了非阻塞模式的套接字，它需要使用一個循環來不聽的測試是否一個文件描述符有數據可讀（稱做polling）。
? ? 應用程序不停的polling 內核來檢查是否I/O操作已經就緒。這將是一個極浪費CPU 資源的操作。這種模式使用中不是很普遍
.I/O 多路復用 select()
? ? 在使用I/O 多路技術的時候，我們調用select()函數和poll()函數，在調用它們的時候阻塞，而不是我們來調用recvfrom（或recv）的時候阻塞。
? ? 當我們調用select 函數阻塞的時候，select 函數等待數據報套接字進入讀就緒狀態。當select 函數返回的時候，也就是套接字可以讀取數據的時候。這時候我們就可以調用recvfrom函數來將數據拷貝到我們的程序緩沖區中。
? ? 和阻塞模式相比較，select()和poll()并沒有什么高級的地方，而且，在阻塞模式下只需要調用一個函數：讀取或發送，在使用了多路復用技術后，我們需要調用兩個函數了：先調用select()函數或poll()函數，然后才能進行真正的讀寫。
? ?
? ? 多路復用的高級之處在于，它能同時等待多個文件描述符，而這些文件描述符（套接字描述符）其中的任意一個進入讀就緒狀態，select()函數就可以返回
? ? 假設我們運行一個網絡客戶端程序，要同時處理套接字傳來的網絡數據又要處理本地的標準輸入輸出。在我們的程序處于阻塞狀態等待標準輸入的數據的時候，假如服務器端的程序被kill（或是自己Down 掉了），那么服務器程端的TCP 協議會給客戶端（我們這端）的TCP 協議發送一個FIN 數據代表終止連接。但是我們的程序阻塞在等待標準輸入的數據上，在它讀取套接字數據之前（也許是很長一段時間），它不會看見結束標志．我們就不能夠使用阻塞模式的套接字。
? ? I/O多路技術一般在下面這些情況中被使用：
? ?? ? 當一個客戶端需要同時處理多個文件描述符的輸入輸出操作的時候（一般來說是標準的輸入輸出和網絡套接字）， I/O 多路復用技術將會有機會得到使用。
? ?? ? 當程序需要同時進行多個套接字的操作的時候。
? ?? ? 如果一個TCP 服務器程序同時處理正在偵聽網絡連接的套接字和已經連接好的套接字。
? ?? ? 如果一個服務器程序同時使用TCP 和UDP 協議。
? ?? ? 如果一個服務器同時使用多種服務并且每種服務可能使用不同的協議（比如inetd就是這樣的）。
??
? ? I/O 多路服用技術并不只局限與網絡程序應用上。幾乎所有的程序都可以找到應用I/O多路復用的地方。
fcntl()函數
? ???簡單的說，阻塞就是＂睡眠＂的同義詞.
? ???如你運行上面的listener 的時候，它只不過是簡單的在那里等待接收數據。它調用recvfrom()函數，但是那個時候（listener 調用recvfrom()函數的時候），它并沒有數據可以接收．所以recvfrom()函數阻塞在那里（也就是程序停在recvfrom()函數處睡大覺）直到有數據傳過來阻塞．你應該明白它的意思。
? ???當你一開始建立一個套接字描述符的時候，系統內核就被設置為阻塞狀態。如果你不想你的套接字描述符是處于阻塞狀態的，那么你可以使用函數fcntl()。
? ???#include
? ???#include
? ???int fcntl (int fd, int cmd, long arg）;
示例:
? ???sockfd = socket（AF_INET, SOCK_STREAM, 0）;
? ???fcntl（sockfd, F_SETFL, O_NONBLOCK）;
? ???這樣將一個套接字設置為無阻塞模式后，你可以對套接字描述符進行有效的“檢測”．
? ???如果你嘗試從一個沒有接收到任何數據的無阻塞模式的套接字描述符那里讀取數據，那么讀取函數會馬上返回–1 代表發生錯誤，全局變量errno 中的值為EWOULDBLOCK。
? ???一般來說，這種無阻塞模式在某些情況下不是一個好的選擇。假如你的程序一直沒有接收到傳過來的數據，那么你的程序就會進行不停的循環來檢查是否有數據到來，浪費了大量的CPU 時間，而這些CPU 時間本來可以做其他事情的。
? ???另外一個比較好的檢測套接字描述符的方法是調用select()函數
套接字選擇項select()函數
/*
*
*??這個技術有一點點奇怪但是它對我們的程序確是非常有用的。
*??假想一下下面的情況：
*? ?? ?你寫的服務器程序想監聽客戶端的連接，但是你同時又想從你以前已經建立過的連接中來讀取數據。
*??你可能會說：“沒有問題，我不就是需要使用一個accept()函數和一對兒recv()函數嗎？”。
*??不要這么著急，你要想想，當你調用accept()函數阻塞的時候，你還能調用recv()函數嗎？
*??“使用非阻塞套接字！”你可能會這么說。是的，你可以。但是如果你又不想浪費寶貴的CPU 時間，該怎么辦呢？
*??Select()函數可以幫助你同時監視許多套接字。它會告訴你哪一個套接字已經可以讀取數據，
*??哪個套接字已經可以寫入數據，甚至你可以知道哪個套接字出現了錯誤，如果你想知道的話。
*
*??
*
* 當select()函數返回的時候，readfds 將會被修改用來告訴你哪一個文件描述符你可以用來讀取數據。
*
* numfds? ?? ?? ?是readfds，writefds，exceptfds 中fd 集合中文件描述符中最大的數字加上1 也就是sockfd+1（因為標準輸入的文件描述符的值為0 ，所以其他任何的文件描述符都會比標準輸入的文件描述符大）。
*
* readfds? ?? ???中的fd 集合將由select 來監視是否可以讀取,如果你想知道是是否可以從標準輸入和一些套接字（sockfd）中讀取數據，你就可以把文件描述符和sockfd 加入readfds 中。
* writefds? ?? ? 中的fds 集合將由select 來監視是否可以寫入
* exceptfds? ?? ?中的fds 集合將由select 來監視是否有例外發生
* struct timeval 超時設置。
*? ?? ?? ?? ?? ?? ???一般來說，如果沒有任何文件描述符滿足你的要求，你的程序是不想永遠等下去的．也許每隔1 分鐘你就想在屏幕上輸出信息：“hello！”。
*? ?? ?? ?? ?? ? 這個代表時間的結構將允許你定義一個超時。
*? ?? ?? ?? ?? ? 在調用select()函數中，如果時間超過timeval 參數所代表的時間長度，
*? ?? ?? ?? ?? ? 而還沒有文件描述符滿足你的要求，那么select()函數將回返回，允許你進行下面的操作。
*? ?? ?? ?? ?? ? 只需要將tv_sec 設置為你想等待的秒數，然后設置tv_usec 為想等待的微秒數
*? ?? ?? ?? ?? ? (真正的時間就是tv_sec 所表示的秒數加上tv_usec 所表示的微秒數）．注意，是微秒（百萬分之一）而不是毫秒．
*? ?? ?? ?? ?? ? 一秒有1,000 毫秒，一毫秒有1,000 微秒。所以，一秒有1,000,000 微秒．
*? ?? ?? ?? ?? ? 這個timeval 結構定義如下：
*? ?? ?? ?? ?? ? struct timeval
*? ?? ?? ?? ?? ? {
*? ?? ?? ?? ?? ?? ???int tv_sec ;? ?//秒數
*? ?? ?? ?? ?? ?? ???int tv_usec ;??//微秒
*? ?? ?? ?? ?? ? };
*? ?? ?? ?? ?? ? 我們擁有了一個以微秒為單位的記時器！但是因為Linux 和UNIX 一樣，最小的時間片是100 微秒，所以不管你將tv_usec 設置的多小，實質上記時器的最小單位是100微秒．
*
*? ?? ?? ?? ?? ? 如果你將struct timeval 設置為0，則select()函數將會立即返回，同時返回在你的集合中的文件描述符的狀態。
*
*? ?? ?? ?? ?? ? 如果你將timeout 這個參數設置為NULL，則select()函數進入阻塞狀態，除了等待到文件描述符的狀態變化，否則select()函數不會返回。
*
*
* return? ?? ???當select()函數返回的時候，timeval 中的時間將會被設置為執行為select()后還剩下的時間。
*
*
*
*/
#include
#include
#include
int select(int numfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
使用FD_ISSET() 宏，你可以選出select()函數執行的結果。
在進行更深的操作前，我們來看一看怎樣處理這些fd_sets。下面這些宏可以是專門進行這類操作的：
??FD_ZERO(fd_set *set)? ?? ?? ???將一個文件描述符集合清零
??FD_SET(int fd, fd_set *set)? ? 將文件描述符fd 加入集合set 中。
??FD_CLR(int fd, fd_set *set)? ? 將文件描述符fd 從集合set 中刪除．
??FD_ISSET(int fd, fd_set *set)??測試文件描述符fd 是否存在于文件描述符set 中．
下面這段代碼演示了從標準輸入等待輸入等待2.5 秒．
#include
#include
#include
/* 標準輸入的文件描述符數值 */
#define STDIN 0
main()
{
? ?fd_set readfds;
? ?struct timeval tv;
? ?/* 設置等待時間為2 秒零500,000 微秒 */
? ?tv.tv_sec??= 2;
? ?tv.tv_usec = 500000;
? ?FD_ZERO(&readfds);
? ?FD_SET(STDIN, &readfds);
? ?/* 因為我們只想等待輸入，所以將writefds 和execeptfds 設為NULL */
? ?/* 程序將會在這里等待2 秒零500,000 微秒，除非在這段時間中標準輸入有操作 */
? ?select(STDIN+1, &readfds, NULL, NULL, &tv);
? ?/* 測試STDIN 是否在readfds 集合中 */
? ?if (FD_ISSET(STDIN, &readfds))
? ?{
? ?? ?/* 在，則在標準輸入有輸入 */
? ?? ?printf(“A key was pressed!\n”);
? ?}
? ?else
? ?{
? ?? ?/* 不在，則在標準輸入沒有任何輸入 */
? ?? ?printf(“Timed out.\n”);
? ?}
}
在標準輸入上，你需要輸入回車后終端才會將輸入的信息傳給你的程序。所以如果你沒有輸入回車的話，程序會一直等待到超時。
對select()函數需要注意的最后一點：如果你的套接字描述符正在通過listen()函數偵聽等待一個外來的網絡連接，則你可以使用select()函數（將套接字描述符加入readfds 集合中）來測試是否存在一個未經處理的新連接
DIN 是否在readfds 集合中 */
? ?if (FD_ISSET(STDIN, &readfds))
? ?{
? ?? ?/* 在，則在標準輸入有輸入 */
? ?? ?printf(“A key was pressed!\n”);
? ?}
? ?else
? ?{
? ?? ?/* 不在，則在標準輸入沒有任何輸入 */
? ?? ?printf(“Timed out.\n”);
? ?}
}
在標準輸入上，你需要輸入回車后終端才會將輸入的信息傳給你的程序。所以如果你沒有輸入回車的話，程序會一直等待到超時。
對select()函數需要注意的最后一點：如果你的套接字描述符正在通過listen()函數偵聽等待一個外來的網絡連接，則你可以使用select()函數（將套接字描述符加入readfds 集合中）來測試是否存在一個未經處理的新連接
的使用)
