接收方拒绝仅为- 0构建打开套接字

大家好，

(编辑:单文件版本在末尾)

我只在某些编译设置中有问题(这表明某种UB，但我决定将这个问题标记为boost-asio，因为它可能涉及有关asio细节的知识)。注意，我使用的是当前git版本的独立asio库。

首先让我删除一些片段-完整的代码在这里:https://github.com/paulhilbert/magellan(请注意，CMakeLists.txt非常粗糙，可能需要修复，以防您想要编译它)。

我有一个测试echo服务器(tcp, async)在examples/echo_server.cpp:

[snip...]
int main (int argc, char const* argv[]) {
    try {
        if (argc != 2) {
            std::cerr << "Usage: echo_server <port>n";
            return 1;
        }
        asio::io_context io_context;
        magellan::server server;
        server.accept<echo_session>(io_context, 9003);
        io_context.run();
    } catch (std::exception& e) {
        std::cerr << e.what() << "n";
    }
}

显然，server和echo_session类是有趣的部分;然而，后者似乎工作正常，所以我要放弃server类在这里。包括/server.hpp:

#ifndef MAGELLAN_SERVER_HPP_
#define MAGELLAN_SERVER_HPP_
#include "session.hpp"
namespace magellan {
class server {
    public:
        [snip typedefs...]
    public:
        server();
        virtual ~server();
        template <typename Session>
        void accept(asio::io_context& io_context, short port);
        [snip comments...]
};
} // magellan
#include "server.ipp"
#endif /* MAGELLAN_SERVER_HPP_ */

…include/server.ipp:

#include <iostream>
namespace magellan {
template <typename Session>
inline void
server::accept(asio::io_context& io_context, short port) {
    using asio::ip::tcp;
    asio::spawn(io_context, [&](asio::yield_context yield) {
        tcp::acceptor acceptor(io_context, tcp::endpoint(tcp::v4(), port));
        for (;;) {
            asio::error_code ec;
            tcp::socket socket(io_context);
            acceptor.async_accept(socket, yield[ec]);
            if (!ec) {
                auto session = std::make_shared<Session>(std::move(socket));
                session->start();
            }
        }
    });
}
[snip comments...]
} // magellan

现在有趣的是，async_accept打开一个tcp套接字，如果我用-O1， -O2和-O3编译，而不是用- 0。我通过:

> ss -a | grep 9003
296:tcp    LISTEN     0      128     *:9003                  *:*  

当使用- 0编译时，套接字永远不会打开。我还通过io_context::work实例检查了该服务是否仍在运行。

我最好的猜测(诚然缺乏信心)是boost协程与- 0做了一些不同的事情。值得一提的是，如果我在服务器中使用注释掉的代码。Ipp也不会打开套接字(不管编译设置是什么):

template <typename Session>
inline void
server::accept(asio::io_context& io_context, short port) {
    using asio::ip::tcp;
    accept<Session>(io_context, port, [](tcp::socket s) {
        return std::make_shared<Session>(std::move(s));
    });
}
template <typename Session, typename Func>
void
server::accept(asio::io_context& io_context, short port, Func&& factory) {
    using asio::ip::tcp;
    asio::spawn(io_context, [&](asio::yield_context yield) {
        tcp::acceptor acceptor(io_context, tcp::endpoint(tcp::v4(), port));
        for (;;) {
            asio::error_code ec;
            tcp::socket socket(io_context);
            acceptor.async_accept(socket, yield[ec]);
            if (!ec) {
                auto session = factory(std::move(socket));
                session->start();
            } else {
                std::cout << "failed accept" << "n";
            }
        }
    });
}

这是我最初的问题，我将其归因于复制的套接字而不是移动的套接字，直到我到达- 0标志问题。

我在这一点上相当迷失，因为我不知道如何调试这些异步进程，但我仍然有信心对我的问题的实际答案将在某种程度上令人尴尬;)

希望你能给我点提示。

最好的,理查德。

以下是一个压缩的单文件版本:

#include <iostream>
#include <asio.hpp>
#include <asio/spawn.hpp>
using asio::ip::tcp;
namespace magellan {
class session : public std::enable_shared_from_this<session> {
public:
    session(asio::ip::tcp::socket socket) : socket_(std::move(socket)), strand_(socket_.get_io_context()) {
    }
    template <typename Func>
    void
    async_do(Func&& f) {
        auto self(shared_from_this());
        asio::spawn(strand_, [this, self, f](asio::yield_context yield) {
            try {
                f(std::ref(socket_), std::ref(yield));
            } catch (std::exception& e) {
                socket_.close();
            }
        });
    }
    void start() {
        async_do([this] (tcp::socket& s, asio::yield_context& yc) {
            perform(s, yc);
        });
    }
protected:
    virtual void perform(asio::ip::tcp::socket& s, asio::yield_context&) {
        s.close();
    }
protected:
    asio::ip::tcp::socket socket_;
    asio::io_context::strand strand_;
};
class server {
    public:
        typedef std::shared_ptr<server>       ptr;
        typedef std::weak_ptr<server>         wptr;
        typedef std::shared_ptr<const server> const_ptr;
        typedef std::weak_ptr<const server>   const_wptr;
    public:
        server() {}
        virtual ~server() {}
        template <typename Session>
        void
        accept(asio::io_context& io_context, short port) {
            using asio::ip::tcp;
            asio::spawn(io_context, [&](asio::yield_context yield) {
                tcp::acceptor acceptor(io_context, tcp::endpoint(tcp::v4(), port));
                for (;;) {
                    asio::error_code ec;
                    tcp::socket socket(io_context);
                    acceptor.async_accept(socket, yield[ec]);
                    if (!ec) {
                        auto session = std::make_shared<Session>(std::move(socket));
                        session->start();
                    }
                }
            });
        }
};
} // magellan
class echo_session : public magellan::session {
    public:
        typedef std::shared_ptr<echo_session>       ptr;
        typedef std::weak_ptr<echo_session>         wptr;
        typedef std::shared_ptr<const echo_session> const_ptr;
        typedef std::weak_ptr<const echo_session>   const_wptr;
    public:
        echo_session(tcp::socket socket)
            : magellan::session(std::move(socket)) {}
        virtual ~echo_session() {}
    protected:
        void perform(asio::ip::tcp::socket& s, asio::yield_context& yc) {
            char data[128];
            for (;;) {
                std::size_t n = s.async_read_some(asio::buffer(data), yc);
                asio::async_write(s, asio::buffer(data, n), yc);
            }
        }
};

int main (int argc, char const* argv[]) {
    try {
        if (argc != 2) {
            std::cerr << "Usage: echo_server <port>n";
            return 1;
        }
        asio::io_context io_context;
        magellan::server server;
        server.accept<echo_session>(io_context, 9003);
        io_context.run();
    } catch (std::exception& e) {
        std::cerr << e.what() << "n";
    }
}