3、TCP状态转换图、端口复用、半关闭状态、心跳包、select服务器（linux网络编程）
程序员文章站
2022-06-30 18:20:22
...
TCP状态转换图:
1 三次握手过程:
客户端: SYN_SENT—connect()
服务端: LISTEN–listen() SYN_RCVD
当三次握手完成后, 都处于ESTABLISHED状态
2 数据传输过程中状态不发生变化, 都是ESTABLISHED状态
3 四次挥手过程:
主动关闭方: FIN_WAIT_T FIN_WAIT_2 TIME_WAIT
被动关闭方: CLOSE_WAIT LAST_ACK
思考题
1 SYN_SENT状态出现在哪一方? 客户端
2 SYN_RCVD状态出现在哪一方? 服务端
3 TIME_WAIT状态出现在哪一方? 主动关闭方
4 在数据传输的时候没有状态变化.
在这里插入图片描述
TIME_WAIT是如何出现的:
启动服务端, 启动客户端, 连接建好, 而且也可以正常发送数据;
然后先关闭服务端, 服务端就会出现TIME_WAIT状态.
为什么需要2MSL时间:
原因之一: 让四次挥手的过程更可靠, 确保最后一个发送给对方的ACK到达;
若对方没有收到ACK应答, 对方会再次发送FIN请求关闭,
此时在2MS时间内被动关闭方仍然可以发送ACK给对方.
原因之二: 为了保证在2MS时间内, 不能启动相同的SOCKET-PAIR.
TIME_WAIT一定是出现在主动关闭的一方, 也就是说2MS是针对主动关闭一方来说的;
由于TCP有可能存在丢包重传, 丢包重传若发给了已经断开连接之后相同的socket-pair
(该连接是新建的, 与原来的socket-pair完全相同,双方使用的是相同的IP和端口),
这样会对之后的连接造成困扰, 严重可能引起程序异常.
设置端口复用:
int opt = 1;
setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));
shutdown函数和close函数的区别:
1 shutdown可以实现半关闭, close不行
2 shutdown关闭的时候, 不考虑文件描述符的引用计数, 是直接彻底关闭
close考虑文件描述符的引用计数, 调用一次close只是将引用计数减1,
只有减小到0的时候才会真正关闭.
长连接和端连接的概念:
长连接: 连接建立好之后,一直保持连接不关闭
短连接: 连接使用完之后就立刻关闭.
什么是心跳包?
用于监测长连接是否正常的字符串.
在什么情况下使用心跳包?
主要用于监测长连接是否正常.
如何使用心跳包?
通信双方需要协商规则(协议), 如4个字节长度+数据部分
使用select的开发服务端流程:
1 创建socket, 得到监听文件描述符lfd---socket()
2 设置端口复用-----setsockopt()
3 将lfd和IP PORT绑定----bind()
4 设置监听---listen()
5 fd_set readfds; //定义文件描述符集变量
fd_set tmpfds;
FD_ZERO(&readfds); //清空文件描述符集变量
FD_SET(lfd, &readfds);//将lfd加入到readfds集合中;
maxfd = lfd;
while(1)
{
tmpfds = readfds;
nready = select(maxfd+1, &tmpfds, NULL, NULL, NULL);
if(nready<0)
{
if(errno==EINTR)//被信号中断
{
continue;
}
break;
}
//有客户端连接请求到来
if(FD_ISSET(lfd, &tmpfds))
{
//接受新的客户端连接请求
cfd = accept(lfd, NULL, NULL);
//将cfd加入到readfds集合中
FD_SET(cfd, &readfds);
//修改内核监控的文件描述符的范围
if(maxfd<cfd)
{
maxfd = cfd;
}
if(--nready==0)
{
continue;
}
}
//有客户端数据发来
for(i=lfd+1; i<=maxfd; i++)
{
if(FD_ISSET(i, &tmpfds))
{
//read数据
n = read(i, buf, sizeof(buf));
if(n<=0)
{
close(i);
//将文件描述符i从内核中去除
FD_CLR(i, &readfds);
}
//write应答数据给客户端
write(i, buf, n);
}
if(--nready==0)
{
break;
}
}
close(lfd);
return 0;
}
wrap.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.h>
void 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);
#endif
wrap.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))
goto again;
else
perr_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;
else
return -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;
else
return -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;
else
return -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;
else
return -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];
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;
return n - 1;
} else
return -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));
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);
Bind(lfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
return lfd;
}
//select.c
//IO多路复用技术select函数的使用
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/types.h>
#include<unistd.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<ctype.h>
//#include<pthread.h>
#include<sys/select.h>
#include<errno.h>
#include"wrap.h"
int main()
{
int lfd = Socket(AF_INET,SOCK_STREAM,0);//创建socket
//设置端口复用
int opt = 1;
setsockopt(lfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(int));
//绑定bind
struct sockaddr_in svraddr; //bzero(&serv,sizeof(serv));
svraddr.sin_family= AF_INET;
svraddr.sin_port = htons(8888);
svraddr.sin_addr.s_addr = htonl(INADDR_ANY);
Bind(lfd,(struct sockaddr *)&svraddr,sizeof(svraddr));
//监听
Listen(lfd,128);
//定义fd_set类型变量
fd_set tmpfds;
fd_set readfds; //要监控的文件描述符集
//清空tmpfds和readfds文件描述符集
FD_ZERO(&tmpfds);
FD_ZERO(&readfds);
//lfd加入到readfds中，委托内核监控
FD_SET(lfd,&readfds);
int maxfd =lfd;
int nready;
int cfd;
int i;
int sockfd;
int n;
char buf[1024];
while(1)
{
tmpfds = readfds;
//tmpfds是输入输出参数：
//输入：告诉内核要监测哪些文件描述符
//输出：内核告诉应用程序有哪些文件描述符发生了变化
nready = select(maxfd+1,&tmpfds,NULL,NULL,NULL);
if(nready<0)
{
if(errno==EINTR)
{
continue;
}
break;
}
//有客户端连接请求到来
if(FD_ISSET(lfd,&tmpfds))
{
//接受新的客户端连接请求
cfd = Accept(lfd, NULL,NULL);
//将cfd加入到 readfds集合中
FD_SET(cfd,&readfds);
//修改内核的监控范围
if(maxfd<cfd)
{
maxfd = cfd;
}
if(--nready==0)
{
continue;
}
}
//有数据发来的情况
for(i=lfd+1;i<=maxfd;i++)
{
sockfd = i;
//判断sockfd文件描述符是否有变化
if(FD_ISSET(sockfd,&tmpfds))
{
//读数据
memset(buf,0x00,sizeof(buf));
n = Read(sockfd,buf,sizeof(buf));
if(n<=0)
{
//关闭连接//perror("read over");
close(sockfd);
//将sockfd从readfds从中删除
FD_CLR(sockfd,&readfds);
}
else
{
printf("[%d]:[%s]\n",n,buf);
int k=0;
for(k=0;k<n;k++)
{
buf[k]= toupper(buf[k]);
}
Write(sockfd,buf,n);
}
if(--nready<=0)
{
break;
}
}
}
}
close(lfd);
return 0;
}
代码优化方向:
int client[1024]
for()
{
client[i] = -1;
}
1 将通信文件描述符保存到一个整形数组中, 使用一个变量记录
数组中最大元素的下标maxi.
2 如果数组中有无效的文件描述符, 直接跳过
//select_advance.c
//IO多路复用技术select函数的使用
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/select.h>
#include<ctype.h>
int main()
{
int i;
int n;
int lfd;
int cfd;
int ret;
int nready;
int maxfd;//最大的文件描述符
char buf[FD_SETSIZE];
socklen_t len;
int maxi; //有效的文件描述符最大值
int connfd[FD_SETSIZE]; //有效的文件描述符数组
fd_set tmpfds, rdfds; //要监控的文件描述符集
struct sockaddr_in svraddr, cliaddr;
//创建socket
lfd = socket(AF_INET, SOCK_STREAM, 0);
if(lfd<0)
{
perror("socket error");
return -1;
}
//允许端口复用
int opt = 1;
setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));
//绑定bind
svraddr.sin_family = AF_INET;
svraddr.sin_addr.s_addr = htonl(INADDR_ANY);
svraddr.sin_port = htons(8888);
ret = bind(lfd, (struct sockaddr *)&svraddr, sizeof(struct sockaddr_in));
if(ret<0)
{
perror("bind error");
return -1;
}
//监听listen
ret = listen(lfd, 5);
if(ret<0)
{
perror("listen error");
return -1;
}
//文件描述符集初始化
FD_ZERO(&tmpfds);
FD_ZERO(&rdfds);
//将lfd加入到监控的读集合中
FD_SET(lfd, &rdfds);
//初始化有效的文件描述符集, 为-1表示可用, 该数组不保存lfd
for(i=0; i<FD_SETSIZE; i++)
{
connfd[i] = -1;
}
maxfd = lfd;
len = sizeof(struct sockaddr_in);
//将监听文件描述符lfd加入到select监控中
while(1)
{
//select为阻塞函数,若没有变化的文件描述符,就一直阻塞,若有事件发生则解除阻塞,函数返回
//select的第二个参数tmpfds为输入输出参数,调用select完毕后这个集合中保留的是发生变化的文件描述符
tmpfds = rdfds;
nready = select(maxfd+1, &tmpfds, NULL, NULL, NULL);
if(nready>0)
{
//发生变化的文件描述符有两类, 一类是监听的, 一类是用于数据通信的
//监听文件描述符有变化, 有新的连接到来, 则accept新的连接
if(FD_ISSET(lfd, &tmpfds))
{
cfd = accept(lfd, (struct sockaddr *)&cliaddr, &len);
if(cfd<0)
{
if(errno==ECONNABORTED || errno==EINTR)
{
continue;
}
break;
}
//先找位置, 然后将新的连接的文件描述符保存到connfd数组中
//for(i=0; i<FD_SETSIZE; i++) 原作者 误
for(i=lfd+1; i<FD_SETSIZE; i++)
{
if(connfd[i]==-1)
{
connfd[i] = cfd;
break;
}
}
//若连接总数达到了最大值,则关闭该连接
if(i==FD_SETSIZE)
{
close(cfd);
printf("too many clients, i==[%d]\n", i);
//exit(1);
continue;
}
//确保connfd中maxi保存的是最后一个文件描述符的下标
if(i>maxi)
{
maxi = i;
}
//打印客户端的IP和PORT
char sIP[16];
memset(sIP, 0x00, sizeof(sIP));
printf("receive from client--->IP[%s],PORT:[%d]\n", inet_ntop(AF_INET, &cliaddr.sin_addr.s_addr, sIP, sizeof(sIP)), htons(cliaddr.sin_port));
//将新的文件 描述符加入到select监控的文件描述符集合中
FD_SET(cfd, &rdfds);
if(maxfd<cfd)
{
maxfd = cfd;
}
//若没有变化的文件描述符,则无需执行后续代码
if(--nready<=0)
{
continue;
}
}
//下面是通信的文件描述符有变化的情况
//只需循环connfd数组中有效的文件描述符即可, 这样可以减少循环的次数
for(i=0; i<=maxi; i++)//原作者
//for(i=lfd+1; i<=maxi; i++)//该
{
int sockfd = connfd[i];
//数组内的文件描述符如果被释放有可能变成-1
if(sockfd==-1)
{
continue;
}
if(FD_ISSET(sockfd, &tmpfds))
{
memset(buf, 0x00, sizeof(buf));
n = read(sockfd, buf, sizeof(buf));
if(n<0)
{
perror("read over");
close(sockfd);
FD_CLR(sockfd, &rdfds);
connfd[i] = -1; //将connfd[i]置为-1,表示该位置可用
}
else if(n==0)
{
printf("client is closed\n");
close(sockfd);
FD_CLR(sockfd, &rdfds);
connfd[i] = -1; //将connfd[i]置为-1,表示该位置可用
}
else
{
printf("[%d]:[%s]\n", n, buf);
int k=0;//自己加
for(k=0;k<n;k++)//自己加
{
buf[k]= toupper(buf[k]);//自己加
}
write(sockfd, buf, n);
}
if(--nready<=0)
{
break; //注意这里是break,而不是continue, 应该是从最外层的while继续循环
}
}
}
}
}
//关闭监听文件描述符
close(lfd);
return 0;
}
上一篇： TCP/IP网络编程学习笔记(六)
下一篇： TCP/IP网络编程学习笔记(9)