// Smoldot

// Copyright (C) 2019-2022  Parity Technologies (UK) Ltd.

// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

use crate::{libp2p::peer_id, util::protobuf};

use alloc::vec::Vec;

// See https://github.com/libp2p/specs/tree/master/kad-dht#rpc-messages for the protobuf format.

/// Builds a wire message to send on the Kademlia request-response protocol to ask the target to

/// return the nodes closest to the parameter.

// TODO: parameter type?

pub fn build_find_node_request(peer_id: &[u8]) -> Vec<u8> {

    // The capacity is arbitrary but large enough to avoid Vec reallocations.

    let mut out = Vec::with_capacity(64 + peer_id.len());

    for slice in protobuf::enum_tag_encode(1, 4) {

        out.extend_from_slice(slice.as_ref());

    }

    for slice in protobuf::bytes_tag_encode(2, peer_id) {

        out.extend_from_slice(slice.as_ref());

    }

    out

}

Unexecuted instantiation: _RNvNtNtNtCsN16ciHI6Qf_7smoldot7network5codec8kademlia23build_find_node_request

Unexecuted instantiation: _RNvNtNtNtCseuYC0Zibziv_7smoldot7network5codec8kademlia23build_find_node_request

/// Decodes a response to a request built using [`build_find_node_request`].

// TODO: return a borrow of the response bytes ; we're limited by protobuf library

pub fn decode_find_node_response(

    response_bytes: &[u8],

) -> Result<Vec<(peer_id::PeerId, Vec<Vec<u8>>)>, DecodeFindNodeResponseError> {

    let mut parser = nom::combinator::all_consuming::<_, _, nom::error::Error<&[u8]>, _>(

        nom::combinator::complete(protobuf::message_decode! {

            #[optional] response_ty = 1 => protobuf::enum_tag_decode,

            #[repeated(max = 1024)] peers = 8 => protobuf::message_tag_decode(protobuf::message_decode!{

                #[required] peer_id = 1 => protobuf::bytes_tag_decode,

                #[repeated(max = 1024)] addrs = 2 => protobuf::bytes_tag_decode,

            }),

Unexecuted instantiation: _RNCNvNtNtNtCsN16ciHI6Qf_7smoldot7network5codec8kademlia25decode_find_node_responses_0B9_

Unexecuted instantiation: _RNCNvNtNtNtCseuYC0Zibziv_7smoldot7network5codec8kademlia25decode_find_node_responses_0B9_

Unexecuted instantiation: _RNCNCNCNvNtNtNtCsN16ciHI6Qf_7smoldot7network5codec8kademlia25decode_find_node_responses_000Bd_

Unexecuted instantiation: _RNCNCNCNvNtNtNtCseuYC0Zibziv_7smoldot7network5codec8kademlia25decode_find_node_responses_000Bd_

        }),

    );

    let closer_peers = match nom::Finish::finish(parser(response_bytes)) {

        Ok((_, out)) if out.response_ty.unwrap_or(0) == 4 => out.peers,

        Ok((_, _)) => return Err(DecodeFindNodeResponseError::BadResponseTy),

        Err(_) => {

            return Err(DecodeFindNodeResponseError::ProtobufDecode(

                ProtobufDecodeError,

            ))

        }

    };

    let mut result = Vec::with_capacity(closer_peers.len());

    for peer in closer_peers {

        let peer_id = peer_id::PeerId::from_bytes(peer.peer_id.to_vec())

            .map_err(|(err, _)| DecodeFindNodeResponseError::BadPeerId(err))?;

Unexecuted instantiation: _RNCNvNtNtNtCsN16ciHI6Qf_7smoldot7network5codec8kademlia25decode_find_node_response0B9_

Unexecuted instantiation: _RNCNvNtNtNtCseuYC0Zibziv_7smoldot7network5codec8kademlia25decode_find_node_response0B9_

        let mut multiaddrs = Vec::with_capacity(peer.addrs.len());

        for addr in peer.addrs {

            multiaddrs.push(addr.to_vec());

        }

        result.push((peer_id, multiaddrs));

    }

    Ok(result)

}

Unexecuted instantiation: _RNvNtNtNtCsN16ciHI6Qf_7smoldot7network5codec8kademlia25decode_find_node_response

Unexecuted instantiation: _RNvNtNtNtCseuYC0Zibziv_7smoldot7network5codec8kademlia25decode_find_node_response

/// Error potentially returned by [`decode_find_node_response`].

#[derive(Debug, derive_more::Display)]

Unexecuted instantiation: _RNvXs_NtNtNtCsN16ciHI6Qf_7smoldot7network5codec8kademliaNtB4_27DecodeFindNodeResponseErrorNtNtCsaYZPK01V26L_4core3fmt7Display3fmt

Unexecuted instantiation: _RNvXs_NtNtNtCseuYC0Zibziv_7smoldot7network5codec8kademliaNtB4_27DecodeFindNodeResponseErrorNtNtCsaYZPK01V26L_4core3fmt7Display3fmt

pub enum DecodeFindNodeResponseError {

    /// Error while decoding the Protobuf encoding.

    #[display(fmt = "Error decoding the response: {_0}")]

    ProtobufDecode(ProtobufDecodeError),

    /// Response isn't a response to a find node request.

    BadResponseTy,

    /// Error while parsing a [`peer_id::PeerId`] in the response.

    #[display(fmt = "Invalid PeerId: {_0}")]

    BadPeerId(peer_id::FromBytesError),

}

/// Error while decoding the Protobuf encoding.

#[derive(Debug, derive_more::Display)]

Unexecuted instantiation: _RNvXs1_NtNtNtCsN16ciHI6Qf_7smoldot7network5codec8kademliaNtB5_19ProtobufDecodeErrorNtNtCsaYZPK01V26L_4core3fmt7Display3fmt

Unexecuted instantiation: _RNvXs1_NtNtNtCseuYC0Zibziv_7smoldot7network5codec8kademliaNtB5_19ProtobufDecodeErrorNtNtCsaYZPK01V26L_4core3fmt7Display3fmt

pub struct ProtobufDecodeError;