界
传说中的水手
 
UID 19851
精华
0
积分 1296
帖子 1296
阅读权限 1
注册 2002-4-17
状态 离线
|
[求助]请问哪里有下载纯C的SOCKET编程电子书籍？
很久以前我用过，以前我在这里推荐过连接的，现在都失效了。
windows上的和unix上的不太一样。
windows的你应该可以在msdn里面找到。电子版的我也有，你要的话我mail给你
这个是一个unix的
Beej`s_网络编程指南
Internet_Sockets
Version_1.5.5_(13-Jan-1999)
原著：Brian_"Beej"_Hall
翻译：Wilbur_Lang
介绍
Hey!_Socket_编程让你沮丧吗？从_man_pages_中很难得到有用的信息吗？你想跟上时代去做一做_Internet_
程序，但是为你在调用_connect()_前的_bind()_的结构而愁眉不展？…_好了，我现在已经来了，我将和所
有人共享我的知识了。如果你了解_C_语言并想穿过网络编程的沼泽，那么你来对地方了。_
--------------------------------------------------------------------------------
读者
这个文档是写成一个指南，而不是参考书。如果你刚开始_socket_编程并想找一本入门书，那么你是我的读
者。这可不是一本完全的_socket_编程书。_
--------------------------------------------------------------------------------
平台和编译器
这篇文章中的大多数代码都在一台_Linux_PC_上用_GNU_的_gcc_成功编译过。而且他们在一台_HPUX_上用
gcc_也成功编译过。但是注意，并不是每个代码片段都X$%@X测试过。_
--------------------------------------------------------------------------------
目录：
什么是套接口？_
Internet_套接口的两种类型_
网络理论_
struct--要么了解他们，要么等异形入侵地球_
Convert_the_Natives!_
IP_地址和如何处理他们_
socket()--得到文件描述符！_
bind()--我们在哪个端口？_
connect()--Hello！_
listen()--有人给我打电话吗？_
accept()--"Thank_you_for_calling_port_3490."_
send()_和_recv()--Talk_to_me, baby!_
sendto()_和_recvfrom()--Talk_to_me, DGRAM-style_
close()_和_shutdown()--滚开！_
getpeername()--你是谁？_
gethostname()--我是谁？_
DNS--你说“白宫”，我说_"198.137.240.100"_
客户-服务器背景知识_
简单的服务器_
简单的客户端_
数据报_Socket_
阻塞_
select()--多路同步_I/O，酷！_
参考资料_
Disclaimer_and_Call_for_Help_
--------------------------------------------------------------------------------
什么是_socket？
你始终听到人们谈论着_"socket"，而你不知道他的确切含义。那么，现在我告诉你：他是使用_Unix_文件描
述符_(fiel_descriptor)_和其他程序通讯的方式。_
什么？_
Ok--你也许听到一些_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_套接口？是的。不，我在撒谎。其实还有很多，但是我可不想吓着你。我们这里
只讲两种。_除此之处, 还有一种“原始套接口”也是高效的，并且你应该查到它们。好了，好了。那两种类
型是什么呢？一种是_"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。这一点在实现
SOCK_DGRAM_应用程序的时候非常重要。_
--------------------------------------------------------------------------------
网络理论
既然我刚才提到了协议层，那么现在是讨论网络究竟如何工作和演示_SOCK_DGRAM_的工作。当然，你也可以跳
过这一段，如果你认为已经熟悉的话。_
朋友们，现在是学习_数据封装_(Data_Encapsulation)_的时候了！这对于你刚刚学习网络编程是非常重要的。
;-).主要的内容是：一个包，先是被第一个协议(在这里是_TFTP_)包装(“封装”)，然后，整个数据(包括_
TFTP_头)被另外一个协议(在这里是_UDP_)封装，然后下一个(_IP_)，一直重复下去，直到硬件(物理)层
(_Ethernet_)。当另外一台机器接收到包，硬件先剥去_Ethernet_头，内核剥去_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。如果你从来不曾了解他，也没有关系，你还活着不是吗。_
--------------------------------------------------------------------------------
structs
终于到达这里了，终于谈到编程了。在这章，我将谈到被套接口用到的各种数据类型。因为他们中的一些太重
要了。_
首先是简单的一个：socket_descriptor。他是下面的类型：_
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];_/*_与struct_sockaddr一样的长度_*/
};
这个数据结构让可以轻松处理套接口地址的基本元素。注意_sin_zero_(他被加入到这个结构，并且长度和
struct_sockaddr_一样)_应该使用函数_bzero()_或_memset()_来全部置零。_Also, and_this_is_the_
important_bit, a_pointer_to_a_struct_sockaddr_in_can_be_cast_to_a_pointer_to_a_struct_sockaddr_
and_vice-versa.这样的话即使_socket()_想要的是_struct_sockaddr_*，你仍然可以使用_struct_
sockaddr_in，and_cast_it_at_the_last_minute!_同时，注意_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_address_(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_地址是和上面我说的一样(这是因为_#define。)
--------------------------------------------------------------------------------
Convert_the_Natives!
我们现在到达下个章节。我们曾经讲了很多网络到本机字节顺序，现在是采取行动的时刻了！_
你能够转换两种类型：_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_地址。没有必要用手工计算他们，也没有必要用
＜＜_操作符来操作_long。_
首先，假设你用_struct_sockaddr_in_ina，你想将_IP_地址_"132.241.5.10"_储存到其中。你要用的函数是_
inet_addr()，转换_numbers-and-dots_格式的_IP_地址到_unsigned_long。这个工作可以这样来做：_
ina.sin_addr.s_addr_=_inet_addr("132.241.5.10");
注意：inet_addr()_返回的地址已经是按照网络字节顺序的，你没有必要再去调用_htonl()。_
上面的代码可不是很健壮_(robust)，因为没有错误检查。inet_addr()_在发生错误的时候返回-1。记得二进
制数吗?_在_IP_地址为_255.255.255.255_的时候返回的是_(unsigned)-1！这是个广播地址！记住正确的使用
错误检查。_
好了，你现在可以转换字符串形式的_IP_地址为_long_了。那么你有一个数据结构_struct_in_addr，该如何
按照_numbers-and-dots_格式打印呢?_在这个时候，也许你要用函数_inet_ntoa()_("ntoa"_意思是_
"network_to_ascii")：_
printf("%s",inet_ntoa(ina.sin_addr));
他将打印_IP_地址。注意的是：函数_inet_ntoa()_的参数是_struct_in_addr，而不是_long。同时要注意的
是他返回的是一个指向字符的指针。在_inet_ntoa_内部的指针静态地储存字符数组，因此每次你调用_
inet_ntoa()_的时候他将覆盖以前的内容。例如：_
char_*a1, *a2;
.
.
a1_=_inet_ntoa(ina1.sin_addr);_/*_this_is_198.92.129.1_*/
a2_=_inet_ntoa(ina2.sin_addr);_/*_this_is_132.241.5.10_*/
printf("address_1:_%s/n",a1);
printf("address_2:_%s/n",a2);
运行结果是：_
address_1:_132.241.5.10
address_2:_132.241.5.10
如果你想保存地址，那么用_strcpy()_保存到自己的字符数组中。_
这就是这章的内容了。以后，我们将学习转换_"whitehouse.gov"_形式的字符串到正确的_IP_地址(请看后面
的_DNS_一章。)_
--------------------------------------------------------------------------------
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_page。当然，还有
一个"更好"的方式去得到_protocol。请看_getprotobyname()_的_man_page。)_
socket()_只是返回你以后在系统调用种可能用到的_socket_描述符，或者在错误的时候返回-1。全局变量_
errno_中储存错误值。(请参考_perror()_的_man_page。)_
--------------------------------------------------------------------------------
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;_/*_主机字节序_*/
my_addr.sin_port_=_htons(MYPORT);_/*_short, 网络字节序_*/
my_addr.sin_addr.s_addr_=_inet_addr("132.241.5.10");
bzero(&(my_addr.sin_zero), 8);_/*_zero_the_rest_of_the_struct_*/
/*_不要忘了为bind()做错误检查:_*/
bind(sockfd, (struct_sockaddr_*)&my_addr, sizeof(struct_sockaddr));
.
.
.
这里也有要注意的几件事情。my_addr.sin_port_是网络字节顺序，my_addr.sin_addr.s_addr_也是的。另外
要注意到的事情是因系统的不同，包含的头文件也不尽相同，请查阅自己的_man_page。_
在_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。但是完美主义者说安全第一，那么看
下面的代码：_
my_addr.sin_port_=_htons(0);_/*_随机地选择一个没有使用的端口*/
my_addr.sin_addr.s_addr_=_htonl(INADDR_ANY);_/*_使用当前机器的IP地址_*/
你可能不相信，上面的代码将可以随便移植。_
bind()_在错误的时候依然是返回-1，并且设置全局变量_errno。_
在你调用_bind()_的时候，你要小心的另一件事情是：不要采用小于1024的端口号。所有小于1024的端口号都
被系统保留！你可以选择从1024到65535(如果他们没有被别的程序使用的话)。_
你要注意的另外一件小事是：有时候你根本不需要调用他。如果你使用_connect()_来和远程机器通讯，你不
要关心你的本地端口号(就象你在使用_telnet_的时候)，你只要简单的调用_connect()_就够可，他会检查套
接口是否绑定，如果没有，他会自己绑定一个没有使用的本地端口。_
--------------------------------------------------------------------------------
connect()--Hello！
现在我们假设你是个_telnet_程序。你的用户命令你(就象电影_TRON_中一样)得到套接口的文件描述符。你听
从命令调用了_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;_/*_主机字节序_*/
dest_addr.sin_port_=_htons(DEST_PORT);_/*_short, 网络字节序_*/
dest_addr.sin_addr.s_addr_=_inet_addr(DEST_IP);
bzero(&(dest_addr.sin_zero), 8);_/*_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()--嗯，有事请call我?
好, 这次是一个改变.即使你不想立即联接到一个远程主机.你可以用其它方法等待接受联接并且处理它们.
处理过程分两步：首先，你听--listen()，然后，你接受--accept()_(请看下面的内容)。_
除了要一点解释外，系统调用_listen_相当简单。_
int_listen(int_sockfd, int_backlog);
sockfd_是调用_socket()_返回的套接口文件描述符。backlog_是在进入队列中允许的连接数目。是什么意思
呢?_进入的连接是在队列中一直等待直到你接受_(accept()_请看下面的文章)的连接。他们的数目限制于队列
的允许。大多数系统的允许数目是20，你也可以设置为5到10。_
和别的函数一样，在发生错误的时候返回-1，并设置全局变量_errno。_
你可能想象到了，在你调用_listen()_前你或者要调用_bind()_或者让内核随便选择一个端口。如果你想侦听
进入的连接，那么系统调用的顺序可能是这样的：_
socket();
bind();
listen();
/*_accept()_goes_here_*/
因为他相当的明了，我将在这里不给出例子了。(在_accept()_那一章的代码将更加完全。)真正麻烦的部分在
accept()。_
--------------------------------------------------------------------------------
accept()--"Thank_you_for_calling_port_3490."
准备好了，系统调用_accept()_会有点古怪的地方的！你可以想象发生这样的事情：有人从很远的地方通过一
个你在侦听_(listen())_的端口连接_(connect())_到你的机器。他的连接将加入到等待接受_(accept())_的
队列中。你调用_accept()_告诉他你有空闲的连接。他将返回一个新的套接口文件描述符！原来的一个还在侦
听你的那个端口，新的最后在准备发送_(send())_和接收_(_recv())_数据。这就是这个过程！_
函数是这样定义的：_
#include_＜sys/socket.h>_
int_accept(int_sockfd, void_*addr, int_*addrlen);
sockfd_相当简单，是和_listen()_中一样的套接口描述符。addr_是个指向局部的数据结构_struct_
sockaddr_in_的指针。这是关于接受联接的信息的地方(并且你能确定是哪一台主机的哪一个端口在call你).
在他的地址传递给_accept_之前，addrlen_是个局部的整形变量，设置为_sizeof(struct_sockaddr_in)。
accept_将不会将多余的字节给_addr。如果你放入的少些，那么在_addrlen_的值中反映出来。_
同样，在错误时返回-1并设置全局变量_errno。_
现在是你应该熟悉的代码片段。_
#include_＜string.h>_
#include_＜sys/types.h>_
#include_＜sys/socket.h>_
#define_MYPORT_3490_/*_用户将联接到这个端口*/
#define_BACKLOG_10_/*_保存未联接队列的数量_*/
main()
{
int_sockfd, new_fd;_/*_在sock_fd上监听, 在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);_/*_short, 网络字节序_*/
my_addr.sin_addr.s_addr_=_INADDR_ANY;_/*_自动用我的主机地址填充_*/
bzero(&(my_addr.sin_zero), 8);_/*_zero_the_rest_of_the_struct_*/
/*_不要忘了为这些调用做一些错误检查_*/
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()_中你应该使用新的文件描述符。如果你只想让一个连接进来，那么你可
以使用_close()_去关闭原来的文件描述符_sockfd_来避免同一个端口更多的连接。_
--------------------------------------------------------------------------------
send()_and_recv()--Talk_to_me, baby!
这两个函数用于流式套接口和数据报套接口的通讯。如果你喜欢使用无连接的数据报套接口，你应该看一看下
面关于_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()--Talk_to_me, DGRAM-style
"这很不错啊"，我听到你说，"但是你还没有讲无连接数据报套接口呢。"没问题，现在我们开始这个内容。_
既然数据报套接口不是连接到远程主机的，那么在我们发送一个包之前需要什么信息呢?_不错，是目标地址！
看看下面的：_
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()--Get_outta_my_face!
你已经整天都在发送_(send())_和接收_(recv())_数据了，现在你准备关闭你的套接口描述符了。这很简单，
你可以使用一般的_Unix_文件描述符的_close()_函数：_
close(sockfd);
他将防止套接口上更多的数据的读写。任何在另一端读写套接口的企图都将返回错误信息。_
如果你想在如何关闭套接口上有多一点的控制，你可以使用函数_shutdown()。他能够让你将一定方向的通讯
或者双向的通讯(就象_close()_一样)关闭，你可以使用：_
int_shutdown(int_sockfd, int_how);
sockfd_是你想要关闭的套接口文件描述复。how_的值是下面的其中之一：_
0_-_Further_receives_are_disallowed_
1_-_Further_sends_are_disallowed_
2_-_Further_sends_and_receives_are_disallowed_(和_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--You_say_"whitehouse.gov", I_say_"198.137.240.100"
如果你不知道_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_-_以0结束的数组标识的主机网络地址.主机地址是网络字节序.
h_addr_-_在h_addr_list中的第一个地址.
gethostbyname()_成功时返回一个指向_struct_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_address/n");
exit(1);
}
if_((h=gethostbyname(argv[1]))_==_NULL)_{_/*_获取主机信息_*/
herror("gethostbyname");
exit(1);
}
printf("Host_name_:_%s/n", h->h_name);
printf("IP_Address_:_%s/n",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_说明了客户和服务器之间的信息交换。_
注意，客户--服务器之间可以使用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;_/*_在sock_fd上监听, 在new_fd上建立新的联接_*/
struct_sockaddr_in_my_addr;_/*_我的地址信息_*/
struct_sockaddr_in_their_addr;_/*_联接者的地址信息_*/
int_sin_size;
if_((sockfd_=_socket(AF_INET, SOCK_STREAM, 0))_==_-1)_{
perror("socket");
exit(1);
}
my_addr.sin_family_=_AF_INET;_/*_主机字节序_*/
my_addr.sin_port_=_htons(MYPORT);_/*_short, 网络字节序*/
my_addr.sin_addr.s_addr_=_INADDR_ANY;_/*_自动用主机的IP地址进行填充*/
bzero(&(my_addr.sin_zero), 8);_/*_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)_{_/*_主accept()循环_*/
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_%s/n", /
inet_ntoa(their_addr.sin_addr));
if_(!fork())_{_/*子进程*/
if_(send(new_fd, "Hello, world!/n", 14, 0)_==_-1)
perror("send");
close(new_fd);
exit(0);
}
close(new_fd);_/*_父进程不要这样做_*/
while(waitpid(-1,NULL,WNOHANG)_>_0);_/*_清除子进程_*/
}
}
如果你很挑剔的话，一定不满意我所有的代码都在一个很大的_main()_函数中。如果你不喜欢，可以划分得更
细点。_
你也可以用我们下一章中的程序得到服务器端发送的字符串。_
--------------------------------------------------------------------------------
简单的客户程序
这个程序比服务器还简单。这个程序的所有工作是通过_3490_端口连接到命令行中制定的主机，然后得到服务
器的字符串。_
客户代码:_
#include_＜stdio.h>_
#include_＜stdlib.h>_
#include_＜errno.h>_
#include_＜string.h>_
#include_＜netdb.h>_
#include_＜sys/types.h>_
#include_＜netinet/in.h>_
#include_＜sys/socket.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;_/*_联接者地址信息_*/
if_(argc_!=_2)_{
fprintf(stderr,"usage:_client_hostname/n");
exit(1);
}
if_((he=gethostbyname(argv[1]))_==_NULL)_{_/*_获取主机信息_*/
herror("gethostbyname");
exit(1);
}
if_((sockfd_=_socket(AF_INET, SOCK_STREAM, 0))_==_-1)_{
perror("socket");
exit(1);
}
their_addr.sin_family_=_AF_INET;_/*_主机字节序_*/
their_addr.sin_port_=_htons(PORT);_/*_short, 网络字节序_*/
their_addr.sin_addr_=_*((struct_in_addr_*)he->h_addr);
bzero(&(their_addr.sin_zero), 8);_/*_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]_=_`/0`;
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_/*_用户将发送到这个端口_*/
#define_MAXBUFLEN_100
main()
{
int_sockfd;
struct_sockaddr_in_my_addr;_/*_我的地址信息_*/
struct_sockaddr_in_their_addr;_/*_联接者的地址信息_*/
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;_/*_主机字节序_*/
my_addr.sin_port_=_htons(MYPORT);_/*_short, 网络字节序_*/
my_addr.sin_addr.s_addr_=_INADDR_ANY;_/*_自动用主机IP地址进行填充_*/
bzero(&(my_addr.sin_zero), 8);_/*_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_%s/n",inet_ntoa(their_addr.sin_addr));
printf("packet_is_%d_bytes_long/n",numbytes);
buf[numbytes]_=_`/0`;
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_＜netdb.h>_
#include_＜sys/socket.h>_
#include_＜sys/wait.h>_
#define_MYPORT_4950_/*_用户将发送到这个端口_*/
int_main(int_argc, char_*argv[])
{
int_sockfd;
struct_sockaddr_in_their_addr;_/*_联接者的地址信息_*/
struct_hostent_*he;
int_numbytes;
if_(argc_!=_3)_{
fprintf(stderr,"usage:_talker_hostname_message/n");
exit(1);
}
if_((he=gethostbyname(argv[1]))_==_NULL)_{_/*_获取主机信息_*/
herror("gethostbyname");
exit(1);
}
if_((sockfd_=_socket(AF_INET, SOCK_DGRAM, 0))_==_-1)_{
perror("socket");
exit(1);
}
their_addr.sin_family_=_AF_INET;_/*_主机字节序_*/
their_addr.sin_port_=_htons(MYPORT);_/*_short, 网络字节序_*/
their_addr.sin_addr_=_*((struct_in_addr_*)he->h_addr);
bzero(&(their_addr.sin_zero), 8);_/*_对结构赋0值_*/
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_%s/n",numbytes,inet_ntoa(their_addr.sin_addr));
close(sockfd);
return_0;
}
这就是所有的了。在一台机器上运行_listener，然后在另外一台机器上运行_talker。观察他们的通讯！_
这些细小的详细信息我在这一部分提到了多次:_用数据报套接口联接.自从我们在这本资料的数据报一节讲述
以来，我还要在这里讨论它。_程序调用connect()并且指定监听者的地址.在这个基础上,talker可能发送并
且接收来自用connect()调用指定的地址.由于这个原因, 你不得不用sendto()_和_recvfrom();_你也可以用
简单的send()和recv().
--------------------------------------------------------------------------------
阻塞
阻塞，你也许早就听说了。"阻塞"是_"sleep"_的科技行话。你可能注意到前面运行的_listener_程序，他在
那里不停地运行，等待数据包的到来。实际在运行的是他调用_recvfrom()，然后没有数据，因此_recvfrom()
说"阻塞_(block)"_直到数据的到来。_
很多函数都利用阻塞。accept()_阻塞，所有的_recv*()_函数阻塞。他们之所以能这样做是因为他们被允许这
样做。当你第一次调用_socket()_建立套接口描述符的时候，内核就将他设置为阻塞。如果你不想套接口阻塞，
你就要调用函数_fcntl()：_
#include_＜unistd.h>_
#include_＜fcntl.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()_要讲的所有的东西。_
--------------------------------------------------------------------------------
更多的参考资料
试一下下面的man手册:_
socket()_
bind()_
connect()_
listen()_
accept()_
send()_
recv()_
sendto()_
recvfrom()_
close()_
shutdown()_
getpeername()_
getsockname()_
gethostbyname()_
gethostbyaddr()_
getprotobyname()_
fcntl()_
select()_
perror()_
同样, 查找下面的书:
《Internetworking_with_TCP/IP, volumes_I-III》_by_Douglas_E.Comer_and_David_L.Stevens.Published_
by_Prentice_Hall.Second_edition_ISBNs:_0-13-468505-9, 0-13-472242-6, 0-13-474222-2.
这是这套书的第三版.
《Using_C_on_the_UNIX_System》_by_David_A.Curry.Published_by_O`Reilly_&_Associates, Inc.
ISBN_0-937175-23-4.
《TCP/IP_Network_Administration》_by_Craig_Hunt.Published_by_O`Reilly_&_Associates, Inc.
ISBN_0-937175-82-X.
《TCP/IP_Illustrated, volumes_1-3》_by_W.Richard_Stevens_and_Gary_R.Wright.Published_by_Addison_
Wesley.ISBNs:_0-201-63346-9, 0-201-63354-X, 0-201-63495-3.
《Unix_Network_Programming_by》_W.Richard_Stevens.Published_by_Prentice_Hall.
ISBN_0-13-949876-1.
--------------------------------------------------------------------------------
|
|
