C语言SOCKET编程指南

1、介绍

Socket 编程让你沮丧吗?从man pages中很难得到有用的信息吗?你想跟上时代去编Internet相关的程序,但是为你在调用 connect() 前的bind() 的结构而不知所措?等等… 

    好在我已经将这些事完成了,我将和所有人共享我的知识了。如果你了解 C语言并想穿过网络编程的沼泽,那么你来对地方了。

2、读者对象 

这个文档是一个指南,而不是参考书。如果你刚开始 socket 编程并想找一本入门书,那么你是我的读者。但这不是一本完全的 socket 编程书。

3、平台和编译器 

这篇文档中的大多数代码都在 Linux 平台PC 上用 GNU 的 gcc 成功编译过。而且它们在 HPUX平台 上用 gcc 也成功编译过。但是注意,并不是每个代码片段都独立测试过。

  

目录

1、介绍

2、读者对象

3、平台和编译器

4、什么是 socket

5、Internet 套接字的两种类型

6、网络理论

7、结构体

8、本机转换

9、IP 地址和如何处理它们

10、socket()函数

11、bind()函数

12、connect()程序

13、listen()函数

14、accept()函数

15、send() and recv()函数

16、sendto() 和 recvfrom()函数

17、close()和shutdown()函数

18、getpeername()函数

19、gethostname()函数

20、域名服务(DNS

21、客户-服务器背景知识

22、简单的服务器

23、简单的客户程序

24、数据包 Sockets

25、阻塞

26、select()--多路同步 I/O

27、参考书目:

28、修改历史

4、什么是socket

  你经常听到人们谈论着 “socket”,或许你还不知道它的确切含义。现在让我告诉你:它是使用 标准Unix 文件描述符 (file descriptor) 和其它程序通讯的方式。什么?你也许听到一些Unix高手(hacker)这样说过:“呀,Unix中的一切就是文件!”那个家伙也许正在说到一个事实:Unix 程序在执行任何形式的I/O 的时候,程序是在读或者写一个文件描述符。一个文件描述符只是一个和打开的文件相关联的整数。但是(注意后面的话),这个文件可能是一个网络连接,FIFO,管道,终端,磁盘上的文件或者什么其它的东西。Unix 中所有的东西就是文件!所以,你想和Internet上别的程序通讯的时候,你将要使用到文件描述符。你必须理解刚才的话。现在你脑海中或许冒出这样的念头:“那么我从哪里得到网络通讯的文件描述符呢?”,这个问题无论如何我都要回答:你利用系统调用socket(),它返回套接字描述符 (socket descriptor),然后你再通过它来进行send() 和 recv()调用。“但是...”,你可能有很大的疑惑,“如果它是个文件描述符,那么为什么不用一般调用read()和write()来进行套接字通讯?”简单的答案是:“你可以使用!”。详细的答案是:“你可以,但是使用send()和recv()让你更好的控制数据传输。”存在这样一个情况:在我们的世界上,有很多种套接字。有DARPA Internet 地址 (Internet 套接字),本地节点的路径名(Unix套接字),CCITT X.25地址 (你可以将X.25 套接字完全忽略)。也许在你的Unix 机器上还有其它的。我们在这里只讲第一种:Internet 套接字。

5Internet 套接字的两种类型 

  什么意思?有两种类型的Internet 套接字?是的。不,我在撒谎。其实还有很多,但是我可不想吓着你。我们这里只讲两种。除了这些, 我打算另外介绍的"Raw Sockets" 也是非常强大的,很值得查阅。

那么这两种类型是什么呢?一种是"Stream Sockets"(流格式),另外一种是"Datagram Sockets"(数据包格式)。我们以后谈到它们的时候也会用到"SOCK_STREAM" 和 "SOCK_DGRAM"。数据报套接字有时也叫“无连接套接字”(如果你确实要连接的时候可以用connect()流式套接字是可靠的双向通讯的数据流。如果你向套接字按顺序输出“1,2”,那么它们将按顺序“1,2”到达另一边。它们是无错误的传递的,有自己的错误控制,在此不讨论。

    有什么在使用流式套接字?你可能听说过 telnet,不是吗?它就使用流式套接字。你需要你所输入的字符按顺序到达,不是吗?同样,WWW浏览器使用的 HTTP协议也使用它们来下载页面。实际上,当你通过端口80 telnet 到一个 WWW 站点,然后输入 “GET pagename” 的时候,你也可以得到 HTML 的内容。为什么流式套接字可以达到高质量的数据传输?这是因为它使用了“传输控制协议 (The Transmission Control Protocol)”,也叫 “TCP” (请参考 RFC-793 获得详细资料。)TCP 控制你的数据按顺序到达并且没有错

误。你也许听到 “TCP” 是因为听到过 “TCP/IP”。这里的 IP 是指“Internet 协议”(请参考 RFC-791。) IP 只是处理Internet 路由而已。 

    那么数据报套接字呢?为什么它叫无连接呢?为什么它是不可靠的呢?有这样的一些事实:如果你发送一个数据报,它可能会到达,它可能次序颠倒了。如果它到达,那么在这个包的内部是无错误的。数据报也使用 IP 作路由,但是它不使用TCP。它使用“用户数据报协议 (User Datagram Protocol)”,也叫 “UDP”(请参考 RFC-768。)

    为什么它们是无连接的呢?主要是因为它并不象流式套接字那样维持一个连接。你只要建立一个包,构造一个有目标信息的IP 头,然后发出去。无需连接。它们通常使用于传输包-包信息。简单的应用程序有:tftp, bootp等等。

    你也许会想:“假如数据丢失了这些程序如何正常工作?”我的朋友,每个程序在 UDP 上有自己的协议。例如,tftp 协议每发出的一个被接受到包,收到者必须发回一个包来说“我收到了!” (一个“命令正确应答”也叫“ACK” 包)。如果在一定时间内(例如5秒),发送方没有收到应答,它将重新发送,直到得到ACK。这一ACK过程在实现SOCK_DGRAM 应用程序的时候非常重要。

6、网络理论

  既然我刚才提到了协议层,那么现在是讨论网络究竟如何工作和一些 关于SOCK_DGRAM 包是如何建立的例子。当然,你也可以跳过这一段, 如果你认为已经熟悉的话。 

    现在是学习数据封装 (Data Encapsulation) 的时候了!它非常非常重 要。它重要性重要到你在网络课程学(图1:数据封装)习中无论如何也得也得掌握它。主要的内容是:一个包,先是被第一个协议(在这里是TFTP )在它的报头(也许 是报尾)包装(“封装”),然后,整个数据(包括 TFTP 头)被另外一个协议(在这里是 UDP )封装,然后下一个( IP ),一直重复下去,直到硬件(物理) 层(这里是以太网 )。 

当另外一台机器接收到包,硬件先剥去以太网头,内核剥去IP和UDP 头,TFTP程序再剥去TFTP头,最后得到数据。现在我们终于讲到声名狼藉的网络分层模型(Layered Network Model)。这种网络模型在描述网络系统上相对其它模型有很多优点。例如, 你可以写一个套接字程序而不用关心数据的物理传输(串行口,以太网,连 接单元接口 (AUI) 还是其它介质),因为底层的程序会为你处理它们。实际 的网络硬件和拓扑对于程序员来说是透明的。

不说其它废话了,我现在列出整个层次模型。如果你要参加网络考试, 可一定要记住: 

应用层 (Application)

表示层 (Presentation)

会话层 (Session)

传输层(Transport)

网络层(Network)

数据链路层(Data Link)

物理层(Physical)

物理层是硬件(串口,以太网等等)。应用层是和硬件层相隔最远的--它是用户和网络交互的地方。 

这个模型如此通用,如果你想,你可以把它作为修车指南。把它对应 到 Unix,结果是:

应用层(Application Layer) (telnet, ftp,等等)

传输层(Host-to-Host Transport Layer) (TCP, UDP)

Internet层(Internet Layer) (IP和路由)

网络访问层 (Network Access Layer) (网络层,数据链路层和物理层)

现在,你可能看到这些层次如何协调来封装原始的数据了。 

看看建立一个简单的数据包有多少工作?哎呀,你将不得不使用 "cat" 来建立数据包头!这仅仅是个玩笑。对于流式套接字你要作的是 send() 发送数据。对于数据报式套接字,你按照你选择的方式封装数据然后使用sendto()。内核将为你建立传输层和 Internet 层,硬件完成网络访问层。 这就是现代科技。 

现在结束我们的网络理论速成班。哦,忘记告诉你关于路由的事情了。 但是我不准备谈它,如果你真的关心,那么参考 IP RFC。

7、结构体 

  终于谈到编程了。在这章,我将谈到被套接字用到的各种数据类型。 因为它们中的一些内容很重要了。 

首先是简单的一个:socket描述符。它是下面的类型: 

int 

仅仅是一个常见的 int。 

从现在起,事情变得不可思议了,而你所需做的就是继续看下去。注意这样的事实:有两种字节排列顺序:重要的字节 (有时叫"octet",即八位位组) 在前面,或者不重要的字节在前面。前一种叫“网络字节顺序 (Network Byte Order,NBO)”。有些机器在内部是按照这个顺序储存数据,而另外一些则不然。当我说某数据必须按照 NBO 顺序,那么你要调用函数(例如htons() )来将它从本机字节顺序(Host Byte Order) 转换过来。如果我没有提到 NBO, 那么就让它保持本机字节顺序。

我的第一个结构(在这个技术手册TM中)--struct sockaddr.。这个结构为许多类型的套接字储存套接字地址信息: 

struct sockaddr

   unsigned short sa_family;

     char sa_data[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;  

   unsigned char sin_zero[8];  

}; 

用这个数据结构可以轻松处理套接字地址的基本元素。注意 sin_zero (它被加入到这个结构,并且长度和 struct sockaddr 一样) 应该使用函数 bzero()或memset() 来全部置零。 同时,这一重要的字节,一个指向 sockaddr_in结构体的指针也可以被指向结构体sockaddr并且代替它。这样的话即使 socket() 想要的是 struct sockaddr *,你仍然可以使用 struct sockaddr_in,并且在最后转换。同时,注意 sin_family 和 struct sockaddr 中的 sa_family 一致并能够设置为 "AF_INET"。最后,sin_port和 sin_addr 必须是网络字节顺序(Network Byte Order)!

 

struct sockaddr
{
   unsigned short int sa_family;
   char sa_data[14];
};
1、sa_family 为调用socket()时的domain 参数, 即AF_xxxx 值.
2、sa_data 最多使用14 个字符长度.

此sockaddr 结构会因使用不同的socket domain 而有不同结构定义, 例如使用AF_INET domain,其socketaddr 结构定义便为
struct socketaddr_in
{
   unsigned short int sin_family;
   uint16_t sin_port;
   struct in_addr sin_addr;
   unsigned char sin_zero[8];
};

struct in_addr
{
   uint32_t s_addr;
};
1、sin_family 即为sa_family
2、sin_port 为使用的port 编号
3、sin_addr. s_addr 为IP 地址 sin_zero 未使用.
参数 addrlen 为sockaddr 的结构长度.

 

你也许会反对道:"但是,怎么让整个数据结构 struct in_addr sin_addr 按照网络字节顺序呢?" 要知道这个问题的答案,我们就要仔细的看一看这 个数据结构: struct in_addr, 有这样一个联合 (unions): 

 

struct in_addr

   unsigned long s_addr; 

}; 

它曾经是个最坏的联合,但是现在那些日子过去了。如果你声明 "ina" 是数据结构 struct sockaddr_in 的实例,那么 "ina.sin_addr.s_addr" 就储存4字节的 IP 地址(使用网络字节顺序)。如果你不幸的系统使用的还是恐怖的联合struct in_addr ,你还是可以放心4字节的 IP 地址并且和上面我说的一样(这是因为使用了“#define”。

8、本机转换

  我们现在到了新的章节。我们曾经讲了很多网络到本机字节顺序的转 换,现在可以实践了! 

你能够转换两种类型: 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 没有发送到网络上,它们可以是本机字节顺序。 

9IP 地址和如何处理它们

现在我们很幸运,因为我们有很多的函数来方便地操作 IP 地址。没有 必要用手工计算它们,也没有必要用"<<"操作来储存成长整字型。 首先,假设你已经有了一个sockaddr_in结构体ina,你有一个IP地 址"132.241.5.10"要储存在其中,你就要用到函数inet_addr(),将IP地址从 点数格式转换成无符号长整型。使用方法如下:

ina.sin_addr.s_addr = inet_addr("132.241.5.10");

注意,inet_addr()返回的地址已经是网络字节格式,所以你无需再调用 函数htonl()

我们现在发现上面的代码片断不是十分完整的,因为它没有错误检查。 显而易见,当inet_addr()发生错误时返回-1。记住这些二进制数字?(无符 号数)-1仅仅和IP地址255.255.255.255相符合!这可是广播地址!大错特错!记住要先进行错误检查。

好了,现在你可以将IP地址转换成长整型了。有没有其相反的方法呢? 它可以将一个in_addr结构体输出成点数格式?这样的话,你就要用到函数 inet_ntoa()("ntoa"的含义是"network to ascii"),就像这样: 

printf("%s",inet_ntoa(ina.sin_addr));

它将输出IP地址。需要注意的是inet_ntoa()将结构体in-addr作为一 个参数,不是长整形。同样需要注意的是它返回的是一个指向一个字符的 指针。它是一个由inet_ntoa()控制的静态的固定的指针,所以每次调用 inet_ntoa(),它就将覆盖上次调用时所得的IP地址。例如:

char *a1, *a2;

a1 = inet_ntoa(ina1.sin_addr);

a2 = inet_ntoa(ina2.sin_addr);

printf("address 1: %s/n",a1);

printf("address 2: %s/n",a2);

 

输出如下:

 

address 1: 132.241.5.10

address 2: 132.241.5.10

假如你需要保存这个IP地址,使用strcopy()函数来指向你自己的字符 指针。

上面就是关于这个主题的介绍。稍后,你将学习将一个类 似"wintehouse.gov"的字符串转换成它所对应的IP地址(查阅域名服务,稍 后)。

10socket()函数 

我想我不能再不提这个了-下面我将讨论一下socket()系统调用。

下面是详细介绍:

#include <sys/types.h> 

#include <sys/socket.h> 

int socket(int domain, int type, int protocol); 

但是它们的参数是什么? 首先,domain 应该设置成"AF_INET",就象上面的数据结构struct sockaddr_in 中一样。然后,参数 type 告诉内核是 SOCK_STREAM类型还是SOCK_DGRAM 类型。最后,把 protocol 设置为 "0"。(注意:有很多种domain、type,我不可能一一列出了,请看 socket() 的 man帮助。当然,还有一个"更好"的方式去得到 protocol。同时请查阅 getprotobyname() 的 man帮助。

socket() 只是返回你以后在系统调用中可能用到的 socket 描述符,或者在错误的时候返回-1。全局变量 errno 中将储存返回的错误值。(请参考 perror() 的man 帮助。

11bind()函数

  一旦你有一个套接字,你可能要将套接字和机器上的一定的端口关联起来。(如果你想用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 

void  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("132.241.5.10"); 

   bzero(&(my_addr.sin_zero),8);   

   bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr));

}

这里也有要注意的几件事情。my_addr.sin_port 是网络字节顺序,my_addr.sin_addr.s_addr 也是的。另外要注意到的事情是因系统的不同, 包含的头文件也不尽相同,请查阅本地的 man 帮助文件。

在 bind() 主题中最后要说的话是,在处理自己的 IP 地址和/或端口的时候,有些工作是可以自动处理的。

my_addr.sin_port = 0;  

my_addr.sin_addr.s_addr = INADDR_ANY;  

通过将0赋给 my_addr.sin_port,你告诉 bind() 自己选择合适的端 口。同样,将my_addr.sin_addr.s_addr 设置为 INADDR_ANY,你告诉它自动填上它所运行的机器de 的 IP 地址。

如果你一向小心谨慎,那么你可能注意到我没有将 INADDR_ANY 转换为网络字节顺序!这是因为我知道内部的东西:INADDR_ANY 实际上就是 0!即使你改变字节的顺序,0依然是0。但是完美主义者说应该处处一 致,INADDR_ANY或许是12呢?你的代码就不能工作了,那么就看下面的代码:

my_addr.sin_port = htons(0);  

my_addr.sin_addr.s_addr = htonl(INADDR_ANY); 

你或许不相信,上面的代码将可以随便移植。我只是想指出,既然你所遇到的程序不会都运行使用htonl的INADDR_ANY。

bind() 在错误的时候依然是返回-1,并且设置全局错误变量errno。 

在你调用 bind() 的时候,你要小心的另一件事情是:不要采用小于 1024的端口号。所有小于1024的端口号都被系统保留!你可以选择从1024 到65535的端口(如果它们没有被别的程序使用的话)。

你要注意的另外一件小事是:有时候你根本不需要调用它。如果你使用connect()来和远程机器进行通讯,你不需要关心你的本地端口号(就象你在使用telnet 的时候),你只要简单的调用 connect() 就可以了,它会检查套接字是否绑定端口,如果没有,它会自己绑定一个没有使用的本地端口

12connect()程序

  现在我们假设你是个 telnet 程序。你的用户命令你得到套接字的文件描述符。你听从命令调用了socket()。下一步,你的用户告诉你通过端口23(标准telnet 端口)连接到"132.241.5.10"。你该怎么做呢? 幸运的是,你正在阅读connect()--如何连接到远程主机这一章。你可不想让你的用户失望。 

connect() 系统调用是这样的: 

#include <sys/types.h> 

#include <sys/socket.h>

int connect(int sockfd, struct sockaddr *serv_addr, int addrlen); 

 

sockfd 是系统调用socket() 返回的套接字文件描述符。serv_addr 是保存着目的地端口和 IP 地址的数据结构 struct sockaddr。addrlen 设置 为sizeof(struct sockaddr)。 

想知道得更多吗?让我们来看个例子: 

#include <string.h> 

#include <sys/types.h> 

#include <sys/socket.h> 

#define DEST_IP "132.241.5.10" 

#define DEST_PORT 23 

main() 

  int sockfd; 

  struct sockaddr_in dest_addr;  

  sockfd = socket(AF_INET, SOCK_STREAM, 0);  

  dest_addr.sin_family = AF_INET;  

  dest_addr.sin_port = htons(DEST_PORT);  

  dest_addr.sin_addr.s_addr = inet_addr(DEST_IP); 

  bzero(&(dest_addr.sin_zero),8);  

    connect(sockfd, (struct sockaddr *)&dest_addr, sizeof(struct sockaddr));

  再一次,你应该检查 connect() 的返回值--它在错误的时候返回-1,设置全局错误变量 errno 

同时,你可能看到,我没有调用 bind()。因为我不在乎本地的端口号。 我只关心我要去那。内核将为我选择一个合适的端口号,而我们所连接的地方也自动地获得这些信息。一切都不用担心。 

13listen()函数

  是换换内容得时候了。假如你不希望与远程的一个地址相连,或者说,仅仅是将它踢开,那你就需要等待接入请求并且用各种方法处理它们。处理过程分两步:首先,你听--listen(),然后,你接受--accept() (请看下面的内容)。

除了要一点解释外,系统调用 listen 也相当简单。

int listen(int sockfd, int backlog); 

sockfd 是调用socket() 返回的套接字文件描述符。backlog 是在进入队列中允许的连接数目。什么意思呢? 进入的连接是在队列中一直等待直到你接受(accept() 请看下面的文章)连接。它们的数目限制于队列的允许。大多数系统的允许数目是20,你也可以设置为5到10。

和别的函数一样,在发生错误的时候返回-1,并设置全局错误变量errno。

你可能想象到了,在你调用 listen() 前你或者要调用bind()或者让内核随便选择一个端口。如果你想侦听进入的连接,那么系统调用的顺序可能是这样的: 

socket(); 

bind(); 

listen();  

因为它相当的明了,我将在这里不给出例子了。(在 accept() 那一章的 代码将更加完全。)真正麻烦的部分在 accept()。 

14accept()函数

  准备好了,系统调用 accept() 会有点古怪的地方的!你可以想象发生这样的事情:有人从很远的地方通过一个你在侦听 (listen()) 的端口连接(connect()) 到你的机器。它的连接将加入到等待接受 (accept()) 的队列中。你调用 accept() 告诉它你有空闲的连接。它将返回一个新的套接字文件描述符!这样你就有两个套接字了,原来的一个还在侦听你的那个端口, 新的在准备发送 (send()) 和接收 ( recv()) 数据。这就是这个过程!

函数是这样定义的: 

头文件:#include <sys/types.h>   #include <sys/socket.h>

定义函数:int accept(int s, struct sockaddr * addr, int * addrlen);

函数说明:accept()用来接受参数s 的socket 连线. 参数s 的socket 必需先经bind()、listen()函数处理过, 当有连线进来时accept()会返回一个新的socket 处理代码, 往后的数据传送与读取就是经由新的socket处理, 而原来参数s 的socket 能继续使用accept()来接受新的连线要求. 连线成功时, 参数addr 所指的结构会被系统填入远程主机的地址数据, 参数addrlen 为scokaddr 的结构长度. 关于机构sockaddr 的定义请参考bind().

返回值:成功则返回新的socket 处理代码, 失败返回-1, 错误原因存于errno 中.

错误代码:
1、EBADF 参数s 非合法socket 处理代码.
2、EFAULT 参数addr 指针指向无法存取的内存空间.
3、ENOTSOCK 参数s 为一文件描述词, 非socket.
4、EOPNOTSUPP 指定的socket 并非SOCK_STREAM.
5、EPERM 防火墙拒绝此连线.
6、ENOBUFS 系统的缓冲内存不足.
7、ENOMEM 核心内存不足.

现在是你应该熟悉的代码片段。 

#include <string.h>

#include <sys/socket.h>

#include <sys/types.h>

#define MYPORT 3490  

#define BACKLOG 10  

main()  

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

       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() 中你应该使用新的套接字描述符 new_fd。如果你只想让一个连接进来,那么你可以使用 close() 去关闭原 来的文件描述符sockfd 来避免同一个端口更多的连接。 

15send() and recv()函数

  这两个函数用于流式套接字或者数据报套接字的通讯。如果你喜欢使用无连接的数据报套接字,你应该看一看下面关于sendto() 和recvfrom() 的章节。

send() 是这样的:

int send(int sockfd, const void *msg, int len, int flags); 

sockfd 是你想发送数据的套接字描述符(或者是调用 socket() 或者是accept()返回的。)msg 是指向你想发送的数据的指针。len 是数据的长度。 把 flags 设置为 0 就可以了。(详细的资料请看send() 的 man page)。 

这里是一些可能的例子:

char *msg = "Beej was here!"; 

int len, bytes_sent;

len = strlen(msg);

bytes_sent = send(sockfd, msg, len, 0); 

send() 返回实际发送的数据的字节数--它可能小于你要求发送的数目! 注意,有时候你告诉它要发送一堆数据可是它不能处理成功。它只是发送它可能发送的数据,然后希望你能够发送其它的数据。记住,如果 send() 返回的数据和 len不匹配,你就应该发送其它的数据。但是这里也 有个好消息:如果你要发送的包很小(小于大约 1K),它可能处理让数据一 次发送完。最后要说得就是,它在错误的时候返回-1,并设置 errno。

recv() 函数很相似:

int recv(int sockfd, void *buf, int len, unsigned int flags);

sockfd 是要读的套接字描述符。buf 是要读的信息的缓冲。len 是缓 冲的最大长度。flags 可以设置为0。(请参考recv() 的 man page。) recv() 返回实际读入缓冲的数据的字节数。或者在错误的时候返回-1, 同时设置 errno。

很简单,不是吗? 你现在可以在流式套接字上发送数据和接收数据了。 你现在是Unix 网络程序员了!

16sendto() 和 recvfrom()函数

  “这很不错啊”,你说,“但是你还没有讲无连接数据报套接字呢?” 没问题,现在我们开始这个内容。

既然数据报套接字不是连接到远程主机的,那么在我们发送一个包之 前需要什么信息呢? 不错,是目标地址!看看下面的:

int sendto(int sockfd, const void *msg, int len, unsigned int flags, 

    const struct sockaddr *to, int tolen); 

你已经看到了,除了另外的两个信息外,其余的和函数 send() 是一样 的。 to是个指向数据结构 struct sockaddr 的指针,它包含了目的地的 IP 地址和端口信息tolen 可以简单地设置为 sizeof(struct sockaddr)。 和函数 send()类似,sendto() 返回实际发送的字节数(它也可能小于你想要发送的字节数!),或者在错误的时候返回 -1

相似的还有函数 recv() 和 recvfrom()。recvfrom() 的定义是这样的:

int recvfrom(int sockfd, void *buf, int len, unsigned int flags,  

    struct sockaddr *from, int *fromlen);

又一次,除了两个增加的参数外,这个函数和 recv() 也是一样的。from 是一个指向局部数据结构 struct sockaddr 的指针,它的内容是源机器的 IP 地址和端口信息fromlen 是个 int 型的局部指针,它的初始值为 sizeof(struct sockaddr)。函数调用返回后,fromlen 保存着实际储存在 from 中的地址的长度。

recvfrom() 返回收到的字节长度,或者在发生错误后返回 -1。

记住,如果你用 connect() 连接一个数据报套接字(即UDP(SOCK_DGRAM),非TCP(SOCK_STREAM)),你可以简单的调用 send()和 recv() 来满足你的要求。这个时候依然是数据报套接字,依然使用 UDP,系统套接字接口会为你自动加上了目标和源的信息

17close()和shutdown()函数

  你已经整天都在发送 (send()) 和接收 (recv()) 数据了,现在你准备关闭你的套接字描述符了。这很简单,你可以使用一般的 Unix 文件描述符 的close() 函数:

  close(sockfd);

它将防止套接字上更多的数据的读写。任何在另一端读写套接字的企图都将返回错误信息。

如果你想在如何关闭套接字上有多一点的控制,你可以使用函数 shutdown()。它允许你将一定方向上的通讯或者双向的通讯(就象close()一 样)关闭,你可以使用:

int shutdown(int sockfd, int how); 

sockfd 是你想要关闭的套接字文件描述复。how 的值是下面的其中之 一:

  0 - 不允许接受

  1 - 不允许发送

  2 - 不允许发送和接受(和close() 一样)

shutdown() 成功时返回 0,失败时返回 -1(同时设置 errno。如果在无连接的数据报套接字中使用shutdown(),那么只不过是让 send() 和 recv() 不能使用(记住你在数据报套接字中使用了 connect 后 是可以使用它们的)。

18getpeername()函数

  这个函数太简单了。

它太简单了,以至我都不想单列一章。但是我还是这样做了。 函数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 以获得更多的信息。

19gethostname()函数

  甚至比 getpeername() 还简单的函数是 gethostname()。它返回你程序所运行的机器的主机名字。然后你可以使用 gethostbyname() 以获得你的机器的IP 地址

  下面是定义:

  #include <unistd.h>

int gethostname(char *hostname, size_t size);

参数很简单:hostname 是一个字符数组指针,它将在函数返回时保存

主机名。size是hostname 数组的字节长度。

函数调用成功时返回 0,失败时返回 -1,并设置errno。

20、域名服务(DNS)

  如果你不知道 DNS 的意思,那么我告诉你,它代表域名服务(Domain Name Service)。它主要的功能是:你给它一个容易记忆的某站点的地址, 它给你 IP地址(然后你就可以使用 bind(), connect(), sendto() 或者其它 函数) 。当一个人输入:

   $ telnet whitehouse.gov 

telnet 能知道它将连接(connect()) 到 "198.137.240.100"。 

但是这是如何工作的呢? 你可以调用函数 gethostbyname(): 

#include <netdb.h>

  struct hostent *gethostbyname(const char *name); 

很明白的是,它返回一个指向 struct hostent 的指针。这个数据结构 是这样的:

struct hostent

{

   char *h_name;

   char **h_aliases;

   int h_addrtype;

   int h_length;

   char **h_addr_list;

};

   #define h_addr h_addr_list[0] 

这里是这个数据结构的详细资料: 

struct hostent: 

  h_name - 地址的正式名称。

  h_aliases - 空字节-地址的预备名称的指针。

  h_addrtype -地址类型; 通常是AF_INET。 

  h_length - 地址的比特长度。

  h_addr_list - 零字节-主机网络地址指针。网络字节顺序。

  h_addr - h_addr_list中的第一地址。

gethostbyname() 成功时返回一个指向结构体 hostent 的指针,或者 是个空(NULL) 指针。(但是和以前不同,不设置errno,h_errno 设置错 误信息。请看下面的 herror()。

但是如何使用呢? 有时候(我们可以从电脑手册中发现),向读者灌输信息是不够的。这个函数可不象它看上去那么难用。

这里是个例子:

#include <stdio.h>

#include <stdlib.h>

#include <errno.h>

#include <netdb.h>

#include <sys/types.h>

#include <netinet/in.h>

int main(int argc, char *argv[])

{

   struct hostent *h;

if (argc != 2)

{

                   fprintf(stderr,"usage: getip 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 *,然后得到数据

21、客户-服务器背景知识

  这里是个客户--服务器的世界。在网络上的所有东西都是在处理客户进程和服务器进程的交谈。举个telnet 的例子。当你用 telnet (客户)通过23号端口登陆到主机,主机上运行的一个程序(一般叫 telnetd,服务器)激活。 它处理这个连接,显示登陆界面,等等。

 

2:客户机和服务器的关系

图 2 说明了客户和服务器之间的信息交换。 

注意,客户--服务器之间可以使用SOCK_STREAM、SOCK_DGRAM 或者其它(只要它们采用相同的)。一些很好的客户--服务器的例子有telnet/telnetd、 ftp/ftpd 和bootp/bootpd。每次你使用 ftp 的时候,在远端都有一个 ftpd 为你服务。 

一般,在服务端只有一个服务器,它采用 fork() 来处理多个客户的连 接。基本的程序是:服务器等待一个连接,接受(accept()) 连接,然后 fork() 一个子进程处理它。这是下一章我们的例子中会讲到的。

22、简单的服务器

  这个服务器所做的全部工作是在流式连接上发送字符串 "Hello, World!/n"。你要测试这个程序的话,可以在一台机器上运行该程序,然后在另外一机器上登陆: 

   $ telnet remotehostname 3490 

remotehostname 是该程序运行的机器的名字。 

服务器代码: 

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <errno.h>
 4 #include <string.h>
 5 #include <sys/types.h>
 6 #include <netinet/in.h>
 7 #include <sys/socket.h>
 8 #include <sys/wait.h>
 9 #define MYPORT 3490  
10 #define BACKLOG 10  
11 
12 main() 
13 { 
14     int sockfd, new_fd;  
15     struct sockaddr_in my_addr;  
16     struct sockaddr_in their_addr;  
17     int sin_size;
18     if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
19    { 
20           perror("socket"); 
21           exit(1); 
22     }
23    my_addr.sin_family = AF_INET;  
24    my_addr.sin_port = htons(MYPORT);  
25    my_addr.sin_addr.s_addr = INADDR_ANY;  
26    bzero(&(my_addr.sin_zero),8);
27    if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr))== -1)
28   { 
29          perror("bind"); 
30          exit(1); 
31     } 
32   if (listen(sockfd, BACKLOG) == -1)
33   { 
34          perror("listen"); 
35          exit(1); 
36   }
37   while(1) {  
38      sin_size = sizeof(struct sockaddr_in); 
39     if ((new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size)) == -1)
40     { 
41            perror("accept"); 
42            continue; 
43     } 
44     printf("server: got connection from %s/n", / 
45     inet_ntoa(their_addr.sin_addr)); 
46     if (!fork())
47     {  
48           if (send(new_fd, "Hello, world!/n", 14, 0) == -1) 
49              perror("send"); 
50           close(new_fd); 
51           exit(0); 
52       } 
53     close(new_fd);  
54     while(waitpid(-1,NULL,WNOHANG) > 0);  
55   } 
56 } 

 

如果你很挑剔的话,一定不满意我所有的代码都在一个很大的main() 函数中。如果你不喜欢,可以划分得更细点。

你也可以用我们下一章中的程序得到服务器端发送的字符串。

23、简单的客户程序 

  这个程序比服务器还简单。这个程序的所有工作是通过 3490 端口连接到命令行中指定的主机,然后得到服务器发送的字符串。 

客户代码

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <errno.h>
 4 #include <string.h>
 5 #include <sys/types.h>
 6 #include <netinet/in.h>
 7 #include <sys/socket.h>
 8 #include <sys/wait.h>
 9 
10 #define PORT 3490  
11 #define MAXDATASIZE 100  
12 
13 int main(int argc, char *argv[]) 
14 { 
15     int sockfd, numbytes; 
16     char buf[MAXDATASIZE]; 
17     struct hostent *he; 
18     struct sockaddr_in their_addr;  
19      if (argc != 2)
20      { 
21          Fprintf(stderr,"usage: client hostname/n"); 
22         exit(1); 
23     } 
24      if ((he=gethostbyname(argv[1])) == NULL)
25      {  
26           herror("gethostbyname"); 
27           exit(1); 
28      }
29      if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
30      { 
31           perror("socket"); 
32           exit(1); 
33     }
34       their_addr.sin_family = AF_INET;  
35      their_addr.sin_port = htons(PORT);  
36      their_addr.sin_addr = *((struct in_addr *)he->h_addr); 
37      bzero(&(their_addr.sin_zero),;  
38       if (connect(sockfd, (struct sockaddr *)&their_addr,sizeof(struct sockaddr)) == -1)
39       { 
40           perror("connect"); 
41           exit(1); 
42     } 
43       if ((numbytes=recv(sockfd, buf, MAXDATASIZE, 0)) == -1)
44       { 
45           perror("recv"); 
46           exit(1); 
47     } 
48       buf[numbytes] = '/0'; 
49       printf("Received: %s",buf); 
50       close(sockfd);  
51       return 0; 
52  }                                                         

注意,如果你在运行服务器之前运行客户程序,connect() 将返回 "Connection refused" 信息,这非常有用。

 

24、数据包Sockets 

我不想讲更多了,所以我给出代码 talker.c 和 listener.c。 

listener 在机器上等待在端口4590 来的数据包。talker 发送数据包到一定的机器,它包含用户在命令行输入的内容。 

这里就是 listener.c: 

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <errno.h>
 4 #include <string.h>
 5 #include <sys/types.h>
 6 #include <netinet/in.h>
 7 #include <sys/socket.h>
 8 #include <sys/wait.h>
 9 
10 #define MYPORT 4950  
11 #define MAXBUFLEN 100 
12 
13 void main() 
14 { 
15     int sockfd; 
16     struct sockaddr_in my_addr;  
17     struct sockaddr_in their_addr;  
18     int addr_len, numbytes; 
19     char buf[MAXBUFLEN]; 
20      if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
21       { 
22           perror("socket"); 
23           exit(1); 
24     } 
25      my_addr.sin_family = AF_INET;  
26     my_addr.sin_port = htons(MYPORT);  
27     my_addr.sin_addr.s_addr = INADDR_ANY;  
28     bzero(&(my_addr.sin_zero),;  
29      if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr))==-1) { 
30            perror("bind"); 
31            exit(1); 
32     }
33       addr_len = sizeof(struct sockaddr); 
34     if ((numbytes=recvfrom(sockfd, buf, MAXBUFLEN, 0, / 
35     (struct sockaddr *)&their_addr, &addr_len)) == -1)
36       { 
37            perror("recvfrom"); 
38            exit(1); 
39     } 
40      printf("got packet from %s/n",inet_ntoa(their_addr.sin_addr)); 
41     printf("packet is %d bytes long/n",numbytes); 
42     buf[numbytes] = '/0'; 
43     printf("packet contains /"%s/"/n",buf); 
44     close(sockfd); 
45 } 

注意在我们的调用 socket(),我们最后使用了 SOCK_DGRAM。同时, 没有必要去使用 listen() 或者 accept()。我们在使用无连接的数据报套接字! 

下面是 talker.c: 

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <errno.h>
 4 #include <string.h>
 5 #include <sys/types.h>
 6 #include <netinet/in.h>
 7 #include <sys/socket.h>
 8 #include <sys/wait.h>
 9 #define MYPORT 4950  
10 
11 int main(int argc, char *argv[]) 
12 { 
13     int sockfd; 
14     struct sockaddr_in their_addr;  
15     struct hostent *he; 
16     int numbytes;
17       if (argc != 3)
18       { 
19            fprintf(stderr,"usage: talker hostname message/n"); 
20            exit(1); 
21     }
22       if ((he=gethostbyname(argv[1])) == NULL)
23       {  
24           herror("gethostbyname"); 
25           exit(1); 
26     }
27      if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
28      { 
29           perror("socket"); 
30           exit(1); 
31    }
32      their_addr.sin_family = AF_INET;  
33     their_addr.sin_port = htons(MYPORT);  
34     their_addr.sin_addr = *((struct in_addr *)he->h_addr); 
35     bzero(&(their_addr.sin_zero),8);  
36       if ((numbytes=sendto(sockfd, argv[2], strlen(argv[2]), 0, / 
37     (struct sockaddr *)&their_addr, sizeof(struct sockaddr))) == -1)
38       { 
39           perror("sendto"); 
40           exit(1); 
41     } 
42       printf("sent %d bytes to %s /n",numbytes,inet_ntoa(their_addr.sin_addr)); 
43       close(sockfd); 
44       return 0; 
45 }                  

这就是所有的了。在一台机器上运行 listener,然后在另外一台机器上运行talker。观察它们的通讯!

除了一些我在上面提到的数据流套接字连接的小细节外,对于数据流套接字,我还得说一些,当一个讲话者呼叫connect()函数时并指定接受者的地址时,从这点可以看出,讲话者只能向connect()函数指定的地址发送和接受信息。因此,你不需要使用sendto()和recvfrom(),你完全可以用send() 和recv()代替。

25、阻塞 

  阻塞,你也许早就听说了。"阻塞"是"sleep" 的科技行话。你可能注意到前面运行的listener程序,它在那里不停地运行,等待数据包的到来。实际在运行的是它调用 recvfrom(),然后没有数据,因此recvfrom() 说" 阻塞(block)",直到数据的到来。

很多函数都利用阻塞。accept() 阻塞,所有的 recv*() 函数阻塞。它们之所以能这样做是因为它们被允许这样做。当你第一次调用 socket() 建立套接字描述符的时候,内核就将它设置为阻塞。如果你不想套接字阻塞, 你就要调用函数fcntl(): 

#include <unistd.h>

#include <fontl.h>

sockfd = socket(AF_INET, SOCK_STREAM, 0); 

fcntl(sockfd, F_SETFL, O_NONBLOCK); 

  通过设置套接字为非阻塞,你能够有效地"询问"套接字以获得信息。如果你尝试着从一个非阻塞的套接字读信息并且没有任何数据,它不允许阻塞--它将返回 -1 并将errno 设置为 EWOULDBLOCK。 

但是一般说来,这种询问不是个好主意。如果你让你的程序在忙等状态查询套接字的数据,你将浪费大量的 CPU 时间。更好的解决之道是用下一章讲的select()去查询是否有数据要读进来。

26select()--多路同步 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;  

   int tv_usec;  

}; 

只要将 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 秒: 

 1 #include <sys/time.h>
 2 #include <sys/types.h>
 3 #include <unistd.h>
 4 #define STDIN 0  
 5 
 6 void main() 
 7 { 
 8     struct timeval tv; 
 9     fd_set readfds; 
10     tv.tv_sec = 2; 
11     tv.tv_usec = 500000; 
12     FD_ZERO(&readfds); 
13     FD_SET(STDIN, &readfds); 
14     select(STDIN+1, &readfds, NULL, NULL, &tv); 
15     if (FD_ISSET(STDIN, &readfds)) 
16         printf("A key was pressed!/n"); 
17     else 
18         printf("Timed out./n"); 
19 }     

 

如果你是在一个 line buffered 终端上,那么你敲的键应该是回车 (RETURN),否则无论如何它都会超时。

现在,你可能回认为这就是在数据报套接字上等待数据的方式--你是对 的:它可能是。有些 Unix 系统可以按这种方式,而另外一些则不能。你 在尝试以前可能要先看看本系统的 man page 了。

最后一件关于 select() 的事情:如果你有一个正在侦听 (listen()) 的套 接字,你可以通过将该套接字的文件描述符加入到 readfds 集合中来看是 否有新的连接。

这就是我关于函数select() 要讲的所有的东西。

27、参考书目: 

  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. There is a third edition of 

this set which covers IPv6 and IP over ATM. 

  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. 

  On the web: 

  BSD Sockets: A Quick And Dirty Primer 

  (http://www.cs.umn.edu/~bentlema/unix/--has other great Unix 

system programming info, too!) 

Client-Server Computing 

  (http://pandonia.canberra.edu.au/ClientServer/socket.html) 

Intro to TCP/IP (gopher)

(gopher://gopher-chem.ucdavis.edu/11/Index/Internet_aw/Intro_the_Inter

 

net/intro.to.ip/) 

Internet Protocol Frequently Asked Questions (France) 

  (http://web.cnam.fr/Network/TCP-IP/) 

The Unix Socket FAQ 

  (http://www.ibrado.com/sock-faq/) 

RFCs--the real dirt: 

RFC-768 -- The User Datagram Protocol

28、修改历史

版本

修改描述

修改时间

V1.0

初始版本

2012-08-14

 

 

 

 

 

转自:http://blog.sina.com.cn/s/blog_79b01f66010163q3.html

 

 

posted on 2016-06-23 09:44  苦涩的茶  阅读(30308)  评论(0编辑  收藏  举报