linux网卡堵塞,linux c++ 网络测试-- 阻塞测试

首先说下问题的疑惑点在哪里?

1.客户端用户不发数据，服务器阻塞udp socket ，recvfrom函数是否会一直阻塞?

来，我们来写一端代码，方便我们测试，— 一定要多写代码，再简单都要写，理解和你认为你理解了，这之间的鸿沟，看似简单，实则非常深，而且不自己写一遍，心里真的是很没底的.

#include #include #include #include #include #include #include #define bind_local_port 9996

int main()

{

int sfd = socket(AF_INET,SOCK_DGRAM,0);

//bind port -- struct sockaddr_in 在头文件里

struct sockaddr_in addr;

addr.sin_family = AF_INET;

addr.sin_port = htons(bind_local_port);

addr.sin_addr.s_addr = INADDR_ANY;

if ( bind( sfd , (struct sockaddr*)&addr, sizeof(addr) ) < 0 )

{

perror("bind fail");

exit(1);

}

struct sockaddr_in client;

int len;

char recvbuf [2000];

int recvlen = recvfrom(sfd,recvbuf ,sizeof(recvbuf) , 0 ,(struct sockaddr*)&client , (socklen_t*)&len) ;

if(recvlen < 0)

{

switch(errno)

{

case EAGAIN:

{

printf("EAGIN event\n");

}

break;

// case EWOULDBLOCK:

// {

// printf("EWOULDBLOCK event\n");

// }

// break;

case ECONNREFUSED:

{

printf("ECONNREFUSED event\n");

}

break;

case EFAULT://内核内存错误---

{

printf("EFAULT event\n");

}

break;

case EINTR://被信号打断

{

printf("EINTR event\n");

}

break;

case ENOMEM:

{

printf("ENOMEM event\n");

}

break;

default:

{

printf("unknow error event:%d \n" , errno);

}

break;

}

}

//现在我没有用超时的来判断，我就是一个阻塞的udp socket

//测试:

//1.如果我一直阻塞，那么这里是否在一直等待.

//2.如果我在阻塞函数里设置了超时,是否回直接返回，我怎么判断返回是超时触发的?

//3.超时触发后，如果客户端直接中断连接了，那么服务器端怎么检测出来？-- 或者说超时之后，服务器是否还能够检测出来?

if(recvlen < 0)

{

//判断errno

}

printf("recv len: %d \n" , recvlen);

close(sfd);

return 0;

}

测试结论:

阻塞函数，如果不设置超时，那么是真的会一直阻塞，直到有数据过来!!!

2.如果这个时候我们设置了超时时间(注意此阶段，客户端依然不发送任何数据)，那么阻塞函数recvfrom的反馈是怎样的？ 非正常返回后，我们如何判断是超时导致的错误呢?

到了这一部，我们需要给我们的sock属性设置超时时间。

好我们来设置超时时间为2秒.

//设置超时属性

struct timeval rto;

rto.tv_sec = 2;

rto.tv_usec = 0;

setsockopt(sfd,SOL_SOCKET,SO_RCVTIMEO,(void*)&rto,sizeof(rto));

在recv的时候，我们监控时间属性:

//开始时间

struct timeval tb;

gettimeofday(&tb,NULL);

int recvlen = recvfrom(sfd,recvbuf ,sizeof(recvbuf) , 0 ,(struct sockaddr*)&client , (socklen_t*)&len) ;

//recv time out结束属性

struct timeval te;

gettimeofday(&te,NULL);

printf("second:%d usec:%d \n" , te.tv_sec - tb.tv_sec , te.tv_usec - tb.tv_usec);

结论:

从结果来看，很明显了，返回-1， errno为EAGIN,系统回告诉你，再次去读取数据.

3.在recv的过程中，如果客户端中断了连接，那么recv函数返回的情况是怎样的?

这里我们直接换用TCP连接进行测试，效果更加直接.

直接说结果:

如果说tcp stream，如果返回0，那么代表流已经终止了，返回-1代表发生了异常.

但是在udp里面，因为udp是无连接的，所以udp其实是存在接收0个长度的数据的可能性的.

这里我们一定要看官方的文档api说明.

RETURN VALUE

These calls return the number of bytes received, or -1 if an error

occurred. In the event of an error, errno is set to indicate the

error.

When a stream socket peer has performed an orderly shutdown, the return

value will be 0 (the traditional "end-of-file" return).

Datagram sockets in various domains (e.g., the UNIX and Internet

domains) permit zero-length datagrams. When such a datagram is

received, the return value is 0.

如果tcp stream 的 recv 超时呢,返回的是-1，并且errno = EAGIN,告诉我们继续去读取数据,这里和udp上面是或的是一致的.

总结下，就是就算recv失败，除非你自己调用close, 否则server端的管道是不会关闭的，但是server可以知道连接上的管道是否close掉了.

Server

gcc -o block_write block_write.c -lpthread

#include #include #include #include #include #include #include #include //write阻塞测试

#define SERVER_PORT 9995

#define MAX_SOCKETS 256

void* user_coming( void *args)

{

int cfd = *((int*)(args));

//内环缓冲区，默认的的缓冲区大小配置在: 系统默认在 cat /proc/sys/net/ipv4/tcp_wmem

int default_recv_buf_size ;

int len = 0;

getsockopt(cfd,SOL_SOCKET,SO_RCVBUF,&default_recv_buf_size,(socklen_t*)&len);

printf("sock recv default size:%d \n" , default_recv_buf_size);

//上面获取的用户进程的写缓冲区 。

uint8_t pkt [1024];

int size_writed = 0;

int c ;

//文档说明:https://linux.die.net/man/3/write

while(1)

{

fprintf(stderr, "start write ， size writed:%d \n", size_writed);

c = write(cfd,pkt,sizeof(pkt));

if ( c == -1)

{

switch (errno)

{

case EAGAIN:

{

fprintf(stderr," EAGAIN \n");

}

break;

case EBADF:

{

fprintf(stderr, "EBADF \n");

}

break;

case EFBIG:

{

fprintf(stderr, "EFBIG \n");

}

break;

case EINTR:

{

fprintf(stderr, "EINTR \n");

}

break;

case EIO:

{

fprintf(stderr, "EIO \n");

}

break;

case ENOSPC:

{

fprintf(stderr, "ENOSPC \n");

}

break;

case EPIPE:

{

fprintf(stderr, "EPIPE \n");

}

break;

case ERANGE:

{

fprintf(stderr, "ERANGE \n");

}

break;

default:

fprintf(stderr, "Errno unknow: %d \n" , errno);

break;

}

break;

}

//注意事项:

//1.write函数的说明，它的返回值是怎么回事?

size_writed += c;

fprintf(stderr, "end write ， size writed:%d \n", size_writed);

}

fprintf(stderr, "exit client \n");

close(cfd);

}

int main( int argc ,char *argv[])

{

int sfd = 0;

int ret = 0;

sfd = socket(AF_INET,SOCK_STREAM,0);

struct sockaddr_in addr;

addr.sin_family = AF_INET;

addr.sin_addr.s_addr = INADDR_ANY;

addr.sin_port = htons(SERVER_PORT);

ret = bind(sfd, (struct sockaddr *)&addr, sizeof(struct sockaddr_in));

if( ret < 0 )

{

fprintf(stderr,"Error bind(). \n");

goto close;

}

ret = listen(sfd,MAX_SOCKETS);

if (ret < 0)

{

fprintf(stderr, "Error listen(). \n");

goto close;

}

while(1)

{

struct sockaddr_in clientAddr;

int len;

int cfd = accept(sfd,(struct sockaddr_in *)&clientAddr, (socklen_t*)&len );

if(cfd < 0)

{

break;

}

//创建线程

pthread_t cthr_id;

pthread_create(&cthr_id,NULL,user_coming,&cfd);

}

close:

close(sfd);

return 0;

}

结论:

如果客户端不接收，服务器会一直发送，一直到把内核的缓冲区塞满，塞满之后，此时再次write就会阻塞住，直到内核缓冲区中有空间可以继续写数据了.

如果客户端关闭了和服务器的连接，那么write就会返回-1，errno返回ECONNRESET (=104),

ECONNRESET

A write was attempted on a socket that is not connected.