基本原理
计算机网络体系结构模式
通信模式
所有的网络通信的实现方式可以分为两种：线路交换和
包交换
所谓线路交换就是指传输时在发送端和接收端之间建立
一个特定的线路连接数据就可以在这条线路上传输
最常用的电话就是采用这种线路交换的技术
计算机网络采用的是包交换的方法所有的计算机使用一
个共同的网络连接 数据的发送端将要传输的数据分割
成
块而每个块经过适当的处理（数据封装）后形成一个数
据
包，包中有接收端的地址等必要信息，并且每个包单独
传输
OSI标准
系统互联标准(Open System Interconnection)
定义的是一种七层通信协议标准
物理层（Physical）
数据链接层（Data Link）
网络层（Network）
传输层（Transport）
会话层（Session）
表示层（Presentation）
应用层（Application）
应用层
应用层是网络的最高层 也就是最接近用户的一层 应用
层里包含了构筑在各种通信协议上的网络应用软件 可
以
实现与用户直接交互的功能 例如电子邮件和文件传输
程
序
表示层
表示层完成被传输数据的表示和解释工作 它包含数据
转
换和数据加密以及数据压缩等 它的主要功能为：
为用户提供执行会话层服务原语的手段
提供描述复杂数据结构的方法
管理当前所需的数据结构集
完成数据的内部格式与外部格式间的转换
会话层
会话层使用运输层协议提供的可靠的端到端通信服务
并
增加一些用户所需要的附加功能和建立不同机器上的用
户之间的数据交换
传输层
它是OSI网络体系结构中最核心的一层 它把实际使用的
通信子网与高层应用分开 提供发送端和接收端之间的
高
可靠低成本的数据传输 TCP和UDP协议都属于这一层
网络层
网络层主要对主机和网络之间的交互进行定义 它又被
称
为通信子网层 定义了在网络中传输的基本数据单元以
及
目的寻址和选路的概念 IP协议属于这一层
数据链接层
数据链接层对下层传来的数据进行打包封装 将上层的
数
据分割成帧 它还完成流量控制和差错处理的工作
物理层
物理层是OSI的最底层 它规定传输媒体本身及与其相关
联的机械和电气接口 这些接口和传输媒体必须保证发
送
和接受信号的一致性
TCP/IP协议
TCP/IP协议是一组在网络中提供可靠数据传输和无连接
数据服务的协议 其中提供可据传输的协议称为传输控
制
协议TCP 而提供无连接数据包服务的协议叫做网际协议
IP
TCP/IP协议的体系结构包含五层
硬件层
网络接口层
网络层
传输层
应用层
应用层
应用层包括网络应用程序和网络进程 是与用户交互的
界
面 它为用户提供所需要的各种服务 包括远程登录 文
件
传输和电子邮件等 它的作用相当于OSI 中的应用层及
表
示层和会话层
传输层
相当于OSI 中的传输层 它为应用程序提供通信服务 这
种通信又叫端对端通信 它有三个主要协议：
传输控制协议（TCP）
用户数据包协议（UDP）
互联网控制消息协议 ICMP）
TCP 协议以建立连接高可靠性的消息传输为目的它负责
把大量的用户数据按一定的长度组成多个数据包进行发
送并在接收到数据包之后按分解顺序重组和恢复用户数
据 它是一种面向连接的可靠的双向通信的数据流
UDP 协议提供无连接数据包传输服务 它把用户数据分
解
为多个数据包后发送给接收方 它具有执行代码小以及
系
统开销小和处理速度快等优点
ICMP协议主要用于端主机和网关以及互联网管理中心等
地消息通信以达到控制管理网络运行的目的ICMP协议能
发送出错消息给发送数据包的端主机 还有限制流量的
功
能
网络层
相当于OSI的网络层 使用的协议是IP协议 它是用来处
理
机器之间的通信问题的它接收传输层请求 传输某个具
有
目的地址信息的分组 该层把分组封装到IP数据包中 填
入数据包的头部包头）使用路由算法来选择是直接把数
据包发送到目标主机还是发给路由器 然后把数据包交
给
下面的网络接口层中的对应网络接口模块
网络接口层
相当于 OSI 中的数据链接层和物理层 它负责接收 IP
数据包和把数据包通过选定的网络发送出去
套接口编程基础
学习网络编程无论使用哪种语言 哪种操作系统 不可避
免地要遇到socket这个名词 它就是所说的套接口
套接口也就是网络进程的ID 网络通信归根到底就是进
程
间的通信
在网络中每一个节点都有一个网络地址 也就是IP地址
两个进程通信时 首先要确定各自所在的网络节点的网
络
地址 但是网络地址只能确定进程所在的计算机 由于一
台计算机上可能同时有多个网络进程 所以仅凭网络地
址
还不能确定到底是网络中的哪个进程 因此套接口中还
需
要其他的信息 也就是端口号(port) 在一台计算机中一
个端口号一次只能分配给一个进程 在一台计算机中 端
口号和进程之间是一一对应的关系 所以使用端口号
和网络地址的组合就能唯一地确定整个网络中的一个网
络进程
把网络应用程序中所用到的网络地址和端口号信息放在
一个结构体中 就是套接口地址结构 套接口函数都需要
一个指向套接口地址结构的指针作为参数 来传递地址
信
息
套接口根据所使用的协议的不同可以分为很多类主要介
绍两种 TCP套接口(流式套接口) UDP套接口(数据包套
接口 无连接套接口)
TCP是一种面向连接的可靠的双向通信的数据流 它使用
的是三段式握手方式(重传 肯定 确认)传输数据 接收
端
在接收数据之后要发出一个肯定确认 发送端必须接到
接
收端的肯定信号 否则就要将数据重发 而且它还保证数
据的顺序 它有自己的错误控制机制所以是无错误传递
UDP提供读数据的直接访问权 传输时无连接不执行端对
端的可靠性检查 没有验证机制 因此是一种不太可靠的
协议 但是它的开销非常低
当传输可靠性要求不是特别高的时候就可以使用UDP协
议
但是使用UD 套接口时最好在应用程序中有一定的弥补
措
施以确认数据是否正确传输
Linux中套接口的数据结构
#include<sys/socket.h>
struct sockaddr
{
unit8_t sa_len;
sa_family_t sa_family；
char sa_data[14];
}
字节排序函数
计算机在内存中的数据存储方式有两种：一种是小端字
节序 另一种是大端字节序
网络字节序使用的是大端字节序
假如某个给定系统所采用的字节序为主机字节序 它可
能
是小端字节序 也可能是大端字节序 在网络协议中处理
多字节数据时采用的都是网络字节序 而不是主机字节
序
需要把主机字节序和网络字节序相对应 就要用到提供
主
机字节序和网络字节序之间相互转换功能的函数
#include <netinet/in.h>
uint16_t htons(uint16_t hostvalue)
uint32_t htonl(uint32_t hostvalue)
返回的是网络字节序
#include <netinet/in.h>
uint16_t ntohs(uint16_t netvalue)
uint32_t ntohl(uint32_t netvalue)
返回的是主机字节序
h 代表host
n 代表network
s 代表short
l 代表long
使用htons和ntohs转换端口号
使用htonl和ntohl 转换IP地址
htonl()把32位值从主机字节序转换成网络字节序
htons()把16位值从主机字节序转换成网络字节序
ntohl()把32位值从网络字节序转换成主机字节序
ntohs()把16位值从网络字节序转换成主机字节序
字节操纵函数
#include <strings.h>
void bzero(void *dest,size_t nbytes)
bzero 函数将指定的起始地址设置为0
地址转换函数
TCP/IP网络上使用地址即使用以“.”隔开的四个十进制
的
数表示 但是在套接口地址中则是使用32位的网络字节
序
的二进制数值 要实现两者之间的转换 就要用到以下三
个函数
in_addr_t inet_addr(const char *straddr)
成功时返回32位二进制的网络字节序地址
出错返回INADDR_NONE
int inet_aton(const char *straddr,struct in_addr
*addrp)
返回1表示转换成功
返回0则是转换不成功
char *inet_ntoa(struct in_addr inaddr)
成功返回地址
转换失败返回NULL
inet_aton是将地址转换成网络字节序的32位二进制值
输入的数放在参数straddr中
返回结果的整数放在参数addrp中
inet_ntoa的功能正好相反它将32位二进制值地址转换
成
地址
如果有struct_sockaddr_in类型的变量sin想将IP地址
162.105.12.145存储到其中可以使用函数inet_addr()
sin.sin_addr.s_addr＝inet_addr(“162.105.12.145”)
函数inet_addr（）返回的地址已经是按照网络字节序
的
32位二进制地址
又如有一个数据结构struct in_addr要按照ASCII格式
打
印可以使用函数inet_ntoa()
printf(“%s”,inet_ntoa(sin.sin_addr))
连接函数
在编写客户和服务器程序时当分配端口后要建立连接这
一过程可能用到的函数如下
创建套接口函数socket 它的功能是生成一个套接口描
述
字也称为套接字
#include <sys/socket.h>
int socket(int family,int type,int protocol)
成功返回值为非负描述字
失败返回负值
参数family指明协议族
AF_LOCAL UNIX协议族
AF_ROUTE 路由套接口
AF_INET IPv4协议
AF_INET6 IPv6协议
AF_KEY 密钥套接口
参数type指明字节流类型
SOCK_STREAM TCP套接口
SOCK_DGRAM UDP套接口
SOCK_PACKET 支持数据链路访问
SOCK_RAM 原始套接口
而参数protocol一般为0
绑定套接口函数bind 是为套接口分配一个本地协议地
址
也就是本地IP地址与本地套接口的组合 调用函数bind
可以指定一个端口号 一个IP地址 或者
两者都不指定
#include <sys/socket.h>
int bind(int sockfd,const struct sockaddr
*myaddr,socklen_t addrlen)
参数sockfd为套接字
参数 myaddr是一个指向特定协议地址结构的指针
addrlen是地址结构的长度
套接口中设定port为0内核指定端口号
设置sin_addr为INADDR_ANY内核指定IP地址
struct sockaddr_in serveraddr
serveraddr.port=0
serveraddr.sin_addr.s_addr=htonl(INADDR_ANY)
当IP地址使用统配地址INADDR_ANY 如果端口号设置为0
则表示内核选择地址和端口
如果端口号非零 则为内核选择地址进程指定端口
当IP地址指定为本地IP地址时 如果端口号设置为0则表
示进程选择地址 内核指定端口
如果端口号设置为非零则表示进程选择地址和端口
若是不指定IP地址 将缺省为统配地址INADDR_ANY其值
为零
若是不指定端口则端口号缺省为0
成功返回值为0
失败则返回-1
如果希望使客户端和服务器连接就要调用connect()函
数
#include <sys/types.h>
#include <sys/socket.h>
int connect(int sockfd,const struct sockaddr
*serv_addr,int addrlen)
参数sockfd是系统调用socket()返回的套接口描述
serv_addr是目的端口和IP地址的套接口
参数addrlen是目的套接口的长度
连接成功则返回0
错误则返回-1
服务器不知道自己要与谁连接 因此它也不会主动地要
求
与某个进程连接 它只是监听是否有其他客户进程要与
它
连接 然后响应这个连接请求并对它作出处理
#include <sys/socket.h>
int listen(int sockfd,int backlog)
参数sockfd为套接字
参数backlog则规定内核为此套接口排队的最大选择个
数
成功返回为0
失败则返回-1
函数accept的功能是从已完成连接队列头返回下一个已
完成连接，如果已完成连接队列
为空时，则进程睡眠，这个函数由服务器调用。定义如
下。
#include <sys/socket.h>
int accept(int sockfd,struct sockaddr
*cliaddr,socklen_t *addrlen)
参数cliaddr返回客户进程的协议地址
参数addrlen为返回客户进程的协议长度
参数sockfd称为监听套接口描述字它由函数 socket生
成
如果不需要客户的协议地址,可将第二个和第三个参数
设
置为空指针
成功返回非负 则返回值用来标识新建立的连接
出错返回-1
accept 的函数返回值称为已连接套接口描述字
它们的区别在于 监听套接口描述字只有一个而且一直
存
在 每一个连接都有一个已连接套接口描述字当连接断
开
时就关闭该描述字
send()和recv()这两个函数用于面向连接的socket上进
行数据传输
size_t send(int sock_fd, const void *msg, int
len, int flags)
sock_fd是你想用来传输数据的socket描述符
msg是一个指向要发送数据的指针
len是以字节为单位的数据的长度
flags一般情况下置为0
成功返回实际反送的数据的字节数
失败返回-1
int recv(int sock_fd,void *buf,int len,unsigned
int flags)
sock_fd是接受数据的socket描述符
buf 是存放接收数据的缓冲区
len是缓冲的长度
flags也被置为0
成功返回实际上接收的字节数
返回-1
sendto()和recvfrom()用于在无连接的数据报socket方
式下进行数据传输
由于本地socket并没有与远端机器建立连接，所以在发
送数据时应指明目的地址
int sendto(int sockfd, const void *msg,int
len,unsigned int flags,const struct sockaddr
*to,
int tolen)
to表示目地机的IP地址和端口号信息
而tolen常常被赋值为sizeof(struct sockaddr)
sendto函数也返回实际发送的数据字节长度
错误时返回-1
recvfrom()函数原型为
int recvfrom(int sockfd,void *buf,int
len,unsigned int flags,struct sockaddr *from,int
*fromlen)
from是一个struct sockaddr类型的变量该变量保存源
机
的IP地址及端口号
fromlen常置为sizeof(struct sockaddr)
当recvfrom()返回时fromlen包含实际存入from中的数
据
字节数
Recvfrom()函数返回接收到的字节数
错误时返回-1
一个服务器进程中系统调用的顺序通常如下:
socket()
bind()
listen()
accept()
TCP协议建立连接时使用三段握手 TWH方式：
客户端先用connect()向服务器发出一个要求连接的信
号
SYN1
服务器进程接收到这个信号后发回应答信号 ack1同时
这
也是一个要求回答的信号SYN2
客户端收到信号ack1和SYN2后 再次应答ack2
服务器收到应答信号ack2一次连接才算建立完成
函数close()的功能是关闭套接口
#include <unistd.h>
int close(int sockfd)
参数sockfd 是关闭的套接口描述字
成功则返回0
否则返回-1
当对一个套接口调用close()时 关闭该套接口描述字
并
停止连接 以后这个套接口不能再使用也不能再执行任
何读写操作 但关闭时已经排队准备发送的数据仍会被
发出
如果想在任何关闭套接口上有多一点控制 还可以使用
函
数shutdown() 允许将某一方向的通信或者双向通信关
闭
int shutdown(int sockfd,int how)
参数sockfd是想要关闭的套接口文件描述字
参数how的值是下面中的一个
0：不允许再接收
1：不允许再发送
2：不允许再接收和发送
shutdown()不是关闭套接口 而是关闭该套接口的通信
功
能 该套接口仍是打开的
IP地址转换
用gethostbyname()函数来实现名字地址到数字地址之
间
的转换工作
#include <netdb.h>
struct hostent *gethostbyname(const char
*hostname)
成功返回一个指向结构hostent 的指针
调用失败返回一个空指针
Hostent 的数据结构
Struct hostent
{
char *h_name
char **h_aliases
int h_addrtype
int h_length
char **h_addr_list
}
#define h_addr_list[0]
h_name主机的规范名字
h_aliases主机的别名列表指向一个二维数组
h_addrtype返回主机的地址类型
h_length返回地址长度
h_addr_list主机的一组网络地址列表
h_addr h_addr_list[0]主机的第一个网络地址
socket 系统调用都将错误
#include<netdb.h>
HOST_NOT_FOUND找不到主机
TRY_AGAIN重试
NO_RECOVERY不可修复性错误
NO_DATA指定的名字有效但没有记录
gethostbyaddr()将一个数字地址转换成一个名字地址
或
者主机名
#include <netdb.h>
struct hostent *gethostbyaddr(const char
*addr,size_t len,int family)
addr是一个指向含有地址结构(in_addr或in6_addr)的
指
针
len是此结构的大小 如果是IPv4为4 而IPv6则为16
参数family为协议地址族
成功返回一个指向结构hostent 的指针
调用失败返回一个空指针
得到当前主机的名字的函数
函数uname()的作用是返回当前主机的名字经常把它和
函
数gethostbyname一起使用来确定本地主机的IP地址
#include <sys/utsname.h>
int uname(struct utsname *name)
成功返回一个非负值
失败返回-1
结构utsname 的定义形式如下。
#define UTS_NAMESIZE 16
#define UTS_NODESIZE 256
struct utsname
{
char sysname[UTS_NAMESIZE]
char nodename[UTS_NODESIZE]
char release[UTS_NAMESIZE]
char version[UTS_NAMESIZE]
char machine[UTS_NAMESIZE]
}
TCP套接口编程例子：
client：
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include <unp.h>
#define MAXSIZE 80
void str_cli(FILE *,int)
int main(int argc,char **argv)
{
int sockfd,ret,len;
struct sockaddr_in ser_addr;
char *myname;
struct hostent *sh;
struct in_addr **addrs;
if(argc!=2){
printf(“parameters not match.”);
exit(0);
}
/*判断参数是否匹配 */
if((sh=gethostbyname(argv[1]))==NULL)
{
printf(“error when gethostbyname”);
exit(0);
}
/* 根据服务器名获得详细信息*/
addrs=(struct in_addr **)sh->h_addr_list;
for(;*addrs!=NULL;addrs++){
sockfd=socket(AF_INET,SOCK_STREAM,0);
if(sockfd<0)
{
printf(“error in socket”);
exit(1);
}
/* 创建套接口*/
ser_addr.sin_family=AF_INET;
ser_addr.sin_port=sh->h_port;
memcpy(ser_addr,sin_addr,*addrs,sizeof(struct
in_addr));
bzero(&(ser_addr.sin_zero),8);
ret=connect(sockfd,(SA)&ser_addr,sizeof(struct
sockaddr));
if(ret==0)
break;
/* 连接成功则跳出循环*/
else
{
printf(“error connecting”);
close(sockfd);
}
}
/*尝试与服务器的各个地址连接，知道连接上其中一个
为止 */
if(*addrs==NULL)
{
printf(“can’t get connected with server”);
exit(0);
}
/*连接不成功则报错并退出 */
str_cli(stdin,sockfd);
/*数据传输操作 */
close(sockfd);
exit(0);
}
void str_cli(FILE *fp,int sockfd)
{
char sends[MAXSIZE],recvs[MAXSIZE];
int n=0;
while(fgets(sends,MAXSIZE,fp)!=NULL)
{
send(sockfd,sends,strlen(sends),0);
if((n=recv(sockfd,recvs,MAXSIZE,0))==0){
printf(“error receiving data”);
exit(1);
}
recvs[n]=0;
fputs(recvs,stdout);
}
}
server：
/*服务器端代码*/
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <unp.h>
#define MAXSIZE=80
#define MYPORT 3490
#define BACKLOG 10
#define BUFSIZE 100
main ( )
{
int sockfd,new_fd,numbytes,ret;
struct sockaddr_in my_addr;
struct sockaddr_in their_addr;
int sin_size;
char *buf;
sockfd=socket(AF_INET,SOCK_STREAM,0);
if(sockfd<0){
printf(“error in socket”);
exit(1);
}
/*创建监听套接口 */
my_addr.sin_family=AF_INET;
my_addr.sin_port=htons(MYPORT);
my_addr.sin_addr.s_addr=htonl(INADDR_ANY);
bzero(&(my_addr.sin_zero),8);
ret=bind(sockfd,(struct sockaddr
*)&my_addr,sizeof(struct sockaddr));
if(ret<0)
{
printf(“error in binding”);
exit(1);
}
/*绑定监听套接口 */
ret=listen (sockfd,BACKLOG);
if(ret<0)
{
printf(“error in listening”);
exit(1);
}
/* 监听连接请求*/
while(true)
{
sin_size=sizeof(struct sockaddr_in);
con_fd=accept(sockfd,(SA*)&their_addr,&
s
in_size);
if(con_fd<0)
{
printf(“error in accept”);
exit(1);
}
/*创建新的连接 */
if((pid=fork())==0)
{
close(sockfd);
str_ser(con_fd);
/*接收并处理数据 */
close(con_fd);
exit(0)；
}
/*子进程代码 */
else
close(con_fd);
/*父进程代码 */
}
close(sockfd);
exit(0);
}
void str_ser(int sockfd)
{
char recvs[MAXSIZE];
int n=0;
while(true)
{
if((n=recv(sockfd,recvs,MAXSIZE,0))==0)
return;
/*对方关连接，返回主程序 */
send(sockfd,recvs,n,0);
}
}
sockaddr_in sockaddr in_addr
struct sockaddr {
unsigned short sa_family;
char sa_data[14];
};
struct sockaddr_in {
short int sin_family;
unsigned short int sin_port;
struct in_addr sin_addr; //
unsigned char sin_zero[8];
};
struct in_addr {
unsigned long s_addr;
};
使用socket, listen, bind等函数填值的时候使用
sockaddr_in结构，而作为函数的参数传入的时候转换
成
sockaddr
UDP:
server:socket-->bing-->sendto -->recvfrom
client:socket-->sendto -->recvfrom
LINUX网络编程(fork、select）
1.fork:每accept到一个socket之后，开启一个子进程
来负责收发处理工作。
int main(int argc, char*argv[])
{
int fdServer = -1;
int fdClient = -1;
int nStatus = -1;
pid_t pid = 0;
int nSockAddrLen = sizeof(struct sockaddr_in);
struct sockaddr_in addrServer;
struct sockaddr_in addrSocket;
bzero(&addrServer, sizeof(struct sockaddr_in));
bzero(&addrSocket, sizeof(struct sockaddr_in));
if(-1 == (fdServer = socket(AF_INET,
SOCK_STREAM, 0))){
perror(strerror(errno));
exit(-1);
}
int nReuseAddr = 1;
SetOption(fdServer, SOL_SOCKET, SO_REUSEADDR,
&nReuseAddr, sizeof(int));
addrServer.sin_family = AF_INET;
addrServer.sin_port = htons(SERVER_PORT);
addrServer.sin_addr.s_addr = INADDR_ANY;
if (-1 == bind(fdServer, (struct sockaddr
*)&addrServer, sizeof(struct sockaddr)))
{
perror(strerror(errno));
exit(-1);
}
if (-1 == listen(fdServer, 128))
{
perror(strerror(errno));
exit(-1);
}
while (true)
{
if ((fdClient = accept(fdServer, (struct
sockaddr *)&addrSocket,
(socklen_t*)&nSockAddrLen)) < 0)
{
perror(strerror(errno));
exit(-1);
}
printf("client address:%s\t port:%d\r\n",
inet_ntoa(addrSocket.sin_addr),
ntohs(addrSocket.sin_port));
if ((pid = fork()) < 0)
{
perror(strerror(errno));
exit(-1);
}
else if (0 == pid) /* clild */
{
while (true)
{
try
{
string strValue;
if(0 < SocketRead(fdClient, strValue))
{
SocketWrite(fdClient, strValue.c_str(),
strValue.length());
}
else
{
close(fdClient);
}
// 要有延时，不然CPU使用率很高
usleep(10);
}
catch(const SocketException& e)
{
cerr << e.what() << endl;
close(fdClient);
break;
}
}
}
else /* parent */
{
close(fdClient);
}
}
return 0;
}
1.select:监控文件描述符事件。
int main(int argc, char*argv[])
{
int fdServer = -1;
int fdClient = -1;
int fdMax = -1;
int nRead = 0;
char buf[NUM_BUFFER];
int nSockAddrLen = sizeof(struct sockaddr_in);
struct sockaddr_in addrServer;
struct sockaddr_in addrSocket;
bzero(&addrServer, sizeof(struct sockaddr_in));
bzero(&addrSocket, sizeof(struct sockaddr_in));
int fdBuf[NUM_MON];
memset(fdBuf, -1, sizeof(fdBuf));
// 被监控的描述符集合
fd_set fsMon;
// 事件的描述符集合
fd_set fsRead;
FD_ZERO(&fsMon);
FD_ZERO(&fsRead);
if(-1 == (fdServer = socket(AF_INET,
SOCK_STREAM, 0)))
{
perror(strerror(errno));
exit(-1);
}
int nReuseAddr = 1;
SetOption(fdServer, SOL_SOCKET, SO_REUSEADDR,
&nReuseAddr, sizeof(int));
addrServer.sin_family = AF_INET;
addrServer.sin_port = htons(SERVER_PORT);
addrServer.sin_addr.s_addr = INADDR_ANY;
if (-1 == bind(fdServer, (struct sockaddr
*)&addrServer, sizeof(struct sockaddr)))
{
perror(strerror(errno));
exit(-1);
}
if (-1 == listen(fdServer, 128))
{
perror(strerror(errno));
exit(-1);
}
// 服务端是被监控对象之一
FD_SET(fdServer, &fsMon);
fdMax = fdServer;
while (true)
{
fsRead = fsMon;
switch(select(fdMax + 1, &fsRead, NULL, NULL,
NULL))
{
case -1:
perror(strerror(errno));
exit(-1);
case 0:
perror("timeout");
continue;
default:
break;
}
// 是否为fdServer的可读事件
if (FD_ISSET(fdServer, &fsRead))
{
if (0 > (fdClient = accept(fdServer, (struct
sockaddr *)&addrSocket,
(socklen_t*)&nSockAddrLen)))
{
perror(strerror(errno));
exit(-1);
}
// socket加入fdBuf, fdBuf中是保存的所有
socket的集合
for (int i = 0; i < NUM_MON; ++i)
{
if(-1 == fdBuf[i])
{
fdBuf[i] = fdClient;
break;
}
}
// 把socket加入监控集合
FD_SET(fdClient, &fsMon) ;
fdMax = max(fdMax, fdClient);
continue;
}
for (int i = 0; i < NUM_MON; ++i)
{
if (-1 == fdBuf[i]) continue;
if (!FD_ISSET(fdBuf[i], &fsMon))
continue;
// 缓冲区中，是否有数据可读
ioctl(fdBuf[i], FIONREAD, &nRead);
if (0 >= nRead)
{
// 非可读
FD_CLR(fdBuf[i], &fsMon);
continue;
}
read(fdBuf[i], buf, nRead) ;
write(fdBuf[i], buf, nRead) ;
}
}
}
定义函数
int select(int n,fd_set * readfds,fd_set *
writefds,fd_set * exceptfds,struct timeval *
timeout)
函数说明
select()用来等待文件描述词状态的改变。
参数n代表最大的文件描述词加1，参数readfds、writefds 和
exceptfds 称为描述词组，是用来回传该描述词的读，
写或例外的状况。底下的宏提供了处理这三种描述词组
的方式:
FD_CLR(inr fd,fd_set* set)；用来清除描述词组set
中相关fd 的位
FD_ISSET(int fd,fd_set *set)；用来测试描述词组
set中相关fd 的位是否为真
FD_SET（int fd,fd_set*set）；用来设置描述词组set
中相关fd的位
FD_ZERO（fd_set *set）； 用来清除描述词组set的全
部位参数
timeout为结构timeval，用来设置select()的等待时间
，其结构定义如下
struct timeval
{
time_t tv_sec;
time_t tv_usec;
};
返回值
如果参数timeout设为NULL则表示select（）没有
timeout
范例
FD_ZERO(&readset)
FD_SET(fd,&readset)
select(fd+1,&readset,NULL,NULL,NULL)
if(FD_ISSET(fd,readset){……}
＃include <sys/time.h>
＃include <stdio.h>
＃include <sys/types.h>
＃include <sys/stat.h>
＃include <fcntl.h>
＃include <assert.h>
int main ()
{
int keyboard;
int ret,i;
char c;
fd_set readfd;
struct timeval timeout;
keyboard = open("/dev/tty",O_RDONLY |
O_NONBLOCK);
assert(keyboard>0);
while(1)
{
timeout.tv_sec=1;
timeout.tv_usec=0;
FD_ZERO(&readfd);
FD_SET(keyboard,&readfd);
ret=select(keyboard+1,&readfd,NULL,NULL,&timeout
);
if(FD_ISSET(keyboard,&readfd))
{
i=read(keyboard,&c,1);
if('\n'==c)
continue;
printf("hehethe input is %c\n",c);
if ('q'==c)
break;
}
}
}
利用socket套接字和select实现异步聊天
就是通讯任意一方可以任意发送消息，有消息来到时会
收到系统提示去接收消息。
先建立好套接字，然后绑定，转化为监听套接字，接受
连接。
这里要用到select函数。使用步骤如下：
1、设置一个集合变量，用来存放所有要判断的句柄
（file descriptors：即我们建立的每个socket、用
open打开的每个文件等）
2、把需要判断的句柄加入到集合里
3、设置判断时间
4、开始等待，即select
5、如果在设定的时间内有任何句柄状态变化了就马上
返回，并把句柄设置到集合里
服务端代码:
#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>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/time.h>
#include <sys/types.h>
#define MAXBUF 1024
int main(int argc, char **argv)
{
int sockfd, new_fd;
socklen_t len;
struct sockaddr_in my_addr, their_addr;
unsigned int myport, lisnum;
char buf[MAXBUF + 1];
fd_set rfds;
struct timeval tv;
int retval, maxfd = -1;
if (argv[1])
myport = atoi(argv[1]);
else
myport = 7838;
if (argv[2])
lisnum = atoi(argv[2]);
else
lisnum = 2;
if ((sockfd = socket(AF_INET, SOCK_STREAM,
0)) == -1)
{
perror("socket");
exit(1);
}
bzero(&my_addr, sizeof(my_addr));
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(myport);
if (argv[3])
my_addr.sin_addr.s_addr=
inet_addr(argv[3]);
else
my_addr.sin_addr.s_addr = INADDR_ANY;
if (bind(sockfd, (struct sockaddr *)
&my_addr, sizeof(struct sockaddr))
== -1)
{
perror("bind");
exit(1);
}
if (listen(sockfd, lisnum) == -1)
{
perror("listen");
exit(1);
}
while (1)
{
printf
("\n----等待新的连接到来开始新一轮聊
天……\n");
len = sizeof(struct sockaddr);
if ((new_fd =
accept(sockfd, (struct sockaddr *)
&their_addr, &len)) == -1)
{
perror("accept");
exit(errno);
}
else
printf("server: got connection from
%s, port %d, socket %d\n",
inet_ntoa(their_addr.sin_addr
),
ntohs(their_addr.sin_port),
new_fd);
/* 开始处理每个新连接上的数据收发 */
printf
("\n准备就绪，可以开始聊天了……直接输
入消息回车即可发信息给对方\n");
while (1)
{
/* 把集合清空 */
FD_ZERO(&rfds);
/* 把标准输入句柄0加入到集合中 */
FD_SET(0, &rfds);
maxfd = 0;
/* 把当前连接句柄new_fd加入到集合中
*/
FD_SET(new_fd, &rfds);
if (new_fd > maxfd)
maxfd = new_fd;
/* 设置最大等待时间 */
tv.tv_sec = 1;
tv.tv_usec = 0;
/* 开始等待 */
retval = select(maxfd + 1, &rfds,
NULL, NULL, &tv);
if (retval == -1)
{
printf("将退出，select出错！
%s", strerror(errno));
break;
}
else if (retval == 0)
{
continue;
}
else
{
if (FD_ISSET(0, &rfds))
{
/* 用户按键了，则读取用户输
入的内容发送出去 */
bzero(buf, MAXBUF + 1);
fgets(buf, MAXBUF, stdin);
if (!strncasecmp(buf,"quit",
4))
{
printf("自己请求终止聊天
！\n");
break;
}
len = send(new_fd, buf,
strlen(buf) - 1, 0);
if (len > 0)
printf
("消息:%s\t发送成功
，共发送了%d个字节
！\n",
buf, len);
else {
printf
("消息'%s'发送失败！
错误代码是%d，错误信
息是'%s'\n",
buf, errno,
strerror(errno));
break;
}
}
if (FD_ISSET(new_fd, &rfds))
{
/* 当前连接的socket上有消息
到来则接收对方发过来的消息并
显示 */
bzero(buf, MAXBUF + 1);
/* 接收客户端的消息 */
len = recv(new_fd, buf,
MAXBUF, 0);
if (len > 0)
printf
("接收消息成功
:'%s'，共%d个字节的
数据\n",
buf, len);
else {
if (len < 0)
printf
("消息接收失败！
错误代码是%d，错
误信息是'%s'\n",
errno,
strerror(errno)
);
else
printf("对方退出了，
聊天终止\n");
break;
}
}
}
}
close(new_fd);
/* 处理每个新连接上的数据收发结束 */
printf("还要和其它连接聊天吗？(no->退出
)");
fflush(stdout);
bzero(buf, MAXBUF + 1);
fgets(buf, MAXBUF, stdin);
if (!strncasecmp(buf, "no", 2))
{
printf("终止聊天！\n");
break;
}
}
close(sockfd);
return 0;
}
客服端：
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/socket.h>
#include <resolv.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/types.h>
#define MAXBUF 1024
int main(int argc, char **argv)
{
int sockfd, len;
struct sockaddr_in dest;
char buffer[MAXBUF + 1];
fd_set rfds;
struct timeval tv;
int retval, maxfd = -1;
if (argc != 3)
{
printf("参数格式错误！正确用法如下：\n\t\t%s
IP地址 端口\n\t比如:\t%s 127.0.0.1 80\n此程
序用来从某个 IP 地址的服务器某个端口接收最多
MAXBUF 个字节的消息",
argv[0], argv[0]);
exit(0);
}
/* 创建一个 socket 用于 tcp 通信 */
if ((sockfd = socket(AF_INET, SOCK_STREAM,
0)) < 0)
{
perror("Socket");
exit(errno);
}
bzero(&dest, sizeof(dest));
dest.sin_family = AF_INET;
dest.sin_port = htons(atoi(argv[2]));
if (inet_aton(argv[1], (struct in_addr *)
&dest.sin_addr.s_addr) == 0)
{
perror(argv[1]);
exit(errno);
}
if (connect(sockfd, (struct sockaddr *)
&dest, sizeof(dest)) != 0)
{
perror("Connect ");
exit(errno);
}
printf
("\n准备就绪，可以开始聊天了……直接输入消
息回车即可发信息给对方\n");
while (1)
{
/* 把集合清空 */
FD_ZERO(&rfds);
/* 把标准输入句柄0加入到集合中 */
FD_SET(0, &rfds);
maxfd = 0;
/* 把当前连接句柄sockfd加入到集合中 */
FD_SET(sockfd, &rfds);
if (sockfd > maxfd)
maxfd = sockfd;
/* 设置最大等待时间 */
tv.tv_sec = 1;
tv.tv_usec = 0;
/* 开始等待 */
retval = select(maxfd + 1, &rfds,
NULL,NULL, &tv);
if (retval == -1)
{
printf("将退出，select出错！ %s",
strerror(errno));
break;
}
else if (retval == 0)
{
/* printf
("没有任何消息到来，用户也没有按
键，继续等待……\n"); */
continue;
}
else
{
if (FD_ISSET(sockfd, &rfds))
{
/* 连接的socket上有消息到来则接
收对方发过来的消息并显示 */
bzero(buffer, MAXBUF + 1);
/* 接收对方发过来的消息，最多接
收 MAXBUF 个字节 */
len = recv(sockfd, buffer,
MAXBUF, 0);
if (len > 0)
printf
("接收消息成功:'%s'，共
%d个字节的数据\n",
buffer, len);
else
{
if (len < 0)
printf
("消息接收失败！错误
代码是%d，错误信息
是'%s'\n",
errno,
strerror(errno));
else
printf("对方退出了，聊天
终止！\n");
break;
}
}
if (FD_ISSET(0, &rfds))
{
/* 用户按键了，则读取用户输入的
内容发送出去 */
bzero(buffer, MAXBUF + 1);
fgets(buffer, MAXBUF, stdin);
if (!strncasecmp(buffer, "quit",
4))
{
printf("自己请求终止聊天
！\n");
break;
}
/* 发消息给服务器 */
len = send(sockfd, buffer,
strlen(buffer) - 1, 0);
if (len < 0)
{
printf
("消息'%s'发送失败！错误代
码是%d，错误信息是'%s'\n",
buffer, errno,
strerror(errno));
break;
}
else
printf
("消息：%s\t发送成功，共
发送了%d个字节！\n",
buffer, len);
}
}
}
/* 关闭连接 */
close(sockfd);
return 0;
}
fork：
服务：
#include<stdio.h>
#include<strings.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#define PORT 1234
#define BACKLOG 1
#define MAXDATASIZE 100
void main()
{
int listenfd, connectfd;
struct sockaddr_in server;
struct sockaddr_in client;
socklen_t addrlen;
char buf[MAXDATASIZE];
pid_t pid;
if((listenfd = socket(AF_INET, SOCK_STREAM, 0))
== -1) {
perror("socket() error.");
exit(1);
}
int opt = SO_REUSEADDR;
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR,
&opt, sizeof(opt));
bzero(&server, sizeof(server));
server.sin_family = AF_INET;
server.sin_port = htons(PORT);
server.sin_addr.s_addr = htonl(INADDR_ANY);
if(bind(listenfd, (struct sockaddr *)&server,
sizeof(server)) == -1)
{
perror("bind() error.");
exit(1);
}
if(listen(listenfd, BACKLOG) == -1)
{
perror("listen() error.");
exit(1);
}
addrlen = sizeof(client);
while(1)
{
if((connectfd = accept(listenfd, (struct
sockaddr *)&client, &addrlen )) == -1)
{
perror("accept() error.");
exit(1);
}
if((pid = fork()) >0)
{
while(1)
{
close(listenfd);
recv(connectfd, buf, MAXDATASIZE,0);
printf("the client says: %s\n",buf);
}
}
else if(pid == 0)
{
while(1)
{
close(listenfd);
fgets(buf, MAXDATASIZE, stdin);
send(connectfd, buf, MAXDATASIZE, 0);
}
}
else
return 1;
}
close(connectfd);
close(listenfd);
}
客户：
#include<stdio.h>
#include<unistd.h>
#include<strings.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<netdb.h>
#define PORT 1234 /*listen port*/
#define MAXDATASIZE 100
int main ( int argc, char *argv[])
{
int sockfd, num;
pid_t pid;
char buf[MAXDATASIZE];
struct hostent *he;
struct sockaddr_in server;
if(argc!=2)
{
printf("usage %s<ip address>\n",argv[0]);
exit(1);
}
if((he = gethostbyname(argv[1])) == NULL)
{
printf("gethostbyname error\n");
exit(1);
}
if((sockfd = socket(AF_INET, SOCK_STREAM, 0))
== -1)
{
printf("socket() error \n");
exit(1);
}
bzero(&server, sizeof(server));
server.sin_family = AF_INET;
server.sin_port = htons(PORT);
server.sin_addr = *((struct in_addr
*)he->h_addr);
if(connect(sockfd, (struct sockaddr *)&server,
sizeof(server)) == -1)
{
printf("connetc() error\n");
exit(1);
}
if((pid = fork()) >0)
{
while(1)
{
fgets(buf, MAXDATASIZE, stdin);
send(sockfd, buf, MAXDATASIZE, 0);
}
}
else if(pid == 0)
{ while(1)
{
recv(sockfd, buf, MAXDATASIZE, 0);
printf("server message: %s",buf);
}
}
else
return 1;
close(sockfd);
}