Tcp Fast Open测试

最新推荐文章于 2022-11-27 09:33:02 发布
最新推荐文章于 2022-11-27 09:33:02 发布
阅读量1.8k 收藏 1
点赞数

在github上找了一个用C++开启并测试Tcp Fast Open，看完之后来验证。

client：

#include <iostream>
#include <string>
#include <vector>
#include <memory>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <random>
#include <functional>
#include <limits>
#include <algorithm>
#include <thread>
#include <atomic>

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>

#include "common.h"

#define SERVER_PORT "32345"

int getsock(const std::string &server_addr, const std::vector<char> &msg_to_send)
{
    struct addrinfo hint, *res;
    
    std::memset(&hint, 0, sizeof(hint));
    hint.ai_family = AF_UNSPEC;
    hint.ai_socktype = SOCK_STREAM;
    
    int e = getaddrinfo(server_addr.c_str(), SERVER_PORT, &hint, &res);
    if( e == -1 )
    {
        cerror("getaddrinfo");
        std::exit(EXIT_FAILURE);
    }
    int sock;
    struct addrinfo *rp; 
    for( rp = res; rp != nullptr; rp = rp->ai_next )
    {
        // Need to create the socket again when EINTR is returned
redo:
        sock = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
        if( sock == -1 )
            continue;
        ssize_t r = sendto(sock, &msg_to_send[0], msg_to_send.size(),
                MSG_FASTOPEN, rp->ai_addr, rp->ai_addrlen);
        if( r == -1 && errno == EINTR )
        {
            close(sock);
            goto redo;
        }
        // Exit the loop when sendto succeeded
        if( r != -1 )
            break;
        // Try without TCP FastOpen
        r = connect(sock, rp->ai_addr, rp->ai_addrlen);
        if( r == -1 && errno == EINTR )
        {
            close(sock);
            goto redo;
        }
        if( r != -1 )
        {
            ssize_t sent;
            do
            {
                sent = send(sock, &msg_to_send[0], msg_to_send.size(), 0);
            } while( sent == -1 && sent == EINTR );
            // Success
            if( r != -1 )
                break;
        }
        close(sock);
    }
    freeaddrinfo(res);
    if( rp == nullptr )
    {
        std::cerr << "Couldn't get a socket." << std::endl;
        std::exit(EXIT_FAILURE);
    }
    return sock;
}

void send_recv(const std::string &server_addr, const int msg_size, std::atomic_int &count)
{
    std::vector<char> msg_buf(msg_size), recv_buf(msg_size);
    
    std::mt19937 rand_engine;
    std::uniform_int_distribution<char> distribution(
        std::numeric_limits<char>::min(), std::numeric_limits<char>::max());
    auto generator = std::bind(distribution, rand_engine);
    while( count-- > 0 )
    {
        std::generate(msg_buf.begin(), msg_buf.end(), generator);
        FD sock(getsock(server_addr, msg_buf));
        shutdown(sock, SHUT_WR);
        ssize_t read_bytes = 0;
        while( read_bytes != msg_size )
        {
            ssize_t r;
            do
            {
                r = recv(sock, &recv_buf[read_bytes], recv_buf.size() - read_bytes, 0);
            } while( r == -1 && errno == EINTR );
            if( r == 0 ) break;
            if( r == -1 )
            {
                cerror("recv");
                std::exit(EXIT_FAILURE);
            }
            read_bytes += r;
        }
        if( msg_buf != recv_buf )
            std::cerr << "Receive mismatch." << std::endl;
    }
}

int main(int argc, char *argv[])
{
    if( argc <= 4 )
    {
        std::cerr << "Usage: client [server addr] [msg size] [count] [thread]" << std::endl;
        return EXIT_FAILURE;
    }
    
    std::string server_addr(argv[1]);
    int msg_size = std::atoi(argv[2]);
    std::atomic_int count(std::atoi(argv[3]));
    int nthreads = std::atoi(argv[4]);

    std::vector<std::thread> threads;
    threads.reserve(nthreads);
    for( int i = 0; i < nthreads; ++i )
        threads.push_back(std::thread(send_recv, server_addr, msg_size, std::ref(count)));
    std::for_each(threads.begin(), threads.end(), std::mem_fn(&std::thread::join));
}
server 
#include <iostream>
#include <string>
#include <vector>
#include <memory>
#include <cstdlib>
#include <cstdio>
#include <cstring>

#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/tcp.h>
#include <netdb.h>

#define DEFAULT_PORT "32345"
#define TFO_QLEN 128
#define LISTEN_QLEN 128
#define BUFFER_SIZE 4096
#define MAX_EVENTS 32

#include "common.h"

int open_socket(const std::string &port)
{
    struct addrinfo hint, *res;
    
    std::memset(&hint, 0, sizeof(hint));
    hint.ai_family = AF_UNSPEC;
    hint.ai_socktype = SOCK_STREAM;
    hint.ai_flags = AI_PASSIVE | AI_NUMERICSERV;
    int e = getaddrinfo(nullptr, port.c_str(), &hint, &res);
    if( e != 0 )
    {
        std::cerr << "getaddrinfo: " << gai_strerror(e) << std::endl;
        std::exit(EXIT_FAILURE);
    }
    
    int sock;
    struct addrinfo *rp;
    for( rp = res; rp != nullptr; rp = rp->ai_next )
    {
        sock = socket(rp->ai_family, rp->ai_socktype | SOCK_NONBLOCK, rp->ai_protocol);
        if( sock == -1 ) continue;
        if( bind(sock, rp->ai_addr, rp->ai_addrlen) == 0 ) break;
        close(sock);
    }
    if( rp == nullptr )
    {
        std::cerr << "Couldn't bind." << std::endl;
        std::exit(EXIT_FAILURE);
    }
    int protocol = rp->ai_protocol;
    freeaddrinfo(res);
    
    const int qlen = TFO_QLEN;
    e = setsockopt(sock, protocol, TCP_FASTOPEN, &qlen, sizeof(qlen));
    if( e == -1 )
    {
        close(sock);
        cerror("setsockopt");
        std::exit(EXIT_FAILURE);
    }
    if( listen(sock, LISTEN_QLEN) == -1 )
    {
        close(sock);
        cerror("listen");
        std::exit(EXIT_FAILURE);
    }
    return sock;
}

int accept_and_register(int sfd, int epollfd)
{
    // Accept a new connection
    struct sockaddr addr;
    socklen_t addrlen = sizeof(addr);
    int s;
    do
    {
        s = accept4(sfd, &addr, &addrlen, SOCK_NONBLOCK);
    } while( s == -1 && errno == EINTR );
    if( s == -1 )
    {
        cerror("accept");
        std::exit(EXIT_FAILURE);
    }

    struct epoll_event ev;
    ev.events = EPOLLIN | EPOLLET;
    ev.data.fd = s;
    if( epoll_ctl(epollfd, EPOLL_CTL_ADD, s, &ev) == -1 )
    {
        perror("epoll_ctl: EPOLL_CTL_ADD");
        std::exit(EXIT_FAILURE);
    }
    return s;
}

void process_client_socket(int s, int epollfd)
{
    static std::vector<char> buf(BUFFER_SIZE);
    ssize_t rs;
    while( (rs = recv(s, &buf[0], buf.size(), 0)) != 0 )
    {
        if( rs == -1 )
        {
            if( errno == EINTR ) continue;
            if( errno == EAGAIN || errno == EWOULDBLOCK ) return;
            cerror("recv");
            break;
        }
        ssize_t sent;
        // EAGAIN or EWOULDBLOCK is retuned when the socket buffer is full
        // We should try with another socket for maximum performance, however,
        // we just wait until the buffer becomes available as we don't have
        // enough buffer for that.
        do {
            sent = send(s, &buf[0], rs, 0);
        } while( sent == -1 && 
                 (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK) );
        if( sent == -1 )
        {
            cerror("send");
            break;
        }
    }
    if( epoll_ctl(epollfd, EPOLL_CTL_DEL, s, nullptr) == -1 )
        cerror("epoll_ctl: EPOLL_CTL_DEL");
    close(s);
}

void server(const std::string &port)
{
    FD sfd(open_socket(port));
    
    struct epoll_event ev, events[MAX_EVENTS];

    FD epollfd(epoll_create1(0));
    if( epollfd == -1 )
    {
        cerror("epoll_create1");
        std::exit(EXIT_FAILURE);
    }
    ev.events = EPOLLIN;
    ev.data.fd = sfd;
    if( epoll_ctl(epollfd, EPOLL_CTL_ADD, sfd, &ev) == -1 )
    {
        perror("epoll_ctl: EPOLL_CTL_ADD");
        std::exit(EXIT_FAILURE);
    }

    while( 1 )
    {
        const int nfds = epoll_wait(epollfd, events, MAX_EVENTS, -1);
        if( nfds == -1 )
        {
            if( errno == EINTR ) continue;
            cerror("epoll_wait");
            std::exit(EXIT_FAILURE);
        }

        for( int i = 0; i < nfds; ++i )
        {
            if( events[i].data.fd == sfd )
                accept_and_register(sfd, epollfd);
            else
                process_client_socket(events[i].data.fd, epollfd);
        }
    }
}

int main(int argc, char *argv[])
{
    std::string port;
    if( argc <= 1 )
    {
        port = DEFAULT_PORT;
    } else {
        port = argv[1];
    }

    server(port);
}


common.h

#include <iostream>
#include <cstring>

static void cerror(const char *str)
{
    std::cerr << str << ": " << std::strerror(errno) << std::endl;
}

class FD
{
private:
    int fd_;
public:
    FD(int fd): fd_(fd) {}
    ~FD()
    {
        this->close();
    }
    operator int() const
    {
        return fd_;
    }
    void close()
    {
        if( fd_ == -1 ) return;
        ::close(fd_);
        fd_ = -1;
    }
};

Makefile 

CXX = g++
CXXFLAGS = -O -std=c++11 -Wall
TARGETS = client server

.PHONY: all clean

all: $(TARGETS)

client: client.cpp common.h
	$(CXX) $(CXXFLAGS) -pthread -o $@ $<

server: server.cpp common.h
	$(CXX) $(CXXFLAGS) -o $@ $<

clean:
	rm -f $(TARGETS)

四个文件保存好然后进入文件夹make.

开启TFO：sudo sysctl -w net.ipv4.tcp_fastopen=3 (client和Server端都要开启)

server:

./server

client:

./client <server ip><message size><test count><threads>

eg：./client 192.168.1.112 1024 100 1 1

抓包分析：



第一个数据包

(上传的时候用的是Ctrl+v然后没有上传成功，再测试已经开启TFO了所以第一个SYN包已经带数据了)

第三个数据包

(同第一个数据包原因)

再次建立TCP连接时

第九个数据包


可以看到第一次SYN和第二次SYN+ACK两次握手，我们打开第一个数据包可以看到因为第一次是携带FOC请求报文没携带数据包，再然后打开第三个数据包可以看到ACK携带有我们测试的数据，第四个数据包因为客户端没有请求所以没有返回数据。第5、6、7、8是tcp的四次挥手不用看。我们再看第九个数据包，可以看到SYN请求时携带数据包的（Data 1024Bytes），由此可以看出开启TFO后在第一次握手的时候是可以携带数据包的，这样就能节省一个RTT。

也可以用命令来看是否成功开启TFO：grep ‘^TcpExt:’ /proc/net/netstat | cut -d ’ ’ -f 91-96 | column -


TCPFastOpenActiveFail  TCPFastOpenPassive  TCPFastOpenPassiveFail  TCPFastOpenListenOverflow  TCPFastOpenCookieReqd  TCPSpuriousRtxHostQueues
0                      99                  0                       0                          1                      0


TCPFastOpenPassive 数量增长代表成功开启TFO功能，TCPFastOpenCookieReqd代表缓存的地址数。

分析包的时候还发现一个问题：4个字节Fast Open选项在options里没有发现，暂时还不知道为何。

浪里小白龙233
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
TCP Fast Open原理和使用
01-03 704
TFO
Linux TCP_FASTOPEN的作用
热门推荐
for_tech的博客
01-08 1万+
1. 原理1. 1. 客户端发送一个SYN包到服务器，这个包中携带了Fast Open Cookie Request； 2. 服务器生成一个cookie，这个cookie是加密客户端的IP地址生成的。服务器给客户端发送SYN＋ACK响应，在响应包的选项中包含了这个cookie； 3. 客户端存储这个cookie以便将来再次与这个服务器的IP建立TFO连接时使用； 也就是说，第一次TC...
Linux内核3.7 TCP Fast Open验证实例
张亮校的专栏
12-23 1606
Linux内核在3.6和3.7合入了TCP Fast Open特性，在3.7.3版本上验证了一下，I did it! 以下是C语言实例（LWN介绍）： server端代码： [cpp] view plaincopyprint? #include            #include  /* See NOTES */  #include   #include   i
linux TCP Fast Open开启和测试
聚焦游戏和图形引擎开发技术
05-12 1万+
linux上要开启TCP Fast Open，内核版本至少为3.7.0, 且需要设置 /proc/sys/net/ipv4/tcp_fastopen 为3. 开启后，如果有连接进来，使用如下命令查看： grep ‘^TcpExt:’ /proc/net/netstat | cut -d ’ ’ -f 91-96 | column -t 例如：[root@vmxxx ~]# grep '^TcpE
Linux fast open,Linux TCP_FASTOPEN的作用
weixin_42131439的博客
05-26 266
1. 原理1.1. 客户端发送一个SYN包到服务器，这个包中携带了Fast Open Cookie Request；2. 服务器生成一个cookie，这个cookie是加密客户端的IP地址生成的。服务器给客户端发送SYN＋ACK响应，在响应包的选项中包含了这个cookie；3. 客户端存储这个cookie以便将来再次与这个服务器的IP建立TFO连接时使用；也就是说，第一次TCP连接只是交换cook...
tcp_fast_open的概念 作用以及实现（转）
随意的风的专栏
07-05 1万+
TCP Fast Open定义 TCP Fast Open（TFO）是用来加速连续TCP连接的数据交互的TCP协议扩展，原理如下：在TCP三次握手的过程中，当用户首次访问Server时，发送SYN包，Server根据用户IP生成Cookie（已加密），并与SYN-ACK一同发回Client；当Client随后重连时，在SYN包携带TCP Cookie；如果Server校验合法，则在用户回复ACK...
tcp.zip_9260_LINUX TCP
09-20
- **特定功能支持**：可能包含对某些特定TCP选项或扩展的支持，如TCP Fast Open、延迟确认或SACK（选择性确认）。 - **故障恢复和可靠性**：在高可用性场景下，可能有额外的错误检测和恢复机制，比如心跳检测、连接...
TCP有什么缺陷 629 - 637
最新发布
05-15
例如，TCP Fast Open特性虽然在2013年提出，但因客户端和服务器操作系统支持的问题，其普及速度非常慢。 其次，TCP建立连接的延迟是另一个显著问题。TCP连接需要经过著名的三次握手过程，对于HTTP和其他基于TCP的...
TCP_WINDOWS_SET.rar_tcp Windows set
09-23
8. **快速打开（TCP Fast Open, TFO）**：通过在三次握手期间传递数据，TFO可以减少建立连接的延迟，提高数据传输速度。 9. **TCP连接复用**：使用连接池可以重用先前建立的TCP连接，减少每次连接的初始化开销。 ...
c10k_Client.zip_look
09-19
例如，使用TCP快启动（TCP Fast Open）、TCP窗口缩放等特性可以提高连接建立速度和带宽利用率。 再者，编程语言的选择和使用方式也会影响性能。例如，使用事件驱动编程模型（如Node.js的Event Loop）或协程（如...
android-25
03-23
3. **网络与连接**：支持TCP Fast Open、HTTP/2和DNS over TLS等网络优化技术，提升应用的网络性能和安全性。 四、Android SDK Build-Tools 1. **资源压缩优化**：Build-Tools包含资源压缩算法，减少了APK的大小，...
Linux fast open,TFO(tcp fast open)简介
weixin_34322238的博客
05-26 470
一直以来对内核没有太多研究，最近国外业务扩展较快，国外没有节点。所以 国外用户访问国内服务器时，延时比较大。为了解决这个问题，在香港上了一个proxy，通过proxy回国内节点获取数据，最后返回客户端。为提高回源性能，有人提出TFO解决方案，以前没有听说过。所以来学习一下。1. TFO(tcp fast open)简介为了改善web应用相应时延方面的一个工作，google通过修改T...
tcp fastopen什么时候可以开启？
weixin_41374218的博客
12-18 2141
tcp fastopen的问题和适用场景
linux tcp fast open,TFO(TCP Fast Open)介绍
weixin_32880357的博客
05-15 775
一、TFO概述为了改善web应用相应时延，google发布了通过修改TCP协议利用三次握手时进行数据交换的TFO(TCP fast open，RFC 7413)。TFO允许在TCP握手期间发送和接收初始SYN分组中的数据。如果客户端和服务器都支持TFO功能，则可以减少建立到同一服务器的多个TCP连接的延迟。这是通过在初始TCP握手之后在客户端上存储TFO cookie来实现的。如果客户端稍后重新连...
几款网络测试工具总结
一名数据库爱好者的专栏
05-06 6920
ping命令以前是一个很好用并且常用的网络测试工具，它是基于ICMP协议，但是出于网络安全等因素，大部分网络环境以及云环境可能都会禁止ICMP协议，所以在工作中，我们必须掌握一些其他比较流行的网络测试工具，下面分别介绍 tcpping、tcping、psping、hping、paping等几款网络测试工具。 关于ICMP概念： ICMP是（Internet Control Message Protocol）Internet控制报文协议。它是TCP/IP协议族的一个子协议，用于在IP主机、路由器之间传递控制消
Linux系统tcp连接设置
superbfly的专栏
11-27 2774
【代码】Linux系统tcp连接设置。
TCP快速打开-TCP Fast Open
专注音视频基础、WebRTC、ffmpeg、流媒体服务器
03-28 1742
假设我们有一台服务器，它的作用是将接收到数据转成大写后，返回给客户端。如果客户端每次建立连接只发送一次数据，就断开连接，再次发送数据时，重新建立连接。这样每次在连接时，都需要三次握手。并且在第二次建立握手时，客户端发送SYN时，是不可以携带数据的。 而使用TFP（Tcp Fast Open）后，除了第一次的完整握手，之后的握手，在SYN中就可以携带数据，这样的好处是可以减少一个RTT。 抓取的网络包可以到这个连接下载： 链接：https://pan.baidu.com/s/1hqJzcbIYTf6MapHg
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值