汉中做网站,营销型企业网站建设策划,我也要投放广告,保定网站建设方案报价目录
1.三次握手和四次挥手
2 滑动窗口
3 函数封装思想
4 高并发服务器 学习目标#xff1a;
掌握三次握手建立连接过程掌握四次握手关闭连接的过程掌握滑动窗口的概念掌握错误处理函数封装实现多进程并发服务器实现多线程并发服务器 1.三次握手和四次挥手
思考: 为什么…
目录
1.三次握手和四次挥手
2 滑动窗口
3 函数封装思想
4 高并发服务器 学习目标
掌握三次握手建立连接过程掌握四次握手关闭连接的过程掌握滑动窗口的概念掌握错误处理函数封装实现多进程并发服务器实现多线程并发服务器 1.三次握手和四次挥手
思考: 为什么TCP是面向连接的安全可靠的传输????
TCP是面向连接的安全的数据传输, 在客户端与服务端建立建立的时候要经过三次握手的过程, 在客户端与服务端断开连接的时候要经历四次挥手的过程, 下图是客户端与服务端三次握手建立连接, 数据传输和断开连接四次挥手的全过程.
TCP时序: 说明讲义中图的含义.
SYN: 表示请求, ACK:表示确认
服务端发送的SYN和客户端发送的SYN本身也会占1位.
单独讲解三次握手过程, 以图解形式说明.
上图中ACK表示确认序号, 确认序号的值是对方发送的序号值数据的长度, 特别注意的是SYN和FIN本身也会占用一位.
注: SYS-----synchronous ACK-----acknowledgement FIN------finish
三次握手和四次挥手的过程都是在内核实现的.
下图是TCP数据报格式 窗口大小: 指的是缓冲区大小 通信的时候不再需要SYN标识位了, 只有在请求连接的时候需要SYN标识位.
传输数据的时候的随机序号seq就是最近一次对方发送给自己的ACK的随机序号值, 而发给对方的ACK就是上次刚刚发给对方的ACK的值. 图中发送的ACK确认包表示给对方发送数据的一个确认, 表示你发送的数据我都收到了, 同时告诉对方下次发送该序号开始的数据.
由于每次发送数据都会收到对方发来的确认包, 所以可以确认对方是否收到了, 若没有收到对方发来的确认包, 则会进行重发.
mss: 最大报文长度, 告诉对方我这边最多一次能收多少, 你不能超过这个长度.
win: 表示告诉对方我这边缓存大小最大是多少.
2 滑动窗口
主要作用: 滑动窗口主要是进行流量控制的.
见下图:如果发送端发送的速度较快接收端接收到数据后处理的速度较慢而接收缓冲区的大小是固定的就会导致接收缓冲区满而丢失数据。TCP协议通过“滑动窗口Sliding Window”机制解决这一问题。 详细说明参考讲义
图中win表示告诉对方我这边缓冲区大小是多少, mss表示告诉对方我这边最多一次可以接收多少数据, 你最好不要超过这个长度.
在客户端给服务端发包的时候, 不一定是非要等到服务端返回响应包, 由于客户端知道服务端的窗口大小, 所以可以持续多次发送, 当发送数据达到对方窗口大小了就不再发送, 需要等到对方进行处理, 对方处理之后可继续发送. mss和MTU
MTU: 最大传输单元
MTU:通信术语最大传输单元Maximum Transmission UnitMTU
是指一种通信协议的某一层上面所能通过的最大数据包大小以字节为 单位). 最大传输单元这个参数通常与通信接口有关网络接口卡、串 口等), 这个值如果设置为太大会导致丢包重传的时候重传的数据量较大, 图中的最大值是1500, 其实是一个经验值. mss: 最大报文长度, 只是在建立连接的时候, 告诉对方我最大能够接收多少 数据, 在数据通信的过程中就没有mss了.
3 函数封装思想
函数封装的思想-处理异常情况
结合man-page和errno进行封装.
在封装的时候起名可以把第一个函数名的字母大写, 如socket可以封装成Socket, 这样可以按shiftk进行搜索, shiftk搜索函数说明的时候不区分大小写, 使用man page也可以查看, man page对大小写不区分. 像acceptread这样的能够引起阻塞的函数若被信号打断由于信号的优先级较高, 会优先处理信号, 信号处理完成后会使accept或者read解除阻塞, 然后返回, 此时返回值为 -1设置errnoEINTR;
errnoECONNABORTED表示连接被打断,异常. errno宏:
在/usr/include/asm-generic/errno.h文件中包含了errno所有的宏和对应的错误描述信息.
warp.h
#ifndef __WRAP_H_
#define __WRAP_H_
#include stdlib.h
#include stdio.h
#include unistd.h
#include errno.h
#include string.h
#include sys/socket.h
#include arpa/inet.h
#include strings.hvoid perr_exit(const char *s);
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
int Bind(int fd, const struct sockaddr *sa, socklen_t salen);
int Connect(int fd, const struct sockaddr *sa, socklen_t salen);
int Listen(int fd, int backlog);
int Socket(int family, int type, int protocol);
ssize_t Read(int fd, void *ptr, size_t nbytes);
ssize_t Write(int fd, const void *ptr, size_t nbytes);
int Close(int fd);
ssize_t Readn(int fd, void *vptr, size_t n);
ssize_t Writen(int fd, const void *vptr, size_t n);
ssize_t my_read(int fd, char *ptr);
ssize_t Readline(int fd, void *vptr, size_t maxlen);
int tcp4bind(short port,const char *IP);
#endifwarp.c
#include stdlib.h
#include stdio.h
#include unistd.h
#include errno.h
#include string.h
#include sys/socket.h
#include arpa/inet.h
#include strings.h
//绑定错误显示和退出
void perr_exit(const char *s)
{perror(s);exit(-1);
}int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{int n;again:if ((n accept(fd, sa, salenptr)) 0) {if ((errno ECONNABORTED) || (errno EINTR))//ECONNABORTED 代表连接失败 ETINTR 代表被信号打断goto again;elseperr_exit(accept error);}return n;
}int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{int n;if ((n bind(fd, sa, salen)) 0)perr_exit(bind error);return n;
}int Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{int n;if ((n connect(fd, sa, salen)) 0)perr_exit(connect error);return n;
}int Listen(int fd, int backlog)
{int n;if ((n listen(fd, backlog)) 0)perr_exit(listen error);return n;
}int Socket(int family, int type, int protocol)
{int n;if ((n socket(family, type, protocol)) 0)perr_exit(socket error);return n;
}ssize_t Read(int fd, void *ptr, size_t nbytes)
{ssize_t n;again:if ( (n read(fd, ptr, nbytes)) -1) {if (errno EINTR)//被信号打断应该继续读goto again;elsereturn -1;}return n;
}ssize_t Write(int fd, const void *ptr, size_t nbytes)
{ssize_t n;again:if ( (n write(fd, ptr, nbytes)) -1) {if (errno EINTR)goto again;elsereturn -1;}return n;
}int Close(int fd)
{int n;if ((n close(fd)) -1)perr_exit(close error);return n;
}/*参三: 应该读取的字节数*/
ssize_t Readn(int fd, void *vptr, size_t n)
{size_t nleft; //usigned int 剩余未读取的字节数ssize_t nread; //int 实际读到的字节数char *ptr;ptr vptr;nleft n;while (nleft 0) {if ((nread read(fd, ptr, nleft)) 0) {if (errno EINTR)nread 0;elsereturn -1;} else if (nread 0)break;nleft - nread;//防止一次数据没有读完ptr nread;//指针需要向后移动}return n - nleft;
}ssize_t Writen(int fd, const void *vptr, size_t n)
{size_t nleft;ssize_t nwritten;const char *ptr;ptr vptr;nleft n;while (nleft 0) {if ( (nwritten write(fd, ptr, nleft)) 0) {if (nwritten 0 errno EINTR)nwritten 0;elsereturn -1;}nleft - nwritten;ptr nwritten;}return n;
}static ssize_t my_read(int fd, char *ptr)
{static int read_cnt;static char *read_ptr;static char read_buf[100];//定义了100的缓冲区if (read_cnt 0) {
again://使用缓冲区可以避免多次从底层缓冲读取数据--为了提高效率if ( (read_cnt read(fd, read_buf, sizeof(read_buf))) 0) {if (errno EINTR)goto again;return -1;} else if (read_cnt 0)return 0;read_ptr read_buf;}read_cnt--;*ptr *read_ptr;//从缓冲区取数据return 1;
}
//读取一行
ssize_t Readline(int fd, void *vptr, size_t maxlen)
{ssize_t n, rc;char c, *ptr;ptr vptr;for (n 1; n maxlen; n) {if ( (rc my_read(fd, c)) 1) {*ptr c;if (c \n)//代表任务完成break;} else if (rc 0) {//对端关闭*ptr 0;//0 \0return n - 1;} elsereturn -1;}*ptr 0;return n;
}int tcp4bind(short port,const char *IP)
{struct sockaddr_in serv_addr;int lfd Socket(AF_INET,SOCK_STREAM,0);bzero(serv_addr,sizeof(serv_addr));//清空serv_addr地址 对比 memset()if(IP NULL){//如果这样使用 0.0.0.0,任意ip将可以连接serv_addr.sin_addr.s_addr INADDR_ANY;}else{if(inet_pton(AF_INET,IP,serv_addr.sin_addr.s_addr) 0){perror(IP);//转换失败exit(1);}}serv_addr.sin_family AF_INET;serv_addr.sin_port htons(port);int opt 1;setsockopt(lfd,SOL_SOCKET,SO_REUSEADDR,opt,sizeof(opt));Bind(lfd,(struct sockaddr *)serv_addr,sizeof(serv_addr));return lfd;
} 粘包的概念
粘包: 多次数据发送, 收尾相连, 接收端接收的时候不能正确区分第一次发 送多少, 第二次发送多少.
粘包问题分析和解决??
方案1: 包头数据
如4位的数据长度数据 ----------- 00101234567890
其中0010表示数据长度, 1234567890表示10个字节长度的数据.
另外, 发送端和接收端可以协商更为复杂的报文结构, 这个报文结 构就相当于双方约定的一个协议.
方案2: 添加结尾标记.
如结尾最后一个字符为\n \$等.
方案3: 数据包定长 如发送方和接收方约定, 每次只发送128个字节的内容, 接收方接收定 长128个字节就可以了.
wrap.c代码解读和分析.
要求能看懂代码, 会使用即可.
4 高并发服务器
如何支持多个客户端---支持多并发的服务器
由于accept和read函数都会阻塞, 如当read的时候, 不能调用accept接受新的连接, 当accept阻塞等待的时候不能read读数据. 第一种方案: 使用多进程, 可以让父进程接受新连接, 让子进程处理与客户端通信
思路: 让父进程accept接受新连接, 然后fork子进程, 让子进程处理通信, 子进程处理完成后退出, 父进程使用SIGCHLD信号回收子进程.
代码实现:
#include stdlib.h
#include stdio.h
#include string.h
#include unistd.h
#include sys/types.h
#include string.h
#include ctype.h
#include arpa/inet.h
#include netinet/in.h
#include warp.hint main()
{// 创建socketint lfd Socket(AF_INET, SOCK_STREAM, 0);// 绑定struct sockaddr_in serv;bzero(serv, sizeof(serv));serv.sin_family AF_INET;serv.sin_port htons(8888);serv.sin_addr.s_addr htonl(INADDR_ANY);Bind(lfd, (struct sockaddr *)serv, sizeof(serv));pid_t pid;// 设置g监听Listen(lfd, 128);int cfd;struct sockaddr_in client;socklen_t len;char sIP[16];while (1){lensizeof(client);memset(sIP,0x00,sizeof(sIP));// 接受新的连接,创建一个新的子进程g让子进程完成数据的收发的工作cfd Accept(lfd, (struct sockaddr *)client, len);//打印客户端的ip地址printf(client:[%s],[%d]\n,inet_ntop(AF_INET,client.sin_addr.s_addr,sIP,sizeof(sIP)),ntohs(client.sin_port));pid fork();if (pid 0){perror(fork error);exit(-1);}// 父进程else if (pid 0){// 关闭g通信文件描述符cfdclose(cfd);}// 子进程 --收发数据else if (pid 0){// 关闭监听文件描述符号close(lfd);int n;int i 0;char buf[1024];while (1){// 读数据n Read(cfd, buf, sizeof(buf));if (n 0){printf(read error or client closed,n[%d]\n, n);break;}//将收到的数据再服务端显示出来printf([%d] -- n[%d],buf[%s]\n,ntohs(client.sin_port),n,buf);// 将小写转换为大写 之后再发送给客户端for (i 0; i n; i){buf[i] toupper(buf[i]);}// 发送数据Write(cfd, buf, n);}close(cfd);// 停止n不让子进程继续创建exit(0);}}// 关闭监听文件描述符close(lfd);return 0;//note ::父子进程可以共享的内容有哪些 /*文件描述符子进程是复制父进程的文件描述符mmap 共享映射区*/
} 第二种方案: 使用多线程, 让主线程接受新连接, 让子线程处理与客户端通信; 使用多线程要将线程设置为分离属性, 让线程在退出之后自己回收资源. #includestdlib.h
#includestdio.h
#includestring.h
#includeunistd.h
#include sys/types.h
#includestring.h
#include arpa/inet.h
#include netinet/in.h
#includectype.h
#includepthread.h
#include warp.h//子线程回调函数
void *thread_work(void * arg){int cfd*(int *)arg;int n;int i;char buf[1024];while(1){//read 数据memset(buf,0x00,sizeof(buf));nRead(cfd,buf,sizeof(buf));if(n0){printf(read error or client close,n[%d]\n,n);break;}printf(n[%d],buf[%s]\n,n,buf);//将数据转换成大写再发送给客户端。for(i0;in;i){buf[i]toupper(buf[i]);}//发送数据// printf(in);Write(cfd,buf,n);}//关闭通信文件描述符close(cfd);pthread_exit(NULL);}/*\ 续航符
*/int main()
{//创建socketint lfdSocket(AF_INET,SOCK_STREAM,0);//设置端口复用 int opt1;setsockopt(lfd,SOL_SOCKET,SO_REUSEADDR,opt,sizeof(int));struct sockaddr_in serv;bzero(serv,sizeof(serv));serv.sin_familyAF_INET;serv.sin_porthtons(8888);serv.sin_addr.s_addrhtonl(INADDR_ANY);Bind(lfd,(struct sockaddr *)serv,sizeof(serv));//设置监听Listen(lfd,128);int cfd;pthread_t threadID;while (1){//接受新的连接cfdAccept(lfd,NULL,NULL);//创建子线程pthread_create(threadID,NULL,thread_work,cfd);//i设置子线程为分离属性pthread_detach(threadID);}//关闭i监听i文件描述符close(lfd);return 0;
}/*1.子线程可以关闭监听文件描述符吗原因是lfd 子线程和主线程共享文件描述符而不是复制的。2.主线程不能 不能关闭cfd.原因是主线程和子线程共享一个cfd,close() 之后就会被真的关闭,他俩共享一个cfd 不是复制的cfd.3.多个子线程可以共享cfd 嘛会发生什么问题。一个i·最后一个线程cfd 覆盖了之前的内容 struct INFO{int cfd;pthread_t threadID;struct sockaddr_in client;}struct INFO info[100];
*/
//多线程可以共享哪些东西 思考: 如何不使用多进程或者多线程完成多个客户端的连接请求
可以将accept和read函数设置为非阻塞, 调用fcntl函数可以将文件描述符设置为非阻塞, 让后再while循环中忙轮询.
