socket编程（一）
socket编程原理
1、问题的引入
1) TCP/IP协议被集成到UNIX内核中
TCP/IP协议被集成到UNIX内核中时，相当于在UNIX系统引入了一种新型的I/O操作。UNIX用户进程与网络协议的交互作用比用户进程与传统的I/O设备相互作用复杂得多。首先，进行网络操作的两个进程在不同机器上，如何建立它们之间的联系？其次，网络协议存在多种，如何建立一种通用机制以支持多种协议？这些都是网络应用编程界面所要解决的问题。
2) 需要一种通用的网络编程接口: 独立于具体协议和通用的网络编程socket
2 、套接字编程基本概念
开始使用套接字编程之前，首先必须建立以下概念。
2.1 网间进程通信
进程通信的概念最初来源于单机系统。由于每个进程都在自己的地址范围内运行，为保证两个相互通信的进程之间既互不干扰又协调一致工作，操作系统为进程通信提供了相应设施，
如UNIX BSD有：管道（pipe）、命名管道（named pipe）软中断信号（signal）
UNIX system V有：消息（message）、共享存储区（shared memory）和信号量（semaphore)等.
他们都仅限于用在本机进程之间通信。
网间进程通信要解决的是不同主机进程间的相互通信问题（可把同机进程通信看作是其中的特例）。为此，首先要解决的是网间进程标识问题。TCP/IP协议引入了下列几个概念。
1）端口
传输层与网络层在功能上的最大区别是传输层提供进程通信能力。
端口是一种抽象的软件结构（包括一些数据结构和I/O缓冲区）。
在TCP/IP协议的实现中，对端口的操作类似于一般的I/O操作，进程获取一个端口：相当于获取本地唯一的I/O文件，可以用一般的读写原语访问之
由于TCP/IP传输层的两个协议TCP和UDP是完全独立的两个软件模块，因此各自的端口号也相互独立，如TCP有一个255号端口，UDP也可以有一个255号端口，二者并不冲突。
=>端口号的分配是一个重要问题。
有两种基本分配方式：第一种叫全局分配，这是一种集中控制方式，由一个公认的中央机构根据用户需要进行统一分配，并将结果公布于众。
第二种是本地分配，又称动态连接，即进程需要访问传输层服务时，向本地操作系统提出申请，操作系统返回一个本地唯一的端口号，进程再通过合适的系统调用将自己与该端口号联系起来（绑扎）。TCP/IP端口号的分配中综合了上述两种方式。TCP/IP将端口号分为两部分，少量的作为保留端口，以全局方式分配给服务进程
每一个标准服务器都拥有一个全局公认的端口（即周知口，well-known port）
2）地址
网络通信中通信的两个进程分别在不同的机器上。在互连网络中，两台机器可能位于不同的网络，这些网络通过网络互连设备（网关，网桥，路由器等）连接。因此需要三级寻址：
1. 某一主机可与多个网络相连，必须指定一特定网络地址；
2. 网络上每一台主机应有其唯一的地址；
3. 每一主机上的每一进程应有在该主机上的唯一标识符。
通常主机地址由网络ID和主机ID组成，在TCP/IP协议中用32位整数值表示；TCP和UDP均使用16位端口号标识用户进程。
3）网络字节顺序
在网络协议中须指定网络字节顺序
4）连接
两个进程间的通信链路称为连接。连接在内部表现为一些缓冲区和一组协议机制，在外部表现出比无连接高的可靠性。
5）半相关
综上所述，网络中用一个三元组可以在全局唯一标志一个进程：
（协议，本地地址，本地端口号） 这样一个三元组，叫做一个半相关（half-association），它指定连接的每半部分。
6）全相关
一个完整的网间进程通信需要由两个进程组成，并且只能使用同一种高层协议。也就是说，不可能通信的一端用TCP协议，而另一端用UDP协议。因此一个完整的网间通信需要一个五元组来标识：
（协议，本地地址，本地端口号，远地地址，远地端口号） 这样一个五元组，叫做一个相关（association），即两个协议相同的半相关才能组合成一个合适的相关，或完全指定组成一连接。
2.2 服务方式
1.网络层及其以下各层又称为通信子网，只提供点到点通信，没有程序或进程的概念。
2.而传输层实现的是“端到端”通信，引进网间进程通信概念，同时也要解决差错控制，流量控制，数据排序（报文排序），连接管理等问题，为此提供不同的服务方式：
1）面向连接（虚电路）或无连接
面向连接服务（TCP协议）无连接服务（UDP协议）
2）流控制
在数据传输过程中控制数据传输速率的一种机制，以保证数据不被丢失。TCP协议提供这项服务。
3）字节流
字节流方式指的是仅把传输中的报文看作是一个字节序列，不提供数据流的任何边界。TCP协议提供字节流
服务。
6）报文
接收方要保存发送方的报文边界。UDP协议提供报文服务。
7）全双工/半双工
端－端间数据同时以两个方向/一个方向传送。
8）缓存/带外数据
2.4 套接字类型
TCP/IP的socket提供下列三种类型套接字。
流式套接字（SOCK_STREAM）：
提供了一个面向连接、可靠的数据传输服务，数据无差错、无重复地发送，且按发送顺序接收。内设流量控
制，避免数据流超限；数据被看作是字节流，无长度限制。文件传送协议（FTP）即使用流式套接字。
数据报式套接字（SOCK_DGRAM）：
提供了一个无连接服务。数据包以独立包形式被发送，不提供无错保证，
数据可能丢失或重复，并且接收顺序混乱。网络文件系统（NFS）使用数据报式套接字。
原始式套接字（SOCK_RAW） ：
该接口允许对较低层协议，如IP、ICMP直接访问。常用于检验新的协议实现或访问现有服务中配置的新设备。
2.4 典型套接字调用过程举例
如前所述，TCP/IP协议的应用一般采用客户/服务器模式，因此在实际应用中，必须有客户和服务器两个进 程，并且首先启动服务器，其系统调用时序图如下。 面向连接的协议（如TCP）的套接字系统调用如图2.1所示：
服务器必须首先启动，直到它执行完accept()调用，进入等待状态后，方能接收客户请求。假如客户在此前启动，则connect()将返回出错代码，连接不成功。 无连接协议的套接字调用如图2.2所示：
无连接服务器也必须先启动，否则客户请求传不到服务进程。无连接客户不调用connect()。因此在数据发送之前，客户与服务器之间尚未建立完全相关，但各自通过socket()和bind()建立了半相关。发送数据时，发送方除指定本地套接字号外，还需指定接收方套接字号，从而在数据收发过程中动态地建立了全相关。
实例
本实例使用面向连接协议的客户/服务器模式，其流程如图2.3所示：
服务器方程序：
/* File Name: streams.c */
#include <winsock.h>
#include <stdio.h>
#define TRUE 1
/* 这个程序建立一个套接字，然后开始无限循环；每当它通过循环接收到一个连接，则打印出一个信息。
当连接断开，或接收到终止信息，则此连接结束，程序再接收一个新的连接。命令行的格式是：streams */
main( )
{
int sock, length;
struct sockaddr_in server;
struct sockaddr tcpaddr;
int msgsock;
char buf[1024];
int rval, len;
/* 建立套接字 */
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0) {
perror(“opening stream socket”);
exit(1);
}
/* 使用任意端口命名套接字 */
server.sin_family = AF_INET;
server.sin_port = INADDR_ANY;
if (bind(sock, (struct sockaddr *)&server, sizeof(server)) < 0) {
perror(“binding stream socket”);
exit(1);
}
/* 找出指定的端口号并打印出来 */
length = sizeof(server);
if (getsockname(sock, (struct sockaddr *)&server, &length) < 0) {
perror(“getting socket name”);
exit(1);
}
printf(“socket port #%d/n”, ntohs(server.sin_port));
/* 开始接收连接 */
listen(sock, 5);
len = sizeof(struct sockaddr);
do {
msgsock = accept(sock, (struct sockaddr *)&tcpaddr, (int *)&len);
if (msgsock == -1)
perror(“accept”);
elsedo{
memset(buf, 0, sizeof(buf));
if ((rval = recv(msgsock, buf, 1024)) < 0)
perror(“reading stream message”);
if (rval == 0)
printf(“ending connection /n”);
else
printf(“-->;%s/n”, buf);
}while (rval != 0);
closesocket(msgsock);
} while (TRUE);
/* 因为这个程序已经有了一个无限循环，所以套接字“sock”从来不显式关闭。然而，当进程被杀死或正
常终止时，所有套接字都将自动地被关闭。*/
exit(0);
}
客户方程序：
/* File Name: streamc.c */
#include <winsock.h>
#include <stdio.h>
#define DATA “half a league, half a league ...”
/* 这个程序建立套接字，然后与命令行给出的套接字连接；连接结束时，在连接上发送
一个消息，然后关闭套接字。命令行的格式是：streamc 主机名 端口号
端口号要与服务器程序的端口号相同 */
main(argc, argv)
int argc;
char *argv[ ];
{
int sock;
struct sockaddr_in server;
struct hostent *hp, *gethostbyname( );
char buf[1024];
/* 建立套接字 */
sock = socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0) {
perror(“opening stream socket”);
exit(1);
}
/* 使用命令行中指定的名字连接套接字 */
server.sin_family = AF_INET;
hp = gethostbyname(argv[1]);
if (hp == 0) {
fprintf(stderr, “%s: unknown host /n”, argv[1]);
exit(2);
}
memcpy((char*)&server.sin_addr, (char*)hp->;h_addr, hp->;h_length);
sever.sin_port = htons(atoi(argv[2]));
if (connect(sock, (struct sockaddr*)&server, sizeof(server)) < 0) {
perror(“connecting stream socket”);
exit(3);
}
if (send(sock, DATA, sizeof(DATA)) < 0)
perror(“sending on stream socket”);
closesocket(sock);
exit(0);
}
2.5 一个通用的实例程序
使用socket编程几乎有一 个模式，即所有的程序几乎毫无例外地按相同的顺序调用相同的函数。
设计一个中间层 ，一个通用的网络程序接口，它向上层提供几个简单的函数，程序设计者只要使用这几个函数 就可以完成绝大多数网络数据传输：使用面向连接的流式套接字 ，采用非阻塞的工作机制，程序只要调用这些函数查询网络消息并作出相应的响应即可。
这些函数包括：l InitSocketsStruct：初始化socket结构，获取服务端口号。客户程序使用。
l InitPassiveSock：初始化socket结构，获取服务端口号，建立主套接字。服务器程序使用。
l CloseMainSock：关闭主套接字。服务器程序使用。
l CreateConnection：建立连接。客户程序使用。
l AcceptConnection：接收连接。服务器程序使用。
l CloseConnection：关闭连接。
l QuerySocketsMsg：查询套接字消息。
l SendPacket：发送数据。
l RecvPacket：接收数据。
2.5.1 头文件
/* File Name: tcpsock.h */
/* 头文件包括 socket 程序经常用到的系统头文件（本例中给出的是 SCO Unix下的头文件，其它版本的 Unix的头文件
可能略有不同），并定义了我们自己的两个数据结构及其实例变量，以及我们提供的函数说明。*/
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <sys/tape.h>
#include <sys/signal.h>
#include <sys/errno.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/netinet/in.h>
#include <sys/netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
typedefstruct SocketsMsg{ /* 套接字消息结构 */
int AcceptNum; /* 指示是否有外来连接等待接收 */
int ReadNum; /* 有外来数据等待读取的连接数 */
int ReadQueue[32]; /* 有外来数据等待读取的连接队列 */
int WriteNum; /* 可以发送数据的连接数 */
int WriteQueue[32]; /* 可以发送数据的连接队列 */
int ExceptNum; /* 有例外的连接数 */
int ExceptQueue[32]; /* 有例外的连接队列 */
} SocketsMsg;
typedefstruct Sockets { /* 套接字结构 */
int DaemonSock; /* 主套接字 */
int SockNum; /* 数据套接字数目 */
int Sockets[64]; /* 数据套接字数组 */
fd_set readfds, writefds, exceptfds; /* 要被检测的可
int Port; /* 端口号 */
} Sockets;
Sockets Mysock; /* 全局变量 */
SocketsMsg SockMsg;
int InitSocketsStruct(char * servicename) ;
int InitPassiveSock(char * servicename) ;
void CloseMainSock();
int CreateConnection(struct in_addr *sin_addr);
int AcceptConnection(struct in_addr *IPaddr);
int CloseConnection(int Sockno);
int QuerySocketsMsg();
int SendPacket(int Sockno, void *buf, int len);
int RecvPacket(int Sockno, void *buf, int size);
2.5.2 函数源文件
/* File Name: tcpsock.c */
/* 本文件给出九个函数的源代码，其中部分地方给出中文注释 */
#include "tcpsock.h"
intInitSocketsStruct(char * servicename)
/* Initialize Sockets structure. If succeed then return 1, else return error code (<0) */
/* 此函数用于只需要主动套接字的客户程序，它用来获取服务信息。服务的定义
在/etc/services 文件中 */
{
struct servent *servrec;
struct sockaddr_in serv_addr;
if ((servrec = getservbyname(servicename, "tcp")) == NULL) {
return(-1);
}
bzero((char *)&Mysock, sizeof(Sockets));
Mysock.Port = servrec->s_port; /* Service Port in Network Byte Order */
return(1);
}
intInitPassiveSock(char * servicename)
/* Initialize Passive Socket. If succeed then return 1, else return error code (<0) */
/* 此函数用于需要被动套接字的服务器程序，它除了获取服务信息外，还建立
一个被动套接字。*/
{
int mainsock, flag=1;
struct servent *servrec;
struct sockaddr_in serv_addr;
if ((servrec = getservbyname(servicename, "tcp")) == NULL) {
return(-1);
}
bzero((char *)&Mysock, sizeof(Sockets));
Mysock.Port = servrec->s_port; /* Service Port in Network Byte Order */
if((mainsock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
return(-2);
}bzero((char *)&serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); /* 任意网络接口 */
serv_addr.sin_port = servrec->s_port;
if (bind(mainsock, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0) {
close(mainsock);
return(-3);
}
if (listen(mainsock, 5) == -1) { /* 将主动套接字变为被动套接字，准备好接收连接 */
close(mainsock);
return(-4);
}
/* Set this socket as a Non-blocking socket. */
if (ioctl(mainsock, FIONBIO, &flag) == -1) {
close(mainsock);
return(-5);
}
Mysock.DaemonSock = mainsock;
FD_SET(mainsock, &Mysock.readfds); /* 申明对主套接字“可读”感兴趣 */
FD_SET(mainsock, &Mysock.exceptfds); /* 申明对主套接字上例外事件感兴趣 */
return(1);
}
voidCloseMainSock()
/* 关闭主套接字，并清除对它上面事件的申明。在程序结束前关闭主套接字是一个好习惯 */
{
close(Mysock.DaemonSock);
FD_CLR(Mysock.DaemonSock, &Mysock.readfds);
FD_CLR(Mysock.DaemonSock, &Mysock.exceptfds);
}
intCreateConnection(struct in_addr *sin_addr)
/* Create a Connection to remote host which IP address is in sin_addr.
Param: sin_addr indicates the IP address in Network Byte Order.
if succeed return the socket number which indicates this connection,
else return error code (<0) */
{
struct sockaddr_in server; /* server address */
int tmpsock, flag=1, i;
if ((tmpsock = socket(AF_INET, SOCK_STREAM, 0)) < 0)
return(-1);
server.sin_family = AF_INET;
server.sin_port = Mysock.Port;
server.sin_addr.s_addr = sin_addr->s_addr;
/* Set this socket as a Non-blocking socket. */
if (ioctl(tmpsock, FIONBIO, &flag) == -1) {
close(tmpsock);
return(-2);
}
/* Connect to the server. */
if (connect(tmpsock, (struct sockaddr *)&server, sizeof(server)) < 0) {
if ((errno != EWOULDBLOCK) && (errno != EINPROGRESS)) {
/* 如果错误代码是 EWOULDBLOCK 和 EINPROGRESS，则不用关闭套接字，因为系统将在之后继续
为套接字建立连接，连接是否建立成功可用 select()函数来检测套接字是否“可写”来确定。*/
close(tmpsock);
return(-3); /* Connect error. */
}
}
FD_SET(tmpsock, &Mysock.readfds);
FD_SET(tmpsock, &Mysock.writefds);
FD_SET(tmpsock, &Mysock.exceptfds);
i = 0;
while (Mysock.Sockets[i] != 0) i++; /* look for a blank sockets position */
if (i >= 64) {
close(tmpsock);
return(-4); /* too many connections */
}
Mysock.Sockets[i] = tmpsock;
Mysock.SockNum++;
return(i);
}
intAcceptConnection(struct in_addr *IPaddr)
/* Accept a connection. If succeed, return the data sockets number, else return -1. */
{
int newsock, len, flag=1, i;
struct sockaddr_in addr;
len = sizeof(addr);
bzero((char *)&addr, len);
if ((newsock = accept(Mysock.DaemonSock, &addr, &len)) == -1)
return(-1); /* Accept error. */
/* Set this socket as a Non-blocking socket. */
ioctl(newsock, FIONBIO, &flag);
FD_SET(newsock, &Mysock.readfds);
FD_SET(newsock, &Mysock.writefds);
FD_SET(newsock, &Mysock.exceptfds);
/* Return IP address in the Parameter. */
IPaddr->s_addr = addr.sin_addr.s_addr;
i = 0;
while (Mysock.Sockets[i] != 0) i++; /* look for a blank sockets position */
if (i >= 64) {
close(newsock);
return(-4); /* too many connections */
}
Mysock.Sockets[i] = newsock;
Mysock.SockNum++;
return(i);
}
intCloseConnection(int Sockno)
/* Close a connection indicated by Sockno. */
{
int retcode;
if ((Sockno >= 64) || (Sockno < 0) || (Mysock.Sockets[Sockno] == 0））
return(0);
retcode = close(Mysock.Sockets[Sockno]);
FD_CLR(Mysock.Sockets[Sockno], &Mysock.readfds);
FD_CLR(Mysock.Sockets[Sockno], &Mysock.writefds);
FD_CLR(Mysock.Sockets[Sockno], &Mysock.exceptfds);
Mysock.Sockets[Sockno] = 0;
Mysock.SockNum--;
return(retcode);
}
intQuerySocketsMsg()
/* Query Sockets Message. If succeed return message number, else return -1.
The message information stored in struct SockMsg. */
{
fd_set rfds, wfds, efds;
int retcode, i;
struct timeval TimeOut;
rfds = Mysock.readfds;
wfds = Mysock.writefds;
efds = Mysock.exceptfds;
TimeOut.tv_sec = 0; /* 立即返回，不阻塞。*/
TimeOut.tv_usec = 0;
bzero((char *)&SockMsg, sizeof(SockMsg));
if ((retcode = select(64, &rfds, &wfds, &efds, &TimeOut)) == 0)
return(0);
if (FD_ISSET(Mysock.DaemonSock, &rfds))
SockMsg.AcceptNum = 1; /* some client call server. */
for (i=0; i<64; i++) /* Data in message */
{
if ((Mysock.Sockets[i] > 0) && (FD_ISSET(Mysock.Sockets[i], &rfds)))
SockMsg.ReadQueue[SockMsg.ReadNum++] = i;
}
for (i=0; i<64; i++) /* Data out ready message */
{
if ((Mysock.Sockets[i] > 0) && (FD_ISSET(Mysock.Sockets[i], &wfds)))
SockMsg.WriteQueue[SockMsg.WriteNum++] = i;
}
if (FD_ISSET(Mysock.DaemonSock, &efds))
SockMsg.AcceptNum = -1; /* server socket error. */
for (i=0; i<64; i++) /* Error message */
{
if ((Mysock.Sockets[i] > 0) && (FD_ISSET(Mysock.Sockets[i], &efds)))
SockMsg.ExceptQueue[SockMsg.ExceptNum++] = i;
}
return(retcode);
}
intSendPacket(int Sockno, void *buf, int len)
/* Send a packet. If succeed return the number of send data, else return -1 */
{
int actlen;
if ((Sockno >= 64) || (Sockno < 0) || (Mysock.Sockets[Sockno] == 0))
return(0);
if ((actlen = send(Mysock.Sockets[Sockno], buf, len, 0)) < 0)
return(-1);
return(actlen);
}
intRecvPacket(int Sockno, void *buf, int size)
/* Receive a packet. If succeed return the number of receive data, else if the connection
is shutdown by peer then return 0, otherwise return 0-errno */
{
int actlen;
if ((Sockno >= 64) || (Sockno < 0) || (Mysock.Sockets[Sockno] == 0))
return(0);
if ((actlen = recv(Mysock.Sockets[Sockno], buf, size, 0)) < 0)
return(0-errno);
return(actlen); /* actlen 是接收的数据长度，如果为零，指示连接被对方关闭。*/
}
2.5.3 简单服务器程序示例
/* File Name: server.c */
/* 这是一个很简单的重复服务器程序，它初始化好被动套接字后，循环等待接收连接。如果接收到连接，它显示数据
套接字序号和客户端的 IP 地址；如果数据套接字上有数据到来，它接收数据并显示该连接的数据套接字序号和接收到
的字符串。*/
#include "tcpsock.c"
main(argc, argv)
int argc;
char **argv;
{
struct in_addr sin_addr;
int retcode, i;
char buf[32];
/* 对于服务器程序，它经常是处于无限循环状态，只有在用户主动 kill 该进程或系统关机时，它才结束。对于使用 kill
强行终止的服务器程序，由于主套接字没有关闭，资源没有主动释放，可能会给随后的服务器程序重新启动产生影响。
因此，主动关闭主套接字是一个良好的变成习惯。
下面的语句使程序在接收到 SIGINT、SIGQUIT和 SIGTERM 等信号
时先执行 CloseMainSock()函数关闭主套接字，然后再结束程序。因此，在使用 kill 强行终止服务器进程时，应该先使
用 kill -2 PID 给服务器程序一个消息使其关闭主套接字，然后在用 kill -9 PID 强行结束该进程。*/
(void) signal(SIGINT, CloseMainSock);
(void) signal(SIGQUIT, CloseMainSock);
(void) signal(SIGTERM, CloseMainSock);
if ((retcode = InitPassiveSock("TestService")) < 0) {
printf("InitPassiveSock: error code = %d\n", retcode);
exit(-1);
}
while (1) {
retcode = QuerySocketsMsg(); /* 查询网络消息 */
if (SockMsg.AcceptNum == 1) { /* 有外来连接等待接收？*/
retcode = AcceptConnection(&sin_addr);
printf("retcode = %d, IP = %s \n", retcode, inet_ntoa(sin_addr.s_addr));
}
elseif (SockMsg.AcceptNum == -1) /* 主套接字错误？*/
printf("Daemon Sockets error.\n");
for (i=0; i<SockMsg.ReadNum; i++) { /* 接收外来数据 */
if ((retcode = RecvPacket(SockMsg.ReadQueue[i], buf, 32)) > 0)
printf("sockno %d Recv string = %s \n", SockMsg.ReadQueue[i], buf);
else/* 返回数据长度为零，指示连接中断，关闭套接字。*/
CloseConnection(SockMsg.ReadQueue[i]);
}
} /* end while */
}
2.5.4 简单客户程序示例
/* File Name: client.c */
/* 客户程序在执行时，先初始化数据结构，然后等待用户输入命令。它识别四个命令：
conn(ect)： 和服务器建立连接；
send： 给指定连接发送数据；
clos(e)： 关闭指定连接；
quit： 退出客户程序。
*/
#include "tcpsock.h"
main(argc, argv)
int argc;
char **argv;
{
char cmd_buf[16];
struct in_addr sin_addr;
int sockno1, retcode;
char *buf = "This is a string for test.";
sin_addr.s_addr = inet_addr("166.111.5.249"); /* 运行服务器程序的主机的 IP 地址 */
if ((retcode = InitSocketsStruct("TestService")) < 0) { /* 初始化数据结构 */
printf("InitSocketsStruct: error code = %d\n", retcode);
exit(1);
}
while (1) {
printf(">");
gets(cmd_buf);
if (!strncmp(cmd_buf, "conn", 4)) {
retcode = CreateConnection(&sin_addr); /* 建立连接 */
printf("return code: %d\n", retcode);
}
elseif(!strncmp(cmd_buf, "send", 4)) {
printf("Sockets Number:");
scanf("%d", &sockno1);
retcode = SendPacket(sockno1, buf, 26); /* 发送数据 */
printf("return code: %d\n", retcode, sizeof(buf));
}
elseif (!strncmp(cmd_buf, "close", 4)) {
printf("Sockets Number:");
scanf("%d", &sockno1);
retcode = CloseConnection(sockno1); /* 关闭连接 */
printf("return code: %d\n", retcode);
}
elseif (!strncmp(cmd_buf, "quit", 4))
exit(0);
else
putchar('\007');
} /* end while */
}
3 基本套接字系统调用
为了更好地说明套接字编程原理，下面给出几个基本套接字系统调用说明。
3.1 创建套接字──socket()
应用程序在使用套接字前，首先必须拥有一个套接字，系统调用socket()向应用程序提供创建套接字的手段，其调用格式如下：
SOCKET PASCAL FAR socket(int af, int type, int protocol);
该调用要接收三个参数：af、type、protocol。参数af指定通信发生的区域，UNIX系统支持的地址族有：AF_UNIX、AF_INET、AF_NS等，而DOS、WINDOWS中仅支持AF_INET，它是网际网区域。因此，地址族与协议族相同。参数type 描述要建立的套接字的类型。参数protocol说明该套接字使用的特定协议，如果调用者不希望特别指定使用的协议，则置为0，使用默认的连接模式。根据这三个参数建立一个套接字，并将相应的资源分配给它，同时返回一个整型套接字号。因此，socket()系统调用实际上指定了相关五元组中的“协议”这一元。
3.2 指定本地地址──bind()
当一个套接字用socket()创建后，存在一个名字空间(地址族),但它没有被命名。bind()将套接字地址（包括本地主机地址和本地端口地址）与所创建的套接字号联系起来，即将名字赋予套接字，以指定本地半相关。其调用格式如下：
int PASCAL FAR bind(SOCKET s, conststruct sockaddr FAR * name, int namelen);
参数s：是由socket()调用返回的并且未作连接的套接字描述符(套接字号)。
参数name： 是赋给套接字s的本地地址（名字），其长度可变，结构随通信域的不同而不同。
参数namelen：表明了name的长度。
如果没有错误发生，bind()返回0。否则返回值SOCKET_ERROR。
地址在建立套接字通信过程中起着重要作用，作为一个网络应用程序设计者对套接字地址结构必须有明确认识。例如，UNIX BSD有一组描述套接字地址的数据结构，其中使用TCP/IP协议的地址结构为：
struct sockaddr_in{
short sin_family; /*AF_INET*/
u_short sin_port; /*16位端口号，网络字节顺序*/
struct in_addr sin_addr; /*32位IP地址，网络字节顺序*/
char sin_zero[8]; /*保留*/
}
3.3 建立套接字连接──connect()与accept()
这两个系统调用用于完成一个完整相关的建立，其中connect()用于建立连接。无连接的套接字进程也可以调用connect()，但这时在进程之间没有实际的报文交换，调用将从本地操作系统直接返回。这样做的优点是程序员不必为每一数据指定目的地址，而且如果收到的一个数据报，其目的端口未与任何套接字建立“连接”，便能判断该端靠纪纪可操作。而accept()用于使服务器等待来自某客户进程的实际连接。
connect()的调用格式如下：
int PASCAL FAR connect(SOCKET s, conststruct sockaddr FAR * name, int namelen);
由于地址族总被包含在套接字地址结构的前两个字节中，并通过socket()调用与某个协议族相关。因此bind()和connect()无须协议作为参数。
accept()的调用格式如下：
SOCKET PASCAL FAR accept(SOCKET s, struct sockaddr FAR* addr, int FAR* addrlen);
accept()用于面向连接服务器。参数addr和addrlen存放客户方的地址信息。调用前，参数addr 指向一个初始值为空的地址结构，而addrlen 的初始值为0；
四个套接字系统调用，socket()、bind()、connect()、accept()，可以完成一个完全五元相关的建立。
socket()指定五元组中的协议元，它的用法与是否为客户或服务器、是否面向连接无关。
bind()指定五元组中的本地二元，即本地主机地址和端口号，
=》 面向连接，则可以不调用bind()，而通过connect()自动完成。
若采用无连接，客户方必须使用bind()以获得一个唯一的地址。
3.4 监听连接──listen()
此调用用于面向连接服务器，表明它愿意接收连接。listen()需在accept()之前调用，其调用格式如下：
int PASCAL FAR listen(SOCKET s, int backlog);
backlog表示请求连接队列的最大长度，用于限制排队请求的个数，目前允许的最大值为5。
如果没有错误发生，listen()返回0。
否则它返回SOCKET_ERROR。
listen()在执行调用过程中可为没有调用过bind()的套接字s完成所必须的连接，并建立长度为backlog的请求连接队列。
调用listen()是服务器接收一个连接请求的四个步骤中的第三步。它在调用socket()分配一个流套接字，且调用bind()给s赋于一个名字之后调用，而且一定要在accept()之前调用。
客户/服务器模式中，有两种类型的服务：重复服务和并发服务。accept()调用为实现并发服务提供了极大方便，因为它要返回一个新的套接字号，其典型结构为：
int initsockid, newsockid;
if ((initsockid = socket(....)) < 0)
error(“can’t create socket”);
if (bind(initsockid,....) < 0)
error(“bind error”);
if (listen(initsockid , 5) < 0)
error(“listen error”);
for (; {
newsockid = accept(initsockid, ...) /* 阻塞 */
if (newsockid < 0)
error(“accept error“);
if (fork() == 0){ /* 子进程 */
closesocket(initsockid);
do(newsockid); /* 处理请求 */
exit(0);
}
closesocket(newsockid); /* 父进程 */
}
这段程序执行的结果是newsockid与客户的套接字建立相关：
子进程启动后，关闭继承下来的主服务器的initsockid,并利用新的newsockid与客户通信。主服务器的initsockid可继续等待新的客户连接请求。由于在Unix等抢先多任务系统中，在系统调度下，多个进程可以同时进行。因此，使用并发服务器可以使服务器进程在同一时间可以有多个子进程和不同的客户程序连接、通信。
客户程序看来，服务器可以同时并发地处理多个客户的请求，这就是并发服务器名称的来由。
面向连接服务器也可以是重复服务器，其结构如下：
int initsockid, newsockid;
if ((initsockid = socket(....))<0)
error(“can’t create socket”);
if (bind(initsockid,....)<0)
error(“bind error”);
if (listen(initsockid,5)<0)
error(“listen error”);
for (; {
newsockid = accept(initsockid, ...) /* 阻塞 */
if (newsockid < 0)
error(“accept error“);
do(newsockid); /* 处理请求 */
closesocket(newsockid);
}
重复服务器在一个时间只能和一个客户程序建立连接，
它对多个客户程序的处理是采用循环的方式重复进行，因此叫重复服务器。
并发服务器可以改善客户程序的响应速度，但它增加了系统调度的开销；重复服务器正好与其相反，因此用户在决定是使用并发服务器还是重复服务器时，要根据应用的实际情考网考网来定。
3.5 数据传输──send()与recv()
当一个连接建立以后，就可以传输数据了。常用的系统调用有send()和recv()。
send()调用用于已连接的数据报或流套接字上发送输出数据，格式如下：
int PASCAL FAR send(SOCKET s, constchar FAR *buf, int len, int flags);
buf 指向存有发送数据的缓冲区的指针，
len :buf长度由len 指定。
flags 指定传输控制方式，如是否发送带外数据等。
如果没有错误发生，send()返回总共发送的字节数。否则它返回SOCKET_ERROR。
recv()调用用于已连接的数据报或流套接字上接收输入数据，格式如下：
int PASCAL FAR recv(SOCKET s, char FAR *buf, int len, int flags);
3.6 输入/输出多路复用──select()
select()调用用来检测一个或多个套接字的状态。
这个调用可以请求读、写或错误状态方面的信息。
请求给定状态的套接字集合由一个fd_set结构指示。
在返回时，此结构被更新，以反映那些满足特定条件的套接字的子集，同时， select()调用返回满足条件的套接字的数目，其调用格式如下：
int PASCAL FAR select(int nfds, fd_set FAR * readfds, fd_set FAR * writefds, fd_set FAR * exceptfds, const struct timeval FAR * timeout);
参数nfds:指明被检查的套接字描述符的值域，此变量一般被忽略。
参数readfds:指向要做读检测的套接字描述符集合的指针，调用者希望从中读取数据。
参数writefds :指向要做写检测的套接字描述符集合的指针。
exceptfds指向要检测是否出错的套接字描述符集合的指针。
timeout指向select()函数等待的最大时间，如果设为NULL则为阻塞操作。
select()返回包含在fd_set结构中已准备好的套接字描述符的总数目，或者是发生错误则返回SOCKET_ERROR。
3.7 关闭套接字──closesocket()
closesocket()关闭套接字s，并释放分配给该套接字的资源；如果s涉及一个打开的TCP连接，则该连接被释放。closesocket()的调用格式如下：
BOOL PASCAL FAR closesocket(SOCKET s);
参数s待关闭的套接字描述符。如果没有错误发生，closesocket()返回0。否则返回值SOCKET_ERROR。