socket编程原理

socket编程原理

一、问题的引入  

1) 普通的I/O操做过程:

UNIX系统的I/O命令集，是从Maltics和早期系统中的命令演变出来的，其模式为打开一读/写一关闭（open-write-read-close）。在一个用户进程进行I/O操做时，它首先调用“打开”得到对指定文件或设备的使用权，并返回称为文件描写叙述符的整型数，以描写叙述用户在打开的文件或设备上进行I/O操做的进程。而后这个用户进程屡次调用“读/写”以数据传输。当所有的传输操做完毕后，用户进程关闭调用，通知操做系统已经完毕了对某对象的使用。 

2) TCP/IP协议被集成到UNIX内核中

TCP/IP协议被集成到UNIX内核中时，至关于在UNIX系统引入了一种新型的I/O操做。UNIX用户进程与网络协议的交互做用比用户进程与传统的I/O设备相互做用复杂得多。首先，进行网络操做的两个进程在不一样机器上，怎样创建它们之间的联系？其次，网络协议存在多种，怎样创建一种通用机制以支持多种协议？这些都是网络应用编程界面所要解决的问题。 

3) 需要一种通用的网络编程接口:  独立于详细协议和通用的网络编程

在UNIX系统中，网络应用编程界面有两类：UNIX BSD的套接字（socket）和UNIX System V的TLI。由于Sun公司採用了支持TCP/IP的UNIX BSD操做系统，使TCP/IP的应用有更大的发展，其网络应用编程界面──套接字（socket）在网络软件中被普遍应用，至今已引进微机操做系统DOS和Windows系统中，成为开发网络应用软件的强有力工具，本章将要具体讨论这个问题。 

2 、套接字编程基本概念  

         開始使用套接字编程以前，首先必须创建下面概念。 

2.1 网间进程通讯  

进程通讯的概念最初来源于单机系统。由于每个进程都在本身的地址范围内执行，为保证两个相互通讯的进程之间既互不干扰又协调一致工做，操做系统为进程通讯提供了对应设施，

如UNIX BSD有：管道（pipe）、命名管道（named pipe）软中断信号（signal）

UNIX system V有：消息（message）、共享存储区（shared memory）和信号量（semaphore)等.

他们都仅限于用在本机进程之间通讯。网间进程通讯要解决的是不一样主机进程间的相互通讯问题（可把同机进程通讯看做是当中的特例）。为此，首先要解决的是网间进程标识问题。同一主机上，不一样进程可用进程号（process ID）惟一标识。但在网络环境下，各主机独立分配的进程号不能惟一标识该进程。好比，主机A赋于某进程号5，在B机中也可以存在5号进程，所以，“5号进程”这句话就没有意义了。 其次，操做系统支持的网络协议众多，不一样协议的工做方式不一样，地址格式也不一样。所以，网间进程通讯还要解决多重协议的识别问题。 为了解决上述问题，TCP/IP协议引入了下列几个概念。 

1）port 

网络中可以被命名和寻址的通讯port，是操做系统可分配的一种资源。 

依照OSI七层协议的描写叙述，传输层与网络层在功能上的最大差异是传输层提供进程通讯能力。从这个意义上讲，网络通讯的终于地址就不不过主机地址了，还包含可以描写叙述进程的某种标识符。为此，TCP/IP协议提出了协议port（protocol port，简称端口）的概念，用于标识通讯的进程。 

port是一种抽象的软件结构（包含一些数据结构和I/O缓冲区）。应用程序（即进程）经过系统调用与某端口创建链接（binding）后，传输层传给该port的数据都被对应进程所接收，对应进程发给传输层的数据都经过该port输出。在TCP/IP协议的实现中，对port的操做相似于通常的I/O操做，进程获取一个port，至关于获取本地惟一的I/O文件，可以用通常的读写原语訪问之。 相似于文件描写叙述符，每个port都拥有一个叫port号（port number）的整数型标识符，用于差异不一样port。

由于TCP/IP传输层的两个协议TCP和UDP是全然独立的两个软件模块，所以各自的port号也相互独立，如TCP有一个255号port，UDP也可以有一个255号port，两者并不冲突。 

port号的分配是一个重要问题。有两种基本分配方式：第一种叫全局分配，这是一种集中控制方式，由一个公认的中央机构依据用户需要进行统一分配，并将结果发布于众。另一种是本地分配，又称动态链接，即进程需要訪问传输层服务时，向本地操做系统提出申请，操做系统返回一个本地惟一的port号，进程再经过合适的系统调用将本身与该port号联系起来（绑扎）。TCP/IPport号的分配中综合了上述两种方式。TCP/IP将port号分为两部分，少许的做为保留port，以全局方式分配给服务进程。所以，每一个标准server都拥有一个全局公认的port（即周知口，well-known port），即便在不一样的机器上，其port号也一样。剩余的为自由port，以本地方式进行分配。TCP和UDP均规定，小于256的port号才干做保留port。 

2）地址 

网络通讯中通讯的两个进程分别在不一样的机器上。在互连网络中，两台机器可能位于不一样的网络，这些网络经过网络互连设备（网关，网桥，路由器等）链接。所以需要三级寻址： 

1. 某一主机可与多个网络相连，必须指定一特定网络地址； 

2. 网络上每一台主机应有其惟一的地址； 

3. 每一主机上的每一进程应有在该主机上的惟一标识符。 

一般主机地址由网络ID和主机ID组成，在TCP/IP协议中用32位整数值表示；TCP和UDP均使用16位port号标识用户进程。 

3）网络字节顺序 

不一样的计算机存放多字节值的顺序不一样，有的机器在起始地址存放低位字节（小端序），有的存高位字节（大端序）。为保证数据的正确性，在网络协议中须指定网络字节顺序。TCP/IP协议使用16位整数和32位整数的高价先存格式，它们均含在协议头文件里。 具体解释http://blog.csdn.net/hguisu/article/details/7449955#t1

4）链接 

两个进程间的通讯链路称为链接。链接在内部表现为一些缓冲区和一组协议机制，在外部表现出比无链接高的可靠性。 

5）半相关 

综上所述，网络中用一个三元组可以在全局惟一标志一个进程： 

（协议，本地地址，本地port号） 这样一个三元组，叫作一个半相关（half-association），它指定链接的每半部分。 

6）全相关 

一个完整的网间进程通讯需要由两个进程组成，并且仅仅能使用同一种高层协议。也就是说，不可能通讯的一端用TCP协议，而还有一端用UDP协议。所以一个完整的网间通讯需要一个五元组来标识： 

（协议，本地地址，本地port号，远地地址，远地port号） 这样一个五元组，叫作一个相关（association），即两个协议一样的半相关才干组合成一个合适的相关，或全然指定组成一链接。 

2.2 服务方式  

在网络分层结构中，各层之间是严格单向依赖的，各层次的分工和协做集中体现在不一样层之间的界面上。“服务”是描写叙述不一样层之间关系的抽象概念，即网络中各层向紧邻上层提供的一组操做。下层是服务提供者，上层是请求服务的用户。服务的表现形式是原语（primitive），如系统调用或库函数。系统调用是操做系统内核向网络应用程序或高层协议提供的服务原语。网络中的n层总要向n+1层提供比n-1层更完备的服务，不然n层就没有存在的价值。 在OSI的术语中，网络层及其下面各层又称为通讯子网，仅仅提供点到点通讯，没有程序或进程的概念。而传输层实现的是“端到端”通讯，引进网间进程通讯概念，同一时候也要解决差错控制，流量控制，数据排序（报文排序），链接管理等问题，为此提供不一样的服务方式： 

1）面向链接（虚电路）或无链接 

面向链接服务（TCP协议） ：是电话系统服务模式的抽象，即每一次完整的传输数据都要通过创建链接，使用链接，终止连 接的过程。在传输数据过程当中，各数据分组不携带目的地址，而使用链接号（connect ID）。本质上，链接 是一个管道，收发数据不但顺序一致，而且内容一样。TCP协议提供面向链接的虚电路。

无链接服务（UDP协议）：是邮政系统服务的抽象，每个分组都携带完整的目的地址，各分组在系统中独立传送。无链接服务不能保证分组的前后顺序，不进行分组出错的恢复与重传，不保证传输的可靠性。UDP协议提供无链接的数据报服务。 

如下给出这两种服务的类型及应用中的样例： 

2）顺序 

在网络传输中，两个连续报文在端－端通讯中可能通过不一样路径，这样到达目的地时的顺序可能会与发送时不一样。“顺序”是指接收数据顺序与发送数据顺序一样。TCP协议提供这项服务。 

3）差错控制 

保证应用程序接收的数据无差错的一种机制。检查差错的方法一般是採用检验“检查和（Checksum）”的方法。而保证传送无差错的方法是两方採用确认应答技术。TCP协议提供这项服务。 

4）流控制 

在传输数据过程当中控制传输数据速率的一种机制，以保证数据不被丢失。TCP协议提供这项服务。 

5）字节流 

字节流方式指的是仅把传输中的报文看做是一个字节序列，不提供数据流的不论什么边界。TCP协议提供字节流

服务。 

6）报文 

接收方要保存发送方的报文边界。UDP协议提供报文服务。 

7）全双工/半双工 

端－端间数据同一时候以两个方向/一个方向传送。 

8）缓存/带外数据 

在字节流服务中，由于没有报文边界，用户进程在某一时刻可以读或写随意数量的字节。为保证传输正确或採用有流控制的协议时，都要进行缓存。但对某些特殊的需求，如交互式应用程序，又会要求取消这样的缓存。 在数据传送过程当中，但愿不经过常规传输方式传送给用户以便及时处理的某一类信息，如UNIX系统的中断键（Delete或Control-c）、终端流控制符（Control-s和Control-q），称为带外数据。逻辑上看，好象用户进程使用了一个独立的通道传输这些数据。该通道与每对链接的流相联系。由于Berkeley Software Distribution中对带外数据的实现与RFC 1122中规定的Host Agreement不一致,为了将互操做中的问题减到最小，应用程序编写者除非与现有服务互操做时要求带外数据外，最好不使用它。 

2.3 客户/server模式  

在TCP/IP网络应用中，通讯的两个进程间相互做用的主要模式是客户/server模式（Client/Server model），即客户向server发出服务请求，server接收到请求后，提供对应的服务。客户/server模式的创建基于以下两点：首先，创建网络的原由是网络中软硬件资源、运算能力和信息不均等，需要共享，从而造就拥有众多资源的主机提供服务，资源较少的客户请求服务这一非对等做用。其次，网间进程通讯全然是异步的，相互通讯的进程间既不存在父子关系，又不共享内存缓冲区，所以需要一种机制为但愿通讯的进程间创建联系，为两者的数据交换提供同步，这就是基于不一样的客户/server模式的TCP/IP。 客户/server模式在工做过程当中採取的是主动请求方式： 

server方：

首先server方要先启动，并依据请求提供对应服务： 

1. 打开一通讯通道并告知本地主机，它愿意在某一公认地址上（周知口，如FTP为21）接收客户请求； 

2. 等待客户请求到达该port； 

3. 接收到反复服务请求，处理该请求并发送应答信号。接收到并发服务请求，要激活一新进程来处理这个客户请求（如UNIX系统中用fork、exec）。新进程处理此客户请求，并不需要对其余请求做出应答。服务完成后，关闭此新进程与客户的通讯链路，并终止。 

4. 返回第二步，等待还有一客户请求。 

5. 关闭server 

客户方： 

1. 打开一通讯通道，并链接到server所在主机的特定port； 

2. 向server发服务请求报文，等待并接收应答；继续提出请求...... 

3. 请求结束后关闭通讯通道并终止。 

从上面所描写叙述过程可知： 

1. 客户与server进程的做用是非对称的，所以编码不一样。 

2. 服务进程一般是先于客户请求而启动的。仅仅要系统执行，该服务进程一直存在，直到正常或强迫终止。 

2.4 套接字类型  

TCP/IP的socket提供下列三种类型套接字。 

流式套接字（SOCK_STREAM）：

提供了一个面向链接、可靠的传输数据服务，数据无差错、无反复地发送，且按发送顺序接收。内设流量控

制，避免数据流超限；数据被看做是字节流，无长度限制。文件传送协议（FTP）即便用流式套接字。 

数据报式套接字（SOCK_DGRAM）：

提供了一个无链接服务。数据包以独立包形式被发送，不提供无错保证，

数据可能丢失或反复，并且接收顺序混乱。网络文件系统（NFS）使用数据报式套接字。 

原始式套接字（SOCK_RAW） ：

该接口赞成对较低层协议，如IP、ICMP直接訪问。常用于检验新的协议实现或訪问现有服务中配置的新设备。 

2.4 典型套接字调用过程举例  

如前所述，TCP/IP协议的应用通常採用客户/server模式，所以在实际应用中，必须有客户和server两个进 程，并且首先启动server，其系统调用时序图例如如下。  面向链接的协议（如TCP）的套接字系统调用如图2.1所看到的：

 

server必须首先启动，直到它运行完accept()调用，进入等待状态后，方能接收客户请求。假如客户在此前启动，则connect()将返回出错代码，链接不成功。 无链接协议的套接字调用如图2.2所看到的：  

无链接server也必须先启动，不然客户请求传不到服务进程。无链接客户不调用connect()。所以在数据发送以前，客户与server之间还没有创建全然相关，但各自经过socket()和bind()创建了半相关。发送数据时，发送方除指定本地套接字号外，还需指定接收方套接字号，从而在数据收发过程当中动态地创建了全相关。 

实例 

本实例使用面向链接协议的客户/server模式，其流程如图2.3所看到的： 

server方程序： 

/* 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); 
} 

/* 使用随意port命名套接字 */ 
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); 
} 

/* 找出指定的port号并打印出来 */ 
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”); 
else do{ 
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 主机名 port号 
port号要与server程序的port号一样 */ 
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程序实例。从这个样例咱们可以看出，使用socket编程差点儿有一 个模式，即所有的程序差点儿毫无例外地按一样的顺序调用一样的函数。所以咱们可以设想，设计一个中间层 ，它向上提供几个简单的函数，程序仅仅要调用这几个函数就可以实现普通的网络传输数据，程序设计者没必要 太多地关心socket程序设计的细节。  本节咱们将介绍一个通用的网络程序接口，它向上层提供几个简单的函数，程序设计者仅仅要使用这几个函数 就可以完毕绝大多数网络传输数据。这些函数将socket编程和上层隔离开来，它使用面向链接的流式套接字 ，採用非堵塞的工做机制，程序仅仅要调用这些函数查询网络消息并做出对应的响应就能够。这些函数包含： 

l InitSocketsStruct：初始化socket结构，获取服务port号。客户程序使用。 

l InitPassiveSock：初始化socket结构，获取服务port号，创建主套接字。server程序使用。 

l CloseMainSock：关闭主套接字。server程序使用。 

l CreateConnection：创建链接。客户程序使用。 

l AcceptConnection：接收链接。server程序使用。 

l CloseConnection：关闭链接。 

l QuerySocketsMsg：查询套接字消息。 

l SendPacket：发送数据。 

l RecvPacket：接收数据。 

2.5.1 头文件  

/* File Name: tcpsock.h */ 

/* 头文件包含socket程序经常用到的系统头文件（本例中给出的是SCO Unix下的头文件，其余版本号的Unix的头文件可能略有不一样），并定义了咱们本身的两个数据结构及事实上例变量，以及咱们提供的函数说明。*/

/* 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> 
  
typedef struct SocketsMsg{ /*  套接字消息结构 */ 
    int AcceptNum;  /*  指示是否有外来链接等待接收 */ 
    int ReadNum;   /*  有外来数据等待读取的链接数 */ 
    int ReadQueue[32];   /*  有外来数据等待读取的链接队列 */ 
    int WriteNum;   /*  可以发送数据的链接数 */ 
    int WriteQueue[32];   /*  可以发送数据的链接队列 */ 
    int ExceptNum;  /*  有例外的链接数 */ 
    int ExceptQueue[32];   /*  有例外的链接队列 */ 
} SocketsMsg; 
 typedef struct Sockets {  /*  套接字结构 */ 
    int DaemonSock;  /*  主套接字 */ 
    int SockNum;   /*  数据套接字数目 */
    int Sockets[64];  /*  数据套接字数组 */ 
    fd_set readfds, writefds, exceptfds; /*  要被检測的可
    int Port;    /*  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" 
  
int InitSocketsStruct(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);     
} 
  
int InitPassiveSock(char * servicename)  
/* Initialize Passive Socket. If succeed then return 1, else return error code (<0) */ 
/*  此函数用于需要被动套接字的server程序，它除了获取服务信息外，还创建 
    一个被动套接字。*/ 
{ 
    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);     
} 
void CloseMainSock() 
/*  关闭主套接字，并清除对它上面事件的申明。在程序结束前关闭主套接字是一个好习惯 */ 
{ 
    close(Mysock.DaemonSock); 
    FD_CLR(Mysock.DaemonSock, &Mysock.readfds); 
    FD_CLR(Mysock.DaemonSock, &Mysock.exceptfds); 
} 
  
int CreateConnection(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); 
} 
  
int AcceptConnection(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); 
}
int CloseConnection(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); 
}
int QuerySocketsMsg() 
/* 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); 
} 
  
int SendPacket(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); 
} 
  
int RecvPacket(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 简单server程序演示样例  

/* File Name: server.c */ 
/*  这是一个很是easy的反复server程序，它初始化好被动套接字后，循环等待接收链接。假设接收到链接，它显示数据
套接字序号和client的 IP 地址；假设数据套接字上有数据到来，它接收数据并显示该链接的数据套接字序号和接收到
的字符串。*/ 
#include "tcpsock.c" 
main(argc, argv) 
int argc; 
char **argv; 
{ 
 struct in_addr sin_addr; 
     int retcode, i; 
    char buf[32]; 
  
/*  对于server程序，它经常是处于无限循环状态，仅仅有在用户主动 kill 该进程或系统关机时，它才结束。对于使用 kill
强行终止的server程序，由于主套接字没有关闭，资源没有主动释放，可能会给随后的server程序又一次启动产生影响。
所以，主动关闭主套接字是一个良好的变成习惯。如下的语句使程序在接收到 SIGINT、SIGQUIT和 SIGTERM 等信号
时先运行 CloseMainSock()函数关闭主套接字，而后再结束程序。所以，在使用 kill 强行终止server进程时，应该先使
用 kill -2 PID 给server程序一个消息使其关闭主套接字，而后在用 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)); 
  } 
  else if (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)：  和server创建链接； 
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");    /*  执行server程序的主机的 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); 
	  } 
	  else if(!strncmp(cmd_buf, "send", 4)) { 
		   printf("Sockets Number:"); 
		   scanf("%d", &sockno1); 
		   retcode = SendPacket(sockno1, buf, 26); /*  发送数据 */ 
		   printf("return code: %d\n", retcode, sizeof(buf)); 
	  } 
	  else if (!strncmp(cmd_buf, "close", 4)) { 
		   printf("Sockets Number:"); 
		   scanf("%d", &sockno1); 
		   retcode = CloseConnection(sockno1);  /*  关闭链接 */ 
		   printf("return code: %d\n", retcode); 
	  } 
	  else if (!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()将套接字地址（包含本地主机地址和本地port地址）与所建立的套接字号联系起来，即将名字赋予套接字，以指定本地半相关。其调用格式例如如下：

 int PASCAL FAR bind(SOCKET s, const struct 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()，但这时在进程之间没有实际的报文交换，调用将从本地操做系统直接返回。这样作的长处是程序猿没必要为每一数据指定目的地址，而且假设收到的一个数据报，其目的port未与不论什么套接字创建“链接”，便能推断该端靠纪纪可操做。而accept()用于使server等待来自某客户进程的实际链接。
    connect()的调用格式例如如下：
 

 int PASCAL FAR connect(SOCKET s, const struct sockaddr FAR * name, int namelen);

    參数s：是欲创建链接的本地套接字描写叙述符。
    參数name：指出说明对方套接字地址结构的指针。
    namele：对方套接字地址长度由namelen说明。
    假设没有发生错误，connect()返回0。不然返回值SOCKET_ERROR。在面向链接的协议中，该调用致使本地系统和外部系统之间链接实际创建。
    由于地址族总被包括在套接字地址结构的前两个字节中，并经过socket()调用与某个协议族相关。所以bind()和connect()无须协议做为參数。
    accept()的调用格式例如如下：

SOCKET PASCAL FAR accept(SOCKET s, struct sockaddr FAR* addr, int FAR* addrlen);

參数s：为本地套接字描写叙述符，在用作accept()调用的參数前应该先调用过listen()。
參数addr： 指向客户方套接字地址结构的指针，用来接收链接实体的地址。addr的确切格式由套接字建立时创建的地址族决定。
參数addrlen: 为客户方套接字地址的长度（字节数）。假设没有发生错误，accept()返回一个SOCKET类型的值，表示接收到的套接字的描写叙述符。不然返回值INVALID_SOCKET。
    accept()用于面向链接server。參数addr和addrlen存放客户方的地址信息。调用前，參数addr 指向一个初始值为空的地址结构，而addrlen 的初始值为0；调用accept()后，server等待从编号为s的套接字上接受客户链接请求，而链接请求是由客户方的connect()调用发出的。当有链接请求到达时，accept()调用将请求链接队列上的第一个客户方套接字地址及长度放入addr 和addrlen，并建立一个与s有一样特性的新套接字号。新的套接字可用于处理server并发请求。
    四个套接字系统调用，socket()、bind()、connect()、accept()，可以完毕一个全然五元相关的创建。socket()指定五元组中的协议元，它的使用方法与是否为客户或server、是否面向链接无关。bind()指定五元组中的本地二元，即本地主机地址和port号，其使用方法与是否面向链接有关：在server方，不论是否面向链接，均要调用bind()；钥纪纪户方，若採用面向链接，则可以不调用bind()，而经过connect()本身主动完毕。若採用无链接，客户方必须使用bind()以得到一个惟一的地址。
    以上讨论仅对客户/server模式而言，实际上套接字的使用是很灵活的，惟一需遵循的原则是进程通讯以前，必须创建完整的相关。

 3.4 监听链接──listen()

 

    此调用用于面向链接server，代表它愿意接收链接。listen()需在accept()以前调用，其调用格式例如如下：
int PASCAL FAR listen(SOCKET s, int backlog);
    參数s标识一个本地已创建、还没有链接的套接字号，server愿意从它上面接收请求。backlog表示请求链接队列的最大长度，用于限制排队请求的个数，眼下赞成的最大值为5。假设没有发生错误，listen()返回0。不然它返回SOCKET_ERROR。
    listen()在运行调用过程当中可为没有调用过bind()的套接字s完毕所必须的链接，并创建长度为backlog的请求链接队列。
    调用listen()是server接收一个链接请求的四个步骤中的第三步。它在调用socket()分配一个流套接字，且调用bind()给s赋于一个名字以后调用，而且必定要在accept()以前调用。
    2.3节中提到钥纪纪户/server模式中，有两种类型的服务：反复服务和并发服务。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与客户的套接字创建相关，子进程启动后，关闭继承下来的主server的initsockid,并利用新的newsockid与客户通讯。主server的initsockid可继续等待新的客户链接请求。由于在Unix等抢先多任务系统中，在系统调度下，多个进程可以同一时候进行。所以，使用并发server可以使server进程在同一时间可以有多个子进程和不一样的客户程序链接、通讯。钥纪纪户程序看来，server可以同一时候并发地处理多个客户的请求，这就是并发server名称的来由。
    面向链接server也可以是反复server，其结构例如如下：

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

    反复server在一个时间仅仅能和一个客户程序创建链接，它对多个客户程序的处理是採用循环的方式反复进行，所以叫反复server。并发server和反复server各有利弊：并发server可以改善客户程序的响应速度，但它添加�了系统调度的开销；反复server正好与其相反，所以用户在决定是使用并发server仍是反复server时，要依据应用的实际情考网考网来定。

3.5 传输数据──send()与recv()

    当一个链接创建之后，就可以数据传输了。常用的系统调用有send()和recv()。
    send()调用用于钥纪纪数s指定的已链接的数据报或流套接字上发送输出数据，格式例如如下：

int PASCAL FAR send(SOCKET s, const char FAR *buf, int len, int flags);

參数s:为已链接的本地套接字描写叙述符。
buf 指向存有发送数据的缓冲区的指针，
len :buf长度由len 指定。
flags 指定传输控制方式，如是否发送带外数据等。
假设没有发生错误，send()返回总共发送的字节数。不然它返回SOCKET_ERROR。
    recv()调用用于钥纪纪数s指定的已链接的数据报或流套接字上接收输入数据，格式例如如下：

   int PASCAL FAR recv(SOCKET s, char FAR *buf, int len, int flags);

參数s 为已链接的套接字描写叙述符。
buf:指向接收输入数据缓冲区的指针，
len :buf长度由len 指定。
flags 指定传输控制方式，如是否接收带外数据等。
假设没有发生错误，recv()返回总共接收的字节数。假设链接被关闭，返回0。不然它返回SOCKET_ERROR。

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指向要检測是否出错的套接字描写叙述符集合的指针。
imeout指向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。