主要作用: 滑动窗口主要是进行流量控制的.
如果发送端发送的速度较快,接收端接收到数据后处理的速度较慢,而接收缓冲区的大小是固定的,就会导致接收缓冲区满而丢失数据。TCP协议通过“滑动窗口(Sliding Window)”机制解决这一问题。
图中的win表示告诉对方我这边缓冲区大小是多少, mss表示告诉对方我这边最多一次可以接收多少数据, 你最好不要超过这个长度.
例如:socket—> Socket Tcp_socket
wrap.h
#ifndef __WRAP_H_
#define __WRAP_H_
#include
#include
#include
#include
#include
#include
#include
#include
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
#include
#include
#include
#include
#include
#include
#include
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;
}
阻塞函数在阻塞期间若收到信号, 会被信号终端, errno设置为EINTR,这个错误不应该看成一个错误.
粘包: 多次数据发送, 收尾相连, 接收端接收的时候不能正确区分第一次发送多少, 第二次发送多少.
粘包问题分析和解决??
方案1: 包头+数据
如4位的数据长度+数据 -----------> 00101234567890 其中0010表示数据长度,1234567890表示10个字节长度的数据.
另外, 发送端和接收端可以协商更为复杂的报文结构, 这个报文结构就相当于双方约定的一个协议.
方案2: 添加结尾标记.
如结尾最后一个字符为\n\$等.
方案3: 数据包定长
如发送方和接收方约定, 每次只发送128个字节的内容, 接收方接收定长128个字节就可以了.
while(1)
{
cfd = accept();
while(1)
{
n = read(cfd, buf, sizeof(buf));
if(n<=0)
{
break;
}
}
}
存在问题1:
已连接客户端,但是客户端不发送任何数据,read函数处于阻塞状态,导致新的客户端无法连接。
存在问题2:
有多个客户端连接,分不清是哪个客户端发来的数据。
解决办法1:
将cfd设置为非阻塞: fcntl
假如有多个客户端连接请求, cfd只会保留最后一个文件描述符的值
解决方法2:
使用多进程,让父进程监听接受新的连接, 子进程处理新的连接(接收和发送数据);父进程还负责回收子进程
处理流程:
1 创建socket, 得到一个监听的文件描述符lfd—socket()
2 将lfd和IP和端口port进行绑定-----bind();
3 设置监听----listen()
4 进入while(1)
while(1)
{
//等待有新的客户端连接到来
cfd = accept();
//fork一个子进程, 让子进程去处理数据
pid = fork();
if(pid<0)
{
exit(-1);
}
else if(pid>0)
{
//关闭通信文件描述符cfd
close(cfd);
}
else if(pid==0)
{
//关闭监听文件描述符
close(lfd);
//收发数据
while(1)
{
//读数据
n = read(cfd, buf, sizeof(buf));
if(n<=0)
{
break;
}
//发送数据给对方
write(cfd, buf, n);
}
close(cfd);
//下面的exit必须有, 防止子进程再去创建子进程
exit(0);
}
}
close(lfd);
mult-process.c
//多进程版本的网络服务器
#include
#include
#include
#include
#include
#include
#include
#include
#include "wrap.h"
int main()
{
//创建socket
int 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));
//设置监听
Listen(lfd, 128);
pid_t pid;
int cfd;
char sIP[16];
socklen_t len;
struct sockaddr_in client;
while(1)
{
//接受新的连接
len = sizeof(client);
memset(sIP, 0x00, sizeof(sIP));
cfd = Accept(lfd, (struct sockaddr *)&client, &len);
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)
{
//关闭通信文件描述符cfd
close(cfd);
}
else if(pid==0)
{
//关闭监听文件描述符
close(lfd);
int i=0;
int n;
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("client:[%s] [%d]\n", inet_ntop(AF_INET, &client.sin_addr.s_addr, sIP, sizeof(sIP)), ntohs(client.sin_port));
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);
}
//关闭cfd
close(cfd);
exit(0);
}
}
//关闭监听文件描述符
close(lfd);
return 0;
}
还需要添加的功能: 父进程使用SIGCHLD信号完成对子进程的回收
注意点: accept或者read函数是阻塞函数, 会被信号打断, 此时不应该视为一个错误.errno=EINTR
父子进程能够共享的:
文件描述符(子进程复制父进程的文件描述符)
mmap共享映射区
while(1)
{
//接受新的客户端连接请求
cfd = accept();
//创建一个子线程
pthread_create(&threadID, NULL, thread_work, &cfd);
//设置线程为分离属性
pthread_detach(threadID);
}
close(lfd);
子线程执行函数:
void *thread_work(void *arg)
{
//获得参数: 通信文件描述符
int cfd = *(int *)arg;
while(1)
{
//读数据
n = read(cfd, buf, sizeof(buf));
if(n<=0)
{
break;
}
//发送数据
write(cfd, buf, n);
}
close(cfd);
}
muti-thread.c
//多线程版本的高并发服务器
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "wrap.h"
//子线程回调函数
void *thread_work(void *arg)
{
sleep(20);
int cfd = *(int *)arg;
printf("cfd==[%d]\n", cfd);
int i;
int n;
char buf[1024];
while(1)
{
//read数据
memset(buf, 0x00, sizeof(buf));
n = Read(cfd, buf, sizeof(buf));
if(n<=0)
{
printf("read error or client closed,n==[%d]\n", n);
break;
}
printf("n==[%d], buf==[%s]\n", n, buf);
for(i=0; i<n; i++)
{
buf[i] = toupper(buf[i]);
}
//发送数据给客户端
Write(cfd, buf, n);
}
//关闭通信文件描述符
close(cfd);
pthread_exit(NULL);
}
int main()
{
//创建socket
int lfd = Socket(AF_INET, SOCK_STREAM, 0);
//设置端口复用
int opt = 1;
setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));
//绑定
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));
//设置监听
Listen(lfd, 128);
int cfd;
pthread_t threadID;
while(1)
{
//接受新的连接
cfd = Accept(lfd, NULL, NULL);
//创建子线程
pthread_create(&threadID, NULL, thread_work, &cfd);
//设置子线程为分离属性
pthread_detach(threadID);
}
//关闭监听文件描述符
close(lfd);
return 0;
}
问题:
struct INFO
{
int cfd;
pthread_t threadID;
struct sockaddr_in client;
};
struct INFO info[100];
//初始化INFO数组
for(i=0; i<100; i++)
{
info[i].cfd=-1;
}
for(i=0; i<100; i++)
{
if(info[i].cfd==-1)
{
//这块内存可以使用
}
}
if(i==100)
{
//拒绝接受新的连接
close(cfd);
}
改进:
mult_process_adv.c
//多进程版本的服务器
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "wrap.h"
//信号处理函数
void waitchild(int signo)
{
pid_t wpid;
while(1)
{
wpid = waitpid(-1, NULL, WNOHANG);
if(wpid>0)
{
printf("child exit, wpid==[%d]\n", wpid);
}
else if(wpid==0 || wpid==-1)
{
break;
}
}
}
int main()
{
//创建socket
int lfd = Socket(AF_INET, SOCK_STREAM, 0);
//设置端口复用
int opt = 1;
setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));
//绑定-bind
struct sockaddr_in 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));
//监听-listen
Listen(lfd, 128);
//阻塞SIGCHLD信号
sigset_t mask;
sigemptyset(&mask);
sigaddset(&mask, SIGCHLD);
sigprocmask(SIG_BLOCK, &mask, NULL);
int cfd;
socklen_t len;
char sIP[16];
pid_t pid;
struct sockaddr_in client;
while(1)
{
//等待客户端连接--accept
memset(sIP, 0x00, sizeof(sIP));
len = sizeof(client);
bzero(&client, sizeof(client));
cfd = Accept(lfd, (struct sockaddr *)&client, &len);
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");
close(lfd);
return -1;
}
else if(pid>0) //父进程
{
//关闭通信的文件描述符
close(cfd);
//注册SIGCHLD信号处理函数
struct sigaction act;
act.sa_handler = waitchild;
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
sigaction(SIGCHLD, &act, NULL);
//解除对SIGCHLD信号的阻塞
sigprocmask(SIG_UNBLOCK, &mask, NULL);
}
else if(pid==0) //子进程
{
//关闭监听文件描述符
close(lfd);
int i = 0;
int n = 0;
char buf[1024];
while(1)
{
memset(buf, 0x00, sizeof(buf));
n = Read(cfd, buf, sizeof(buf));
if(n<=0)
{
printf("read error or client closed, n==[%d]\n", n);
break;
}
printf("read over, n==[%d],buf==[%s]\n", n, buf);
for(i=0; i<n; i++)
{
buf[i] = toupper(buf[i]);
}
write(cfd, buf, n);
}
close(cfd);
exit(0);
}
}
//关闭监听文件描述符
close(lfd);
return 0;
}
//多线程版本的服务器
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "wrap.h"
typedef struct info
{
int cfd; //若为-1表示可用, 大于0表示已被占用
int idx;
pthread_t thread;
struct sockaddr_in client;
}INFO;
INFO thInfo[1024];
//线程执行函数
void *thread_work(void *arg)
{
INFO *p = (INFO *)arg;
printf("idx==[%d]\n", p->idx);
char sIP[16];
memset(sIP, 0x00, sizeof(sIP));
printf("new client:[%s][%d]\n", inet_ntop(AF_INET, &(p->client.sin_addr.s_addr), sIP, sizeof(sIP)), ntohs(p->client.sin_port));
int n;
int cfd = p->cfd;
struct sockaddr_in client;
memcpy(&client, &(p->client), sizeof(client));
char buf[1024];
while(1)
{
memset(buf, 0x00, sizeof(buf));
//读数据
n = Read(cfd, buf, sizeof(buf));
if(n<=0)
{
printf("read error or client closed, n==[%d]\n", n);
Close(cfd);
p->cfd =-1; //设置为-1表示该位置可用
pthread_exit(NULL);
}
for(int i=0; i<n; i++)
{
buf[i] = toupper(buf[i]);
}
//发送数据
Write(cfd, buf, n);
}
}
void init_thInfo()
{
int i = 0;
for(i=0; i<1024; i++)
{
thInfo[i].cfd = -1;;
}
}
int findIndex()
{
int i;
for(i=0; i<1024; i++)
{
if(thInfo[i].cfd==-1)
{
break;
}
}
if(i==1024)
{
return -1;
}
return i;
}
int main()
{
//创建socket
int lfd = Socket(AF_INET, SOCK_STREAM, 0);
//设置端口复用
int opt = 1;
setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));
//绑定--将lfd 和 IP PORT绑定
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));
//监听
Listen(lfd, 128);
//初始化
init_thInfo();
int cfd;
int ret;
int idx;
socklen_t len;
pthread_t thread;
struct sockaddr_in client;
while(1)
{
len = sizeof(client);
bzero(&client, sizeof(client));
//获得一个新的连接
cfd = Accept(lfd, (struct sockaddr *)&client, &len);
//创建一个子进程, 让子进程处理连接---接收数据和发送数据
//找数组中空闲的位置
idx = findIndex();
if(idx==-1)
{
Close(cfd);
continue;
}
//对空闲位置的元素的成员赋值
thInfo[idx].cfd = cfd;
thInfo[idx].idx = idx;
memcpy(&thInfo[idx].client, &client, sizeof(client));
//创建子线程---该子线程完成对数据的收发
ret = pthread_create(&thInfo[idx].thread, NULL, thread_work, &thInfo[idx]);
if(ret!=0)
{
printf("create thread error:[%s]\n", strerror(ret));
exit(-1);
}
//设置子线程为分离属性
pthread_detach(thInfo[idx].thread);
}
Close(lfd);
return 0;
}