Gav Wood
11 years ago
74 changed files with 3096 additions and 2560 deletions
@ -0,0 +1,55 @@ |
|||
CURRENT_SOURCE_DIR=$1 |
|||
CURRENT_BINARY_DIR=$2 |
|||
BUILD_TYPE=$3 |
|||
BUILD_PLATFORM=$4 |
|||
|
|||
echo "Current source dir: $CURRENT_SOURCE_DIR" |
|||
echo "Current binary dir: $CURRENT_BINARY_DIR" |
|||
echo "Build type: $BUILD_TYPE" |
|||
echo "Build platform: $BUILD_PLATFORM" |
|||
|
|||
if [[ -e "$CURRENT_SOURCE_DIR/BuildInfo.h" ]] |
|||
then |
|||
echo "Using existing BuildInfo.h" |
|||
cp $CURRENT_SOURCE_DIR/BuildInfo.h $CURRENT_BINARY_DIR/BuildInfo.h.tmp |
|||
else |
|||
if [[ -e "$CURRENT_SOURCE_DIR/.git" ]] |
|||
then |
|||
ETH_COMMIT_HASH=$(git --git-dir=$CURRENT_SOURCE_DIR/.git --work-tree=$CURRENT_SOURCE_DIR rev-parse HEAD) |
|||
ETH_LOCAL_CHANGES=$(git --git-dir=$CURRENT_SOURCE_DIR/.git --work-tree=$CURRENT_SOURCE_DIR diff --shortstat) |
|||
if [[ -z "$ETH_LOCAL_CHANGES" ]] |
|||
then |
|||
ETH_CLEAN_REPO=1 |
|||
else |
|||
ETH_CLEAN_REPO=0 |
|||
fi |
|||
|
|||
echo "Commit hash: ${ETH_COMMIT_HASH} (Clean: ${ETH_CLEAN_REPO} - ${ETH_LOCAL_CHANGES})" |
|||
else |
|||
echo "Unknown repo." |
|||
ETH_COMMIT_HASH=0 |
|||
ETH_CLEAN_REPO=1 |
|||
fi |
|||
|
|||
echo "// This file was automatically generated by cmake" > $CURRENT_BINARY_DIR/BuildInfo.h.tmp |
|||
echo "" >> $CURRENT_BINARY_DIR/BuildInfo.h.tmp |
|||
echo "#pragma once" >> $CURRENT_BINARY_DIR/BuildInfo.h.tmp |
|||
echo "" >> $CURRENT_BINARY_DIR/BuildInfo.h.tmp |
|||
echo "#define ETH_COMMIT_HASH $ETH_COMMIT_HASH" >> $CURRENT_BINARY_DIR/BuildInfo.h.tmp |
|||
echo "#define ETH_CLEAN_REPO $ETH_CLEAN_REPO" >> $CURRENT_BINARY_DIR/BuildInfo.h.tmp |
|||
echo "#define ETH_BUILD_TYPE $BUILD_TYPE" >> $CURRENT_BINARY_DIR/BuildInfo.h.tmp |
|||
echo "#define ETH_BUILD_PLATFORM $BUILD_PLATFORM" >> $CURRENT_BINARY_DIR/BuildInfo.h.tmp |
|||
fi |
|||
|
|||
if [[ -e "$CURRENT_BINARY_DIR/BuildInfo.h" ]] |
|||
then |
|||
DIFF=$(diff $CURRENT_BINARY_DIR/BuildInfo.h $CURRENT_BINARY_DIR/BuildInfo.h.tmp) |
|||
if [[ -z "$DIFF" ]] |
|||
then |
|||
rm $CURRENT_BINARY_DIR/BuildInfo.h.tmp |
|||
else |
|||
mv $CURRENT_BINARY_DIR/BuildInfo.h.tmp $CURRENT_BINARY_DIR/BuildInfo.h |
|||
fi |
|||
else |
|||
mv $CURRENT_BINARY_DIR/BuildInfo.h.tmp $CURRENT_BINARY_DIR/BuildInfo.h |
|||
fi |
|||
@ -1,94 +0,0 @@ |
|||
### UP FOR GRABS |
|||
|
|||
BUG: Nonce sometimes jumps one. |
|||
|
|||
Tests |
|||
- Use standard tests. |
|||
|
|||
Crypto stuff: |
|||
- kFromMessage |
|||
- Check all the tweak instructions. |
|||
|
|||
Network: |
|||
- *** Exponential backoff on bad connection. |
|||
- *** Handle exception when no network. |
|||
- *** Only download blocks from one peer at once. |
|||
- Download in parallel, but stripe. |
|||
- NotInChain will be very bad for new peers - it'll run through until the genesis. |
|||
- Check how many it has first. |
|||
- Crypto on network - use id as public key? |
|||
- Make work with IPv6 |
|||
- Peers rated. |
|||
- Useful/useless - new blocks/transactions or useful peers? |
|||
- Solid communications? |
|||
- Strategy for peer suggestion? |
|||
- Ignore transactions with future nonces until address's nonce changes. |
|||
|
|||
Cleanups & caching |
|||
- All caches should flush unused data (I'm looking at you, BlockChain) to avoid memory overload. |
|||
- State DB should keep only last few N blocks worth of nodes (except for restore points - configurable, defaults to every 30000th block - all blocks that are restore points should be stored so their stateRoots are known good). |
|||
|
|||
THREAD-SAFETY |
|||
- BlockChain |
|||
- TransactionQueue |
|||
- State |
|||
|
|||
General: |
|||
- Better logging. |
|||
- Colours. |
|||
- Move over to new system. |
|||
- Remove block chain on protocol change (i.e. store protocol with block chain). |
|||
|
|||
Robustness |
|||
- Remove aborts |
|||
- Recover from all exceptions. |
|||
- Especially RLP & other I/O. |
|||
- RLP should never assert; only throw. |
|||
- Store version alongside BC DB. |
|||
- Better handling of corrupt blocks. |
|||
- Kill DB & restart. |
|||
- Avoid transactions with future invalid nonces until additional transactions are processed. |
|||
|
|||
GUI |
|||
- Make address/block chain list model-based, JIT populated. |
|||
- Make everything else model-based |
|||
- Qt/QML class. |
|||
- Turn on/off debug channels. |
|||
|
|||
|
|||
### Marko |
|||
|
|||
Ubuntu builds |
|||
- Raring (branch, local, x64 only :-( ) |
|||
- Quantal (branch) (Launchpad) |
|||
- Saucy (master) (Launchpad) |
|||
|
|||
### Alex |
|||
|
|||
Mac build. |
|||
Mac build instructions. |
|||
|
|||
### Eric |
|||
|
|||
Windows XC build. |
|||
Windows XC build instructions. |
|||
|
|||
### Tim/Harv |
|||
|
|||
Windows MSVC build. |
|||
Windows MSVC build instructions. |
|||
|
|||
LATER: |
|||
|
|||
Trie on DB. |
|||
- Move the restore point stuff into block restore points |
|||
- i.e. keep all nodes from last 127 blocks with counter, at 128, kill but keep every (60*24*7)th or so i.e. one per week as a restore point. |
|||
- maybe allow this to be configured. |
|||
|
|||
|
|||
### TIM |
|||
|
|||
Stateful Miner class. |
|||
|
|||
Better Mod-Exp. |
|||
|
|||
@ -1,6 +0,0 @@ |
|||
cpp-ethereum for Debian |
|||
----------------------- |
|||
|
|||
<possible notes regarding this package - if none, delete this file> |
|||
|
|||
-- Gav <Gav Wood <i@gavwood.com>> Mon, 03 Feb 2014 14:50:20 +0000 |
|||
@ -1,9 +0,0 @@ |
|||
cpp-ethereum for Debian |
|||
----------------------- |
|||
|
|||
<this file describes information about the source package, see Debian policy |
|||
manual section 4.14. You WILL either need to modify or delete this file> |
|||
|
|||
|
|||
|
|||
|
|||
@ -1,23 +0,0 @@ |
|||
cpp-ethereum (0.1.0-1) saucy; urgency=low |
|||
|
|||
* Various improvements moving towards PoC-2. |
|||
|
|||
-- Ethereum (Ethereum Project) <ethereum@gavwood.com> Fri, 07 Feb 2014 00:48:26 +0000 |
|||
|
|||
cpp-ethereum (0.1-3) saucy; urgency=low |
|||
|
|||
* Packaging stuff. |
|||
|
|||
-- Ethereum (Ethereum Project) <ethereum@gavwood.com> Thu, 06 Feb 2014 14:13:00 +0000 |
|||
|
|||
cpp-ethereum (0.1-2) saucy; urgency=low |
|||
|
|||
* Fix Qt dep. |
|||
|
|||
-- Gav Wood <ethereum@gavwood.com> Mon, 06 Feb 2014 11:35:20 +0000 |
|||
|
|||
cpp-ethereum (0.1-1) saucy; urgency=low |
|||
|
|||
* Initial release. |
|||
|
|||
-- Gav Wood <ethereum@gavwood.com> Mon, 03 Feb 2014 14:50:20 +0000 |
|||
@ -1 +0,0 @@ |
|||
8 |
|||
@ -1,29 +0,0 @@ |
|||
Source: cpp-ethereum |
|||
Section: science |
|||
Priority: extra |
|||
Maintainer: Ethereum (Ethereum Project) <ethereum@gavwood.com> |
|||
Build-Depends: debhelper (>= 8.0.0), cmake, libgmp-dev, libcryptoppeth-dev, libboost-filesystem1.53-dev, libboost-mpi1.53-dev, libboost1.53-dev, libleveldb-dev, libminiupnpc-dev, qtbase5-dev, qt5-default |
|||
Standards-Version: 3.9.4 |
|||
Homepage: http://ethereum.org |
|||
#Vcs-Git: git://git.debian.org/collab-maint/cpp-ethereum.git |
|||
#Vcs-Browser: http://git.debian.org/?p=collab-maint/cpp-ethereum.git;a=summary |
|||
|
|||
Package: libethereum |
|||
Section: libdevel |
|||
Architecture: any |
|||
Depends: ${shlibs:Depends}, ${misc:Depends}, libgmp, libcryptoppeth, libboost-filesystem1.53.0, libboost-mpi1.53.0, libleveldb, libminiupnpc, secp256k1eth |
|||
Description: The future of computational social contracts. |
|||
A long description of libethereum. |
|||
|
|||
Package: libethereum-dev |
|||
Section: libdevel |
|||
Architecture: any |
|||
Depends: libethereum (= ${binary:Version}), ${shlibs:Depends}, ${misc:Depends}, libgmp, libcryptoppeth, libboost-filesystem1.53.0, libboost-mpi1.53.0, libleveldb, libminiupnpc |
|||
Description: The future of computational social contracts. Dev Files. |
|||
A long description of libethereum. Dev Files. |
|||
|
|||
Package: alethzero |
|||
Architecture: any |
|||
Depends: ${shlibs:Depends}, ${misc:Depends}, libethereum (= ${binary:Version}), qtbase5 |
|||
Description: The Qt-based Ethereum GUI. |
|||
A long description of alethzero. |
|||
@ -1,24 +0,0 @@ |
|||
Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ |
|||
Upstream-Name: cpp-ethereum |
|||
Source: github.com/ethereum/cpp-ethereum |
|||
|
|||
Files: * |
|||
Copyright: 2014 Gav Wood <i@gavwood.com> |
|||
License: MIT |
|||
Permission is hereby granted, free of charge, to any person obtaining a copy |
|||
of this software and associated documentation files (the "Software"), to deal |
|||
in the Software without restriction, including without limitation the rights |
|||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|||
copies of the Software, and to permit persons to whom the Software is |
|||
furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
|||
THE SOFTWARE. |
|||
@ -1,3 +0,0 @@ |
|||
CodingStandards.txt |
|||
README.md |
|||
TODO |
|||
@ -1,36 +0,0 @@ |
|||
#!/usr/bin/make -f |
|||
# -*- makefile -*- |
|||
# Sample debian/rules that uses debhelper. |
|||
# |
|||
# This file was originally written by Joey Hess and Craig Small. |
|||
# As a special exception, when this file is copied by dh-make into a |
|||
# dh-make output file, you may use that output file without restriction. |
|||
# This special exception was added by Craig Small in version 0.37 of dh-make. |
|||
# |
|||
# Modified to make a template file for a multi-binary package with separated |
|||
# build-arch and build-indep targets by Bill Allombert 2001 |
|||
|
|||
# Uncomment this to turn on verbose mode. |
|||
#export DH_VERBOSE=1 |
|||
|
|||
# This has to be exported to make some magic below work. |
|||
export DH_OPTIONS |
|||
|
|||
|
|||
%: |
|||
dh $@ |
|||
|
|||
override_dh_auto_configure: |
|||
cmake -DCMAKE_INSTALL_PREFIX=$(CURDIR)/debian/libethereum-dev/usr . |
|||
|
|||
override_dh_auto_build: |
|||
$(MAKE) -j8 |
|||
|
|||
override_dh_auto_install: |
|||
$(MAKE) install |
|||
# Move the libs over to the non-dev package. |
|||
mkdir -p $(CURDIR)/debian/libethereum/usr |
|||
mv $(CURDIR)/debian/libethereum-dev/usr/lib $(CURDIR)/debian/libethereum/usr/lib |
|||
mkdir -p $(CURDIR)/debian/alephzero/usr/bin |
|||
mv $(CURDIR)/debian/libethereum-dev/usr/bin/alethzero $(CURDIR)/debian/alethzero/usr/lib |
|||
|
|||
@ -0,0 +1,96 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum 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. |
|||
|
|||
cpp-ethereum 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 cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file Common.cpp
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "CommonData.h" |
|||
|
|||
#include <random> |
|||
#include "Exceptions.h" |
|||
using namespace std; |
|||
using namespace eth; |
|||
|
|||
std::string eth::escaped(std::string const& _s, bool _all) |
|||
{ |
|||
std::string ret; |
|||
ret.reserve(_s.size()); |
|||
ret.push_back('"'); |
|||
for (auto i: _s) |
|||
if (i == '"' && !_all) |
|||
ret += "\\\""; |
|||
else if (i == '\\' && !_all) |
|||
ret += "\\\\"; |
|||
else if (i < ' ' || i > 127 || _all) |
|||
{ |
|||
ret += "\\x"; |
|||
ret.push_back("0123456789abcdef"[(uint8_t)i / 16]); |
|||
ret.push_back("0123456789abcdef"[(uint8_t)i % 16]); |
|||
} |
|||
else |
|||
ret.push_back(i); |
|||
ret.push_back('"'); |
|||
return ret; |
|||
} |
|||
|
|||
std::string eth::randomWord() |
|||
{ |
|||
static std::mt19937_64 s_eng(0); |
|||
std::string ret(std::uniform_int_distribution<int>(4, 10)(s_eng), ' '); |
|||
char const n[] = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM1234567890"; |
|||
std::uniform_int_distribution<int> d(0, sizeof(n) - 2); |
|||
for (char& c: ret) |
|||
c = n[d(s_eng)]; |
|||
return ret; |
|||
} |
|||
|
|||
int eth::fromHex(char _i) |
|||
{ |
|||
if (_i >= '0' && _i <= '9') |
|||
return _i - '0'; |
|||
if (_i >= 'a' && _i <= 'f') |
|||
return _i - 'a' + 10; |
|||
if (_i >= 'A' && _i <= 'F') |
|||
return _i - 'A' + 10; |
|||
throw BadHexCharacter(); |
|||
} |
|||
|
|||
bytes eth::fromHex(std::string const& _s) |
|||
{ |
|||
assert(_s.size() % 2 == 0); |
|||
if (_s.size() < 2) |
|||
return bytes(); |
|||
uint s = (_s[0] == '0' && _s[1] == 'x') ? 2 : 0; |
|||
std::vector<uint8_t> ret; |
|||
ret.reserve((_s.size() - s) / 2); |
|||
for (uint i = s; i < _s.size(); i += 2) |
|||
ret.push_back((byte)(fromHex(_s[i]) * 16 + fromHex(_s[i + 1]))); |
|||
return ret; |
|||
} |
|||
|
|||
bytes eth::asNibbles(std::string const& _s) |
|||
{ |
|||
std::vector<uint8_t> ret; |
|||
ret.reserve(_s.size() * 2); |
|||
for (auto i: _s) |
|||
{ |
|||
ret.push_back(i / 16); |
|||
ret.push_back(i % 16); |
|||
} |
|||
return ret; |
|||
} |
|||
@ -0,0 +1,186 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum 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. |
|||
|
|||
cpp-ethereum 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 cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file Common.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
* |
|||
* Shared algorithms and data types. |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <vector> |
|||
#include <algorithm> |
|||
#include <type_traits> |
|||
#include <cstring> |
|||
#include <string> |
|||
#include "Common.h" |
|||
|
|||
namespace eth |
|||
{ |
|||
|
|||
// String conversion functions, mainly to/from hex/nibble/byte representations.
|
|||
|
|||
/// Convert a series of bytes to the corresponding string of hex duplets.
|
|||
/// @param _w specifies the width of each of the elements. Defaults to two - enough to represent a byte.
|
|||
/// @example toHex("A\x69") == "4169"
|
|||
template <class _T> |
|||
std::string toHex(_T const& _data, int _w = 2) |
|||
{ |
|||
std::ostringstream ret; |
|||
for (auto i: _data) |
|||
ret << std::hex << std::setfill('0') << std::setw(_w) << (int)(typename std::make_unsigned<decltype(i)>::type)i; |
|||
return ret.str(); |
|||
} |
|||
|
|||
/// Converts a (printable) ASCII hex character into the correspnding integer value.
|
|||
/// @example fromHex('A') == 10 && fromHex('f') == 15 && fromHex('5') == 5
|
|||
int fromHex(char _i); |
|||
|
|||
/// Converts a (printable) ASCII hex string into the corresponding byte stream.
|
|||
/// @example fromHex("41626261") == asBytes("Abba")
|
|||
bytes fromHex(std::string const& _s); |
|||
|
|||
/// Converts byte array to a string containing the same (binary) data. Unless
|
|||
/// the byte array happens to contain ASCII data, this won't be printable.
|
|||
inline std::string asString(bytes const& _b) |
|||
{ |
|||
return std::string((char const*)_b.data(), (char const*)(_b.data() + _b.size())); |
|||
} |
|||
|
|||
/// Converts a string to a byte array containing the string's (byte) data.
|
|||
inline bytes asBytes(std::string const& _b) |
|||
{ |
|||
return bytes((byte const*)_b.data(), (byte const*)(_b.data() + _b.size())); |
|||
} |
|||
|
|||
/// Converts a string into the big-endian base-16 stream of integers (NOT ASCII).
|
|||
/// @example asNibbles("A")[0] == 4 && asNibbles("A")[1] == 1
|
|||
bytes asNibbles(std::string const& _s); |
|||
|
|||
|
|||
// Big-endian to/from host endian conversion functions.
|
|||
|
|||
/// Converts a templated integer value to the big-endian byte-stream represented on a templated collection.
|
|||
/// The size of the collection object will be unchanged. If it is too small, it will not represent the
|
|||
/// value properly, if too big then the additional elements will be zeroed out.
|
|||
/// @a _Out will typically be either std::string or bytes.
|
|||
/// @a _T will typically by uint, u160, u256 or bigint.
|
|||
template <class _T, class _Out> |
|||
inline void toBigEndian(_T _val, _Out& o_out) |
|||
{ |
|||
for (auto i = o_out.size(); i-- != 0; _val >>= 8) |
|||
o_out[i] = (typename _Out::value_type)(uint8_t)_val; |
|||
} |
|||
|
|||
/// Converts a big-endian byte-stream represented on a templated collection to a templated integer value.
|
|||
/// @a _In will typically be either std::string or bytes.
|
|||
/// @a _T will typically by uint, u160, u256 or bigint.
|
|||
template <class _T, class _In> |
|||
inline _T fromBigEndian(_In const& _bytes) |
|||
{ |
|||
_T ret = 0; |
|||
for (auto i: _bytes) |
|||
ret = (ret << 8) | (byte)(typename std::make_unsigned<typename _In::value_type>::type)i; |
|||
return ret; |
|||
} |
|||
|
|||
/// Convenience functions for toBigEndian
|
|||
inline std::string toBigEndianString(u256 _val) { std::string ret(32, '\0'); toBigEndian(_val, ret); return ret; } |
|||
inline std::string toBigEndianString(u160 _val) { std::string ret(20, '\0'); toBigEndian(_val, ret); return ret; } |
|||
inline bytes toBigEndian(u256 _val) { bytes ret(32); toBigEndian(_val, ret); return ret; } |
|||
inline bytes toBigEndian(u160 _val) { bytes ret(20); toBigEndian(_val, ret); return ret; } |
|||
|
|||
/// Convenience function for toBigEndian.
|
|||
/// @returns a string just big enough to represent @a _val.
|
|||
template <class _T> |
|||
inline std::string toCompactBigEndianString(_T _val) |
|||
{ |
|||
int i = 0; |
|||
for (_T v = _val; v; ++i, v >>= 8) {} |
|||
std::string ret(i, '\0'); |
|||
toBigEndian(_val, ret); |
|||
return ret; |
|||
} |
|||
|
|||
|
|||
// Algorithms for string and string-like collections.
|
|||
|
|||
/// Escapes a string into the C-string representation.
|
|||
/// @p _all if true will escape all characters, not just the unprintable ones.
|
|||
std::string escaped(std::string const& _s, bool _all = true); |
|||
|
|||
/// Determines the length of the common prefix of the two collections given.
|
|||
/// @returns the number of elements both @a _t and @a _u share, in order, at the beginning.
|
|||
/// @example commonPrefix("Hello world!", "Hello, world!") == 5
|
|||
template <class _T, class _U> |
|||
uint commonPrefix(_T const& _t, _U const& _u) |
|||
{ |
|||
uint s = std::min<uint>(_t.size(), _u.size()); |
|||
for (uint i = 0;; ++i) |
|||
if (i == s || _t[i] != _u[i]) |
|||
return i; |
|||
return s; |
|||
} |
|||
|
|||
/// Creates a random, printable, word.
|
|||
std::string randomWord(); |
|||
|
|||
|
|||
// General datatype convenience functions.
|
|||
|
|||
/// Trims a given number of elements from the front of a collection.
|
|||
/// Only works for POD element types.
|
|||
template <class _T> |
|||
void trimFront(_T& _t, uint _elements) |
|||
{ |
|||
static_assert(std::is_pod<typename _T::value_type>::value, ""); |
|||
memmove(_t.data(), _t.data() + _elements, (_t.size() - _elements) * sizeof(_t[0])); |
|||
_t.resize(_t.size() - _elements); |
|||
} |
|||
|
|||
/// Pushes an element on to the front of a collection.
|
|||
/// Only works for POD element types.
|
|||
template <class _T, class _U> |
|||
void pushFront(_T& _t, _U _e) |
|||
{ |
|||
static_assert(std::is_pod<typename _T::value_type>::value, ""); |
|||
_t.push_back(_e); |
|||
memmove(_t.data() + 1, _t.data(), (_t.size() - 1) * sizeof(_e)); |
|||
_t[0] = _e; |
|||
} |
|||
|
|||
/// Concatenate two vectors of elements. _T must be POD.
|
|||
template <class _T> |
|||
inline std::vector<_T>& operator+=(std::vector<typename std::enable_if<std::is_pod<_T>::value, _T>::type>& _a, std::vector<_T> const& _b) |
|||
{ |
|||
auto s = _a.size(); |
|||
_a.resize(_a.size() + _b.size()); |
|||
memcpy(_a.data() + s, _b.data(), _b.size() * sizeof(_T)); |
|||
return _a; |
|||
|
|||
} |
|||
|
|||
/// Concatenate two vectors of elements. _T must be POD.
|
|||
template <class _T> |
|||
inline std::vector<_T> operator+(std::vector<typename std::enable_if<std::is_pod<_T>::value, _T>::type> const& _a, std::vector<_T> const& _b) |
|||
{ |
|||
std::vector<_T> ret(_a); |
|||
return ret += _b; |
|||
} |
|||
|
|||
} |
|||
@ -0,0 +1,200 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum 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. |
|||
|
|||
cpp-ethereum 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 cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file CommonEth.cpp
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "CommonEth.h" |
|||
|
|||
#if WIN32 |
|||
#pragma warning(push) |
|||
#pragma warning(disable:4244) |
|||
#else |
|||
#pragma GCC diagnostic ignored "-Wunused-function" |
|||
#endif |
|||
#include <secp256k1.h> |
|||
#include <sha3.h> |
|||
#if WIN32 |
|||
#pragma warning(pop) |
|||
#else |
|||
#endif |
|||
#include "Exceptions.h" |
|||
using namespace std; |
|||
using namespace eth; |
|||
|
|||
//#define ETH_ADDRESS_DEBUG 1
|
|||
|
|||
static const vector<pair<u256, string>> g_units = |
|||
{ |
|||
{((((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000, "Uether"}, |
|||
{((((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000, "Vether"}, |
|||
{((((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000, "Dether"}, |
|||
{(((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000, "Nether"}, |
|||
{(((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000, "Yether"}, |
|||
{(((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000, "Zether"}, |
|||
{((u256(1000000000) * 1000000000) * 1000000000) * 1000000000, "Eether"}, |
|||
{((u256(1000000000) * 1000000000) * 1000000000) * 1000000, "Pether"}, |
|||
{((u256(1000000000) * 1000000000) * 1000000000) * 1000, "Tether"}, |
|||
{(u256(1000000000) * 1000000000) * 1000000000, "Gether"}, |
|||
{(u256(1000000000) * 1000000000) * 1000000, "Mether"}, |
|||
{(u256(1000000000) * 1000000000) * 1000, "Kether"}, |
|||
{u256(1000000000) * 1000000000, "ether"}, |
|||
{u256(1000000000) * 1000000, "finney"}, |
|||
{u256(1000000000) * 1000, "szabo"}, |
|||
{u256(1000000000), "Gwei"}, |
|||
{u256(1000000), "Mwei"}, |
|||
{u256(1000), "Kwei"}, |
|||
{u256(1), "wei"} |
|||
}; |
|||
|
|||
vector<pair<u256, string>> const& eth::units() |
|||
{ |
|||
return g_units; |
|||
} |
|||
|
|||
std::string eth::formatBalance(u256 _b) |
|||
{ |
|||
ostringstream ret; |
|||
if (_b > g_units[0].first * 10000) |
|||
{ |
|||
ret << (_b / g_units[0].first) << " " << g_units[0].second; |
|||
return ret.str(); |
|||
} |
|||
ret << setprecision(5); |
|||
for (auto const& i: g_units) |
|||
if (i.first != 1 && _b >= i.first * 100) |
|||
{ |
|||
ret << (double(_b / (i.first / 1000)) / 1000.0) << " " << i.second; |
|||
return ret.str(); |
|||
} |
|||
ret << _b << " wei"; |
|||
return ret.str(); |
|||
} |
|||
|
|||
Address eth::toAddress(Secret _private) |
|||
{ |
|||
secp256k1_start(); |
|||
|
|||
byte pubkey[65]; |
|||
int pubkeylen = 65; |
|||
int ok = secp256k1_ecdsa_seckey_verify(_private.data()); |
|||
if (!ok) |
|||
return Address(); |
|||
ok = secp256k1_ecdsa_pubkey_create(pubkey, &pubkeylen, _private.data(), 0); |
|||
assert(pubkeylen == 65); |
|||
if (!ok) |
|||
return Address(); |
|||
ok = secp256k1_ecdsa_pubkey_verify(pubkey, 65); |
|||
if (!ok) |
|||
return Address(); |
|||
auto ret = right160(eth::sha3(bytesConstRef(&(pubkey[1]), 64))); |
|||
#if ETH_ADDRESS_DEBUG |
|||
cout << "---- ADDRESS -------------------------------" << endl; |
|||
cout << "SEC: " << _private << endl; |
|||
cout << "PUB: " << toHex(bytesConstRef(&(pubkey[1]), 64)) << endl; |
|||
cout << "ADR: " << ret << endl; |
|||
#endif |
|||
return ret; |
|||
} |
|||
|
|||
KeyPair KeyPair::create() |
|||
{ |
|||
secp256k1_start(); |
|||
static std::mt19937_64 s_eng(time(0)); |
|||
std::uniform_int_distribution<uint16_t> d(0, 255); |
|||
|
|||
for (int i = 0; i < 100; ++i) |
|||
{ |
|||
h256 sec; |
|||
for (unsigned i = 0; i < 32; ++i) |
|||
sec[i] = (byte)d(s_eng); |
|||
|
|||
KeyPair ret(sec); |
|||
if (ret.address()) |
|||
return ret; |
|||
} |
|||
return KeyPair(); |
|||
} |
|||
|
|||
KeyPair::KeyPair(h256 _sec): |
|||
m_secret(_sec) |
|||
{ |
|||
int ok = secp256k1_ecdsa_seckey_verify(m_secret.data()); |
|||
if (!ok) |
|||
return; |
|||
|
|||
byte pubkey[65]; |
|||
int pubkeylen = 65; |
|||
ok = secp256k1_ecdsa_pubkey_create(pubkey, &pubkeylen, m_secret.data(), 0); |
|||
if (!ok || pubkeylen != 65) |
|||
return; |
|||
|
|||
ok = secp256k1_ecdsa_pubkey_verify(pubkey, 65); |
|||
if (!ok) |
|||
return; |
|||
|
|||
m_secret = m_secret; |
|||
memcpy(m_public.data(), &(pubkey[1]), 64); |
|||
m_address = right160(eth::sha3(bytesConstRef(&(pubkey[1]), 64))); |
|||
|
|||
#if ETH_ADDRESS_DEBUG |
|||
cout << "---- ADDRESS -------------------------------" << endl; |
|||
cout << "SEC: " << m_secret << endl; |
|||
cout << "PUB: " << m_public << endl; |
|||
cout << "ADR: " << m_address << endl; |
|||
#endif |
|||
} |
|||
|
|||
std::string eth::sha3(std::string const& _input, bool _hex) |
|||
{ |
|||
if (!_hex) |
|||
{ |
|||
string ret(32, '\0'); |
|||
sha3(bytesConstRef((byte const*)_input.data(), _input.size()), bytesRef((byte*)ret.data(), 32)); |
|||
return ret; |
|||
} |
|||
|
|||
uint8_t buf[32]; |
|||
sha3(bytesConstRef((byte const*)_input.data(), _input.size()), bytesRef((byte*)&(buf[0]), 32)); |
|||
std::string ret(64, '\0'); |
|||
for (unsigned int i = 0; i < 32; i++) |
|||
sprintf((char*)(ret.data())+i*2, "%02x", buf[i]); |
|||
return ret; |
|||
} |
|||
|
|||
void eth::sha3(bytesConstRef _input, bytesRef _output) |
|||
{ |
|||
CryptoPP::SHA3_256 ctx; |
|||
ctx.Update((byte*)_input.data(), _input.size()); |
|||
assert(_output.size() >= 32); |
|||
ctx.Final(_output.data()); |
|||
} |
|||
|
|||
bytes eth::sha3Bytes(bytesConstRef _input) |
|||
{ |
|||
bytes ret(32); |
|||
sha3(_input, &ret); |
|||
return ret; |
|||
} |
|||
|
|||
h256 eth::sha3(bytesConstRef _input) |
|||
{ |
|||
h256 ret; |
|||
sha3(_input, bytesRef(&ret[0], 32)); |
|||
return ret; |
|||
} |
|||
@ -0,0 +1,137 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum 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. |
|||
|
|||
cpp-ethereum 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 cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file CommonEth.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
* |
|||
* Ethereum-specific data structures & algorithms. |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include "Common.h" |
|||
#include "FixedHash.h" |
|||
|
|||
namespace eth |
|||
{ |
|||
|
|||
/// A secret key: 32 bytes.
|
|||
/// @NOTE This is not endian-specific; it's just a bunch of bytes.
|
|||
using Secret = h256; |
|||
|
|||
/// A public key: 64 bytes.
|
|||
/// @NOTE This is not endian-specific; it's just a bunch of bytes.
|
|||
using Public = h512; |
|||
|
|||
/// An Ethereum address: 20 bytes.
|
|||
/// @NOTE This is not endian-specific; it's just a bunch of bytes.
|
|||
using Address = h160; |
|||
|
|||
/// A vector of Ethereum addresses.
|
|||
using Addresses = h160s; |
|||
|
|||
/// User-friendly string representation of the amount _b in wei.
|
|||
std::string formatBalance(u256 _b); |
|||
|
|||
/// Get information concerning the currency denominations.
|
|||
std::vector<std::pair<u256, std::string>> const& units(); |
|||
|
|||
// The various denominations; here for ease of use where needed within code.
|
|||
static const u256 Uether = ((((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000; |
|||
static const u256 Vether = ((((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000; |
|||
static const u256 Dether = ((((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000; |
|||
static const u256 Nether = (((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000000; |
|||
static const u256 Yether = (((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000000; |
|||
static const u256 Zether = (((u256(1000000000) * 1000000000) * 1000000000) * 1000000000) * 1000; |
|||
static const u256 Eether = ((u256(1000000000) * 1000000000) * 1000000000) * 1000000000; |
|||
static const u256 Pether = ((u256(1000000000) * 1000000000) * 1000000000) * 1000000; |
|||
static const u256 Tether = ((u256(1000000000) * 1000000000) * 1000000000) * 1000; |
|||
static const u256 Gether = (u256(1000000000) * 1000000000) * 1000000000; |
|||
static const u256 Mether = (u256(1000000000) * 1000000000) * 1000000; |
|||
static const u256 Kether = (u256(1000000000) * 1000000000) * 1000; |
|||
static const u256 ether = u256(1000000000) * 1000000000; |
|||
static const u256 finney = u256(1000000000) * 1000000; |
|||
static const u256 szabo = u256(1000000000) * 1000; |
|||
static const u256 Gwei = u256(1000000000); |
|||
static const u256 Mwei = u256(1000000); |
|||
static const u256 Kwei = u256(1000); |
|||
static const u256 wei = u256(1); |
|||
|
|||
/// Convert a private key into the public key equivalent.
|
|||
/// @returns 0 if it's not a valid private key.
|
|||
Address toAddress(h256 _private); |
|||
|
|||
/// Simple class that represents a "key pair".
|
|||
/// All of the data of the class can be regenerated from the secret key (m_secret) alone.
|
|||
/// Actually stores a tuplet of secret, public and address (the right 160-bits of the public).
|
|||
class KeyPair |
|||
{ |
|||
public: |
|||
/// Null constructor.
|
|||
KeyPair() {} |
|||
|
|||
/// Normal constructor - populates object from the given secret key.
|
|||
KeyPair(Secret _k); |
|||
|
|||
/// Create a new, randomly generated object.
|
|||
static KeyPair create(); |
|||
|
|||
/// Retrieve the secret key.
|
|||
Secret const& secret() const { return m_secret; } |
|||
/// Retrieve the secret key.
|
|||
Secret const& sec() const { return m_secret; } |
|||
|
|||
/// Retrieve the public key.
|
|||
Public const& pub() const { return m_public; } |
|||
|
|||
/// Retrieve the associated address of the public key.
|
|||
Address const& address() const { return m_address; } |
|||
|
|||
private: |
|||
Secret m_secret; |
|||
Public m_public; |
|||
Address m_address; |
|||
}; |
|||
|
|||
|
|||
// SHA-3 convenience routines.
|
|||
|
|||
/// Calculate SHA3-256 hash of the given input and load it into the given output.
|
|||
void sha3(bytesConstRef _input, bytesRef _output); |
|||
|
|||
/// Calculate SHA3-256 hash of the given input, possibly interpreting it as nibbles, and return the hash as a string filled with binary data.
|
|||
std::string sha3(std::string const& _input, bool _isNibbles); |
|||
|
|||
/// Calculate SHA3-256 hash of the given input, returning as a byte array.
|
|||
bytes sha3Bytes(bytesConstRef _input); |
|||
|
|||
/// Calculate SHA3-256 hash of the given input (presented as a binary string), returning as a byte array.
|
|||
inline bytes sha3Bytes(std::string const& _input) { return sha3Bytes((std::string*)&_input); } |
|||
|
|||
/// Calculate SHA3-256 hash of the given input, returning as a byte array.
|
|||
inline bytes sha3Bytes(bytes const& _input) { return sha3Bytes((bytes*)&_input); } |
|||
|
|||
/// Calculate SHA3-256 hash of the given input, returning as a 256-bit hash.
|
|||
h256 sha3(bytesConstRef _input); |
|||
|
|||
/// Calculate SHA3-256 hash of the given input, returning as a 256-bit hash.
|
|||
inline h256 sha3(bytes const& _input) { return sha3(bytesConstRef((bytes*)&_input)); } |
|||
|
|||
/// Calculate SHA3-256 hash of the given input (presented as a binary-filled string), returning as a 256-bit hash.
|
|||
inline h256 sha3(std::string const& _input) { return sha3(bytesConstRef(_input)); } |
|||
|
|||
} |
|||
@ -0,0 +1,48 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum 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. |
|||
|
|||
cpp-ethereum 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 cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file CommonIO.cpp
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "Common.h" |
|||
|
|||
#include <fstream> |
|||
#include "Exceptions.h" |
|||
using namespace std; |
|||
using namespace eth; |
|||
|
|||
bytes eth::contents(std::string const& _file) |
|||
{ |
|||
std::ifstream is(_file, std::ifstream::binary); |
|||
if (!is) |
|||
return bytes(); |
|||
// get length of file:
|
|||
is.seekg (0, is.end); |
|||
streamoff length = is.tellg(); |
|||
is.seekg (0, is.beg); |
|||
bytes ret(length); |
|||
is.read((char*)ret.data(), length); |
|||
is.close(); |
|||
return ret; |
|||
} |
|||
|
|||
void eth::writeFile(std::string const& _file, bytes const& _data) |
|||
{ |
|||
ofstream(_file, ios::trunc).write((char const*)_data.data(), _data.size()); |
|||
} |
|||
|
|||
@ -0,0 +1,223 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum 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. |
|||
|
|||
cpp-ethereum 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 cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file CommonIO.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
* |
|||
* File & stream I/O routines. |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <map> |
|||
#include <set> |
|||
#include <unordered_map> |
|||
#include <unordered_set> |
|||
#include <array> |
|||
#include <list> |
|||
#include <memory> |
|||
#include <vector> |
|||
#include <array> |
|||
#include <sstream> |
|||
#include <string> |
|||
#include <iostream> |
|||
#include "Common.h" |
|||
|
|||
namespace eth |
|||
{ |
|||
|
|||
/// Retrieve and returns the contents of the given file. If the file doesn't exist or isn't readable, returns an empty bytes.
|
|||
bytes contents(std::string const& _file); |
|||
|
|||
/// Write the given binary data into the given file, replacing the file if it pre-exists.
|
|||
void writeFile(std::string const& _file, bytes const& _data); |
|||
|
|||
/// Converts arbitrary value to string representation using std::stringstream.
|
|||
template <class _T> |
|||
std::string toString(_T const& _t) |
|||
{ |
|||
std::ostringstream o; |
|||
o << _t; |
|||
return o.str(); |
|||
} |
|||
|
|||
// Stream I/O functions.
|
|||
// Provides templated stream I/O for all STL collections so they can be shifted on to any iostream-like interface.
|
|||
|
|||
template <class S, class T> struct StreamOut { static S& bypass(S& _out, T const& _t) { _out << _t; return _out; } }; |
|||
template <class S> struct StreamOut<S, uint8_t> { static S& bypass(S& _out, uint8_t const& _t) { _out << (int)_t; return _out; } }; |
|||
|
|||
template <class S, class T> |
|||
inline S& streamout(S& _out, std::vector<T> const& _e) |
|||
{ |
|||
_out << "["; |
|||
if (!_e.empty()) |
|||
{ |
|||
StreamOut<S, T>::bypass(_out, _e.front()); |
|||
for (auto i = ++_e.begin(); i != _e.end(); ++i) |
|||
StreamOut<S, T>::bypass(_out << ",", *i); |
|||
} |
|||
_out << "]"; |
|||
return _out; |
|||
} |
|||
|
|||
template <class T> inline std::ostream& operator<<(std::ostream& _out, std::vector<T> const& _e) { streamout(_out, _e); return _out; } |
|||
|
|||
template <class S, class T, unsigned Z> |
|||
inline S& streamout(S& _out, std::array<T, Z> const& _e) |
|||
{ |
|||
_out << "["; |
|||
if (!_e.empty()) |
|||
{ |
|||
StreamOut<S, T>::bypass(_out, _e.front()); |
|||
auto i = _e.begin(); |
|||
for (++i; i != _e.end(); ++i) |
|||
StreamOut<S, T>::bypass(_out << ",", *i); |
|||
} |
|||
_out << "]"; |
|||
return _out; |
|||
} |
|||
template <class T, unsigned Z> inline std::ostream& operator<<(std::ostream& _out, std::array<T, Z> const& _e) { streamout(_out, _e); return _out; } |
|||
|
|||
template <class S, class T, unsigned long Z> |
|||
inline S& streamout(S& _out, std::array<T, Z> const& _e) |
|||
{ |
|||
_out << "["; |
|||
if (!_e.empty()) |
|||
{ |
|||
StreamOut<S, T>::bypass(_out, _e.front()); |
|||
auto i = _e.begin(); |
|||
for (++i; i != _e.end(); ++i) |
|||
StreamOut<S, T>::bypass(_out << ",", *i); |
|||
} |
|||
_out << "]"; |
|||
return _out; |
|||
} |
|||
template <class T, unsigned long Z> inline std::ostream& operator<<(std::ostream& _out, std::array<T, Z> const& _e) { streamout(_out, _e); return _out; } |
|||
|
|||
template <class S, class T> |
|||
inline S& streamout(S& _out, std::list<T> const& _e) |
|||
{ |
|||
_out << "["; |
|||
if (!_e.empty()) |
|||
{ |
|||
_out << _e.front(); |
|||
for (auto i = ++_e.begin(); i != _e.end(); ++i) |
|||
_out << "," << *i; |
|||
} |
|||
_out << "]"; |
|||
return _out; |
|||
} |
|||
template <class T> inline std::ostream& operator<<(std::ostream& _out, std::list<T> const& _e) { streamout(_out, _e); return _out; } |
|||
|
|||
template <class S, class T, class U> |
|||
inline S& streamout(S& _out, std::pair<T, U> const& _e) |
|||
{ |
|||
_out << "(" << _e.first << "," << _e.second << ")"; |
|||
return _out; |
|||
} |
|||
template <class T, class U> inline std::ostream& operator<<(std::ostream& _out, std::pair<T, U> const& _e) { streamout(_out, _e); return _out; } |
|||
|
|||
template <class S, class T1, class T2, class T3> |
|||
inline S& streamout(S& _out, std::tuple<T1, T2, T3> const& _t) |
|||
{ |
|||
_out << "(" << std::get<0>(_t) << "," << std::get<1>(_t) << "," << std::get<2>(_t) << ")"; |
|||
return _out; |
|||
} |
|||
template <class T1, class T2, class T3> inline std::ostream& operator<<(std::ostream& _out, std::tuple<T1, T2, T3> const& _e) { streamout(_out, _e); return _out; } |
|||
|
|||
template <class S, class T, class U> |
|||
S& streamout(S& _out, std::map<T, U> const& _v) |
|||
{ |
|||
if (_v.empty()) |
|||
return _out << "{}"; |
|||
int i = 0; |
|||
for (auto p: _v) |
|||
_out << (!(i++) ? "{ " : "; ") << p.first << " => " << p.second; |
|||
return _out << " }"; |
|||
} |
|||
template <class T, class U> inline std::ostream& operator<<(std::ostream& _out, std::map<T, U> const& _e) { streamout(_out, _e); return _out; } |
|||
|
|||
template <class S, class T, class U> |
|||
S& streamout(S& _out, std::unordered_map<T, U> const& _v) |
|||
{ |
|||
if (_v.empty()) |
|||
return _out << "{}"; |
|||
int i = 0; |
|||
for (auto p: _v) |
|||
_out << (!(i++) ? "{ " : "; ") << p.first << " => " << p.second; |
|||
return _out << " }"; |
|||
} |
|||
template <class T, class U> inline std::ostream& operator<<(std::ostream& _out, std::unordered_map<T, U> const& _e) { streamout(_out, _e); return _out; } |
|||
|
|||
template <class S, class T> |
|||
S& streamout(S& _out, std::set<T> const& _v) |
|||
{ |
|||
if (_v.empty()) |
|||
return _out << "{}"; |
|||
int i = 0; |
|||
for (auto p: _v) |
|||
_out << (!(i++) ? "{ " : ", ") << p; |
|||
return _out << " }"; |
|||
} |
|||
template <class T> inline std::ostream& operator<<(std::ostream& _out, std::set<T> const& _e) { streamout(_out, _e); return _out; } |
|||
|
|||
template <class S, class T> |
|||
S& streamout(S& _out, std::unordered_set<T> const& _v) |
|||
{ |
|||
if (_v.empty()) |
|||
return _out << "{}"; |
|||
int i = 0; |
|||
for (auto p: _v) |
|||
_out << (!(i++) ? "{ " : ", ") << p; |
|||
return _out << " }"; |
|||
} |
|||
template <class T> inline std::ostream& operator<<(std::ostream& _out, std::unordered_set<T> const& _e) { streamout(_out, _e); return _out; } |
|||
|
|||
template <class S, class T> |
|||
S& streamout(S& _out, std::multiset<T> const& _v) |
|||
{ |
|||
if (_v.empty()) |
|||
return _out << "{}"; |
|||
int i = 0; |
|||
for (auto p: _v) |
|||
_out << (!(i++) ? "{ " : ", ") << p; |
|||
return _out << " }"; |
|||
} |
|||
template <class T> inline std::ostream& operator<<(std::ostream& _out, std::multiset<T> const& _e) { streamout(_out, _e); return _out; } |
|||
|
|||
template <class S, class T, class U> |
|||
S& streamout(S& _out, std::multimap<T, U> const& _v) |
|||
{ |
|||
if (_v.empty()) |
|||
return _out << "{}"; |
|||
T l; |
|||
int i = 0; |
|||
for (auto p: _v) |
|||
if (!(i++)) |
|||
_out << "{ " << (l = p.first) << " => " << p.second; |
|||
else if (l == p.first) |
|||
_out << ", " << p.second; |
|||
else |
|||
_out << "; " << (l = p.first) << " => " << p.second; |
|||
return _out << " }"; |
|||
} |
|||
template <class T, class U> inline std::ostream& operator<<(std::ostream& _out, std::multimap<T, U> const& _e) { streamout(_out, _e); return _out; } |
|||
|
|||
template <class _S, class _T> _S& operator<<(_S& _out, std::shared_ptr<_T> const& _p) { if (_p) _out << "@" << (*_p); else _out << "nullptr"; return _out; } |
|||
|
|||
} |
|||
@ -0,0 +1,25 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum 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. |
|||
|
|||
cpp-ethereum 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 cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file FixedHash.cpp
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "FixedHash.h" |
|||
|
|||
using namespace std; |
|||
using namespace eth; |
|||
@ -0,0 +1,195 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum 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. |
|||
|
|||
cpp-ethereum 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 cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file FixedHash.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
* |
|||
* The FixedHash fixed-size "hash" container type. |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <array> |
|||
#include <algorithm> |
|||
#include "CommonData.h" |
|||
|
|||
namespace eth |
|||
{ |
|||
|
|||
/// Fixed-size raw-byte array container type, with an API optimised for storing hashes.
|
|||
/// Transparently converts to/from the corresponding arithmetic type; this will
|
|||
/// assume the data contained in the hash is big-endian.
|
|||
template <unsigned N> |
|||
class FixedHash |
|||
{ |
|||
/// The corresponding arithmetic type.
|
|||
using Arith = boost::multiprecision::number<boost::multiprecision::cpp_int_backend<N * 8, N * 8, boost::multiprecision::unsigned_magnitude, boost::multiprecision::unchecked, void>>; |
|||
|
|||
public: |
|||
/// The size of the container.
|
|||
enum { size = N }; |
|||
|
|||
/// A dummy flag to avoid accidental construction from pointer.
|
|||
enum ConstructFromPointerType { ConstructFromPointer }; |
|||
|
|||
/// Method to convert from a string.
|
|||
enum ConstructFromStringType { FromHex, FromBinary }; |
|||
|
|||
/// Construct an empty hash.
|
|||
FixedHash() { m_data.fill(0); } |
|||
|
|||
/// Convert from the corresponding arithmetic type.
|
|||
FixedHash(Arith const& _arith) { toBigEndian(_arith, m_data); } |
|||
|
|||
/// Explicitly construct, copying from a byte array.
|
|||
explicit FixedHash(bytes const& _b) { if (_b.size() == N) memcpy(m_data.data(), _b.data(), std::min<uint>(_b.size(), N)); } |
|||
|
|||
/// Explicitly construct, copying from a bytes in memory with given pointer.
|
|||
explicit FixedHash(byte const* _bs, ConstructFromPointerType) { memcpy(m_data.data(), _bs, N); } |
|||
|
|||
/// Explicitly construct, copying from a string.
|
|||
explicit FixedHash(std::string const& _s, ConstructFromStringType _t = FromHex): FixedHash(_t == FromHex ? fromHex(_s) : eth::asBytes(_s)) {} |
|||
|
|||
/// Convert to arithmetic type.
|
|||
operator Arith() const { return fromBigEndian<Arith>(m_data); } |
|||
|
|||
/// @returns true iff this is the empty hash.
|
|||
operator bool() const { return ((Arith)*this) != 0; } |
|||
|
|||
// The obvious comparison operators.
|
|||
bool operator==(FixedHash const& _c) const { return m_data == _c.m_data; } |
|||
bool operator!=(FixedHash const& _c) const { return m_data != _c.m_data; } |
|||
bool operator<(FixedHash const& _c) const { return m_data < _c.m_data; } |
|||
|
|||
// The obvious binary operators.
|
|||
FixedHash& operator^=(FixedHash const& _c) { for (auto i = 0; i < N; ++i) m_data[i] ^= _c.m_data[i]; return *this; } |
|||
FixedHash operator^(FixedHash const& _c) const { return FixedHash(*this) ^= _c; } |
|||
FixedHash& operator|=(FixedHash const& _c) { for (auto i = 0; i < N; ++i) m_data[i] |= _c.m_data[i]; return *this; } |
|||
FixedHash operator|(FixedHash const& _c) const { return FixedHash(*this) |= _c; } |
|||
FixedHash& operator&=(FixedHash const& _c) { for (auto i = 0; i < N; ++i) m_data[i] &= _c.m_data[i]; return *this; } |
|||
FixedHash operator&(FixedHash const& _c) const { return FixedHash(*this) &= _c; } |
|||
FixedHash& operator~() { for (auto i = 0; i < N; ++i) m_data[i] = ~m_data[i]; return *this; } |
|||
|
|||
/// @returns a particular byte from the hash.
|
|||
byte& operator[](unsigned _i) { return m_data[_i]; } |
|||
/// @returns a particular byte from the hash.
|
|||
byte operator[](unsigned _i) const { return m_data[_i]; } |
|||
|
|||
/// @returns an abridged version of the hash as a user-readable hex string.
|
|||
std::string abridged() const { return toHex(ref().cropped(0, 4)) + ".."; } |
|||
|
|||
/// @returns a mutable byte vector_ref to the object's data.
|
|||
bytesRef ref() { return bytesRef(m_data.data(), N); } |
|||
|
|||
/// @returns a constant byte vector_ref to the object's data.
|
|||
bytesConstRef ref() const { return bytesConstRef(m_data.data(), N); } |
|||
|
|||
/// @returns a mutable byte pointer to the object's data.
|
|||
byte* data() { return m_data.data(); } |
|||
|
|||
/// @returns a constant byte pointer to the object's data.
|
|||
byte const* data() const { return m_data.data(); } |
|||
|
|||
/// @returns a copy of the object's data as a byte vector.
|
|||
bytes asBytes() const { return bytes(data(), data() + N); } |
|||
|
|||
/// @returns a mutable reference to the object's data as an STL array.
|
|||
std::array<byte, N>& asArray() { return m_data; } |
|||
|
|||
/// @returns a constant reference to the object's data as an STL array.
|
|||
std::array<byte, N> const& asArray() const { return m_data; } |
|||
|
|||
/// A generic std::hash compatible function object.
|
|||
struct hash |
|||
{ |
|||
/// Make a hash of the object's data.
|
|||
size_t operator()(FixedHash const& value) const |
|||
{ |
|||
size_t h = 0; |
|||
for (auto i: value.m_data) |
|||
h = (h << 5 - h) + i; |
|||
return h; |
|||
} |
|||
}; |
|||
|
|||
private: |
|||
std::array<byte, N> m_data; ///< The binary data.
|
|||
}; |
|||
|
|||
|
|||
/// Fast equality operator for h256.
|
|||
template<> inline bool FixedHash<32>::operator==(FixedHash<32> const& _other) const |
|||
{ |
|||
const uint64_t* hash1 = (const uint64_t*)this->data(); |
|||
const uint64_t* hash2 = (const uint64_t*)_other.data(); |
|||
return (hash1[0] == hash2[0]) && (hash1[1] == hash2[1]) && (hash1[2] == hash2[2]) && (hash1[3] == hash2[3]); |
|||
} |
|||
|
|||
/// Fast std::hash compatible hash function object for h256.
|
|||
template<> inline size_t FixedHash<32>::hash::operator()(FixedHash<32> const& value) const |
|||
{ |
|||
const uint64_t*data = (const uint64_t*)value.data(); |
|||
uint64_t hash = data[0]; |
|||
hash ^= data[1]; |
|||
hash ^= data[2]; |
|||
hash ^= data[3]; |
|||
return (size_t)hash; |
|||
} |
|||
|
|||
/// Stream I/O for the FixedHash class.
|
|||
template <unsigned N> |
|||
inline std::ostream& operator<<(std::ostream& _out, FixedHash<N> const& _h) |
|||
{ |
|||
_out << std::noshowbase << std::hex << std::setfill('0'); |
|||
for (unsigned i = 0; i < N; ++i) |
|||
_out << std::setw(2) << (int)_h[i]; |
|||
_out << std::dec; |
|||
return _out; |
|||
} |
|||
|
|||
// Common types of FixedHash.
|
|||
using h512 = FixedHash<64>; |
|||
using h256 = FixedHash<32>; |
|||
using h160 = FixedHash<20>; |
|||
using h256s = std::vector<h256>; |
|||
using h160s = std::vector<h160>; |
|||
using h256Set = std::set<h256>; |
|||
using h160Set = std::set<h160>; |
|||
|
|||
/// Convert the given value into h160 (160-bit unsigned integer) using the right 20 bytes.
|
|||
inline h160 right160(h256 const& _t) |
|||
{ |
|||
h160 ret; |
|||
memcpy(ret.data(), _t.data() + 12, 20); |
|||
return ret; |
|||
} |
|||
|
|||
/// Convert the given value into h160 (160-bit unsigned integer) using the left 20 bytes.
|
|||
inline h160 left160(h256 const& _t) |
|||
{ |
|||
h160 ret; |
|||
memcpy(&ret[0], _t.data(), 20); |
|||
return ret; |
|||
} |
|||
|
|||
} |
|||
|
|||
namespace std |
|||
{ |
|||
/// Forward std::hash<eth::h256> to eth::h256::hash.
|
|||
template<> struct hash<eth::h256>: eth::h256::hash {}; |
|||
} |
|||
@ -0,0 +1,41 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum 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. |
|||
|
|||
cpp-ethereum 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 cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file Log.cpp
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "Log.h" |
|||
|
|||
#include <string> |
|||
#include <iostream> |
|||
using namespace std; |
|||
using namespace eth; |
|||
|
|||
// Logging
|
|||
int eth::g_logVerbosity = 8; |
|||
map<type_info const*, bool> eth::g_logOverride; |
|||
|
|||
ThreadLocalLogName eth::t_logThreadName("main"); |
|||
|
|||
void eth::simpleDebugOut(std::string const& _s, char const*) |
|||
{ |
|||
cout << _s << endl << flush; |
|||
} |
|||
|
|||
std::function<void(std::string const&, char const*)> eth::g_logPost = simpleDebugOut; |
|||
|
|||
@ -0,0 +1,134 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum 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. |
|||
|
|||
cpp-ethereum 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 cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file Log.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
* |
|||
* The logging subsystem. |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <ctime> |
|||
#include <chrono> |
|||
#include <boost/thread.hpp> |
|||
#include "vector_ref.h" |
|||
|
|||
namespace eth |
|||
{ |
|||
|
|||
/// The null output stream. Used when logging is disabled.
|
|||
class NullOutputStream |
|||
{ |
|||
public: |
|||
template <class T> NullOutputStream& operator<<(T const&) { return *this; } |
|||
}; |
|||
|
|||
/// A simple log-output function that prints log messages to stdout.
|
|||
void simpleDebugOut(std::string const&, char const* ); |
|||
|
|||
/// The logging system's current verbosity.
|
|||
extern int g_logVerbosity; |
|||
|
|||
/// The current method that the logging system uses to output the log messages. Defaults to simpleDebugOut().
|
|||
extern std::function<void(std::string const&, char const*)> g_logPost; |
|||
|
|||
/// Map of Log Channel types to bool, false forces the channel to be disabled, true forces it to be enabled.
|
|||
/// If a channel has no entry, then it will output as long as its verbosity (LogChannel::verbosity) is less than
|
|||
/// or equal to the currently output verbosity (g_logVerbosity).
|
|||
extern std::map<std::type_info const*, bool> g_logOverride; |
|||
|
|||
/// Associate a name with each thread for nice logging.
|
|||
struct ThreadLocalLogName |
|||
{ |
|||
ThreadLocalLogName(std::string _name) { m_name.reset(new std::string(_name)); }; |
|||
boost::thread_specific_ptr<std::string> m_name; |
|||
}; |
|||
|
|||
/// The current thread's name.
|
|||
extern ThreadLocalLogName t_logThreadName; |
|||
|
|||
/// Set the current thread's log name.
|
|||
inline void setThreadName(char const* _n) { t_logThreadName.m_name.reset(new std::string(_n)); } |
|||
|
|||
/// The default logging channels. Each has an associated verbosity and three-letter prefix (name() ).
|
|||
/// Channels should inherit from LogChannel and define name() and verbosity.
|
|||
struct LogChannel { static const char* name() { return " "; } static const int verbosity = 1; }; |
|||
struct LeftChannel: public LogChannel { static const char* name() { return "<<<"; } }; |
|||
struct RightChannel: public LogChannel { static const char* name() { return ">>>"; } }; |
|||
struct WarnChannel: public LogChannel { static const char* name() { return "!!!"; } static const int verbosity = 0; }; |
|||
struct NoteChannel: public LogChannel { static const char* name() { return "***"; } }; |
|||
struct DebugChannel: public LogChannel { static const char* name() { return "---"; } static const int verbosity = 0; }; |
|||
|
|||
/// Logging class, iostream-like, that can be shifted to.
|
|||
template <class Id, bool _AutoSpacing = true> |
|||
class LogOutputStream |
|||
{ |
|||
public: |
|||
/// Construct a new object.
|
|||
/// If _term is true the the prefix info is terminated with a ']' character; if not it ends only with a '|' character.
|
|||
LogOutputStream(bool _term = true) |
|||
{ |
|||
std::type_info const* i = &typeid(Id); |
|||
auto it = g_logOverride.find(i); |
|||
if ((it != g_logOverride.end() && it->second == true) || (it == g_logOverride.end() && Id::verbosity <= g_logVerbosity)) |
|||
{ |
|||
time_t rawTime = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now()); |
|||
char buf[24]; |
|||
if (strftime(buf, 24, "%X", localtime(&rawTime)) == 0) |
|||
buf[0] = '\0'; // empty if case strftime fails
|
|||
m_sstr << Id::name() << " [ " << buf << " | " << *(t_logThreadName.m_name.get()) << (_term ? " ] " : ""); |
|||
} |
|||
} |
|||
|
|||
/// Destructor. Posts the accrued log entry to the g_logPost function.
|
|||
~LogOutputStream() { if (Id::verbosity <= g_logVerbosity) g_logPost(m_sstr.str(), Id::name()); } |
|||
|
|||
/// Shift arbitrary data to the log. Spaces will be added between items as required.
|
|||
template <class T> LogOutputStream& operator<<(T const& _t) { if (Id::verbosity <= g_logVerbosity) { if (_AutoSpacing && m_sstr.str().size() && m_sstr.str().back() != ' ') m_sstr << " "; m_sstr << _t; } return *this; } |
|||
|
|||
private: |
|||
std::stringstream m_sstr; ///< The accrued log entry.
|
|||
}; |
|||
|
|||
// Simple cout-like stream objects for accessing common log channels.
|
|||
// Dirties the global namespace, but oh so convenient...
|
|||
#define cnote eth::LogOutputStream<eth::NoteChannel, true>() |
|||
#define cwarn eth::LogOutputStream<eth::WarnChannel, true>() |
|||
|
|||
// Null stream-like objects.
|
|||
#define ndebug if (true) {} else eth::NullOutputStream() |
|||
#define nlog(X) if (true) {} else eth::NullOutputStream() |
|||
#define nslog(X) if (true) {} else eth::NullOutputStream() |
|||
|
|||
// Kill debugging log channel when we're in release mode.
|
|||
#if NDEBUG |
|||
#define cdebug ndebug |
|||
#else |
|||
#define cdebug eth::LogOutputStream<eth::DebugChannel, true>() |
|||
#endif |
|||
|
|||
// Kill all logs when when NLOG is defined.
|
|||
#if NLOG |
|||
#define clog(X) nlog(X) |
|||
#define cslog(X) nslog(X) |
|||
#else |
|||
#define clog(X) eth::LogOutputStream<X, true>() |
|||
#define cslog(X) eth::LogOutputStream<X, false>() |
|||
#endif |
|||
|
|||
} |
|||
File diff suppressed because it is too large
@ -0,0 +1,542 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum 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. |
|||
|
|||
cpp-ethereum 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 cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file PeerNetwork.cpp
|
|||
* @authors: |
|||
* Gav Wood <i@gavwood.com> |
|||
* Eric Lombrozo <elombrozo@gmail.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "PeerServer.h" |
|||
|
|||
#include <sys/types.h> |
|||
#ifdef _WIN32 |
|||
// winsock is already included
|
|||
// #include <winsock.h>
|
|||
#else |
|||
#include <ifaddrs.h> |
|||
#endif |
|||
|
|||
#include <set> |
|||
#include <chrono> |
|||
#include <thread> |
|||
#include "Exceptions.h" |
|||
#include "Common.h" |
|||
#include "BlockChain.h" |
|||
#include "BlockInfo.h" |
|||
#include "TransactionQueue.h" |
|||
#include "UPnP.h" |
|||
#include "PeerSession.h" |
|||
using namespace std; |
|||
using namespace eth; |
|||
|
|||
// Addresses we will skip during network interface discovery
|
|||
// Use a vector as the list is small
|
|||
// Why this and not names?
|
|||
// Under MacOSX loopback (127.0.0.1) can be named lo0 and br0 are bridges (0.0.0.0)
|
|||
static const set<bi::address> c_rejectAddresses = { |
|||
{bi::address_v4::from_string("127.0.0.1")}, |
|||
{bi::address_v6::from_string("::1")}, |
|||
{bi::address_v4::from_string("0.0.0.0")}, |
|||
{bi::address_v6::from_string("::")} |
|||
}; |
|||
|
|||
PeerServer::PeerServer(std::string const& _clientVersion, BlockChain const& _ch, uint _networkId, unsigned short _port, NodeMode _m, string const& _publicAddress, bool _upnp): |
|||
m_clientVersion(_clientVersion), |
|||
m_mode(_m), |
|||
m_listenPort(_port), |
|||
m_chain(&_ch), |
|||
m_acceptor(m_ioService, bi::tcp::endpoint(bi::tcp::v4(), _port)), |
|||
m_socket(m_ioService), |
|||
m_key(KeyPair::create()), |
|||
m_networkId(_networkId) |
|||
{ |
|||
populateAddresses(); |
|||
determinePublic(_publicAddress, _upnp); |
|||
ensureAccepting(); |
|||
clog(NetNote) << "Id:" << toHex(m_key.address().ref().cropped(0, 4)) << "Mode: " << (_m == NodeMode::PeerServer ? "PeerServer" : "Full"); |
|||
} |
|||
|
|||
PeerServer::PeerServer(std::string const& _clientVersion, uint _networkId, NodeMode _m): |
|||
m_clientVersion(_clientVersion), |
|||
m_mode(_m), |
|||
m_listenPort(0), |
|||
m_acceptor(m_ioService, bi::tcp::endpoint(bi::tcp::v4(), 0)), |
|||
m_socket(m_ioService), |
|||
m_key(KeyPair::create()), |
|||
m_networkId(_networkId) |
|||
{ |
|||
// populate addresses.
|
|||
populateAddresses(); |
|||
clog(NetNote) << "Id:" << toHex(m_key.address().ref().cropped(0, 4)) << "Mode: " << (m_mode == NodeMode::PeerServer ? "PeerServer" : "Full"); |
|||
} |
|||
|
|||
PeerServer::~PeerServer() |
|||
{ |
|||
for (auto const& i: m_peers) |
|||
if (auto p = i.second.lock()) |
|||
p->disconnect(ClientQuit); |
|||
delete m_upnp; |
|||
} |
|||
|
|||
unsigned PeerServer::protocolVersion() |
|||
{ |
|||
return 8; |
|||
} |
|||
|
|||
void PeerServer::determinePublic(string const& _publicAddress, bool _upnp) |
|||
{ |
|||
if (_upnp) |
|||
try |
|||
{ |
|||
m_upnp = new UPnP; |
|||
} |
|||
catch (NoUPnPDevice) {} // let m_upnp continue as null - we handle it properly.
|
|||
|
|||
bi::tcp::resolver r(m_ioService); |
|||
if (m_upnp && m_upnp->isValid() && m_peerAddresses.size()) |
|||
{ |
|||
clog(NetNote) << "External addr: " << m_upnp->externalIP(); |
|||
int p = m_upnp->addRedirect(m_peerAddresses[0].to_string().c_str(), m_listenPort); |
|||
if (p) |
|||
clog(NetNote) << "Punched through NAT and mapped local port" << m_listenPort << "onto external port" << p << "."; |
|||
else |
|||
{ |
|||
// couldn't map
|
|||
clog(NetWarn) << "Couldn't punch through NAT (or no NAT in place). Assuming " << m_listenPort << " is local & external port."; |
|||
p = m_listenPort; |
|||
} |
|||
|
|||
auto eip = m_upnp->externalIP(); |
|||
if (eip == string("0.0.0.0") && _publicAddress.empty()) |
|||
m_public = bi::tcp::endpoint(bi::address(), (unsigned short)p); |
|||
else |
|||
{ |
|||
m_public = bi::tcp::endpoint(bi::address::from_string(_publicAddress.empty() ? eip : _publicAddress), (unsigned short)p); |
|||
m_addresses.push_back(m_public.address().to_v4()); |
|||
} |
|||
} |
|||
else |
|||
{ |
|||
// No UPnP - fallback on given public address or, if empty, the assumed peer address.
|
|||
m_public = bi::tcp::endpoint(_publicAddress.size() ? bi::address::from_string(_publicAddress) |
|||
: m_peerAddresses.size() ? m_peerAddresses[0] |
|||
: bi::address(), m_listenPort); |
|||
m_addresses.push_back(m_public.address().to_v4()); |
|||
} |
|||
} |
|||
|
|||
void PeerServer::populateAddresses() |
|||
{ |
|||
#ifdef _WIN32 |
|||
WSAData wsaData; |
|||
if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0) |
|||
throw NoNetworking(); |
|||
|
|||
char ac[80]; |
|||
if (gethostname(ac, sizeof(ac)) == SOCKET_ERROR) |
|||
{ |
|||
clog(NetWarn) << "Error " << WSAGetLastError() << " when getting local host name."; |
|||
WSACleanup(); |
|||
throw NoNetworking(); |
|||
} |
|||
|
|||
struct hostent* phe = gethostbyname(ac); |
|||
if (phe == 0) |
|||
{ |
|||
clog(NetWarn) << "Bad host lookup."; |
|||
WSACleanup(); |
|||
throw NoNetworking(); |
|||
} |
|||
|
|||
for (int i = 0; phe->h_addr_list[i] != 0; ++i) |
|||
{ |
|||
struct in_addr addr; |
|||
memcpy(&addr, phe->h_addr_list[i], sizeof(struct in_addr)); |
|||
char *addrStr = inet_ntoa(addr); |
|||
bi::address ad(bi::address::from_string(addrStr)); |
|||
m_addresses.push_back(ad.to_v4()); |
|||
bool isLocal = std::find(c_rejectAddresses.begin(), c_rejectAddresses.end(), ad) != c_rejectAddresses.end(); |
|||
if (!isLocal) |
|||
m_peerAddresses.push_back(ad.to_v4()); |
|||
clog(NetNote) << "Address: " << ac << " = " << m_addresses.back() << (isLocal ? " [LOCAL]" : " [PEER]"); |
|||
} |
|||
|
|||
WSACleanup(); |
|||
#else |
|||
ifaddrs* ifaddr; |
|||
if (getifaddrs(&ifaddr) == -1) |
|||
throw NoNetworking(); |
|||
|
|||
bi::tcp::resolver r(m_ioService); |
|||
|
|||
for (ifaddrs* ifa = ifaddr; ifa; ifa = ifa->ifa_next) |
|||
{ |
|||
if (!ifa->ifa_addr) |
|||
continue; |
|||
if (ifa->ifa_addr->sa_family == AF_INET) |
|||
{ |
|||
char host[NI_MAXHOST]; |
|||
if (getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in), host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST)) |
|||
continue; |
|||
// TODO: Make exception safe when no internet.
|
|||
auto it = r.resolve({host, "30303"}); |
|||
bi::tcp::endpoint ep = it->endpoint(); |
|||
bi::address ad = ep.address(); |
|||
m_addresses.push_back(ad.to_v4()); |
|||
bool isLocal = std::find(c_rejectAddresses.begin(), c_rejectAddresses.end(), ad) != c_rejectAddresses.end(); |
|||
if (!isLocal) |
|||
m_peerAddresses.push_back(ad.to_v4()); |
|||
clog(NetNote) << "Address: " << host << " = " << m_addresses.back() << (isLocal ? " [LOCAL]" : " [PEER]"); |
|||
} |
|||
} |
|||
|
|||
freeifaddrs(ifaddr); |
|||
#endif |
|||
} |
|||
|
|||
std::map<Public, bi::tcp::endpoint> PeerServer::potentialPeers() |
|||
{ |
|||
std::map<Public, bi::tcp::endpoint> ret; |
|||
if (!m_public.address().is_unspecified()) |
|||
ret.insert(make_pair(m_key.pub(), m_public)); |
|||
for (auto i: m_peers) |
|||
if (auto j = i.second.lock()) |
|||
{ |
|||
auto ep = j->endpoint(); |
|||
// Skip peers with a listen port of zero or are on a private network
|
|||
bool peerOnNet = (j->m_listenPort != 0 && !isPrivateAddress(ep.address())); |
|||
if (peerOnNet && ep.port() && j->m_id) |
|||
ret.insert(make_pair(i.first, ep)); |
|||
} |
|||
return ret; |
|||
} |
|||
|
|||
void PeerServer::ensureAccepting() |
|||
{ |
|||
if (m_accepting == false) |
|||
{ |
|||
clog(NetNote) << "Listening on local port " << m_listenPort << " (public: " << m_public << ")"; |
|||
m_accepting = true; |
|||
m_acceptor.async_accept(m_socket, [=](boost::system::error_code ec) |
|||
{ |
|||
if (!ec) |
|||
try |
|||
{ |
|||
try { |
|||
clog(NetNote) << "Accepted connection from " << m_socket.remote_endpoint(); |
|||
} catch (...){} |
|||
bi::address remoteAddress = m_socket.remote_endpoint().address(); |
|||
// Port defaults to 0 - we let the hello tell us which port the peer listens to
|
|||
auto p = std::make_shared<PeerSession>(this, std::move(m_socket), m_networkId, remoteAddress); |
|||
p->start(); |
|||
} |
|||
catch (std::exception const& _e) |
|||
{ |
|||
clog(NetWarn) << "ERROR: " << _e.what(); |
|||
} |
|||
m_accepting = false; |
|||
if (ec.value() != 1 && (m_mode == NodeMode::PeerServer || m_peers.size() < m_idealPeerCount * 2)) |
|||
ensureAccepting(); |
|||
}); |
|||
} |
|||
} |
|||
|
|||
void PeerServer::connect(std::string const& _addr, unsigned short _port) noexcept |
|||
{ |
|||
try |
|||
{ |
|||
connect(bi::tcp::endpoint(bi::address::from_string(_addr), _port)); |
|||
} |
|||
catch (exception const& e) |
|||
{ |
|||
// Couldn't connect
|
|||
clog(NetNote) << "Bad host " << _addr << " (" << e.what() << ")"; |
|||
} |
|||
} |
|||
|
|||
void PeerServer::connect(bi::tcp::endpoint const& _ep) |
|||
{ |
|||
clog(NetNote) << "Attempting connection to " << _ep; |
|||
bi::tcp::socket* s = new bi::tcp::socket(m_ioService); |
|||
s->async_connect(_ep, [=](boost::system::error_code const& ec) |
|||
{ |
|||
if (ec) |
|||
{ |
|||
clog(NetNote) << "Connection refused to " << _ep << " (" << ec.message() << ")"; |
|||
for (auto i = m_incomingPeers.begin(); i != m_incomingPeers.end(); ++i) |
|||
if (i->second.first == _ep && i->second.second < 3) |
|||
{ |
|||
m_freePeers.push_back(i->first); |
|||
goto OK; |
|||
} |
|||
// for-else
|
|||
clog(NetNote) << "Giving up."; |
|||
OK:; |
|||
} |
|||
else |
|||
{ |
|||
auto p = make_shared<PeerSession>(this, std::move(*s), m_networkId, _ep.address(), _ep.port()); |
|||
clog(NetNote) << "Connected to " << _ep; |
|||
p->start(); |
|||
} |
|||
delete s; |
|||
}); |
|||
} |
|||
|
|||
bool PeerServer::sync() |
|||
{ |
|||
bool ret = false; |
|||
if (isInitialised()) |
|||
for (auto i = m_peers.begin(); i != m_peers.end();) |
|||
{ |
|||
auto p = i->second.lock(); |
|||
if (p && p->m_socket.is_open() && |
|||
(p->m_disconnect == chrono::steady_clock::time_point::max() || chrono::steady_clock::now() - p->m_disconnect < chrono::seconds(1))) // kill old peers that should be disconnected.
|
|||
++i; |
|||
else |
|||
{ |
|||
i = m_peers.erase(i); |
|||
ret = true; |
|||
} |
|||
} |
|||
return ret; |
|||
} |
|||
|
|||
bool PeerServer::ensureInitialised(BlockChain& _bc, TransactionQueue& _tq) |
|||
{ |
|||
if (m_latestBlockSent == h256()) |
|||
{ |
|||
// First time - just initialise.
|
|||
m_latestBlockSent = _bc.currentHash(); |
|||
clog(NetNote) << "Initialising: latest=" << m_latestBlockSent; |
|||
|
|||
for (auto const& i: _tq.transactions()) |
|||
m_transactionsSent.insert(i.first); |
|||
m_lastPeersRequest = chrono::steady_clock::time_point::min(); |
|||
return true; |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
bool PeerServer::sync(BlockChain& _bc, TransactionQueue& _tq, Overlay& _o) |
|||
{ |
|||
bool ret = ensureInitialised(_bc, _tq); |
|||
|
|||
if (sync()) |
|||
ret = true; |
|||
|
|||
if (m_mode == NodeMode::Full) |
|||
{ |
|||
for (auto it = m_incomingTransactions.begin(); it != m_incomingTransactions.end(); ++it) |
|||
if (_tq.import(*it)) |
|||
{}//ret = true; // just putting a transaction in the queue isn't enough to change the state - it might have an invalid nonce...
|
|||
else |
|||
m_transactionsSent.insert(sha3(*it)); // if we already had the transaction, then don't bother sending it on.
|
|||
m_incomingTransactions.clear(); |
|||
|
|||
auto h = _bc.currentHash(); |
|||
bool resendAll = (h != m_latestBlockSent); |
|||
|
|||
// Send any new transactions.
|
|||
for (auto j: m_peers) |
|||
if (auto p = j.second.lock()) |
|||
{ |
|||
bytes b; |
|||
uint n = 0; |
|||
for (auto const& i: _tq.transactions()) |
|||
if ((!m_transactionsSent.count(i.first) && !p->m_knownTransactions.count(i.first)) || p->m_requireTransactions || resendAll) |
|||
{ |
|||
b += i.second; |
|||
++n; |
|||
m_transactionsSent.insert(i.first); |
|||
} |
|||
if (n) |
|||
{ |
|||
RLPStream ts; |
|||
PeerSession::prep(ts); |
|||
ts.appendList(n + 1) << TransactionsPacket; |
|||
ts.appendRaw(b, n).swapOut(b); |
|||
seal(b); |
|||
p->send(&b); |
|||
} |
|||
p->m_knownTransactions.clear(); |
|||
p->m_requireTransactions = false; |
|||
} |
|||
|
|||
// Send any new blocks.
|
|||
if (h != m_latestBlockSent) |
|||
{ |
|||
// TODO: find where they diverge and send complete new branch.
|
|||
RLPStream ts; |
|||
PeerSession::prep(ts); |
|||
ts.appendList(2) << BlocksPacket; |
|||
bytes b; |
|||
ts.appendRaw(_bc.block(_bc.currentHash())).swapOut(b); |
|||
seal(b); |
|||
for (auto j: m_peers) |
|||
if (auto p = j.second.lock()) |
|||
{ |
|||
if (!p->m_knownBlocks.count(_bc.currentHash())) |
|||
p->send(&b); |
|||
p->m_knownBlocks.clear(); |
|||
} |
|||
} |
|||
m_latestBlockSent = h; |
|||
|
|||
for (int accepted = 1, n = 0; accepted; ++n) |
|||
{ |
|||
accepted = 0; |
|||
|
|||
if (m_incomingBlocks.size()) |
|||
for (auto it = prev(m_incomingBlocks.end());; --it) |
|||
{ |
|||
try |
|||
{ |
|||
_bc.import(*it, _o); |
|||
it = m_incomingBlocks.erase(it); |
|||
++accepted; |
|||
ret = true; |
|||
} |
|||
catch (UnknownParent) |
|||
{ |
|||
// Don't (yet) know its parent. Leave it for later.
|
|||
m_unknownParentBlocks.push_back(*it); |
|||
it = m_incomingBlocks.erase(it); |
|||
} |
|||
catch (...) |
|||
{ |
|||
// Some other error - erase it.
|
|||
it = m_incomingBlocks.erase(it); |
|||
} |
|||
|
|||
if (it == m_incomingBlocks.begin()) |
|||
break; |
|||
} |
|||
if (!n && accepted) |
|||
{ |
|||
for (auto i: m_unknownParentBlocks) |
|||
m_incomingBlocks.push_back(i); |
|||
m_unknownParentBlocks.clear(); |
|||
} |
|||
} |
|||
|
|||
// Connect to additional peers
|
|||
while (m_peers.size() < m_idealPeerCount) |
|||
{ |
|||
if (m_freePeers.empty()) |
|||
{ |
|||
if (chrono::steady_clock::now() > m_lastPeersRequest + chrono::seconds(10)) |
|||
{ |
|||
RLPStream s; |
|||
bytes b; |
|||
(PeerSession::prep(s).appendList(1) << GetPeersPacket).swapOut(b); |
|||
seal(b); |
|||
for (auto const& i: m_peers) |
|||
if (auto p = i.second.lock()) |
|||
if (p->isOpen()) |
|||
p->send(&b); |
|||
m_lastPeersRequest = chrono::steady_clock::now(); |
|||
} |
|||
|
|||
|
|||
if (!m_accepting) |
|||
ensureAccepting(); |
|||
|
|||
break; |
|||
} |
|||
|
|||
auto x = time(0) % m_freePeers.size(); |
|||
m_incomingPeers[m_freePeers[x]].second++; |
|||
connect(m_incomingPeers[m_freePeers[x]].first); |
|||
m_freePeers.erase(m_freePeers.begin() + x); |
|||
} |
|||
} |
|||
|
|||
// platform for consensus of social contract.
|
|||
// restricts your freedom but does so fairly. and that's the value proposition.
|
|||
// guarantees that everyone else respect the rules of the system. (i.e. obeys laws).
|
|||
|
|||
// We'll keep at most twice as many as is ideal, halfing what counts as "too young to kill" until we get there.
|
|||
for (uint old = 15000; m_peers.size() > m_idealPeerCount * 2 && old > 100; old /= 2) |
|||
while (m_peers.size() > m_idealPeerCount) |
|||
{ |
|||
// look for worst peer to kick off
|
|||
// first work out how many are old enough to kick off.
|
|||
shared_ptr<PeerSession> worst; |
|||
unsigned agedPeers = 0; |
|||
for (auto i: m_peers) |
|||
if (auto p = i.second.lock()) |
|||
if ((m_mode != NodeMode::PeerServer || p->m_caps != 0x01) && chrono::steady_clock::now() > p->m_connect + chrono::milliseconds(old)) // don't throw off new peers; peer-servers should never kick off other peer-servers.
|
|||
{ |
|||
++agedPeers; |
|||
if ((!worst || p->m_rating < worst->m_rating || (p->m_rating == worst->m_rating && p->m_connect > worst->m_connect))) // kill older ones
|
|||
worst = p; |
|||
} |
|||
if (!worst || agedPeers <= m_idealPeerCount) |
|||
break; |
|||
worst->disconnect(TooManyPeers); |
|||
} |
|||
|
|||
return ret; |
|||
} |
|||
|
|||
std::vector<PeerInfo> PeerServer::peers() const |
|||
{ |
|||
const_cast<PeerServer*>(this)->pingAll(); |
|||
this_thread::sleep_for(chrono::milliseconds(200)); |
|||
std::vector<PeerInfo> ret; |
|||
for (auto& i: m_peers) |
|||
if (auto j = i.second.lock()) |
|||
if (j->m_socket.is_open()) |
|||
ret.push_back(j->m_info); |
|||
return ret; |
|||
} |
|||
|
|||
void PeerServer::pingAll() |
|||
{ |
|||
for (auto& i: m_peers) |
|||
if (auto j = i.second.lock()) |
|||
j->ping(); |
|||
} |
|||
|
|||
bytes PeerServer::savePeers() const |
|||
{ |
|||
RLPStream ret; |
|||
int n = 0; |
|||
for (auto& i: m_peers) |
|||
if (auto p = i.second.lock()) |
|||
if (p->m_socket.is_open() && p->endpoint().port()) |
|||
{ |
|||
ret.appendList(3) << p->endpoint().address().to_v4().to_bytes() << p->endpoint().port() << p->m_id; |
|||
n++; |
|||
} |
|||
return RLPStream(n).appendRaw(ret.out(), n).out(); |
|||
} |
|||
|
|||
void PeerServer::restorePeers(bytesConstRef _b) |
|||
{ |
|||
for (auto i: RLP(_b)) |
|||
{ |
|||
auto k = (Public)i[2]; |
|||
if (!m_incomingPeers.count(k)) |
|||
{ |
|||
m_incomingPeers.insert(make_pair(k, make_pair(bi::tcp::endpoint(bi::address_v4(i[0].toArray<byte, 4>()), i[1].toInt<short>()), 0))); |
|||
m_freePeers.push_back(k); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,133 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum 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. |
|||
|
|||
cpp-ethereum 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 cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file PeerServer.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <map> |
|||
#include <vector> |
|||
#include <set> |
|||
#include <memory> |
|||
#include <utility> |
|||
#include <thread> |
|||
#include "PeerNetwork.h" |
|||
#include "CommonEth.h" |
|||
namespace ba = boost::asio; |
|||
namespace bi = boost::asio::ip; |
|||
|
|||
namespace eth |
|||
{ |
|||
|
|||
class PeerServer |
|||
{ |
|||
friend class PeerSession; |
|||
|
|||
public: |
|||
/// Start server, listening for connections on the given port.
|
|||
PeerServer(std::string const& _clientVersion, BlockChain const& _ch, uint _networkId, unsigned short _port, NodeMode _m = NodeMode::Full, std::string const& _publicAddress = std::string(), bool _upnp = true); |
|||
/// Start server, but don't listen.
|
|||
PeerServer(std::string const& _clientVersion, uint _networkId, NodeMode _m = NodeMode::Full); |
|||
~PeerServer(); |
|||
|
|||
static unsigned protocolVersion(); |
|||
unsigned networkId() { return m_networkId; } |
|||
|
|||
/// Connect to a peer explicitly.
|
|||
void connect(std::string const& _addr, unsigned short _port = 30303) noexcept; |
|||
void connect(bi::tcp::endpoint const& _ep); |
|||
|
|||
/// Sync with the BlockChain. It might contain one of our mined blocks, we might have new candidates from the network.
|
|||
bool sync(BlockChain& _bc, TransactionQueue&, Overlay& _o); |
|||
bool sync(); |
|||
|
|||
/// Conduct I/O, polling, syncing, whatever.
|
|||
/// Ideally all time-consuming I/O is done in a background thread or otherwise asynchronously, but you get this call every 100ms or so anyway.
|
|||
/// This won't touch alter the blockchain.
|
|||
void process() { if (isInitialised()) m_ioService.poll(); } |
|||
|
|||
/// Set ideal number of peers.
|
|||
void setIdealPeerCount(unsigned _n) { m_idealPeerCount = _n; } |
|||
|
|||
void setMode(NodeMode _m) { m_mode = _m; } |
|||
|
|||
/// Get peer information.
|
|||
std::vector<PeerInfo> peers() const; |
|||
|
|||
/// Get number of peers connected; equivalent to, but faster than, peers().size().
|
|||
size_t peerCount() const { return m_peers.size(); } |
|||
|
|||
/// Ping the peers, to update the latency information.
|
|||
void pingAll(); |
|||
|
|||
/// Get the port we're listening on currently.
|
|||
unsigned short listenPort() const { return m_public.port(); } |
|||
|
|||
bytes savePeers() const; |
|||
void restorePeers(bytesConstRef _b); |
|||
|
|||
private: |
|||
void seal(bytes& _b); |
|||
void populateAddresses(); |
|||
void determinePublic(std::string const& _publicAddress, bool _upnp); |
|||
void ensureAccepting(); |
|||
|
|||
/// Check to see if the network peer-state initialisation has happened.
|
|||
bool isInitialised() const { return m_latestBlockSent; } |
|||
/// Initialises the network peer-state, doing the stuff that needs to be once-only. @returns true if it really was first.
|
|||
bool ensureInitialised(BlockChain& _bc, TransactionQueue& _tq); |
|||
|
|||
std::map<Public, bi::tcp::endpoint> potentialPeers(); |
|||
|
|||
std::string m_clientVersion; |
|||
NodeMode m_mode = NodeMode::Full; |
|||
|
|||
unsigned short m_listenPort; |
|||
|
|||
BlockChain const* m_chain = nullptr; |
|||
ba::io_service m_ioService; |
|||
bi::tcp::acceptor m_acceptor; |
|||
bi::tcp::socket m_socket; |
|||
|
|||
UPnP* m_upnp = nullptr; |
|||
bi::tcp::endpoint m_public; |
|||
KeyPair m_key; |
|||
|
|||
unsigned m_networkId; |
|||
std::map<Public, std::weak_ptr<PeerSession>> m_peers; |
|||
|
|||
std::vector<bytes> m_incomingTransactions; |
|||
std::vector<bytes> m_incomingBlocks; |
|||
std::vector<bytes> m_unknownParentBlocks; |
|||
std::vector<Public> m_freePeers; |
|||
std::map<Public, std::pair<bi::tcp::endpoint, unsigned>> m_incomingPeers; |
|||
|
|||
h256 m_latestBlockSent; |
|||
std::set<h256> m_transactionsSent; |
|||
|
|||
std::chrono::steady_clock::time_point m_lastPeersRequest; |
|||
unsigned m_idealPeerCount = 5; |
|||
|
|||
std::vector<bi::address_v4> m_addresses; |
|||
std::vector<bi::address_v4> m_peerAddresses; |
|||
|
|||
bool m_accepting = false; |
|||
}; |
|||
|
|||
} |
|||
@ -0,0 +1,585 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum 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. |
|||
|
|||
cpp-ethereum 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 cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file PeerSession.cpp
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "PeerSession.h" |
|||
|
|||
#include <chrono> |
|||
#include "Exceptions.h" |
|||
#include "Common.h" |
|||
#include "BlockChain.h" |
|||
#include "BlockInfo.h" |
|||
#include "PeerServer.h" |
|||
using namespace std; |
|||
using namespace eth; |
|||
|
|||
#define clogS(X) eth::LogOutputStream<X, true>(false) << "| " << std::setw(2) << m_socket.native_handle() << "] " |
|||
|
|||
static const eth::uint c_maxHashes = 32; ///< Maximum number of hashes GetChain will ever send.
|
|||
static const eth::uint c_maxBlocks = 32; ///< Maximum number of blocks Blocks will ever send. BUG: if this gets too big (e.g. 2048) stuff starts going wrong.
|
|||
static const eth::uint c_maxBlocksAsk = 256; ///< Maximum number of blocks we ask to receive in Blocks (when using GetChain).
|
|||
|
|||
PeerSession::PeerSession(PeerServer* _s, bi::tcp::socket _socket, uint _rNId, bi::address _peerAddress, unsigned short _peerPort): |
|||
m_server(_s), |
|||
m_socket(std::move(_socket)), |
|||
m_reqNetworkId(_rNId), |
|||
m_listenPort(_peerPort), |
|||
m_rating(0) |
|||
{ |
|||
m_disconnect = std::chrono::steady_clock::time_point::max(); |
|||
m_connect = std::chrono::steady_clock::now(); |
|||
m_info = PeerInfo({"?", _peerAddress.to_string(), m_listenPort, std::chrono::steady_clock::duration(0)}); |
|||
} |
|||
|
|||
PeerSession::~PeerSession() |
|||
{ |
|||
m_socket.close(); |
|||
} |
|||
|
|||
bi::tcp::endpoint PeerSession::endpoint() const |
|||
{ |
|||
if (m_socket.is_open()) |
|||
try { |
|||
return bi::tcp::endpoint(m_socket.remote_endpoint().address(), m_listenPort); |
|||
} catch (...){} |
|||
|
|||
return bi::tcp::endpoint(); |
|||
} |
|||
|
|||
// TODO: BUG! 256 -> work out why things start to break with big packet sizes -> g.t. ~370 blocks.
|
|||
|
|||
bool PeerSession::interpret(RLP const& _r) |
|||
{ |
|||
clogS(NetRight) << _r; |
|||
switch (_r[0].toInt<unsigned>()) |
|||
{ |
|||
case HelloPacket: |
|||
{ |
|||
m_protocolVersion = _r[1].toInt<uint>(); |
|||
m_networkId = _r[2].toInt<uint>(); |
|||
auto clientVersion = _r[3].toString(); |
|||
m_caps = _r[4].toInt<uint>(); |
|||
m_listenPort = _r[5].toInt<unsigned short>(); |
|||
m_id = _r[6].toHash<h512>(); |
|||
|
|||
clogS(NetMessageSummary) << "Hello: " << clientVersion << "V[" << m_protocolVersion << "/" << m_networkId << "]" << m_id.abridged() << showbase << hex << m_caps << dec << m_listenPort; |
|||
|
|||
if (m_server->m_peers.count(m_id)) |
|||
if (auto l = m_server->m_peers[m_id].lock()) |
|||
if (l.get() != this && l->isOpen()) |
|||
{ |
|||
// Already connected.
|
|||
cwarn << "Already have peer id" << m_id.abridged() << "at" << l->endpoint() << "rather than" << endpoint(); |
|||
disconnect(DuplicatePeer); |
|||
return false; |
|||
} |
|||
|
|||
if (m_protocolVersion != PeerServer::protocolVersion() || m_networkId != m_server->networkId() || !m_id) |
|||
{ |
|||
disconnect(IncompatibleProtocol); |
|||
return false; |
|||
} |
|||
try |
|||
{ m_info = PeerInfo({clientVersion, m_socket.remote_endpoint().address().to_string(), m_listenPort, std::chrono::steady_clock::duration()}); } |
|||
catch (...) |
|||
{ |
|||
disconnect(BadProtocol); |
|||
return false; |
|||
} |
|||
|
|||
m_server->m_peers[m_id] = shared_from_this(); |
|||
|
|||
// Grab their block chain off them.
|
|||
{ |
|||
clogS(NetAllDetail) << "Want chain. Latest:" << m_server->m_latestBlockSent << ", number:" << m_server->m_chain->details(m_server->m_latestBlockSent).number; |
|||
uint count = std::min(c_maxHashes, m_server->m_chain->details(m_server->m_latestBlockSent).number + 1); |
|||
RLPStream s; |
|||
prep(s).appendList(2 + count); |
|||
s << GetChainPacket; |
|||
auto h = m_server->m_latestBlockSent; |
|||
for (uint i = 0; i < count; ++i, h = m_server->m_chain->details(h).parent) |
|||
{ |
|||
clogS(NetAllDetail) << " " << i << ":" << h; |
|||
s << h; |
|||
} |
|||
|
|||
s << c_maxBlocksAsk; |
|||
sealAndSend(s); |
|||
s.clear(); |
|||
prep(s).appendList(1); |
|||
s << GetTransactionsPacket; |
|||
sealAndSend(s); |
|||
} |
|||
break; |
|||
} |
|||
case DisconnectPacket: |
|||
{ |
|||
string reason = "Unspecified"; |
|||
if (_r[1].isInt()) |
|||
reason = reasonOf((DisconnectReason)_r[1].toInt<int>()); |
|||
|
|||
clogS(NetMessageSummary) << "Disconnect (reason: " << reason << ")"; |
|||
if (m_socket.is_open()) |
|||
clogS(NetNote) << "Closing " << m_socket.remote_endpoint(); |
|||
else |
|||
clogS(NetNote) << "Remote closed."; |
|||
m_socket.close(); |
|||
return false; |
|||
} |
|||
case PingPacket: |
|||
{ |
|||
// clogS(NetMessageSummary) << "Ping";
|
|||
RLPStream s; |
|||
sealAndSend(prep(s).appendList(1) << PongPacket); |
|||
break; |
|||
} |
|||
case PongPacket: |
|||
m_info.lastPing = std::chrono::steady_clock::now() - m_ping; |
|||
// clogS(NetMessageSummary) << "Latency: " << chrono::duration_cast<chrono::milliseconds>(m_lastPing).count() << " ms";
|
|||
break; |
|||
case GetPeersPacket: |
|||
{ |
|||
clogS(NetMessageSummary) << "GetPeers"; |
|||
auto peers = m_server->potentialPeers(); |
|||
RLPStream s; |
|||
prep(s).appendList(peers.size() + 1); |
|||
s << PeersPacket; |
|||
for (auto i: peers) |
|||
{ |
|||
clogS(NetMessageDetail) << "Sending peer " << toHex(i.first.ref().cropped(0, 4)) << i.second; |
|||
s.appendList(3) << i.second.address().to_v4().to_bytes() << i.second.port() << i.first; |
|||
} |
|||
sealAndSend(s); |
|||
break; |
|||
} |
|||
case PeersPacket: |
|||
clogS(NetMessageSummary) << "Peers (" << dec << (_r.itemCount() - 1) << " entries)"; |
|||
for (unsigned i = 1; i < _r.itemCount(); ++i) |
|||
{ |
|||
bi::address_v4 peerAddress(_r[i][0].toArray<byte, 4>()); |
|||
auto ep = bi::tcp::endpoint(peerAddress, _r[i][1].toInt<short>()); |
|||
Public id = _r[i][2].toHash<Public>(); |
|||
if (isPrivateAddress(peerAddress)) |
|||
goto CONTINUE; |
|||
|
|||
clogS(NetAllDetail) << "Checking: " << ep << "(" << toHex(id.ref().cropped(0, 4)) << ")"; |
|||
|
|||
// check that it's not us or one we already know:
|
|||
if (id && (m_server->m_key.pub() == id || m_server->m_peers.count(id) || m_server->m_incomingPeers.count(id))) |
|||
goto CONTINUE; |
|||
|
|||
// check that we're not already connected to addr:
|
|||
if (!ep.port()) |
|||
goto CONTINUE; |
|||
for (auto i: m_server->m_addresses) |
|||
if (ep.address() == i && ep.port() == m_server->listenPort()) |
|||
goto CONTINUE; |
|||
for (auto i: m_server->m_peers) |
|||
if (shared_ptr<PeerSession> p = i.second.lock()) |
|||
{ |
|||
clogS(NetAllDetail) << " ...against " << p->endpoint(); |
|||
if (p->m_socket.is_open() && p->endpoint() == ep) |
|||
goto CONTINUE; |
|||
} |
|||
for (auto i: m_server->m_incomingPeers) |
|||
if (i.second.first == ep) |
|||
goto CONTINUE; |
|||
m_server->m_incomingPeers[id] = make_pair(ep, 0); |
|||
m_server->m_freePeers.push_back(id); |
|||
clogS(NetMessageDetail) << "New peer: " << ep << "(" << id << ")"; |
|||
CONTINUE:; |
|||
} |
|||
break; |
|||
case TransactionsPacket: |
|||
if (m_server->m_mode == NodeMode::PeerServer) |
|||
break; |
|||
clogS(NetMessageSummary) << "Transactions (" << dec << (_r.itemCount() - 1) << " entries)"; |
|||
m_rating += _r.itemCount() - 1; |
|||
for (unsigned i = 1; i < _r.itemCount(); ++i) |
|||
{ |
|||
m_server->m_incomingTransactions.push_back(_r[i].data().toBytes()); |
|||
m_knownTransactions.insert(sha3(_r[i].data())); |
|||
} |
|||
break; |
|||
case BlocksPacket: |
|||
{ |
|||
if (m_server->m_mode == NodeMode::PeerServer) |
|||
break; |
|||
clogS(NetMessageSummary) << "Blocks (" << dec << (_r.itemCount() - 1) << " entries)"; |
|||
unsigned used = 0; |
|||
for (unsigned i = 1; i < _r.itemCount(); ++i) |
|||
{ |
|||
auto h = sha3(_r[i].data()); |
|||
if (!m_server->m_chain->details(h)) |
|||
{ |
|||
m_server->m_incomingBlocks.push_back(_r[i].data().toBytes()); |
|||
m_knownBlocks.insert(h); |
|||
used++; |
|||
} |
|||
} |
|||
m_rating += used; |
|||
if (g_logVerbosity >= 3) |
|||
for (unsigned i = 1; i < _r.itemCount(); ++i) |
|||
{ |
|||
auto h = sha3(_r[i].data()); |
|||
BlockInfo bi(_r[i].data()); |
|||
if (!m_server->m_chain->details(bi.parentHash) && !m_knownBlocks.count(bi.parentHash)) |
|||
clogS(NetMessageDetail) << "Unknown parent " << bi.parentHash << " of block " << h; |
|||
else |
|||
clogS(NetMessageDetail) << "Known parent " << bi.parentHash << " of block " << h; |
|||
} |
|||
if (used) // we received some - check if there's any more
|
|||
{ |
|||
RLPStream s; |
|||
prep(s).appendList(3); |
|||
s << GetChainPacket; |
|||
s << sha3(_r[1].data()); |
|||
s << c_maxBlocksAsk; |
|||
sealAndSend(s); |
|||
} |
|||
break; |
|||
} |
|||
case GetChainPacket: |
|||
{ |
|||
if (m_server->m_mode == NodeMode::PeerServer) |
|||
break; |
|||
clogS(NetMessageSummary) << "GetChain (" << (_r.itemCount() - 2) << " hashes, " << (_r[_r.itemCount() - 1].toInt<bigint>()) << ")"; |
|||
// ********************************************************************
|
|||
// NEEDS FULL REWRITE!
|
|||
h256s parents; |
|||
parents.reserve(_r.itemCount() - 2); |
|||
for (unsigned i = 1; i < _r.itemCount() - 1; ++i) |
|||
parents.push_back(_r[i].toHash<h256>()); |
|||
if (_r.itemCount() == 2) |
|||
break; |
|||
// return 2048 block max.
|
|||
uint baseCount = (uint)min<bigint>(_r[_r.itemCount() - 1].toInt<bigint>(), c_maxBlocks); |
|||
clogS(NetMessageSummary) << "GetChain (" << baseCount << " max, from " << parents.front() << " to " << parents.back() << ")"; |
|||
for (auto parent: parents) |
|||
{ |
|||
auto h = m_server->m_chain->currentHash(); |
|||
h256 latest = m_server->m_chain->currentHash(); |
|||
uint latestNumber = 0; |
|||
uint parentNumber = 0; |
|||
RLPStream s; |
|||
|
|||
if (m_server->m_chain->details(parent)) |
|||
{ |
|||
latestNumber = m_server->m_chain->details(latest).number; |
|||
parentNumber = m_server->m_chain->details(parent).number; |
|||
uint count = min<uint>(latestNumber - parentNumber, baseCount); |
|||
clogS(NetAllDetail) << "Requires " << dec << (latestNumber - parentNumber) << " blocks from " << latestNumber << " to " << parentNumber; |
|||
clogS(NetAllDetail) << latest << " - " << parent; |
|||
|
|||
prep(s); |
|||
s.appendList(1 + count) << BlocksPacket; |
|||
uint endNumber = m_server->m_chain->details(parent).number; |
|||
uint startNumber = endNumber + count; |
|||
clogS(NetAllDetail) << "Sending " << dec << count << " blocks from " << startNumber << " to " << endNumber; |
|||
|
|||
uint n = latestNumber; |
|||
for (; n > startNumber; n--, h = m_server->m_chain->details(h).parent) {} |
|||
for (uint i = 0; i < count; ++i, --n, h = m_server->m_chain->details(h).parent) |
|||
{ |
|||
if (h == parent || n == endNumber) |
|||
{ |
|||
cwarn << "BUG! Couldn't create the reply for GetChain!"; |
|||
return true; |
|||
} |
|||
clogS(NetAllDetail) << " " << dec << i << " " << h; |
|||
s.appendRaw(m_server->m_chain->block(h)); |
|||
} |
|||
clogS(NetAllDetail) << "Parent: " << h; |
|||
} |
|||
else if (parent != parents.back()) |
|||
continue; |
|||
|
|||
if (h != parent) |
|||
{ |
|||
// not in the blockchain;
|
|||
if (parent == parents.back()) |
|||
{ |
|||
// out of parents...
|
|||
clogS(NetAllDetail) << "GetChain failed; not in chain"; |
|||
// No good - must have been on a different branch.
|
|||
s.clear(); |
|||
prep(s).appendList(2) << NotInChainPacket << parents.back(); |
|||
} |
|||
else |
|||
// still some parents left - try them.
|
|||
continue; |
|||
} |
|||
// send the packet (either Blocks or NotInChain) & exit.
|
|||
sealAndSend(s); |
|||
break; |
|||
// ********************************************************************
|
|||
} |
|||
break; |
|||
} |
|||
case NotInChainPacket: |
|||
{ |
|||
if (m_server->m_mode == NodeMode::PeerServer) |
|||
break; |
|||
h256 noGood = _r[1].toHash<h256>(); |
|||
clogS(NetMessageSummary) << "NotInChain (" << noGood << ")"; |
|||
if (noGood == m_server->m_chain->genesisHash()) |
|||
{ |
|||
clogS(NetWarn) << "Discordance over genesis block! Disconnect."; |
|||
disconnect(WrongGenesis); |
|||
} |
|||
else |
|||
{ |
|||
uint count = std::min(c_maxHashes, m_server->m_chain->details(noGood).number); |
|||
RLPStream s; |
|||
prep(s).appendList(2 + count); |
|||
s << GetChainPacket; |
|||
auto h = m_server->m_chain->details(noGood).parent; |
|||
for (uint i = 0; i < count; ++i, h = m_server->m_chain->details(h).parent) |
|||
s << h; |
|||
s << c_maxBlocksAsk; |
|||
sealAndSend(s); |
|||
} |
|||
break; |
|||
} |
|||
case GetTransactionsPacket: |
|||
{ |
|||
if (m_server->m_mode == NodeMode::PeerServer) |
|||
break; |
|||
m_requireTransactions = true; |
|||
break; |
|||
} |
|||
default: |
|||
break; |
|||
} |
|||
return true; |
|||
} |
|||
|
|||
void PeerSession::ping() |
|||
{ |
|||
RLPStream s; |
|||
sealAndSend(prep(s).appendList(1) << PingPacket); |
|||
m_ping = std::chrono::steady_clock::now(); |
|||
} |
|||
|
|||
RLPStream& PeerSession::prep(RLPStream& _s) |
|||
{ |
|||
return _s.appendRaw(bytes(8, 0)); |
|||
} |
|||
|
|||
void PeerServer::seal(bytes& _b) |
|||
{ |
|||
_b[0] = 0x22; |
|||
_b[1] = 0x40; |
|||
_b[2] = 0x08; |
|||
_b[3] = 0x91; |
|||
uint32_t len = (uint32_t)_b.size() - 8; |
|||
_b[4] = (len >> 24) & 0xff; |
|||
_b[5] = (len >> 16) & 0xff; |
|||
_b[6] = (len >> 8) & 0xff; |
|||
_b[7] = len & 0xff; |
|||
} |
|||
|
|||
void PeerSession::sealAndSend(RLPStream& _s) |
|||
{ |
|||
bytes b; |
|||
_s.swapOut(b); |
|||
m_server->seal(b); |
|||
sendDestroy(b); |
|||
} |
|||
|
|||
bool PeerSession::checkPacket(bytesConstRef _msg) |
|||
{ |
|||
if (_msg.size() < 8) |
|||
return false; |
|||
if (!(_msg[0] == 0x22 && _msg[1] == 0x40 && _msg[2] == 0x08 && _msg[3] == 0x91)) |
|||
return false; |
|||
uint32_t len = ((_msg[4] * 256 + _msg[5]) * 256 + _msg[6]) * 256 + _msg[7]; |
|||
if (_msg.size() != len + 8) |
|||
return false; |
|||
RLP r(_msg.cropped(8)); |
|||
if (r.actualSize() != len) |
|||
return false; |
|||
return true; |
|||
} |
|||
|
|||
void PeerSession::sendDestroy(bytes& _msg) |
|||
{ |
|||
clogS(NetLeft) << RLP(bytesConstRef(&_msg).cropped(8)); |
|||
|
|||
if (!checkPacket(bytesConstRef(&_msg))) |
|||
{ |
|||
cwarn << "INVALID PACKET CONSTRUCTED!"; |
|||
} |
|||
|
|||
auto self(shared_from_this()); |
|||
bytes* buffer = new bytes(std::move(_msg)); |
|||
ba::async_write(m_socket, ba::buffer(*buffer), [self, buffer](boost::system::error_code ec, std::size_t length) |
|||
{ |
|||
delete buffer; |
|||
if (ec) |
|||
{ |
|||
cwarn << "Error sending: " << ec.message(); |
|||
self->dropped(); |
|||
} |
|||
// cbug << length << " bytes written (EC: " << ec << ")";
|
|||
}); |
|||
} |
|||
|
|||
void PeerSession::send(bytesConstRef _msg) |
|||
{ |
|||
clogS(NetLeft) << RLP(_msg.cropped(8)); |
|||
|
|||
if (!checkPacket(_msg)) |
|||
{ |
|||
cwarn << "INVALID PACKET CONSTRUCTED!"; |
|||
} |
|||
|
|||
auto self(shared_from_this()); |
|||
bytes* buffer = new bytes(_msg.toBytes()); |
|||
ba::async_write(m_socket, ba::buffer(*buffer), [self, buffer](boost::system::error_code ec, std::size_t length) |
|||
{ |
|||
delete buffer; |
|||
if (ec) |
|||
{ |
|||
cwarn << "Error sending: " << ec.message(); |
|||
self->dropped(); |
|||
} |
|||
// cbug << length << " bytes written (EC: " << ec << ")";
|
|||
}); |
|||
} |
|||
|
|||
void PeerSession::dropped() |
|||
{ |
|||
if (m_socket.is_open()) |
|||
try { |
|||
clogS(NetNote) << "Closing " << m_socket.remote_endpoint(); |
|||
m_socket.close(); |
|||
}catch (...){} |
|||
for (auto i = m_server->m_peers.begin(); i != m_server->m_peers.end(); ++i) |
|||
if (i->second.lock().get() == this) |
|||
{ |
|||
m_server->m_peers.erase(i); |
|||
break; |
|||
} |
|||
} |
|||
|
|||
void PeerSession::disconnect(int _reason) |
|||
{ |
|||
clogS(NetNote) << "Disconnecting (reason:" << reasonOf((DisconnectReason)_reason) << ")"; |
|||
if (m_socket.is_open()) |
|||
{ |
|||
if (m_disconnect == chrono::steady_clock::time_point::max()) |
|||
{ |
|||
RLPStream s; |
|||
prep(s); |
|||
s.appendList(2) << DisconnectPacket << _reason; |
|||
sealAndSend(s); |
|||
m_disconnect = chrono::steady_clock::now(); |
|||
} |
|||
else |
|||
dropped(); |
|||
} |
|||
} |
|||
|
|||
void PeerSession::start() |
|||
{ |
|||
RLPStream s; |
|||
prep(s); |
|||
s.appendList(7) << HelloPacket << (uint)PeerServer::protocolVersion() << m_server->networkId() << m_server->m_clientVersion << (m_server->m_mode == NodeMode::Full ? 0x07 : m_server->m_mode == NodeMode::PeerServer ? 0x01 : 0) << m_server->m_public.port() << m_server->m_key.pub(); |
|||
sealAndSend(s); |
|||
|
|||
ping(); |
|||
|
|||
doRead(); |
|||
} |
|||
|
|||
void PeerSession::doRead() |
|||
{ |
|||
auto self(shared_from_this()); |
|||
m_socket.async_read_some(boost::asio::buffer(m_data), [this,self](boost::system::error_code ec, std::size_t length) |
|||
{ |
|||
if (ec) |
|||
{ |
|||
cwarn << "Error reading: " << ec.message(); |
|||
dropped(); |
|||
} |
|||
else |
|||
{ |
|||
try |
|||
{ |
|||
m_incoming.resize(m_incoming.size() + length); |
|||
memcpy(m_incoming.data() + m_incoming.size() - length, m_data.data(), length); |
|||
while (m_incoming.size() > 8) |
|||
{ |
|||
if (m_incoming[0] != 0x22 || m_incoming[1] != 0x40 || m_incoming[2] != 0x08 || m_incoming[3] != 0x91) |
|||
{ |
|||
clogS(NetWarn) << "Out of alignment."; |
|||
disconnect(BadProtocol); |
|||
return; |
|||
clogS(NetNote) << "Skipping: " << hex << showbase << (int)m_incoming[0] << dec; |
|||
memmove(m_incoming.data(), m_incoming.data() + 1, m_incoming.size() - 1); |
|||
m_incoming.resize(m_incoming.size() - 1); |
|||
} |
|||
else |
|||
{ |
|||
uint32_t len = fromBigEndian<uint32_t>(bytesConstRef(m_incoming.data() + 4, 4)); |
|||
uint32_t tlen = len + 8; |
|||
if (m_incoming.size() < tlen) |
|||
break; |
|||
|
|||
// enough has come in.
|
|||
// cerr << "Received " << len << ": " << toHex(bytesConstRef(m_incoming.data() + 8, len)) << endl;
|
|||
auto data = bytesConstRef(m_incoming.data(), tlen); |
|||
if (!checkPacket(data)) |
|||
{ |
|||
cerr << "Received " << len << ": " << toHex(bytesConstRef(m_incoming.data() + 8, len)) << endl; |
|||
cwarn << "INVALID MESSAGE RECEIVED"; |
|||
disconnect(BadProtocol); |
|||
return; |
|||
} |
|||
else |
|||
{ |
|||
RLP r(data.cropped(8)); |
|||
if (!interpret(r)) |
|||
{ |
|||
// error
|
|||
dropped(); |
|||
return; |
|||
} |
|||
} |
|||
memmove(m_incoming.data(), m_incoming.data() + tlen, m_incoming.size() - tlen); |
|||
m_incoming.resize(m_incoming.size() - tlen); |
|||
} |
|||
} |
|||
doRead(); |
|||
} |
|||
catch (Exception const& _e) |
|||
{ |
|||
clogS(NetWarn) << "ERROR: " << _e.description(); |
|||
dropped(); |
|||
} |
|||
catch (std::exception const& _e) |
|||
{ |
|||
clogS(NetWarn) << "ERROR: " << _e.what(); |
|||
dropped(); |
|||
} |
|||
} |
|||
}); |
|||
} |
|||
@ -0,0 +1,90 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum 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. |
|||
|
|||
cpp-ethereum 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 cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file PeerSession.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <array> |
|||
#include <set> |
|||
#include <memory> |
|||
#include <utility> |
|||
#include "RLP.h" |
|||
#include "CommonEth.h" |
|||
#include "PeerNetwork.h" |
|||
|
|||
namespace eth |
|||
{ |
|||
|
|||
class PeerSession: public std::enable_shared_from_this<PeerSession> |
|||
{ |
|||
friend class PeerServer; |
|||
|
|||
public: |
|||
PeerSession(PeerServer* _server, bi::tcp::socket _socket, uint _rNId, bi::address _peerAddress, unsigned short _peerPort = 0); |
|||
~PeerSession(); |
|||
|
|||
void start(); |
|||
void disconnect(int _reason); |
|||
|
|||
void ping(); |
|||
|
|||
bool isOpen() const { return m_socket.is_open(); } |
|||
|
|||
bi::tcp::endpoint endpoint() const; ///< for other peers to connect to.
|
|||
|
|||
private: |
|||
void dropped(); |
|||
void doRead(); |
|||
void doWrite(std::size_t length); |
|||
bool interpret(RLP const& _r); |
|||
|
|||
/// @returns true iff the _msg forms a valid message for sending or receiving on the network.
|
|||
static bool checkPacket(bytesConstRef _msg); |
|||
|
|||
static RLPStream& prep(RLPStream& _s); |
|||
void sealAndSend(RLPStream& _s); |
|||
void sendDestroy(bytes& _msg); |
|||
void send(bytesConstRef _msg); |
|||
PeerServer* m_server; |
|||
|
|||
bi::tcp::socket m_socket; |
|||
std::array<byte, 65536> m_data; |
|||
PeerInfo m_info; |
|||
Public m_id; |
|||
|
|||
bytes m_incoming; |
|||
uint m_protocolVersion; |
|||
uint m_networkId; |
|||
uint m_reqNetworkId; |
|||
unsigned short m_listenPort; ///< Port that the remote client is listening on for connections. Useful for giving to peers.
|
|||
uint m_caps; |
|||
|
|||
std::chrono::steady_clock::time_point m_ping; |
|||
std::chrono::steady_clock::time_point m_connect; |
|||
std::chrono::steady_clock::time_point m_disconnect; |
|||
|
|||
uint m_rating; |
|||
bool m_requireTransactions; |
|||
|
|||
std::set<h256> m_knownBlocks; |
|||
std::set<h256> m_knownTransactions; |
|||
}; |
|||
|
|||
} |
|||
@ -1,8 +0,0 @@ |
|||
#!/bin/bash |
|||
|
|||
set -e |
|||
rm -f ../cpp-ethereum_*_source.changes |
|||
debuild -S -sa |
|||
cd .. |
|||
dput -f ppa:ethereum/ethereum cpp-ethereum_*_source.changes |
|||
|
|||
@ -1,65 +0,0 @@ |
|||
#!/bin/bash |
|||
|
|||
dist="saucy" |
|||
version=$(grep "define ETH_VERSION" libethereum/Common.h | cut -d ' ' -f 3) |
|||
branch="$(git branch | grep \* | cut -c 3-)" |
|||
|
|||
if [[ ! "$1" == "" ]]; then |
|||
version=$1 |
|||
fi |
|||
|
|||
if [[ ! "$3" == "" ]]; then |
|||
if [[ ! "$4" == "" ]]; then |
|||
dist=$4 |
|||
fi |
|||
if [[ "$2" == "-i" ]]; then |
|||
# increment current debian release only |
|||
# new version ./release VERSION -i MESSAGE DIST |
|||
debchange -i -p "$3" -D "$dist" |
|||
git commit -a -m "$3" |
|||
else |
|||
# new version ./release VERSION DEB-VERSION MESSAGE DIST |
|||
debchange -v $version-$2 -p "$3" -D "$dist" |
|||
git commit -a -m "$3" |
|||
fi |
|||
fi |
|||
|
|||
opwd=`pwd` |
|||
cd /tmp |
|||
|
|||
echo Checking out... |
|||
git clone $opwd |
|||
cd cpp-ethereum |
|||
git checkout "$branch" |
|||
|
|||
archdir="cpp-ethereum-$version" |
|||
archfile="$archdir.tar.bz2" |
|||
|
|||
echo Cleaning backup files... |
|||
find . | grep \~ | xargs rm -f |
|||
|
|||
echo Cleaning others... |
|||
rm release.sh |
|||
|
|||
echo Cleaning versioning... |
|||
rm -rf .git .gitignore |
|||
|
|||
echo Renaming directory... |
|||
cd .. |
|||
rm -rf $archdir |
|||
mv cpp-ethereum $archdir |
|||
|
|||
echo Creating archive... |
|||
tar c $archdir | bzip2 -- > $archfile |
|||
|
|||
[[ ! "$version" == "" ]] && ln -sf $archfile "cpp-ethereum_$version.orig.tar.bz2" |
|||
|
|||
echo Packaging... |
|||
cd "$archdir" |
|||
./package.sh |
|||
|
|||
echo Cleaning up... |
|||
rm -rf /tmp/$archdir |
|||
mv /tmp/$archfile ~ |
|||
|
|||
echo Done. |
|||
@ -0,0 +1,25 @@ |
|||
|
|||
function os.capture(cmd) |
|||
local f = io.popen(cmd, 'r') |
|||
if (f) then |
|||
local s = f:read('*a') |
|||
if (f:close()) then |
|||
return s |
|||
end |
|||
end |
|||
return nil |
|||
end |
|||
|
|||
hash = (os.capture("git rev-parse HEAD") or "UnknownRevision"):gsub("\n$", "") |
|||
clean = ((os.capture("git diff --name-only") or "0"):gsub("\n$", "") == "") and "1" or "0" |
|||
|
|||
local output = io.open(arg[1], "w") |
|||
if (output) then |
|||
output:write("// This file was automatically generated by buildinfo.lua\n#pragma once\n\n") |
|||
output:write("#define ETH_COMMIT_HASH "..hash.."\n") |
|||
output:write("#define ETH_CLEAN_REPO "..clean.."\n") |
|||
output:close() |
|||
end |
|||
|
|||
|
|||
|
|||
@ -0,0 +1,16 @@ |
|||
<?xml version="1.0" encoding="utf-8"?> |
|||
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> |
|||
<ItemGroup> |
|||
<ClCompile Include="..\eth\main.cpp" /> |
|||
</ItemGroup> |
|||
<ItemGroup> |
|||
<Filter Include="Windows"> |
|||
<UniqueIdentifier>{ed0eafbf-bbfb-4700-b7c0-9b58049cc681}</UniqueIdentifier> |
|||
</Filter> |
|||
</ItemGroup> |
|||
<ItemGroup> |
|||
<CustomBuild Include="BuildInfo.lua"> |
|||
<Filter>Windows</Filter> |
|||
</CustomBuild> |
|||
</ItemGroup> |
|||
</Project> |
|||
Loading…
Reference in new issue