Linux网络编程
网络开发
一、网络采用分层的思想：
1.每一层实现不同的功能，对上册的数据做透明传输
2. 每一层向上层提供服务，同时使用下层提供的服务
各层典型的协议：
1. 网络接口与物理层
MAC地址： 48位全球唯一，网络设备的身份标识
ARP/RARP:
ARP: IP地址----->MAC地址
RARP: MAC地址--->IP地址
PPP协议： 拨号协议（GPRS/3G/4G）
网络层：
IP地址
IP: Internet protocol(分为IPV4和IPV6)
ICMP: Internet控制管理协议，ping命令属于ICMP
IGMP: Internet分组管理协议，广播、组播
传输层：
TCP: (Transfer Control protocol，传输控制协议) 提供面向连接的，一对一的可靠数据传输的协议
即数据无误、数据无丢失、数据无失序、数据无重复到达的通信
UDP: (user Datagram Protocol， 用户数据报协议)： 提供不可靠，无连接的尽力传输协议
是不可靠的无连接的协议。在数据发送前，因为不需要进行连接，所以可以进行高效率的数据传输。
SCTP： 是可靠传输，是TCP的增强版，它能实现多主机、多链路的通信（具体可以参考资料中的《UNIX网络编程第三版》）
应用层：
网页访问协议：HTTP/HTTPS
邮件发送接收协议： POP3（收）/SMTP(发) 、IMAP（可接收邮件的一部分)
FTP,
Telnet/SSH: 远程登录
嵌入式相关：
NTP: 网络时钟协议
SNMP: 简单网络管理协议（实现对网络设备集中式管理）
RTP/RTSP：用传输音视频的协议（安防监控）
三、网络的封包和拆包：
四、网络编程的预备知识
4.1.SOCKET
4.1.1 socket是一个应用编程的接口，它是一种特殊的文件描述符（对它执行IO的操作函数，比如,read(),write(),close()等操作函数）
4.1.2 socket代表着网络编程的一种资源
4.1.3 socket的类型：
| 流式套接字(SOCK_STREAM)： 唯一对应着TCP 数据报套接字(SOCK_DGRAM)： 唯一对应着UDP 原始套接字(SOCK_RAW)：（对应着多个协议，发送穿透了传输层） |
4.2 IP地址
1.IP地址分为IPV4和IPV6
IPV4:采用32位的整数来表示
IPV6：采用了128位整数来表示
mobileIPV6: local IP(本地注册的IP)，roam IP(漫游IP)
IPV4地址：
点分形式： 192.168.7.246
32位整数
特殊IP地址:
局域网IP: 192.XXX.XXX.XXX 10.XXX.XXX.XXX
广播IP: xxx.xxx.xxx.255, 255.255.255.255(全网广播)
组播IP: 224.XXX.XXX.XXX~239.xxx.xxx.xxx
4.3 端口号
16位的数字（1-65535）
众所周知端口： 1~1023（FTP: 21，SSH： 22， HTTP:80， HTTPS:469）
保留端口： 1024-5000（不建议使用）
可以使用的：5000~65535
TCP端口和UDP端口是相互独立的
网络里面的通信是由 IP地址+端口号 来决定
4.4 字节序
字节序是指不同的CPU访问内存中的多字节数据时候，存在大小端问题
如CPU访问的是字符串，则不存在大小端问题
一般来说：
X86/ARM： 小端
powerpc/mips, ARM作为路由器时，大端模式
网络传输的时候采用大端模式
=====
本地字节序、网络字节序
IP地址转换函数：
in_addr_t inet_addr(const char *cp);
cp: 点分形式的IP地址，结果是32位整数（内部包含了字节序的转换，默认是网络字节序的模式）
特点： 1. 仅适应于IPV4
2. 当出错时，返回-1
3.此函数不能用于255.255.255.255的转换
inet_pton()/inet_ntop()
特点： 1.适应于IPV4和IPV6
2.能正确的处理255.255.255.255的转换问题
参数：
1. af: 地址协议族（AF_INET或AF_INET6）
2.src:是一个指针（填写点分形式的IP地址[主要指IPV4]）
3.dst: 转换的结果给到dst
RETURN VALUE
inet_pton() returns 1 on success (network address was successfully con‐
verted). 0 is returned if src does not contain a character string representing a valid network address in the specified address family. If af does not contain a valid address family, -1 is returned and errno is set to EAFNOSUPPORT.
TCP编程API
1.socket()函数
1.1 参数：
1.domain:
AF_INET IPv4 Internet protocols ip(7)
AF_INET6 IPv6 Internet protocols ipv6(7)
AF_UNIX, AF_LOCAL Local communication unix(7)
AF_NETLINK Kernel user interface device netlink(7)
AF_PACKET Low level packet interface packet(7)
2.type:
SOCK_STREAM: 流式套接字 唯一对应于TCP
SOCK_DGRAM： 数据报套接字，唯一对应着UDP
SOCK_RAW： 原始套接字
3.protocol: 一般填0，原始套接字编程时需填充
1.2 返回值：
RETURN VALUE
On success, a file descriptor for the new socket is returned. On
error, -1 is returned, and errno is set appropriately.
成功时返回文件描述符，出错时返回为-1
2.bind()函数
2.1 参数：
sockfd: 通过socket()函数拿到的fd
addr: struct sockaddr的结构体变量的地址
addrlen: 地址长度
RETURN VALUE
On success, zero is returned. On error, -1 is returned, and errno is set appropriately.
示例代码：
如果是IPV6的编程，要使用struct sockddr_in6结构体（详细情况请参考man 7 ipv6）,通常更通用的方法可以通过struct sockaddr_storage来编程
3.listen()函数: 把主动套接字变成被动套接字
参数：
sockfd: 通过socket()函数拿到的fd
backlog： 同时允许几路客户端和服务器进行正在连接的过程（正在三次握手）
一般填5， 测试得知,ARM最大为8
| 内核中服务器的套接字fd会维护2个链表： |
比如：listen(fd, 5); //表示系统允许11(=2*5+1)个客户端同时进行三次握手
返回值：
RETURN VALUE
On success, zero is returned. On error, -1 is returned, and errno is set appropriately.
4.accept(): 阻塞等待客户端连接请求
４.１ 参数：
sockfd: 经过前面socket()创建并通过bind(),listen()设置过的fd
addr和addrlen: 获取连接过来的客户的信息
4.2 返回值：
RETURN VALUE
On success, these system calls return a nonnegative integer that is a descriptor for the accepted socket. On
error, -1 is returned, and errno is set appropriately.
成功时返回已经建立好连接的新的newfd
5.客户端的连接函数 connect()
connect()函数和服务器的bind()函数写法类似：
5.1 参数：
sockfd: 通过socket()函数拿到的fd
addr: struct sockaddr的结构体变量的地址
addrlen: 地址长度
5.2 返回值：
RETURN VALUE
If the connection or binding succeeds, zero is returned. On error, -1
is returned, and errno is set appropriately.
/*用多线程的方式进行tcp通信*/
/*server.c文件*/
#include
#include "net.h"
void cli_data_handle (void *arg);//声明多线程函数
int main (void)
{
int fd = -1;
struct sockaddr_in sin;
/* 1. 创建socket fd */
if ((fd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
perror ("socket");
exit (1);
}
/*优化4： 允许绑定地址快速重用 */
int b_reuse = 1;//等以一个整型变量
setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof (int));
/*2. 绑定 */
/*2.1 填充struct sockaddr_in结构体变量 */
bzero (&sin, sizeof (sin));
sin.sin_family = AF_INET;
sin.sin_port = htons (SERV_PORT); //网络字节序的端口号
/*优化1: 让服务器程序能绑定在任意的IP上 */
#if 1
sin.sin_addr.s_addr = htonl (INADDR_ANY);
#else
if (inet_pton (AF_INET, SERV_IP_ADDR, (void *) &sin.sin_addr) != 1) {
perror ("inet_pton");
exit (1);
}
#endif
/*2.2 绑定 */
if (bind (fd, (struct sockaddr *) &sin, sizeof (sin)) < 0) {
perror ("bind");
exit (1);
}
/*3. 调用listen()把主动套接字变成被动套接字 */
if (listen (fd, BACKLOG) < 0) {
perror ("listen");
exit (1);
}
printf ("Server starting....OK!\n");
int newfd = -1;
/*4. 阻塞等待客户端连接请求 */
/* 优化： 用多进程/多线程处理已经建立号连接的客户端数据 */
pthread_t tid;//定义一个pthread_t的变量
struct sockaddr_in cin;//定义一个结构体类型的变量
socklen_t addrlen = sizeof (cin);
while (1) {
/*accpet等待客户端连接*/
if ((newfd = accept (fd, (struct sockaddr *) &cin, &addrlen)) < 0) {
perror ("accept");
exit (1);
}
char ipv4_addr[16];
/*将点分形式的ip地址转换为32位整数*/
if (!inet_ntop (AF_INET, (void *) &cin.sin_addr, ipv4_addr, sizeof (cin))) {
perror ("inet_ntop");
exit (1);
}
//打印提示信息：...客户端已连接
printf ("Clinet(%s:%d) is connected!\n", ipv4_addr, htons (cin.sin_port));
/*创建一个多线程，线程函数为cli_data_handle，传入参数为newfd*/
pthread_create (&tid, NULL, (void *) cli_data_handle, (void *) &newfd);
}
close (fd);
return 0;
}
/*编写线程函数*/
void cli_data_handle (void *arg)
{
int newfd = *(int *) arg;
printf ("handler thread: newfd =%d\n", newfd);
//..和newfd进行数据读写
int ret = -1;
char buf[BUFSIZ];//定义一个buf的数组
while (1) {
bzero (buf, BUFSIZ);//将buf中的数据清零
do {
ret = read (newfd, buf, BUFSIZ - 1);//将newfd中的数据读入带buf中
} while (ret < 0 && EINTR == errno);
if (ret < 0) {
perror ("read");
exit (1);
}
if (!ret) { //对方已经关闭
break;
}
printf ("Receive data: %s\n", buf);//打印buf中的数据
if (!strncasecmp (buf, QUIT_STR, strlen (QUIT_STR))) //用户输入了quit字符
{
printf ("Client(fd=%d) is exiting!\n", newfd);//打印Client的提示信息
break;
}
}
close (newfd);
}
/*client.c*/
/*./client serv_ip serv_port */
#include "net.h"
/*打印提示信息*/
void usage (char *s)
{
printf ("\n%s serv_ip serv_port", s);
printf ("\n\t serv_ip: server ip address");
printf ("\n\t serv_port: server port(>5000)\n\n");
}
int main (int argc, char **argv)
{
int fd = -1;
int port = -1;
struct sockaddr_in sin;
/*做一个参数判断*/
if (argc != 3) {
usage (argv[0]);
exit (1);
}
/* 1. 创建socket fd */
if ((fd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
perror ("socket");
exit (1);
}
port = atoi (argv[2]);//将参数中的字符串给port
if (port < 5000) {
usage (argv[0]);
exit (1);
}
/*2.连接服务器 */
/*2.1 填充struct sockaddr_in结构体变量 */
bzero (&sin, sizeof (sin));
sin.sin_family = AF_INET;
sin.sin_port = htons (port); //网络字节序的端口号
#if 0
sin.sin_addr.s_addr = inet_addr (SERV_IP_ADDR);
#else
if (inet_pton (AF_INET, argv[1], (void *) &sin.sin_addr) != 1) {
perror ("inet_pton");
exit (1);
}
#endif
if (connect (fd, (struct sockaddr *) &sin, sizeof (sin)) < 0) {
perror ("connect");
exit (1);
}
printf ("Client staring...OK!\n");
/*3. 读写数据 */
char buf[BUFSIZ];
int ret = -1;
while (1) {
bzero (buf, BUFSIZ);将buf中的数据清零
if (fgets (buf, BUFSIZ - 1, stdin) == NULL)
{
continue;
}
do {
ret = write (fd, buf, strlen (buf));
} while (ret < 0 && EINTR == errno);
if (!strncasecmp (buf, QUIT_STR, strlen (QUIT_STR))) { //用户输入了quit字符
printf ("Client is exiting!\n");
break;
}
}
/*4.关闭套接字 */
close (fd);
}
/*net.h*/
#ifndef __MAKEU_NET_H__
#define __MAKEU_NET_H__
#include
#include
#include
#include
#include
#include
#include /* See NOTES */
#include
#include
#include /* superset of previous */
#define SERV_PORT 5001
#define SERV_IP_ADDR "192.168.7.246"
#define BACKLOG 5
#define QUIT_STR "quit"
#endif
/*pthread 库不是 Linux 系统默认的库，连接时需要使用静态库 libpthread.a，所以在使用pthread_create()创建线程，以及调用 pthread_atfork()函数建立fork处理程序时，需要链接该库
处理方法：在编译中要加 -lpthread参数
gcc mult-thread-tcp-server.c -o mult-thread-tcp-server -lpthread
*/
/*使用多进程实现tcp通信*/
/*server.c文件*/
#include
#include
#include "net.h"
void cli_data_handle (void *arg);
/*信号响应函数回收子进程*/
void sig_child_handle(int signo)
{
if(SIGCHLD == signo) {
waitpid(-1, NULL, WNOHANG);
}
}
int main (void)
{
int fd = -1;
struct sockaddr_in sin;
/*避免子进程变成僵尸进程，子进程退出时，会发送信号SIGCHLD,设置信号响应函数sig_child_handle*/
signal(SIGCHLD, sig_child_handle);
/* 1. 创建socket fd */
if ((fd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
perror ("socket");
exit (1);
}
/*优化4： 允许绑定地址快速重用 */
int b_reuse = 1;
setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof (int));
/*2. 绑定 */
/*2.1 填充struct sockaddr_in结构体变量 */
bzero (&sin, sizeof (sin));
sin.sin_family = AF_INET;
sin.sin_port = htons (SERV_PORT); //网络字节序的端口号
/*优化1: 让服务器程序能绑定在任意的IP上 */
#if 1
sin.sin_addr.s_addr = htonl (INADDR_ANY);
#else
if (inet_pton (AF_INET, SERV_IP_ADDR, (void *) &sin.sin_addr) != 1) {
perror ("inet_pton");
exit (1);
}
#endif
/*2.2 绑定 */
if (bind (fd, (struct sockaddr *) &sin, sizeof (sin)) < 0) {
perror ("bind");
exit (1);
}
/*3. 调用listen()把主动套接字变成被动套接字 */
if (listen (fd, BACKLOG) < 0) {
perror ("listen");
exit (1);
}
printf ("Server starting....OK!\n");
int newfd = -1;
/*4. 阻塞等待客户端连接请求 */
struct sockaddr_in cin;
socklen_t addrlen = sizeof (cin);
while(1) {
pid_t pid = -1;
/*创建一个新的newfd导入accpet阻塞等待新客户端连接的返回值*/
if ((newfd = accept
(fd, (struct sockaddr *) &cin, &addrlen)) < 0) {
perror ("accept");
break;
}
/*创建一个子进程用于处理已建立连接的客户的交互数据*/
if((pid = fork()) < 0)
{
perror("fork");
break;//创建失败，跳出循环
}
if(0 == pid)
{ //子进程中（pid写到左边，避免编译出错）
close(fd);//关闭不要的文件描述符
char ipv4_addr[16];
/*将网络字节序的ip地址转换成点分形式的ip地址*/
if (!inet_ntop (AF_INET, (void *) &cin.sin_addr, ipv4_addr, sizeof (cin)))
{
perror ("inet_ntop");
exit (1);
}
/*打印客户端的ip地址，并将网络字节序转换成本地字节序*/
printf ("Clinet(%s:%d) is connected!\n", ipv4_addr, ntohs(cin.sin_port));
cli_data_handle(&newfd);
return 0; //表示客户端数据处理完毕
} else { //此处 pid >0, 父进程中
close(newfd);//关闭不要的文件描述符
}
}
close (fd);
return 0;
}
void cli_data_handle (void *arg)
{
int newfd = *(int *) arg;
printf ("Child handling process: newfd =%d\n", newfd);
//..和newfd进行数据读写
int ret = -1;
char buf[BUFSIZ];
while (1) {
bzero (buf, BUFSIZ);
do {
ret = read (newfd, buf, BUFSIZ - 1);
} while (ret < 0 && EINTR == errno);
if (ret < 0) {
perror ("read");
exit (1);
}
if (!ret) { //对方已经关闭
break;
}
printf ("Receive data: %s\n", buf);
if (!strncasecmp (buf, QUIT_STR, strlen (QUIT_STR))) { //用户输入了quit字符
printf ("Client(fd=%d) is exiting!\n", newfd);
break;
}
}
close (newfd);
}
/*client.c文件*/
/*./client serv_ip serv_port */
#include "net.h"
void usage (char *s)
{
printf ("\n%s serv_ip serv_port", s);
printf ("\n\t serv_ip: server ip address");
printf ("\n\t serv_port: server port(>5000)\n\n");
}
int main (int argc, char **argv)
{
int fd = -1;
int port = -1;
struct sockaddr_in sin;
if (argc != 3) {
usage (argv[0]);
exit (1);
}
/* 1. 创建socket fd */
if ((fd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
perror ("socket");
exit (1);
}
port = atoi (argv[2]);
if (port < 5000) {
usage (argv[0]);
exit (1);
}
/*2.连接服务器 */
/*2.1 填充struct sockaddr_in结构体变量 */
bzero (&sin, sizeof (sin));
sin.sin_family = AF_INET;
sin.sin_port = htons (port); //网络字节序的端口号
#if 0
sin.sin_addr.s_addr = inet_addr (SERV_IP_ADDR);
#else
if (inet_pton (AF_INET, argv[1], (void *) &sin.sin_addr) != 1) {
perror ("inet_pton");
exit (1);
}
#endif
if (connect (fd, (struct sockaddr *) &sin, sizeof (sin)) < 0) {
perror ("connect");
exit (1);
}
printf ("Client staring...OK!\n");
/*3. 读写数据 */
char buf[BUFSIZ];
int ret = -1;
while (1) {
bzero (buf, BUFSIZ);
if (fgets (buf, BUFSIZ - 1, stdin) == NULL) {
continue;
}
do {
ret = write (fd, buf, strlen (buf));
} while (ret < 0 && EINTR == errno);
if (!strncasecmp (buf, QUIT_STR, strlen (QUIT_STR))) { //用户输入了quit字符
printf ("Client is exiting!\n");
break;
}
}
/*4.关闭套接字 */
close (fd);
}
/*net.h*/
#ifndef __MAKEU_NET_H__
#define __MAKEU_NET_H__
#include
#include
#include
#include
#include
#include
#include /* See NOTES */
#include
#include
#include /* superset of previous */
#define SERV_PORT 5001
#define SERV_IP_ADDR "192.168.7.246"
#define BACKLOG 5
#define QUIT_STR "quit"
#endif
一、TCP编程API（续）
网络发送数据：send() / write();
#include
#include
ssize_t send(int sockfd, const void *buf, size_t len, int flags);
#include
ssize_t write(int fd, const void *buf, size_t count);
send()比writeduo'多一个参数flags：
flags:
一般填写0，此时和write（）作用一样
特殊的标志：
MSG_DONTWAIT: Enables nonblocking operation ; 非阻塞版本
MSG_OOB: 用与发送TCP类型的带外数据（out-of-band）
网络中接受数据：recv()/read()
#include
#include
ssize_t recv(int sockfd, void *buf, size_t len, int flags);
#include
ssize_t read(int fd, void *buf, size_t count);
flags: 一般填写0，此时和read（）作用一样
特殊的标志：
MSG_DONTWAIT: Enables nonblocking operation ; 非阻塞版本
MSG_OOB: 用与发送TCP类型的带外数据（out-of-band）
MSG_PEEK：
This flag causes the receive operation to return data from the
beginning of the receive queue without removing that data from
the queue. Thus, a subsequent receive call will return the same
data.
二、UDP编程的API
/*UDP编程*/
/*server.c文件*/
#include "net.h"
int main(void)
{
int fd = -1;
struct sockaddr_in sin;
/* 1. 创建socket fd */
if ((fd = socket (AF_INET, SOCK_DGRAM, 0)) < 0) { //udp程序
perror ("socket");
exit (1);
}
/* 2. 允许绑定地址快速重用 */
int b_reuse = 1;
setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, &b_reuse, sizeof (int));
/*2. 绑定 */
/*2.1 填充struct sockaddr_in结构体变量 */
bzero (&sin, sizeof (sin));
sin.sin_family = AF_INET;
sin.sin_port = htons (SERV_PORT); //网络字节序的端口号
/* 让服务器程序能绑定在任意的IP上 */
#if 1
sin.sin_addr.s_addr = htonl (INADDR_ANY);
#else
if (inet_pton (AF_INET, SERV_IP_ADDR, (void *) &sin.sin_addr) != 1) {
perror ("inet_pton");
exit (1);
}
#endif
/*2.2 绑定 */
if (bind (fd, (struct sockaddr *) &sin, sizeof (sin)) < 0) {
perror ("bind");
exit (1);
}
char buf[BUFSIZ];
struct sockaddr_in cin;
socklen_t addrlen = sizeof(cin);
printf("\nUDP server started!\n");//打印提示信息，告知server端已经启动成功
while(1) {
bzero(buf, BUFSIZ);
/*接收客户端发送过来的消息*/
if( recvfrom(fd, buf, BUFSIZ-1, 0,(struct sockaddr *)&cin, &addrlen ) < 0) {
perror("recvfrom");
continue;
}
/*打印提示信息，告知连接服务器的ip和端口号*/
char ipv4_addr[16];
if (!inet_ntop (AF_INET, (void *) &cin.sin_addr, ipv4_addr, sizeof (cin))) {
perror ("inet_ntop");
exit (1);
}
printf("Recived from(%s:%d), data:%s",ipv4_addr, ntohs(cin.sin_port), buf);
/*比较客户端输入信息，如果输入quit字符，则退出服务器*/
if (!strncasecmp (buf, QUIT_STR, strlen (QUIT_STR))) { //用户输入了quit字符
printf ("Client(%s:%d) is exiting!\n", ipv4_addr, ntohs(cin.sin_port));
}
}
close(fd);//关闭流套接字
return 0;
}
/*client.c文件*/
/*udp demo */
/* usage:
* ./client serv_ip serv_port
*/
#include "net.h"
/*打印提示信息，告知输入格式*/
void usage(char *s)
{
printf("\nThis is udp demo!\n");
printf("\nUsage:\n\t %s serv_ip serv_port",s);
printf("\n\t serv_ip: udp server ip address");
printf("\n\t serv_port: udp server port(serv_port > 5000)\n\n");
}
int main(int argc, char *argv[])
{
int fd = -1;
int port = SERV_PORT;
port = atoi(argv[2]);//将端口号字符串型转化为整型
if(port < 0 || (port >0 && port <= 5000)) {
usage(argv[0]);
exit(1);
}
struct sockaddr_in sin;
/*参数不够3个*/
if(argc !=3) {
usage(argv[0]);
exit(1);
}
/* 1. 创建socket fd*/
if( (fd = socket(AF_INET,SOCK_DGRAM, 0)) < 0) { //UDP编程
perror("socket");
exit(1);
}
/*2.1 填充struct sockaddr_in结构体变量 */
bzero(&sin,sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(SERV_PORT); //网络字节序的端口号
#if 0
sin.sin_addr.s_addr = inet_addr(argv[1]);
#else
if( inet_pton(AF_INET, argv[1], (void *)&sin.sin_addr) != 1) {
perror("inet_pton");
exit(1);
}
#endif
printf("UDP client started!\n");
char buf[BUFSIZ];
while(1) {
fprintf(stderr,"pls input string:");
bzero(buf, BUFSIZ);//将buf清零
/*从键盘输入到buf中*/
if( fgets(buf, BUFSIZ-1, stdin) ==NULL) {
perror("fgets");
continue;
}
/*从buf中取数据发送数据*/
sendto(fd, buf, strlen(buf), 0, (struct sockaddr *)&sin, sizeof(sin));
/*比较输入的字符串，如果输入quit，则退出客户端*/
if( !strncasecmp(buf, QUIT_STR, strlen(QUIT_STR))) { //用户输入了quit字符
printf("Client is exited!\n");
break;
}
}
close(fd);//关闭流套接字
return 0;
}
/*net.h文件*/
#ifndef __MAKEU_NET_H__
#define __MAKEU_NET_H__
#include
#include
#include
#include
#include
#include
#include /* See NOTES */
#include
#include
#include /* superset of previous */
#define SERV_PORT 5001
#define SERV_IP_ADDR "192.168.7.246"
#define QUIT_STR "quit"
#endif
IO多路复用
io模型和多路复用模型
在UNIX/Linux下主要有4种I/O 模型：
阻塞I/O： 最常用
非阻塞I/O： 可防止进程阻塞在I/O操作上，需要轮询
I/O 多路复用： 允许同时对多个I/O进行控制
信号驱动I/O:一种异步通信模型
阻塞I/O 模式
阻塞I/O 模式是最普遍使用的I/O 模式，大部分程序使用的都是阻塞模式的I/O 。
缺省情况下，套接字建立后所处于的模式就是阻塞I/O 模式。
前面学习的很多读写函数在调用过程中会发生阻塞。
读操作中的read、recv、recvfrom
写操作中的write、send
其他操作：accept、connect
非阻塞模式I/O
当我们将一个套接字设置为非阻塞模式，我们相当于告诉了系统内核：“当我请求的I/O 操作不能够马上完成，你想让我 的进程进行休眠等待的时候，不要这么做，请马上返回一个错误给我。”
当一个应用程序使用了非阻塞模式的套接字，它需要使用一个循环来不停地测试是否一个文件描述符有数据可读（称 做polling）。
应用程序不停的polling 内核来检查是否I/O操作已经就绪。这将是一个极浪费CPU 资源的操作。
这种模式使用中不普遍。
多路复用I/O
应用程序中同时处理多路输入输出流，若采用阻塞模式，将得不到预期的目的；
若采用非阻塞模式，对多个输入进行轮询，但又太浪费CPU时间；
若设置多个进程，分别处理一条数据通路，将新产生进程间的同步与通信问题，使程序变得更加复杂；
比较好的方法是使用I/O多路复用。其基本思想是：
先构造一张有关描述符的表，然后调用一个函数。当这些文件描述符中的一个或多个已准备好进行I/O时函数才返 回。
函数返回时告诉进程那个描述符已就绪，可以进行I/O操作。
基本常识：
Linux中'每个进程默认的情况下，最多可以打开1024个文件，最多有1024个文件描述符
文件描述符的特点：
1.非负整数
2.从最小可用的数字来分配
3.每个进程默认打开0，1，2 三个文件描述符
多路复用针对不止套接字fd，也针对普通的文件描述fd
L6-D6-1
TCP、IP协议原理
wireshark
wireshark工作原理
L6-D7-1
TCP/IP协议网络封包格式
IP包头碎片化过程
TCP是一种面向连接的，可靠的数据传输
一、TCP头部
二、TCP的可靠传输：通过确认和重发机制
1.TCP把所有要发送的数据进行编号（每用一个字节用一个号）
2.发送时从当前数据位置，发送window大小的数据
三、面向连接
三次、四次握手注意点：
1.一定标注客户端和服务器
2.三次我收的连接必须是由客户端发起的（四次握手客户端和服务器都可以发起）
3.SYN,ACK,FIN等标志符号应该写上
域名解析
gethostbyname() //根据主机名取得主机信息
SYNOPSIS
#include
extern int h_errno;
struct hostent *gethostbyname(const char *name);
#include /* for AF_INET */
struct hostent *gethostbyaddr(const void *addr,
socklen_t len, int type);
void sethostent(int stayopen);
void endhostent(void);
void herror(const char *s);
const char *hstrerror(int err);
/* System V/POSIX extension */
struct hostent *gethostent(void);
返回值:
RETURN VALUE
The gethostbyname() and gethostbyaddr() functions return the hostent
structure or a NULL pointer if an error occurs. On error, the h_errno
variable holds an error number. When non-NULL, the return value may
point at static data, see the notes below.
The hostent structure is defined in as follows:
struct hostent {
char *h_name; /* official name of host */
char **h_aliases; /* alias list */
int h_addrtype; /* host address type */
int h_length; /* length of address */
char **h_addr_list; /* list of addresses */
}
#define h_addr h_addr_list[0] /* for backward compatibility */
h_addr_list
An array of pointers to network addresses for the host (in net‐
work byte order), terminated by a NULL pointer.
/*带有域名解析的客户端*/
/*./client serv_name serv_port */
#include
#include "net.h"
void usage (char *s)
{
printf ("\n%s serv_ip serv_port", s);
printf ("\n\t serv_name: server domain name or ip address");
printf ("\n\t serv_port: server port(>5000)\n\n");
}
int main (int argc, char **argv)
{
int fd = -1;
int port = -1;
struct sockaddr_in sin;
struct hostent *hs = NULL;
if (argc != 3) {
usage (argv[0]);
exit (1);
}
port = atoi (argv[2]);
if (port < 5000) {
usage (argv[0]);
exit (1);
}
if ((hs = gethostbyname (argv[1])) == NULL) {
herror ("gethostbyname error");
exit (1);
}
/* 1. 创建socket fd */
if ((fd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
perror ("socket");
exit (1);
}
/*2.连接服务器 */
/*2.1 填充struct sockaddr_in结构体变量 */
bzero (&sin, sizeof (sin));
sin.sin_family = AF_INET;
sin.sin_port = htons (port); //网络字节序的端口号
#if 1
sin.sin_addr.s_addr = *(uint32_t *) hs->h_addr;
endhostent ();
hs = NULL;
#else
if (inet_pton (AF_INET, argv[1], (void *) &sin.sin_addr) != 1) {
perror ("inet_pton");
exit (1);
}
#endif
if (connect (fd, (struct sockaddr *) &sin, sizeof (sin)) < 0) {
perror ("connect");
exit (1);
}
printf ("Client staring...OK!\n");
int ret = -1;
fd_set rset;
int maxfd = -1;
struct timeval tout;
char buf[BUFSIZ];
while (1) {
FD_ZERO (&rset);
FD_SET (0, &rset);
FD_SET (fd, &rset);
maxfd = fd;
tout.tv_sec = 5;
tout.tv_usec = 0;
select (maxfd + 1, &rset, NULL, NULL, &tout);
if (FD_ISSET (0, &rset)) { //标准键盘上有输入
//读取键盘输入，发送到网络套接字fd
bzero (buf, BUFSIZ);
do {
ret = read (0, buf, BUFSIZ - 1);
} while (ret < 0 && EINTR == errno);
if (ret < 0) {
perror ("read");
continue;
}
if (!ret)
continue;
if (write (fd, buf, strlen (buf)) < 0) {
perror ("write() to socket");
continue;
}
if (!strncasecmp (buf, QUIT_STR, strlen (QUIT_STR))) { //用户输入了quit字符
printf ("Client is exiting!\n");
break;
}
}
if (FD_ISSET (fd, &rset)) { //服务器给发送过来了数据
//读取套接字数据，处理
bzero (buf, BUFSIZ);
do {
ret = read (fd, buf, BUFSIZ - 1);
} while (ret < 0 && EINTR == errno);
if (ret < 0) {
perror ("read from socket");
continue;
}
if (!ret)
break; /* 服务器关闭 */
//There is a BUG,FIXME!!
printf ("server said: %s\n", buf);
if ((strlen (buf) > strlen (SERV_RESP_STR))
&& !strncasecmp (buf + strlen (SERV_RESP_STR), QUIT_STR, strlen (QUIT_STR))) { //用户输入了quit字符
printf ("Sender Client is exiting!\n");
break;
}
}
}
/*4.关闭套接字 */
close (fd);
}
网络属性的设置：
SYNOPSIS
#include
#include
int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen);
int setsockopt(int sockfd, int level, int optname， const void *optval, socklen_t optlen);
level指定控制套接字的层次.可以取三种值:
1)SOL_SOCKET:通用套接字选项. （应用层）
2)IPPROTO_IP:IP选项. （传输层）
3)IPPROTO_TCP:TCP选项.（网络层）
选项：
举例：
其中timeval的定义如下：
struct timeval
{
long tv_sec; /* seconds ：秒*/
long tv_usec; /* microseconds ：微秒*/
};
网络超时优化：
方法一：设置socket的属性 SO_RCVTIMEO
参考代码如下
struct timeval tv;
tv.tv_sec = 5; // 设置5秒时间
tv.tv_usec = 0;
setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, &tv,
sizeof(tv)); // 设置接收超时
recv() / recvfrom() // 从socket读取数据
方法二：用select检测socket是否’ready’
参考代码如下
struct fd_set rdfs;
struct timeval tv = {5 , 0}; // 设置5秒时间
FD_ZERO(&rdfs);
FD_SET(sockfd, &rdfs);
if (select(sockfd+1, &rdfs, NULL, NULL, &tv) > 0) // socket就绪
{
recv() / recvfrom() // 从socket读取数据
}
方法三：设置定时器(timer), 捕捉SIGALRM信号
参考代码如下
void handler(int signo) { return; }
struct sigaction act;
sigaction(SIGALRM, NULL, &act);
act.sa_handler = handler;
act.sa_flags &= ~SA_RESTART; //清除掉SIGALRM信号的SA_RESTART
sigaction(SIGALRM, &act, NULL);
alarm(5);
if (recv(,,,) < 0) ……
心跳监测：
方法1：数据交互双方隔一段时间，一方发送一点数据到对方，对方给出特定的应答，如超过设定次数大小的时间还是没有应答，这时候认为异常
方法2：改变套接字的属性来实现
