<!--@page { margin: 2cm }P { margin-bottom: 0.21cm }-->
网络socket编程指南
介绍 Socket编程让你沮丧吗？从manpages中很难得到有用的信息吗？你想跟上时代去编Internet相关的程序，但是为你在调用connect() 前的bind()的结构而不知所措？等等… 好在我已经将这些事完成了，我将和所有人共享我的知识了。如果你了解C 语言并想穿过网络编程的沼泽，那么你来对地方了。
--------------------------------------------------------------------------------
读者对象 这个文档是一个指南，而不是参考书。如果你刚开始socket 编程并想找一本入门书，那么你是我的读者。但这不是一本完全的socket 编程书。
--------------------------------------------------------------------------------
平台和编译器 这篇文档中的大多数代码都在Linux 平台PC上用 GNU 的 gcc成功编译过。而且它们在 HPUX平台上用 gcc也成功编译过。但是注意，并不是每个代码片段都独立测试过。 --------------------------------------------------------------------------------
目录： 1)什么是套接字？ 2)Internet 套接字的两种类型 3)网络理论 4) 结构体 5)本机转换 6) IP地址和如何处理它们 7)socket()函数 bind()函数 9)connect()函数 10)listen()函数 11)accept()函数 12)send()和recv()函数 13)sendto()和recvfrom()函数 14)close()和shutdown()函数 15)getpeername()函数 16)gethostname()函数 17)域名服务（DNS） 18)客户-服务器背景知识 19) 简单的服务器 20)简单的客户端 21)数据报套接字Socket 22)阻塞 23)select()--多路同步I/O 24)参考资料
Beej网络socket编程指南！
什么是 socket？
你经常听到人们谈论着“socket”，或许你还不知道它的确切含义。现在让我告诉你：它是使用标准Unix 文件描述符(file descriptor) 和其它程序通讯的方式。
什么？你也许听到一些Unix高手(hacker)这样说过：“呀，Unix中的一切就是文件！”那个家伙也许正在说到一个事实：Unix程序在执行任何形式的 I/O的时候，程序是在读或者写一个文件描述符。一个文件描述符只是一个和打开的文件相关联的整数。但是(注意后面的话)，这个文件可能是一个网络连接，FIFO，管道，终端，磁盘上的文件或者什么其它的东西。Unix中所有的东西就是文件！所以，你想和Internet上别的程序通讯的时候，你将要使用到文件描述符。你必须理解刚才的话。现在你脑海中或许冒出这样的念头：“那么我从哪里得到网络通讯的文件描述符呢？”，这个问题无论如何我都要回答：你利用系统调用socket()，它返回套接字描述符(socket descriptor)，然后你再通过它来进行send()和 recv()调用。
“但是...”，你可能有很大的疑惑，“如果它是个文件描述符，那么为什么不用一般调用read()和write()来进行套接字通讯？”简单的答案是：“你可以使用！”。详细的答案是：“你可以，但是使用send()和recv()让你更好的控制数据传输。”
存在这样一个情况：在我们的世界上，有很多种套接字。有DARPAInternet 地址 (Internet套接字)，本地节点的路径名(Unix套接字)，CCITTX.25地址 (你可以将X.25套接字完全忽略)。也许在你的Unix机器上还有其它的。我们在这里只讲第一种：Internet套接字。 -------------------------------------------------------------------------------- Internet套接字的两种类型
什么意思？有两种类型的Internet套接字？是的。不，我在撒谎。其实还有很多，但是我可不想吓着你。我们这里只讲两种。除了这些,我打算另外介绍的 "RawSockets" 也是非常强大的，很值得查阅。 那么这两种类型是什么呢？一种是"StreamSockets"（流格式），另外一种是"DatagramSockets"（数据包格式）。我们以后谈到它们的时候也会用到"SOCK_STREAM" 和"SOCK_DGRAM"。数据报套接字有时也叫“无连接套接字”(如果你确实要连接的时候可以用connect()。)流式套接字是可靠的双向通讯的数据流。如果你向套接字按顺序输出“1，2”，那么它们将按顺序“1，2”到达另一边。它们是无错误的传递的，有自己的错误控制，在此不讨论。
有什么在使用流式套接字？你可能听说过telnet，不是吗？它就使用流式套接字。你需要你所输入的字符按顺序到达，不是吗？同样，WWW浏览器使用的HTTP 协议也使用它们来下载页面。实际上，当你通过端口80telnet 到一个 WWW 站点，然后输入“GET pagename” 的时候，你也可以得到HTML的内容。为什么流式套接字可以达到高质量的数据传输？这是因为它使用了“传输控制协议(The Transmission ControlProtocol)”，也叫 “TCP”(请参考 RFC-793获得详细资料。)TCP控制你的数据按顺序到达并且没有错误。你也许听到“TCP” 是因为听到过“TCP/IP”。这里的 IP是指“Internet 协议”(请参考RFC-791。)IP 只是处理 Internet路由而已。
那么数据报套接字呢？为什么它叫无连接呢？为什么它是不可靠的呢？有这样的一些事实：如果你发送一个数据报，它可能会到达，它可能次序颠倒了。如果它到达，那么在这个包的内部是无错误的。数据报也使用IP 作路由，但是它不使用TCP。它使用“用户数据报协议(User Datagram Protocol)”，也叫“UDP” (请参考RFC-768。) 为什么它们是无连接的呢？主要是因为它并不象流式套接字那样维持一个连接。你只要建立一个包，构造一个有目标信息的IP头，然后发出去。无需连接。它们通常使用于传输包-包信息。简单的应用程序有：tftp,bootp等等。 你也许会想：“假如数据丢失了这些程序如何正常工作？”我的朋友，每个程序在UDP 上有自己的协议。例如，tftp协议每发出的一个被接受到包，收到者必须发回一个包来说“我收到了！”(一个“命令正确应答”也叫“ACK”包)。如果在一定时间内(例如5秒)，发送方没有收到应答，它将重新发送，直到得到ACK。这一ACK过程在实现SOCK_DGRAM应用程序的时候非常重要。 -------------------------------------------------------------------------------- 网络理论 既然我刚才提到了协议层，那么现在是讨论网络究竟如何工作和一些关于 SOCK_DGRAM包是如何建立的例子。当然，你也可以跳过这一段，如果你认为已经熟悉的话。
现在是学习数据封装 (DataEncapsulation) 的时候了！它非常非常重要。它重要性重要到你在网络课程学习中无论如何也得也得掌握它。主要的内容是：一个包，先是被第一个协议(在这里是TFTP)在它的报头（也许 是报尾）包装(“封装”)，然后，整个数据(包括TFTP 头)被另外一个协议(在这里是 UDP)封装，然后下一个( IP)，一直重复下去，直到硬件(物理)层( 这里是以太网)。
当另外一台机器接收到包，硬件先剥去以太网头，内核剥去IP和UDP头，TFTP程序再剥去TFTP头，最后得到数据。 现在我们终于讲到声名狼藉的网络分层模型(Layered NetworkModel)。这种网络模型在描述网络系统上相对其它模型有很多优点。例如，你可以写一个套接字程序而不用关心数据的物理传输(串行口，以太网，连接单元接口 (AUI)还是其它介质)，因为底层的程序会为你处理它们。实际的网络硬件和拓扑对于程序员来说是透明的。
不说其它废话了，我现在列出整个层次模型。如果你要参加网络考试，可一定要记住：
应用层 (Application) 表示层(Presentation) 会话层(Session) 传输层(Transport) 网络层(Network) 数据链路层(DataLink) 物理层(Physical)
物理层是硬件(串口，以太网等等)。应用层是和硬件层相隔最远的--它是用户和网络交互的地方。 这个模型如此通用，如果你想，你可以把它作为修车指南。把它对应到 Unix，结果是：
应用层(ApplicationLayer) (telnet, ftp,等等) 传输层(Host-to-HostTransport Layer) (TCP, UDP) Internet层(InternetLayer) (IP和路由) 网络访问层(Network Access Layer)(网络层，数据链路层和物理层)
现在，你可能看到这些层次如何协调来封装原始的数据了。
看看建立一个简单的数据包有多少工作？哎呀，你将不得不使用"cat"来建立数据包头！这仅仅是个玩笑。对于流式套接字你要作的是send() 发送数据。对于数据报式套接字，你按照你选择的方式封装数据然后使用sendto()。内核将为你建立传输层和Internet 层，硬件完成网络访问层。这就是现代科技。 现在结束我们的网络理论速成班。哦，忘记告诉你关于路由的事情了。但是我不准备谈它，如果你真的关心，那么参考 IPRFC。
结构体 终于谈到编程了。在这章，我将谈到被套接字用到的各种数据类型。因为它们中的一些内容很重要了。 首先是简单的一个：socket描述符。它是下面的类型： int 仅仅是一个常见的int。 从现在起，事情变得不可思议了，而你所需做的就是继续看下去。注意这样的事实：有两种字节排列顺序：重要的字节(有时叫 "octet"，即八位位组)在前面，或者不重要的字节在前面。前一种叫“网络字节顺序(Network ByteOrder)”。有些机器在内部是按照这个顺序储存数据，而另外一些则不然。当我说某数据必须按照 NBO顺序，那么你要调用函数(例如htons() )来将它从本机字节顺序(Host Byte Order) 转换过来。如果我没有提到 NBO，那么就让它保持本机字节顺序。 我的第一个结构(在这个技术手册TM中)--structsockaddr.。这个结构 为许多类型的套接字储存套接字地址信息： struct sockaddr { unsigned short sa_family; /* 地址家族,AF_xxx */ charsa_data[14]; /*14字节协议地址*/ }; sa_family能够是各种各样的类型，但是在这篇文章中都是"AF_INET"。sa_data包含套接字中的目标地址和端口信息。这好像有点不明智。 为了处理structsockaddr，程序员创造了一个并列的结构： structsockaddr_in ("in" 代表 "Internet"。) structsockaddr_in { shortint sin_family; /* 通信类型 */ unsigned short intsin_port; /* 端口 */ struct in_addr sin_addr; /* Internet地址 */ unsigned char sin_zero[8]; /*与sockaddr结构的长度相同*/ }; 用这个数据结构可以轻松处理套接字地址的基本元素。注意sin_zero (它被加入到这个结构，并且长度和struct sockaddr 一样)应该使用函数 bzero() 或memset() 来全部置零。同时，这一重要的字节，一个指向sockaddr_in结构体的指针也可以被指向结构体sockaddr并且代替它。这样的话即使 socket() 想要的是struct sockaddr *，你仍然可以使用struct sockaddr_in，并且在最后转换。同时，注意sin_family 和 structsockaddr 中的 sa_family一致并能够设置为 "AF_INET"。最后，sin_port和sin_addr 必须是网络字节顺序(Network ByteOrder)！ 你也许会反对道："但是，怎么让整个数据结构struct in_addr sin_addr 按照网络字节顺序呢?"要知道这个问题的答案，我们就要仔细的看一看这个数据结构： struct in_addr,有这样一个联合 (unions)： /* Internet 地址(一个与历史有关的结构)*/ struct in_addr{ unsigned longs_addr; }; 它曾经是个最坏的联合，但是现在那些日子过去了。如果你声明"ina" 是数据结构struct sockaddr_in 的实例，那么"ina.sin_addr.s_addr" 就储存4字节的 IP地址(使用网络字节顺序)。如果你不幸的系统使用的还是恐怖的联合 struct in_addr，你还是可以放心4字节的IP 地址并且和上面我说的一样(这是因为使用了“#define”。) -------------------------------------------------------------------------------- 本机转换 我们现在到了新的章节。我们曾经讲了很多网络到本机字节顺序的转换，现在可以实践了！ 你能够转换两种类型：short (两个字节)和long (四个字节)。这个函数对于变量类型 unsigned也适用。假设你想将 short从本机字节顺序转 换为网络字节顺序。用 "h"表示 "本机(host)"，接着是"to"，然后用"n" 表 示 "网络(network)"，最后用"s" 表示 "short"：h-to-n-s, 或者 htons()("Host to Network Short")。 太简单了... 如果不是太傻的话，你一定想到了由"n"，"h"，"s"，和"l"形成的正确组合，例如这里肯定没有stolh()("Short to Long Host") 函数，不仅在这里没有，所有场合都没有。但是这里有： htons()--"Hostto Network Short" htonl()--"Hostto Network Long" ntohs()--"Networkto Host Short" ntohl()--"Networkto Host Long" 现在，你可能想你已经知道它们了。你也可能想：“如果我想改变char 的顺序要怎么办呢?”但是你也许马上就想到，“用不着考虑的”。你也许会想到：我的 68000机器已经使用了网络字节顺序，我没有必要去调用htonl() 转换 IP地址。你可能是对的，但是当你移植你的程序到别的机器上的时候，你的程序将失败。可移植性！这里是 Unix世界！记住：在你 将数据放到网络上的时候，确信它们是网络字节顺序的。 最后一点：为什么在数据结构struct sockaddr_in 中，sin_addr 和 sin_port需要转换为网络字节顺序，而sin_family需不需要呢? 答案是：sin_addr 和 sin_port分别封装在包的 IP 和UDP 层。因此，它们必须要是网络字节顺序。但是 sin_family域只是被内核 (kernel)使用来决定在数 据结构中包含什么类型的地址，所以它必须是本机字节顺序。同时，sin_family 没有发送到网络上，它们可以是本机字节顺序。 -------------------------------------------------------------------------------- IP地址和如何处理它们现在我们很幸运，因为我们有很多的函数来方便地操作IP 地址。没有必要用手工计算它们，也没有必要用"<<"操作来储存成长整字型。首先，假设你已经有了一个sockaddr_in结构体ina，你有一个IP地址"132.241.5.10"要储存在其中，你就要用到函数inet_addr(),将IP地址从点数格式转换成无符号长整型。使用方法如下： ina.sin_addr.s_addr= inet_addr("132.241.5.10"); 注意，inet_addr()返回的地址已经是网络字节格式，所以你无需再调用函数htonl()。 我们现在发现上面的代码片断不是十分完整的，因为它没有错误检查。显而易见，当inet_addr()发生错误时返回-1。记住这些二进制数字？(无符号数)-1仅仅和IP地址255.255.255.255相符合！这可是广播地址！大错特错！记住要先进行错误检查。 好了，现在你可以将IP地址转换成长整型了。有没有其相反的方法呢？它可以将一个in_addr结构体输出成点数格式？这样的话，你就要用到函数inet_ntoa()("ntoa"的含义是"networkto ascii")，就像这样： printf("%s",inet_ntoa(ina.sin_addr)); 它将输出IP地址。需要注意的是inet_ntoa()将结构体in-addr作为一个参数，不是长整形。同样需要注意的是它返回的是一个指向一个字符的指针。它是一个由inet_ntoa()控制的静态的固定的指针，所以每次调用inet_ntoa()，它就将覆盖上次调用时所得的IP地址。例如： char*a1, *a2; . . a1 = inet_ntoa(ina1.sin_addr); /*这是198.92.129.1 */ a2 =inet_ntoa(ina2.sin_addr); /* 这是132.241.5.10*/ printf("address 1: %s/n",a1); printf("address2: %s/n",a2); 输出如下： address1: 132.241.5.10 address 2:132.241.5.10 假如你需要保存这个IP地址，使用strcopy()函数来指向你自己的字符指针。 上面就是关于这个主题的介绍。稍后，你将学习将一个类似"wintehouse.gov"的字符串转换成它所对应的IP地址(查阅域名服务,稍后)。
socket()函数 我想我不能再不提这个了－下面我将讨论一下socket()系统调用。 下面是详细介绍： #include<sys/types.h>; #include <sys/socket.h>; intsocket(int domain, int type, int protocol); 但是它们的参数是什么?首先，domain 应该设置成"AF_INET"，就象上面的数据结构structsockaddr_in 中一样。然后，参数 type告诉内核 是 SOCK_STREAM类型还是 SOCK_DGRAM类型。最后，把 protocol设置为 "0"。(注意：有很多种domain、type，我不可能一一列出了，请看socket() 的man帮助。当然，还有一个"更好"的方式去得到protocol。同 时请查阅getprotobyname() 的 man帮助。) socket()只是返回你以后在系统调用种可能用到的 socket描述符，或 者在错误的时候返回-1。全局变量errno 中将储存返回的错误值。(请参考perror() 的 man帮助。) -------------------------------------------------------------------------------- bind()函数 一旦你有一个套接字，你可能要将套接字和机器上的一定的端口关联起来。(如果你想用listen()来侦听一定端口的数据，这是必要一步--MUD告 诉你说用命令 "telnetx.y.z 6969"。)如果你只想用connect()，那么这个步骤没有必要。但是无论如何，请继续读下去。 这里是系统调用bind() 的大概： #include<sys/types.h>; #include <sys/socket.h>; intbind(int sockfd, struct sockaddr *my_addr, int addrlen); sockfd是调用 socket返回的文件描述符。my_addr是指向数据结构 structsockaddr 的指针，它保存你的地址(即端口和IP 地址)信息。 addrlen 设置为sizeof(struct sockaddr)。 简单得很不是吗?再看看例子： #include<string.h>; #include <sys/types.h>; #include<sys/socket.h>; #define MYPORT 3490 main() { intsockfd; structsockaddr_in my_addr; sockfd = socket(AF_INET, SOCK_STREAM, 0);/*需要错误检查 */ my_addr.sin_family= AF_INET; /* host byte order */ my_addr.sin_port= htons(MYPORT); /* short, network byte order */ my_addr.sin_addr.s_addr =inet_addr("132.241.5.10"; bzero(&(my_addr.sin_zero),;/* zero the rest of the struct */ /* don't forget your errorchecking for bind(): */ bind(sockfd,(struct sockaddr *)&my_addr, sizeof(struct sockaddr)); . . . 这里也有要注意的几件事情。my_addr.sin_port是网络字节顺序， my_addr.sin_addr.s_addr也是的。另外要注意到的事情是因系统的不同，包含的头文件也不尽相同，请查阅本地的 man帮助文件。 在bind() 主题中最后要说的话是，在处理自己的IP 地址和/或端口的时候，有些工作是可以自动处理的。 my_addr.sin_port= 0; /* 随机选择一个没有使用的端口 */ my_addr.sin_addr.s_addr= INADDR_ANY; /* 使用自己的IP地址*/ 通过将0赋给my_addr.sin_port，你告诉bind() 自己选择合适的端口。同样，将 my_addr.sin_addr.s_addr设置为 INADDR_ANY，你告诉它自动填上它所运行的机器的 IP地址。 如果你一向小心谨慎，那么你可能注意到我没有将INADDR_ANY 转换为网络字节顺序！这是因为我知道内部的东西：INADDR_ANY实际上就 是 0！即使你改变字节的顺序，0依然是0。但是完美主义者说应该处处一致，INADDR_ANY或许是12呢？你的代码就不能工作了，那么就看下面的代码： my_addr.sin_port =htons(0); /* 随机选择一个没有使用的端口 */ my_addr.sin_addr.s_addr = htonl(INADDR_ANY);/* 使用自己的IP地址*/ 你或许不相信，上面的代码将可以随便移植。我只是想指出，既然你所遇到的程序不会都运行使用htonl的INADDR_ANY。 bind()在错误的时候依然是返回-1，并且设置全局错误变量errno。 在你调用 bind()的时候，你要小心的另一件事情是：不要采用小于1024的端口号。所有小于1024的端口号都被系统保留！你可以选择从1024到65535的端口(如果它们没有被别的程序使用的话)。 你要注意的另外一件小事是：有时候你根本不需要调用它。如果你使用 connect()来和远程机器进行通讯，你不需要关心你的本地端口号(就象你在使用 telnet 的时候)，你只要简单的调用connect() 就可以了，它会检查套接字是否绑定端口，如果没有，它会自己绑定一个没有使用的本地端口。 -------------------------------------------------------------------------------- connect()程序 现在我们假设你是个telnet 程序。你的用户命令你得到套接字的文件描述符。你听从命令调用了socket()。下一步，你的用户告诉你通过端口23(标准 telnet端口)连接到"132.241.5.10"。你该怎么做呢?幸运的是，你正在阅读 connect()--如何连接到远程主机这一章。你可不想让你的用户失望。 connect()系统调用是这样的： #include<sys/types.h>; #include <sys/socket.h>; intconnect(int sockfd, struct sockaddr *serv_addr, int addrlen); sockfd是系统调用 socket()返回的套接字文件描述符。serv_addr是 保存着目的地端口和 IP地址的数据结构 structsockaddr。addrlen 设置为 sizeof(struct sockaddr)。 想知道得更多吗？让我们来看个例子： #include <string.h>; #include <sys/types.h>; #include <sys/socket.h>; #define DEST_IP "132.241.5.10" #defineDEST_PORT 23 main() { int sockfd; struct sockaddr_in dest_addr; /* 目的地址*/ sockfd = socket(AF_INET, SOCK_STREAM, 0); /* 错误检查*/ dest_addr.sin_family =AF_INET; /* host byte order */ dest_addr.sin_port =htons(DEST_PORT); /* short, network byte order */ dest_addr.sin_addr.s_addr = inet_addr(DEST_IP); bzero(&(dest_addr.sin_zero),; /* zero the rest of the struct*/ /* don't forget to error check the connect()! */ connect(sockfd, (struct sockaddr *)&dest_addr, sizeof(structsockaddr)); . . . 再一次，你应该检查 connect()的返回值--它在错误的时候返回-1，并设置全局错误变量 errno。 同时，你可能看到，我没有调用bind()。因为我不在乎本地的端口号。我只关心我要去那。内核将为我选择一个合适的端口号，而我们所连接的地方也自动地获得这些信息。一切都不用担心。
listen()函数 是换换内容得时候了。假如你不希望与远程的一个地址相连，或者说，仅仅是将它踢开，那你就需要等待接入请求并且用各种方法处理它们。处理过程分两步：首先，你听--listen()，然后，你接受--accept()(请看下面的 内容)。 除了要一点解释外，系统调用listen 也相当简单。 intlisten(int sockfd, int backlog); sockfd 是调用 socket()返回的套接字文件描述符。backlog是在进入 队列中允许的连接数目。什么意思呢?进入的连接是在队列中一直等待直 到你接受(accept() 请看下面的文章)连接。它们的数目限制于队列的允许。大多数系统的允许数目是20，你也可以设置为5到10。 和别的函数一样，在发生错误的时候返回-1，并设置全局错误变量errno。 你可能想象到了，在你调用listen() 前你或者要调用bind() 或者让内核随便选择一个端口。如果你想侦听进入的连接，那么系统调用的顺序可能是这样的： socket(); bind(); listen(); /* accept() 应该在这*/ 因为它相当的明了，我将在这里不给出例子了。(在accept() 那一章的代码将更加完全。)真正麻烦的部分在accept()。 -------------------------------------------------------------------------------- accept()函数 准备好了，系统调用accept() 会有点古怪的地方的！你可以想象发生这样的事情：有人从很远的地方通过一个你在侦听(listen()) 的端口连接(connect()) 到你的机器。它的连接将加入到等待接受(accept()) 的队列 中。你调用accept() 告诉它你有空闲的连接。它将返回一个新的套接字文件描述符！这样你就有两个套接字了，原来的一个还在侦听你的那个端口，新的在准备发送 (send()) 和接收( recv()) 数据。这就是这个过程！ 函数是这样定义的： #include <sys/socket.h>; intaccept(int sockfd, void *addr, int *addrlen); sockfd 相当简单，是和listen() 中一样的套接字描述符。addr是个指 向局部的数据结构 sockaddr_in的指针。这是要求接入的信息所要去的地方（你可以测定那个地址在那个端口呼叫你）。在它的地址传递给accept 之 前，addrlen是个局部的整形变量，设置为 sizeof(structsockaddr_in)。 accept将不会将多余的字节给 addr。如果你放入的少些，那么它会通过改 变addrlen 的值反映出来。 同样，在错误时返回-1，并设置全局错误变量errno。 现在是你应该熟悉的代码片段。 #include <string.h>; #include<sys/socket.h>; #include <sys/types.h>; #defineMYPORT 3490 /*用户接入端口*/ #define BACKLOG 10 /* 多少等待连接控制*/ main() { int sockfd, new_fd;/* listen on sock_fd, new connection on new_fd */ structsockaddr_in my_addr; /* 地址信息 */ struct sockaddr_intheir_addr; /* connector's address information */ intsin_size; sockfd = socket(AF_INET, SOCK_STREAM, 0); /* 错误检查*/ my_addr.sin_family = AF_INET; /* host byte order */ my_addr.sin_port =htons(MYPORT); /* short, network byte order */ my_addr.sin_addr.s_addr= INADDR_ANY; /* auto-fill with my IP */ bzero(&(my_addr.sin_zero),;/* zero the rest of the struct */ /* don't forget your errorchecking for these calls: */ bind(sockfd,(struct sockaddr *)&my_addr, sizeof(struct sockaddr)); listen(sockfd, BACKLOG); sin_size = sizeof(structsockaddr_in); new_fd= accept(sockfd, &their_addr, &sin_size); . . . 注意，在系统调用send() 和 recv()中你应该使用新的套接字描述符new_fd。如果你只想让一个连接进来，那么你可以使用close() 去关闭原 来的文件描述符sockfd 来避免同一个端口更多的连接。 -------------------------------------------------------------------------------- send()and recv()函数 这两个函数用于流式套接字或者数据报套接字的通讯。如果你喜欢使用无连接的数据报套接字，你应该看一看下面关于sendto()和 recvfrom() 的章节。 send()是这样的： intsend(int sockfd, const void *msg, int len, int flags); sockfd是你想发送数据的套接字描述符(或者是调用socket() 或者是 accept()返回的。)msg是指向你想发送的数据的指针。len是数据的长度。 把 flags设置为 0 就可以了。(详细的资料请看send() 的 manpage)。 这里是一些可能的例子： char*msg = "Beej was here!"; intlen, bytes_sent; . . len= strlen(msg); bytes_sent= send(sockfd, msg, len, 0); . . . send() 返回实际发送的数据的字节数--它可能小于你要求发送的数目！ 注意，有时候你告诉它要发送一堆数据可是它不能处理成功。它只是发送它可能发送的数据，然后希望你能够发送其它的数据。记住，如果send() 返回的数据和 len不匹配，你就应该发送其它的数据。但是这里也有个好消息：如果你要发送的包很小(小于大约1K)，它可能处理让数据一次发送完。最后要说得就是，它在错误的时候返回-1，并设置errno。 recv()函数很相似： intrecv(int sockfd, void *buf, int len, unsigned int flags); sockfd是要读的套接字描述符。buf是要读的信息的缓冲。len是缓 冲的最大长度。flags可以设置为0。(请参考recv()的 man page。)recv() 返回实际读入缓冲的数据的字节数。或者在错误的时候返回-1，同时设置 errno。 很简单，不是吗?你现在可以在流式套接字上发送数据和接收数据了。你现在是 Unix 网络程序员了！
sendto()和recvfrom()函数 “这很不错啊”，你说，“但是你还没有讲无连接数据报套接字呢？”没问题，现在我们开始这个内容。 既然数据报套接字不是连接到远程主机的，那么在我们发送一个包之前需要什么信息呢?不错，是目标地址！看看下面的： intsendto(int sockfd, const void *msg, int len, unsigned int flags, const structsockaddr *to, int tolen); 你已经看到了，除了另外的两个信息外，其余的和函数send() 是一样 的。 to是个指向数据结构 structsockaddr 的指针，它包含了目的地的 IP地址和端口信息。tolen可以简单地设置为 sizeof(structsockaddr)。 和函数 send()类似，sendto()返回实际发送的字节数(它也可能小于你想要发送的字节数！)，或者在错误的时候返回-1。 相似的还有函数recv() 和recvfrom()。recvfrom()的定义是这样的： intrecvfrom(int sockfd, void *buf, int len, unsigned int flags, structsockaddr *from, int *fromlen); 又一次，除了两个增加的参数外，这个函数和recv() 也是一样的。from是一个指向局部数据结构 structsockaddr 的指针，它的内容是源机器的 IP地址和端口信息。fromlen是个 int 型的局部指针，它的初始值为sizeof(structsockaddr)。函数调用返回后，fromlen保存着实际储存在 from中的地址的长度。 recvfrom()返回收到的字节长度，或者在发生错误后返回-1。 记住，如果你用connect() 连接一个数据报套接字，你可以简单的调用 send() 和 recv()来满足你的要求。这个时候依然是数据报套接字，依然使用UDP，系统套接字接口会为你自动加上了目标和源的信息。 -------------------------------------------------------------------------------- close()和shutdown()函数 你已经整天都在发送(send()) 和接收 (recv())数据了，现在你准备关 闭你的套接字描述符了。这很简单，你可以使用一般的Unix 文件描述符 的close()函数： close(sockfd); 它将防止套接字上更多的数据的读写。任何在另一端读写套接字的企图都将返回错误信息。 如果你想在如何关闭套接字上有多一点的控制，你可以使用函数shutdown()。它允许你将一定方向上的通讯或者双向的通讯(就象close()一样)关闭，你可以使用： intshutdown(int sockfd, int how); sockfd 是你想要关闭的套接字文件描述复。how的值是下面的其中之 一： 0– 不允许接受 1– 不允许发送 2– 不允许发送和接受(和close() 一样) shutdown()成功时返回 0，失败时返回-1(同时设置 errno。)如果在无连接的数据报套接字中使用shutdown()，那么只不过是让send() 和 recv()不能使用(记住你在数据报套接字中使用了connect 后是可以使用它们的)。 -------------------------------------------------------------------------------- getpeername()函数 这个函数太简单了。 它太简单了，以至我都不想单列一章。但是我还是这样做了。函数 getpeername()告诉你在连接的流式套接字上谁在另外一边。函数是这样的： #include<sys/socket.h>; int getpeername(int sockfd, struct sockaddr*addr, int *addrlen); sockfd 是连接的流式套接字的描述符。addr是一个指向结构 structsockaddr (或者是 structsockaddr_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_tsize); 参数很简单：hostname是一个字符数组指针，它将在函数返回时保存 主机名。size是hostname数组的字节长度。 函数调用成功时返回0，失败时返回 -1，并设置errno。
域名服务（DNS） 如果你不知道DNS 的意思，那么我告诉你，它代表域名服务(DomainName Service)。它主要的功能是：你给它一个容易记忆的某站点的地址，它给你 IP 地址(然后你就可以使用bind(), connect(), sendto() 或者其它函数) 。当一个人输入： $ telnet whitehouse.gov telnet能知道它将连接 (connect())到 "198.137.240.100"。 但是这是如何工作的呢?你可以调用函数 gethostbyname()： #include <netdb.h>; structhostent *gethostbyname(const char *name); 很明白的是，它返回一个指向struct hostent 的指针。这个数据结构是这样的： struct hostent { char *h_name; char**h_aliases; inth_addrtype; inth_length; char**h_addr_list; }; #define h_addr h_addr_list[0] 这里是这个数据结构的详细资料： structhostent: 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[]) { structhostent *h; if (argc != 2) { /* 检查命令行 */ fprintf(stderr,"usage: getipaddress/n"; exit(1); } if ((h=gethostbyname(argv[1]))== NULL) { /* 取得地址信息 */ herror("gethostbyname"; exit(1); } printf("Host name : %s/n",h->;h_name); printf("IPAddress : %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 成 structin_addr *，然后得到数据。 -------------------------------------------------------------------------------- 客户-服务器背景知识 这里是个客户--服务器的世界。在网络上的所有东西都是在处理客户进程和服务器进程的交谈。举个telnet的例子。当你用 telnet(客户)通过23号端口登陆到主机，主机上运行的一个程序(一般叫telnetd，服务器)激活。它处理这个连接，显示登陆界面，等等。 图2：客户机和服务器的关系 图2 说明了客户和服务器之间的信息交换。 注意，客户--服务器之间可以使用SOCK_STREAM、SOCK_DGRAM或者其它(只要它们采用相同的)。一些很好的客户--服务器的例子有telnet/telnetd、 ftp/ftpd和 bootp/bootpd。每次你使用ftp 的时候，在远 端都有一个ftpd 为你服务。 一般，在服务端只有一个服务器，它采用fork() 来处理多个客户的连接。基本的程序是：服务器等待一个连接，接受(accept()) 连接，然后fork() 一个子进程处理它。这是下一章我们的例子中会讲到的。
简单的服务器 这个服务器所做的全部工作是在流式连接上发送字符串"Hello,World!/n"。你要测试这个程序的话，可以在一台机器上运行该程序，然后在另外一机器上登陆： $ telnet remotehostname 3490 remotehostname 是该程序运行的机器的名字。 服务器代码： #include <stdio.h>; #include<stdlib.h>; #include<errno.h>; #include<string.h>; #include<sys/types.h>; #include<netinet/in.h>; #include<sys/socket.h>; #include<sys/wait.h>; #define MYPORT 3490 /*定义用户连接端口*/ #define BACKLOG 10 /*多少等待连接控制*/ main() { int sockfd, new_fd; /* listen onsock_fd, new connection on new_fd */ structsockaddr_in my_addr; /* my address information */ struct sockaddr_in their_addr; /*connector's address information */ intsin_size; if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("socket"; exit(1); } my_addr.sin_family =AF_INET; /* host byte order */ my_addr.sin_port= htons(MYPORT); /* short, network byte order */ my_addr.sin_addr.s_addr =INADDR_ANY; /* auto-fill with my IP */ bzero(&(my_addr.sin_zero),; /*zero the rest of the struct */ if (bind(sockfd, (structsockaddr *)&my_addr, sizeof(struct sockaddr))== -1) { perror("bind"; exit(1); } if (listen(sockfd, BACKLOG) ==-1) { perror("listen"; exit(1); } while(1) { /* mainaccept() 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 childprocess */ if(send(new_fd, "Hello, world!/n", 14, 0) == -1) perror("send"; close(new_fd); exit(0); } close(new_fd);/* parent doesn't need this */ while(waitpid(-1,NULL,WNOHANG) >;0); /* clean up child processes */ } } 如果你很挑剔的话，一定不满意我所有的代码都在一个很大的main()函数中。如果你不喜欢，可以划分得更细点。 你也可以用我们下一章中的程序得到服务器端发送的字符串。 -------------------------------------------------------------------------------- 简单的客户程序 这个程序比服务器还简单。这个程序的所有工作是通过3490 端口连接到命令行中指定的主机，然后得到服务器发送的字符串。 客户代码: #include <stdio.h>; #include<stdlib.h>; #include<errno.h>; #include<string.h>; #include<sys/types.h>; #include<netinet/in.h>; #include<sys/socket.h>; #include<sys/wait.h>; #define PORT 3490 /* 客户机连接远程主机的端口*/ #define MAXDATASIZE 100 /*每次可以接收的最大字节 */ int main(int argc, char *argv[]) { int sockfd,numbytes; charbuf[MAXDATASIZE]; structhostent *he; structsockaddr_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),;/* zero the rest of the struct */ if (connect(sockfd, (structsockaddr *)&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); return0; } 注意，如果你在运行服务器之前运行客户程序，connect()将返回 "Connectionrefused" 信息，这非常有用。 -------------------------------------------------------------------------------- 数据包Sockets 我不想讲更多了，所以我给出代码talker.c 和 listener.c。 listener 在机器上等待在端口4590 来的数据包。talker发送数据包到 一定的机器，它包含用户在命令行输入的内容。 这里就是 listener.c： #include <stdio.h>; #include<stdlib.h>; #include<errno.h>; #include<string.h>; #include<sys/types.h>; #include<netinet/in.h>; #include<sys/socket.h>; #include<sys/wait.h>; #define MYPORT 4950 /* the port users will besending to */ #define MAXBUFLEN 100 main() { intsockfd; structsockaddr_in my_addr; /* my address information */ struct sockaddr_in their_addr; /*connector's address information */ intaddr_len, numbytes; charbuf[MAXBUFLEN]; if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) ==-1) { perror("socket"); exit(1); } my_addr.sin_family = AF_INET;/* host byte order */ my_addr.sin_port= htons(MYPORT); /* short, network byte order */ my_addr.sin_addr.s_addr =INADDR_ANY; /* auto-fill with my IP */ bzero(&(my_addr.sin_zero),; /*zero the rest of the struct */ if (bind(sockfd, (struct sockaddr*)&my_addr, sizeof(struct sockaddr)) / ==-1) { perror("bind"); exit(1); } addr_len = sizeof(structsockaddr); 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 byteslong/n",numbytes); buf[numbytes]= '/0'; printf("packetcontains /"%s/"/n",buf); close(sockfd); } 注意在我们的调用socket()，我们最后使用了SOCK_DGRAM。同时，没有必要去使用 listen() 或者accept()。我们在使用无连接的数据报套接字！ 下面是talker.c： #include<stdio.h>; #include<stdlib.h>; #include<errno.h>; #include<string.h>; #include<sys/types.h>; #include<netinet/in.h>; #include<sys/socket.h>; #include<sys/wait.h>; #define MYPORT 4950 /* the port users will besending to */ int main(int argc, char *argv[]) { intsockfd; structsockaddr_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 = *((structin_addr *)he->;h_addr); bzero(&(their_addr.sin_zero),;/* zero the rest of the struct */ if ((numbytes=sendto(sockfd,argv[2], strlen(argv[2]), 0, / (structsockaddr *)&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()函数时并指定接受者的地址时，从这点可以看出，讲话者只能向connect()函数指定的地址发送和接受信息。因此，你不需要使用sendto()和recvfrom()，你完全可以用send()和recv()代替。
阻塞 阻塞，你也许早就听说了。"阻塞"是"sleep" 的科技行话。你可能注意到前面运行的 listener程序，它在那里不停地运行，等待数据包的到来。实际在运行的是它调用 recvfrom()，然后没有数据，因此recvfrom() 说"阻塞 (block)"，直到数据的到来。 很多函数都利用阻塞。accept()阻塞，所有的 recv*()函数阻塞。它 们之所以能这样做是因为它们被允许这样做。当你第一次调用socket() 建立套接字描述符的时候，内核就将它设置为阻塞。如果你不想套接字阻塞，你就要调用函数 fcntl()： #include <unistd.h>; #include<fontl.h>; . . sockfd = socket(AF_INET,SOCK_STREAM, 0); fcntl(sockfd,F_SETFL, O_NONBLOCK); . . 通过设置套接字为非阻塞，你能够有效地"询问"套接字以获得信息。如果你尝试着从一个非阻塞的套接字读信息并且没有任何数据，它不允许阻塞--它将返回 -1并将 errno 设置为EWOULDBLOCK。 但是一般说来，这种询问不是个好主意。如果你让你的程序在忙等状态查询套接字的数据，你将浪费大量的 CPU时间。更好的解决之道是用 下一章讲的 select()去查询是否有数据要读进来。 -------------------------------------------------------------------------------- select()--多路同步I/O 虽然这个函数有点奇怪，但是它很有用。假设这样的情况：你是个服务器，你一边在不停地从连接上读数据，一边在侦听连接上的信息。没问题，你可能会说，不就是一个 accept()和两个 recv() 吗?这么 容易吗，朋友?如果你在调用 accept()的时候阻塞呢? 你怎么能够同时接受 recv() 数据?“用非阻塞的套接字啊！” 不行！你不想耗尽所有的CPU 吧?那么，该如何是好? select()让你可以同时监视多个套接字。如果你想知道的话，那么它就会告诉你哪个套接字准备读，哪个又准备写，哪个套接字又发生了例外(exception)。 闲话少说，下面是select()： #include<sys/time.h>; #include<sys/types.h>; #include<unistd.h>; int select(int numfds, fd_set *readfds, fd_set*writefds,fd_set *exceptfds, struct timeval*timeout); 这个函数监视一系列文件描述符，特别是readfds、writefds和 exceptfds。如果你想知道你是否能够从标准输入和套接字描述符sockfd 读入数据，你只要将文件描述符0 和 sockfd加入到集合 readfds 中。参数 numfds应该等于最高的文件描述符的值加1。在这个例子中，你应该设置该值为 sockfd+1。因为它一定大于标准输入的文件描述符(0)。 当函数 select()返回的时候，readfds的值修改为反映你选择的哪个 文件描述符可以读。你可以用下面讲到的宏FD_ISSET() 来测试。在我们继续下去之前，让我来讲讲如何对这些集合进行操作。每个集合类型都是 fd_set。下面有一些宏来对这个类型进行操作： FD_ZERO(fd_set *set) –清除一个文件描述符集合 FD_SET(intfd, fd_set *set) - 添加fd到集合 FD_CLR(intfd, fd_set *set) – 从集合中移去fd FD_ISSET(int fd,fd_set *set) – 测试fd是否在集合中 最后，是有点古怪的数据结构struct timeval。有时你可不想永远等待别人发送数据过来。也许什么事情都没有发生的时候你也想每隔96秒在终端上打印字符串 "StillGoing..."。这个数据结构允许你设定一个时间，如果时间到了，而 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 standardinput */ 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("Akey was pressed!/n"); else printf("Timedout./n"); } 如果你是在一个 linebuffered 终端上，那么你敲的键应该是回车(RETURN)，否则无论如何它都会超时。 现在，你可能回认为这就是在数据报套接字上等待数据的方式--你是对的：它可能是。有些 Unix系统可以按这种方式，而另外一些则不能。你在尝试以前可能要先看看本系统的 manpage 了。 最后一件关于select() 的事情：如果你有一个正在侦听(listen()) 的套接字，你可以通过将该套接字的文件描述符加入到readfds 集合中来看是否有新的连接。 这就是我关于函数select()要讲的所有的东西。 参考书目: Internetworkingwith 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 thirdedition of this set which covers IPv6 and IP over ATM. UsingC on the UNIX System by David A. Curry. Published by O'Reilly &Associates, Inc. ISBN 0-937175-23-4. TCP/IPNetwork Administration by Craig Hunt. Published by O'Reilly &Associates, Inc. ISBN 0-937175-82-X. TCP/IPIllustrated, 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. Onthe web: BSDSockets: A Quick And Dirty Primer (http://www.cs.umn.edu/~bentlema/unix/--hasother great Unix system programming info, too!) Client-ServerComputing (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 (UDP) (ftp://nic.ddn.mil/rfc/rfc768.txt) RFC-791 -- The Internet Protocol (IP) (ftp://nic.ddn.mil/rfc/rfc791.txt) RFC-793 -- The Transmission Control Protocol (TCP) (ftp://nic.ddn.mil/rfc/rfc793.txt) RFC-854 -- The Telnet Protocol (ftp://nic.ddn.mil/rfc/rfc854.txt) RFC-951 -- The Bootstrap Protocol (BOOTP) (ftp://nic.ddn.mil/rfc/rfc951.txt) RFC-1350 -- The Trivial File Transfer Protocol (TFTP) (ftp://nic.ddn.mil/rfc/rfc1350.txt)
