I am using libp2p to build a project and I have a multiplayer communication problem.

[ISensuiI]

I have 3 nodes. One user A listens directly to the relay for reservation. The rest of B and C dial to connect to A through the relay.

Now users AB and AC can communicate successfully, but BC cannot.

My previous idea was that A listens to the relay first, then B connects to A, C connects to A and B, and so on.

First of all, I am not sure if this idea is correct.

Secondly, when I implemented it, I used C to connect to A without any problem. When I connected to B, it prompted me that this node was not registered in the relay. Failed to connect to destination.: Failed to connect to destination.: Relay has no reservation for destination.)]
The problem is that a node can only have one mode in the relay, either Listen or Dial.
I tried Listen first, and then Dial, but it prompted me that I already have a connection.

How should this be solved? I have tried it myself for 2 days. I don't have any good ideas.

[dariusc93]

Are you dialing Node B directly or Node C directly or trying to use a relay? Assuming the latter and based on what is mentioned and Node A is listening on the relay and B and C are behind a nat but not listening on a relay themselves, it would make sense for BA and CA to connect but BC unable to connect. The nodes would need some way to connect, either directly (which can be utilized by libp2p-upnp if youre behind a nat with upnp) or through a relay.

Could you provide any code or logs, your behaviour setup, etc., which would give up a better idea? :)

[ISensuiI]

Thank you very much for your reply. The current situation is that A, B and C cannot connect directly (drill holes), and must go through the relay.

My method is to make A listen and reserve in the relay first, and then B and C connect to A through the relay. After the connection, AB and AC are normal. But B and C cannot connect.

In fact, what I want to achieve is similar to Vlan virtual local area network, so that A, B and C can ping each other.

I also have an idea to let A, B and C continue to listen and reserve in the relay. Then use B to connect to A through the relay, and C connects A and B.

In fact, my goal is to let all my nodes connect through the relay. Of course, when the conditions of two nodes are met, they can automatically upgrade to P2P connection through autonat, but all node network types in my current test environment do not support P2P connection. ABCDEF... can all connect to each other, instead of all connecting to A while BCDEF cannot connect to each other.

But I remember that I tested it before, a node can only listen in the relay. Or Dial, you can't Listen to the reservation first, then dial other nodes. I don't know if I'm wrong. I'm still testing it today.
If Libp2p allows Listen registration in the relay first, then dial other nodes. That is, the node itself first registers to the relay reservation, and then dials other people. This meets my needs.

---

Client Behaviour Code

#[derive(NetworkBehaviour)] #[behaviour(out_event = "ClientBehaviourEvent")] pub struct ClientBehaviour { pub relay_client: relay::client::Behaviour, pub identify: identify::Behaviour, pub dcutr: dcutr::Behaviour, pub autonat_client: autonat::v2::client::Behaviour, // pub kademlia_client: kad::Behaviour<kad::store::MemoryStore>, pub sub_stream: SubStreamBehaviour, // pub mdns: mdns::tokio::Behaviour, pub upnp: upnp::tokio::Behaviour, pub rendezvous_client: rendezvous::client::Behaviour, pub gossipsub: gossipsub::Behaviour, pub request_response: request_response::cbor::Behaviour<RRRequestType, RRResponseType>, pub ping: ping::Behaviour, }

Client Swarm Build Code

`pub async fn new() -> Result {

    info!(target: "app::core::swarm::build", "Swarm 初始化");

    let keypair = GlobalState::get_node_store().get_local_keypair()?;

    let local_peer_id = GlobalState::get_node_store().get_local_peer_id()?;

    let mut quic_init_config = quic::Config::new(&keypair);
    // 禁用对 QUIC 协议草案 29 版本的支持
    // 只使用 QUIC 版本 1，保证兼容性和稳定性
    quic_init_config.support_draft_29 = false;

    // 设置初始握手的超时时间为 5 秒
    // 如果在 5 秒内无法完成握手，连接将被终止，防止握手过程卡住
    quic_init_config.handshake_timeout = Duration::from_secs(10);

    // 设置最大空闲超时时间为 10,000 毫秒（10 秒）
    // 如果连接在 10 秒内没有任何活动，它将被关闭，以释放资源
    quic_init_config.max_idle_timeout = 10 * 1000;

    // 设置最大并发双向流的数量为 256
    // 限制单个连接可以同时打开的流的数量，防止资源耗尽
    quic_init_config.max_concurrent_stream_limit = 512;

    // 设置保活包发送间隔为 5 秒
    // 每 5 秒发送一个保活包，以保持连接活跃，防止因空闲而被关闭
    quic_init_config.keep_alive_interval = Duration::from_secs(5);

    // 设置单次连接(Dial)的最大数据量为 1000 MB
    // 限制单个连接可以传输的总数据量，防止单个连接占用过多资源
    quic_init_config.max_connection_data = 100_000_000 * 10;

    // 设置单个流的最大数据量为 1000 MB
    // 限制单个流可以传输的数据量，确保资源在多个流之间公平分配
    quic_init_config.max_stream_data = 100_000_000 * 10;
    // 设置单个数据包 最大传输量

    let quic_config = quic_init_config.mtu_upper_bound(1400);

    let mut yamux_config = yamux::Config::default();

    yamux_config.set_max_num_streams(64);

    let tcp_config = tcp::Config::new()
        // nodelay算法 小数据包频繁 启用 大文件建议关闭
        .nodelay(true)
        // 客户端tcp 等待队列最大值 超出则直接丢弃
        .listen_backlog(128)
        //网络节点跳转次数
        .ttl(64);

    let tcp_base_transport = tcp::tokio::Transport::new(tcp_config)
        .upgrade(upgrade::Version::V1)
        .authenticate(noise::Config::new(&keypair).expect("创建noise配置失败"))
        .multiplex(yamux_config.clone())
        .boxed();

    let quic_base_transport = quic::tokio::Transport::new(quic_config)
        .map(|(peer_id, conn), _| (peer_id, StreamMuxerBox::new(conn)))
        .boxed();

    //创建relay client
    let (relay_transport, relay_behaviour) = relay::client::new(local_peer_id);

    let relay_transport = relay_transport
        .upgrade(upgrade::Version::V1) // 先升级
        .authenticate(noise::Config::new(&keypair).expect("创建noise配置失败")) // 添加认证
        .multiplex(yamux_config) // 添加多路复用
        .boxed();

    let tcp_relay_transport: Boxed<(PeerId, StreamMuxerBox)> =
        OrTransport::new(tcp_base_transport, relay_transport)
            .map(|either, endpoint| {
                // 明确指定 endpoint 类型
                match either {
                    Either::Left((peer_id, muxer)) => (peer_id, muxer),
                    Either::Right((peer_id, muxer)) => (peer_id, muxer),
                }
            })
            .boxed();

    let tcp_quic_relay_transport: Boxed<(PeerId, StreamMuxerBox)> =
        OrTransport::new(tcp_relay_transport, quic_base_transport)
            .map(|either, _endpoint| match either {
                Either::Left((peer_id, muxer)) => (peer_id, muxer),
                Either::Right((peer_id, muxer)) => (peer_id, muxer),
            })
            .boxed();

    // 添加 DNS 支持
    let transport: Boxed<(PeerId, StreamMuxerBox)> = {
        // 自定义 DNS 解析器配置
        let resolver_config = ResolverConfig::default();
        // DNS 解析选项
        let resolver_opts = ResolverOpts::default(); // 使用系统 hosts 文件

        // 创建 DNS transport
        libp2p::dns::tokio::Transport::custom(
            tcp_quic_relay_transport,
            resolver_config,
            resolver_opts,
        )
            .boxed()
    };

    let client_behaviour = ClientBehaviour::new(&keypair, relay_behaviour).await?;

    let swarm_config = libp2p::swarm::Config::with_tokio_executor()
        // 控制同时进行的拨号尝试数量
        // 方式2: 使用 try_from (更安全的方式)
        .with_dial_concurrency_factor(NonZeroU8::try_from(16).expect("拨号并发因子不能为零"))
        // 空闲连接超时时间，超过此时间未活动的连接将被关闭
        .with_idle_connection_timeout(Duration::from_secs(60))
        // 控制最大同时处理的入站流数量
        .with_max_negotiating_inbound_streams(1024) // 默认值：1024
        // 设置通知处理器的缓冲区大小
        .with_notify_handler_buffer_size(NonZeroUsize::new(128).expect("invalid size"))
        // 设置每个连接的事件缓冲区大小
        .with_per_connection_event_buffer_size(512);
    

    let swarm = Swarm::new(transport, client_behaviour, local_peer_id, swarm_config);




    info!(target: "app::core::swarm::build", "P2P Swarm 初始化完成");


    Ok(Self { swarm })
    
}`