Beejs 网络编程指南 Internet Sockets(1)
时间：2007-02-17 来源：PHP爱好者
Beej's 网络编程指南 Internet Sockets
Version 1.5.5 (13-Jan-1999)
[http://www.ecst.csuchico.edu/~beej/guide/net]
原著：Brian "Beej" Hall
翻译：Wilbur Lang
介绍
Hey! Socket 编程让你沮丧吗？从 man pages 中很难得到有用的信息吗？你想跟上时代去做一做 Internet 程序，但是为你在调用 connect() 前的 bind() 的结构而愁眉不展？…
好了，我现在已经来了，我将和所有人共享我的知识了。如果你了解 C 语言并想穿过网络编程的沼泽，那么你来对地方了。
--------------------------------------------------------------------------------
读者
这个文档是写成一个指南，而不是参考书。如果你刚开始 socket 编程并想找一本入门书，那么你是我的读者。这可不是一本完全的 socket 编程书。
--------------------------------------------------------------------------------
平台和编译器
这篇文章中的大多数代码都在一台 Linux PC 上用 GNU 的 gcc 成功编译过。而且他们在一台 HPUX 上用 gcc 也成功编译过。但是注意，并不是每个代码片段都独立测试过。
--------------------------------------------------------------------------------
目录：
什么是套接口？
Internet 套接口的两种类型
网络理论
struct--要么了解他们，要么等异形入侵地球
Convert the Natives!
IP 地址和如何处理他们
socket()--得到文件描述符！
bind()--我们在哪个端口？
connect()--Hello！
listen()--有人给我打电话吗？
accept()--"Thank you for calling port 3490."
send() 和 recv()--Talk to me, baby!
sendto() 和 recvfrom()--Talk to me, DGRAM-style
close() 和 shutdown()--滚开！
getpeername()--你是谁？
gethostname()--我是谁？
DNS--你说“白宫”，我说 "198.137.240.100"
客户-服务器背景知识
简单的服务器
简单的客户端
数据报 Socket
阻塞
select()--多路同步 I/O，酷！
参考资料
Disclaimer and Call for Help
--------------------------------------------------------------------------------
什么是 socket？
你始终听到人们谈论着 "socket"，而你不知道他的确切含义。那么，现在我告诉你：他是使用 Unix 文件描述符 (fiel descriptor) 和其他程序通讯的方式。
什么？
Ok--你也许听到一些 Unix 高手 (hacker) 这样说：“呀，Unix 中所有的东西 就是文件！”那个家伙也许正在说到一个事实：Unix 程序在执行任何形式的 I/O 的时候，程序是在读或者写一个文件描述符。一个文件描述符只是一个和打开的文件相关联的整数。但是(注意后面的话)，这个文件可能是一个网络连接，FIFO，管道，终端，磁盘上的文件或者什么其他的东西。Unix 中所有的东西是文件！因此，你想和 Internet 上别的程序通讯的时候，你将要通过文件描述符。最好相信刚才的话。
现在你脑海中或许冒出这样的念头：“那么我从哪里得到网络通讯的文件描述符呢，聪明人？”无论如何，我要回答这个问题：你利用系统调用 socket()。他返回套接口描述符 (socket descriptor)，然后你再通过他来调用 send() 和 recv()。
“但是...”，你可能现在叫起来，“如果他是个文件描述符，那么为什么不用一般的调用 read() 和 write() 来通过套接口通讯？”简单的答案是：“你可以使用一般的函数！”。详细的答案是：“你可以，但是使用 send() 和 recv() 让你更好的控制数据传输。”
有这样一个事实：在我们的世界上，有很多种套接口。有 DARPA Internet 地址 (Internet 套接口)，本地节点的路径名 (Unix 套接口)，CCITT X.25 地址 (你可以完全忽略 X.25 套接口)。也许在你的 Unix 机器上还有其他的。我们在这里只讲第一种：Internet 套接口。
--------------------------------------------------------------------------------
Internet 套接口的两种类型
什么意思？有两种 Internet 套接口？是的。不，我在撒谎。其实还有很多，但是我可不想吓着你。我们这里只讲两种。 Except for this sentence, where I'm going to tell you that "Raw Sockets" are also very powerful and you should look them up.
好了，好了。那两种类型是什么呢？一种是 "Stream Sockets"，另外一种是 "Datagram Sockets"。我们以后谈到他们的时候也会用到 "SOCK_STREAM" 和 "SOCK_DGRAM"。数据报套接口有时也叫“无连接套接口”(如果你确实要连接的时候用 connect()。)
流式套接口是可靠的双向通讯的数据流。如果你向套接口安顺序输出“1，2”，那么他们将安顺序“1，2”到达另一边。他们也是无错误的传递的，有自己的错误控制。
有谁在使用流式套接口？你可能听说过 telnet，不是吗？他就使用流式套接口。你需要你所输入的字符按顺序到达，不是吗？同样，WWW 浏览器使用的 HTTP 协议也使用他们。实际上，当你通过端口80 telnet 到一个 WWW 站点，然后输入 “GET pagename” 的时候，你也可以得到 HTML 的内容。
为什么流式套接口可以达到高质量的数据传输？他使用了“传输控制协议 (The Transmission Control Protocol)”，也叫 “TCP” (请参考 RFC-793 获得详细资料。)TCP 控制你的数据按顺序到达并且没有错误。你也许听到 “TCP” 是因为听到过 “TCP/IP”。这里的 IP 是指 “Internet 协议”(请参考 RFC-791.) IP 只是处理 Internet 路由而已。
那么数据报套接口呢？为什么他叫无连接呢？为什么他是不可靠的呢？恩，有这样的事实：如果你发送一个数据报，他可能到达，他可能次序颠倒了。如果他到达，那么在这个包的内部是无错误的。
数据报也使用 IP 作路由，但是他不选择 TCP。他使用“用户数据报协议 (User Datagram Protocol)”，也叫 “UDP” (请参考 RFC-768.)
为什么他们是无连接的呢？主要原因是因为他并不象流式套接口那样维持一个连接。你只要建立一个包，在目标信息中构造一个 IP 头，然后发出去。不需要连接。应用程序有： tftp, bootp 等等。
“够了！”你也许会想，“如果数据丢失了这些程序如何正常工作？”我的朋友，每个程序在 UDP 上有自己的协议。例如，tftp 协议每发出一个包，收到者发回一个包来说“我收到了！” (一个“命令正确应答”也叫“ACK” 包)。如果在一定时间内(例如5秒)，发送方没有收到应答，他将重新发送，直到得到 ACK。这一点在实现 SOCK_DGRAM 应用程序的时候非常重要。
--------------------------------------------------------------------------------
网络理论
既然我刚才提到了协议层，那么现在是讨论网络究竟如何工作和演示 SOCK_DGRAM 的工作。当然，你也可以跳过这一段，如果你认为已经熟悉的话。
朋友们，现在是学习 数据封装 (Data Encapsulation) 的时候了！这非常非常重要。It's so important that you might just learn about it if you take the networks course here at Chico State ;-). 主要的内容是：一个包，先是被第一个协议(在这里是 TFTP )包装(“封装”)，然后，整个数据(包括 TFTP 头)被另外一个协议(在这里是 UDP )封装，然后下一个( IP )，一直重复下去，直到硬件(物理)层( Ethernet )。
当另外一台机器接收到包，硬件先剥去 Ethernet 头，内核剥去 IP 和 UDP 头，TFTP 程序再剥去 TFTP 头，最后得到数据。
现在我们终于讲到臭名远播的 网络分层模型 (Layered Network Model)。这种网络模型在描述网络系统上相对其他模型有很多优点。例如，你可以写一个套接口程序而不用关心数据的物理传输(串行口，以太网，连接单元接口 (AUI) 还是其他介质。因为底层的程序为你处理他们。实际的网络硬件和拓扑对于程序员来说是透明的。
不说其他废话了，我现在列出整个层次模型。如果你要参加网络考试，可一定要记住：
应用层 (Application)
表示层 (Presentation)
会话层 (Session)
传输层 (Transport)
网络层 (Network)
数据链路层 (Data Link)
物理层 (Physical)
物理层是硬件(串口，以太网等等)。应用层是和硬件层相隔最远的--他是用户和网络交互的地方。
这个模型如此通用，如果你想，你可以把他作为修车指南。把他应用到 Unix，结果是：
应用层 (Application Layer) (telnet, ftp, 等等)
传输层 (Host-to-Host Transport Layer) (TCP, UDP)
Internet 层 (Internet Layer) (IP 和路由)
网络访问层 (Network Access Layer) (网络层，数据链路层和物理层)
现在，你可能看到这些层次如何协调来封装原始的数据了。
看看建立一个简单的数据包有多少工作？哎呀，你将不得不使用 "cat" 来完成他们！简直是笑话。对于流式套接口你要作的是 send() 发送数据。对于数据报式套接口你按照你选择的方式封装数据然后用 sendto()。内核将为你建立传输层和 Internet 层，硬件完成网络访问层。这就是现代科技。
现在结束我们的网络理论速成班。哦，忘记告诉你关于路由的事情了。但是我不准备谈他。如果你真的想知道，那么参考 IP RFC。如果你从来不曾了解他，也没有关系，你还活着不是吗。
--------------------------------------------------------------------------------
structs
终于到达这里了，终于谈到编程了。在这章，我将谈到被套接口用到的各种数据类型。因为他们中的一些太重要了。
首先是简单的一个：socket descriptor。他是下面的类型：
int
仅仅是一个常见的 int。
从现在起，事情变得不可思议了。请跟我一起忍受苦恼吧。注意这样的事实：有两种字节排列顺序：重要的字节在前面(有时叫 "octet")，或者不重要的字节在前面。前一种叫“网络字节顺序 (Network Byte Order)”。有些机器在内部是按照这个顺序储存数据，而另外一些则不然。当我说某数据必须按照 NBO 顺序，那么你要调用函数(例如 htons() )来将他从本机字节顺序 (Host Byte Order) 转换过来。如果我没有提到 NBO， 那么就让他是本机字节顺序吧。
我的第一个结构(TM)--struct sockaddr. 这个数据结构为许多类型的套接口储存套接口地址信息：
struct sockaddr {
unsigned short sa_family; /* address family, AF_xxx */
char sa_data[14]; /* 14 bytes of protocol address */
};
sa_family 能够是各种各样的事情，但是在这篇文章中是 "AF_INET"。 sa_data 为套接口储存目标地址和端口信息。看上去很笨拙，不是吗。
为了对付 struct sockaddr，程序员创造了一个并列的结构： 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 */
};
这个数据结构让可以轻松处理套接口地址的基本元素。注意 sin_zero (他被加入到这个结构，并且长度和 struct sockaddr 一样) 应该使用函数 bzero() 或 memset() 来全部置零。 Also, and this is the important bit, a pointer to a struct sockaddr_in can be cast to a pointer to a struct sockaddr and vice-versa. 这样的话即使 socket() 想要的是 struct sockaddr *，你仍然可以使用 struct sockaddr_in，and cast it at the last minute! 同时，注意 sin_family 和 struct sockaddr 中的 sa_family 一致并能够设置为 "AF_INET"。最后， sin_port 和 sin_addr 必须是网络字节顺序 (Network Byte Order)！
你也许会反对道："但是，怎么让整个数据结构 struct in_addr sin_addr 按照网络字节顺序呢?" 要知道这个问题的答案，我们就要仔细的看一看这个数据结构： struct in_addr, 有这样一个联合 (unions)：
/* Internet address (a structure for historical reasons) */
struct in_addr {
unsigned long s_addr;
};
他曾经是个最坏的联合，但是现在那些日子过去了。如果你声明 "ina" 是数据结构 struct sockaddr_in 的实例，那么 "ina.sin_addr.s_addr" 就储存4字节的 IP 地址(网络字节顺序)。如果你不幸的系统使用的还是恐怖的联合 struct in_addr ，你还是可以放心4字节的 IP 地址是和上面我说的一样(这是因为 #define。)
--------------------------------------------------------------------------------
Convert the Natives!
我们现在到达下个章节。我们曾经讲了很多网络到本机字节顺序，现在是采取行动的时刻了！
你能够转换两种类型： short (两个字节)和 long (四个字节)。这个函数对于变量类型 unsigned 也适用。假设你想将 short 从本机字节顺序转换为网络字节顺序。用 "h" 表示 "本机 (host)"，接着是 "to"，然后用 "n" 表示 "网络 (network)"，最后用 "s" 表示 "short"： h-to-n-s, 或者 htons() ("Host to Network Short")。
太简单了...
如果不是太傻的话，你一定想到了组合 "n"，"h"，"s"，和 "l"。但是这里没有 stolh() ("Short to Long Host") 函数，但是这里有：
htons()--"Host to Network Short"
htonl()--"Host to Network Long"
ntohs()--"Network to Host Short"
ntohl()--"Network to Host Long"
现在，你可能想你已经知道他们了。你也可能想："如果我改变 char 的顺序会怎么样呢? 我的 68000 机器已经使用了网络字节顺序，我没有必要去调用 htonl() 转换 IP 地址。" 你可能是对的，但是当你移植你的程序到别的机器上的时候，你的程序将失败。可移植性！这里是 Unix 世界！记住：在你将数据放到网络上的时候，确信他们是网络字节顺序。
最后一点：为什么在数据结构 struct sockaddr_in 中， sin_addr 和 sin_port 需要转换为网络字节顺序，而 sin_family 不需要呢? 答案是：sin_addr 和 sin_port 分别封装在包的 IP 和 UDP 层。因此，他们必须要是网络字节顺序。但是 sin_family 域只是被内核 (kernel) 使用来决定在数据结构中包含什么类型的地址，所以他应该是本机字节顺序。也即 sin_family 没有 发送到网络上，他们可以是本机字节顺序。
--------------------------------------------------------------------------------
IP 地址和如何处理他们
现在我们很幸运，因为我们有很多的函数来方便地操作 IP 地址。没有必要用手工计算他们，也没有必要用 <<操作符来操作 long。
首先，假设你用 struct sockaddr_in ina，你想将 IP 地址 "132.241.5.10" 储存到其中。你要用的函数是 inet_addr()，转换 numbers-and-dots 格式的 IP 地址到 unsigned long。这个工作可以这样来做：
ina.sin_addr.s_addr = inet_addr("132.241.5.10");
注意：inet_addr() 返回的地址已经是按照网络字节顺序的，你没有必要再去调用 htonl()。
上面的代码可不是很健壮 (robust)，因为没有错误检查。inet_addr() 在发生错误的时候返回-1。记得二进制数吗? 在 IP 地址为 255.255.255.255 的时候返回的是 (unsigned)-1！这是个广播地址！记住正确的使用错误检查。
好了，你现在可以转换字符串形式的 IP 地址为 long 了。那么你有一个数据结构 struct in_addr，该如何按照 numbers-and-dots 格式打印呢? 在这个时候，也许你要用函数 inet_ntoa() ("ntoa" 意思是 "network to ascii")：
printf("%s",inet_ntoa(ina.sin_addr));
他将打印 IP 地址。注意的是：函数 inet_ntoa() 的参数是 struct in_addr，而不是 long。同时要注意的是他返回的是一个指向字符的指针。在 inet_ntoa 内部的指针静态地储存字符数组，因此每次你调用 inet_ntoa() 的时候他将覆盖以前的内容。例如：
char *a1, *a2;
.
.
a1 = inet_ntoa(ina1.sin_addr); /* this is 198.92.129.1 */
a2 = inet_ntoa(ina2.sin_addr); /* this is 132.241.5.10 */
printf("address 1: %sn",a1);
printf("address 2: %sn",a2);
运行结果是：
address 1: 132.241.5.10
address 2: 132.241.5.10
如果你想保存地址，那么用 strcpy() 保存到自己的字符数组中。
这就是这章的内容了。以后，我们将学习转换 "whitehouse.gov" 形式的字符串到正确的 IP 地址(请看后面的 DNS 一章。)
--------------------------------------------------------------------------------
socket()--得到文件描述符！
我猜我不会再扯远了--我必须讲 socket() 这个系统调用了。这里是详细的定义：
#include
#include
int socket(int domain, int type, int protocol);
但是他们的参数怎么用? 首先，domain 应该设置成 "AF_INET"，就象上面的数据结构 struct sockaddr_in 中一样。然后，参数 type 告诉内核是 SOCK_STREAM 类型还是 SOCK_DGRAM 类型。最后，把 protocol 设置为 "0"。(注意：有很多种 domain、type，我不可能一一列出了，请看 socket() 的 man page。当然，还有一个"更好"的方式去得到 protocol。请看 getprotobyname() 的 man page。)
socket() 只是返回你以后在系统调用种可能用到的 socket 描述符，或者在错误的时候返回-1。全局变量 errno 中储存错误值。(请参考 perror() 的 man page。)
--------------------------------------------------------------------------------
bind()--我在哪个端口?
一旦你得到套接口，你可能要将套接口和机器上的一定的端口关联起来。(如果你想用 listen() 来侦听一定端口的数据，这是必要一步--MUD 经常告诉你说用命令 "telnet x.y.z 6969".)如果你只想用 connect()，那么这个步骤没有必要。但是无论如何，请继续读下去。
这里是系统调用 bind() 的大略：
#include
#include
int bind(int sockfd, struct sockaddr *my_addr, int addrlen);
sockfd 是调用 socket 返回的文件描述符。my_addr 是指向数据结构 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));
.
.
.
这里也有要注意的几件事情。my_addr.sin_port 是网络字节顺序，my_addr.sin_addr.s_addr 也是的。另外要注意到的事情是因系统的不同，包含的头文件也不尽相同，请查阅自己的 man page。
在 bind() 主题中最后要说的话是，在处理自己的 IP 地址和/或端口的时候，有些工作是可以自动处理的。
my_addr.sin_port = 0; /* choose an unused port at random */
my_addr.sin_addr.s_addr = INADDR_ANY; /* use my IP address */
通过将0赋给 my_addr.sin_port，你告诉 bind() 自己选择合适的端口。同样，将 my_addr.sin_addr.s_addr 设置为 INADDR_ANY，你告诉他自动填上他所运行的机器的 IP 地址。
如果你一向小心谨慎，那么你可能注意到我没有将 INADDR_ANY 转换为网络字节顺序！这是因为我知道内部的东西：INADDR_ANY 实际上就是 0！即使你改变字节的顺序，0依然是0。但是完美主义者说安全第一，那么看下面的代码：
my_addr.sin_port = htons(0); /* choose an unused port at random */
my_addr.sin_addr.s_addr = htonl(INADDR_ANY); /* use my IP address */
你可能不相信，上面的代码将可以随便移植。
bind() 在错误的时候依然是返回-1，并且设置全局变量 errno。
在你调用 bind() 的时候，你要小心的另一件事情是：不要采用小于1024的端口号。所有小于1024的端口号都被系统保留！你可以选择从1024到65535(如果他们没有被别的程序使用的话)。
你要注意的另外一件小事是：有时候你根本不需要调用他。如果你使用 connect() 来和远程机器通讯，你不要关心你的本地端口号(就象你在使用 telnet 的时候)，你只要简单的调用 connect() 就够可，他会检查套接口是否绑定，如果没有，他会自己绑定一个没有使用的本地端口。
--------------------------------------------------------------------------------
connect()--Hello！
现在我们假设你是个 telnet 程序。你的用户命令你(就象电影 TRON 中一样)得到套接口的文件描述符。你听从命令调用了 socket()。下一步，你的用户告诉你通过端口23(标准 telnet 端口)连接到"132.241.5.10"。你该怎么做呢?
幸运的是，你正在疯狂地阅读 connect()--如何连接到远程主机这一章。你可不想让你的用户失望。
connect() 系统调用是这样的：
#include
#include
int connect(int sockfd, struct sockaddr *serv_addr, int addrlen);
sockfd 是系统调用 socket() 返回的套接口文件描述符。serv_addr 是保存着目的地端口和 IP 地址的数据结构 struct sockaddr。addrlen 设置为 sizeof(struct sockaddr)。
让我们来看个例子：
#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，并设置全局变量 errno。
同时，你可能看到，我没有调用 bind()。另外，我也没有管本地的端口号。我只关心我在连接。内核将为我选择一个合适的端口号，而我们所连接的地方也自动地获得这些信息。
--------------------------------------------------------------------------------
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. 处理过程分两步：首先，你听--listen()，然后，你接受--accept() (请看下面的内容)。
除了要一点解释外，系统调用 listen 相当简单。
int listen(int sockfd, int backlog);
sockfd 是调用 socket() 返回的套接口文件描述符。backlog 是在进入队列中允许的连接数目。是什么意思呢? 进入的连接是在队列中一直等待直到你接受 (accept() 请看下面的文章)的连接。他们的数目限制于队列的允许。大多数系统的允许数目是20，你也可以设置为5到10。
和别的函数一样，在发生错误的时候返回-1，并设置全局变量 errno。
你可能想象到了，在你调用 listen() 前你或者要调用 bind() 或者让内核随便选择一个端口。如果你想侦听进入的连接，那么系统调用的顺序可能是这样的：
socket();
bind();
listen();
/* accept() goes here */
因为他相当的明了，我将在这里不给出例子了。(在 accept() 那一章的代码将更加完全。)真正麻烦的部分在 accept()。
--------------------------------------------------------------------------------
accept()--"Thank you for calling port 3490."
准备好了，系统调用 accept() 会有点古怪的地方的！你可以想象发生这样的事情：有人从很远的地方通过一个你在侦听 (listen()) 的端口连接 (connect()) 到你的机器。他的连接将加入到等待接受 (accept()) 的队列中。你调用 accept() 告诉他你有空闲的连接。他将返回一个新的套接口文件描述符！原来的一个还在侦听你的那个端口，新的最后在准备发送 (send()) 和接收 ( recv()) 数据。这就是这个过程！
函数是这样定义的：
#include
int accept(int sockfd, void *addr, int *addrlen);
sockfd 相当简单，是和 listen() 中一样的套接口描述符。addr 是个指向局部的数据结构 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 之前，addrlen 是个局部的整形变量，设置为 sizeof(struct sockaddr_in)。accept 将不会将多余的字节给 addr。如果你放入的少些，那么在 addrlen 的值中反映出来。
同样，在错误时返回-1并设置全局变量 errno。
现在是你应该熟悉的代码片段。
#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);
.
.
.
注意，在系统调用 send() 和 recv() 中你应该使用新的文件描述符。如果你只想让一个连接进来，那么你可以使用 close() 去关闭原来的文件描述符 sockfd 来避免同一个端口更多的连接。
--------------------------------------------------------------------------------
send() and recv()--Talk to me, baby!
这两个函数用于流式套接口和数据报套接口的通讯。如果你喜欢使用无连接的数据报套接口，你应该看一看下面关于 sendto() 和 recvfrom() 的章节。
send() 是这样的：
int send(int sockfd, const void *msg, int len, int flags);
sockfd 是你想发送数据的套接口描述符(或者是调用 socket() 或者是 accept() 返回的。)msg 是指向你想发送的数据的指针。len 是数据的长度。把 flags 设置为 0 就可以了。(详细的资料请看 send() 的 man page)。
这里是一些可能的例子：
char *msg = "Beej was here!";
int len, bytes_sent;
.
.
len = strlen(msg);
bytes_sent = send(sockfd, msg, len, 0);
.
.
.
send() 返回实际发送的数据的字节数--他可能小于你要求发送的数目！ 也即你告诉他要发送一堆数据可是他不能处理成功。他只是发送他可能发送的数据，然后希望你以后能够发送其他的数据。记住，如果 send() 返回的数据和 len 不匹配，你应该发送其他的数据。但是这里也有个好消息：如果你要发送的包很小(小于大约 1K)，他可能处理让数据一次发送完。最后，在错误的时候返回-1，并设置 errno。
recv() 函数很相似：
int recv(int sockfd, void *buf, int len, unsigned int flags);
sockfd 是要读的套接口描述符。buf 是要读的信息的缓冲。len 是缓冲的最大长度。flags 也可以设置为0。(请参考recv() 的 man page。)
recv() 返回实际读入缓冲的数据的字节数。或者在错误的时候返回-1，同时设置 errno。
很简单，不是吗? 你现在可以在流式套接口上发送数据和接收数据了。你现在是 Unix 网络程序员了！
--------------------------------------------------------------------------------
sendto() 和 recvfrom()--Talk to me, DGRAM-style
"这很不错啊"，我听到你说，"但是你还没有讲无连接数据报套接口呢。"没问题，现在我们开始这个内容。
既然数据报套接口不是连接到远程主机的，那么在我们发送一个包之前需要什么信息呢? 不错，是目标地址！看看下面的：
int sendto(int sockfd, const void *msg, int len, unsigned int flags,
const struct sockaddr *to, int tolen);
你已经看到了，除了另外的两个信息外，其余的和函数 send() 是一样的。 to 是个指向数据结构 struct sockaddr 的指针，他包含了目的地的 IP 地址和断口信息。tolen 可以简单地设置为 sizeof(struct sockaddr)。
和函数 send() 类似，sendto() 返回实际发送的字节数(他也可能小于你想要发送的字节数！)，或者在错误的时候返回 -1。
相似的还有函数 recv() 和 recvfrom()。recvfrom() 的定义是这样的：
int recvfrom(int sockfd, void *buf, int len, unsigned int flags
struct sockaddr *from, int *fromlen);
又一次，除了一点多余的参数外，这个函数和 recv() 也是一样的。from 是一个指向局部数据结构 struct sockaddr 的指针，他的内容是源机器的 IP 地址和端口信息。fromlen 是个 int 型的局部指针，他的初始值为 sizeof(struct sockaddr)。函数调用后，fromlen 保存着实际储存在 from 中的地址的长度。
recvfrom() 返回收到的字节长度，或者在发生错误后返回 -1。
记住，如果你是用 connect() 连接一个数据报套接口，你可以简单的调用 send() 和 recv() 来满足你的要求。这个时候依然是数据报套接口，依然使用 UDP，系统自动的加上了目标和源的信息。
--------------------------------------------------------------------------------
close() 和 shutdown()--Get outta my face!
你已经整天都在发送 (send()) 和接收 (recv()) 数据了，现在你准备关闭你的套接口描述符了。这很简单，你可以使用一般的 Unix 文件描述符的 close() 函数：
close(sockfd);
他将防止套接口上更多的数据的读写。任何在另一端读写套接口的企图都将返回错误信息。
如果你想在如何关闭套接口上有多一点的控制，你可以使用函数 shutdown()。他能够让你将一定方向的通讯或者双向的通讯(就象 close() 一样)关闭，你可以使用：
int shutdown(int sockfd, int how);
sockfd 是你想要关闭的套接口文件描述复。how 的值是下面的其中之一：
0 - Further receives are disallowed
1 - Further sends are disallowed
2 - Further sends and receives are disallowed (和 close() 一样
shutdown() 成功时返回 0，失败时返回 -1(同时设置 errno。)
如果在无连接的数据报套接口中使用 shutdown()，那么只不过是让 send() 和 recv() 不能使用(记得你在数据报套接口中使用了 connect 后是可以使用他们的吗?)
--------------------------------------------------------------------------------
getpeername()--Who are you?
这个函数太简单了。
他太简单了，以至我都不想单列一章。但是我还是这样做了。
函数 getpeername() 告诉你在连接的流式套接口上谁在另外一边。函数是这样的：
#include
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 以获得更多的信息。)
php爱好者站 http://www.ｐｈｐfans.net c/vc/c++/java.
Version 1.5.5 (13-Jan-1999)
[http://www.ecst.csuchico.edu/~beej/guide/net]
原著：Brian "Beej" Hall
翻译：Wilbur Lang
介绍
Hey! Socket 编程让你沮丧吗？从 man pages 中很难得到有用的信息吗？你想跟上时代去做一做 Internet 程序，但是为你在调用 connect() 前的 bind() 的结构而愁眉不展？…
好了，我现在已经来了，我将和所有人共享我的知识了。如果你了解 C 语言并想穿过网络编程的沼泽，那么你来对地方了。
--------------------------------------------------------------------------------
读者
这个文档是写成一个指南，而不是参考书。如果你刚开始 socket 编程并想找一本入门书，那么你是我的读者。这可不是一本完全的 socket 编程书。
--------------------------------------------------------------------------------
平台和编译器
这篇文章中的大多数代码都在一台 Linux PC 上用 GNU 的 gcc 成功编译过。而且他们在一台 HPUX 上用 gcc 也成功编译过。但是注意，并不是每个代码片段都独立测试过。
--------------------------------------------------------------------------------
目录：
什么是套接口？
Internet 套接口的两种类型
网络理论
struct--要么了解他们，要么等异形入侵地球
Convert the Natives!
IP 地址和如何处理他们
socket()--得到文件描述符！
bind()--我们在哪个端口？
connect()--Hello！
listen()--有人给我打电话吗？
accept()--"Thank you for calling port 3490."
send() 和 recv()--Talk to me, baby!
sendto() 和 recvfrom()--Talk to me, DGRAM-style
close() 和 shutdown()--滚开！
getpeername()--你是谁？
gethostname()--我是谁？
DNS--你说“白宫”，我说 "198.137.240.100"
客户-服务器背景知识
简单的服务器
简单的客户端
数据报 Socket
阻塞
select()--多路同步 I/O，酷！
参考资料
Disclaimer and Call for Help
--------------------------------------------------------------------------------
什么是 socket？
你始终听到人们谈论着 "socket"，而你不知道他的确切含义。那么，现在我告诉你：他是使用 Unix 文件描述符 (fiel descriptor) 和其他程序通讯的方式。
什么？
Ok--你也许听到一些 Unix 高手 (hacker) 这样说：“呀，Unix 中所有的东西 就是文件！”那个家伙也许正在说到一个事实：Unix 程序在执行任何形式的 I/O 的时候，程序是在读或者写一个文件描述符。一个文件描述符只是一个和打开的文件相关联的整数。但是(注意后面的话)，这个文件可能是一个网络连接，FIFO，管道，终端，磁盘上的文件或者什么其他的东西。Unix 中所有的东西是文件！因此，你想和 Internet 上别的程序通讯的时候，你将要通过文件描述符。最好相信刚才的话。
现在你脑海中或许冒出这样的念头：“那么我从哪里得到网络通讯的文件描述符呢，聪明人？”无论如何，我要回答这个问题：你利用系统调用 socket()。他返回套接口描述符 (socket descriptor)，然后你再通过他来调用 send() 和 recv()。
“但是...”，你可能现在叫起来，“如果他是个文件描述符，那么为什么不用一般的调用 read() 和 write() 来通过套接口通讯？”简单的答案是：“你可以使用一般的函数！”。详细的答案是：“你可以，但是使用 send() 和 recv() 让你更好的控制数据传输。”
有这样一个事实：在我们的世界上，有很多种套接口。有 DARPA Internet 地址 (Internet 套接口)，本地节点的路径名 (Unix 套接口)，CCITT X.25 地址 (你可以完全忽略 X.25 套接口)。也许在你的 Unix 机器上还有其他的。我们在这里只讲第一种：Internet 套接口。
--------------------------------------------------------------------------------
Internet 套接口的两种类型
什么意思？有两种 Internet 套接口？是的。不，我在撒谎。其实还有很多，但是我可不想吓着你。我们这里只讲两种。 Except for this sentence, where I'm going to tell you that "Raw Sockets" are also very powerful and you should look them up.
好了，好了。那两种类型是什么呢？一种是 "Stream Sockets"，另外一种是 "Datagram Sockets"。我们以后谈到他们的时候也会用到 "SOCK_STREAM" 和 "SOCK_DGRAM"。数据报套接口有时也叫“无连接套接口”(如果你确实要连接的时候用 connect()。)
流式套接口是可靠的双向通讯的数据流。如果你向套接口安顺序输出“1，2”，那么他们将安顺序“1，2”到达另一边。他们也是无错误的传递的，有自己的错误控制。
有谁在使用流式套接口？你可能听说过 telnet，不是吗？他就使用流式套接口。你需要你所输入的字符按顺序到达，不是吗？同样，WWW 浏览器使用的 HTTP 协议也使用他们。实际上，当你通过端口80 telnet 到一个 WWW 站点，然后输入 “GET pagename” 的时候，你也可以得到 HTML 的内容。
为什么流式套接口可以达到高质量的数据传输？他使用了“传输控制协议 (The Transmission Control Protocol)”，也叫 “TCP” (请参考 RFC-793 获得详细资料。)TCP 控制你的数据按顺序到达并且没有错误。你也许听到 “TCP” 是因为听到过 “TCP/IP”。这里的 IP 是指 “Internet 协议”(请参考 RFC-791.) IP 只是处理 Internet 路由而已。
那么数据报套接口呢？为什么他叫无连接呢？为什么他是不可靠的呢？恩，有这样的事实：如果你发送一个数据报，他可能到达，他可能次序颠倒了。如果他到达，那么在这个包的内部是无错误的。
数据报也使用 IP 作路由，但是他不选择 TCP。他使用“用户数据报协议 (User Datagram Protocol)”，也叫 “UDP” (请参考 RFC-768.)
为什么他们是无连接的呢？主要原因是因为他并不象流式套接口那样维持一个连接。你只要建立一个包，在目标信息中构造一个 IP 头，然后发出去。不需要连接。应用程序有： tftp, bootp 等等。
“够了！”你也许会想，“如果数据丢失了这些程序如何正常工作？”我的朋友，每个程序在 UDP 上有自己的协议。例如，tftp 协议每发出一个包，收到者发回一个包来说“我收到了！” (一个“命令正确应答”也叫“ACK” 包)。如果在一定时间内(例如5秒)，发送方没有收到应答，他将重新发送，直到得到 ACK。这一点在实现 SOCK_DGRAM 应用程序的时候非常重要。
--------------------------------------------------------------------------------
网络理论
既然我刚才提到了协议层，那么现在是讨论网络究竟如何工作和演示 SOCK_DGRAM 的工作。当然，你也可以跳过这一段，如果你认为已经熟悉的话。
朋友们，现在是学习 数据封装 (Data Encapsulation) 的时候了！这非常非常重要。It's so important that you might just learn about it if you take the networks course here at Chico State ;-). 主要的内容是：一个包，先是被第一个协议(在这里是 TFTP )包装(“封装”)，然后，整个数据(包括 TFTP 头)被另外一个协议(在这里是 UDP )封装，然后下一个( IP )，一直重复下去，直到硬件(物理)层( Ethernet )。
当另外一台机器接收到包，硬件先剥去 Ethernet 头，内核剥去 IP 和 UDP 头，TFTP 程序再剥去 TFTP 头，最后得到数据。
现在我们终于讲到臭名远播的 网络分层模型 (Layered Network Model)。这种网络模型在描述网络系统上相对其他模型有很多优点。例如，你可以写一个套接口程序而不用关心数据的物理传输(串行口，以太网，连接单元接口 (AUI) 还是其他介质。因为底层的程序为你处理他们。实际的网络硬件和拓扑对于程序员来说是透明的。
不说其他废话了，我现在列出整个层次模型。如果你要参加网络考试，可一定要记住：
应用层 (Application)
表示层 (Presentation)
会话层 (Session)
传输层 (Transport)
网络层 (Network)
数据链路层 (Data Link)
物理层 (Physical)
物理层是硬件(串口，以太网等等)。应用层是和硬件层相隔最远的--他是用户和网络交互的地方。
这个模型如此通用，如果你想，你可以把他作为修车指南。把他应用到 Unix，结果是：
应用层 (Application Layer) (telnet, ftp, 等等)
传输层 (Host-to-Host Transport Layer) (TCP, UDP)
Internet 层 (Internet Layer) (IP 和路由)
网络访问层 (Network Access Layer) (网络层，数据链路层和物理层)
现在，你可能看到这些层次如何协调来封装原始的数据了。
看看建立一个简单的数据包有多少工作？哎呀，你将不得不使用 "cat" 来完成他们！简直是笑话。对于流式套接口你要作的是 send() 发送数据。对于数据报式套接口你按照你选择的方式封装数据然后用 sendto()。内核将为你建立传输层和 Internet 层，硬件完成网络访问层。这就是现代科技。
现在结束我们的网络理论速成班。哦，忘记告诉你关于路由的事情了。但是我不准备谈他。如果你真的想知道，那么参考 IP RFC。如果你从来不曾了解他，也没有关系，你还活着不是吗。
--------------------------------------------------------------------------------
structs
终于到达这里了，终于谈到编程了。在这章，我将谈到被套接口用到的各种数据类型。因为他们中的一些太重要了。
首先是简单的一个：socket descriptor。他是下面的类型：
int
仅仅是一个常见的 int。
从现在起，事情变得不可思议了。请跟我一起忍受苦恼吧。注意这样的事实：有两种字节排列顺序：重要的字节在前面(有时叫 "octet")，或者不重要的字节在前面。前一种叫“网络字节顺序 (Network Byte Order)”。有些机器在内部是按照这个顺序储存数据，而另外一些则不然。当我说某数据必须按照 NBO 顺序，那么你要调用函数(例如 htons() )来将他从本机字节顺序 (Host Byte Order) 转换过来。如果我没有提到 NBO， 那么就让他是本机字节顺序吧。
我的第一个结构(TM)--struct sockaddr. 这个数据结构为许多类型的套接口储存套接口地址信息：
struct sockaddr {
unsigned short sa_family; /* address family, AF_xxx */
char sa_data[14]; /* 14 bytes of protocol address */
};
sa_family 能够是各种各样的事情，但是在这篇文章中是 "AF_INET"。 sa_data 为套接口储存目标地址和端口信息。看上去很笨拙，不是吗。
为了对付 struct sockaddr，程序员创造了一个并列的结构： 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 */
};
这个数据结构让可以轻松处理套接口地址的基本元素。注意 sin_zero (他被加入到这个结构，并且长度和 struct sockaddr 一样) 应该使用函数 bzero() 或 memset() 来全部置零。 Also, and this is the important bit, a pointer to a struct sockaddr_in can be cast to a pointer to a struct sockaddr and vice-versa. 这样的话即使 socket() 想要的是 struct sockaddr *，你仍然可以使用 struct sockaddr_in，and cast it at the last minute! 同时，注意 sin_family 和 struct sockaddr 中的 sa_family 一致并能够设置为 "AF_INET"。最后， sin_port 和 sin_addr 必须是网络字节顺序 (Network Byte Order)！
你也许会反对道："但是，怎么让整个数据结构 struct in_addr sin_addr 按照网络字节顺序呢?" 要知道这个问题的答案，我们就要仔细的看一看这个数据结构： struct in_addr, 有这样一个联合 (unions)：
/* Internet address (a structure for historical reasons) */
struct in_addr {
unsigned long s_addr;
};
他曾经是个最坏的联合，但是现在那些日子过去了。如果你声明 "ina" 是数据结构 struct sockaddr_in 的实例，那么 "ina.sin_addr.s_addr" 就储存4字节的 IP 地址(网络字节顺序)。如果你不幸的系统使用的还是恐怖的联合 struct in_addr ，你还是可以放心4字节的 IP 地址是和上面我说的一样(这是因为 #define。)
--------------------------------------------------------------------------------
Convert the Natives!
我们现在到达下个章节。我们曾经讲了很多网络到本机字节顺序，现在是采取行动的时刻了！
你能够转换两种类型： short (两个字节)和 long (四个字节)。这个函数对于变量类型 unsigned 也适用。假设你想将 short 从本机字节顺序转换为网络字节顺序。用 "h" 表示 "本机 (host)"，接着是 "to"，然后用 "n" 表示 "网络 (network)"，最后用 "s" 表示 "short"： h-to-n-s, 或者 htons() ("Host to Network Short")。
太简单了...
如果不是太傻的话，你一定想到了组合 "n"，"h"，"s"，和 "l"。但是这里没有 stolh() ("Short to Long Host") 函数，但是这里有：
htons()--"Host to Network Short"
htonl()--"Host to Network Long"
ntohs()--"Network to Host Short"
ntohl()--"Network to Host Long"
现在，你可能想你已经知道他们了。你也可能想："如果我改变 char 的顺序会怎么样呢? 我的 68000 机器已经使用了网络字节顺序，我没有必要去调用 htonl() 转换 IP 地址。" 你可能是对的，但是当你移植你的程序到别的机器上的时候，你的程序将失败。可移植性！这里是 Unix 世界！记住：在你将数据放到网络上的时候，确信他们是网络字节顺序。
最后一点：为什么在数据结构 struct sockaddr_in 中， sin_addr 和 sin_port 需要转换为网络字节顺序，而 sin_family 不需要呢? 答案是：sin_addr 和 sin_port 分别封装在包的 IP 和 UDP 层。因此，他们必须要是网络字节顺序。但是 sin_family 域只是被内核 (kernel) 使用来决定在数据结构中包含什么类型的地址，所以他应该是本机字节顺序。也即 sin_family 没有 发送到网络上，他们可以是本机字节顺序。
--------------------------------------------------------------------------------
IP 地址和如何处理他们
现在我们很幸运，因为我们有很多的函数来方便地操作 IP 地址。没有必要用手工计算他们，也没有必要用 <<操作符来操作 long。
首先，假设你用 struct sockaddr_in ina，你想将 IP 地址 "132.241.5.10" 储存到其中。你要用的函数是 inet_addr()，转换 numbers-and-dots 格式的 IP 地址到 unsigned long。这个工作可以这样来做：
ina.sin_addr.s_addr = inet_addr("132.241.5.10");
注意：inet_addr() 返回的地址已经是按照网络字节顺序的，你没有必要再去调用 htonl()。
上面的代码可不是很健壮 (robust)，因为没有错误检查。inet_addr() 在发生错误的时候返回-1。记得二进制数吗? 在 IP 地址为 255.255.255.255 的时候返回的是 (unsigned)-1！这是个广播地址！记住正确的使用错误检查。
好了，你现在可以转换字符串形式的 IP 地址为 long 了。那么你有一个数据结构 struct in_addr，该如何按照 numbers-and-dots 格式打印呢? 在这个时候，也许你要用函数 inet_ntoa() ("ntoa" 意思是 "network to ascii")：
printf("%s",inet_ntoa(ina.sin_addr));
他将打印 IP 地址。注意的是：函数 inet_ntoa() 的参数是 struct in_addr，而不是 long。同时要注意的是他返回的是一个指向字符的指针。在 inet_ntoa 内部的指针静态地储存字符数组，因此每次你调用 inet_ntoa() 的时候他将覆盖以前的内容。例如：
char *a1, *a2;
.
.
a1 = inet_ntoa(ina1.sin_addr); /* this is 198.92.129.1 */
a2 = inet_ntoa(ina2.sin_addr); /* this is 132.241.5.10 */
printf("address 1: %sn",a1);
printf("address 2: %sn",a2);
运行结果是：
address 1: 132.241.5.10
address 2: 132.241.5.10
如果你想保存地址，那么用 strcpy() 保存到自己的字符数组中。
这就是这章的内容了。以后，我们将学习转换 "whitehouse.gov" 形式的字符串到正确的 IP 地址(请看后面的 DNS 一章。)
--------------------------------------------------------------------------------
socket()--得到文件描述符！
我猜我不会再扯远了--我必须讲 socket() 这个系统调用了。这里是详细的定义：
#include
#include
int socket(int domain, int type, int protocol);
但是他们的参数怎么用? 首先，domain 应该设置成 "AF_INET"，就象上面的数据结构 struct sockaddr_in 中一样。然后，参数 type 告诉内核是 SOCK_STREAM 类型还是 SOCK_DGRAM 类型。最后，把 protocol 设置为 "0"。(注意：有很多种 domain、type，我不可能一一列出了，请看 socket() 的 man page。当然，还有一个"更好"的方式去得到 protocol。请看 getprotobyname() 的 man page。)
socket() 只是返回你以后在系统调用种可能用到的 socket 描述符，或者在错误的时候返回-1。全局变量 errno 中储存错误值。(请参考 perror() 的 man page。)
--------------------------------------------------------------------------------
bind()--我在哪个端口?
一旦你得到套接口，你可能要将套接口和机器上的一定的端口关联起来。(如果你想用 listen() 来侦听一定端口的数据，这是必要一步--MUD 经常告诉你说用命令 "telnet x.y.z 6969".)如果你只想用 connect()，那么这个步骤没有必要。但是无论如何，请继续读下去。
这里是系统调用 bind() 的大略：
#include
#include
int bind(int sockfd, struct sockaddr *my_addr, int addrlen);
sockfd 是调用 socket 返回的文件描述符。my_addr 是指向数据结构 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));
.
.
.
这里也有要注意的几件事情。my_addr.sin_port 是网络字节顺序，my_addr.sin_addr.s_addr 也是的。另外要注意到的事情是因系统的不同，包含的头文件也不尽相同，请查阅自己的 man page。
在 bind() 主题中最后要说的话是，在处理自己的 IP 地址和/或端口的时候，有些工作是可以自动处理的。
my_addr.sin_port = 0; /* choose an unused port at random */
my_addr.sin_addr.s_addr = INADDR_ANY; /* use my IP address */
通过将0赋给 my_addr.sin_port，你告诉 bind() 自己选择合适的端口。同样，将 my_addr.sin_addr.s_addr 设置为 INADDR_ANY，你告诉他自动填上他所运行的机器的 IP 地址。
如果你一向小心谨慎，那么你可能注意到我没有将 INADDR_ANY 转换为网络字节顺序！这是因为我知道内部的东西：INADDR_ANY 实际上就是 0！即使你改变字节的顺序，0依然是0。但是完美主义者说安全第一，那么看下面的代码：
my_addr.sin_port = htons(0); /* choose an unused port at random */
my_addr.sin_addr.s_addr = htonl(INADDR_ANY); /* use my IP address */
你可能不相信，上面的代码将可以随便移植。
bind() 在错误的时候依然是返回-1，并且设置全局变量 errno。
在你调用 bind() 的时候，你要小心的另一件事情是：不要采用小于1024的端口号。所有小于1024的端口号都被系统保留！你可以选择从1024到65535(如果他们没有被别的程序使用的话)。
你要注意的另外一件小事是：有时候你根本不需要调用他。如果你使用 connect() 来和远程机器通讯，你不要关心你的本地端口号(就象你在使用 telnet 的时候)，你只要简单的调用 connect() 就够可，他会检查套接口是否绑定，如果没有，他会自己绑定一个没有使用的本地端口。
--------------------------------------------------------------------------------
connect()--Hello！
现在我们假设你是个 telnet 程序。你的用户命令你(就象电影 TRON 中一样)得到套接口的文件描述符。你听从命令调用了 socket()。下一步，你的用户告诉你通过端口23(标准 telnet 端口)连接到"132.241.5.10"。你该怎么做呢?
幸运的是，你正在疯狂地阅读 connect()--如何连接到远程主机这一章。你可不想让你的用户失望。
connect() 系统调用是这样的：
#include
#include
int connect(int sockfd, struct sockaddr *serv_addr, int addrlen);
sockfd 是系统调用 socket() 返回的套接口文件描述符。serv_addr 是保存着目的地端口和 IP 地址的数据结构 struct sockaddr。addrlen 设置为 sizeof(struct sockaddr)。
让我们来看个例子：
#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，并设置全局变量 errno。
同时，你可能看到，我没有调用 bind()。另外，我也没有管本地的端口号。我只关心我在连接。内核将为我选择一个合适的端口号，而我们所连接的地方也自动地获得这些信息。
--------------------------------------------------------------------------------
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. 处理过程分两步：首先，你听--listen()，然后，你接受--accept() (请看下面的内容)。
除了要一点解释外，系统调用 listen 相当简单。
int listen(int sockfd, int backlog);
sockfd 是调用 socket() 返回的套接口文件描述符。backlog 是在进入队列中允许的连接数目。是什么意思呢? 进入的连接是在队列中一直等待直到你接受 (accept() 请看下面的文章)的连接。他们的数目限制于队列的允许。大多数系统的允许数目是20，你也可以设置为5到10。
和别的函数一样，在发生错误的时候返回-1，并设置全局变量 errno。
你可能想象到了，在你调用 listen() 前你或者要调用 bind() 或者让内核随便选择一个端口。如果你想侦听进入的连接，那么系统调用的顺序可能是这样的：
socket();
bind();
listen();
/* accept() goes here */
因为他相当的明了，我将在这里不给出例子了。(在 accept() 那一章的代码将更加完全。)真正麻烦的部分在 accept()。
--------------------------------------------------------------------------------
accept()--"Thank you for calling port 3490."
准备好了，系统调用 accept() 会有点古怪的地方的！你可以想象发生这样的事情：有人从很远的地方通过一个你在侦听 (listen()) 的端口连接 (connect()) 到你的机器。他的连接将加入到等待接受 (accept()) 的队列中。你调用 accept() 告诉他你有空闲的连接。他将返回一个新的套接口文件描述符！原来的一个还在侦听你的那个端口，新的最后在准备发送 (send()) 和接收 ( recv()) 数据。这就是这个过程！
函数是这样定义的：
#include
int accept(int sockfd, void *addr, int *addrlen);
sockfd 相当简单，是和 listen() 中一样的套接口描述符。addr 是个指向局部的数据结构 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 之前，addrlen 是个局部的整形变量，设置为 sizeof(struct sockaddr_in)。accept 将不会将多余的字节给 addr。如果你放入的少些，那么在 addrlen 的值中反映出来。
同样，在错误时返回-1并设置全局变量 errno。
现在是你应该熟悉的代码片段。
#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);
.
.
.
注意，在系统调用 send() 和 recv() 中你应该使用新的文件描述符。如果你只想让一个连接进来，那么你可以使用 close() 去关闭原来的文件描述符 sockfd 来避免同一个端口更多的连接。
--------------------------------------------------------------------------------
send() and recv()--Talk to me, baby!
这两个函数用于流式套接口和数据报套接口的通讯。如果你喜欢使用无连接的数据报套接口，你应该看一看下面关于 sendto() 和 recvfrom() 的章节。
send() 是这样的：
int send(int sockfd, const void *msg, int len, int flags);
sockfd 是你想发送数据的套接口描述符(或者是调用 socket() 或者是 accept() 返回的。)msg 是指向你想发送的数据的指针。len 是数据的长度。把 flags 设置为 0 就可以了。(详细的资料请看 send() 的 man page)。
这里是一些可能的例子：
char *msg = "Beej was here!";
int len, bytes_sent;
.
.
len = strlen(msg);
bytes_sent = send(sockfd, msg, len, 0);
.
.
.
send() 返回实际发送的数据的字节数--他可能小于你要求发送的数目！ 也即你告诉他要发送一堆数据可是他不能处理成功。他只是发送他可能发送的数据，然后希望你以后能够发送其他的数据。记住，如果 send() 返回的数据和 len 不匹配，你应该发送其他的数据。但是这里也有个好消息：如果你要发送的包很小(小于大约 1K)，他可能处理让数据一次发送完。最后，在错误的时候返回-1，并设置 errno。
recv() 函数很相似：
int recv(int sockfd, void *buf, int len, unsigned int flags);
sockfd 是要读的套接口描述符。buf 是要读的信息的缓冲。len 是缓冲的最大长度。flags 也可以设置为0。(请参考recv() 的 man page。)
recv() 返回实际读入缓冲的数据的字节数。或者在错误的时候返回-1，同时设置 errno。
很简单，不是吗? 你现在可以在流式套接口上发送数据和接收数据了。你现在是 Unix 网络程序员了！
--------------------------------------------------------------------------------
sendto() 和 recvfrom()--Talk to me, DGRAM-style
"这很不错啊"，我听到你说，"但是你还没有讲无连接数据报套接口呢。"没问题，现在我们开始这个内容。
既然数据报套接口不是连接到远程主机的，那么在我们发送一个包之前需要什么信息呢? 不错，是目标地址！看看下面的：
int sendto(int sockfd, const void *msg, int len, unsigned int flags,
const struct sockaddr *to, int tolen);
你已经看到了，除了另外的两个信息外，其余的和函数 send() 是一样的。 to 是个指向数据结构 struct sockaddr 的指针，他包含了目的地的 IP 地址和断口信息。tolen 可以简单地设置为 sizeof(struct sockaddr)。
和函数 send() 类似，sendto() 返回实际发送的字节数(他也可能小于你想要发送的字节数！)，或者在错误的时候返回 -1。
相似的还有函数 recv() 和 recvfrom()。recvfrom() 的定义是这样的：
int recvfrom(int sockfd, void *buf, int len, unsigned int flags
struct sockaddr *from, int *fromlen);
又一次，除了一点多余的参数外，这个函数和 recv() 也是一样的。from 是一个指向局部数据结构 struct sockaddr 的指针，他的内容是源机器的 IP 地址和端口信息。fromlen 是个 int 型的局部指针，他的初始值为 sizeof(struct sockaddr)。函数调用后，fromlen 保存着实际储存在 from 中的地址的长度。
recvfrom() 返回收到的字节长度，或者在发生错误后返回 -1。
记住，如果你是用 connect() 连接一个数据报套接口，你可以简单的调用 send() 和 recv() 来满足你的要求。这个时候依然是数据报套接口，依然使用 UDP，系统自动的加上了目标和源的信息。
--------------------------------------------------------------------------------
close() 和 shutdown()--Get outta my face!
你已经整天都在发送 (send()) 和接收 (recv()) 数据了，现在你准备关闭你的套接口描述符了。这很简单，你可以使用一般的 Unix 文件描述符的 close() 函数：
close(sockfd);
他将防止套接口上更多的数据的读写。任何在另一端读写套接口的企图都将返回错误信息。
如果你想在如何关闭套接口上有多一点的控制，你可以使用函数 shutdown()。他能够让你将一定方向的通讯或者双向的通讯(就象 close() 一样)关闭，你可以使用：
int shutdown(int sockfd, int how);
sockfd 是你想要关闭的套接口文件描述复。how 的值是下面的其中之一：
0 - Further receives are disallowed
1 - Further sends are disallowed
2 - Further sends and receives are disallowed (和 close() 一样
shutdown() 成功时返回 0，失败时返回 -1(同时设置 errno。)
如果在无连接的数据报套接口中使用 shutdown()，那么只不过是让 send() 和 recv() 不能使用(记得你在数据报套接口中使用了 connect 后是可以使用他们的吗?)
--------------------------------------------------------------------------------
getpeername()--Who are you?
这个函数太简单了。
他太简单了，以至我都不想单列一章。但是我还是这样做了。
函数 getpeername() 告诉你在连接的流式套接口上谁在另外一边。函数是这样的：
#include
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 以获得更多的信息。)
php爱好者站 http://www.ｐｈｐfans.net c/vc/c++/java.
相关阅读 更多 +
