d0s3t3ch/wownero
1
0
Fork 0
mirror of https://git.wownero.com/wownero/wownero.git synced 2024-08-15 01:03:23 +00:00
Code Issues Projects Releases Wiki Activity
wownero/src/p2p/p2p_protocol_defs.h

468 lines
14 KiB
C
Raw Normal View History

Update 2018 copyright
2018-01-07 05:05:16 +00:00
// Copyright (c) 2014-2018, The Monero Project
License updated to BSD 3-clause
2014-07-23 13:03:52 +00:00
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification, are
// permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this list of
// conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice, this list
// of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its contributors may be
// used to endorse or promote products derived from this software without specific
// prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
moved all stuff to github
2014-03-03 22:07:58 +00:00
#pragma once
#include <boost/uuid/uuid.hpp>
#include "serialization/keyvalue_serialization.h"
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
#include "net/net_utils_base.h"
moved all stuff to github
2014-03-03 22:07:58 +00:00
#include "misc_language.h"
move includes around to lessen overall load
2017-11-25 22:25:05 +00:00
#include "string_tools.h"
#include "time_helper.h"
moved all stuff to github
2014-03-03 22:07:58 +00:00
#include "cryptonote_config.h"
some include cleanup
2017-07-31 15:36:52 +00:00
#ifdef ALLOW_DEBUG_COMMANDS
moved all stuff to github
2014-03-03 22:07:58 +00:00
#include "crypto/crypto.h"
some include cleanup
2017-07-31 15:36:52 +00:00
#endif
moved all stuff to github
2014-03-03 22:07:58 +00:00
namespace nodetool
{
typedef boost::uuids::uuid uuid;
typedef uint64_t peerid_type;
print peer id in 0 padded hex for consistency
2017-08-20 20:15:53 +00:00
static inline std::string peerid_to_string(peerid_type peer_id)
{
std::ostringstream s;
s << std::hex << peer_id;
return epee::string_tools::pad_string(s.str(), 16, '0', true);
}
moved all stuff to github
2014-03-03 22:07:58 +00:00
#pragma pack (push, 1)
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
struct network_address_old
moved all stuff to github
2014-03-03 22:07:58 +00:00
{
some fixes
2014-03-20 11:46:11 +00:00
uint32_t ip;
uint32_t port;
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(ip)
KV_SERIALIZE(port)
END_KV_SERIALIZE_MAP()
moved all stuff to github
2014-03-03 22:07:58 +00:00
};
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
template<typename AddressType>
struct peerlist_entry_base
moved all stuff to github
2014-03-03 22:07:58 +00:00
{
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
AddressType adr;
moved all stuff to github
2014-03-03 22:07:58 +00:00
peerid_type id;
Fix time_t serialization issue On 32-bit MinGW-w64, time_t is int32_t. The existing code was serializing time_t directly and implicitly assuming that time_t is int64_t. This commit formalizes that assumption by serializing int64_t directly and casting to time_t where appropriate. Thanks go to greatwolf for reporting this issue. monero-project/bitmonero#88
2014-08-20 15:57:29 +00:00
int64_t last_seen;
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(adr)
KV_SERIALIZE(id)
KV_SERIALIZE(last_seen)
END_KV_SERIALIZE_MAP()
moved all stuff to github
2014-03-03 22:07:58 +00:00
};
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
typedef peerlist_entry_base<epee::net_utils::network_address> peerlist_entry;
moved all stuff to github
2014-03-03 22:07:58 +00:00
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
template<typename AddressType>
struct anchor_peerlist_entry_base
Add anchor connections Based on https://eprint.iacr.org/2015/263.pdf 4. Anchor connections. Peer list serialisation version bumped to 5.
2017-02-09 00:11:58 +00:00
{
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
AddressType adr;
Add anchor connections Based on https://eprint.iacr.org/2015/263.pdf 4. Anchor connections. Peer list serialisation version bumped to 5.
2017-02-09 00:11:58 +00:00
peerid_type id;
int64_t first_seen;
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(adr)
KV_SERIALIZE(id)
KV_SERIALIZE(first_seen)
END_KV_SERIALIZE_MAP()
Add anchor connections Based on https://eprint.iacr.org/2015/263.pdf 4. Anchor connections. Peer list serialisation version bumped to 5.
2017-02-09 00:11:58 +00:00
};
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
typedef anchor_peerlist_entry_base<epee::net_utils::network_address> anchor_peerlist_entry;
Add anchor connections Based on https://eprint.iacr.org/2015/263.pdf 4. Anchor connections. Peer list serialisation version bumped to 5.
2017-02-09 00:11:58 +00:00
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
template<typename AddressType>
struct connection_entry_base
moved all stuff to github
2014-03-03 22:07:58 +00:00
{
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
AddressType adr;
moved all stuff to github
2014-03-03 22:07:58 +00:00
peerid_type id;
bool is_income;
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(adr)
KV_SERIALIZE(id)
KV_SERIALIZE(is_income)
END_KV_SERIALIZE_MAP()
moved all stuff to github
2014-03-03 22:07:58 +00:00
};
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
typedef connection_entry_base<epee::net_utils::network_address> connection_entry;
moved all stuff to github
2014-03-03 22:07:58 +00:00
#pragma pack(pop)
inline
p2p: use vector instead of list for peer lists
2018-12-05 22:25:27 +00:00
std::string print_peerlist_to_string(const std::vector<peerlist_entry>& pl)
moved all stuff to github
2014-03-03 22:07:58 +00:00
{
time_t now_time = 0;
time(&now_time);
std::stringstream ss;
ss << std::setfill ('0') << std::setw (8) << std::hex << std::noshowbase;
Replace BOOST_FOREACH with C++11 ranged for
2017-01-22 20:38:10 +00:00
for(const peerlist_entry& pe: pl)
moved all stuff to github
2014-03-03 22:07:58 +00:00
{
Upgrades to epee::net_utils::network_address - internal nullptr checks - prevent modifications to network_address (shallow copy issues) - automagically works with any type containing interface functions - removed fnv1a hashing - ipv4_network_address now flattened with no base class
2017-08-25 15:14:46 +00:00
ss << pe.id << "\t" << pe.adr.str() << " \tlast_seen: " << epee::misc_utils::get_time_interval_string(now_time - pe.last_seen) << std::endl;
moved all stuff to github
2014-03-03 22:07:58 +00:00
}
return ss.str();
}
struct network_config
{
BEGIN_KV_SERIALIZE_MAP()
Rename connections_count to max_out_connection_count This is needed so that a max_in_connection_count can be added.
2018-01-20 06:36:19 +00:00
KV_SERIALIZE(max_out_connection_count)
Allow the number of incoming connections to be limited It was already possible to limit outgoing connections. One might want to do this on home network connections with high bandwidth but low usage caps.
2018-01-20 21:44:23 +00:00
KV_SERIALIZE(max_in_connection_count)
moved all stuff to github
2014-03-03 22:07:58 +00:00
KV_SERIALIZE(handshake_interval)
KV_SERIALIZE(packet_max_size)
KV_SERIALIZE(config_id)
END_KV_SERIALIZE_MAP()
Rename connections_count to max_out_connection_count This is needed so that a max_in_connection_count can be added.
2018-01-20 06:36:19 +00:00
uint32_t max_out_connection_count;
Allow the number of incoming connections to be limited It was already possible to limit outgoing connections. One might want to do this on home network connections with high bandwidth but low usage caps.
2018-01-20 21:44:23 +00:00
uint32_t max_in_connection_count;
some fixes
2014-03-20 11:46:11 +00:00
uint32_t connection_timeout;
uint32_t ping_connection_timeout;
uint32_t handshake_interval;
uint32_t packet_max_size;
uint32_t config_id;
uint32_t send_peerlist_sz;
moved all stuff to github
2014-03-03 22:07:58 +00:00
};
struct basic_node_data
{
uuid network_id;
various fixes to allow mac osx compilation
2014-04-30 17:52:21 +00:00
uint64_t local_time;
moved all stuff to github
2014-03-03 22:07:58 +00:00
uint32_t my_port;
peerid_type peer_id;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE_VAL_POD_AS_BLOB(network_id)
KV_SERIALIZE(peer_id)
KV_SERIALIZE(local_time)
KV_SERIALIZE(my_port)
END_KV_SERIALIZE_MAP()
};
#define P2P_COMMANDS_POOL_BASE 1000
/************************************************************************/
/* */
/************************************************************************/
template<class t_playload_type>
struct COMMAND_HANDSHAKE_T
{
const static int ID = P2P_COMMANDS_POOL_BASE + 1;
struct request
{
basic_node_data node_data;
t_playload_type payload_data;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(node_data)
KV_SERIALIZE(payload_data)
END_KV_SERIALIZE_MAP()
};
struct response
{
basic_node_data node_data;
t_playload_type payload_data;
p2p: use vector instead of list for peer lists
2018-12-05 22:25:27 +00:00
std::vector<peerlist_entry> local_peerlist_new;
moved all stuff to github
2014-03-03 22:07:58 +00:00
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(node_data)
KV_SERIALIZE(payload_data)
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
if (is_store)
{
// saving: save both, so old and new peers can understand it
KV_SERIALIZE(local_peerlist_new)
p2p: use vector instead of list for peer lists
2018-12-05 22:25:27 +00:00
std::vector<peerlist_entry_base<network_address_old>> local_peerlist;
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
for (const auto &p: this_ref.local_peerlist_new)
{
Remove typeid use in network_address Since I had to add an ID to the derived classes anyway, this can be used instead. This removes an apparently pointless warning from CLANG too.
2017-06-28 08:00:29 +00:00
if (p.adr.get_type_id() == epee::net_utils::ipv4_network_address::ID)
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
{
const epee::net_utils::network_address &na = p.adr;
const epee::net_utils::ipv4_network_address &ipv4 = na.as<const epee::net_utils::ipv4_network_address>();
local_peerlist.push_back(peerlist_entry_base<network_address_old>({{ipv4.ip(), ipv4.port()}, p.id, p.last_seen}));
}
else
MDEBUG("Not including in legacy peer list: " << p.adr.str());
}
epee::serialization::selector<is_store>::serialize_stl_container_pod_val_as_blob(local_peerlist, stg, hparent_section, "local_peerlist");
}
else
{
// loading: load old list only if there is no new one
if (!epee::serialization::selector<is_store>::serialize(this_ref.local_peerlist_new, stg, hparent_section, "local_peerlist_new"))
{
p2p: use vector instead of list for peer lists
2018-12-05 22:25:27 +00:00
std::vector<peerlist_entry_base<network_address_old>> local_peerlist;
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
epee::serialization::selector<is_store>::serialize_stl_container_pod_val_as_blob(local_peerlist, stg, hparent_section, "local_peerlist");
for (const auto &p: local_peerlist)
Upgrades to epee::net_utils::network_address - internal nullptr checks - prevent modifications to network_address (shallow copy issues) - automagically works with any type containing interface functions - removed fnv1a hashing - ipv4_network_address now flattened with no base class
2017-08-25 15:14:46 +00:00
((response&)this_ref).local_peerlist_new.push_back(peerlist_entry({epee::net_utils::ipv4_network_address(p.adr.ip, p.adr.port), p.id, p.last_seen}));
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
}
}
moved all stuff to github
2014-03-03 22:07:58 +00:00
END_KV_SERIALIZE_MAP()
};
};
/************************************************************************/
/* */
/************************************************************************/
template<class t_playload_type>
struct COMMAND_TIMED_SYNC_T
{
const static int ID = P2P_COMMANDS_POOL_BASE + 2;
struct request
{
t_playload_type payload_data;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(payload_data)
END_KV_SERIALIZE_MAP()
};
struct response
{
various fixes to allow mac osx compilation
2014-04-30 17:52:21 +00:00
uint64_t local_time;
moved all stuff to github
2014-03-03 22:07:58 +00:00
t_playload_type payload_data;
p2p: use vector instead of list for peer lists
2018-12-05 22:25:27 +00:00
std::vector<peerlist_entry> local_peerlist_new;
moved all stuff to github
2014-03-03 22:07:58 +00:00
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(local_time)
KV_SERIALIZE(payload_data)
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
if (is_store)
{
// saving: save both, so old and new peers can understand it
KV_SERIALIZE(local_peerlist_new)
p2p: use vector instead of list for peer lists
2018-12-05 22:25:27 +00:00
std::vector<peerlist_entry_base<network_address_old>> local_peerlist;
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
for (const auto &p: this_ref.local_peerlist_new)
{
Remove typeid use in network_address Since I had to add an ID to the derived classes anyway, this can be used instead. This removes an apparently pointless warning from CLANG too.
2017-06-28 08:00:29 +00:00
if (p.adr.get_type_id() == epee::net_utils::ipv4_network_address::ID)
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
{
const epee::net_utils::network_address &na = p.adr;
const epee::net_utils::ipv4_network_address &ipv4 = na.as<const epee::net_utils::ipv4_network_address>();
local_peerlist.push_back(peerlist_entry_base<network_address_old>({{ipv4.ip(), ipv4.port()}, p.id, p.last_seen}));
}
else
MDEBUG("Not including in legacy peer list: " << p.adr.str());
}
epee::serialization::selector<is_store>::serialize_stl_container_pod_val_as_blob(local_peerlist, stg, hparent_section, "local_peerlist");
}
else
{
// loading: load old list only if there is no new one
if (!epee::serialization::selector<is_store>::serialize(this_ref.local_peerlist_new, stg, hparent_section, "local_peerlist_new"))
{
p2p: use vector instead of list for peer lists
2018-12-05 22:25:27 +00:00
std::vector<peerlist_entry_base<network_address_old>> local_peerlist;
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
epee::serialization::selector<is_store>::serialize_stl_container_pod_val_as_blob(local_peerlist, stg, hparent_section, "local_peerlist");
for (const auto &p: local_peerlist)
Upgrades to epee::net_utils::network_address - internal nullptr checks - prevent modifications to network_address (shallow copy issues) - automagically works with any type containing interface functions - removed fnv1a hashing - ipv4_network_address now flattened with no base class
2017-08-25 15:14:46 +00:00
((response&)this_ref).local_peerlist_new.push_back(peerlist_entry({epee::net_utils::ipv4_network_address(p.adr.ip, p.adr.port), p.id, p.last_seen}));
abstracted nework addresses All code which was using ip and port now uses a new IPv4 object, subclass of a new network_address class. This will allow easy addition of I2P addresses later (and also IPv6, etc). Both old style and new style peer lists are now sent in the P2P protocol, which is inefficient but allows peers using both codebases to talk to each other. This will be removed in the future. No other subclasses than IPv4 exist yet.
2017-05-27 10:35:54 +00:00
}
}
moved all stuff to github
2014-03-03 22:07:58 +00:00
END_KV_SERIALIZE_MAP()
};
};
/************************************************************************/
/* */
/************************************************************************/
struct COMMAND_PING
{
/*
Used to make "callback" connection, to be sure that opponent node
have accessible connection point. Only other nodes can add peer to peerlist,
and ONLY in case when peer has accepted connection and answered to ping.
*/
const static int ID = P2P_COMMANDS_POOL_BASE + 3;
#define PING_OK_RESPONSE_STATUS_TEXT "OK"
struct request
{
/*actually we don't need to send any real data*/
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string status;
peerid_type peer_id;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(status)
KV_SERIALIZE(peer_id)
END_KV_SERIALIZE_MAP()
};
};
#ifdef ALLOW_DEBUG_COMMANDS
//These commands are considered as insecure, and made in debug purposes for a limited lifetime.
//Anyone who feel unsafe with this commands can disable the ALLOW_GET_STAT_COMMAND macro.
struct proof_of_trust
{
peerid_type peer_id;
uint64_t time;
crypto::signature sign;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(peer_id)
KV_SERIALIZE(time)
KV_SERIALIZE_VAL_POD_AS_BLOB(sign)
END_KV_SERIALIZE_MAP()
};
template<class payload_stat_info>
struct COMMAND_REQUEST_STAT_INFO_T
{
const static int ID = P2P_COMMANDS_POOL_BASE + 4;
struct request
{
proof_of_trust tr;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tr)
END_KV_SERIALIZE_MAP()
};
struct response
{
std::string version;
std::string os_version;
uint64_t connections_count;
uint64_t incoming_connections_count;
payload_stat_info payload_info;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(version)
KV_SERIALIZE(os_version)
KV_SERIALIZE(connections_count)
KV_SERIALIZE(incoming_connections_count)
KV_SERIALIZE(payload_info)
END_KV_SERIALIZE_MAP()
};
};
/************************************************************************/
/* */
/************************************************************************/
struct COMMAND_REQUEST_NETWORK_STATE
{
const static int ID = P2P_COMMANDS_POOL_BASE + 5;
struct request
{
proof_of_trust tr;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(tr)
END_KV_SERIALIZE_MAP()
};
struct response
{
p2p: use vector instead of list for peer lists
2018-12-05 22:25:27 +00:00
std::vector<peerlist_entry> local_peerlist_white;
std::vector<peerlist_entry> local_peerlist_gray;
std::vector<connection_entry> connections_list;
moved all stuff to github
2014-03-03 22:07:58 +00:00
peerid_type my_id;
uint64_t local_time;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE_CONTAINER_POD_AS_BLOB(local_peerlist_white)
KV_SERIALIZE_CONTAINER_POD_AS_BLOB(local_peerlist_gray)
KV_SERIALIZE_CONTAINER_POD_AS_BLOB(connections_list)
KV_SERIALIZE(my_id)
KV_SERIALIZE(local_time)
END_KV_SERIALIZE_MAP()
};
};
/************************************************************************/
/* */
/************************************************************************/
struct COMMAND_REQUEST_PEER_ID
{
const static int ID = P2P_COMMANDS_POOL_BASE + 6;
struct request
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
struct response
{
peerid_type my_id;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(my_id)
END_KV_SERIALIZE_MAP()
};
};
add lightweight block propagation ("fluffy blocks") Added a new command to the P2P protocol definitions to allow querying for support flags. Implemented handling of new support flags command in net_node. Changed for_each callback template to include support flags. Updated print_connections command to show peer support flags. Added p2p constant for signaling fluffy block support. Added get_pool_transaction function to cryptnote_core. Added new commands to cryptonote protocol for relaying fluffy blocks. Implemented handling of fluffy block command in cryptonote protocol. Enabled fluffy block support in node initial configuration. Implemented get_testnet function in cryptonote_core. Made it so that fluffy blocks only run on testnet.
2016-10-26 19:00:08 +00:00
/************************************************************************/
/* */
/************************************************************************/
struct COMMAND_REQUEST_SUPPORT_FLAGS
{
const static int ID = P2P_COMMANDS_POOL_BASE + 7;
struct request
{
BEGIN_KV_SERIALIZE_MAP()
END_KV_SERIALIZE_MAP()
};
struct response
{
uint32_t support_flags;
BEGIN_KV_SERIALIZE_MAP()
KV_SERIALIZE(support_flags)
END_KV_SERIALIZE_MAP()
};
};
moved all stuff to github
2014-03-03 22:07:58 +00:00
#endif
move get_proof_of_trust_hash from util.h to p2p_protocol_defs.h This avoids having to include p2p_protocol_defs.h in util.h, as util.h is used a lot, and p2p_protocol_defs.h includes a lot of other things that most users don't need.
2017-07-27 14:46:47 +00:00
inline crypto::hash get_proof_of_trust_hash(const nodetool::proof_of_trust& pot)
{
std::string s;
s.append(reinterpret_cast<const char*>(&pot.peer_id), sizeof(pot.peer_id));
s.append(reinterpret_cast<const char*>(&pot.time), sizeof(pot.time));
return crypto::cn_fast_hash(s.data(), s.size());
}
moved all stuff to github
2014-03-03 22:07:58 +00:00
}
Reference in a new issue Copy permalink