欧美日韩一区二区三区四区五区,欧美一区免费,欧美黄色大片网站

epoll实现的net_echo�E�序

Sat, 08 Sep 2007 12:49:00 GMT

摘要: �q�是我前两天所做的一个小�l�习�Q�用epoll写个echo�E�序�Q�里面用�׃�n内存存储讉K��信息�Q�脓在这里，哪天生疏了还可以�q�来查查~~ 更多内容误��问： http://lmlf001.blog.sohu.com/ Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter... 阅读全文

芥之�?/a> 2007-09-08 20:49 发表评论

Thu, 27 Apr 2006 05:12:00 GMT

Linux�|�络�~�程--8. 套接字选项

http://linuxc.51.net 作�?hoyt

有时候我们要控制套接字的行�ؓ(如修改缓冲区的大��?,�q�个时候我们就要控制套接字的选项�?

8.1 getsockopt和setsockopt

int getsockopt(int sockfd,int level,int optname,void *optval,socklen_t *optlen)
int setsockopt(int sockfd,int level,int optname,const void *optval,socklen_t *optlen)

level指定控制套接字的层次.可以取三�U��? 1)SOL_SOCKET:通用套接字选项. 2)IPPROTO_IP:IP选项. 3)IPPROTO_TCP:TCP选项.
optname指定控制的方�?选项的名�U?,我们下面详细解释

optval获得或者是讄��套接字选项.�Ҏ��选项名称的数据类型进行�{�?

选项名称说明数据�c�d��
========================================================================
SOL_SOCKET
------------------------------------------------------------------------
SO_BROADCAST 允许发送广播数�? int
SO_DEBUG 允许调试 int
SO_DONTROUTE 不查找�\�? int
SO_ERROR 获得套接字错�? int
SO_KEEPALIVE 保持�q�接 int
SO_LINGER 延迟关闭�q�接 struct linger
SO_OOBINLINE 带外数据攑օ�正常数据��? int
SO_RCVBUF 接收�~�冲区大��? int
SO_SNDBUF 发送缓冲区大小 int
SO_RCVLOWAT 接收�~�冲��Z��? int
SO_SNDLOWAT 发送缓冲区下限 int
SO_RCVTIMEO 接收��时 struct timeval
SO_SNDTIMEO 发送超�? struct timeval
SO_REUSERADDR 允许重用本地地址和端�? int
SO_TYPE 获得套接字类�? int
SO_BSDCOMPAT 与BSD�pȝ��兼容 int
==========================================================================
IPPROTO_IP
--------------------------------------------------------------------------
IP_HDRINCL 在数据包中包含IP首部 int
IP_OPTINOS IP首部选项 int
IP_TOS 服务�c�d��
IP_TTL 生存旉�� int
==========================================================================
IPPRO_TCP
--------------------------------------------------------------------------
TCP_MAXSEG TCP最大数据段的大��? int
TCP_NODELAY 不��用Nagle��法 int
=========================================================================

关于�q�些选项的详�l�情况请查看 Linux Programmer's Manual

8.2 ioctl
ioctl可以控制所有的文�g描述�W�的情况,�q�里介绍一下控制套接字的选项.

int ioctl(int fd,int req,...)

==========================================================================
ioctl的控刉��项
--------------------------------------------------------------------------
SIOCATMARK 是否到达带外标记 int
FIOASYNC 异步输入/输出标志 int
FIONREAD �~�冲区可�ȝ��字节�? int
==========================================================================

详细的选项��L�� man ioctl_list 查看.

芥之�?/a> 2006-04-27 13:12 发表评论

Thu, 27 Apr 2006 04:11:00 GMT

什么是 socket�Q?
你始�l�听��C�h们谈论着 "socket"�Q�而你不知道他的确切含义。那么，现在我告诉你�Q?他是使用 Unix 文�g描述�W?(fiel descriptor) 和其他程序通讯的方式�?
什么？
Ok --你也许听��C��?Unix 高手 (hacker) �q�样��_��“呀�Q�Unix 中所有的东西��是文�g�Q�”那个家伙也许正在说��C��个事实：Unix �E�序在执行�Q何�Ş式的 I/O 的时候，�E�序是在��L��者写一个文件描�q�符。一个文件描�q�符只是一个和打开的文件相兌��的整数。但�?注意后面的话)�Q�这个文件可能是一个网�l�连接， FIFO�Q�管道，�l�端�Q�磁盘上的文�?或者什么其他的东西。Unix 中所有的东西是文�Ӟ��因此�Q�你惛_�� Internet 上别的程序通讯的时候，你将要通过文�g描述�W�。最好相信刚才的话�?
现在你脑��中或许冒出�q�样的念��_��“那么我从哪里得到网�l�通讯的文件描�q�符呢，聪明人？”无论如何，我要回答�q�个问题�Q�你利用�pȝ��调用 socket()。他�q�回套接口描 �q�符 (socket descriptor)�Q�然后你再通过他来调用 send() �?recv()�?
“但�?..”，你可能现在叫��h��Q�“如果他是个文�g描述 �W�，那么��Z��么不用一般的调用 read() �?write() 来通过套接口通讯�Q�”简单的�{�案是：“你可以使用一般的函数�Q�”。详�l�的�{�案是：“你可以�Q�但是��?send() �?recv() 让你更好的控制数据传输。�?
有这样一个事实：在我们的世界上，有很多种套接口。有 DARPA Internet 地址 (Internet 套接�?�Q�本地节点的路径�?(Unix 套接�?�Q�CCITT X.25 地址 (你可以完全忽�?X.25 套接�?�?也许在你�?Unix 机器上还有其他的。我们在�q�里只讲�W�一�U�：Internet 套接口�?
----------------------------------------------------------------------------
Internet 套接口的两种�c�d��
什么意思？有两�U?Internet 套接口？是的。不�Q�我在撒谎。其实还有很多，但是我可不想吓着你。我们这里只讲两�U��?Except for this sentence, where I'm going to tell you that "Raw Sockets" are also very powerful and you should look them up.
好了�Q�好了。那两种�c�d��是什么呢�Q�一�U�是 "Stream Sockets"�Q�另外一�U�是 "Datagram Sockets"。我们以后谈��C��们的时候也会用�?"SOCK_STREAM" �?"SOCK_DGRAM"。数据报套接口有时也叫“无�q�接套接口�?如果你确实要�q�接的时候用 connect()�?
��式套接口是可靠的双向通讯的数据流。如果你向套接口安顺序输出�?�Q?”，那么他们 ��安��序�?�Q?”到辑֏�一辏V��他们也是无错误的传递的�Q�有自己的错误控制�?
�? 谁在使用��式套接口？你可能听说过 telnet�Q�不是吗�Q�他��׃��用流式套接口。你需要你所输入的字�W�按��序到达�Q�不�?吗？同样�Q�WWW ��览器��用的 HTTP 协议也��用他们。实际上�Q�当你通过端口80 telnet ��C��?WWW 站点�Q�然后输�?“GET pagename�? 的时候，你也可以得到 HTML 的内宏V�?
��Z��么流式套接口可以辑ֈ�高质量的数据传输�Q�他使用了“传输控制协�?(The Transmission Control Protocol)”，也叫 “TCP�?(请参�?RFC-793 获得详细资料�?TCP 控制你的数据按顺序到辑�ƈ且没有错误。你也许听到 “TCP�?是因为听到过 “TCP/IP”。这里的 IP 是指 “Internet 协议�?请参�?RFC-791.) IP 只是处理 Internet 路由而已�?
那么数据报套接口呢？��Z��么他叫无�q�接呢？��Z��么他是不可靠的呢�Q�恩�Q�有�q�样的事实：如果你发送一个数据报�Q�他可能到达�Q�他可能�ơ序颠倒了。如果他到达�Q�那么在�q�个包的内部是无错误的�?
数据报也使用 IP 作�\由，但是他不选择 TCP。他使用“用��h��据报协议 (User Datagram Protocol)”，也叫 “UDP�?(请参�?RFC-768.)
��Z��么他们是无连接的呢？主要原因是因��Z��q�不象流式套接口那样�l�持一个连接�?你只要徏立一个包�Q�在目标信息中构造一�?IP ��_��然后发出厅R��不需要连接。应用程序有�Q?tftp, bootp �{�等�?
“够了！”你也许会想�Q�“如果数据丢�׃��q�些�E�序如何正常工作�Q�”我的朋友，每个�E�序�?UDP 上有自己的协议。例如，tftp 协议每发��Z��个包�Q�收到者发回一个包来说“我收到了！�?(一个“命令正��应�{�”也叫“ACK�? �?。如果在一定时间内(例如5�U?�Q�发送方没有收到应答�Q?他将重新发送，直到得到 ACK。这一点在实现 SOCK_DGRAM 应用�E�序的时候非帔R��要�?
----------------------------------------------------------------------------
�|�络理论
既然我刚才提��C��协议层，那么现在是讨论网�l�究竟如何工作和演示 SOCK_DGRAM 的工作。当�Ӟ��你也可以跌��q�一�D�，如果你认�?已经熟悉的话�?
�? 友们�Q�现在是学习数据��装 (Data Encapsulation) 的时候了�Q?�q�非帔R��帔R��要。It's so important that you might just learn about it if you take the networks course here at Chico State . 主要的内�Ҏ��Q�一个包�Q�先是被�W�一个协�?在这里是 TFTP )包装(“封装�?�Q?然后�Q�整个数�?包括 TFTP �?被另外一个协�?在这里是 UDP )��装�Q�然后下一�? IP )�Q�一直重复下去，直到��g(物理)�? Ethernet )�?
当另外一台机器接收到包，��g先剥�?Ethernet ��_��内核剥去 IP �?UDP ��_��TFTP �E�序再剥�?TFTP ��_��最后得到数据�?
�? 在我们终于讲到臭名远播的 �|�络分层模型 (Layered Network Model)。这�U�网�l�模型在描述�|�络�pȝ��上相对其他模型有很多优点。例如，你可以写一个套接口 �E�序而不用关心数据的物理传输(串行口，以太�|�，�q�接单元接口 (AUI) �q�是其他介质�? 因�ؓ底层的程序�ؓ你处理他们。实际的�|�络��g和拓扑对于程序员来说是透明的�?
不说其他废话了，我现在列出整个层�ơ模型。如果你要参加网�l�考试�Q�可一定要��C��Q?
应用�?(Application)
表示�?(Presentation)
会话�?(Session)
传输�?(Transport)
�|�络�?(Network)
数据链�\�?(Data Link)
物理�?(Physical)
物理层是��g(串口�Q�以太网�{�等)。应用层是和��g层相隔最�q�的--他是用户和网�l?交互的地斏V�?
�q�个模型如此通用�Q�如果你惻I��你可以把他作��Z��车指南。把他应用到 Unix�Q�结果是:
应用�?(Application Layer) (telnet, ftp, �{�等)
传输�?(Host-to-Host Transport Layer) (TCP, UDP)
Internet �?(Internet Layer) (IP 和�\�?
�|�络讉K��?(Network Access Layer) (�|�络层，数据链�\层和物理�?
现在�Q�你可能看到�q�些层次如何协调来封装原始的数据了�?
�? 看徏立一个简单的数据包有多少工作�Q�哎呀�Q�你��不得不使用 "cat" 来完�?他们�Q�简直是�W�话。对于流式套接口你要作的�?send() 发送数据。对于数据报式套接口你按照你选择的方式封装数据然后用 sendto()。内核将��Z��建立传输层和 Internet 层，��g完成�|�络讉K��层。这��是��C��U�技�?
现在�l�束我们的网�l�理论速成班。哦�Q�忘记告诉你关于路由的事情了。但是我不准备谈他�?如果你真的想知道�Q�那么参�?IP RFC。如果你从来不曾了解他，也没�?关系�Q�你�q�活着不是吗�?
----------------------------------------------------------------------------
structs
�l�于到达�q�里了，�l�于谈到�~�程了。在�q�章�Q�我��谈到被套接口用到的各种数据�c�d��。因�?他们中的一些太重要了�?
首先是简单的一个：socket descriptor。他是下面的�c�d��Q?
int
仅仅是一个常见的 int�?
�? 现在��P��事情变得不可思议了。请跟我一起忍受苦恼吧。注意这��L��事实�Q?有两�U�字节排列顺序：重要的字节在前面(有时�? "octet")�Q�或者不重要的字节在前面�?前一�U�叫“网�l�字节顺�?(Network Byte Order)”。有些机器在内部是按照这个顺序储存数据，而另外一些则不然。当我说某数据必��L��?NBO ��序�Q�那么你要调用函�?�?�? htons() )来将他从本机字节��序 (Host Byte Order) 转换�q�来。如果我没有提到 NBO�Q?那么��p��他是本机字节��序吧�?
我的�W�一个结�?TM)--struct sockaddr. �q�个数据�l�构 ��多类型的套接口储存套接口地址信息�Q?
struct sockaddr {
unsigned short sa_family; /* address family, AF_xxx */
char sa_data[14]; /* 14 bytes of protocol address */
};
sa_family 能够是各�U�各��L��事情�Q�但是在�q�篇文章中是 "AF_INET"�?sa_data 为套接口储存目标地址和端口信息。看上去很笨拙，不是吗�?
��Z��对付 struct sockaddr�Q�程序员创造了一个�ƈ列的�l�构�Q?struct sockaddr_in ("in" 代表 "Internet".)
struct sockaddr_in {
short int sin_family; /* Address family */
unsigned short int sin_port; /* Port number */
struct in_addr sin_addr; /* Internet address */
unsigned char sin_zero[8]; /* Same size as struct sockaddr */

};
�q? 个数据结构让可以��L��处理套接口地址的基本元素。注�?sin_zero (�?被加入到�q�个�l�构�Q��ƈ且长度和 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. �q�样的话即�� socket() 惌��的是 struct sockaddr *�Q?你仍然可以��?struct sockaddr_in�Q�and cast it at the last minute! 同时�Q�注�? sin_family �?struct sockaddr 中的 sa_family 一致�ƈ能够讄��?"AF_INET"。最后， sin_port �?sin_addr 必须是网�l�字节顺�?(Network Byte Order)�Q?
你也�怼�反对道："但是�Q�怎么让整个数据结�?struct in_addr sin_addr 按照�|�络字节��序�?" 要知道这个问题的�{�案�Q�我们就要仔�l�的看一看这个数据结构： struct in_addr, 有这样一个联�?(unions)�Q?
/* Internet address (a structure for historical reasons) */
struct in_addr {
unsigned long s_addr;
};
�? 曄��是个最坏的联合�Q�但是现在那些日子过��M��。如果你声明 "ina" �?数据�l�构 struct sockaddr_in 的实例，那么 "ina.sin_addr.s_addr" ��储�?字节�?IP 地址(�|�络字节��序)。如果你不幸�?�pȝ��使用的还是恐怖的联合 struct in_addr �Q�你�q�是可以攑ֿ�4�?节的 IP 地址是和上面我说的一�?�q�是因�ؓ #define�?
----------------------------------------------------------------------------
Convert the Natives!
我们现在到达下个章节。我们曾�l�讲了很多网�l�到本机字节��序�Q�现在是采取行动的时��M��Q?
�? 能够转换两种�c�d��Q?short (两个字节)�?long (四个字节)。这�?函数对于变量�c�d�� unsigned 也适用。假设你惛_�� short 从本机字节顺�?转换为网�l�字节顺序。用 "h" 表示 "本机 (host)"�Q�接着�?"to"�Q�然后用 "n" 表示 "�|�络 (network)"�Q�最后用 "s" 表示 "short"�Q?h-to-n-s, 或�?htons() ("Host to Network Short")�?
太简单了...
如果不是太傻的话�Q�你一定想��C��l�合 "n"�Q?h"�Q?s"�Q�和 "l"。但是这里没�?stolh() ("Short to Long Host") 函数�Q�但是这里有�Q?
htons()--"Host to Network Short"
htonl()--"Host to Network Long"
ntohs()--"Network to Host Short"
ntohl()--"Network to Host Long"
�? 在，你可能想你已�l�知道他们了。你也可能想�Q?如果我改�?char 的顺序会怎么样呢? 我的 68000 机器已经使用了网�l�字节顺序，我没有必要去调用 htonl() 转换 IP 地址�? 你可能是对的�Q�但是当你移植你的程序到别的机器上的时候，你的�E�序��?��p�|。可�U�L��性！�q�里�?Unix 世界�Q�记住：在你��数据放到网�l�上的时候，��信他们是网�l�字节顺序�?
最后一点：��Z��么在数据�l�构 struct sockaddr_in 中， sin_addr �?sin_port 需要�{换�ؓ�|�络字节��序�Q��?sin_family 不需要呢? �{�案是：sin_addr �? sin_port 分别��装在包�?IP �?UDP 层。因此，他们必须要是�|�络字节��序�?但是 sin_family 域只是被内核 (kernel) 使用来决定在数据�l�构中包含什么类型的地址�Q�所以他应该是本机字节顺序。也�?sin_family 没有 �? 送到�|�络上，他们可以是本机字节顺序�?
----------------------------------------------------------------------------
IP 地址和如何处理他�?
现在我们很幸�q�，因�ؓ我们有很多的函数来方便地操作 IP 地址。没有必要用手工计算他们�Q�也没有必要�?<< 操作�W�来操作 long�?
�? 先，假设你用 struct sockaddr_in ina�Q�你惛_�� IP 地址 "132.241.5.10" 储存到其中。你要用的函数是 inet_addr()�Q��{�?numbers-and-dots 格式�?IP 地址�?unsigned long。这个工作可以这��h��做：
ina.sin_addr.s_addr = inet_addr("132.241.5.10");
注意�Q�inet_addr() �q�回的地址已经是按照网�l�字节顺序的�Q�你没有必要再去调用 htonl()�?
�? 面的代码可不是很健壮 (robust)�Q�因为没有错误检查。inet_addr() 在发生错�?的时候返�?1。记得二�q�制数吗? �?IP 地址�?255.255.255.255 的时候返回的�?(unsigned)-1�Q�这是个�q�播地址�Q�记住正��的使用错误��查�?
好了�Q�你�? 在可以�{换字�W�串形式�?IP 地址�?long 了。那么你有一个数据结�?struct in_addr�Q�该如何按照 numbers-and-dots 格式打印�? 在这�?时候，也许你要用函�?inet_ntoa() ("ntoa" 意思是 "network to ascii")�Q?
printf("%s",inet_ntoa(ina.sin_addr));
他将打印 IP 地址。注意的是：函数 inet_ntoa() 的参数是 struct in_addr�Q�而不�? long。同时要注意的是他返回的是一个指向字�W�的指针�?�?inet_ntoa 内部的指针静态地储存字符数组�Q�因此每�ơ你调用 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);
�q�行�l�果是：
address 1: 132.241.5.10
address 2: 132.241.5.10
如果你想保存地址�Q�那么用 strcpy() 保存到自��q��字符数组中�?
�q�就是这章的内容了。以后，我们��学习�{�?"whitehouse.gov" 形式的字�W�串到正��?�?IP 地址(��L��后面�?DNS 一章�?
----------------------------------------------------------------------------
socket()--得到文�g描述�W�！
我猜我不会再扯远�?-我必��讲 socket() �q�个�pȝ��调用了。这里是详细的定义：
#include
#include
int socket(int domain, int type, int protocol);
�? 是他们的参数怎么�? 首先�Q�domain 应该讄��?"AF_INET"�Q�就象上面的数据�l�构 struct sockaddr_in 中一栗��然后，参数 type 告诉内核�?SOCK_STREAM �c�d��q�是 SOCK_DGRAM �c�d��。最后，�?protocol 讄��? "0"�?注意�Q�有很多�U?domain、type�Q?我不可能一一列出了，��L�� socket() �?man page。当�Ӟ��q�有一�?更好"的方�?��d��?protocol。请�?getprotobyname() �?man page�?
socket() 只是�q�回你以后在�pȝ��调用�U�可能用到的 socket 描述�W�，或者在错误的时候返�?1。全局变量 errno 中储存错误倹{�?请参�?perror() �?man page�?
----------------------------------------------------------------------------
bind()--我在哪个端口?
一旦你得到套接口，你可能要��套接口和机器上的一定的端口兌��h��?如果你想�?listen() 来侦听一定端口的数据�Q�这是必要一�?-MUD �l�常告诉你说用命�?"telnet x.y.z 6969".)如果你只想用 connect()�Q�那么这个步骤没有必要。但是无论如何，��L��l�读下去�?
�q�里是系�l�调�?bind() 的大略：
#include
#include
int bind(int sockfd, struct sockaddr *my_addr, int addrlen);
sockfd 是调�?socket �q�回的文件描�q�符。my_addr 是指�?数据�l�构 struct sockaddr 的指针，他保存你的地址(即端口和 IP 地址) 信息。addrlen 讄��?sizeof(struct sockaddr)�?
��单得很不是吗? 再看看例子：
#include
#include
#include
#define MYPORT 3490
main()
{
int sockfd;
struct sockaddr_in my_addr;
sockfd = socket(AF_INET, SOCK_STREAM, 0); /* do some error checking! */
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), 8); /* zero the rest of the struct */
/* don't forget your error checking for bind(): */
bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr));
.
.
.
�q�里也有要注意的几�g事情。my_addr.sin_port 是网�l�字节顺序，my_addr.sin_addr.s_addr 也是的。另外要注意到的事情是因�pȝ��的不同，包含的头文�g也不��相同，��h��阅自��q�� man page�?
�?bind() 主题中最后要说的话是�Q�在处理自己�?IP 地址�?或端口的时候，有些工作是可以自动处理的�?
my_addr.sin_port = 0; /* choose an unused port at random */
my_addr.sin_addr.s_addr = INADDR_ANY; /* use my IP address */
通过��?赋给 my_addr.sin_port�Q�你告诉 bind() 自己选择合适的端口。同��P�� ?y_addr.sin_addr.s_addr 讄��?INADDR_ANY�Q�你告诉他自动填�?他所�q�行的机器的 IP 地址�?
如果你一向小心�}慎，那么你可能注意到我没有将 INADDR_ANY 转换为网�l�字节顺序！�q�是因�ؓ我知道内部的东西�Q�INADDR_ANY 实际上就�?0�Q�即使你改变字节的顺序，0依然�?。但是完��主义者说安全�W�一�Q�那么看下面的代码：
my_addr.sin_port = htons(0); /* choose an unused port at random */
my_addr.sin_addr.s_addr = htonl(INADDR_ANY); /* use my IP address */
你可能不�怿��Q�上面的代码��可以随便移植�?
bind() 在错误的时候依然是�q�回-1�Q��ƈ且设�|�全局变量 errno�?
在你调用 bind() 的时候，你要��心的另一件事情是�Q�不要采用小�?024的端口号。所有小�?024的端口号�?被系�l�保留！你可以选择�?024�?5535(如果他们没有被别的程序��用的�?�?
�? 要注意的另外一件小事是�Q�有时候你�Ҏ��不需要调用他。如果你使用 connect() 来和�q�程机器通讯�Q�你不要兛_��你的本地端口�?��p��你在使用 telnet 的时�?�Q�你只要 ��单的调用 connect() ��够可，他会��查套接口是否�l�定�Q�如果没有，他会自己�l�定一个没有��用的本地端口�?
----------------------------------------------------------------------------
connect()--Hello�Q?
�? 在我们假设你是个 telnet �E�序。你的用户命令你(��p��电媄 TRON 中一�?得到套接�?的文件描�q�符。你听从命��o调用�? socket()。下一步，你的用户告诉你通过端口23(�?�?telnet 端口)�q�接�?132.241.5.10"。你该怎么做呢?
�q�运的是�Q�你正在疯狂地阅�?connect()--如何�q�接到远�E�主��一章。你可不惌�� 你的用户失望�?
connect() �pȝ��调用是这��L��Q?
#include
#include
int connect(int sockfd, struct sockaddr *serv_addr, int addrlen);
sockfd 是系�l�调�?socket() �q�回的套接口文�g描述�W�。serv_addr 是保存着目的地端口和 IP 地址的数据结�?struct sockaddr。addrlen 讄��?sizeof(struct sockaddr)�?
让我们来看个例子�Q?
#include
#include
#include
#define DEST_IP "132.241.5.10"
#define DEST_PORT 23
main()
{
int sockfd;
struct sockaddr_in dest_addr; /* will hold the destination addr */
sockfd = socket(AF_INET, SOCK_STREAM, 0); /* do some error checking! */
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), 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�Q��ƈ 讄��全局变量 errno�?
同时�Q�你可能看到�Q�我没有调用 bind()。另外，我也没有��本地的端口受��我只关�?我在�q�接。内核将为我选择一个合适的端口��P��而我们所�q�接的地方也自动地获得这些信息�?
----------------------------------------------------------------------------
listen()--Will somebody please call me?
Ok, time for a change of pace. What if you don't want to connect to a remote host. Say, just for kicks, that you want to wait for incoming connections and handle them in some way. 处理�q�程分两步：首先�Q�你�?-listen()�Q�然后，你接�?-accept() (��L�� 下面的内�?�?
除了要一点解释外�Q�系�l�调�?listen 相当��单�?
int listen(int sockfd, int backlog);
sockfd 是调�?socket() �q�回的套接口文�g描述�W�。backlog �?在进入队列中允许的连接数目。是什么意思呢? �q�入的连接是在队列中一直等待直��C��接受 (accept() ��L��下面的文�?的连接。他们的数目限制于队列的允许。大多数�pȝ��的允许数目是20�Q�你也可以设�|��ؓ5�?0�?
和别的函��C��P��在发生错误的时候返�?1�Q��ƈ讄��全局变量 errno�?
你可能想象到了，在你调用 listen() 前你或者要调用 bind() 或者让内核随便选择一个端口。如果你想侦听进入的�q�接�Q�那么系�l�调用的��序可能是这��L��Q?
socket();
bind();
listen();
/* accept() goes here */
因�ؓ他相当的明了�Q�我��在�q�里不给��Z��子了�?�?accept() 那一章的代码��更�?完全�?真正�ȝ��的部分在 accept()�?
----------------------------------------------------------------------------
accept()--"Thank you for calling port 3490."
�? 备好了，�pȝ��调用 accept() 会有点古怪的地方的！你可以想象发生这��L��事情�Q?有�h从很�q�的地方通过一个你在侦�?(listen()) 的端口连�?(connect()) ��C��的机器。他的连接将加入到等待接�?(accept()) 的队列中。你调用 accept() 告诉他你有空闲的�q�接。他��返回一个新的套接口文�g描述�W�！原来的一个还在侦听你的那个端口，新的最后在准备发�?(send()) 和接�?( recv()) 数据。这��是�q�个�q�程�Q?
函数是这样定义的�Q?
#include
int accept(int sockfd, void *addr, int *addrlen);
sockfd 相当��单，是和 listen() 中一��L��套接口描�q�符。addr 是个指向局部的数据�l�构 struct sockaddr_in 的指针。This is where the information about the incoming connection will go (and you can determine which host is calling you from which port). 在他的地址传递给 accept 之前�Q�addrlen 是个局部的整�Ş变量�Q�设�|��ؓ sizeof(struct sockaddr_in)。accept ��?不会��多余的字节�l?addr。如果你攑օ�的少些，那么�?addrlen 的��g��反映出来�?
同样�Q�在错误时返�?1�q�设�|�全局变量 errno�?
现在是你应该熟悉的代码片�D�c�?
#include
#include
#include
#define MYPORT 3490 /* the port users will be connecting to */
#define BACKLOG 10 /* how many pending connections queue will hold */
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;
sockfd = socket(AF_INET, SOCK_STREAM, 0); /* do some error checking! */
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), 8); /* 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);
.
.
.
注意�Q�在�pȝ��调用 send() �?recv() 中你应该使用新的文�g描述�W��?如果你只惌��一个连接进来，那么你可以��?close() ��d��闭原来的文�g描述 �W?sockfd 来避免同一个端口更多的�q�接�?
----------------------------------------------------------------------------
send() and recv()--Talk to me, baby!
�q�两个函数用于流式套接口和数据报套接口的通讯。如果你喜欢使用无连接的数据�?套接口，你应该看一看下面关�?sendto() �?recvfrom() 的章节�?
send() 是这��L��Q?
int send(int sockfd, const void *msg, int len, int flags);
sockfd 是你惛_��送数据的套接口描�q�符(或者是调用 socket() 或者是 accept() �q�回的�?msg 是指向你惛_��送的数据的指针。len �? 数据的长度。把 flags 讄��?0 ��可以了�?详细的资料请�?send() �?man page)�?
�q�里是一些可能的例子�Q?
char *msg = "Beej was here!";
int len, bytes_sent;
.
.
len = strlen(msg);
bytes_sent = send(sockfd, msg, len, 0);
.
.
.
send() �q�回实际发送的数据的字节数--他可能小于你要求发送的数目�Q�也即你告诉他要发送一堆数据可是他不能处理成功。他只是发送他可能发送的数据�Q�然�? 希望你以后能够发送其他的数据。记住，如果 send() �q�回的数据和 len �? 匚w��Q�你应该发送其他的数据。但是这里也有个好消息：如果你要发送的包很��?��于大约 1K)�Q�他可能处理让数据一�ơ发送完。最后，在错误的时候返�?1�Q��ƈ讄�� errno�?
recv() 函数很相��|��
int recv(int sockfd, void *buf, int len, unsigned int flags);
sockfd 是要�ȝ��套接口描�q�符。buf 是要�ȝ��信息的缓册Ӏ�len �?�~�冲的最大长度。flags 也可以设�|��ؓ0�?请参考recv() �?man page�?
recv() �q�回实际��d��~�冲的数据的字节数。或者在错误的时候返�?1�Q�同时设�|?errno�?
很简单，不是�? 你现在可以在��式套接口上发送数据和接收数据了。你现在�?Unix �|�络�E�序员了�Q?
----------------------------------------------------------------------------
sendto() �?recvfrom()--Talk to me, DGRAM-style
"�q�很不错�?�Q�我听到你说�Q?但是你还没有讲无�q�接数据报套接口呢�?没问题，现在我们开�?�q�个内容�?
既然数据报套接口不是�q�接到远�E�主机的�Q�那么在我们发送一个包之前需要什么信息呢? 不错�Q�是目标地址�Q�看下面的：
int sendto(int sockfd, const void *msg, int len, unsigned int flags,
const struct sockaddr *to, int tolen);
�? 已经看到了，除了另外的两个信息外�Q�其余的和函�?send() 是一��L��?to 是个指向数据�l�构 struct sockaddr 的指针，他包含了目的地的 IP 地址和断口信息。tolen 可以��单地讄��?sizeof(struct sockaddr)�?
和函�?send() �c�M��Q�sendto() �q�回实际发送的字节�?他也可能��于�?惌��发送的字节敎ͼ�)�Q�或者在错误的时候返�?-1�?
�怼�的还有函�?recv() �?recvfrom()。recvfrom() 的定义是 �q�样的：
int recvfrom(int sockfd, void *buf, int len, unsigned int flags
struct sockaddr *from, int *fromlen);
�? 一�ơ，除了一点多余的参数外，�q�个函数�?recv() 也是一��L��。from �?一个指向局部数据结�?struct sockaddr 的指针，他的内容是源机器 �?IP 地址和端口信息。fromlen 是个 int 型的局部指针，他的初始�?�?sizeof(struct sockaddr)。函数调用后�Q�fromlen 保存着实际储存�?from 中的地址的长度�?
recvfrom() �q�回收到的字节长度，或者在发生错误后返�?-1�?
��C��Q�如果你是用 connect() �q�接一个数据报套接口，你可以简单的调用 send() �?recv() 来满��你的要求。这个时候依然是数据报套接口�Q�依然��?UDP�Q�系�l?自动的加上了目标和源的信息�?
----------------------------------------------------------------------------
close() �?shutdown()--Get outta my face!
你已�l�整天都在发�?(send()) 和接�?(recv()) 数据了，现在你准�?关闭你的套接口描�q�符了。这很简单，你可以��用一般的 Unix 文�g描述�W�的 close() �?敎ͼ�
close(sockfd);
他将防止套接口上更多的数据的��d��。�Q何在另一端读写套接口的企��N��返回错误信息�?
如果你想在如何关闭套接口上有多一点的控制�Q�你可以使用函数 shutdown()。他能够�?你将一定方向的通讯或者双向的通讯(��p�� close() 一�?关闭�Q�你可以使用�Q?
int shutdown(int sockfd, int how);
sockfd 是你惌��关闭的套接口文�g描述复。how 的值是下面的其中之一�Q?
0 - Further receives are disallowed
1 - Further sends are disallowed
2 - Further sends and receives are disallowed (�?close() 一�?
shutdown() 成功时返�?0�Q�失败时�q�回 -1(同时讄�� errno�?
如果在无�q�接的数据报套接口中使用 shutdown()�Q�那么只不过是让 send() �?recv() 不能使用(记得你在数据报套接口中��用了 connect 后是可以使用他们的吗?)
----------------------------------------------------------------------------
getpeername()--Who are you?
�q�个函数太简单了�?
他太��单了�Q�以��x��都不惛_��列一章。但是我�q�是�q�样做了�?
函数 getpeername() 告诉你在�q�接的流式套接口上谁在另外一辏V��函数是�q�样的：
#include
int getpeername(int sockfd, struct sockaddr *addr, int *addrlen);
sockfd 是连接的��式套接口的描述�W�。addr 是一个指向结�?struct sockaddr (或者是 struct sockaddr_in) 的指针，他保存着 �q�接的另一边的信息。addrlen 是一�?int 型的指针�Q�他初始化�ؓ sizeof(struct sockaddr)�?
函数在错误的时候返�?-1�Q�设�|�相应的 errno�?
一旦你获得他们的地址�Q�你可以使用 inet_ntoa() 或�?gethostbyaddr() 来打印或者获得更多的信息。但是你不能得到他的帐号�?如果他运行着愚蠢的守护进�E�，�q�是可能的，但是他的讨论已经��出了本文的范围�Q�请参�? RFC-1413 以获得更多的信息�?
-------------------------------------------------------------------------------
gethostname()--Who am I?
甚至�?getpeername() �q�简单的函数�?gethostname()。他�q�回你程�?所�q�行的机器的��L��名字。然后你可以使用 gethostbyname() 以获得你的机器的 IP 地址�?
下面是定义：
#include
int gethostname(char *hostname, size_t size);
参数很简单：hostname 是一个字�W�数�l�指针，他将在函数返回时保存 ��L��名。size �?hostname 数组的字节长度�?
函数调用成功时返�?0�Q�失败时�q�回 -1�Q��ƈ讄�� errno�?
--------------------------------------------------------------------------------
DNS--You say "whitehouse.gov", I say "198.137.240.100"
�? 果你不知�?DNS 的意思，那么我告诉你�Q�他代表"域名服务 (Domain Name Service)"。他主要的功能是�Q�你�l�他一个容易记忆的某站点的地址�Q�他�l�你 IP 地址(然后你就可以使用 bind(), connect(), sendto() 或者其他函数�?当一个�h 输入�Q?
$ telnet whitehouse.gov
telnet 能知道他��连�?(connect()) �?"198.137.240.100"�?
但是�q�是如何工作的呢? 你可以调用函�?gethostbyname()�Q?
#include
struct hostent *gethostbyname(const char *name);
很明白的是，他返回一个指�?struct hostent 的指针。这个数据结构是 �q�样的：
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]
�q�里是这个数据结构的详细资料�Q?struct hostent:
h_name - Official name of the host.
h_aliases - A NULL-terminated array of alternate names for the host.
h_addrtype - The type of address being returned; usually AF_INET.
h_length - The length of the address in bytes.
h_addr_list - A zero-terminated array of network addresses for the host. Host addresses are in Network Byte Order.
h_addr - The first address in h_addr_list.
gethostbyname() 成功时返回一个指�?struct hostent �?指针�Q�或者是个空 (NULL) 指针�?但是和以前不同，errno 不设�|�，h_errno 讄��错误信息。请看下面的 herror()�?
但是如何使用�? �q�个函数可不象他看上去那么难用�?
�q�里是个例子�Q?
#include
#include
#include
#include
#include
#include
int main(int argc, char *argv[])
{
struct hostent *h;
if (argc != 2) { /* error check the command line */
fprintf(stderr,"usage: getip address\n");
exit(1);
}
if ((h=gethostbyname(argv[1])) == NULL) { /* get the host info */
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 没有使用)�Q�你应该调用 herror()�?
相当��单，你只是传递一个保存机器名的自负串(例如 "whitehouse.gov") �l?gethostbyname()�Q�然后从�q�回的数据结�?struct hostent �?攉��信息�?
唯一让�h�q�h��的是打印 IP 地址信息。h->h_addr 是一�?char *�Q?但是 inet_ntoa() 需要的�?struct in_addr。因此，�?转换 h->h_addr �?struct in_addr *�Q�然后得到数据�?
--------------------------------------------------------------------------------
Client-Server Background
�q? 里是个客�?-服务器的世界。在�|�络上的所有东襉K��是在处理客户�q�程和服务器�q�程的交谈�?举个 telnet 的例子。当你用 telnet (客户)通过 23 ��L��口登陆到��L��Q�主��Z��q�行的一个程�?一般叫 telnetd�Q�服务器)�Ȁ�z�R��他处理�q�个�q�接�Q�显�C�登陆界面，�{�等�?
Figure 2. The Client-Server Relationship.
�?2 说明了客户和服务器之间的信息交换�?
�? 意，�?-服务器之间可以��用SOCK_STREAM、SOCK_DGRAM 或者其�?只要他们采用相同�?。一些很好的客户--服务器的例子�? telnet/telnetd�?ftp/ftpd �?bootp/bootpd。每�ơ你使用 ftp �?时候，在远端都有一�?ftpd ��Z��服务�?
一般，在服务端只有一个服务器�Q�他采用 fork() 来处理多个客��L��q�接。基本的 �E�序是：服务器等待一个连接，接受 (accept()) �q�接�Q�然�?fork() 一�?子进�E�处理他。这是下一章我们的例子中会讲到的�?
--------------------------------------------------------------------------------
��单的服务�?
�q�个服务器所做的全部工作是在留式�q�接上发送字�W�串 "Hello, World!\n"。你�?��试�q�个�E�序的话�Q�可以在一台机器上�q�行该程序，然后在另外一机器上登陆：
$ telnet remotehostname 3490
remotehostname 是该�E�序�q�行的机器的名字�?
服务器代码：
#include
#include
#include
#include
#include
#include
#include
#include
#define MYPORT 3490 /* the port users will be connecting to */
#define BACKLOG 10 /* how many pending connections queue will hold */
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), 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) { /* 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 %s\n", \
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 */
}
}
如果你很挑剔的话�Q�一定不满意我所有的代码都在一个很大的 main() 函数中。如果你不喜�Ƣ，可以划分得更�l�点�?
你也可以用我们下一章中的程序得到服务器端发送的字符丌Ӏ?
--------------------------------------------------------------------------------
��单的客户�E�序
�q�个�E�序比服务器�q�简单。这个程序的所有工作是通过 3490 端口�q�接到命令行中制定的��L��Q?然后得到服务器的字符丌Ӏ?
客户代码:
#include
#include
#include
#include
#include
#include
#include
#include
#define PORT 3490 /* the port client will be connecting to */
#define MAXDATASIZE 100 /* max number of bytes we can get at once */
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 hostname\n");
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), 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;
}
注意�Q�如果你在运行服务器之前�q�行客户�E�序�Q�connect() ��返�?"Connection refused" 信息�?
--------------------------------------------------------------------------------
数据�?Sockets
我不惌��更多了，所以我�l�出代码 talker.c �?listener.c�?
listener 在机器上�{�待在端�?4590 来的数据包。talker 发送数据包��C��定的机器�Q�他包含用户在命令行输入的东�ѝ�?
�q�里��是 listener.c�Q?
#include
#include
#include
#include
#include
#include
#include
#include
#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), 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()�Q�我们最后��用了 SOCK_DGRAM。同�Ӟ��没有必要��M��?listen() 或�?accept()。我们在使用无连接的数据报套接口�Q?
下面�?talker.c�Q?
#include
#include
#include
#include
#include
#include
#include
#include
#include
#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 message\n");
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), 8); /* 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 %s\n",numbytes,inet_ntoa(their_addr.sin_addr));
close(sockfd);
return 0;
}
�q�就是所有的了。在一台机器上�q�行 listener�Q�然后在另外一台机器上�q�行 talker。观察他们的通讯�Q?
Except for one more tiny detail that I've mentioned many times in the past: connected datagram sockets. I need to talk about this here, since we're in the datagram section of the document. Let's say that talker calls connect() and specifies the listener's address. From that point on, talker may only sent to and receive from the address specified by connect(). For this reason, you don't have to use sendto() and recvfrom(); you can simply use send() and recv().
--------------------------------------------------------------------------------
��d��
�? 塞，你也许早��听说了�?��d��"�?"sleep" 的科技行话。你可能注意到前面运行的 listener �E�序�Q�他在那里不停地�q�行�Q�等待数据包的到来。实际在�q�行的是他调�?recvfrom()�Q�然后没有数据，因此 recvfrom() �?��d�� (block)" 直到数据的到来�?
很多函数都利用阻塞。accept() ��d��Q�所有的 recv*() 函数��d��。他们之所以能�q�样做是因�ؓ他们被允许这样做。当你第一�ơ调�?socket() 建立套接口描�q�符的时候，内核��将他设�|��ؓ��d��。如果你不想套接口阻塞，你就要调用函�?fcntl()�Q?
#include
#include
.
.
sockfd = socket(AF_INET, SOCK_STREAM, 0);
fcntl(sockfd, F_SETFL, O_NONBLOCK);
.
.
通过讄��套接口�ؓ非阻塞，你能够有效地"询问"套接口以获得信息。如果你��试着从一个非��d��的套接口��M��息�ƈ且没有�Q何数据，他不会变成阻�?-他将�q�回 -1 �q?��?errno 讄��?EWOULDBLOCK�?
但是一般说来，�q�种轮询不是个好��L��。如果你让你的程序在忙等状态查询套接口的数据，你将��费大量�?CPU 旉��。更好的解决之道是用下一章讲�?select() ��L��?是否有数据要读进来�?
--------------------------------------------------------------------------------
select()--多�\同步 I/O
虽然�q�个函数有点奇怪，但是他很有用。假设这��L��情况�Q�你是个服务器，你一边在不停�?从连接上��L��据，一边在侦听�q�接上的信息�?
�? 问题�Q�你可能会说�Q�不��是一�?accept() 和两�?recv() �? �q�么�Ҏ�� 吗，朋友? 如果你在调用 accept() 的时候阻塞呢? 你怎么能够同时接受 recv() 数据? "用非��d��的套接口啊！" 不行�Q�你不想耗尽所有的 CPU�Q�不是吗? 那么�Q�该如何是好?
select() 让你可以同时监视多个套接口。如果你想知道的话，那么他就会告诉你哪个套接口准备读�Q�哪个又准备好了写，哪个套接口又发生了例�?(exception)�?
闲话��说�Q�下面是 select()�Q?
#include
#include
#include
int select(int numfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, struct timeval *timeout);
�q? 个函数监视一�p�d��文�g描述�W�，特别�?readfds、writefds �?exceptfds。如果你想知道你是否能够从标准输入和套接口描�q�符 sockfd �?入数据，你只要将文�g描述�W?0 �?sockfd 加入到集�?readfds 中�?参数 numfds 应该�{�于最高的文�g描述�W�的值加1。在�q�个例子中，你应该设�|�该�?�?sockfd+1。因��Z��一定大于标准输入的文�g描述�W?(0)�?
当函�?select() �q�回的时候，readfds 的��g��改�ؓ反映你选择的哪个文�?描述�W�可以读。你可以用下面讲到的�?FD_ISSET() 来测试�?
在我们��l�下��M��前，让我来讲讲如何对�q�些集合�q�行操作。每个集合类型都�?fd_set�?下面有一些宏来对�q�个�c�d��q�行操作�Q?
FD_ZERO(fd_set *set) - clears a file descriptor set
FD_SET(int fd, fd_set *set) - adds fd to the set
FD_CLR(int fd, fd_set *set) - removes fd from the set
FD_ISSET(int fd, fd_set *set) - tests to see if fd is in the set
最后，是有点古怪的数据�l�构 struct timeval。有时你可不��x��q�等待别人发送数据过来。也�总�么事情都没有发生的时候你也想每隔96�U�在�l�端上打印字�W�串 "Still Going..."。这个数据结构允�怽�讑֮�一个时��_��如果旉��C��Q?�?select() �q�没有找��C��个准备好的文件描�q�符�Q�他��返回让你��l�处理�?
数据�l�构 struct timeval 是这��L��Q?
struct timeval {
int tv_sec; /* seconds */
int tv_usec; /* microseconds */
};
�? 要将 tv_sec 讄��Z��要等待的�U�数�Q�将 tv_usec 讄��Z��要等待的微秒数就可以了。是的，是微�U�而不是毫�U��?,000微秒�{�于1豪秒�Q?,000毫秒�{�于1�U�。也��是��_��1�U�等�?,000,000�? �U�。�ؓ什么用�W�号 "usec" �? 字母 "u" 很象希腊字母 Mu�Q?�?Mu 表示 "�? 的意思。当�Ӟ��函数�q�回的时�?timeout 可能是剩余的旉��Q�之所以是可能�Q�是因�ؓ他依赖于你的 Unix 操作�pȝ��?
哈！我们现在有一个微�U��的定时器�Q�不要计��了�Q�标准的 Unix �pȝ��的时间片�?00毫秒�Q�所�?无论你如何设�|�你的数据结�?struct timeval�Q�你都要�{�待那么长的旉��?
�q? 有一些有��的事情�Q�如果你讄��数据�l�构 struct timeval 中的数据�?0�Q�select() ��立卌��Ӟ��q�样��可以有效地轮询集合中的所有的文�g描述�W�。如果你��参�?timeout 赋��gؓ NULL�Q�那么将永远不会发生��时�Q�即一直等到第一个文件描�q�符��q�A。最后，如果你不是很兛_��{�待多长旉��Q�那�?��把他赋�?NULL 吧�?
下面的代码演�C�Z��在标准输入上�{�待 2.5 �U�：
#include
#include
#include
#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 �l�端上，那么你敲的键应该是回�?(RETURN)�Q�否则无论如�?他都会超时�?
现在�Q�你可能回认��是在数据报套接口上�{�待数据的方�?-你是对的�Q�他可能是�?有些 Unix �pȝ��可以按这�U�方式，而另外一些则不能。你在尝试以前可能要先看看本�pȝ�� ?man page 了�?
最后一件关�?select() 的事情：如果你有一个正在侦�?(listen()) 的套接口�Q�你可以通过��该套接口的文�g描述�W�加入到 readfds 集合中来�?是否有新的连接�?
�q�就是我关于函数 select() 要讲的所有的东西�?img src ="http://m.shnenglu.com/lmlf001/aggbug/6370.html" width = "1" height = "1" />

芥之�?/a> 2006-04-27 12:11 发表评论

Thu, 27 Apr 2006 03:58:00 GMT

原文地址�Q�http://study.pay500.com/1/s12212.htm

Linux�|�络�~�程--9. 服务器模�?/font>

学习�q�《��Y件工�E�》吧.软�g工程可是每一个程序员"必修"的课�E�啊.如果你没有学习过, ��你去看一�? 在这一章里�?我们一��h��从��Y件工�E�的角度学习�|�络�~�程的思想.在我们写�E�序之前, 我们都应该从软�g工程的角度规划好我们的��Y�?�q�样我们开发��Y件的效率才会�? 在网�l�程序里�?一般的来说都是许多客户机对应一个服务器.��Z��处理客户机的��h��, �Ҏ��务端的程序就提出了特�D�的要求.我们学习一下目前最常用的服务器模型.

循环服务�?循环服务器在同一个时��d��可以响应一个客��L��的请�?

�q�发服务�?�q�发服务器在同一个时��d��以响应多个客��L��的请�?

9.1 循环服务�?UDP服务�?
UDP循环服务器的实现非常��?UDP服务器每�ơ从套接字上��d��一个客��L��的请�?处理, 然后��结果返回给客户�?

可以用下面的��法来实�?

socket(...);
bind(...);
while(1)
{
recvfrom(...);
process(...);
sendto(...);
}

因�ؓUDP是非面向�q�接�?没有一个客��L��可以老是占住服务�? 只要处理�q�程不是��d�@�? 服务器对于每一个客��h��的请求��L��能够满��.
9.2 循环服务�?TCP服务�?
TCP循环服务器的实现也不�?TCP服务器接受一个客��L��的连�?然后处理,完成了这个客��L��所有请求后,断开�q�接.

��法如下:

socket(...);
bind(...);
listen(...);
while(1)
{
accept(...);
while(1)
{
read(...);
process(...);
write(...);
}
close(...);
}

TCP循环服务器一�ơ只能处理一个客��L��的请�?只有在这个客��L��所有请求都满��? 服务器才可以�l�箋后面的请�?�q�样如果有一个客��L��占住服务器不放时,其它的客��h��都不能工作了.因此,TCP服务器一般很��用循环服务器模型的.

9.3 �q�发服务�?TCP服务�?
��Z��弥补循环TCP服务器的�~�陷,��Z��又想��Z��q�发服务器的模型. �q�发服务器的思想是每一个客��h��的请求�ƈ不由服务器直接处�?而是服务器创��Z��?子进�E�来处理.

��法如下:

socket(...);
bind(...);
listen(...);
while(1)
{
accept(...);
if(fork(..)==0)
{
while(1)
{
read(...);
process(...);
write(...);
}
close(...);
exit(...);
}
close(...);
}

TCP�q�发服务器可以解决TCP循环服务器客��h��独占服务器的情况. 不过也同时带来了一个不��的问题.��Z��响应客户机的��h��,服务器要创徏子进�E�来处理. 而创建子�q�程是一�U�非常消耗资源的操作.

9.4 �q�发服务�?多�\复用I/O
��Z��解决创徏子进�E�带来的�pȝ��资源消�?��Z��又想��Z��多�\复用I/O模型.

首先介绍一个函数select

int select(int nfds,fd_set *readfds,fd_set *writefds,
fd_set *except fds,struct timeval *timeout)
void FD_SET(int fd,fd_set *fdset)
void FD_CLR(int fd,fd_set *fdset)
void FD_ZERO(fd_set *fdset)
int FD_ISSET(int fd,fd_set *fdset)

一般的来说当我们在向文件读写时,�q�程有可能在��d��出阻�?直到一定的条�g满��. 比如我们从一个套接字��L��据时,可能�~�冲区里面没有数据可�?通信的对方还没有发送数据过�?,�q�个时候我们的读调用就会等�?��d��)直到有数据可�?如果我们�?希望��d��,我们的一个选择是用select�pȝ��调用. 只要我们讄��好select的各个参�?那么当文件可以读写的时候select�?通知"我们说可以读写了. readfds所有要�ȝ��文�g文�g描述�W�的集合
writefds所有要的写文�g文�g描述�W�的集合

exceptfds其他的服要向我们通知的文件描�q�符

timeout��时讄��.

nfds所有我们监控的文�g描述�W�中最大的那一个加1

在我们调用select时进�E�会一直阻塞直��C��下的一�U�情况发�? 1)有文件可以读.2)有文件可以写.3)��时所讄��的时间到.

��Z��讄��文�g描述�W�我们要使用几个�? FD_SET��fd加入到fdset

FD_CLR��fd从fdset里面清除

FD_ZERO从fdset中清除所有的文�g描述�W?

FD_ISSET判断fd是否在fdset集合�?

使用select的一个例�?

int use_select(int *readfd,int n)
{
fd_set my_readfd;
int maxfd;
int i;

maxfd=readfd[0];
for(i=1;i
if(readfd[i]>maxfd) maxfd=readfd[i];
while(1)
{
/* ��所有的文�g描述�W�加�? */
FD_ZERO(&my_readfd);
for(i=0;i
FD_SET(readfd[i],*my_readfd);
/* �q�程��d�� */
select(maxfd+1,& my_readfd,NULL,NULL,NULL);
/* 有东西可以读�? */
for(i=0;i
if(FD_ISSET(readfd[i],&my_readfd))
{
/* 原来是我可以��M�� */
we_read(readfd[i]);
}
}
}

使用select后我们的服务器程序就变成�?

初始�?socket,bind,listen);

while(1)
{
讄��监听��d��文�g描述�W?FD_*);

调用select;

如果是們֐�套接字就�l?说明一个新的连接请求徏�?
{
建立�q�接(accept);
加入到监听文件描�q�符中去;
}
否则说明是一个已�l�连接过的描�q�符
{
�q�行操作(read或者write);
}

}

多�\复用I/O可以解决资源限制的问�?着模型实际上是��UDP循环模型用在了TCP上面. �q�也��带来了一些问�?如由于服务器依次处理客户的请�?所以可能会��D��有的客户会等待很�?

9.5 �q�发服务�?UDP服务�?
��Z��把�ƈ发的概念用于UDP��得��C��q�发UDP服务器模�? �q�发UDP服务器模型其实是��单的.和�ƈ发的TCP服务器模型一��h��创徏一个子�q�程来处理的 ��法和�ƈ发的TCP模型一�?

除非服务器在处理客户端的��h��所用的旉��比较长以�?��Z��实际上很��用�q�种模型.

9.6 一个�ƈ发TCP服务器实�?

#include
#include
#include
#include
#include
#define MY_PORT 8888

int main(int argc ,char **argv)
{
int listen_fd,accept_fd;
struct sockaddr_in client_addr;
int n;

if((listen_fd=socket(AF_INET,SOCK_STREAM,0))<0)
{
printf("Socket Error:%s\n\a",strerror(errno));
exit(1);
}

bzero(&client_addr,sizeof(struct sockaddr_in));
client_addr.sin_family=AF_INET;
client_addr.sin_port=htons(MY_PORT);
client_addr.sin_addr.s_addr=htonl(INADDR_ANY);
n=1;
/* 如果服务器终止后,服务器可以第二次快速启动而不用等待一�D�|��? */
setsockopt(listen_fd,SOL_SOCKET,SO_REUSEADDR,&n,sizeof(int));
if(bind(listen_fd,(struct sockaddr *)&client_addr,sizeof(client_addr))<0)
{
printf("Bind Error:%s\n\a",strerror(errno));
exit(1);
}
listen(listen_fd,5);
while(1)
{
accept_fd=accept(listen_fd,NULL,NULL);
if((accept_fd<0)&&(errno==EINTR))
continue;
else if(accept_fd<0)
{
printf("Accept Error:%s\n\a",strerror(errno));
continue;
}
if((n=fork())==0)
{
/* 子进�E�处理客��L��的连�?*/
char buffer[1024];

close(listen_fd);
n=read(accept_fd,buffer,1024);
write(accept_fd,buffer,n);
close(accept_fd);
exit(0);
}
else if(n<0)
printf("Fork Error:%s\n\a",strerror(errno));
close(accept_fd);
}
}

你可以用我们前面写客��L��E�序来调试着�E�序,或者是用来telnet调试

芥之�?/a> 2006-04-27 11:58 发表评论

Thu, 27 Apr 2006 03:51:00 GMT

一个简单聊天室的两�U�实�?(fcntl �?select)(�?

在互联网相当普及的今天，在互联网上聊天对很多“网虫”来说已�l�是家常侉K��了。聊天室�E�序可以说是�|�上最��单的多点通信�E�序。聊天室的实现方法有很多�Q�但都是利用所谓的“多用户�I�间”来对信息进行交换，��h��典型的多路I/O的架构。一个简单的聊天�? 从程序员的观�Ҏ��看就是在多个I/O端点之间实现多对多的通信。其架构如图一所�C�。这��L��实现在用��L��眼里��是聊天室内��M��一个�h输入一�D�字�W�之�?其他用户都可以得到这一句话。这�U�“多用户�I�间”的架构在其他多炚w��信�E�序中应用的非常�q�泛�Q�其核心��是多�\I/O通信。多路I/O通信又被�U�CؓI/O多�\�? 用（I/O Multiplexing�Q�一般被使用在以下的场合�Q?
客户�E�序需要同时处理交互式的输入和同服务器之间的网�l�连接时需要处理I/O多�\复用问题�Q?
客户端需要同时对多个�|�络�q�接作出反应�Q�这�U�情况很��见�Q�；
TCP服务器需要同时处理处于监听状态和多个�q�接状态的socket�Q?
服务器需要处理多个网�l�协议的socket;
服务器需要同时处理不同的�|�络服务和协议�?
聊天室所需要面对的情况正是�W�一和第三两�U�情��c��我们将通过在TCP/IP协议之上建立一个功能简单的聊天室让大家更加了解多�\I/O以及它的实现�Ҏ��?
我们要讨论的聊天室功能非常简�? 感兴��的朋友可以��其功能扩展, 发展成一个功能比较完整的聊天�? 如加上用戯��? 用户�늧�, �U�密信息, semote �{�功�?
首先它是一�?client/server �l�构的程�? 首先启动 server, 然后用户使用 client �q�行�q�接. client/server �l�构的优�Ҏ��速度�? �~�点是当 server �q�行更新�? client 也必需更新.
　
�|�络初始�?
　
首先是初始化 server, 使server �q�入监听状�? (��Z��z��v�?以下引用的程序与实际�E�序略有出入, 下同)
sockfd = socket( AF_INET,SOCK_STREAM, 0);
// 首先建立一�?socket, 族�ؓ AF_INET, �c�d��?SOCK_STREAM.
// AF_INET = ARPA Internet protocols 即��?TCP/IP 协议�?
// SOCK_STREAM �c�d��提供了顺序的, 可靠�? ��Z��字节��的全双工连�?
// �׃��该协议族中只有一个协�? 因此�W�三个参��Cؓ 0
　
bind( sockfd, ( struct sockaddr *)&serv_addr, sizeof( serv_addr));
// 再将�q�个 socket 与某个地址�q�行�l�定.
// serv_addr 包括 sin_family = AF_INET 协议族同 socket
// sin_addr.s_addr = htonl( INADDR_ANY) server 所接受的所有其�?
// 地址��h��建立的连�?
// sin_port = htons( SERV_TCP_PORT) server 所监听的端�?
// 在本�E�序�? server �?IP和监听的端口都存攑֜� config 文�g�?
listen( sockfd, MAX_CLIENT);
// 地址�l�定之后, server �q�入监听状�?
// MAX_CLIENT 是可以同时徏立连接的 client ��L��.
server �q�入 listen 状态后, �{�待 client 建立�q�接�?
Client端要建立�q�接首先也需要初始化�q�接�Q?
sockfd = socket( AF_INET,SOCK_STREAM,0));
// 同样�? client 也先建立一�?socket, 其参��C�� server 相同.
connect( sockfd, ( struct sockaddr *)&serv_addr, sizeof( serv_addr));
// client 使用 connect 建立一个连�?
// serv_addr 中的变量分别讄��?
// sin_family = AF_INET 协议族同 socket
// sin_addr.s_addr = inet_addr( SERV_HOST_ADDR) 地址�?server
// 所在的计算机的地址.
// sin_port = htons( SERV_TCP_PORT) 端口�?server 监听的端�?
�?client 建立新连接的��h��被送到Server端时, server 使用 accept 来接受该�q�接:
accept( sockfd, (struct sockaddr*)&cli_addr, &cli_len);
// 在函数返回时, cli_addr 中保留的是该�q�接�Ҏ��的信�?
// 包括�Ҏ��?IP 地址和对方��用的端口.
// accept �q�回一个新的文件描�q�符.
�?server �q�入 listen 状态之�? �׃��已有多个用户在线�Q�所以程序需要同时对�q�些用户�q�行操作�Q��ƈ在它们之间实��C��息交换。这在实��C��U�CؓI/O多�\复用技术。多路复用一般有以下几种�Ҏ��Q?
非阻塞通信�Ҏ��Q�将文�g��道通过fcntl()设�ؓ非阻塞通信方式�Q�每隔一端时间对他们实行一�ơ轮询，以判断是否可以进行读写操作。这�U�方式的�~�点是费用太高，大部分资源浪费在轮询上�?
子进�E�方法：应用多个子进�E�，每一个对一个单工阻塞方式通信。所有子�q�程通过IPC和父�q�程�q�行通信。父�q�程掌管所有信息。这�U�方式的�~�点是实现复杂，而且�׃��IPC在各个操作系�l��^��C��q�不完全一��_��会导致可�U�L��性降低�?
信号驱动�Q�SIGIO�Q�的异步I/O�Ҏ��Q�首先，异步I/O是基于信��h��制的�Q��ƈ不可靠。其�ơ单一的信号不��以提供更多的信息来源。还是需要辅助以其他的手�D�，实现上有很高的难度�?
select ()�Ҏ��Q�在BSD中提供了一�U�可以对多�\I/O�q�行��d��式查询的�Ҏ��——select()。它提供同时对多个I/O描述�W�进行阻塞式查询的方法，利用它，我们可以很方便的实现多�\复用。根据统一UNIX规范的协�?POSIX也采用了�q�种�Ҏ��Q�因此，我们可以在大多数操作�pȝ��中��用select�Ҏ��?
使用专门的I/O多�\复用器：在“UNIX? SYSTEM V Programmer's Guide: STREAMS”一书中详细的说明了构造和使用多�\复用器的�Ҏ��。这里就不再详述了�?
　
我们下面分别讨论多�\I/O的两�U�实现方�?
1. 非阻塞通信�Ҏ��
�? 一个文件描�q�符指定的文件或讑֤�, 有两�U�工作方�? ��d��与非��d��。所谓阻塞方式的意思是�? 当试囑֯�该文件描�q�符�q�行��d��? 如果当时没有东西可读,或者暂时不可写, �E�序��p��入等待状�? 直到有东西可��L��者可写�ؓ止。而对于非��d��状�? 如果没有东西可读, 或者不可写, ��d��函数马上�q�回, 而不会等待。缺省情况下, 文�g描述�W�处于阻塞状态。在实现聊天室时, server 需要轮��查询与各client 建立�? socket, 一旦可��d��该 socket 中的字符��d��来�ƈ向所有其他client 发送。�ƈ�? server �q�要随时查看是否有新�? client 试图建立�q�接,�q�样, 如果 server 在�Q何一个地斚w��塞了, 其他 client 发送的内容��׃��受到影响,得不到服务器的及时响应。新 client 试图建立�q�接也会受到影响。所以我们在�q�里不能使用�~�省的阻塞的文�g工作方式�Q�而需要将文�g的工作方式变成非��d��方式。在UNIX下，函数fcntl() 可以用来改变文�gI/O操作的工作方式，函数描述如下�Q?
fcntl( sockfd, F_SETFL, O_NONBLOCK);
// sockfd 是要改变状态的文�g描述�W?
// F_SETFL 表明要改变文件描�q�符的状�?
// O_NONBLOCK 表示��文件描�q�符变�ؓ非阻塞的.
��Z��节省��幅我们使用自然语言描述聊天�?server :
while ( 1) {
if 有新�q�接 then 建立�q�记录该新连�?
for ( 所有的有效�q�接)
begin
if 该连接中有字�W�可�?then
begin
��d��字符�Ԍ��
for ( 所有其他的有效�q�接)
begin
��该字符串发送给该连�?
end;
end;
end;
end.
�׃��判断是否有新�q�接, 是否可读都是非阻塞的, 因此每次判断,不管有还是没�? 都会马上�q�回. �q�样,��M��一�?client �?server 发送字�W�或者试囑־�立新�q�接, 都不会对其他 client 的活动造成影响�?
�?client 而言, 建立�q�接之后, 只需要处理两个文件描�q�符, 一个是建立了连接的 socket 描述�W? 另一个是标准输入. �? server 一�? 如果使用��d��方式的话, 很容易因为其中一个暂时没有输入而媄响另外一个的��d��.. 因此��它们都变成非阻塞的, 然后client �q�行如下动作:
while ( 不想退�?
begin
if ( �?server 的连接有字符可读)
begin
从该�q�接��d��, �q�输出到标准输出上去.
End;
if ( 标准输入可读)
Begin
从标准输入读�? �q�输出到�?server 的连接中�?
End;
End.
上面的读写分别调用这样两个函�?
read( userfd[i], line, MAX_LINE);
// userfd[i] 是指�W?i �?client �q�接的文件描�q�符.
// line 是指��d��的字�W�存攄��位置.
// MAX_LINE 是一�ơ最多读出的字符�?
// �q�回值是实际��d��的字�W�数.
write( userfd[j], line, strlen( line));
// userfd[j] 是第 j �?client 的文件描�q�符.
// line 是要发送的字符�?
// strlen( line) 是要发送的字符串长�?
分析上面的程序可以知�? 不管�?server �q�是 client, 它们都不停的轮流查询各个文�g描述�W? 一旦可��d��d��q�进行处�? �q�样的程�? 不停的在执行, 只要有CPU 资源, ��׃��会放�q�。因此对�pȝ��资源的消耗非常大。server 或�?client 单独执行�? CPU 资源�?98% 左右都被其占用。极大的消耗了�pȝ��资源�?
select �Ҏ��
因此�Q�虽然我们不希望在某一个用��h��有反应时��d��其他的用��P��但我们却应该在没有�Q何用��h��反应的情况之下停止程序的�q�行�Q�让出抢占的�pȝ��资源�Q�进入阻塞状态。有没有�q�种�Ҏ��呢？现在的UNIX�pȝ��中都提供了select�Ҏ��Q�具体实现方式如下：
select �Ҏ��? 所有文件描�q�符都是��d��? 使用 select 判断一�l�文件描�q�符中是否有一个可�?�?, 如果没有��阻�? 直到有一个的时候就被唤�? 我们先看比较��单的 client 的实�?
�׃�� client 只需要处理两个文件描�q�符, 因此, 需要判断是否有可读写的文�g描述�W�只需要加入两��?
FD_ZERO( sockset);
// ��?sockset 清空
FD_SET( sockfd, sockset);
// �?sockfd 加入�?sockset 集合�?
FD_SET( 0, sockset);
// �?0 (标准输入) 加入�?sockset 集合�?
然后 client 的处理如�?
while ( 不想退�? {
select( sockfd+1, &sockset, NULL, NULL, NULL);
// 此时该函数将��d��直到标准输入或�?sockfd 中有一个可��Mؓ�?
// �W�一个参数是 0 �?sockfd 中的最大值加一
// �W�二个参数是读集, 也就�?sockset
// �W�三, 四个参数是写集和异常�? 在本�E�序中都为空
// �W�五个参数是��时旉��, 卛_��指定旉��内仍没有可读, 则出�?
// �q�返�? 当这个参��CؓNULL �? ��时旉��被设�|��ؓ无限�?
// �?select 因�ؓ可读�q�回�? sockset 中包含的只是可读�?
// 那些文�g描述�W?
if ( FD_ISSET( sockfd, &sockset)) {
// FD_ISSET �q�个宏判�?sockfd 是否属于可读的文件描�q�符
�?sockfd 中读�? 输出到标准输��Z��?
}
if ( FD_ISSET( 0, &sockset)) {
// FD_ISSET �q�个宏判�?sockfd 是否属于可读的文件描�q�符
从标准输入读�? 输出�?sockfd 中去.
}
重新讄�� sockset. (卛_�� sockset 清空, �q�将 sockfd �?0 加入)
}
下面�?server 的情�?
讄�� sockset 如下:
FD_ZERO( sockset);
FD_SET( sockfd, sockset);
for ( 所有有效连�?
FD_SET( userfd[i], sockset);
}
maxfd = 最大的文�g描述�W�号 + 1;
server 处理如下:
while ( 1) {
select( maxfd, &sockset, NULL, NULL, NULL);
if ( FD_ISSET( sockfd, &sockset)) {
// 有新�q�接
建立新连�? �q�将该连接描�q�符加入�?sockset 中去�?
}
for ( 所有有效连�? {
if ( FD_ISSET ( userfd[i], &sockset)) {
// 该连接中有字�W�可�?
从该�q�接中读入字�W? �q�发送到其他有效�q�接中去.
}
}
重新讄�� sockset;
}
性能比较
�׃��采用 select 机制, 因此当没有字�W�可��L��, �E�序处于��d��状�?最��程度的占用CPU 资源, 在同一台机器上执行一�?server 和若�q�个client �? �pȝ��负蝲只有 0.1 左右, 而采用原来的非阻塞通信�Ҏ��, 只运行一�?server, �pȝ��负蝲��可以达�?1.5 左右. 因此我们推荐使用 select.

芥之�?/a> 2006-04-27 11:51 发表评论

Thu, 27 Apr 2006 03:46:00 GMT

Linux环境下的Socket�~�程

什么是Socket
　　Socket接口是TCP/IP�|�络的API�Q�Socket接口定义了许多函数或例程�Q�程序员可以用它们来开发TCP/IP�|�络上的应用�E�序。要学Internet上的TCP/IP�|�络�~�程�Q�必��ȝ��解Socket接口�?
　　Socket接口设计者最先是��接口放在Unix操作�pȝ��里面的。如果了解Unix�pȝ��的输入和输出的话�Q�就很容易了解Socket了。网�l�的 Socket数据传输是一�U�特�D�的I/O�Q�Socket也是一�U�文件描�q�符。Socket也具有一个类��g��打开文�g的函数调用Socket()�Q�该函数�q? 回一个整型的Socket描述�W�，随后的连接徏立、数据传输等操作都是通过该Socket实现的。常用的Socket�c�d��有两�U�：��式Socket �Q�SOCK_STREAM�Q�和数据报式Socket�Q�SOCK_DGRAM�Q�。流式是一�U�面向连接的Socket�Q�针对于面向�q�接的TCP服务应用�Q�数�? 报式Socket是一�U�无�q�接的Socket�Q�对应于无连接的UDP服务应用�?

Socket建立
　　��Z��建立Socket�Q�程序可以调用Socket函数�Q�该函数�q�回一个类��g��文�g描述�W�的句柄。socket函数原型为：
　　int socket(int domain, int type, int protocol);
　　domain指明所使用的协议族�Q�通常为PF_INET�Q�表�C�Z��联网协议族（TCP/IP协议族）�Q�type参数指定socket的类型： SOCK_STREAM 或SOCK_DGRAM�Q�Socket接口�q�定义了原始Socket�Q�SOCK_RAW�Q�，允许�E�序使用低层协议�Q�protocol通常赋�?0"�? Socket()调用�q�回一个整型socket描述�W�，你可以在后面的调用��用它�?
　　Socket描述�W�是一个指向内部数据结构的指针�Q�它指向描述�W�表入口。调用Socket函数�Ӟ��socket执行体将建立一个Socket�Q�实际上"建立一个Socket"意味着��Z��个Socket数据�l�构分配存储�I�间。Socket执行体�ؓ你管理描�q�符表�?
　　两个�|�络�E�序之间的一个网�l�连接包括五�U�信息：通信协议、本地协议地址、本��C��机端口、远端主机地址和远端协议端口。Socket数据�l�构中包含这五种信息�?

Socket配置
　　通过socket调用�q�回一个socket描述�W�后�Q�在使用socket�q�行�|�络传输以前�Q�必��配�|�该socket。面向连接的socket客户端通过调用Connect函数在socket数据�l�构中保存本地和�q�端信息。无�q�接socket的客��L��和服务端以及面向�q�接socket的服务端通过调用 bind函数来配�|�本��C��息�?
Bind函数��socket与本��Z��的一个端口相兌��Q�随后你��可以在该端口监听服务请求。Bind函数原型为：
　　int bind(int sockfd,struct sockaddr *my_addr, int addrlen);
　　Sockfd是调用socket函数�q�回的socket描述�W?my_addr是一个指向包含有本机IP地址及端口号�{�信息的sockaddr�c�d��的指针；addrlen常被讄��为sizeof(struct sockaddr)�?
　　struct sockaddr�l�构�c�d��是用来保存socket信息的：
　　struct sockaddr {
　　 unsigned short sa_family; /* 地址族， AF_xxx */
char sa_data[14]; /* 14 字节的协议地址 */
};
　　sa_family一般�ؓAF_INET�Q�代表Internet�Q�TCP/IP�Q�地址族；sa_data则包含该socket的IP地址和端口号�?
　　另外�q�有一�U�结构类型：
　　struct sockaddr_in {
　　 short int sin_family; /* 地址�?*/
　　 unsigned short int sin_port; /* 端口�?*/
　　 struct in_addr sin_addr; /* IP地址 */
　　 unsigned char sin_zero[8]; /* 填充0 以保持与struct sockaddr同样大小 */
　　};
　　�q�个�l�构更方便��用。sin_zero用来��sockaddr_in�l�构填充��C��struct sockaddr同样的长度，可以用bzero()或memset()函数��其�|��ؓ零。指向sockaddr_in 的指针和指向sockaddr的指针可以相互�{换，�q�意味着如果一个函数所需参数�c�d��是sockaddr�Ӟ��你可以在函数调用的时候将一个指�? sockaddr_in的指针�{换�ؓ指向sockaddr的指针；或者相反�?
　　使用bind函数�Ӟ��可以用下面的赋值实现自动获得本机IP地址和随��取一个没有被占用的端口号�Q?
　　my_addr.sin_port = 0; /* �pȝ��随机选择一个未被��用的端口�?*/
　　my_addr.sin_addr.s_addr = INADDR_ANY; /* 填入本机IP地址 */
通过��my_addr.sin_port�|��ؓ0�Q�函��C��自动��Z��选择一个未占用的端口来使用。同��P��通过��my_addr.sin_addr.s_addr�|��ؓINADDR_ANY�Q�系�l�会自动填入本机IP地址�?
注意在��用bind函数是需要将sin_port和sin_addr转换成�ؓ�|�络字节优先��序�Q�而sin_addr则不需要�{换�?
　　计算机数据存储有两种字节优先��序�Q�高位字节优先和低位字节优先。Internet上数据以高位字节优先��序在网�l�上传输�Q�所以对于在内部是以低位字节优先方式存储数据的机器，在Internet上传输数据时��需要进行�{换，否则��׃��出现数据不一致�?
　　下面是几个字节顺序�{换函敎ͼ�
·htonl()�Q�把32位��g��L��字节序�{换成�|�络字节�?
·htons()�Q�把16位��g��L��字节序�{换成�|�络字节�?
·ntohl()�Q�把32位��g��|�络字节序�{换成��L��字节�?
·ntohs()�Q�把16位��g��|�络字节序�{换成��L��字节�?
　　Bind()函数在成功被调用时返�?�Q�出现错误时�q�回"-1"�q�将errno�|��ؓ相应的错误号。需要注意的是，在调用bind函数时一般不要将端口��L��为小�?024的��|��因�ؓ1�?024是保留端口号�Q�你可以选择大于1024中的��M��一个没有被占用的端口号�?

�q�接建立
　　面向�q�接的客��L��序��用Connect函数来配�|�socket�q�与�q�端服务器徏立一个TCP�q�接�Q�其函数原型为：
　　int connect(int sockfd, struct sockaddr *serv_addr,int addrlen);
Sockfd 是socket函数�q�回的socket描述�W�；serv_addr是包含远端主机IP地址和端口号的指针；addrlen是远端地质结构的长度�? Connect函数在出现错误时�q�回-1�Q��ƈ且设�|�errno为相应的错误码。进行客��L��E�序设计无须调用bind()�Q�因��U�情况下只需知道目的机器的IP地址�Q�而客户通过哪个端口与服务器建立�q�接�q�不需要关心，socket执行体�ؓ你的�E�序自动选择一个未被占用的端口�Q��ƈ通知你的�E�序数据什么时候到打断口�?
　　Connect函数启动和远端主机的直接�q�接。只有面向连接的客户�E�序使用socket时才需要将此socket与远端主机相�q�。无�q�接协议从不建立直接�q�接。面向连接的服务器也从不启动一个连接，它只是被动的在协议端口监听客��L��h��?
　　Listen函数使socket处于被动的监听模式，�q��ؓ该socket建立一个输入数据队列，��到辄��服务��h��保存在此队列中，直到�E�序处理它们�?
　　int listen(int sockfd�Q?int backlog);
Sockfd 是Socket�pȝ��调用�q�回的socket 描述�W�；backlog指定在请求队列中允许的最大请求数�Q�进入的�q�接��h��在队列中等待accept()它们�Q�参考下文）。Backlog寚w��列中�{�待服务的请求的数目�q�行了限�Ӟ��大多数系�l�缺省��gؓ20。如果一个服务请求到来时�Q�输入队列已满，该socket��拒�l�连接请求，客户��收��C��个出错信息�?
当出现错误时listen函数�q�回-1�Q��ƈ�|�相应的errno错误码�?
　　accept()函数让服务器接收客户的连接请求。在建立好输入队列后�Q�服务器��p��用accept函数�Q�然后睡眠�ƈ�{�待客户的连接请求�?
　　int accept(int sockfd, void *addr, int *addrlen);
　　sockfd是被监听的socket描述�W�，addr通常是一个指向sockaddr_in变量的指针，该变量用来存放提��接请求服务的��L��的信�? �Q�某��C��Z��某个端口发出该请求）�Q�addrten通常��Z��个指向��gؓsizeof(struct sockaddr_in)的整型指针变量。出现错误时accept函数�q�回-1�q�置相应的errno倹{�?
　　首先�Q�当accept函数监视�? socket收到�q�接��h��Ӟ��socket执行体将建立一个新的socket�Q�执行体��这个新socket和请求连接进�E�的地址联系��h��Q�收到服务请求的初始socket仍可以��l�在以前�?socket上监听，同时可以在新的socket描述�W�上�q�行数据传输操作�?

数据传输
　　Send()和recv()�q�两个函数用于面向连接的socket上进行数据传输�?
　　Send()函数原型为：
　　int send(int sockfd, const void *msg, int len, int flags);
Sockfd是你想用来传输数据的socket描述�W�；msg是一个指向要发送数据的指针�Q�Len是以字节为单位的数据的长度；flags一般情况下�|��ؓ0�Q�关于该参数的用法可参照man手册�Q��?
　　Send()函数�q�回实际上发送出的字节数�Q�可能会��于你希望发送的数据。在�E�序中应该将send()的返回��g��Ʋ发送的字节数进行比较。当send()�q�回��g��len不匹配时�Q�应该对�q�种情况�q�行处理�?
char *msg = "Hello!";
int len, bytes_sent;
…�?
len = strlen(msg);
bytes_sent = send(sockfd, msg,len,0);
…�?
　　recv()函数原型为：
　　int recv(int sockfd,void *buf,int len,unsigned int flags);
　　Sockfd是接受数据的socket描述�W�；buf 是存放接收数据的�~�冲区；len是缓冲的长度。Flags也被�|��ؓ0。Recv()�q�回实际上接收的字节敎ͼ�当出现错误时�Q�返�?1�q�置相应的errno倹{�?
Sendto()和recvfrom()用于在无�q�接的数据报socket方式下进行数据传输。由于本地socket�q�没有与�q�端机器建立�q�接�Q�所以在发送数据时应指明目的地址�?
sendto()函数原型为：
　　int sendto(int sockfd, const void *msg,int len,unsigned int flags,const struct sockaddr *to, int tolen);
　　该函数比send()函数多了两个参数�Q�to表示目地机的IP地址和端口号信息�Q�而tolen常常被赋��gؓsizeof (struct sockaddr)。Sendto 函数也返回实际发送的数据字节长度或在出现发送错误时�q�回-1�?
　　Recvfrom()函数原型为：
　　int recvfrom(int sockfd,void *buf,int len,unsigned int flags,struct sockaddr *from,int *fromlen);
　　from是一个struct sockaddr�c�d��的变量，该变量保存源机的IP地址及端口号。fromlen常置为sizeof (struct sockaddr)。当recvfrom()�q�回�Ӟ��fromlen包含实际存入from中的数据字节数。Recvfrom()函数�q�回接收到的字节数或当出现错误时�q�回-1�Q��ƈ�|�相应的errno�?
如果你对数据报socket调用了connect()函数�Ӟ��你也可以利用send()和recv()�q�行数据传输�Q�但该socket仍然是数据报socket�Q��ƈ且利用传输层的UDP服务。但在发送或接收数据报时�Q�内�怼�自动��Z��加上目地和源地址信息�?

�l�束传输
　　当所有的数据操作�l�束以后�Q�你可以调用close()函数来释放该socket�Q�从而停止在该socket上的��M��数据操作�Q?
close(sockfd);
　　你也可以调用shutdown()函数来关闭该socket。该函数允许你只停止在某个方向上的数据传输，而一个方向上的数据传输��l�进行。如你可以关闭某socket的写操作而允许��l�在该socket上接受数据，直至��d��所有数据�?
　　int shutdown(int sockfd,int how);
　　Sockfd是需要关闭的socket的描�q�符。参�?how允许为shutdown操作选择以下几种方式�Q?
　　·0-------不允许��l�接收数�?
　　·1-------不允许��l�发送数�?
·2-------不允许��l�发送和接收数据�Q?
·均�ؓ允许则调用close ()
　　shutdown在操作成功时�q�回0�Q�在出现错误时返�?1�q�置相应errno�?

面向�q�接的Socket实例
　　代码实例中的服务器通过socket�q�接向客��L��发送字�W�串"Hello, you are connected!"。只要在服务器上�q�行该服务器软�g�Q�在客户端运行客戯��Y�Ӟ��客户端就会收到该字符丌Ӏ?
　　该服务器软�g代码如下�Q?
#include
#include
#include
#include
#include
#include
#include
#include
#define SERVPORT 3333 /*服务器监听端口号 */
#define BACKLOG 10 /* 最大同时连接请求数 */
main()
{
int sockfd,client_fd; /*sock_fd�Q�监听socket�Q�client_fd�Q�数据传输socket */
　struct sockaddr_in my_addr; /* 本机地址信息 */
　struct sockaddr_in remote_addr; /* 客户端地址信息 */
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
　　perror("socket创徏出错�Q?); exit(1);
}
my_addr.sin_family=AF_INET;
　my_addr.sin_port=htons(SERVPORT);
　my_addr.sin_addr.s_addr = INADDR_ANY;
bzero(&(my_addr.sin_zero),8);
　if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) \
　　 == -1) {
perror("bind出错�Q?);
exit(1);
}
　if (listen(sockfd, BACKLOG) == -1) {
perror("listen出错�Q?);
exit(1);
}
while(1) {
　　sin_size = sizeof(struct sockaddr_in);
　　if ((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, \
　　&sin_size)) == -1) {
perror("accept出错");
continue;
}
　　printf("received a connection from %s\n", inet_ntoa(remote_addr.sin_addr));
　 if (!fork()) { /* 子进�E�代码段 */
　　 if (send(client_fd, "Hello, you are connected!\n", 26, 0) == -1)
　　 perror("send出错�Q?);
close(client_fd);
exit(0);
}
　　close(client_fd);
　　}
　}
}
　　服务器的工作��程是这��L��Q�首先调用socket函数创徏一个Socket�Q�然后调用bind函数��其与本机地址以及一个本地端口号�l�定�Q�然后调�? listen在相应的socket上监听，当accpet接收��C��个连接服务请求时�Q�将生成一个新的socket。服务器昄��该客��h��的IP地址�Q��ƈ通过新的socket向客��L��发送字�W�串"Hello�Q�you are connected!"。最后关闭该socket�?
　　代码实例中的fork()函数生成一个子�q�程来处理数据传输部分，fork()语句对于子进�E�返回的��gؓ0。所以包含fork函数的if语句是子�q�程代码部分�Q�它与if语句后面的父�q�程代码部分是�ƈ发执行的�?

客户端程序代码如下：
#include
#include
#include
#include
#include
#include
#include
#include
#define SERVPORT 3333
#define MAXDATASIZE 100 /*每次最大数据传输量 */
main(int argc, char *argv[]){
　int sockfd, recvbytes;
　char buf[MAXDATASIZE];
　struct hostent *host;
　struct sockaddr_in serv_addr;
　if (argc < 2) {
fprintf(stderr,"Please enter the server's hostname!\n");
exit(1);
}
　if((host=gethostbyname(argv[1]))==NULL) {
herror("gethostbyname出错�Q?);
exit(1);
}
　if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
perror("socket创徏出错�Q?);
exit(1);
}
　serv_addr.sin_family=AF_INET;
　serv_addr.sin_port=htons(SERVPORT);
　serv_addr.sin_addr = *((struct in_addr *)host->h_addr);
　bzero(&(serv_addr.sin_zero),8);
　if (connect(sockfd, (struct sockaddr *)&serv_addr, \
　　 sizeof(struct sockaddr)) == -1) {
perror("connect出错�Q?);
exit(1);
}
　if ((recvbytes=recv(sockfd, buf, MAXDATASIZE, 0)) ==-1) {
perror("recv出错�Q?);
exit(1);
}
　buf[recvbytes] = '\0';
　printf("Received: %s",buf);
　close(sockfd);
}
　　客户端程序首先通过服务器域名获得服务器的IP地址�Q�然后创��Z��个socket�Q�调用connect函数与服务器建立�q�接�Q�连接成功之后接收从服务器发送过来的数据�Q�最后关闭socket�?
　　函数gethostbyname()是完成域名�{换的。由于IP地址难以记忆和读写，所以�ؓ了方便，��Z��常常用域名来表示��L��Q�这��需要进行域名和IP地址的�{换。函数原型�ؓ�Q?
　　struct hostent *gethostbyname(const char *name);
　　函数�q�回为hosten的结构类型，它的定义如下�Q?
　　struct hostent {
　 char *h_name; /* ��L��的官方域�?*/
　　 char **h_aliases; /* 一个以NULL�l�尾的主机别名数�l?*/
　　 int h_addrtype; /* �q�回的地址�c�d��Q�在Internet环境下�ؓAF-INET */
　　int h_length; /* 地址的字节长�?*/
　　 char **h_addr_list; /* 一个以0�l�尾的数�l�，包含该主机的所有地址*/
　　};
　　#define h_addr h_addr_list[0] /*在h-addr-list中的�W�一个地址*/
　　�?gethostname()调用成功�Ӟ��q�回指向struct hosten的指针，当调用失败时�q�回-1。当调用gethostbyname�Ӟ��你不能��用perror()函数来输出错误信息，而应该��用herror()函数来输出�?

　　无连接的客户/服务器程序的在原理上和连接的客户/服务器是一��L��Q�两者的区别在于无连接的客户/服务器中的客户一般不需要徏立连接，而且在发送接收数据时�Q�需要指定远端机的地址�?

��d��和非��d��
　　��d��函数在完成其指定的�Q务以前不允许�E�序调用另一个函数。例如，�E�序执行一个读数据的函数调用时�Q�在此函数完成读操作以前��不会执行下一�E�序语句。当服务器运行到accept语句�Ӟ��而没有客戯��接服务请求到来，服务器就会停止在accept语句上等待连接服务请求的到来。这�U�情�늧�为阻�? �Q�blocking�Q�。而非��d��操作则可以立卛_��成。比如，如果你希望服务器仅仅注意��查是否有客户在等待连接，有就接受�q�接�Q�否则就�l�箋做其他事情，�? 可以通过��Socket讄��为非��d��方式来实现。非��d��socket在没有客户在�{�待时就使accept调用立即�q�回�?
　　#include
　　#include
　　…�?
sockfd = socket(AF_INET,SOCK_STREAM,0);
fcntl(sockfd,F_SETFL,O_NONBLOCK)�Q?
…�?
　　通过讄��socket为非��d��方式�Q�可以实�?轮询"若干Socket。当企图从一个没有数据等待处理的非阻塞Socket��d��数据�Ӟ��函数��立卌�� 回，�q�回��gؓ-1�Q��ƈ�|�errno��gؓEWOULDBLOCK。但是这�U?轮询"会��CPU处于忙等待方式，从而降低性能�Q�浪费系�l�资源。而调�? select()会有效地解决�q�个问题�Q�它允许你把�q�程本��n挂�v来，而同时�ɾpȝ��内核监听所要求的一�l�文件描�q�符的�Q何活动，只要��认在�Q何被监控的文�? 描述�W�上出现�z�d��Q�select()调用��返回指�C��文�g描述�W�已准备好的信息�Q�从而实��C��E�选出随机的变化，而不必由�q�程本��n对输入进行测试而浪�? CPU开销。Select函数原型�?
int select(int numfds,fd_set *readfds,fd_set *writefds�Q?
fd_set *exceptfds,struct timeval *timeout);
　　其中readfds、writefds、exceptfds分别是被select()监视的读、写和异常处理的文�g描述�W�集合。如果你希望��定是否可以从标准输入和某个socket描述�W�读取数据，你只需要将标准输入的文件描�q�符0和相应的sockdtfd加入到readfds集合中；numfds的�? 是需要检查的��L��最高的文�g描述�W�加1�Q�这个例子中numfds的值应为sockfd+1�Q�当select�q�回�Ӟ��readfds��被修改�Q�指�C�某个文�? 描述�W�已�l�准备被��d��Q�你可以通过FD_ISSSET()来测试。�ؓ了实现fd_set中对应的文�g描述�W�的讄��、复位和��试�Q�它提供了一�l�宏�Q?
　　FD_ZERO(fd_set *set)----清除一个文件描�q�符集；
　　FD_SET(int fd,fd_set *set)----��一个文件描�q�符加入文�g描述�W�集中；
　　FD_CLR(int fd,fd_set *set)----��一个文件描�q�符从文件描�q�符集中清除�Q?
　　FD_ISSET(int fd,fd_set *set)----试判断是否文件描�q�符被置位�?
　　Timeout参数是一个指向struct timeval�c�d��的指针，它可以��select()在等待timeout长时间后没有文�g描述�W�准备好卌��回。struct timeval数据�l�构为：
　　struct timeval {
　　 int tv_sec; /* seconds */
　　 int tv_usec; /* microseconds */
};

POP3客户端实�?
　　下面的代码实例基于POP3的客户协议，与邮件服务器�q�接�q�取回指定用户帐��L��邮�g。与邮�g服务器交互的命��o存储在字�W�串数组POPMessage中，�E�序通过一个do-while循环依次发送这些命令�?
#include
#include
#include
#include
#include
#include
#include
#include
#define POP3SERVPORT 110
#define MAXDATASIZE 4096

main(int argc, char *argv[]){
int sockfd;
struct hostent *host;
struct sockaddr_in serv_addr;
char *POPMessage[]={
"USER userid\r\n",
"PASS password\r\n",
"STAT\r\n",
"LIST\r\n",
"RETR 1\r\n",
"DELE 1\r\n",
"QUIT\r\n",
NULL
};
int iLength;
int iMsg=0;
int iEnd=0;
char buf[MAXDATASIZE];

if((host=gethostbyname("your.server"))==NULL) {
perror("gethostbyname error");
exit(1);
}
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
perror("socket error");
exit(1);
}
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(POP3SERVPORT);
serv_addr.sin_addr = *((struct in_addr *)host->h_addr);
bzero(&(serv_addr.sin_zero),8);
if (connect(sockfd, (struct sockaddr *)&serv_addr,sizeof(struct sockaddr))==-1){
perror("connect error");
exit(1);
}

do {
send(sockfd,POPMessage[iMsg],strlen(POPMessage[iMsg]),0);
printf("have sent: %s",POPMessage[iMsg]);

iLength=recv(sockfd,buf+iEnd,sizeof(buf)-iEnd,0);
iEnd+=iLength;
buf[iEnd]='\0';
printf("received: %s,%d\n",buf,iMsg);

iMsg++;
} while (POPMessage[iMsg]);

close(sockfd);
}

芥之�?/a> 2006-04-27 11:46 发表评论