基本知识：
1.协议
【作用】：使交换信息的两个部分之间相互理解的一组规则、
约定和数据结构的集合。
即：为了使不同版本的计算机能相互沟通而存在
在现在的网络应用中使用最广泛的协议是TCP/IP协议
ISO
OSI【【七层协议】】模型
【1】.应用层：为应用(程序提供服务)并(规定)应用程序中(通信的相关细节),
如：ftp,tftp,smtp,ssh,telnet...
【2】.表示层：主要负责数据格式的转换(设备固有格式 <==> 网络格式)
【3】.会话层：主要建立和断开通信连接
【4】.传输层：起着可靠传输的作用
【5】.网络层：将数据传输到目标地址，主要负责寻址和路由选择
【6】.数据链路层：负责物理层面上的互连的节点之间的通信传输
【7】.物理层：负责0、1比特流与电压的高低、光的闪灭之间的互换
根据七层协议模型， tcp/IP协议可分为四层
【1】.应用层：
【2】.传输层： TCP UDP
【3】.网络层： IPv4 IPv6
【4】.网络接口层
2.常用协议
【1】.TCP协议
传输控制协议，是一种【面向连接】的协议，类似打电话
【2】.UDP协议
用户数据报协议，是一种【无连接】的协议，类似发短信
【3】.IP协议
互联网协议，是上述两种协议的底层协议，当需要【开发
新的通信协议】时，才需要关注
3.IP地址
【作用】：作为通信设备在互联网中的唯一地址标识
【本质】： 1.由32位二进制组成的【整数】(IPv4)
2.由128位二进制组成的【整数】(IPv6)
日常生活中采用点分十进制表示法来描述IP地址，也就是将每个字节的
二进制转为十进制的整数，不同的整数之间用小数点分隔
0x01020304 ==>1.2.3.4
2^32个地址，怎么管理？
将【IP地址分为两部分】：网络地址和主机地址
【网络地址】：属于哪个网络 【可以定位在哪个网吧上网】
【主机地址】：网络中主机的编号 【可以定位在哪台电脑上网】
根据网络地址和主机地址位数的不同分为四类：
A: 0 + 7位的网络号 + 24位主机地址
0.0.0.0 ~ 127.255.255.255
B: 10 + 14位网络号 + 16位主机地址
128.0.0.0 ~ 191.255.255.255
C: 110 + 21位网络号 + 8位主机地址
192.0.0.0 ~ 223.255.255.255
D: 1110 + 28位多(组)播地址
224.0.0.0 ~ 239.255.255.255
E: 备用
查看IP地址的命令
ipconfig
ifconfig
3.子网掩码 【第一种分IP地址的方法】
【作用】：用于划分IP地址中的网络地址和主机地址，
也可以用于判断两个IP是否在同一局域网中
具体分法： 【IP地址】 跟 【子网掩码】 做【与运算】 得到 【网络地址】
【前提是换成二进制】
IP地址 & 子网掩码 = 网络地址
例：
172.30.100.64 IP
& 255.255.255.0 子网掩码
--------------------------------
172.30.100.0 ---网络地址
64---主机地址
例：
IP：166.111.160.1 和 166.111.161.45
子网掩码：255.255.254.0
解析：
166.111.160.1
255.255.254.0 &
---------------
166.111.160 网络号
166.111.161.45
255.255.254.0 &
---------------
166.111.160 网络号
总结：上面两个IP地址在同一个局域网中
【第二种分IP地址的方法】：
斜杠'/'后面的数字N表示前N位为网络号
166.111.160.1 /23
166.111.161.45 /23
23：表示前23位为网络号
4.端口号
【IP地址】 -- 定位到具体的某一台主机/设备 【推断出你在哪个网吧哪台机子上网】
【端口号】 -- 定位到主机/设备上的某一个进程 【推断出你在那台机子玩什么】
本质上就是一个16位的无符号整数 unsigned short，范围是0~65535
其中0-1024之间的端口号被系统使用，建议【从5000开始使用】
【网络编程】中需【要提供】两个信息：【IP地址】+【端口号】
5.字节序(多字节整数)
小端模式：主要指将低位字节数据保存在低位内存地址的系统
大端模式：主要指将低位字节数据保存在高位内存地址的系统
【在准备通信地址和使用通信地址信息时需要注意类型的转换】
----------------------------------------------------------
网络编程【又名socket编程，因为要使用socket函数得到信息载体】
一、网络编程又叫socket编程
【套接字概念】：是一个网络编程的接口，是网络数据传输的软设备。
【套接字作用】：用于网络交互。
【网络编程本质】：编写程序【使两台连网的计算机】相互【交换数据】。
unix/linux系统作为服务器操作系统存在至今，因此，
Linux的网络功能应该是非常全面和强大。
网络编程其实有很成熟的通信模型，并且windows也通用。
二、通信模型(基于TCP的一对一的通信模型)
【1】.一对一服务器：
【等待连接原理】：
1 有人从很远很远的地方尝试调用 connect()来连接你的机器上的某个端口
（当然是你已经在 listen()的）。
2 他的连接将被 listen 加入等待队列等待 accept()函数的调用（加入等待队
列的最多数目由调用 listen()函数的第二个参数 backlog 来决定）。
3 你调用 accept()函数，告诉他你准备连接。
4 accept()函数将返回一个新的套接字描述符，这个描述符就代表了这个连接！
好，这时候你有了【两个套接字描述符】，返回给你的那个就是和远程计算机的连接，
而第一个套接字描述符仍然在你的机器上原来的那个端口上 listen()。
这时候你所得到的那个新的套接字描述符就可以进行 send()操作和recv()操作了。
http://blog.csdn.net/wukui1008/article/details/7669173 【套接字】
【监听套接字】：创建通信载体时得到的返回值;
作用：用来监听一个端口，当有客户端过来时，给他指路
【连接套接字】：等待客户端连接完成后得到的返回值;
作用：作为和客户端(远程计算机)真正联系的【链接】
监听套接字就是个牵线指路的，你实质上是跟它指的那个人说话。
因为你要找的那个人不可能随时等你来，而监听套接字就是专职等你来问，
它回答你要找的人在哪，并唤醒你要找的人，于是通话就建立起来了，
就像现实生活中的接线员一样。
1.创建监听套接字 使用socket()函数
原型：int socket(int domain, int type, int protocol);
即：socket(协议族,通信类型,具体的协议);
功能：
主要用于创建可以实现通信的交流点，也就是socket通信载体(相当于电话机)
得到监听套接字
返回值：
成功：返回新的socket描述符【监听套接字】
失败：返回-1，errno被设置
例如：
int sockfd = socket(AF_INET,SOCK_DGRAM,0);
AF_INET：域/协议族，决定了是【本地通信还是网络通信】
AF_UNIX/AF_LOCAL 用于实现本地通信
AF_INET 用于实现基于IPv4的网络通信
AF_INET6 用于实现基于IPv6的网络通信
SOCK_DGRAM：通信类型，决定了【具体的通信式】
SOCK_STREAM 提供有序的、可靠的、双向的、面向连接的字节流通信方式，默认使用TCP协议
SOCK_DGRAM 提供无序的、不可靠的，非面向连接的数据报通信方式，默认使用UDP协议
0：指定具体的协议，默认为0，使用默认协议
2.准备通信地址【要先清零再赋值】
通信地址数据【类型】：
1】.通用地址结构
struct sockaddr
{
sa_family_t sa_family; //域/协议族
char sa_data[14]; //??????
};
2】.IPv4通信地址结构
struct sockaddr_in
{
sa_family_t sin_family;//协议族，AF_INET
in_port_t sin_port;//16位的端口号
struct in_addr sin_addr;//IP地址
};
struct in_addr
{
in_addr_t s_addr; //16位的端口号
};
例如：(IPv4通信地址结构)
struct sockaddr_in saddr;
memset(&saddr,0,sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_port = htons(atoi(argv[2]));
saddr.sin_addr.s_addr = inet_addr(argv[1]);
【作用】：(以IPv4通信地址结构为例)
saddr.sin_family：决定该地址遵循何种协议
saddr.sin_port：决定该地址的端口 【哪台机子】
saddr.sin_addr.s_addr：决定该地址的IP地址 【哪个网吧】
【IP地址格式转换】：
IP地址从main()函数【输入时是字符串】格式的，
初始化通信地址的时候要用inet_addr()函数转换成结构体类型;
接收【调用】别人的IP地址时，得到的是【结构体类型】的;
若要【输出】，则要用inet_ntoa()函数转换成【字符串】格式;
【端口号格式转换】：
端口号从main()函数【输入时是字符串】格式的，
初始化通信地址的时候要先用atoi()函数转换成int型;
是主机字节顺序，要再用 htons()函数转换成网络字节顺序(大端模式);
接收【调用】别人的IP地址时，得到的是【网络字节顺序】;
若要【输出】，则要用ntohs()函数转换成【主机字节顺序】；
端口格式转换相关【函数详解】：
#include <arpa/inet.h>
uint32_t htonl(uint32_t hostlong);
uint16_t htons(uint16_t hostshort);
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);
h:host 本地格式
n:network 网络格式(大端模式)
s:short 2字节整数
l:long 4字节整数
功能：把本地格式转成网络格式，或者反过来。
IP地址格式转换相关函数：
in_addr_t inet_addr(const char *cp);
功能：将字符串形式的IP地址转为整数类型
char *inet_ntoa(struct in_addr in);
功能：将结构类型的IP地址转为字符串形式
/*************服务器**************/
3.绑定(通信地址与监听套接字) bind()函数
原型：int bind(int sockfd, const struct sockaddr *saddr,
socklen_t addrlen);
即：bind(监听套接字描述符,强转后的通信地址,通信地址大小) ;
功能：
主要用于绑定socket和具体的通信地址
返回值：
成功：返回0
失败：返回-1，errno被设置
例如：
int ret = bind(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));
if(ret < 0) //很有必要！！
{
perror("bind");
exit(-1);
}
sockfd：socket描述符，即监听套接字
(struct sockaddr*)&saddr：结构体指针，
不管是什么协议的地址结构，都需要强转为该类型
sizeof(saddr)：通信地址结构的大小，使用sizeof()计算即可
4.监听 使用listen()函数
原型：int listen(int sockfd, int backlog);
即：listen(监听套接字,监听队列大小);
功能：
为套接字sockfd建立一个连接请求监听队列，在调用listen函数成功后，这个套接字便成为服务套接字，即被动套接字
返回值：
成功：返回0
失败：返回-1，errno被设置
例如：
listen(sockfd,10);
sockfd：socket描述符，即监听套接字
10：监听队列的大小
5.等待连接 accept()函数
原型：int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
即：accept(监听套接字,强转后的通信地址,指针类型的通信地址大小);
功能：
用于接收服务套接字sockfd上的连接请求
返回值：
成功：返回一个【连接套接字】
(新的，在后面的代码中起作用，代替监听套接字出现)
失败返回-1，errno被设置
例如：
socklen_t len = sizeof(caddr); //不能直接在等待中用sizeof(caddr)
//保存客户地址的结构体的大小，必需由调用者初始化
int confd = accept(sockfd,(struct sockaddr*)&caddr,&len);
caddr： 结构体指针，用于保存接受的客户端通信地址,
与被初始化的通信地址一起定义，用来存储客户端的地址
sockfd：socket函数的返回值，监听套接字
(struct sockaddr*)&caddr：结构体指针，
不管是什么协议的地址结构，都需要强转为该类型
&len：指针类型，用于保存客户端网络地址的信息的长度
注：如果对客户地址不感兴趣，那么第二、三两个参数写NULL即可。
如果需要客户的地址，那么第三个参数必须由调用者初始化。
6.通信
【方法】：把连接套接字当成文件描述符操作，
可以读取里面的东西，也可以往里面写东西
7.关闭连接套接字和监听套接字
close(confd);
close(sockfd);
/*********************服务器*************/
/*****************客户端*************/
3.连接 使用connect()函数
原型：int connect(int sockfd, const struct sockaddr *addr,
socklen_t addrlen);
即：connect(监听套接字描述符,服务器的通信地址,通信地址结构的大小);
功能：
用于连接服务器
返回值：
成功:返回0
失败:返回-1，errno被设置
例如：
int ret = connect(sockfd,(struct sockaddr *)&saddr,sizeof(saddr));
if(ret < 0)
{
perror("connect");
exit(-1);
}
4.通信
【方法】：把监听套接字当成文件描述符操作，
可以读取里面的东西，也可以往里面写东西
5.关闭监听套接字
close(sockfd);
/****************客户端*************/
迭代服务器
并发服务器
多进程服务器
多线程服务器
多路复用服务器
【2】.IO多路复用服务器
【作用】：实现多个文件的查询是否就绪，
在某个文件可读的情况下，马上读到数据，
【方法】：运用select()函数
【原理】：对集合中的文件进行轮询，每隔一段时间就会去
询问文件描述符[0,nfds)中的每一个文件，查看是否就绪，
如果就绪那么把相应的文件描述符集合中置1. .......
直到有文件就绪或超时或出错。
超时时间结构体：
struct timeval {
time_t tv_sec; /* 秒 */
suseconds_t tv_usec; /* 毫秒 */
};
例如：
struct timeval tv;//超时时间结构体
/* 超时时间设为5秒. */
tv.tv_sec = 5;
tv.tv_usec = 0;
select()【函数原型】：
int select(int nfds, fd_set *readfds, fd_set *writefds,
fd_set *exceptfds, struct timeval *timeout);
即：select(感兴趣的文件集合中最大的文件描述符,
对读感兴趣的文件描述符集合,
对写感兴趣的文件描述符集合,
对异常感兴趣的文件描述符集合,
超时时间);
返回值：
1.有文件数据就绪，立马返回，返回就绪的文件描述符个数 >0
2.超时返回，返回0
3.出错了，返回-1 ,errno被设置
例如：
int retval;
retval = select(10, &tmpfds, NULL, NULL, &tv);
if(retavl < 0)
{ //出错
perror("select");
}
else if(retavl > 0)
{ //有文件就绪
。。。。
}
else if(retval == 0)
{ //等待超时
。。。。
}
【辅助函数】：
1】. void FD_ZERO(fd_set *set);
功能：初始化指定的集合，全部清零
例如：
FD_ZERO(sockfd,&rfds);
2】. void FD_SET(int fd, fd_set *set);
功能：把指定的fd设置到集合中去
例如：
FD_SET(sockfd,&rfds);
3】. int FD_ISSET(int fd, fd_set *set);
功能：判断指定的fd是否在这个集合中
返回值：
成功：返回非0
失败：返回0
例如：
FD_ISSET(sockfd,&rfds);
4】. void FD_CLR(int fd, fd_set *set);
功能：把指定fd从集合中移除
例如：
FD_CLR(sockfd,&rfds);
select使用【步骤】：
1.设置文件描述符
fd_set rfds,tmpfds;//创建两个文件描述符集合
struct timeval tv;//定义一个超时时间结构体
int retval; //定义一个描述符作为轮询函数的返回值，
//用于划分轮询结果以便分配任务
2. 初始化指定的文件集合，全部清零
FD_ZERO(&rfds);//把文件描述符集合清零，即初始化
3. 把指定的文件的文件描述符设置到集合中去
FD_SET(i, &rfds);//把文件描述符i，放到集合rfds中，即把对应的位置1
4.初始化时间结构体 ，
/* 超时时间设为5秒. */
tv.tv_sec = 5;
tv.tv_usec = 0;
5.备份需要轮询的文件描述符集合
tmpfds = rfds;//拷贝准备好的描述符集合，
//每循环一次，备份一次文件描述符，启动一次轮询函数
//防止源集合被覆盖
6.启动轮询函数
retval = select(fd_max+1,&tmpfds,NULL,NULL,&tv);
7.判断指定的fd是否在这个集合中
FD_ISSET(i,&rfds) //判断指定的文件是否在集合中
8. 把指定fd从集合中移除
FD_CLR(i,&rfds);//从集合中移除这个连接套接字描述符
9. 关闭文件
close(i);
【TCP与UDP协议的比较】：
1.tcp协议：
传输控制协议 类似打电话
面向连接的 (建立连接-->进行通信-->断开连接)
在通信的整个过程中必需保持连接
该协议保证了数据的传递是可靠且有序的
属于全双工的字节流通信方式
服务器压力较大，资源消耗大，执行效率较低
2.udp协议：
用户数据报协议
面向非连接的 类似发短信
在通信的整个过程中不需要保持连接
不保证数据的可靠性和有序性
属于全双工的数据报通信方式
服务器压力较小，资源消耗小，执行效率高
【3】.基于【UDP协议】的通信模型
【注意】：
1.UDP不分服务器和客户端
2. UDP调用接收函数必须要绑定地址，
要用socklen_t len = sizeof(saddr);
求出目标地址长度，在函数中用&len代表长度
3.调用方式函数不用绑定地址，也不要先求出长度
用法：
1.创建监听套接字
使用socket()函数
2.准备通信地址
定义并初始化结构体变量
/******************接收方**************/
3.绑定监听套接字和通信地址
使用bind()函数
4.通信
————————————————————————————
接收数据报函数：recvfrom()
原型：ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
struct sockaddr *src_addr, socklen_t *addrlen);
即：recvfrom(监听套接字描述符,强转的被发送的数据首地址,
发送数据的大小,发送标志,
发送数据的目标地址,目标地址的大小);
作用：
将目标地址发过来的N个字节存到缓冲区中
例如：
socklen_t len = sizeof(saddr);
ret = recvfrom(sockfd,buf,sizeof(buf),0,(struct sockaddr *)&saddr,&len);
sockfd： socket函数的返回值，监听套接字
buf： 被发送的数据首地址
sizeof(buf)： 发送数据的大小
0： 发送标志
0：功能与write一样，即阻塞
MSG_DONTWAIT: 非阻塞
(struct sockaddr *)&saddr：发送数据的目标地址
&len：目标地址的大小
**********************************/
/***************发送方*************/
3.通信
————————————————————————————
发送数据报函数：sendto()
原型：ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
const struct sockaddr *dest_addr, socklen_t addrlen);
即：sendto(监听套接字描述符,强转的被发送的数据首地址,
发送数据的大小,发送标志,
发送数据的目标地址,目标地址的大小);
作用：
将准备好的数据中的N个发送给大小为M的目标地址，进行通信
例如：
int res = sendto(sockfd,str,strlen(str),0,
(struct sockaddr *)&saddr,sizeof(saddr));
sockfd： socket函数的返回值，监听套接字
str： 被发送的数据首地址
strlen(str)： 发送数据的大小
0： 发送标志
0：功能与write一样，即阻塞
MSG_DONTWAIT: 非阻塞
(struct sockaddr *)&saddr：发送数据的目标地址 【发给谁】
sizeof(saddr)：目标地址的大小
**********************************/
5.关闭套接字
close(sockfd);
【UDP】应用
广播 组播
发送方：1.要有一个套接字
2.要有一个目标地址(不是给自己用的，所以不用绑定)
3.要用专门的函数sendto()发送数据报
接收方：1.要有一个套接字
2.要有一个给自己用的通信地址(需要绑定)和
一个存储发送者资料的地址
3.
方法一：
使用setsockopt()函数将默认接收的缓冲区设计为一个小的缓冲区，
缓冲区地址和大小任意定义，使用getsockopt()函数得到套接字选项值
例如：
setsockopt(sockfd,SOL_SOCKET,SO_BROADCAST,(void*)&j,sizeof(j));
getsockopt(sockfd,SOL_SOCKET,SO_BROADCAST,(void*)&i,&size);
方法二：
定义一个多播组结构体变量，并初始化，使用setsockopt()函数将默认接收
的缓冲区设计为一个小的缓冲区，缓冲区地址为定义结构体变量的首地址，
大小为结构体变量所占字节数
例如：//加入多播组的方式
struct ip_mreq join_addr;
memset(&join_addr,0,sizeof(join_addr));
join_addr.imr_multiaddr.s_addr = inet_addr(argv[1]);// 组播组的IP地址。
join_addr.imr_interface.s_addr = htonl(INADDR_ANY); // 本地某一网络设备接口的IP地址。
setsockopt(sockfd,IPPROTO_IP,IP_ADD_MEMBERSHIP,(void*)&join_addr,sizeof(join_addr));
4.绑定监听套接字和通信地址
5.使用专门的函数recvfrom()接收数据报
http://blog.csdn.net/chary8088/article/details/2486377
【套接字】：
【概念】：通信的两方的一种约定，用套接字中的相关函数来完成通信过程
【套接字选项】：
【概念】：每个【套接字】在不同的协议层次上【有】不同的【行为属性】，
那么这个【行为属性】就称为套接字选项
【作用】： 设置地址复用
允许发送广播消息
将主机加入多播组
设置发送与接收缓冲区的大小等
我们正常使用套接字编程时，一般只关注数据通信，而忽略套接字的不同特性
但有时需要设置地址复用，允许发送广播消息，将主机加入多播组，设置发送与接收缓冲区的大小等
这些都需要对套接字选项进行设置。
【所用函数】：
原型：int getsockopt(int sockfd, int level, int optname,
void *optval, socklen_t *optlen);
即：getsockopt(监听套接字,套接字选项所在的协议层次,
套接字选项的名称,缓冲区首地址,
缓冲区的长度);
功能： 得到套接字选项值
返回值：
成功：返回0。
失败：返回-1，errno被设置
例如：
原型：int setsockopt(int sockfd, int level, int optname,
const void *optval, socklen_t optlen);
即：setsockopt(监听套接字,套接字选项所在的协议层次,
套接字选项的名称,缓冲区首地址,
缓冲区的长度);
功能：如果认为套接口的默认发送以及接收缓冲区的尺寸太大时，
作为程序设计者的我们可以【将默认发送的缓冲区设计为一个小的缓冲区】。
将socket加入一个组播组，因为socket要接收组播地址224.0.0.1的
数据，它就必须加入该组播组。结构体struct ip_mreq mreq是
该操作的参数，下面是其定义：
struct ip_mreq
{
struct in_addr imr_multiaddr; // 组播组的IP地址。
struct in_addr imr_interface; // 本地某一网络设备接口的IP地址。
};
一台主机上可能有多块网卡，接入多个不同的子网，
imr_interface参数就是指定一个特定的设备接口，
告诉协议栈只想在这个设备所在的子网中加入某个组播组。
有了这两个参数，协议栈就能知道：在哪个网络设备接口上
加入哪个组播组。为了简单起见，我们的程序中直接写明了
IP地址：在172.16.48.2所在的设备接口上加入组播组224.0.1.1。
这个操作是在网络层上的一个选项，所以级别是SOL_IP
IP_ADD_MEMBERSHIP选项把用户传入的参数拷贝成了
struct ip_mreqn结构体：
393
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
