commit adcdd6cb1b80b669e5377a6446bd6d1b88444200
Author: Shinoa-Fores <btcinfo@sdf.org>
Date: Wed, 13 Jan 2021 16:50:09 -0500
genesis.vpatch
Diffstat:
66 files changed, 26410 insertions(+), 0 deletions(-)
diff --git a/bitcoin/.gitignore b/bitcoin/.gitignore
@@ -0,0 +1,21 @@
+src/*.exe
+src/bitcoin
+src/bitcoind
+.*.swp
+*.*~*
+*.bak
+*.rej
+*.orig
+*.o
+*.patch
+.bitcoin
+#compilation and Qt preprocessor part
+*.qm
+Makefile
+bitcoin-qt
+#resources cpp
+qrc_*.cpp
+#qt creator
+*.pro.user
+#mac specific
+.DS_Store
diff --git a/bitcoin/COPYING b/bitcoin/COPYING
@@ -0,0 +1,19 @@
+Copyright (c) 2009-2012 Bitcoin Developers
+
+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.
diff --git a/bitcoin/src/base58.h b/bitcoin/src/base58.h
@@ -0,0 +1,323 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2011 The Bitcoin Developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+
+//
+// Why base-58 instead of standard base-64 encoding?
+// - Don't want 0OIl characters that look the same in some fonts and
+// could be used to create visually identical looking account numbers.
+// - A string with non-alphanumeric characters is not as easily accepted as an account number.
+// - E-mail usually won't line-break if there's no punctuation to break at.
+// - Doubleclicking selects the whole number as one word if it's all alphanumeric.
+//
+#ifndef BITCOIN_BASE58_H
+#define BITCOIN_BASE58_H
+
+#include <string>
+#include <vector>
+#include "bignum.h"
+
+static const char* pszBase58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+
+// Encode a byte sequence as a base58-encoded string
+inline std::string EncodeBase58(const unsigned char* pbegin, const unsigned char* pend)
+{
+ CAutoBN_CTX pctx;
+ CBigNum bn58 = 58;
+ CBigNum bn0 = 0;
+
+ // Convert big endian data to little endian
+ // Extra zero at the end make sure bignum will interpret as a positive number
+ std::vector<unsigned char> vchTmp(pend-pbegin+1, 0);
+ reverse_copy(pbegin, pend, vchTmp.begin());
+
+ // Convert little endian data to bignum
+ CBigNum bn;
+ bn.setvch(vchTmp);
+
+ // Convert bignum to std::string
+ std::string str;
+ // Expected size increase from base58 conversion is approximately 137%
+ // use 138% to be safe
+ str.reserve((pend - pbegin) * 138 / 100 + 1);
+ CBigNum dv;
+ CBigNum rem;
+ while (bn > bn0)
+ {
+ if (!BN_div(&dv, &rem, &bn, &bn58, pctx))
+ throw bignum_error("EncodeBase58 : BN_div failed");
+ bn = dv;
+ unsigned int c = rem.getulong();
+ str += pszBase58[c];
+ }
+
+ // Leading zeroes encoded as base58 zeros
+ for (const unsigned char* p = pbegin; p < pend && *p == 0; p++)
+ str += pszBase58[0];
+
+ // Convert little endian std::string to big endian
+ reverse(str.begin(), str.end());
+ return str;
+}
+
+// Encode a byte vector as a base58-encoded string
+inline std::string EncodeBase58(const std::vector<unsigned char>& vch)
+{
+ return EncodeBase58(&vch[0], &vch[0] + vch.size());
+}
+
+// Decode a base58-encoded string psz into byte vector vchRet
+// returns true if decoding is succesful
+inline bool DecodeBase58(const char* psz, std::vector<unsigned char>& vchRet)
+{
+ CAutoBN_CTX pctx;
+ vchRet.clear();
+ CBigNum bn58 = 58;
+ CBigNum bn = 0;
+ CBigNum bnChar;
+ while (isspace(*psz))
+ psz++;
+
+ // Convert big endian string to bignum
+ for (const char* p = psz; *p; p++)
+ {
+ const char* p1 = strchr(pszBase58, *p);
+ if (p1 == NULL)
+ {
+ while (isspace(*p))
+ p++;
+ if (*p != '\0')
+ return false;
+ break;
+ }
+ bnChar.setulong(p1 - pszBase58);
+ if (!BN_mul(&bn, &bn, &bn58, pctx))
+ throw bignum_error("DecodeBase58 : BN_mul failed");
+ bn += bnChar;
+ }
+
+ // Get bignum as little endian data
+ std::vector<unsigned char> vchTmp = bn.getvch();
+
+ // Trim off sign byte if present
+ if (vchTmp.size() >= 2 && vchTmp.end()[-1] == 0 && vchTmp.end()[-2] >= 0x80)
+ vchTmp.erase(vchTmp.end()-1);
+
+ // Restore leading zeros
+ int nLeadingZeros = 0;
+ for (const char* p = psz; *p == pszBase58[0]; p++)
+ nLeadingZeros++;
+ vchRet.assign(nLeadingZeros + vchTmp.size(), 0);
+
+ // Convert little endian data to big endian
+ reverse_copy(vchTmp.begin(), vchTmp.end(), vchRet.end() - vchTmp.size());
+ return true;
+}
+
+// Decode a base58-encoded string str into byte vector vchRet
+// returns true if decoding is succesful
+inline bool DecodeBase58(const std::string& str, std::vector<unsigned char>& vchRet)
+{
+ return DecodeBase58(str.c_str(), vchRet);
+}
+
+
+
+
+// Encode a byte vector to a base58-encoded string, including checksum
+inline std::string EncodeBase58Check(const std::vector<unsigned char>& vchIn)
+{
+ // add 4-byte hash check to the end
+ std::vector<unsigned char> vch(vchIn);
+ uint256 hash = Hash(vch.begin(), vch.end());
+ vch.insert(vch.end(), (unsigned char*)&hash, (unsigned char*)&hash + 4);
+ return EncodeBase58(vch);
+}
+
+// Decode a base58-encoded string psz that includes a checksum, into byte vector vchRet
+// returns true if decoding is succesful
+inline bool DecodeBase58Check(const char* psz, std::vector<unsigned char>& vchRet)
+{
+ if (!DecodeBase58(psz, vchRet))
+ return false;
+ if (vchRet.size() < 4)
+ {
+ vchRet.clear();
+ return false;
+ }
+ uint256 hash = Hash(vchRet.begin(), vchRet.end()-4);
+ if (memcmp(&hash, &vchRet.end()[-4], 4) != 0)
+ {
+ vchRet.clear();
+ return false;
+ }
+ vchRet.resize(vchRet.size()-4);
+ return true;
+}
+
+// Decode a base58-encoded string str that includes a checksum, into byte vector vchRet
+// returns true if decoding is succesful
+inline bool DecodeBase58Check(const std::string& str, std::vector<unsigned char>& vchRet)
+{
+ return DecodeBase58Check(str.c_str(), vchRet);
+}
+
+
+
+
+
+// Base class for all base58-encoded data
+class CBase58Data
+{
+protected:
+ // the version byte
+ unsigned char nVersion;
+
+ // the actually encoded data
+ std::vector<unsigned char> vchData;
+
+ CBase58Data()
+ {
+ nVersion = 0;
+ vchData.clear();
+ }
+
+ ~CBase58Data()
+ {
+ // zero the memory, as it may contain sensitive data
+ if (!vchData.empty())
+ memset(&vchData[0], 0, vchData.size());
+ }
+
+ void SetData(int nVersionIn, const void* pdata, size_t nSize)
+ {
+ nVersion = nVersionIn;
+ vchData.resize(nSize);
+ if (!vchData.empty())
+ memcpy(&vchData[0], pdata, nSize);
+ }
+
+ void SetData(int nVersionIn, const unsigned char *pbegin, const unsigned char *pend)
+ {
+ SetData(nVersionIn, (void*)pbegin, pend - pbegin);
+ }
+
+public:
+ bool SetString(const char* psz)
+ {
+ std::vector<unsigned char> vchTemp;
+ DecodeBase58Check(psz, vchTemp);
+ if (vchTemp.empty())
+ {
+ vchData.clear();
+ nVersion = 0;
+ return false;
+ }
+ nVersion = vchTemp[0];
+ vchData.resize(vchTemp.size() - 1);
+ if (!vchData.empty())
+ memcpy(&vchData[0], &vchTemp[1], vchData.size());
+ memset(&vchTemp[0], 0, vchTemp.size());
+ return true;
+ }
+
+ bool SetString(const std::string& str)
+ {
+ return SetString(str.c_str());
+ }
+
+ std::string ToString() const
+ {
+ std::vector<unsigned char> vch(1, nVersion);
+ vch.insert(vch.end(), vchData.begin(), vchData.end());
+ return EncodeBase58Check(vch);
+ }
+
+ int CompareTo(const CBase58Data& b58) const
+ {
+ if (nVersion < b58.nVersion) return -1;
+ if (nVersion > b58.nVersion) return 1;
+ if (vchData < b58.vchData) return -1;
+ if (vchData > b58.vchData) return 1;
+ return 0;
+ }
+
+ bool operator==(const CBase58Data& b58) const { return CompareTo(b58) == 0; }
+ bool operator<=(const CBase58Data& b58) const { return CompareTo(b58) <= 0; }
+ bool operator>=(const CBase58Data& b58) const { return CompareTo(b58) >= 0; }
+ bool operator< (const CBase58Data& b58) const { return CompareTo(b58) < 0; }
+ bool operator> (const CBase58Data& b58) const { return CompareTo(b58) > 0; }
+};
+
+// base58-encoded bitcoin addresses
+// Addresses have version 0 or 111 (testnet)
+// The data vector contains RIPEMD160(SHA256(pubkey)), where pubkey is the serialized public key
+class CBitcoinAddress : public CBase58Data
+{
+public:
+ bool SetHash160(const uint160& hash160)
+ {
+ SetData(fTestNet ? 111 : 0, &hash160, 20);
+ return true;
+ }
+
+ bool SetPubKey(const std::vector<unsigned char>& vchPubKey)
+ {
+ return SetHash160(Hash160(vchPubKey));
+ }
+
+ bool IsValid() const
+ {
+ int nExpectedSize = 20;
+ bool fExpectTestNet = false;
+ switch(nVersion)
+ {
+ case 0:
+ break;
+
+ case 111:
+ fExpectTestNet = true;
+ break;
+
+ default:
+ return false;
+ }
+ return fExpectTestNet == fTestNet && vchData.size() == nExpectedSize;
+ }
+
+ CBitcoinAddress()
+ {
+ }
+
+ CBitcoinAddress(uint160 hash160In)
+ {
+ SetHash160(hash160In);
+ }
+
+ CBitcoinAddress(const std::vector<unsigned char>& vchPubKey)
+ {
+ SetPubKey(vchPubKey);
+ }
+
+ CBitcoinAddress(const std::string& strAddress)
+ {
+ SetString(strAddress);
+ }
+
+ CBitcoinAddress(const char* pszAddress)
+ {
+ SetString(pszAddress);
+ }
+
+ uint160 GetHash160() const
+ {
+ assert(vchData.size() == 20);
+ uint160 hash160;
+ memcpy(&hash160, &vchData[0], 20);
+ return hash160;
+ }
+};
+
+#endif
diff --git a/bitcoin/src/bignum.h b/bitcoin/src/bignum.h
@@ -0,0 +1,538 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2011 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#ifndef BITCOIN_BIGNUM_H
+#define BITCOIN_BIGNUM_H
+
+#include <stdexcept>
+#include <vector>
+#include <openssl/bn.h>
+
+#include "util.h"
+
+class bignum_error : public std::runtime_error
+{
+public:
+ explicit bignum_error(const std::string& str) : std::runtime_error(str) {}
+};
+
+
+
+class CAutoBN_CTX
+{
+protected:
+ BN_CTX* pctx;
+ BN_CTX* operator=(BN_CTX* pnew) { return pctx = pnew; }
+
+public:
+ CAutoBN_CTX()
+ {
+ pctx = BN_CTX_new();
+ if (pctx == NULL)
+ throw bignum_error("CAutoBN_CTX : BN_CTX_new() returned NULL");
+ }
+
+ ~CAutoBN_CTX()
+ {
+ if (pctx != NULL)
+ BN_CTX_free(pctx);
+ }
+
+ operator BN_CTX*() { return pctx; }
+ BN_CTX& operator*() { return *pctx; }
+ BN_CTX** operator&() { return &pctx; }
+ bool operator!() { return (pctx == NULL); }
+};
+
+
+
+class CBigNum : public BIGNUM
+{
+public:
+ CBigNum()
+ {
+ BN_init(this);
+ }
+
+ CBigNum(const CBigNum& b)
+ {
+ BN_init(this);
+ if (!BN_copy(this, &b))
+ {
+ BN_clear_free(this);
+ throw bignum_error("CBigNum::CBigNum(const CBigNum&) : BN_copy failed");
+ }
+ }
+
+ CBigNum& operator=(const CBigNum& b)
+ {
+ if (!BN_copy(this, &b))
+ throw bignum_error("CBigNum::operator= : BN_copy failed");
+ return (*this);
+ }
+
+ ~CBigNum()
+ {
+ BN_clear_free(this);
+ }
+
+ CBigNum(char n) { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
+ CBigNum(short n) { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
+ CBigNum(int n) { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
+ CBigNum(long n) { BN_init(this); if (n >= 0) setulong(n); else setint64(n); }
+ CBigNum(int64 n) { BN_init(this); setint64(n); }
+ CBigNum(unsigned char n) { BN_init(this); setulong(n); }
+ CBigNum(unsigned short n) { BN_init(this); setulong(n); }
+ CBigNum(unsigned int n) { BN_init(this); setulong(n); }
+ CBigNum(unsigned long n) { BN_init(this); setulong(n); }
+ CBigNum(uint64 n) { BN_init(this); setuint64(n); }
+ explicit CBigNum(uint256 n) { BN_init(this); setuint256(n); }
+
+ explicit CBigNum(const std::vector<unsigned char>& vch)
+ {
+ BN_init(this);
+ setvch(vch);
+ }
+
+ void setulong(unsigned long n)
+ {
+ if (!BN_set_word(this, n))
+ throw bignum_error("CBigNum conversion from unsigned long : BN_set_word failed");
+ }
+
+ unsigned long getulong() const
+ {
+ return BN_get_word(this);
+ }
+
+ unsigned int getuint() const
+ {
+ return BN_get_word(this);
+ }
+
+ int getint() const
+ {
+ unsigned long n = BN_get_word(this);
+ if (!BN_is_negative(this))
+ return (n > INT_MAX ? INT_MAX : n);
+ else
+ return (n > INT_MAX ? INT_MIN : -(int)n);
+ }
+
+ void setint64(int64 n)
+ {
+ unsigned char pch[sizeof(n) + 6];
+ unsigned char* p = pch + 4;
+ bool fNegative = false;
+ if (n < (int64)0)
+ {
+ n = -n;
+ fNegative = true;
+ }
+ bool fLeadingZeroes = true;
+ for (int i = 0; i < 8; i++)
+ {
+ unsigned char c = (n >> 56) & 0xff;
+ n <<= 8;
+ if (fLeadingZeroes)
+ {
+ if (c == 0)
+ continue;
+ if (c & 0x80)
+ *p++ = (fNegative ? 0x80 : 0);
+ else if (fNegative)
+ c |= 0x80;
+ fLeadingZeroes = false;
+ }
+ *p++ = c;
+ }
+ unsigned int nSize = p - (pch + 4);
+ pch[0] = (nSize >> 24) & 0xff;
+ pch[1] = (nSize >> 16) & 0xff;
+ pch[2] = (nSize >> 8) & 0xff;
+ pch[3] = (nSize) & 0xff;
+ BN_mpi2bn(pch, p - pch, this);
+ }
+
+ void setuint64(uint64 n)
+ {
+ unsigned char pch[sizeof(n) + 6];
+ unsigned char* p = pch + 4;
+ bool fLeadingZeroes = true;
+ for (int i = 0; i < 8; i++)
+ {
+ unsigned char c = (n >> 56) & 0xff;
+ n <<= 8;
+ if (fLeadingZeroes)
+ {
+ if (c == 0)
+ continue;
+ if (c & 0x80)
+ *p++ = 0;
+ fLeadingZeroes = false;
+ }
+ *p++ = c;
+ }
+ unsigned int nSize = p - (pch + 4);
+ pch[0] = (nSize >> 24) & 0xff;
+ pch[1] = (nSize >> 16) & 0xff;
+ pch[2] = (nSize >> 8) & 0xff;
+ pch[3] = (nSize) & 0xff;
+ BN_mpi2bn(pch, p - pch, this);
+ }
+
+ void setuint256(uint256 n)
+ {
+ unsigned char pch[sizeof(n) + 6];
+ unsigned char* p = pch + 4;
+ bool fLeadingZeroes = true;
+ unsigned char* pbegin = (unsigned char*)&n;
+ unsigned char* psrc = pbegin + sizeof(n);
+ while (psrc != pbegin)
+ {
+ unsigned char c = *(--psrc);
+ if (fLeadingZeroes)
+ {
+ if (c == 0)
+ continue;
+ if (c & 0x80)
+ *p++ = 0;
+ fLeadingZeroes = false;
+ }
+ *p++ = c;
+ }
+ unsigned int nSize = p - (pch + 4);
+ pch[0] = (nSize >> 24) & 0xff;
+ pch[1] = (nSize >> 16) & 0xff;
+ pch[2] = (nSize >> 8) & 0xff;
+ pch[3] = (nSize >> 0) & 0xff;
+ BN_mpi2bn(pch, p - pch, this);
+ }
+
+ uint256 getuint256()
+ {
+ unsigned int nSize = BN_bn2mpi(this, NULL);
+ if (nSize < 4)
+ return 0;
+ std::vector<unsigned char> vch(nSize);
+ BN_bn2mpi(this, &vch[0]);
+ if (vch.size() > 4)
+ vch[4] &= 0x7f;
+ uint256 n = 0;
+ for (int i = 0, j = vch.size()-1; i < sizeof(n) && j >= 4; i++, j--)
+ ((unsigned char*)&n)[i] = vch[j];
+ return n;
+ }
+
+ void setvch(const std::vector<unsigned char>& vch)
+ {
+ std::vector<unsigned char> vch2(vch.size() + 4);
+ unsigned int nSize = vch.size();
+ // BIGNUM's byte stream format expects 4 bytes of
+ // big endian size data info at the front
+ vch2[0] = (nSize >> 24) & 0xff;
+ vch2[1] = (nSize >> 16) & 0xff;
+ vch2[2] = (nSize >> 8) & 0xff;
+ vch2[3] = (nSize >> 0) & 0xff;
+ // swap data to big endian
+ reverse_copy(vch.begin(), vch.end(), vch2.begin() + 4);
+ BN_mpi2bn(&vch2[0], vch2.size(), this);
+ }
+
+ std::vector<unsigned char> getvch() const
+ {
+ unsigned int nSize = BN_bn2mpi(this, NULL);
+ if (nSize < 4)
+ return std::vector<unsigned char>();
+ std::vector<unsigned char> vch(nSize);
+ BN_bn2mpi(this, &vch[0]);
+ vch.erase(vch.begin(), vch.begin() + 4);
+ reverse(vch.begin(), vch.end());
+ return vch;
+ }
+
+ CBigNum& SetCompact(unsigned int nCompact)
+ {
+ unsigned int nSize = nCompact >> 24;
+ std::vector<unsigned char> vch(4 + nSize);
+ vch[3] = nSize;
+ if (nSize >= 1) vch[4] = (nCompact >> 16) & 0xff;
+ if (nSize >= 2) vch[5] = (nCompact >> 8) & 0xff;
+ if (nSize >= 3) vch[6] = (nCompact >> 0) & 0xff;
+ BN_mpi2bn(&vch[0], vch.size(), this);
+ return *this;
+ }
+
+ unsigned int GetCompact() const
+ {
+ unsigned int nSize = BN_bn2mpi(this, NULL);
+ std::vector<unsigned char> vch(nSize);
+ nSize -= 4;
+ BN_bn2mpi(this, &vch[0]);
+ unsigned int nCompact = nSize << 24;
+ if (nSize >= 1) nCompact |= (vch[4] << 16);
+ if (nSize >= 2) nCompact |= (vch[5] << 8);
+ if (nSize >= 3) nCompact |= (vch[6] << 0);
+ return nCompact;
+ }
+
+ void SetHex(const std::string& str)
+ {
+ // skip 0x
+ const char* psz = str.c_str();
+ while (isspace(*psz))
+ psz++;
+ bool fNegative = false;
+ if (*psz == '-')
+ {
+ fNegative = true;
+ psz++;
+ }
+ if (psz[0] == '0' && tolower(psz[1]) == 'x')
+ psz += 2;
+ while (isspace(*psz))
+ psz++;
+
+ // hex string to bignum
+ static char phexdigit[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0 };
+ *this = 0;
+ while (isxdigit(*psz))
+ {
+ *this <<= 4;
+ int n = phexdigit[*psz++];
+ *this += n;
+ }
+ if (fNegative)
+ *this = 0 - *this;
+ }
+
+ std::string ToString(int nBase=10) const
+ {
+ CAutoBN_CTX pctx;
+ CBigNum bnBase = nBase;
+ CBigNum bn0 = 0;
+ std::string str;
+ CBigNum bn = *this;
+ BN_set_negative(&bn, false);
+ CBigNum dv;
+ CBigNum rem;
+ if (BN_cmp(&bn, &bn0) == 0)
+ return "0";
+ while (BN_cmp(&bn, &bn0) > 0)
+ {
+ if (!BN_div(&dv, &rem, &bn, &bnBase, pctx))
+ throw bignum_error("CBigNum::ToString() : BN_div failed");
+ bn = dv;
+ unsigned int c = rem.getulong();
+ str += "0123456789abcdef"[c];
+ }
+ if (BN_is_negative(this))
+ str += "-";
+ reverse(str.begin(), str.end());
+ return str;
+ }
+
+ std::string GetHex() const
+ {
+ return ToString(16);
+ }
+
+ unsigned int GetSerializeSize(int nType=0, int nVersion=VERSION) const
+ {
+ return ::GetSerializeSize(getvch(), nType, nVersion);
+ }
+
+ template<typename Stream>
+ void Serialize(Stream& s, int nType=0, int nVersion=VERSION) const
+ {
+ ::Serialize(s, getvch(), nType, nVersion);
+ }
+
+ template<typename Stream>
+ void Unserialize(Stream& s, int nType=0, int nVersion=VERSION)
+ {
+ std::vector<unsigned char> vch;
+ ::Unserialize(s, vch, nType, nVersion);
+ setvch(vch);
+ }
+
+
+ bool operator!() const
+ {
+ return BN_is_zero(this);
+ }
+
+ CBigNum& operator+=(const CBigNum& b)
+ {
+ if (!BN_add(this, this, &b))
+ throw bignum_error("CBigNum::operator+= : BN_add failed");
+ return *this;
+ }
+
+ CBigNum& operator-=(const CBigNum& b)
+ {
+ *this = *this - b;
+ return *this;
+ }
+
+ CBigNum& operator*=(const CBigNum& b)
+ {
+ CAutoBN_CTX pctx;
+ if (!BN_mul(this, this, &b, pctx))
+ throw bignum_error("CBigNum::operator*= : BN_mul failed");
+ return *this;
+ }
+
+ CBigNum& operator/=(const CBigNum& b)
+ {
+ *this = *this / b;
+ return *this;
+ }
+
+ CBigNum& operator%=(const CBigNum& b)
+ {
+ *this = *this % b;
+ return *this;
+ }
+
+ CBigNum& operator<<=(unsigned int shift)
+ {
+ if (!BN_lshift(this, this, shift))
+ throw bignum_error("CBigNum:operator<<= : BN_lshift failed");
+ return *this;
+ }
+
+ CBigNum& operator>>=(unsigned int shift)
+ {
+ // Note: BN_rshift segfaults on 64-bit if 2^shift is greater than the number
+ // if built on ubuntu 9.04 or 9.10, probably depends on version of openssl
+ CBigNum a = 1;
+ a <<= shift;
+ if (BN_cmp(&a, this) > 0)
+ {
+ *this = 0;
+ return *this;
+ }
+
+ if (!BN_rshift(this, this, shift))
+ throw bignum_error("CBigNum:operator>>= : BN_rshift failed");
+ return *this;
+ }
+
+
+ CBigNum& operator++()
+ {
+ // prefix operator
+ if (!BN_add(this, this, BN_value_one()))
+ throw bignum_error("CBigNum::operator++ : BN_add failed");
+ return *this;
+ }
+
+ const CBigNum operator++(int)
+ {
+ // postfix operator
+ const CBigNum ret = *this;
+ ++(*this);
+ return ret;
+ }
+
+ CBigNum& operator--()
+ {
+ // prefix operator
+ CBigNum r;
+ if (!BN_sub(&r, this, BN_value_one()))
+ throw bignum_error("CBigNum::operator-- : BN_sub failed");
+ *this = r;
+ return *this;
+ }
+
+ const CBigNum operator--(int)
+ {
+ // postfix operator
+ const CBigNum ret = *this;
+ --(*this);
+ return ret;
+ }
+
+
+ friend inline const CBigNum operator-(const CBigNum& a, const CBigNum& b);
+ friend inline const CBigNum operator/(const CBigNum& a, const CBigNum& b);
+ friend inline const CBigNum operator%(const CBigNum& a, const CBigNum& b);
+};
+
+
+
+inline const CBigNum operator+(const CBigNum& a, const CBigNum& b)
+{
+ CBigNum r;
+ if (!BN_add(&r, &a, &b))
+ throw bignum_error("CBigNum::operator+ : BN_add failed");
+ return r;
+}
+
+inline const CBigNum operator-(const CBigNum& a, const CBigNum& b)
+{
+ CBigNum r;
+ if (!BN_sub(&r, &a, &b))
+ throw bignum_error("CBigNum::operator- : BN_sub failed");
+ return r;
+}
+
+inline const CBigNum operator-(const CBigNum& a)
+{
+ CBigNum r(a);
+ BN_set_negative(&r, !BN_is_negative(&r));
+ return r;
+}
+
+inline const CBigNum operator*(const CBigNum& a, const CBigNum& b)
+{
+ CAutoBN_CTX pctx;
+ CBigNum r;
+ if (!BN_mul(&r, &a, &b, pctx))
+ throw bignum_error("CBigNum::operator* : BN_mul failed");
+ return r;
+}
+
+inline const CBigNum operator/(const CBigNum& a, const CBigNum& b)
+{
+ CAutoBN_CTX pctx;
+ CBigNum r;
+ if (!BN_div(&r, NULL, &a, &b, pctx))
+ throw bignum_error("CBigNum::operator/ : BN_div failed");
+ return r;
+}
+
+inline const CBigNum operator%(const CBigNum& a, const CBigNum& b)
+{
+ CAutoBN_CTX pctx;
+ CBigNum r;
+ if (!BN_mod(&r, &a, &b, pctx))
+ throw bignum_error("CBigNum::operator% : BN_div failed");
+ return r;
+}
+
+inline const CBigNum operator<<(const CBigNum& a, unsigned int shift)
+{
+ CBigNum r;
+ if (!BN_lshift(&r, &a, shift))
+ throw bignum_error("CBigNum:operator<< : BN_lshift failed");
+ return r;
+}
+
+inline const CBigNum operator>>(const CBigNum& a, unsigned int shift)
+{
+ CBigNum r = a;
+ r >>= shift;
+ return r;
+}
+
+inline bool operator==(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) == 0); }
+inline bool operator!=(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) != 0); }
+inline bool operator<=(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) <= 0); }
+inline bool operator>=(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) >= 0); }
+inline bool operator<(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) < 0); }
+inline bool operator>(const CBigNum& a, const CBigNum& b) { return (BN_cmp(&a, &b) > 0); }
+
+#endif
diff --git a/bitcoin/src/bitcoinrpc.cpp b/bitcoin/src/bitcoinrpc.cpp
@@ -0,0 +1,2573 @@
+// Copyright (c) 2010 Satoshi Nakamoto
+// Copyright (c) 2009-2012 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+#include "headers.h"
+#include "db.h"
+#include "net.h"
+#include "init.h"
+#undef printf
+#include <boost/asio.hpp>
+#include <boost/iostreams/concepts.hpp>
+#include <boost/iostreams/stream.hpp>
+#include <boost/algorithm/string.hpp>
+#ifdef USE_SSL
+#include <boost/asio/ssl.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+typedef boost::asio::ssl::stream<boost::asio::ip::tcp::socket> SSLStream;
+#endif
+#include "json/json_spirit_reader_template.h"
+#include "json/json_spirit_writer_template.h"
+#include "json/json_spirit_utils.h"
+#define printf OutputDebugStringF
+// MinGW 3.4.5 gets "fatal error: had to relocate PCH" if the json headers are
+// precompiled in headers.h. The problem might be when the pch file goes over
+// a certain size around 145MB. If we need access to json_spirit outside this
+// file, we could use the compiled json_spirit option.
+
+using namespace std;
+using namespace boost;
+using namespace boost::asio;
+using namespace json_spirit;
+
+void ThreadRPCServer2(void* parg);
+typedef Value(*rpcfn_type)(const Array& params, bool fHelp);
+extern map<string, rpcfn_type> mapCallTable;
+
+static std::string strRPCUserColonPass;
+
+static int64 nWalletUnlockTime;
+static CCriticalSection cs_nWalletUnlockTime;
+
+
+Object JSONRPCError(int code, const string& message)
+{
+ Object error;
+ error.push_back(Pair("code", code));
+ error.push_back(Pair("message", message));
+ return error;
+}
+
+
+void PrintConsole(const std::string &format, ...)
+{
+ char buffer[50000];
+ int limit = sizeof(buffer);
+ va_list arg_ptr;
+ va_start(arg_ptr, format);
+ int ret = _vsnprintf(buffer, limit, format.c_str(), arg_ptr);
+ va_end(arg_ptr);
+ if (ret < 0 || ret >= limit)
+ {
+ ret = limit - 1;
+ buffer[limit-1] = 0;
+ }
+ printf("%s", buffer);
+ fprintf(stdout, "%s", buffer);
+}
+
+
+int64 AmountFromValue(const Value& value)
+{
+ double dAmount = value.get_real();
+ if (dAmount <= 0.0 || dAmount > 21000000.0)
+ throw JSONRPCError(-3, "Invalid amount");
+ int64 nAmount = roundint64(dAmount * COIN);
+ if (!MoneyRange(nAmount))
+ throw JSONRPCError(-3, "Invalid amount");
+ return nAmount;
+}
+
+Value ValueFromAmount(int64 amount)
+{
+ return (double)amount / (double)COIN;
+}
+
+void WalletTxToJSON(const CWalletTx& wtx, Object& entry)
+{
+ entry.push_back(Pair("confirmations", wtx.GetDepthInMainChain()));
+ entry.push_back(Pair("txid", wtx.GetHash().GetHex()));
+ entry.push_back(Pair("time", (boost::int64_t)wtx.GetTxTime()));
+ BOOST_FOREACH(const PAIRTYPE(string,string)& item, wtx.mapValue)
+ entry.push_back(Pair(item.first, item.second));
+}
+
+string AccountFromValue(const Value& value)
+{
+ string strAccount = value.get_str();
+ if (strAccount == "*")
+ throw JSONRPCError(-11, "Invalid account name");
+ return strAccount;
+}
+
+
+
+///
+/// Note: This interface may still be subject to change.
+///
+
+
+Value help(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() > 1)
+ throw runtime_error(
+ "help [command]\n"
+ "List commands, or get help for a command.");
+
+ string strCommand;
+ if (params.size() > 0)
+ strCommand = params[0].get_str();
+
+ string strRet;
+ set<rpcfn_type> setDone;
+ for (map<string, rpcfn_type>::iterator mi = mapCallTable.begin(); mi != mapCallTable.end(); ++mi)
+ {
+ string strMethod = (*mi).first;
+ // We already filter duplicates, but these deprecated screw up the sort order
+ if (strMethod == "getamountreceived" ||
+ strMethod == "getallreceived" ||
+ strMethod == "getblocknumber" || // deprecated
+ (strMethod.find("label") != string::npos))
+ continue;
+ if (strCommand != "" && strMethod != strCommand)
+ continue;
+ try
+ {
+ Array params;
+ rpcfn_type pfn = (*mi).second;
+ if (setDone.insert(pfn).second)
+ (*pfn)(params, true);
+ }
+ catch (std::exception& e)
+ {
+ // Help text is returned in an exception
+ string strHelp = string(e.what());
+ if (strCommand == "")
+ if (strHelp.find('\n') != -1)
+ strHelp = strHelp.substr(0, strHelp.find('\n'));
+ strRet += strHelp + "\n";
+ }
+ }
+ if (strRet == "")
+ strRet = strprintf("help: unknown command: %s\n", strCommand.c_str());
+ strRet = strRet.substr(0,strRet.size()-1);
+ return strRet;
+}
+
+
+Value stop(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 0)
+ throw runtime_error(
+ "stop\n"
+ "Stop bitcoin server.");
+#ifndef QT_GUI
+ // Shutdown will take long enough that the response should get back
+ CreateThread(Shutdown, NULL);
+ return "bitcoin server stopping";
+#else
+ throw runtime_error("NYI: cannot shut down GUI with RPC command");
+#endif
+}
+
+
+Value getblockcount(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 0)
+ throw runtime_error(
+ "getblockcount\n"
+ "Returns the number of blocks in the longest block chain.");
+
+ return nBestHeight;
+}
+
+
+// deprecated
+Value getblocknumber(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 0)
+ throw runtime_error(
+ "getblocknumber\n"
+ "Deprecated. Use getblockcount.");
+
+ return nBestHeight;
+}
+
+
+Value getconnectioncount(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 0)
+ throw runtime_error(
+ "getconnectioncount\n"
+ "Returns the number of connections to other nodes.");
+
+ return (int)vNodes.size();
+}
+
+
+double GetDifficulty()
+{
+ // Floating point number that is a multiple of the minimum difficulty,
+ // minimum difficulty = 1.0.
+
+ if (pindexBest == NULL)
+ return 1.0;
+ int nShift = (pindexBest->nBits >> 24) & 0xff;
+
+ double dDiff =
+ (double)0x0000ffff / (double)(pindexBest->nBits & 0x00ffffff);
+
+ while (nShift < 29)
+ {
+ dDiff *= 256.0;
+ nShift++;
+ }
+ while (nShift > 29)
+ {
+ dDiff /= 256.0;
+ nShift--;
+ }
+
+ return dDiff;
+}
+
+Value getdifficulty(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 0)
+ throw runtime_error(
+ "getdifficulty\n"
+ "Returns the proof-of-work difficulty as a multiple of the minimum difficulty.");
+
+ return GetDifficulty();
+}
+
+
+Value getgenerate(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 0)
+ throw runtime_error(
+ "getgenerate\n"
+ "Returns true or false.");
+
+ return (bool)fGenerateBitcoins;
+}
+
+
+Value setgenerate(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() < 1 || params.size() > 2)
+ throw runtime_error(
+ "setgenerate <generate> [genproclimit]\n"
+ "<generate> is true or false to turn generation on or off.\n"
+ "Generation is limited to [genproclimit] processors, -1 is unlimited.");
+
+ bool fGenerate = true;
+ if (params.size() > 0)
+ fGenerate = params[0].get_bool();
+
+ if (params.size() > 1)
+ {
+ int nGenProcLimit = params[1].get_int();
+ fLimitProcessors = (nGenProcLimit != -1);
+ WriteSetting("fLimitProcessors", fLimitProcessors);
+ if (nGenProcLimit != -1)
+ WriteSetting("nLimitProcessors", nLimitProcessors = nGenProcLimit);
+ if (nGenProcLimit == 0)
+ fGenerate = false;
+ }
+
+ GenerateBitcoins(fGenerate, pwalletMain);
+ return Value::null;
+}
+
+
+Value gethashespersec(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 0)
+ throw runtime_error(
+ "gethashespersec\n"
+ "Returns a recent hashes per second performance measurement while generating.");
+
+ if (GetTimeMillis() - nHPSTimerStart > 8000)
+ return (boost::int64_t)0;
+ return (boost::int64_t)dHashesPerSec;
+}
+
+
+Value getinfo(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 0)
+ throw runtime_error(
+ "getinfo\n"
+ "Returns an object containing various state info.");
+
+ Object obj;
+ obj.push_back(Pair("version", (int)VERSION));
+ obj.push_back(Pair("balance", ValueFromAmount(pwalletMain->GetBalance())));
+ obj.push_back(Pair("blocks", (int)nBestHeight));
+ obj.push_back(Pair("connections", (int)vNodes.size()));
+ obj.push_back(Pair("proxy", (fUseProxy ? addrProxy.ToStringIPPort() : string())));
+ obj.push_back(Pair("generate", (bool)fGenerateBitcoins));
+ obj.push_back(Pair("genproclimit", (int)(fLimitProcessors ? nLimitProcessors : -1)));
+ obj.push_back(Pair("difficulty", (double)GetDifficulty()));
+ obj.push_back(Pair("hashespersec", gethashespersec(params, false)));
+ obj.push_back(Pair("testnet", fTestNet));
+ obj.push_back(Pair("keypoololdest", (boost::int64_t)pwalletMain->GetOldestKeyPoolTime()));
+ obj.push_back(Pair("keypoolsize", pwalletMain->GetKeyPoolSize()));
+ obj.push_back(Pair("paytxfee", ValueFromAmount(nTransactionFee)));
+ if (pwalletMain->IsCrypted())
+ obj.push_back(Pair("unlocked_until", (boost::int64_t)nWalletUnlockTime / 1000));
+ obj.push_back(Pair("errors", GetWarnings("statusbar")));
+ return obj;
+}
+
+
+Value getnewaddress(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() > 1)
+ throw runtime_error(
+ "getnewaddress [account]\n"
+ "Returns a new bitcoin address for receiving payments. "
+ "If [account] is specified (recommended), it is added to the address book "
+ "so payments received with the address will be credited to [account].");
+
+ // Parse the account first so we don't generate a key if there's an error
+ string strAccount;
+ if (params.size() > 0)
+ strAccount = AccountFromValue(params[0]);
+
+ if (!pwalletMain->IsLocked())
+ pwalletMain->TopUpKeyPool();
+
+ // Generate a new key that is added to wallet
+ std::vector<unsigned char> newKey;
+ if (!pwalletMain->GetKeyFromPool(newKey, false))
+ throw JSONRPCError(-12, "Error: Keypool ran out, please call keypoolrefill first");
+ CBitcoinAddress address(newKey);
+
+ pwalletMain->SetAddressBookName(address, strAccount);
+
+ return address.ToString();
+}
+
+
+CBitcoinAddress GetAccountAddress(string strAccount, bool bForceNew=false)
+{
+ CWalletDB walletdb(pwalletMain->strWalletFile);
+
+ CAccount account;
+ walletdb.ReadAccount(strAccount, account);
+
+ bool bKeyUsed = false;
+
+ // Check if the current key has been used
+ if (!account.vchPubKey.empty())
+ {
+ CScript scriptPubKey;
+ scriptPubKey.SetBitcoinAddress(account.vchPubKey);
+ for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin();
+ it != pwalletMain->mapWallet.end() && !account.vchPubKey.empty();
+ ++it)
+ {
+ const CWalletTx& wtx = (*it).second;
+ BOOST_FOREACH(const CTxOut& txout, wtx.vout)
+ if (txout.scriptPubKey == scriptPubKey)
+ bKeyUsed = true;
+ }
+ }
+
+ // Generate a new key
+ if (account.vchPubKey.empty() || bForceNew || bKeyUsed)
+ {
+ if (!pwalletMain->GetKeyFromPool(account.vchPubKey, false))
+ throw JSONRPCError(-12, "Error: Keypool ran out, please call keypoolrefill first");
+
+ pwalletMain->SetAddressBookName(CBitcoinAddress(account.vchPubKey), strAccount);
+ walletdb.WriteAccount(strAccount, account);
+ }
+
+ return CBitcoinAddress(account.vchPubKey);
+}
+
+Value getaccountaddress(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 1)
+ throw runtime_error(
+ "getaccountaddress <account>\n"
+ "Returns the current bitcoin address for receiving payments to this account.");
+
+ // Parse the account first so we don't generate a key if there's an error
+ string strAccount = AccountFromValue(params[0]);
+
+ Value ret;
+
+ ret = GetAccountAddress(strAccount).ToString();
+
+ return ret;
+}
+
+
+
+Value setaccount(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() < 1 || params.size() > 2)
+ throw runtime_error(
+ "setaccount <bitcoinaddress> <account>\n"
+ "Sets the account associated with the given address.");
+
+ CBitcoinAddress address(params[0].get_str());
+ if (!address.IsValid())
+ throw JSONRPCError(-5, "Invalid bitcoin address");
+
+
+ string strAccount;
+ if (params.size() > 1)
+ strAccount = AccountFromValue(params[1]);
+
+ // Detect when changing the account of an address that is the 'unused current key' of another account:
+ if (pwalletMain->mapAddressBook.count(address))
+ {
+ string strOldAccount = pwalletMain->mapAddressBook[address];
+ if (address == GetAccountAddress(strOldAccount))
+ GetAccountAddress(strOldAccount, true);
+ }
+
+ pwalletMain->SetAddressBookName(address, strAccount);
+
+ return Value::null;
+}
+
+
+Value getaccount(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 1)
+ throw runtime_error(
+ "getaccount <bitcoinaddress>\n"
+ "Returns the account associated with the given address.");
+
+ CBitcoinAddress address(params[0].get_str());
+ if (!address.IsValid())
+ throw JSONRPCError(-5, "Invalid bitcoin address");
+
+ string strAccount;
+ map<CBitcoinAddress, string>::iterator mi = pwalletMain->mapAddressBook.find(address);
+ if (mi != pwalletMain->mapAddressBook.end() && !(*mi).second.empty())
+ strAccount = (*mi).second;
+ return strAccount;
+}
+
+
+Value getaddressesbyaccount(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 1)
+ throw runtime_error(
+ "getaddressesbyaccount <account>\n"
+ "Returns the list of addresses for the given account.");
+
+ string strAccount = AccountFromValue(params[0]);
+
+ // Find all addresses that have the given account
+ Array ret;
+ BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, string)& item, pwalletMain->mapAddressBook)
+ {
+ const CBitcoinAddress& address = item.first;
+ const string& strName = item.second;
+ if (strName == strAccount)
+ ret.push_back(address.ToString());
+ }
+ return ret;
+}
+
+Value settxfee(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() < 1 || params.size() > 1)
+ throw runtime_error(
+ "settxfee <amount>\n"
+ "<amount> is a real and is rounded to the nearest 0.00000001");
+
+ // Amount
+ int64 nAmount = 0;
+ if (params[0].get_real() != 0.0)
+ nAmount = AmountFromValue(params[0]); // rejects 0.0 amounts
+
+ nTransactionFee = nAmount;
+ return true;
+}
+
+Value sendtoaddress(const Array& params, bool fHelp)
+{
+ if (pwalletMain->IsCrypted() && (fHelp || params.size() < 2 || params.size() > 4))
+ throw runtime_error(
+ "sendtoaddress <bitcoinaddress> <amount> [comment] [comment-to]\n"
+ "<amount> is a real and is rounded to the nearest 0.00000001\n"
+ "requires wallet passphrase to be set with walletpassphrase first");
+ if (!pwalletMain->IsCrypted() && (fHelp || params.size() < 2 || params.size() > 4))
+ throw runtime_error(
+ "sendtoaddress <bitcoinaddress> <amount> [comment] [comment-to]\n"
+ "<amount> is a real and is rounded to the nearest 0.00000001");
+
+ CBitcoinAddress address(params[0].get_str());
+ if (!address.IsValid())
+ throw JSONRPCError(-5, "Invalid bitcoin address");
+
+ // Amount
+ int64 nAmount = AmountFromValue(params[1]);
+
+ // Wallet comments
+ CWalletTx wtx;
+ if (params.size() > 2 && params[2].type() != null_type && !params[2].get_str().empty())
+ wtx.mapValue["comment"] = params[2].get_str();
+ if (params.size() > 3 && params[3].type() != null_type && !params[3].get_str().empty())
+ wtx.mapValue["to"] = params[3].get_str();
+
+ if (pwalletMain->IsLocked())
+ throw JSONRPCError(-13, "Error: Please enter the wallet passphrase with walletpassphrase first.");
+
+ string strError = pwalletMain->SendMoneyToBitcoinAddress(address, nAmount, wtx);
+ if (strError != "")
+ throw JSONRPCError(-4, strError);
+
+ return wtx.GetHash().GetHex();
+}
+
+static const string strMessageMagic = "Bitcoin Signed Message:\n";
+
+Value signmessage(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 2)
+ throw runtime_error(
+ "signmessage <bitcoinaddress> <message>\n"
+ "Sign a message with the private key of an address");
+
+ if (pwalletMain->IsLocked())
+ throw JSONRPCError(-13, "Error: Please enter the wallet passphrase with walletpassphrase first.");
+
+ string strAddress = params[0].get_str();
+ string strMessage = params[1].get_str();
+
+ CBitcoinAddress addr(strAddress);
+ if (!addr.IsValid())
+ throw JSONRPCError(-3, "Invalid address");
+
+ CKey key;
+ if (!pwalletMain->GetKey(addr, key))
+ throw JSONRPCError(-4, "Private key not available");
+
+ CDataStream ss(SER_GETHASH);
+ ss << strMessageMagic;
+ ss << strMessage;
+
+ vector<unsigned char> vchSig;
+ if (!key.SignCompact(Hash(ss.begin(), ss.end()), vchSig))
+ throw JSONRPCError(-5, "Sign failed");
+
+ return EncodeBase64(&vchSig[0], vchSig.size());
+}
+
+Value verifymessage(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 3)
+ throw runtime_error(
+ "verifymessage <bitcoinaddress> <signature> <message>\n"
+ "Verify a signed message");
+
+ string strAddress = params[0].get_str();
+ string strSign = params[1].get_str();
+ string strMessage = params[2].get_str();
+
+ CBitcoinAddress addr(strAddress);
+ if (!addr.IsValid())
+ throw JSONRPCError(-3, "Invalid address");
+
+ bool fInvalid = false;
+ vector<unsigned char> vchSig = DecodeBase64(strSign.c_str(), &fInvalid);
+
+ if (fInvalid)
+ throw JSONRPCError(-5, "Malformed base64 encoding");
+
+ CDataStream ss(SER_GETHASH);
+ ss << strMessageMagic;
+ ss << strMessage;
+
+ CKey key;
+ if (!key.SetCompactSignature(Hash(ss.begin(), ss.end()), vchSig))
+ return false;
+
+ return (key.GetAddress() == addr);
+}
+
+
+Value getreceivedbyaddress(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() < 1 || params.size() > 2)
+ throw runtime_error(
+ "getreceivedbyaddress <bitcoinaddress> [minconf=1]\n"
+ "Returns the total amount received by <bitcoinaddress> in transactions with at least [minconf] confirmations.");
+
+ // Bitcoin address
+ CBitcoinAddress address = CBitcoinAddress(params[0].get_str());
+ CScript scriptPubKey;
+ if (!address.IsValid())
+ throw JSONRPCError(-5, "Invalid bitcoin address");
+ scriptPubKey.SetBitcoinAddress(address);
+ if (!IsMine(*pwalletMain,scriptPubKey))
+ return (double)0.0;
+
+ // Minimum confirmations
+ int nMinDepth = 1;
+ if (params.size() > 1)
+ nMinDepth = params[1].get_int();
+
+ // Tally
+ int64 nAmount = 0;
+ for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
+ {
+ const CWalletTx& wtx = (*it).second;
+ if (wtx.IsCoinBase() || !wtx.IsFinal())
+ continue;
+
+ BOOST_FOREACH(const CTxOut& txout, wtx.vout)
+ if (txout.scriptPubKey == scriptPubKey)
+ if (wtx.GetDepthInMainChain() >= nMinDepth)
+ nAmount += txout.nValue;
+ }
+
+ return ValueFromAmount(nAmount);
+}
+
+
+void GetAccountAddresses(string strAccount, set<CBitcoinAddress>& setAddress)
+{
+ BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, string)& item, pwalletMain->mapAddressBook)
+ {
+ const CBitcoinAddress& address = item.first;
+ const string& strName = item.second;
+ if (strName == strAccount)
+ setAddress.insert(address);
+ }
+}
+
+
+Value getreceivedbyaccount(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() < 1 || params.size() > 2)
+ throw runtime_error(
+ "getreceivedbyaccount <account> [minconf=1]\n"
+ "Returns the total amount received by addresses with <account> in transactions with at least [minconf] confirmations.");
+
+ // Minimum confirmations
+ int nMinDepth = 1;
+ if (params.size() > 1)
+ nMinDepth = params[1].get_int();
+
+ // Get the set of pub keys that have the label
+ string strAccount = AccountFromValue(params[0]);
+ set<CBitcoinAddress> setAddress;
+ GetAccountAddresses(strAccount, setAddress);
+
+ // Tally
+ int64 nAmount = 0;
+ for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
+ {
+ const CWalletTx& wtx = (*it).second;
+ if (wtx.IsCoinBase() || !wtx.IsFinal())
+ continue;
+
+ BOOST_FOREACH(const CTxOut& txout, wtx.vout)
+ {
+ CBitcoinAddress address;
+ if (ExtractAddress(txout.scriptPubKey, pwalletMain, address) && setAddress.count(address))
+ if (wtx.GetDepthInMainChain() >= nMinDepth)
+ nAmount += txout.nValue;
+ }
+ }
+
+ return (double)nAmount / (double)COIN;
+}
+
+
+int64 GetAccountBalance(CWalletDB& walletdb, const string& strAccount, int nMinDepth)
+{
+ int64 nBalance = 0;
+
+ // Tally wallet transactions
+ for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
+ {
+ const CWalletTx& wtx = (*it).second;
+ if (!wtx.IsFinal())
+ continue;
+
+ int64 nGenerated, nReceived, nSent, nFee;
+ wtx.GetAccountAmounts(strAccount, nGenerated, nReceived, nSent, nFee);
+
+ if (nReceived != 0 && wtx.GetDepthInMainChain() >= nMinDepth)
+ nBalance += nReceived;
+ nBalance += nGenerated - nSent - nFee;
+ }
+
+ // Tally internal accounting entries
+ nBalance += walletdb.GetAccountCreditDebit(strAccount);
+
+ return nBalance;
+}
+
+int64 GetAccountBalance(const string& strAccount, int nMinDepth)
+{
+ CWalletDB walletdb(pwalletMain->strWalletFile);
+ return GetAccountBalance(walletdb, strAccount, nMinDepth);
+}
+
+
+Value getbalance(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() > 2)
+ throw runtime_error(
+ "getbalance [account] [minconf=1]\n"
+ "If [account] is not specified, returns the server's total available balance.\n"
+ "If [account] is specified, returns the balance in the account.");
+
+ if (params.size() == 0)
+ return ValueFromAmount(pwalletMain->GetBalance());
+
+ int nMinDepth = 1;
+ if (params.size() > 1)
+ nMinDepth = params[1].get_int();
+
+ if (params[0].get_str() == "*") {
+ // Calculate total balance a different way from GetBalance()
+ // (GetBalance() sums up all unspent TxOuts)
+ // getbalance and getbalance '*' should always return the same number.
+ int64 nBalance = 0;
+ for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
+ {
+ const CWalletTx& wtx = (*it).second;
+ if (!wtx.IsFinal())
+ continue;
+
+ int64 allGeneratedImmature, allGeneratedMature, allFee;
+ allGeneratedImmature = allGeneratedMature = allFee = 0;
+ string strSentAccount;
+ list<pair<CBitcoinAddress, int64> > listReceived;
+ list<pair<CBitcoinAddress, int64> > listSent;
+ wtx.GetAmounts(allGeneratedImmature, allGeneratedMature, listReceived, listSent, allFee, strSentAccount);
+ if (wtx.GetDepthInMainChain() >= nMinDepth)
+ BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress,int64)& r, listReceived)
+ nBalance += r.second;
+ BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress,int64)& r, listSent)
+ nBalance -= r.second;
+ nBalance -= allFee;
+ nBalance += allGeneratedMature;
+ }
+ return ValueFromAmount(nBalance);
+ }
+
+ string strAccount = AccountFromValue(params[0]);
+
+ int64 nBalance = GetAccountBalance(strAccount, nMinDepth);
+
+ return ValueFromAmount(nBalance);
+}
+
+
+Value movecmd(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() < 3 || params.size() > 5)
+ throw runtime_error(
+ "move <fromaccount> <toaccount> <amount> [minconf=1] [comment]\n"
+ "Move from one account in your wallet to another.");
+
+ string strFrom = AccountFromValue(params[0]);
+ string strTo = AccountFromValue(params[1]);
+ int64 nAmount = AmountFromValue(params[2]);
+ if (params.size() > 3)
+ // unused parameter, used to be nMinDepth, keep type-checking it though
+ (void)params[3].get_int();
+ string strComment;
+ if (params.size() > 4)
+ strComment = params[4].get_str();
+
+ CWalletDB walletdb(pwalletMain->strWalletFile);
+ walletdb.TxnBegin();
+
+ int64 nNow = GetAdjustedTime();
+
+ // Debit
+ CAccountingEntry debit;
+ debit.strAccount = strFrom;
+ debit.nCreditDebit = -nAmount;
+ debit.nTime = nNow;
+ debit.strOtherAccount = strTo;
+ debit.strComment = strComment;
+ walletdb.WriteAccountingEntry(debit);
+
+ // Credit
+ CAccountingEntry credit;
+ credit.strAccount = strTo;
+ credit.nCreditDebit = nAmount;
+ credit.nTime = nNow;
+ credit.strOtherAccount = strFrom;
+ credit.strComment = strComment;
+ walletdb.WriteAccountingEntry(credit);
+
+ walletdb.TxnCommit();
+
+ return true;
+}
+
+
+Value sendfrom(const Array& params, bool fHelp)
+{
+ if (pwalletMain->IsCrypted() && (fHelp || params.size() < 3 || params.size() > 6))
+ throw runtime_error(
+ "sendfrom <fromaccount> <tobitcoinaddress> <amount> [minconf=1] [comment] [comment-to]\n"
+ "<amount> is a real and is rounded to the nearest 0.00000001\n"
+ "requires wallet passphrase to be set with walletpassphrase first");
+ if (!pwalletMain->IsCrypted() && (fHelp || params.size() < 3 || params.size() > 6))
+ throw runtime_error(
+ "sendfrom <fromaccount> <tobitcoinaddress> <amount> [minconf=1] [comment] [comment-to]\n"
+ "<amount> is a real and is rounded to the nearest 0.00000001");
+
+ string strAccount = AccountFromValue(params[0]);
+ CBitcoinAddress address(params[1].get_str());
+ if (!address.IsValid())
+ throw JSONRPCError(-5, "Invalid bitcoin address");
+ int64 nAmount = AmountFromValue(params[2]);
+ int nMinDepth = 1;
+ if (params.size() > 3)
+ nMinDepth = params[3].get_int();
+
+ CWalletTx wtx;
+ wtx.strFromAccount = strAccount;
+ if (params.size() > 4 && params[4].type() != null_type && !params[4].get_str().empty())
+ wtx.mapValue["comment"] = params[4].get_str();
+ if (params.size() > 5 && params[5].type() != null_type && !params[5].get_str().empty())
+ wtx.mapValue["to"] = params[5].get_str();
+
+ if (pwalletMain->IsLocked())
+ throw JSONRPCError(-13, "Error: Please enter the wallet passphrase with walletpassphrase first.");
+
+ // Check funds
+ int64 nBalance = GetAccountBalance(strAccount, nMinDepth);
+ if (nAmount > nBalance)
+ throw JSONRPCError(-6, "Account has insufficient funds");
+
+ // Send
+ string strError = pwalletMain->SendMoneyToBitcoinAddress(address, nAmount, wtx);
+ if (strError != "")
+ throw JSONRPCError(-4, strError);
+
+ return wtx.GetHash().GetHex();
+}
+
+
+Value sendmany(const Array& params, bool fHelp)
+{
+ if (pwalletMain->IsCrypted() && (fHelp || params.size() < 2 || params.size() > 4))
+ throw runtime_error(
+ "sendmany <fromaccount> {address:amount,...} [minconf=1] [comment]\n"
+ "amounts are double-precision floating point numbers\n"
+ "requires wallet passphrase to be set with walletpassphrase first");
+ if (!pwalletMain->IsCrypted() && (fHelp || params.size() < 2 || params.size() > 4))
+ throw runtime_error(
+ "sendmany <fromaccount> {address:amount,...} [minconf=1] [comment]\n"
+ "amounts are double-precision floating point numbers");
+
+ string strAccount = AccountFromValue(params[0]);
+ Object sendTo = params[1].get_obj();
+ int nMinDepth = 1;
+ if (params.size() > 2)
+ nMinDepth = params[2].get_int();
+
+ CWalletTx wtx;
+ wtx.strFromAccount = strAccount;
+ if (params.size() > 3 && params[3].type() != null_type && !params[3].get_str().empty())
+ wtx.mapValue["comment"] = params[3].get_str();
+
+ set<CBitcoinAddress> setAddress;
+ vector<pair<CScript, int64> > vecSend;
+
+ int64 totalAmount = 0;
+ BOOST_FOREACH(const Pair& s, sendTo)
+ {
+ CBitcoinAddress address(s.name_);
+ if (!address.IsValid())
+ throw JSONRPCError(-5, string("Invalid bitcoin address:")+s.name_);
+
+ if (setAddress.count(address))
+ throw JSONRPCError(-8, string("Invalid parameter, duplicated address: ")+s.name_);
+ setAddress.insert(address);
+
+ CScript scriptPubKey;
+ scriptPubKey.SetBitcoinAddress(address);
+ int64 nAmount = AmountFromValue(s.value_);
+ totalAmount += nAmount;
+
+ vecSend.push_back(make_pair(scriptPubKey, nAmount));
+ }
+
+ if (pwalletMain->IsLocked())
+ throw JSONRPCError(-13, "Error: Please enter the wallet passphrase with walletpassphrase first.");
+
+ // Check funds
+ int64 nBalance = GetAccountBalance(strAccount, nMinDepth);
+ if (totalAmount > nBalance)
+ throw JSONRPCError(-6, "Account has insufficient funds");
+
+ // Send
+ CReserveKey keyChange(pwalletMain);
+ int64 nFeeRequired = 0;
+ bool fCreated = pwalletMain->CreateTransaction(vecSend, wtx, keyChange, nFeeRequired);
+ if (!fCreated)
+ {
+ if (totalAmount + nFeeRequired > pwalletMain->GetBalance())
+ throw JSONRPCError(-6, "Insufficient funds");
+ throw JSONRPCError(-4, "Transaction creation failed");
+ }
+ if (!pwalletMain->CommitTransaction(wtx, keyChange))
+ throw JSONRPCError(-4, "Transaction commit failed");
+
+ return wtx.GetHash().GetHex();
+}
+
+
+struct tallyitem
+{
+ int64 nAmount;
+ int nConf;
+ tallyitem()
+ {
+ nAmount = 0;
+ nConf = INT_MAX;
+ }
+};
+
+Value ListReceived(const Array& params, bool fByAccounts)
+{
+ // Minimum confirmations
+ int nMinDepth = 1;
+ if (params.size() > 0)
+ nMinDepth = params[0].get_int();
+
+ // Whether to include empty accounts
+ bool fIncludeEmpty = false;
+ if (params.size() > 1)
+ fIncludeEmpty = params[1].get_bool();
+
+ // Tally
+ map<CBitcoinAddress, tallyitem> mapTally;
+ for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
+ {
+ const CWalletTx& wtx = (*it).second;
+ if (wtx.IsCoinBase() || !wtx.IsFinal())
+ continue;
+
+ int nDepth = wtx.GetDepthInMainChain();
+ if (nDepth < nMinDepth)
+ continue;
+
+ BOOST_FOREACH(const CTxOut& txout, wtx.vout)
+ {
+ CBitcoinAddress address;
+ if (!ExtractAddress(txout.scriptPubKey, pwalletMain, address) || !address.IsValid())
+ continue;
+
+ tallyitem& item = mapTally[address];
+ item.nAmount += txout.nValue;
+ item.nConf = min(item.nConf, nDepth);
+ }
+ }
+
+ // Reply
+ Array ret;
+ map<string, tallyitem> mapAccountTally;
+ BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, string)& item, pwalletMain->mapAddressBook)
+ {
+ const CBitcoinAddress& address = item.first;
+ const string& strAccount = item.second;
+ map<CBitcoinAddress, tallyitem>::iterator it = mapTally.find(address);
+ if (it == mapTally.end() && !fIncludeEmpty)
+ continue;
+
+ int64 nAmount = 0;
+ int nConf = INT_MAX;
+ if (it != mapTally.end())
+ {
+ nAmount = (*it).second.nAmount;
+ nConf = (*it).second.nConf;
+ }
+
+ if (fByAccounts)
+ {
+ tallyitem& item = mapAccountTally[strAccount];
+ item.nAmount += nAmount;
+ item.nConf = min(item.nConf, nConf);
+ }
+ else
+ {
+ Object obj;
+ obj.push_back(Pair("address", address.ToString()));
+ obj.push_back(Pair("account", strAccount));
+ obj.push_back(Pair("amount", ValueFromAmount(nAmount)));
+ obj.push_back(Pair("confirmations", (nConf == INT_MAX ? 0 : nConf)));
+ ret.push_back(obj);
+ }
+ }
+
+ if (fByAccounts)
+ {
+ for (map<string, tallyitem>::iterator it = mapAccountTally.begin(); it != mapAccountTally.end(); ++it)
+ {
+ int64 nAmount = (*it).second.nAmount;
+ int nConf = (*it).second.nConf;
+ Object obj;
+ obj.push_back(Pair("account", (*it).first));
+ obj.push_back(Pair("amount", ValueFromAmount(nAmount)));
+ obj.push_back(Pair("confirmations", (nConf == INT_MAX ? 0 : nConf)));
+ ret.push_back(obj);
+ }
+ }
+
+ return ret;
+}
+
+Value listreceivedbyaddress(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() > 2)
+ throw runtime_error(
+ "listreceivedbyaddress [minconf=1] [includeempty=false]\n"
+ "[minconf] is the minimum number of confirmations before payments are included.\n"
+ "[includeempty] whether to include addresses that haven't received any payments.\n"
+ "Returns an array of objects containing:\n"
+ " \"address\" : receiving address\n"
+ " \"account\" : the account of the receiving address\n"
+ " \"amount\" : total amount received by the address\n"
+ " \"confirmations\" : number of confirmations of the most recent transaction included");
+
+ return ListReceived(params, false);
+}
+
+Value listreceivedbyaccount(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() > 2)
+ throw runtime_error(
+ "listreceivedbyaccount [minconf=1] [includeempty=false]\n"
+ "[minconf] is the minimum number of confirmations before payments are included.\n"
+ "[includeempty] whether to include accounts that haven't received any payments.\n"
+ "Returns an array of objects containing:\n"
+ " \"account\" : the account of the receiving addresses\n"
+ " \"amount\" : total amount received by addresses with this account\n"
+ " \"confirmations\" : number of confirmations of the most recent transaction included");
+
+ return ListReceived(params, true);
+}
+
+void ListTransactions(const CWalletTx& wtx, const string& strAccount, int nMinDepth, bool fLong, Array& ret)
+{
+ int64 nGeneratedImmature, nGeneratedMature, nFee;
+ string strSentAccount;
+ list<pair<CBitcoinAddress, int64> > listReceived;
+ list<pair<CBitcoinAddress, int64> > listSent;
+ wtx.GetAmounts(nGeneratedImmature, nGeneratedMature, listReceived, listSent, nFee, strSentAccount);
+
+ bool fAllAccounts = (strAccount == string("*"));
+
+ // Generated blocks assigned to account ""
+ if ((nGeneratedMature+nGeneratedImmature) != 0 && (fAllAccounts || strAccount == ""))
+ {
+ Object entry;
+ entry.push_back(Pair("account", string("")));
+ if (nGeneratedImmature)
+ {
+ entry.push_back(Pair("category", wtx.GetDepthInMainChain() ? "immature" : "orphan"));
+ entry.push_back(Pair("amount", ValueFromAmount(nGeneratedImmature)));
+ }
+ else
+ {
+ entry.push_back(Pair("category", "generate"));
+ entry.push_back(Pair("amount", ValueFromAmount(nGeneratedMature)));
+ }
+ if (fLong)
+ WalletTxToJSON(wtx, entry);
+ ret.push_back(entry);
+ }
+
+ // Sent
+ if ((!listSent.empty() || nFee != 0) && (fAllAccounts || strAccount == strSentAccount))
+ {
+ BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, int64)& s, listSent)
+ {
+ Object entry;
+ entry.push_back(Pair("account", strSentAccount));
+ entry.push_back(Pair("address", s.first.ToString()));
+ entry.push_back(Pair("category", "send"));
+ entry.push_back(Pair("amount", ValueFromAmount(-s.second)));
+ entry.push_back(Pair("fee", ValueFromAmount(-nFee)));
+ if (fLong)
+ WalletTxToJSON(wtx, entry);
+ ret.push_back(entry);
+ }
+ }
+
+ // Received
+ if (listReceived.size() > 0 && wtx.GetDepthInMainChain() >= nMinDepth)
+ BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, int64)& r, listReceived)
+ {
+ string account;
+ if (pwalletMain->mapAddressBook.count(r.first))
+ account = pwalletMain->mapAddressBook[r.first];
+ if (fAllAccounts || (account == strAccount))
+ {
+ Object entry;
+ entry.push_back(Pair("account", account));
+ entry.push_back(Pair("address", r.first.ToString()));
+ entry.push_back(Pair("category", "receive"));
+ entry.push_back(Pair("amount", ValueFromAmount(r.second)));
+ if (fLong)
+ WalletTxToJSON(wtx, entry);
+ ret.push_back(entry);
+ }
+ }
+}
+
+void AcentryToJSON(const CAccountingEntry& acentry, const string& strAccount, Array& ret)
+{
+ bool fAllAccounts = (strAccount == string("*"));
+
+ if (fAllAccounts || acentry.strAccount == strAccount)
+ {
+ Object entry;
+ entry.push_back(Pair("account", acentry.strAccount));
+ entry.push_back(Pair("category", "move"));
+ entry.push_back(Pair("time", (boost::int64_t)acentry.nTime));
+ entry.push_back(Pair("amount", ValueFromAmount(acentry.nCreditDebit)));
+ entry.push_back(Pair("otheraccount", acentry.strOtherAccount));
+ entry.push_back(Pair("comment", acentry.strComment));
+ ret.push_back(entry);
+ }
+}
+
+Value listtransactions(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() > 3)
+ throw runtime_error(
+ "listtransactions [account] [count=10] [from=0]\n"
+ "Returns up to [count] most recent transactions skipping the first [from] transactions for account [account].");
+
+ string strAccount = "*";
+ if (params.size() > 0)
+ strAccount = params[0].get_str();
+ int nCount = 10;
+ if (params.size() > 1)
+ nCount = params[1].get_int();
+ int nFrom = 0;
+ if (params.size() > 2)
+ nFrom = params[2].get_int();
+
+ Array ret;
+ CWalletDB walletdb(pwalletMain->strWalletFile);
+
+ // Firs: get all CWalletTx and CAccountingEntry into a sorted-by-time multimap:
+ typedef pair<CWalletTx*, CAccountingEntry*> TxPair;
+ typedef multimap<int64, TxPair > TxItems;
+ TxItems txByTime;
+
+ for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
+ {
+ CWalletTx* wtx = &((*it).second);
+ txByTime.insert(make_pair(wtx->GetTxTime(), TxPair(wtx, (CAccountingEntry*)0)));
+ }
+ list<CAccountingEntry> acentries;
+ walletdb.ListAccountCreditDebit(strAccount, acentries);
+ BOOST_FOREACH(CAccountingEntry& entry, acentries)
+ {
+ txByTime.insert(make_pair(entry.nTime, TxPair((CWalletTx*)0, &entry)));
+ }
+
+ // Now: iterate backwards until we have nCount items to return:
+ TxItems::reverse_iterator it = txByTime.rbegin();
+ if (txByTime.size() > nFrom) std::advance(it, nFrom);
+ for (; it != txByTime.rend(); ++it)
+ {
+ CWalletTx *const pwtx = (*it).second.first;
+ if (pwtx != 0)
+ ListTransactions(*pwtx, strAccount, 0, true, ret);
+ CAccountingEntry *const pacentry = (*it).second.second;
+ if (pacentry != 0)
+ AcentryToJSON(*pacentry, strAccount, ret);
+
+ if (ret.size() >= nCount) break;
+ }
+ // ret is now newest to oldest
+
+ // Make sure we return only last nCount items (sends-to-self might give us an extra):
+ if (ret.size() > nCount)
+ {
+ Array::iterator last = ret.begin();
+ std::advance(last, nCount);
+ ret.erase(last, ret.end());
+ }
+ std::reverse(ret.begin(), ret.end()); // oldest to newest
+
+ return ret;
+}
+
+Value listaccounts(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() > 1)
+ throw runtime_error(
+ "listaccounts [minconf=1]\n"
+ "Returns Object that has account names as keys, account balances as values.");
+
+ int nMinDepth = 1;
+ if (params.size() > 0)
+ nMinDepth = params[0].get_int();
+
+ map<string, int64> mapAccountBalances;
+ BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, string)& entry, pwalletMain->mapAddressBook) {
+ if (pwalletMain->HaveKey(entry.first)) // This address belongs to me
+ mapAccountBalances[entry.second] = 0;
+ }
+
+ for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); ++it)
+ {
+ const CWalletTx& wtx = (*it).second;
+ int64 nGeneratedImmature, nGeneratedMature, nFee;
+ string strSentAccount;
+ list<pair<CBitcoinAddress, int64> > listReceived;
+ list<pair<CBitcoinAddress, int64> > listSent;
+ wtx.GetAmounts(nGeneratedImmature, nGeneratedMature, listReceived, listSent, nFee, strSentAccount);
+ mapAccountBalances[strSentAccount] -= nFee;
+ BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, int64)& s, listSent)
+ mapAccountBalances[strSentAccount] -= s.second;
+ if (wtx.GetDepthInMainChain() >= nMinDepth)
+ {
+ mapAccountBalances[""] += nGeneratedMature;
+ BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress, int64)& r, listReceived)
+ if (pwalletMain->mapAddressBook.count(r.first))
+ mapAccountBalances[pwalletMain->mapAddressBook[r.first]] += r.second;
+ else
+ mapAccountBalances[""] += r.second;
+ }
+ }
+
+ list<CAccountingEntry> acentries;
+ CWalletDB(pwalletMain->strWalletFile).ListAccountCreditDebit("*", acentries);
+ BOOST_FOREACH(const CAccountingEntry& entry, acentries)
+ mapAccountBalances[entry.strAccount] += entry.nCreditDebit;
+
+ Object ret;
+ BOOST_FOREACH(const PAIRTYPE(string, int64)& accountBalance, mapAccountBalances) {
+ ret.push_back(Pair(accountBalance.first, ValueFromAmount(accountBalance.second)));
+ }
+ return ret;
+}
+
+Value listsinceblock(const Array& params, bool fHelp)
+{
+ if (fHelp)
+ throw runtime_error(
+ "listsinceblock [blockid] [target-confirmations]\n"
+ "Get all transactions in blocks since block [blockid], or all transactions if omitted");
+
+ CBlockIndex *pindex = NULL;
+ int target_confirms = 1;
+
+ if (params.size() > 0)
+ {
+ uint256 blockId = 0;
+
+ blockId.SetHex(params[0].get_str());
+ pindex = CBlockLocator(blockId).GetBlockIndex();
+ }
+
+ if (params.size() > 1)
+ {
+ target_confirms = params[1].get_int();
+
+ if (target_confirms < 1)
+ throw JSONRPCError(-8, "Invalid parameter");
+ }
+
+ int depth = pindex ? (1 + nBestHeight - pindex->nHeight) : -1;
+
+ Array transactions;
+
+ for (map<uint256, CWalletTx>::iterator it = pwalletMain->mapWallet.begin(); it != pwalletMain->mapWallet.end(); it++)
+ {
+ CWalletTx tx = (*it).second;
+
+ if (depth == -1 || tx.GetDepthInMainChain() < depth)
+ ListTransactions(tx, "*", 0, true, transactions);
+ }
+
+ uint256 lastblock;
+
+ if (target_confirms == 1)
+ {
+ printf("oops!\n");
+ lastblock = hashBestChain;
+ }
+ else
+ {
+ int target_height = pindexBest->nHeight + 1 - target_confirms;
+
+ CBlockIndex *block;
+ for (block = pindexBest;
+ block && block->nHeight > target_height;
+ block = block->pprev) { }
+
+ lastblock = block ? block->GetBlockHash() : 0;
+ }
+
+ Object ret;
+ ret.push_back(Pair("transactions", transactions));
+ ret.push_back(Pair("lastblock", lastblock.GetHex()));
+
+ return ret;
+}
+
+Value gettransaction(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 1)
+ throw runtime_error(
+ "gettransaction <txid>\n"
+ "Get detailed information about <txid>");
+
+ uint256 hash;
+ hash.SetHex(params[0].get_str());
+
+ Object entry;
+
+ if (!pwalletMain->mapWallet.count(hash))
+ throw JSONRPCError(-5, "Invalid or non-wallet transaction id");
+ const CWalletTx& wtx = pwalletMain->mapWallet[hash];
+
+ int64 nCredit = wtx.GetCredit();
+ int64 nDebit = wtx.GetDebit();
+ int64 nNet = nCredit - nDebit;
+ int64 nFee = (wtx.IsFromMe() ? wtx.GetValueOut() - nDebit : 0);
+
+ entry.push_back(Pair("amount", ValueFromAmount(nNet - nFee)));
+ if (wtx.IsFromMe())
+ entry.push_back(Pair("fee", ValueFromAmount(nFee)));
+
+ WalletTxToJSON(pwalletMain->mapWallet[hash], entry);
+
+ Array details;
+ ListTransactions(pwalletMain->mapWallet[hash], "*", 0, false, details);
+ entry.push_back(Pair("details", details));
+
+ return entry;
+}
+
+
+Value backupwallet(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 1)
+ throw runtime_error(
+ "backupwallet <destination>\n"
+ "Safely copies wallet.dat to destination, which can be a directory or a path with filename.");
+
+ string strDest = params[0].get_str();
+ BackupWallet(*pwalletMain, strDest);
+
+ return Value::null;
+}
+
+
+Value keypoolrefill(const Array& params, bool fHelp)
+{
+ if (pwalletMain->IsCrypted() && (fHelp || params.size() > 0))
+ throw runtime_error(
+ "keypoolrefill\n"
+ "Fills the keypool, requires wallet passphrase to be set.");
+ if (!pwalletMain->IsCrypted() && (fHelp || params.size() > 0))
+ throw runtime_error(
+ "keypoolrefill\n"
+ "Fills the keypool.");
+
+ if (pwalletMain->IsLocked())
+ throw JSONRPCError(-13, "Error: Please enter the wallet passphrase with walletpassphrase first.");
+
+ pwalletMain->TopUpKeyPool();
+
+ if (pwalletMain->GetKeyPoolSize() < GetArg("-keypool", 100))
+ throw JSONRPCError(-4, "Error refreshing keypool.");
+
+ return Value::null;
+}
+
+
+void ThreadTopUpKeyPool(void* parg)
+{
+ pwalletMain->TopUpKeyPool();
+}
+
+void ThreadCleanWalletPassphrase(void* parg)
+{
+ int64 nMyWakeTime = GetTimeMillis() + *((int64*)parg) * 1000;
+
+ ENTER_CRITICAL_SECTION(cs_nWalletUnlockTime);
+
+ if (nWalletUnlockTime == 0)
+ {
+ nWalletUnlockTime = nMyWakeTime;
+
+ do
+ {
+ if (nWalletUnlockTime==0)
+ break;
+ int64 nToSleep = nWalletUnlockTime - GetTimeMillis();
+ if (nToSleep <= 0)
+ break;
+
+ LEAVE_CRITICAL_SECTION(cs_nWalletUnlockTime);
+ Sleep(nToSleep);
+ ENTER_CRITICAL_SECTION(cs_nWalletUnlockTime);
+
+ } while(1);
+
+ if (nWalletUnlockTime)
+ {
+ nWalletUnlockTime = 0;
+ pwalletMain->Lock();
+ }
+ }
+ else
+ {
+ if (nWalletUnlockTime < nMyWakeTime)
+ nWalletUnlockTime = nMyWakeTime;
+ }
+
+ LEAVE_CRITICAL_SECTION(cs_nWalletUnlockTime);
+
+ delete (int64*)parg;
+}
+
+Value walletpassphrase(const Array& params, bool fHelp)
+{
+ if (pwalletMain->IsCrypted() && (fHelp || params.size() != 2))
+ throw runtime_error(
+ "walletpassphrase <passphrase> <timeout>\n"
+ "Stores the wallet decryption key in memory for <timeout> seconds.");
+ if (fHelp)
+ return true;
+ if (!pwalletMain->IsCrypted())
+ throw JSONRPCError(-15, "Error: running with an unencrypted wallet, but walletpassphrase was called.");
+
+ if (!pwalletMain->IsLocked())
+ throw JSONRPCError(-17, "Error: Wallet is already unlocked.");
+
+ // Note that the walletpassphrase is stored in params[0] which is not mlock()ed
+ SecureString strWalletPass;
+ strWalletPass.reserve(100);
+ // TODO: get rid of this .c_str() by implementing SecureString::operator=(std::string)
+ // Alternately, find a way to make params[0] mlock()'d to begin with.
+ strWalletPass = params[0].get_str().c_str();
+
+ if (strWalletPass.length() > 0)
+ {
+ if (!pwalletMain->Unlock(strWalletPass))
+ throw JSONRPCError(-14, "Error: The wallet passphrase entered was incorrect.");
+ }
+ else
+ throw runtime_error(
+ "walletpassphrase <passphrase> <timeout>\n"
+ "Stores the wallet decryption key in memory for <timeout> seconds.");
+
+ CreateThread(ThreadTopUpKeyPool, NULL);
+ int64* pnSleepTime = new int64(params[1].get_int64());
+ CreateThread(ThreadCleanWalletPassphrase, pnSleepTime);
+
+ return Value::null;
+}
+
+
+Value walletpassphrasechange(const Array& params, bool fHelp)
+{
+ if (pwalletMain->IsCrypted() && (fHelp || params.size() != 2))
+ throw runtime_error(
+ "walletpassphrasechange <oldpassphrase> <newpassphrase>\n"
+ "Changes the wallet passphrase from <oldpassphrase> to <newpassphrase>.");
+ if (fHelp)
+ return true;
+ if (!pwalletMain->IsCrypted())
+ throw JSONRPCError(-15, "Error: running with an unencrypted wallet, but walletpassphrasechange was called.");
+
+ // TODO: get rid of these .c_str() calls by implementing SecureString::operator=(std::string)
+ // Alternately, find a way to make params[0] mlock()'d to begin with.
+ SecureString strOldWalletPass;
+ strOldWalletPass.reserve(100);
+ strOldWalletPass = params[0].get_str().c_str();
+
+ SecureString strNewWalletPass;
+ strNewWalletPass.reserve(100);
+ strNewWalletPass = params[1].get_str().c_str();
+
+ if (strOldWalletPass.length() < 1 || strNewWalletPass.length() < 1)
+ throw runtime_error(
+ "walletpassphrasechange <oldpassphrase> <newpassphrase>\n"
+ "Changes the wallet passphrase from <oldpassphrase> to <newpassphrase>.");
+
+ if (!pwalletMain->ChangeWalletPassphrase(strOldWalletPass, strNewWalletPass))
+ throw JSONRPCError(-14, "Error: The wallet passphrase entered was incorrect.");
+
+ return Value::null;
+}
+
+
+Value walletlock(const Array& params, bool fHelp)
+{
+ if (pwalletMain->IsCrypted() && (fHelp || params.size() != 0))
+ throw runtime_error(
+ "walletlock\n"
+ "Removes the wallet encryption key from memory, locking the wallet.\n"
+ "After calling this method, you will need to call walletpassphrase again\n"
+ "before being able to call any methods which require the wallet to be unlocked.");
+ if (fHelp)
+ return true;
+ if (!pwalletMain->IsCrypted())
+ throw JSONRPCError(-15, "Error: running with an unencrypted wallet, but walletlock was called.");
+
+ CRITICAL_BLOCK(cs_nWalletUnlockTime)
+ {
+ pwalletMain->Lock();
+ nWalletUnlockTime = 0;
+ }
+
+ return Value::null;
+}
+
+
+Value encryptwallet(const Array& params, bool fHelp)
+{
+ if (!pwalletMain->IsCrypted() && (fHelp || params.size() != 1))
+ throw runtime_error(
+ "encryptwallet <passphrase>\n"
+ "Encrypts the wallet with <passphrase>.");
+ if (fHelp)
+ return true;
+ if (pwalletMain->IsCrypted())
+ throw JSONRPCError(-15, "Error: running with an encrypted wallet, but encryptwallet was called.");
+
+#ifdef QT_GUI
+ // shutting down via RPC while the GUI is running does not work (yet):
+ throw runtime_error("Not Yet Implemented: use GUI to encrypt wallet, not RPC command");
+#endif
+
+ // TODO: get rid of this .c_str() by implementing SecureString::operator=(std::string)
+ // Alternately, find a way to make params[0] mlock()'d to begin with.
+ SecureString strWalletPass;
+ strWalletPass.reserve(100);
+ strWalletPass = params[0].get_str().c_str();
+
+ if (strWalletPass.length() < 1)
+ throw runtime_error(
+ "encryptwallet <passphrase>\n"
+ "Encrypts the wallet with <passphrase>.");
+
+ if (!pwalletMain->EncryptWallet(strWalletPass))
+ throw JSONRPCError(-16, "Error: Failed to encrypt the wallet.");
+
+ // BDB seems to have a bad habit of writing old data into
+ // slack space in .dat files; that is bad if the old data is
+ // unencrypted private keys. So:
+ CreateThread(Shutdown, NULL);
+ return "wallet encrypted; bitcoin server stopping, restart to run with encrypted wallet";
+}
+
+
+Value validateaddress(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() != 1)
+ throw runtime_error(
+ "validateaddress <bitcoinaddress>\n"
+ "Return information about <bitcoinaddress>.");
+
+ CBitcoinAddress address(params[0].get_str());
+ bool isValid = address.IsValid();
+
+ Object ret;
+ ret.push_back(Pair("isvalid", isValid));
+ if (isValid)
+ {
+ // Call Hash160ToAddress() so we always return current ADDRESSVERSION
+ // version of the address:
+ string currentAddress = address.ToString();
+ ret.push_back(Pair("address", currentAddress));
+ ret.push_back(Pair("ismine", (pwalletMain->HaveKey(address) > 0)));
+ if (pwalletMain->mapAddressBook.count(address))
+ ret.push_back(Pair("account", pwalletMain->mapAddressBook[address]));
+ }
+ return ret;
+}
+
+
+Value getwork(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() > 1)
+ throw runtime_error(
+ "getwork [data]\n"
+ "If [data] is not specified, returns formatted hash data to work on:\n"
+ " \"midstate\" : precomputed hash state after hashing the first half of the data (DEPRECATED)\n" // deprecated
+ " \"data\" : block data\n"
+ " \"hash1\" : formatted hash buffer for second hash (DEPRECATED)\n" // deprecated
+ " \"target\" : little endian hash target\n"
+ "If [data] is specified, tries to solve the block and returns true if it was successful.");
+
+ if (vNodes.empty())
+ throw JSONRPCError(-9, "Bitcoin is not connected!");
+
+ if (IsInitialBlockDownload())
+ throw JSONRPCError(-10, "Bitcoin is downloading blocks...");
+
+ typedef map<uint256, pair<CBlock*, CScript> > mapNewBlock_t;
+ static mapNewBlock_t mapNewBlock;
+ static vector<CBlock*> vNewBlock;
+ static CReserveKey reservekey(pwalletMain);
+
+ if (params.size() == 0)
+ {
+ // Update block
+ static unsigned int nTransactionsUpdatedLast;
+ static CBlockIndex* pindexPrev;
+ static int64 nStart;
+ static CBlock* pblock;
+ if (pindexPrev != pindexBest ||
+ (nTransactionsUpdated != nTransactionsUpdatedLast && GetTime() - nStart > 60))
+ {
+ if (pindexPrev != pindexBest)
+ {
+ // Deallocate old blocks since they're obsolete now
+ mapNewBlock.clear();
+ BOOST_FOREACH(CBlock* pblock, vNewBlock)
+ delete pblock;
+ vNewBlock.clear();
+ }
+ nTransactionsUpdatedLast = nTransactionsUpdated;
+ pindexPrev = pindexBest;
+ nStart = GetTime();
+
+ // Create new block
+ pblock = CreateNewBlock(reservekey);
+ if (!pblock)
+ throw JSONRPCError(-7, "Out of memory");
+ vNewBlock.push_back(pblock);
+ }
+
+ // Update nTime
+ pblock->nTime = max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
+ pblock->nNonce = 0;
+
+ // Update nExtraNonce
+ static unsigned int nExtraNonce = 0;
+ IncrementExtraNonce(pblock, pindexPrev, nExtraNonce);
+
+ // Save
+ mapNewBlock[pblock->hashMerkleRoot] = make_pair(pblock, pblock->vtx[0].vin[0].scriptSig);
+
+ // Prebuild hash buffers
+ char pmidstate[32];
+ char pdata[128];
+ char phash1[64];
+ FormatHashBuffers(pblock, pmidstate, pdata, phash1);
+
+ uint256 hashTarget = CBigNum().SetCompact(pblock->nBits).getuint256();
+
+ Object result;
+ result.push_back(Pair("midstate", HexStr(BEGIN(pmidstate), END(pmidstate)))); // deprecated
+ result.push_back(Pair("data", HexStr(BEGIN(pdata), END(pdata))));
+ result.push_back(Pair("hash1", HexStr(BEGIN(phash1), END(phash1)))); // deprecated
+ result.push_back(Pair("target", HexStr(BEGIN(hashTarget), END(hashTarget))));
+ return result;
+ }
+ else
+ {
+ // Parse parameters
+ vector<unsigned char> vchData = ParseHex(params[0].get_str());
+ if (vchData.size() != 128)
+ throw JSONRPCError(-8, "Invalid parameter");
+ CBlock* pdata = (CBlock*)&vchData[0];
+
+ // Byte reverse
+ for (int i = 0; i < 128/4; i++)
+ ((unsigned int*)pdata)[i] = ByteReverse(((unsigned int*)pdata)[i]);
+
+ // Get saved block
+ if (!mapNewBlock.count(pdata->hashMerkleRoot))
+ return false;
+ CBlock* pblock = mapNewBlock[pdata->hashMerkleRoot].first;
+
+ pblock->nTime = pdata->nTime;
+ pblock->nNonce = pdata->nNonce;
+ pblock->vtx[0].vin[0].scriptSig = mapNewBlock[pdata->hashMerkleRoot].second;
+ pblock->hashMerkleRoot = pblock->BuildMerkleTree();
+
+ return CheckWork(pblock, *pwalletMain, reservekey);
+ }
+}
+
+
+Value getmemorypool(const Array& params, bool fHelp)
+{
+ if (fHelp || params.size() > 1)
+ throw runtime_error(
+ "getmemorypool [data]\n"
+ "If [data] is not specified, returns data needed to construct a block to work on:\n"
+ " \"version\" : block version\n"
+ " \"previousblockhash\" : hash of current highest block\n"
+ " \"transactions\" : contents of non-coinbase transactions that should be included in the next block\n"
+ " \"coinbasevalue\" : maximum allowable input to coinbase transaction, including the generation award and transaction fees\n"
+ " \"time\" : timestamp appropriate for next block\n"
+ " \"bits\" : compressed target of next block\n"
+ "If [data] is specified, tries to solve the block and returns true if it was successful.");
+
+ if (params.size() == 0)
+ {
+ if (vNodes.empty())
+ throw JSONRPCError(-9, "Bitcoin is not connected!");
+
+ if (IsInitialBlockDownload())
+ throw JSONRPCError(-10, "Bitcoin is downloading blocks...");
+
+ static CReserveKey reservekey(pwalletMain);
+
+ // Update block
+ static unsigned int nTransactionsUpdatedLast;
+ static CBlockIndex* pindexPrev;
+ static int64 nStart;
+ static CBlock* pblock;
+ if (pindexPrev != pindexBest ||
+ (nTransactionsUpdated != nTransactionsUpdatedLast && GetTime() - nStart > 5))
+ {
+ nTransactionsUpdatedLast = nTransactionsUpdated;
+ pindexPrev = pindexBest;
+ nStart = GetTime();
+
+ // Create new block
+ if(pblock)
+ delete pblock;
+ pblock = CreateNewBlock(reservekey);
+ if (!pblock)
+ throw JSONRPCError(-7, "Out of memory");
+ }
+
+ // Update nTime
+ pblock->nTime = max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
+ pblock->nNonce = 0;
+
+ Array transactions;
+ BOOST_FOREACH(CTransaction tx, pblock->vtx) {
+ if(tx.IsCoinBase())
+ continue;
+
+ CDataStream ssTx;
+ ssTx << tx;
+
+ transactions.push_back(HexStr(ssTx.begin(), ssTx.end()));
+ }
+
+ Object result;
+ result.push_back(Pair("version", pblock->nVersion));
+ result.push_back(Pair("previousblockhash", pblock->hashPrevBlock.GetHex()));
+ result.push_back(Pair("transactions", transactions));
+ result.push_back(Pair("coinbasevalue", (int64_t)pblock->vtx[0].vout[0].nValue));
+ result.push_back(Pair("time", (int64_t)pblock->nTime));
+
+ union {
+ int32_t nBits;
+ char cBits[4];
+ } uBits;
+ uBits.nBits = htonl((int32_t)pblock->nBits);
+ result.push_back(Pair("bits", HexStr(BEGIN(uBits.cBits), END(uBits.cBits))));
+
+ return result;
+ }
+ else
+ {
+ // Parse parameters
+ CDataStream ssBlock(ParseHex(params[0].get_str()));
+ CBlock pblock;
+ ssBlock >> pblock;
+
+ return ProcessBlock(NULL, &pblock);
+ }
+}
+
+
+
+
+
+
+
+
+
+
+
+//
+// Call Table
+//
+
+pair<string, rpcfn_type> pCallTable[] =
+{
+ make_pair("help", &help),
+ make_pair("stop", &stop),
+ make_pair("getblockcount", &getblockcount),
+ make_pair("getblocknumber", &getblocknumber),
+ make_pair("getconnectioncount", &getconnectioncount),
+ make_pair("getdifficulty", &getdifficulty),
+ make_pair("getgenerate", &getgenerate),
+ make_pair("setgenerate", &setgenerate),
+ make_pair("gethashespersec", &gethashespersec),
+ make_pair("getinfo", &getinfo),
+ make_pair("getnewaddress", &getnewaddress),
+ make_pair("getaccountaddress", &getaccountaddress),
+ make_pair("setaccount", &setaccount),
+ make_pair("getaccount", &getaccount),
+ make_pair("getaddressesbyaccount", &getaddressesbyaccount),
+ make_pair("sendtoaddress", &sendtoaddress),
+ make_pair("getreceivedbyaddress", &getreceivedbyaddress),
+ make_pair("getreceivedbyaccount", &getreceivedbyaccount),
+ make_pair("listreceivedbyaddress", &listreceivedbyaddress),
+ make_pair("listreceivedbyaccount", &listreceivedbyaccount),
+ make_pair("backupwallet", &backupwallet),
+ make_pair("keypoolrefill", &keypoolrefill),
+ make_pair("walletpassphrase", &walletpassphrase),
+ make_pair("walletpassphrasechange", &walletpassphrasechange),
+ make_pair("walletlock", &walletlock),
+ make_pair("encryptwallet", &encryptwallet),
+ make_pair("validateaddress", &validateaddress),
+ make_pair("getbalance", &getbalance),
+ make_pair("move", &movecmd),
+ make_pair("sendfrom", &sendfrom),
+ make_pair("sendmany", &sendmany),
+ make_pair("gettransaction", &gettransaction),
+ make_pair("listtransactions", &listtransactions),
+ make_pair("signmessage", &signmessage),
+ make_pair("verifymessage", &verifymessage),
+ make_pair("getwork", &getwork),
+ make_pair("listaccounts", &listaccounts),
+ make_pair("settxfee", &settxfee),
+ make_pair("getmemorypool", &getmemorypool),
+ make_pair("listsinceblock", &listsinceblock),
+};
+map<string, rpcfn_type> mapCallTable(pCallTable, pCallTable + sizeof(pCallTable)/sizeof(pCallTable[0]));
+
+string pAllowInSafeMode[] =
+{
+ "help",
+ "stop",
+ "getblockcount",
+ "getblocknumber", // deprecated
+ "getconnectioncount",
+ "getdifficulty",
+ "getgenerate",
+ "setgenerate",
+ "gethashespersec",
+ "getinfo",
+ "getnewaddress",
+ "getaccountaddress",
+ "getaccount",
+ "getaddressesbyaccount",
+ "backupwallet",
+ "keypoolrefill",
+ "walletpassphrase",
+ "walletlock",
+ "validateaddress",
+ "getwork",
+ "getmemorypool",
+};
+set<string> setAllowInSafeMode(pAllowInSafeMode, pAllowInSafeMode + sizeof(pAllowInSafeMode)/sizeof(pAllowInSafeMode[0]));
+
+
+
+
+//
+// HTTP protocol
+//
+// This ain't Apache. We're just using HTTP header for the length field
+// and to be compatible with other JSON-RPC implementations.
+//
+
+string HTTPPost(const string& strMsg, const map<string,string>& mapRequestHeaders)
+{
+ ostringstream s;
+ s << "POST / HTTP/1.1\r\n"
+ << "User-Agent: bitcoin-json-rpc/" << FormatFullVersion() << "\r\n"
+ << "Host: 127.0.0.1\r\n"
+ << "Content-Type: application/json\r\n"
+ << "Content-Length: " << strMsg.size() << "\r\n"
+ << "Connection: close\r\n"
+ << "Accept: application/json\r\n";
+ BOOST_FOREACH(const PAIRTYPE(string, string)& item, mapRequestHeaders)
+ s << item.first << ": " << item.second << "\r\n";
+ s << "\r\n" << strMsg;
+
+ return s.str();
+}
+
+string rfc1123Time()
+{
+ char buffer[64];
+ time_t now;
+ time(&now);
+ struct tm* now_gmt = gmtime(&now);
+ string locale(setlocale(LC_TIME, NULL));
+ setlocale(LC_TIME, "C"); // we want posix (aka "C") weekday/month strings
+ strftime(buffer, sizeof(buffer), "%a, %d %b %Y %H:%M:%S +0000", now_gmt);
+ setlocale(LC_TIME, locale.c_str());
+ return string(buffer);
+}
+
+static string HTTPReply(int nStatus, const string& strMsg)
+{
+ if (nStatus == 401)
+ return strprintf("HTTP/1.0 401 Authorization Required\r\n"
+ "Date: %s\r\n"
+ "Server: bitcoin-json-rpc/%s\r\n"
+ "WWW-Authenticate: Basic realm=\"jsonrpc\"\r\n"
+ "Content-Type: text/html\r\n"
+ "Content-Length: 296\r\n"
+ "\r\n"
+ "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\"\r\n"
+ "\"http://www.w3.org/TR/1999/REC-html401-19991224/loose.dtd\">\r\n"
+ "<HTML>\r\n"
+ "<HEAD>\r\n"
+ "<TITLE>Error</TITLE>\r\n"
+ "<META HTTP-EQUIV='Content-Type' CONTENT='text/html; charset=ISO-8859-1'>\r\n"
+ "</HEAD>\r\n"
+ "<BODY><H1>401 Unauthorized.</H1></BODY>\r\n"
+ "</HTML>\r\n", rfc1123Time().c_str(), FormatFullVersion().c_str());
+ const char *cStatus;
+ if (nStatus == 200) cStatus = "OK";
+ else if (nStatus == 400) cStatus = "Bad Request";
+ else if (nStatus == 403) cStatus = "Forbidden";
+ else if (nStatus == 404) cStatus = "Not Found";
+ else if (nStatus == 500) cStatus = "Internal Server Error";
+ else cStatus = "";
+ return strprintf(
+ "HTTP/1.1 %d %s\r\n"
+ "Date: %s\r\n"
+ "Connection: close\r\n"
+ "Content-Length: %d\r\n"
+ "Content-Type: application/json\r\n"
+ "Server: bitcoin-json-rpc/%s\r\n"
+ "\r\n"
+ "%s",
+ nStatus,
+ cStatus,
+ rfc1123Time().c_str(),
+ strMsg.size(),
+ FormatFullVersion().c_str(),
+ strMsg.c_str());
+}
+
+int ReadHTTPStatus(std::basic_istream<char>& stream)
+{
+ string str;
+ getline(stream, str);
+ vector<string> vWords;
+ boost::split(vWords, str, boost::is_any_of(" "));
+ if (vWords.size() < 2)
+ return 500;
+ return atoi(vWords[1].c_str());
+}
+
+int ReadHTTPHeader(std::basic_istream<char>& stream, map<string, string>& mapHeadersRet)
+{
+ int nLen = 0;
+ loop
+ {
+ string str;
+ std::getline(stream, str);
+ if (str.empty() || str == "\r")
+ break;
+ string::size_type nColon = str.find(":");
+ if (nColon != string::npos)
+ {
+ string strHeader = str.substr(0, nColon);
+ boost::trim(strHeader);
+ boost::to_lower(strHeader);
+ string strValue = str.substr(nColon+1);
+ boost::trim(strValue);
+ mapHeadersRet[strHeader] = strValue;
+ if (strHeader == "content-length")
+ nLen = atoi(strValue.c_str());
+ }
+ }
+ return nLen;
+}
+
+int ReadHTTP(std::basic_istream<char>& stream, map<string, string>& mapHeadersRet, string& strMessageRet)
+{
+ mapHeadersRet.clear();
+ strMessageRet = "";
+
+ // Read status
+ int nStatus = ReadHTTPStatus(stream);
+
+ // Read header
+ int nLen = ReadHTTPHeader(stream, mapHeadersRet);
+ if (nLen < 0 || nLen > MAX_SIZE)
+ return 500;
+
+ // Read message
+ if (nLen > 0)
+ {
+ vector<char> vch(nLen);
+ stream.read(&vch[0], nLen);
+ strMessageRet = string(vch.begin(), vch.end());
+ }
+
+ return nStatus;
+}
+
+bool HTTPAuthorized(map<string, string>& mapHeaders)
+{
+ string strAuth = mapHeaders["authorization"];
+ if (strAuth.substr(0,6) != "Basic ")
+ return false;
+ string strUserPass64 = strAuth.substr(6); boost::trim(strUserPass64);
+ string strUserPass = DecodeBase64(strUserPass64);
+ return strUserPass == strRPCUserColonPass;
+}
+
+//
+// JSON-RPC protocol. Bitcoin speaks version 1.0 for maximum compatibility,
+// but uses JSON-RPC 1.1/2.0 standards for parts of the 1.0 standard that were
+// unspecified (HTTP errors and contents of 'error').
+//
+// 1.0 spec: http://json-rpc.org/wiki/specification
+// 1.2 spec: http://groups.google.com/group/json-rpc/web/json-rpc-over-http
+// http://www.codeproject.com/KB/recipes/JSON_Spirit.aspx
+//
+
+string JSONRPCRequest(const string& strMethod, const Array& params, const Value& id)
+{
+ Object request;
+ request.push_back(Pair("method", strMethod));
+ request.push_back(Pair("params", params));
+ request.push_back(Pair("id", id));
+ return write_string(Value(request), false) + "\n";
+}
+
+string JSONRPCReply(const Value& result, const Value& error, const Value& id)
+{
+ Object reply;
+ if (error.type() != null_type)
+ reply.push_back(Pair("result", Value::null));
+ else
+ reply.push_back(Pair("result", result));
+ reply.push_back(Pair("error", error));
+ reply.push_back(Pair("id", id));
+ return write_string(Value(reply), false) + "\n";
+}
+
+void ErrorReply(std::ostream& stream, const Object& objError, const Value& id)
+{
+ // Send error reply from json-rpc error object
+ int nStatus = 500;
+ int code = find_value(objError, "code").get_int();
+ if (code == -32600) nStatus = 400;
+ else if (code == -32601) nStatus = 404;
+ string strReply = JSONRPCReply(Value::null, objError, id);
+ stream << HTTPReply(nStatus, strReply) << std::flush;
+}
+
+bool ClientAllowed(const string& strAddress)
+{
+ if (strAddress == asio::ip::address_v4::loopback().to_string())
+ return true;
+ const vector<string>& vAllow = mapMultiArgs["-rpcallowip"];
+ BOOST_FOREACH(string strAllow, vAllow)
+ if (WildcardMatch(strAddress, strAllow))
+ return true;
+ return false;
+}
+
+#ifdef USE_SSL
+//
+// IOStream device that speaks SSL but can also speak non-SSL
+//
+class SSLIOStreamDevice : public iostreams::device<iostreams::bidirectional> {
+public:
+ SSLIOStreamDevice(SSLStream &streamIn, bool fUseSSLIn) : stream(streamIn)
+ {
+ fUseSSL = fUseSSLIn;
+ fNeedHandshake = fUseSSLIn;
+ }
+
+ void handshake(ssl::stream_base::handshake_type role)
+ {
+ if (!fNeedHandshake) return;
+ fNeedHandshake = false;
+ stream.handshake(role);
+ }
+ std::streamsize read(char* s, std::streamsize n)
+ {
+ handshake(ssl::stream_base::server); // HTTPS servers read first
+ if (fUseSSL) return stream.read_some(asio::buffer(s, n));
+ return stream.next_layer().read_some(asio::buffer(s, n));
+ }
+ std::streamsize write(const char* s, std::streamsize n)
+ {
+ handshake(ssl::stream_base::client); // HTTPS clients write first
+ if (fUseSSL) return asio::write(stream, asio::buffer(s, n));
+ return asio::write(stream.next_layer(), asio::buffer(s, n));
+ }
+ bool connect(const std::string& server, const std::string& port)
+ {
+ ip::tcp::resolver resolver(stream.get_io_service());
+ ip::tcp::resolver::query query(server.c_str(), port.c_str());
+ ip::tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
+ ip::tcp::resolver::iterator end;
+ boost::system::error_code error = asio::error::host_not_found;
+ while (error && endpoint_iterator != end)
+ {
+ stream.lowest_layer().close();
+ stream.lowest_layer().connect(*endpoint_iterator++, error);
+ }
+ if (error)
+ return false;
+ return true;
+ }
+
+private:
+ bool fNeedHandshake;
+ bool fUseSSL;
+ SSLStream& stream;
+};
+#endif
+
+void ThreadRPCServer(void* parg)
+{
+ IMPLEMENT_RANDOMIZE_STACK(ThreadRPCServer(parg));
+ try
+ {
+ vnThreadsRunning[4]++;
+ ThreadRPCServer2(parg);
+ vnThreadsRunning[4]--;
+ }
+ catch (std::exception& e) {
+ vnThreadsRunning[4]--;
+ PrintException(&e, "ThreadRPCServer()");
+ } catch (...) {
+ vnThreadsRunning[4]--;
+ PrintException(NULL, "ThreadRPCServer()");
+ }
+ printf("ThreadRPCServer exiting\n");
+}
+
+void ThreadRPCServer2(void* parg)
+{
+ printf("ThreadRPCServer started\n");
+
+ strRPCUserColonPass = mapArgs["-rpcuser"] + ":" + mapArgs["-rpcpassword"];
+ if (strRPCUserColonPass == ":")
+ {
+ unsigned char rand_pwd[32];
+ RAND_bytes(rand_pwd, 32);
+ string strWhatAmI = "To use bitcoind";
+ if (mapArgs.count("-server"))
+ strWhatAmI = strprintf(_("To use the %s option"), "\"-server\"");
+ else if (mapArgs.count("-daemon"))
+ strWhatAmI = strprintf(_("To use the %s option"), "\"-daemon\"");
+ PrintConsole(
+ _("Error: %s, you must set a rpcpassword in the configuration file:\n %s\n"
+ "It is recommended you use the following random password:\n"
+ "rpcuser=bitcoinrpc\n"
+ "rpcpassword=%s\n"
+ "(you do not need to remember this password)\n"
+ "If the file does not exist, create it with owner-readable-only file permissions.\n"),
+ strWhatAmI.c_str(),
+ GetConfigFile().c_str(),
+ EncodeBase58(&rand_pwd[0],&rand_pwd[0]+32).c_str());
+#ifndef QT_GUI
+ CreateThread(Shutdown, NULL);
+#endif
+ return;
+ }
+
+ bool fUseSSL = GetBoolArg("-rpcssl");
+ asio::ip::address bindAddress = mapArgs.count("-rpcallowip") ? asio::ip::address_v4::any() : asio::ip::address_v4::loopback();
+
+ asio::io_service io_service;
+ ip::tcp::endpoint endpoint(bindAddress, GetArg("-rpcport", 8332));
+ ip::tcp::acceptor acceptor(io_service, endpoint);
+
+ acceptor.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
+
+#ifdef USE_SSL
+ ssl::context context(io_service, ssl::context::sslv23);
+ if (fUseSSL)
+ {
+ context.set_options(ssl::context::no_sslv2);
+ filesystem::path certfile = GetArg("-rpcsslcertificatechainfile", "server.cert");
+ if (!certfile.is_complete()) certfile = filesystem::path(GetDataDir()) / certfile;
+ if (filesystem::exists(certfile)) context.use_certificate_chain_file(certfile.string().c_str());
+ else printf("ThreadRPCServer ERROR: missing server certificate file %s\n", certfile.string().c_str());
+ filesystem::path pkfile = GetArg("-rpcsslprivatekeyfile", "server.pem");
+ if (!pkfile.is_complete()) pkfile = filesystem::path(GetDataDir()) / pkfile;
+ if (filesystem::exists(pkfile)) context.use_private_key_file(pkfile.string().c_str(), ssl::context::pem);
+ else printf("ThreadRPCServer ERROR: missing server private key file %s\n", pkfile.string().c_str());
+
+ string ciphers = GetArg("-rpcsslciphers",
+ "TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!AH:!3DES:@STRENGTH");
+ SSL_CTX_set_cipher_list(context.impl(), ciphers.c_str());
+ }
+#else
+ if (fUseSSL)
+ throw runtime_error("-rpcssl=1, but bitcoin compiled without full openssl libraries.");
+#endif
+
+ loop
+ {
+ // Accept connection
+#ifdef USE_SSL
+ SSLStream sslStream(io_service, context);
+ SSLIOStreamDevice d(sslStream, fUseSSL);
+ iostreams::stream<SSLIOStreamDevice> stream(d);
+#else
+ ip::tcp::iostream stream;
+#endif
+
+ ip::tcp::endpoint peer;
+ vnThreadsRunning[4]--;
+#ifdef USE_SSL
+ acceptor.accept(sslStream.lowest_layer(), peer);
+#else
+ acceptor.accept(*stream.rdbuf(), peer);
+#endif
+ vnThreadsRunning[4]++;
+ if (fShutdown)
+ return;
+
+ // Restrict callers by IP
+ if (!ClientAllowed(peer.address().to_string()))
+ {
+ // Only send a 403 if we're not using SSL to prevent a DoS during the SSL handshake.
+ if (!fUseSSL)
+ stream << HTTPReply(403, "") << std::flush;
+ continue;
+ }
+
+ map<string, string> mapHeaders;
+ string strRequest;
+
+ boost::thread api_caller(ReadHTTP, boost::ref(stream), boost::ref(mapHeaders), boost::ref(strRequest));
+ if (!api_caller.timed_join(boost::posix_time::seconds(GetArg("-rpctimeout", 30))))
+ { // Timed out:
+ acceptor.cancel();
+ printf("ThreadRPCServer ReadHTTP timeout\n");
+ continue;
+ }
+
+ // Check authorization
+ if (mapHeaders.count("authorization") == 0)
+ {
+ stream << HTTPReply(401, "") << std::flush;
+ continue;
+ }
+ if (!HTTPAuthorized(mapHeaders))
+ {
+ printf("ThreadRPCServer incorrect password attempt from %s\n",peer.address().to_string().c_str());
+ /* Deter brute-forcing short passwords.
+ If this results in a DOS the user really
+ shouldn't have their RPC port exposed.*/
+ if (mapArgs["-rpcpassword"].size() < 20)
+ Sleep(250);
+
+ stream << HTTPReply(401, "") << std::flush;
+ continue;
+ }
+
+ Value id = Value::null;
+ try
+ {
+ // Parse request
+ Value valRequest;
+ if (!read_string(strRequest, valRequest) || valRequest.type() != obj_type)
+ throw JSONRPCError(-32700, "Parse error");
+ const Object& request = valRequest.get_obj();
+
+ // Parse id now so errors from here on will have the id
+ id = find_value(request, "id");
+
+ // Parse method
+ Value valMethod = find_value(request, "method");
+ if (valMethod.type() == null_type)
+ throw JSONRPCError(-32600, "Missing method");
+ if (valMethod.type() != str_type)
+ throw JSONRPCError(-32600, "Method must be a string");
+ string strMethod = valMethod.get_str();
+ if (strMethod != "getwork" && strMethod != "getmemorypool")
+ printf("ThreadRPCServer method=%s\n", strMethod.c_str());
+
+ // Parse params
+ Value valParams = find_value(request, "params");
+ Array params;
+ if (valParams.type() == array_type)
+ params = valParams.get_array();
+ else if (valParams.type() == null_type)
+ params = Array();
+ else
+ throw JSONRPCError(-32600, "Params must be an array");
+
+ // Find method
+ map<string, rpcfn_type>::iterator mi = mapCallTable.find(strMethod);
+ if (mi == mapCallTable.end())
+ throw JSONRPCError(-32601, "Method not found");
+
+ // Observe safe mode
+ string strWarning = GetWarnings("rpc");
+ if (strWarning != "" && !GetBoolArg("-disablesafemode") && !setAllowInSafeMode.count(strMethod))
+ throw JSONRPCError(-2, string("Safe mode: ") + strWarning);
+
+ try
+ {
+ // Execute
+ Value result;
+ CRITICAL_BLOCK(cs_main)
+ CRITICAL_BLOCK(pwalletMain->cs_wallet)
+ result = (*(*mi).second)(params, false);
+
+ // Send reply
+ string strReply = JSONRPCReply(result, Value::null, id);
+ stream << HTTPReply(200, strReply) << std::flush;
+ }
+ catch (std::exception& e)
+ {
+ ErrorReply(stream, JSONRPCError(-1, e.what()), id);
+ }
+ }
+ catch (Object& objError)
+ {
+ ErrorReply(stream, objError, id);
+ }
+ catch (std::exception& e)
+ {
+ ErrorReply(stream, JSONRPCError(-32700, e.what()), id);
+ }
+ }
+}
+
+
+
+
+Object CallRPC(const string& strMethod, const Array& params)
+{
+ if (mapArgs["-rpcuser"] == "" && mapArgs["-rpcpassword"] == "")
+ throw runtime_error(strprintf(
+ _("You must set rpcpassword=<password> in the configuration file:\n%s\n"
+ "If the file does not exist, create it with owner-readable-only file permissions."),
+ GetConfigFile().c_str()));
+
+ // Connect to localhost
+ bool fUseSSL = GetBoolArg("-rpcssl");
+#ifdef USE_SSL
+ asio::io_service io_service;
+ ssl::context context(io_service, ssl::context::sslv23);
+ context.set_options(ssl::context::no_sslv2);
+ SSLStream sslStream(io_service, context);
+ SSLIOStreamDevice d(sslStream, fUseSSL);
+ iostreams::stream<SSLIOStreamDevice> stream(d);
+ if (!d.connect(GetArg("-rpcconnect", "127.0.0.1"), GetArg("-rpcport", "8332")))
+ throw runtime_error("couldn't connect to server");
+#else
+ if (fUseSSL)
+ throw runtime_error("-rpcssl=1, but bitcoin compiled without full openssl libraries.");
+
+ ip::tcp::iostream stream(GetArg("-rpcconnect", "127.0.0.1"), GetArg("-rpcport", "8332"));
+ if (stream.fail())
+ throw runtime_error("couldn't connect to server");
+#endif
+
+
+ // HTTP basic authentication
+ string strUserPass64 = EncodeBase64(mapArgs["-rpcuser"] + ":" + mapArgs["-rpcpassword"]);
+ map<string, string> mapRequestHeaders;
+ mapRequestHeaders["Authorization"] = string("Basic ") + strUserPass64;
+
+ // Send request
+ string strRequest = JSONRPCRequest(strMethod, params, 1);
+ string strPost = HTTPPost(strRequest, mapRequestHeaders);
+ stream << strPost << std::flush;
+
+ // Receive reply
+ map<string, string> mapHeaders;
+ string strReply;
+ int nStatus = ReadHTTP(stream, mapHeaders, strReply);
+ if (nStatus == 401)
+ throw runtime_error("incorrect rpcuser or rpcpassword (authorization failed)");
+ else if (nStatus >= 400 && nStatus != 400 && nStatus != 404 && nStatus != 500)
+ throw runtime_error(strprintf("server returned HTTP error %d", nStatus));
+ else if (strReply.empty())
+ throw runtime_error("no response from server");
+
+ // Parse reply
+ Value valReply;
+ if (!read_string(strReply, valReply))
+ throw runtime_error("couldn't parse reply from server");
+ const Object& reply = valReply.get_obj();
+ if (reply.empty())
+ throw runtime_error("expected reply to have result, error and id properties");
+
+ return reply;
+}
+
+
+
+
+template<typename T>
+void ConvertTo(Value& value)
+{
+ if (value.type() == str_type)
+ {
+ // reinterpret string as unquoted json value
+ Value value2;
+ if (!read_string(value.get_str(), value2))
+ throw runtime_error("type mismatch");
+ value = value2.get_value<T>();
+ }
+ else
+ {
+ value = value.get_value<T>();
+ }
+}
+
+int CommandLineRPC(int argc, char *argv[])
+{
+ string strPrint;
+ int nRet = 0;
+ try
+ {
+ // Skip switches
+ while (argc > 1 && IsSwitchChar(argv[1][0]))
+ {
+ argc--;
+ argv++;
+ }
+
+ // Method
+ if (argc < 2)
+ throw runtime_error("too few parameters");
+ string strMethod = argv[1];
+
+ // Parameters default to strings
+ Array params;
+ for (int i = 2; i < argc; i++)
+ params.push_back(argv[i]);
+ int n = params.size();
+
+ //
+ // Special case non-string parameter types
+ //
+ if (strMethod == "setgenerate" && n > 0) ConvertTo<bool>(params[0]);
+ if (strMethod == "setgenerate" && n > 1) ConvertTo<boost::int64_t>(params[1]);
+ if (strMethod == "sendtoaddress" && n > 1) ConvertTo<double>(params[1]);
+ if (strMethod == "settxfee" && n > 0) ConvertTo<double>(params[0]);
+ if (strMethod == "getreceivedbyaddress" && n > 1) ConvertTo<boost::int64_t>(params[1]);
+ if (strMethod == "getreceivedbyaccount" && n > 1) ConvertTo<boost::int64_t>(params[1]);
+ if (strMethod == "listreceivedbyaddress" && n > 0) ConvertTo<boost::int64_t>(params[0]);
+ if (strMethod == "listreceivedbyaddress" && n > 1) ConvertTo<bool>(params[1]);
+ if (strMethod == "listreceivedbyaccount" && n > 0) ConvertTo<boost::int64_t>(params[0]);
+ if (strMethod == "listreceivedbyaccount" && n > 1) ConvertTo<bool>(params[1]);
+ if (strMethod == "getbalance" && n > 1) ConvertTo<boost::int64_t>(params[1]);
+ if (strMethod == "move" && n > 2) ConvertTo<double>(params[2]);
+ if (strMethod == "move" && n > 3) ConvertTo<boost::int64_t>(params[3]);
+ if (strMethod == "sendfrom" && n > 2) ConvertTo<double>(params[2]);
+ if (strMethod == "sendfrom" && n > 3) ConvertTo<boost::int64_t>(params[3]);
+ if (strMethod == "listtransactions" && n > 1) ConvertTo<boost::int64_t>(params[1]);
+ if (strMethod == "listtransactions" && n > 2) ConvertTo<boost::int64_t>(params[2]);
+ if (strMethod == "listaccounts" && n > 0) ConvertTo<boost::int64_t>(params[0]);
+ if (strMethod == "walletpassphrase" && n > 1) ConvertTo<boost::int64_t>(params[1]);
+ if (strMethod == "listsinceblock" && n > 1) ConvertTo<boost::int64_t>(params[1]);
+ if (strMethod == "sendmany" && n > 1)
+ {
+ string s = params[1].get_str();
+ Value v;
+ if (!read_string(s, v) || v.type() != obj_type)
+ throw runtime_error("type mismatch");
+ params[1] = v.get_obj();
+ }
+ if (strMethod == "sendmany" && n > 2) ConvertTo<boost::int64_t>(params[2]);
+
+ // Execute
+ Object reply = CallRPC(strMethod, params);
+
+ // Parse reply
+ const Value& result = find_value(reply, "result");
+ const Value& error = find_value(reply, "error");
+
+ if (error.type() != null_type)
+ {
+ // Error
+ strPrint = "error: " + write_string(error, false);
+ int code = find_value(error.get_obj(), "code").get_int();
+ nRet = abs(code);
+ }
+ else
+ {
+ // Result
+ if (result.type() == null_type)
+ strPrint = "";
+ else if (result.type() == str_type)
+ strPrint = result.get_str();
+ else
+ strPrint = write_string(result, true);
+ }
+ }
+ catch (std::exception& e)
+ {
+ strPrint = string("error: ") + e.what();
+ nRet = 87;
+ }
+ catch (...)
+ {
+ PrintException(NULL, "CommandLineRPC()");
+ }
+
+ if (strPrint != "")
+ {
+ fprintf((nRet == 0 ? stdout : stderr), "%s\n", strPrint.c_str());
+ }
+ return nRet;
+}
+
+
+
+
+#ifdef TEST
+int main(int argc, char *argv[])
+{
+#ifdef _MSC_VER
+ // Turn off microsoft heap dump noise
+ _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
+ _CrtSetReportFile(_CRT_WARN, CreateFile("NUL", GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0));
+#endif
+ setbuf(stdin, NULL);
+ setbuf(stdout, NULL);
+ setbuf(stderr, NULL);
+
+ try
+ {
+ if (argc >= 2 && string(argv[1]) == "-server")
+ {
+ printf("server ready\n");
+ ThreadRPCServer(NULL);
+ }
+ else
+ {
+ return CommandLineRPC(argc, argv);
+ }
+ }
+ catch (std::exception& e) {
+ PrintException(&e, "main()");
+ } catch (...) {
+ PrintException(NULL, "main()");
+ }
+ return 0;
+}
+#endif
diff --git a/bitcoin/src/bitcoinrpc.h b/bitcoin/src/bitcoinrpc.h
@@ -0,0 +1,7 @@
+// Copyright (c) 2010 Satoshi Nakamoto
+// Copyright (c) 2011 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+void ThreadRPCServer(void* parg);
+int CommandLineRPC(int argc, char *argv[]);
diff --git a/bitcoin/src/checkpoints.cpp b/bitcoin/src/checkpoints.cpp
@@ -0,0 +1,65 @@
+// Copyright (c) 2009-2012 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+#include <boost/assign/list_of.hpp> // for 'map_list_of()'
+#include <boost/foreach.hpp>
+
+#include "headers.h"
+#include "checkpoints.h"
+
+namespace Checkpoints
+{
+ typedef std::map<int, uint256> MapCheckpoints;
+
+ //
+ // What makes a good checkpoint block?
+ // + Is surrounded by blocks with reasonable timestamps
+ // (no blocks before with a timestamp after, none after with
+ // timestamp before)
+ // + Contains no strange transactions
+ //
+ static MapCheckpoints mapCheckpoints =
+ boost::assign::map_list_of
+ ( 11111, uint256("0x0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d"))
+ ( 33333, uint256("0x000000002dd5588a74784eaa7ab0507a18ad16a236e7b1ce69f00d7ddfb5d0a6"))
+ ( 68555, uint256("0x00000000001e1b4903550a0b96e9a9405c8a95f387162e4944e8d9fbe501cd6a"))
+ ( 70567, uint256("0x00000000006a49b14bcf27462068f1264c961f11fa2e0eddd2be0791e1d4124a"))
+ ( 74000, uint256("0x0000000000573993a3c9e41ce34471c079dcf5f52a0e824a81e7f953b8661a20"))
+ (105000, uint256("0x00000000000291ce28027faea320c8d2b054b2e0fe44a773f3eefb151d6bdc97"))
+ (118000, uint256("0x000000000000774a7f8a7a12dc906ddb9e17e75d684f15e00f8767f9e8f36553"))
+ (134444, uint256("0x00000000000005b12ffd4cd315cd34ffd4a594f430ac814c91184a0d42d2b0fe"))
+ (140700, uint256("0x000000000000033b512028abb90e1626d8b346fd0ed598ac0a3c371138dce2bd"))
+ (168000, uint256("0x000000000000099e61ea72015e79632f216fe6cb33d7899acb35b75c8303b763"))
+ ;
+
+ bool CheckBlock(int nHeight, const uint256& hash)
+ {
+ if (fTestNet) return true; // Testnet has no checkpoints
+
+ MapCheckpoints::const_iterator i = mapCheckpoints.find(nHeight);
+ if (i == mapCheckpoints.end()) return true;
+ return hash == i->second;
+ }
+
+ int GetTotalBlocksEstimate()
+ {
+ if (fTestNet) return 0;
+
+ return mapCheckpoints.rbegin()->first;
+ }
+
+ CBlockIndex* GetLastCheckpoint(const std::map<uint256, CBlockIndex*>& mapBlockIndex)
+ {
+ if (fTestNet) return NULL;
+
+ BOOST_REVERSE_FOREACH(const MapCheckpoints::value_type& i, mapCheckpoints)
+ {
+ const uint256& hash = i.second;
+ std::map<uint256, CBlockIndex*>::const_iterator t = mapBlockIndex.find(hash);
+ if (t != mapBlockIndex.end())
+ return t->second;
+ }
+ return NULL;
+ }
+}
diff --git a/bitcoin/src/checkpoints.h b/bitcoin/src/checkpoints.h
@@ -0,0 +1,29 @@
+// Copyright (c) 2011 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#ifndef BITCOIN_CHECKPOINT_H
+#define BITCOIN_CHECKPOINT_H
+
+#include <map>
+#include "util.h"
+
+class uint256;
+class CBlockIndex;
+
+//
+// Block-chain checkpoints are compiled-in sanity checks.
+// They are updated every release or three.
+//
+namespace Checkpoints
+{
+ // Returns true if block passes checkpoint checks
+ bool CheckBlock(int nHeight, const uint256& hash);
+
+ // Return conservative estimate of total number of blocks, 0 if unknown
+ int GetTotalBlocksEstimate();
+
+ // Returns last CBlockIndex* in mapBlockIndex that is a checkpoint
+ CBlockIndex* GetLastCheckpoint(const std::map<uint256, CBlockIndex*>& mapBlockIndex);
+}
+
+#endif
diff --git a/bitcoin/src/crypter.cpp b/bitcoin/src/crypter.cpp
@@ -0,0 +1,132 @@
+// Copyright (c) 2011 The Bitcoin Developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <openssl/aes.h>
+#include <openssl/evp.h>
+#include <vector>
+#include <string>
+#include "headers.h"
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+#include "crypter.h"
+#include "main.h"
+#include "util.h"
+
+bool CCrypter::SetKeyFromPassphrase(const SecureString& strKeyData, const std::vector<unsigned char>& chSalt, const unsigned int nRounds, const unsigned int nDerivationMethod)
+{
+ if (nRounds < 1 || chSalt.size() != WALLET_CRYPTO_SALT_SIZE)
+ return false;
+
+ // Try to keep the keydata out of swap (and be a bit over-careful to keep the IV that we don't even use out of swap)
+ // Note that this does nothing about suspend-to-disk (which will put all our key data on disk)
+ // Note as well that at no point in this program is any attempt made to prevent stealing of keys by reading the memory of the running process.
+ mlock(&chKey[0], sizeof chKey);
+ mlock(&chIV[0], sizeof chIV);
+
+ int i = 0;
+ if (nDerivationMethod == 0)
+ i = EVP_BytesToKey(EVP_aes_256_cbc(), EVP_sha512(), &chSalt[0],
+ (unsigned char *)&strKeyData[0], strKeyData.size(), nRounds, chKey, chIV);
+
+ if (i != WALLET_CRYPTO_KEY_SIZE)
+ {
+ memset(&chKey, 0, sizeof chKey);
+ memset(&chIV, 0, sizeof chIV);
+ return false;
+ }
+
+ fKeySet = true;
+ return true;
+}
+
+bool CCrypter::SetKey(const CKeyingMaterial& chNewKey, const std::vector<unsigned char>& chNewIV)
+{
+ if (chNewKey.size() != WALLET_CRYPTO_KEY_SIZE || chNewIV.size() != WALLET_CRYPTO_KEY_SIZE)
+ return false;
+
+ // Try to keep the keydata out of swap
+ // Note that this does nothing about suspend-to-disk (which will put all our key data on disk)
+ // Note as well that at no point in this program is any attempt made to prevent stealing of keys by reading the memory of the running process.
+ mlock(&chKey[0], sizeof chKey);
+ mlock(&chIV[0], sizeof chIV);
+
+ memcpy(&chKey[0], &chNewKey[0], sizeof chKey);
+ memcpy(&chIV[0], &chNewIV[0], sizeof chIV);
+
+ fKeySet = true;
+ return true;
+}
+
+bool CCrypter::Encrypt(const CKeyingMaterial& vchPlaintext, std::vector<unsigned char> &vchCiphertext)
+{
+ if (!fKeySet)
+ return false;
+
+ // max ciphertext len for a n bytes of plaintext is
+ // n + AES_BLOCK_SIZE - 1 bytes
+ int nLen = vchPlaintext.size();
+ int nCLen = nLen + AES_BLOCK_SIZE, nFLen = 0;
+ vchCiphertext = std::vector<unsigned char> (nCLen);
+
+ EVP_CIPHER_CTX ctx;
+
+ EVP_CIPHER_CTX_init(&ctx);
+ EVP_EncryptInit_ex(&ctx, EVP_aes_256_cbc(), NULL, chKey, chIV);
+
+ EVP_EncryptUpdate(&ctx, &vchCiphertext[0], &nCLen, &vchPlaintext[0], nLen);
+ EVP_EncryptFinal_ex(&ctx, (&vchCiphertext[0])+nCLen, &nFLen);
+
+ EVP_CIPHER_CTX_cleanup(&ctx);
+
+ vchCiphertext.resize(nCLen + nFLen);
+ return true;
+}
+
+bool CCrypter::Decrypt(const std::vector<unsigned char>& vchCiphertext, CKeyingMaterial& vchPlaintext)
+{
+ if (!fKeySet)
+ return false;
+
+ // plaintext will always be equal to or lesser than length of ciphertext
+ int nLen = vchCiphertext.size();
+ int nPLen = nLen, nFLen = 0;
+
+ vchPlaintext = CKeyingMaterial(nPLen);
+
+ EVP_CIPHER_CTX ctx;
+
+ EVP_CIPHER_CTX_init(&ctx);
+ EVP_DecryptInit_ex(&ctx, EVP_aes_256_cbc(), NULL, chKey, chIV);
+
+ EVP_DecryptUpdate(&ctx, &vchPlaintext[0], &nPLen, &vchCiphertext[0], nLen);
+ EVP_DecryptFinal_ex(&ctx, (&vchPlaintext[0])+nPLen, &nFLen);
+
+ EVP_CIPHER_CTX_cleanup(&ctx);
+
+ vchPlaintext.resize(nPLen + nFLen);
+ return true;
+}
+
+
+bool EncryptSecret(CKeyingMaterial& vMasterKey, const CSecret &vchPlaintext, const uint256& nIV, std::vector<unsigned char> &vchCiphertext)
+{
+ CCrypter cKeyCrypter;
+ std::vector<unsigned char> chIV(WALLET_CRYPTO_KEY_SIZE);
+ memcpy(&chIV[0], &nIV, WALLET_CRYPTO_KEY_SIZE);
+ if(!cKeyCrypter.SetKey(vMasterKey, chIV))
+ return false;
+ return cKeyCrypter.Encrypt((CKeyingMaterial)vchPlaintext, vchCiphertext);
+}
+
+bool DecryptSecret(const CKeyingMaterial& vMasterKey, const std::vector<unsigned char>& vchCiphertext, const uint256& nIV, CSecret& vchPlaintext)
+{
+ CCrypter cKeyCrypter;
+ std::vector<unsigned char> chIV(WALLET_CRYPTO_KEY_SIZE);
+ memcpy(&chIV[0], &nIV, WALLET_CRYPTO_KEY_SIZE);
+ if(!cKeyCrypter.SetKey(vMasterKey, chIV))
+ return false;
+ return cKeyCrypter.Decrypt(vchCiphertext, *((CKeyingMaterial*)&vchPlaintext));
+}
diff --git a/bitcoin/src/crypter.h b/bitcoin/src/crypter.h
@@ -0,0 +1,96 @@
+// Copyright (c) 2011 The Bitcoin Developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#ifndef __CRYPTER_H__
+#define __CRYPTER_H__
+
+#include "key.h"
+
+const unsigned int WALLET_CRYPTO_KEY_SIZE = 32;
+const unsigned int WALLET_CRYPTO_SALT_SIZE = 8;
+
+/*
+Private key encryption is done based on a CMasterKey,
+which holds a salt and random encryption key.
+
+CMasterKeys are encrypted using AES-256-CBC using a key
+derived using derivation method nDerivationMethod
+(0 == EVP_sha512()) and derivation iterations nDeriveIterations.
+vchOtherDerivationParameters is provided for alternative algorithms
+which may require more parameters (such as scrypt).
+
+Wallet Private Keys are then encrypted using AES-256-CBC
+with the double-sha256 of the public key as the IV, and the
+master key's key as the encryption key (see keystore.[ch]).
+*/
+
+class CMasterKey
+{
+public:
+ std::vector<unsigned char> vchCryptedKey;
+ std::vector<unsigned char> vchSalt;
+ // 0 = EVP_sha512()
+ // 1 = scrypt()
+ unsigned int nDerivationMethod;
+ unsigned int nDeriveIterations;
+ // Use this for more parameters to key derivation,
+ // such as the various parameters to scrypt
+ std::vector<unsigned char> vchOtherDerivationParameters;
+
+ IMPLEMENT_SERIALIZE
+ (
+ READWRITE(vchCryptedKey);
+ READWRITE(vchSalt);
+ READWRITE(nDerivationMethod);
+ READWRITE(nDeriveIterations);
+ READWRITE(vchOtherDerivationParameters);
+ )
+ CMasterKey()
+ {
+ // 25000 rounds is just under 0.1 seconds on a 1.86 GHz Pentium M
+ // ie slightly lower than the lowest hardware we need bother supporting
+ nDeriveIterations = 25000;
+ nDerivationMethod = 0;
+ vchOtherDerivationParameters = std::vector<unsigned char>(0);
+ }
+};
+
+typedef std::vector<unsigned char, secure_allocator<unsigned char> > CKeyingMaterial;
+
+class CCrypter
+{
+private:
+ unsigned char chKey[WALLET_CRYPTO_KEY_SIZE];
+ unsigned char chIV[WALLET_CRYPTO_KEY_SIZE];
+ bool fKeySet;
+
+public:
+ bool SetKeyFromPassphrase(const SecureString &strKeyData, const std::vector<unsigned char>& chSalt, const unsigned int nRounds, const unsigned int nDerivationMethod);
+ bool Encrypt(const CKeyingMaterial& vchPlaintext, std::vector<unsigned char> &vchCiphertext);
+ bool Decrypt(const std::vector<unsigned char>& vchCiphertext, CKeyingMaterial& vchPlaintext);
+ bool SetKey(const CKeyingMaterial& chNewKey, const std::vector<unsigned char>& chNewIV);
+
+ void CleanKey()
+ {
+ memset(&chKey, 0, sizeof chKey);
+ memset(&chIV, 0, sizeof chIV);
+ munlock(&chKey, sizeof chKey);
+ munlock(&chIV, sizeof chIV);
+ fKeySet = false;
+ }
+
+ CCrypter()
+ {
+ fKeySet = false;
+ }
+
+ ~CCrypter()
+ {
+ CleanKey();
+ }
+};
+
+bool EncryptSecret(CKeyingMaterial& vMasterKey, const CSecret &vchPlaintext, const uint256& nIV, std::vector<unsigned char> &vchCiphertext);
+bool DecryptSecret(const CKeyingMaterial& vMasterKey, const std::vector<unsigned char> &vchCiphertext, const uint256& nIV, CSecret &vchPlaintext);
+
+#endif
diff --git a/bitcoin/src/db.cpp b/bitcoin/src/db.cpp
@@ -0,0 +1,1069 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2012 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+#include "headers.h"
+#include "db.h"
+#include "net.h"
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+
+using namespace std;
+using namespace boost;
+
+
+unsigned int nWalletDBUpdated;
+uint64 nAccountingEntryNumber = 0;
+
+
+
+//
+// CDB
+//
+
+static CCriticalSection cs_db;
+static bool fDbEnvInit = false;
+DbEnv dbenv(0);
+static map<string, int> mapFileUseCount;
+static map<string, Db*> mapDb;
+
+static void EnvShutdown()
+{
+ if (!fDbEnvInit)
+ return;
+
+ fDbEnvInit = false;
+ try
+ {
+ dbenv.close(0);
+ }
+ catch (const DbException& e)
+ {
+ printf("EnvShutdown exception: %s (%d)\n", e.what(), e.get_errno());
+ }
+ DbEnv(0).remove(GetDataDir().c_str(), 0);
+}
+
+class CDBInit
+{
+public:
+ CDBInit()
+ {
+ }
+ ~CDBInit()
+ {
+ EnvShutdown();
+ }
+}
+instance_of_cdbinit;
+
+
+CDB::CDB(const char* pszFile, const char* pszMode) : pdb(NULL)
+{
+ int ret;
+ if (pszFile == NULL)
+ return;
+
+ fReadOnly = (!strchr(pszMode, '+') && !strchr(pszMode, 'w'));
+ bool fCreate = strchr(pszMode, 'c');
+ unsigned int nFlags = DB_THREAD;
+ if (fCreate)
+ nFlags |= DB_CREATE;
+
+ CRITICAL_BLOCK(cs_db)
+ {
+ if (!fDbEnvInit)
+ {
+ if (fShutdown)
+ return;
+ string strDataDir = GetDataDir();
+ string strLogDir = strDataDir + "/database";
+ filesystem::create_directory(strLogDir.c_str());
+ string strErrorFile = strDataDir + "/db.log";
+ printf("dbenv.open strLogDir=%s strErrorFile=%s\n", strLogDir.c_str(), strErrorFile.c_str());
+
+ dbenv.set_lg_dir(strLogDir.c_str());
+ dbenv.set_lg_max(10000000);
+ dbenv.set_lk_max_locks(10000);
+ dbenv.set_lk_max_objects(10000);
+ dbenv.set_errfile(fopen(strErrorFile.c_str(), "a")); /// debug
+ dbenv.set_flags(DB_AUTO_COMMIT, 1);
+ ret = dbenv.open(strDataDir.c_str(),
+ DB_CREATE |
+ DB_INIT_LOCK |
+ DB_INIT_LOG |
+ DB_INIT_MPOOL |
+ DB_INIT_TXN |
+ DB_THREAD |
+ DB_RECOVER,
+ S_IRUSR | S_IWUSR);
+ if (ret > 0)
+ throw runtime_error(strprintf("CDB() : error %d opening database environment", ret));
+ fDbEnvInit = true;
+ }
+
+ strFile = pszFile;
+ ++mapFileUseCount[strFile];
+ pdb = mapDb[strFile];
+ if (pdb == NULL)
+ {
+ pdb = new Db(&dbenv, 0);
+
+ ret = pdb->open(NULL, // Txn pointer
+ pszFile, // Filename
+ "main", // Logical db name
+ DB_BTREE, // Database type
+ nFlags, // Flags
+ 0);
+
+ if (ret > 0)
+ {
+ delete pdb;
+ pdb = NULL;
+ CRITICAL_BLOCK(cs_db)
+ --mapFileUseCount[strFile];
+ strFile = "";
+ throw runtime_error(strprintf("CDB() : can't open database file %s, error %d", pszFile, ret));
+ }
+
+ if (fCreate && !Exists(string("version")))
+ {
+ bool fTmp = fReadOnly;
+ fReadOnly = false;
+ WriteVersion(VERSION);
+ fReadOnly = fTmp;
+ }
+
+ mapDb[strFile] = pdb;
+ }
+ }
+}
+
+void CDB::Close()
+{
+ if (!pdb)
+ return;
+ if (!vTxn.empty())
+ vTxn.front()->abort();
+ vTxn.clear();
+ pdb = NULL;
+
+ // Flush database activity from memory pool to disk log
+ unsigned int nMinutes = 0;
+ if (fReadOnly)
+ nMinutes = 1;
+ if (strFile == "addr.dat")
+ nMinutes = 2;
+ if (strFile == "blkindex.dat" && IsInitialBlockDownload() && nBestHeight % 500 != 0)
+ nMinutes = 1;
+ dbenv.txn_checkpoint(0, nMinutes, 0);
+
+ CRITICAL_BLOCK(cs_db)
+ --mapFileUseCount[strFile];
+}
+
+void static CloseDb(const string& strFile)
+{
+ CRITICAL_BLOCK(cs_db)
+ {
+ if (mapDb[strFile] != NULL)
+ {
+ // Close the database handle
+ Db* pdb = mapDb[strFile];
+ pdb->close(0);
+ delete pdb;
+ mapDb[strFile] = NULL;
+ }
+ }
+}
+
+bool CDB::Rewrite(const string& strFile, const char* pszSkip)
+{
+ while (!fShutdown)
+ {
+ CRITICAL_BLOCK(cs_db)
+ {
+ if (!mapFileUseCount.count(strFile) || mapFileUseCount[strFile] == 0)
+ {
+ // Flush log data to the dat file
+ CloseDb(strFile);
+ dbenv.txn_checkpoint(0, 0, 0);
+ dbenv.lsn_reset(strFile.c_str(), 0);
+ mapFileUseCount.erase(strFile);
+
+ bool fSuccess = true;
+ printf("Rewriting %s...\n", strFile.c_str());
+ string strFileRes = strFile + ".rewrite";
+ { // surround usage of db with extra {}
+ CDB db(strFile.c_str(), "r");
+ Db* pdbCopy = new Db(&dbenv, 0);
+
+ int ret = pdbCopy->open(NULL, // Txn pointer
+ strFileRes.c_str(), // Filename
+ "main", // Logical db name
+ DB_BTREE, // Database type
+ DB_CREATE, // Flags
+ 0);
+ if (ret > 0)
+ {
+ printf("Cannot create database file %s\n", strFileRes.c_str());
+ fSuccess = false;
+ }
+
+ Dbc* pcursor = db.GetCursor();
+ if (pcursor)
+ while (fSuccess)
+ {
+ CDataStream ssKey;
+ CDataStream ssValue;
+ int ret = db.ReadAtCursor(pcursor, ssKey, ssValue, DB_NEXT);
+ if (ret == DB_NOTFOUND)
+ {
+ pcursor->close();
+ break;
+ }
+ else if (ret != 0)
+ {
+ pcursor->close();
+ fSuccess = false;
+ break;
+ }
+ if (pszSkip &&
+ strncmp(&ssKey[0], pszSkip, std::min(ssKey.size(), strlen(pszSkip))) == 0)
+ continue;
+ if (strncmp(&ssKey[0], "\x07version", 8) == 0)
+ {
+ // Update version:
+ ssValue.clear();
+ ssValue << VERSION;
+ }
+ Dbt datKey(&ssKey[0], ssKey.size());
+ Dbt datValue(&ssValue[0], ssValue.size());
+ int ret2 = pdbCopy->put(NULL, &datKey, &datValue, DB_NOOVERWRITE);
+ if (ret2 > 0)
+ fSuccess = false;
+ }
+ if (fSuccess)
+ {
+ db.Close();
+ CloseDb(strFile);
+ if (pdbCopy->close(0))
+ fSuccess = false;
+ delete pdbCopy;
+ }
+ }
+ if (fSuccess)
+ {
+ Db dbA(&dbenv, 0);
+ if (dbA.remove(strFile.c_str(), NULL, 0))
+ fSuccess = false;
+ Db dbB(&dbenv, 0);
+ if (dbB.rename(strFileRes.c_str(), NULL, strFile.c_str(), 0))
+ fSuccess = false;
+ }
+ if (!fSuccess)
+ printf("Rewriting of %s FAILED!\n", strFileRes.c_str());
+ return fSuccess;
+ }
+ }
+ Sleep(100);
+ }
+ return false;
+}
+
+
+void DBFlush(bool fShutdown)
+{
+ // Flush log data to the actual data file
+ // on all files that are not in use
+ printf("DBFlush(%s)%s\n", fShutdown ? "true" : "false", fDbEnvInit ? "" : " db not started");
+ if (!fDbEnvInit)
+ return;
+ CRITICAL_BLOCK(cs_db)
+ {
+ map<string, int>::iterator mi = mapFileUseCount.begin();
+ while (mi != mapFileUseCount.end())
+ {
+ string strFile = (*mi).first;
+ int nRefCount = (*mi).second;
+ printf("%s refcount=%d\n", strFile.c_str(), nRefCount);
+ if (nRefCount == 0)
+ {
+ // Move log data to the dat file
+ CloseDb(strFile);
+ dbenv.txn_checkpoint(0, 0, 0);
+ printf("%s flush\n", strFile.c_str());
+ dbenv.lsn_reset(strFile.c_str(), 0);
+ mapFileUseCount.erase(mi++);
+ }
+ else
+ mi++;
+ }
+ if (fShutdown)
+ {
+ char** listp;
+ if (mapFileUseCount.empty())
+ {
+ dbenv.log_archive(&listp, DB_ARCH_REMOVE);
+ EnvShutdown();
+ }
+ }
+ }
+}
+
+
+
+
+
+
+//
+// CTxDB
+//
+
+bool CTxDB::ReadTxIndex(uint256 hash, CTxIndex& txindex)
+{
+ assert(!fClient);
+ txindex.SetNull();
+ return Read(make_pair(string("tx"), hash), txindex);
+}
+
+bool CTxDB::UpdateTxIndex(uint256 hash, const CTxIndex& txindex)
+{
+ assert(!fClient);
+ return Write(make_pair(string("tx"), hash), txindex);
+}
+
+bool CTxDB::AddTxIndex(const CTransaction& tx, const CDiskTxPos& pos, int nHeight)
+{
+ assert(!fClient);
+
+ // Add to tx index
+ uint256 hash = tx.GetHash();
+ CTxIndex txindex(pos, tx.vout.size());
+ return Write(make_pair(string("tx"), hash), txindex);
+}
+
+bool CTxDB::EraseTxIndex(const CTransaction& tx)
+{
+ assert(!fClient);
+ uint256 hash = tx.GetHash();
+
+ return Erase(make_pair(string("tx"), hash));
+}
+
+bool CTxDB::ContainsTx(uint256 hash)
+{
+ assert(!fClient);
+ return Exists(make_pair(string("tx"), hash));
+}
+
+bool CTxDB::ReadOwnerTxes(uint160 hash160, int nMinHeight, vector<CTransaction>& vtx)
+{
+ assert(!fClient);
+ vtx.clear();
+
+ // Get cursor
+ Dbc* pcursor = GetCursor();
+ if (!pcursor)
+ return false;
+
+ unsigned int fFlags = DB_SET_RANGE;
+ loop
+ {
+ // Read next record
+ CDataStream ssKey;
+ if (fFlags == DB_SET_RANGE)
+ ssKey << string("owner") << hash160 << CDiskTxPos(0, 0, 0);
+ CDataStream ssValue;
+ int ret = ReadAtCursor(pcursor, ssKey, ssValue, fFlags);
+ fFlags = DB_NEXT;
+ if (ret == DB_NOTFOUND)
+ break;
+ else if (ret != 0)
+ {
+ pcursor->close();
+ return false;
+ }
+
+ // Unserialize
+ string strType;
+ uint160 hashItem;
+ CDiskTxPos pos;
+ ssKey >> strType >> hashItem >> pos;
+ int nItemHeight;
+ ssValue >> nItemHeight;
+
+ // Read transaction
+ if (strType != "owner" || hashItem != hash160)
+ break;
+ if (nItemHeight >= nMinHeight)
+ {
+ vtx.resize(vtx.size()+1);
+ if (!vtx.back().ReadFromDisk(pos))
+ {
+ pcursor->close();
+ return false;
+ }
+ }
+ }
+
+ pcursor->close();
+ return true;
+}
+
+bool CTxDB::ReadDiskTx(uint256 hash, CTransaction& tx, CTxIndex& txindex)
+{
+ assert(!fClient);
+ tx.SetNull();
+ if (!ReadTxIndex(hash, txindex))
+ return false;
+ return (tx.ReadFromDisk(txindex.pos));
+}
+
+bool CTxDB::ReadDiskTx(uint256 hash, CTransaction& tx)
+{
+ CTxIndex txindex;
+ return ReadDiskTx(hash, tx, txindex);
+}
+
+bool CTxDB::ReadDiskTx(COutPoint outpoint, CTransaction& tx, CTxIndex& txindex)
+{
+ return ReadDiskTx(outpoint.hash, tx, txindex);
+}
+
+bool CTxDB::ReadDiskTx(COutPoint outpoint, CTransaction& tx)
+{
+ CTxIndex txindex;
+ return ReadDiskTx(outpoint.hash, tx, txindex);
+}
+
+bool CTxDB::WriteBlockIndex(const CDiskBlockIndex& blockindex)
+{
+ return Write(make_pair(string("blockindex"), blockindex.GetBlockHash()), blockindex);
+}
+
+bool CTxDB::EraseBlockIndex(uint256 hash)
+{
+ return Erase(make_pair(string("blockindex"), hash));
+}
+
+bool CTxDB::ReadHashBestChain(uint256& hashBestChain)
+{
+ return Read(string("hashBestChain"), hashBestChain);
+}
+
+bool CTxDB::WriteHashBestChain(uint256 hashBestChain)
+{
+ return Write(string("hashBestChain"), hashBestChain);
+}
+
+bool CTxDB::ReadBestInvalidWork(CBigNum& bnBestInvalidWork)
+{
+ return Read(string("bnBestInvalidWork"), bnBestInvalidWork);
+}
+
+bool CTxDB::WriteBestInvalidWork(CBigNum bnBestInvalidWork)
+{
+ return Write(string("bnBestInvalidWork"), bnBestInvalidWork);
+}
+
+CBlockIndex static * InsertBlockIndex(uint256 hash)
+{
+ if (hash == 0)
+ return NULL;
+
+ // Return existing
+ map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
+ if (mi != mapBlockIndex.end())
+ return (*mi).second;
+
+ // Create new
+ CBlockIndex* pindexNew = new CBlockIndex();
+ if (!pindexNew)
+ throw runtime_error("LoadBlockIndex() : new CBlockIndex failed");
+ mi = mapBlockIndex.insert(make_pair(hash, pindexNew)).first;
+ pindexNew->phashBlock = &((*mi).first);
+
+ return pindexNew;
+}
+
+bool CTxDB::LoadBlockIndex()
+{
+ // Get database cursor
+ Dbc* pcursor = GetCursor();
+ if (!pcursor)
+ return false;
+
+ // Load mapBlockIndex
+ unsigned int fFlags = DB_SET_RANGE;
+ loop
+ {
+ // Read next record
+ CDataStream ssKey;
+ if (fFlags == DB_SET_RANGE)
+ ssKey << make_pair(string("blockindex"), uint256(0));
+ CDataStream ssValue;
+ int ret = ReadAtCursor(pcursor, ssKey, ssValue, fFlags);
+ fFlags = DB_NEXT;
+ if (ret == DB_NOTFOUND)
+ break;
+ else if (ret != 0)
+ return false;
+
+ // Unserialize
+ string strType;
+ ssKey >> strType;
+ if (strType == "blockindex")
+ {
+ CDiskBlockIndex diskindex;
+ ssValue >> diskindex;
+
+ // Construct block index object
+ CBlockIndex* pindexNew = InsertBlockIndex(diskindex.GetBlockHash());
+ pindexNew->pprev = InsertBlockIndex(diskindex.hashPrev);
+ pindexNew->pnext = InsertBlockIndex(diskindex.hashNext);
+ pindexNew->nFile = diskindex.nFile;
+ pindexNew->nBlockPos = diskindex.nBlockPos;
+ pindexNew->nHeight = diskindex.nHeight;
+ pindexNew->nVersion = diskindex.nVersion;
+ pindexNew->hashMerkleRoot = diskindex.hashMerkleRoot;
+ pindexNew->nTime = diskindex.nTime;
+ pindexNew->nBits = diskindex.nBits;
+ pindexNew->nNonce = diskindex.nNonce;
+
+ // Watch for genesis block
+ if (pindexGenesisBlock == NULL && diskindex.GetBlockHash() == hashGenesisBlock)
+ pindexGenesisBlock = pindexNew;
+
+ if (!pindexNew->CheckIndex())
+ return error("LoadBlockIndex() : CheckIndex failed at %d", pindexNew->nHeight);
+ }
+ else
+ {
+ break;
+ }
+ }
+ pcursor->close();
+
+ // Calculate bnChainWork
+ vector<pair<int, CBlockIndex*> > vSortedByHeight;
+ vSortedByHeight.reserve(mapBlockIndex.size());
+ BOOST_FOREACH(const PAIRTYPE(uint256, CBlockIndex*)& item, mapBlockIndex)
+ {
+ CBlockIndex* pindex = item.second;
+ vSortedByHeight.push_back(make_pair(pindex->nHeight, pindex));
+ }
+ sort(vSortedByHeight.begin(), vSortedByHeight.end());
+ BOOST_FOREACH(const PAIRTYPE(int, CBlockIndex*)& item, vSortedByHeight)
+ {
+ CBlockIndex* pindex = item.second;
+ pindex->bnChainWork = (pindex->pprev ? pindex->pprev->bnChainWork : 0) + pindex->GetBlockWork();
+ }
+
+ // Load hashBestChain pointer to end of best chain
+ if (!ReadHashBestChain(hashBestChain))
+ {
+ if (pindexGenesisBlock == NULL)
+ return true;
+ return error("CTxDB::LoadBlockIndex() : hashBestChain not loaded");
+ }
+ if (!mapBlockIndex.count(hashBestChain))
+ return error("CTxDB::LoadBlockIndex() : hashBestChain not found in the block index");
+ pindexBest = mapBlockIndex[hashBestChain];
+ nBestHeight = pindexBest->nHeight;
+ bnBestChainWork = pindexBest->bnChainWork;
+ printf("LoadBlockIndex(): hashBestChain=%s height=%d\n", hashBestChain.ToString().substr(0,20).c_str(), nBestHeight);
+
+ // Load bnBestInvalidWork, OK if it doesn't exist
+ ReadBestInvalidWork(bnBestInvalidWork);
+
+ // Verify blocks in the best chain
+ CBlockIndex* pindexFork = NULL;
+ for (CBlockIndex* pindex = pindexBest; pindex && pindex->pprev; pindex = pindex->pprev)
+ {
+ if (pindex->nHeight < nBestHeight-2500 && !mapArgs.count("-checkblocks"))
+ break;
+ CBlock block;
+ if (!block.ReadFromDisk(pindex))
+ return error("LoadBlockIndex() : block.ReadFromDisk failed");
+ if (!block.CheckBlock())
+ {
+ printf("LoadBlockIndex() : *** found bad block at %d, hash=%s\n", pindex->nHeight, pindex->GetBlockHash().ToString().c_str());
+ pindexFork = pindex->pprev;
+ }
+ }
+ if (pindexFork)
+ {
+ // Reorg back to the fork
+ printf("LoadBlockIndex() : *** moving best chain pointer back to block %d\n", pindexFork->nHeight);
+ CBlock block;
+ if (!block.ReadFromDisk(pindexFork))
+ return error("LoadBlockIndex() : block.ReadFromDisk failed");
+ CTxDB txdb;
+ block.SetBestChain(txdb, pindexFork);
+ }
+
+ return true;
+}
+
+
+
+
+
+//
+// CAddrDB
+//
+
+bool CAddrDB::WriteAddress(const CAddress& addr)
+{
+ return Write(make_pair(string("addr"), addr.GetKey()), addr);
+}
+
+bool CAddrDB::EraseAddress(const CAddress& addr)
+{
+ return Erase(make_pair(string("addr"), addr.GetKey()));
+}
+
+bool CAddrDB::LoadAddresses()
+{
+ CRITICAL_BLOCK(cs_mapAddresses)
+ {
+ // Get cursor
+ Dbc* pcursor = GetCursor();
+ if (!pcursor)
+ return false;
+
+ loop
+ {
+ // Read next record
+ CDataStream ssKey;
+ CDataStream ssValue;
+ int ret = ReadAtCursor(pcursor, ssKey, ssValue);
+ if (ret == DB_NOTFOUND)
+ break;
+ else if (ret != 0)
+ return false;
+
+ // Unserialize
+ string strType;
+ ssKey >> strType;
+ if (strType == "addr")
+ {
+ CAddress addr;
+ ssValue >> addr;
+ mapAddresses.insert(make_pair(addr.GetKey(), addr));
+ }
+ }
+ pcursor->close();
+
+ printf("Loaded %d addresses\n", mapAddresses.size());
+ }
+
+ return true;
+}
+
+bool LoadAddresses()
+{
+ return CAddrDB("cr+").LoadAddresses();
+}
+
+
+
+
+//
+// CWalletDB
+//
+
+bool CWalletDB::WriteName(const string& strAddress, const string& strName)
+{
+ nWalletDBUpdated++;
+ return Write(make_pair(string("name"), strAddress), strName);
+}
+
+bool CWalletDB::EraseName(const string& strAddress)
+{
+ // This should only be used for sending addresses, never for receiving addresses,
+ // receiving addresses must always have an address book entry if they're not change return.
+ nWalletDBUpdated++;
+ return Erase(make_pair(string("name"), strAddress));
+}
+
+bool CWalletDB::ReadAccount(const string& strAccount, CAccount& account)
+{
+ account.SetNull();
+ return Read(make_pair(string("acc"), strAccount), account);
+}
+
+bool CWalletDB::WriteAccount(const string& strAccount, const CAccount& account)
+{
+ return Write(make_pair(string("acc"), strAccount), account);
+}
+
+bool CWalletDB::WriteAccountingEntry(const CAccountingEntry& acentry)
+{
+ return Write(boost::make_tuple(string("acentry"), acentry.strAccount, ++nAccountingEntryNumber), acentry);
+}
+
+int64 CWalletDB::GetAccountCreditDebit(const string& strAccount)
+{
+ list<CAccountingEntry> entries;
+ ListAccountCreditDebit(strAccount, entries);
+
+ int64 nCreditDebit = 0;
+ BOOST_FOREACH (const CAccountingEntry& entry, entries)
+ nCreditDebit += entry.nCreditDebit;
+
+ return nCreditDebit;
+}
+
+void CWalletDB::ListAccountCreditDebit(const string& strAccount, list<CAccountingEntry>& entries)
+{
+ bool fAllAccounts = (strAccount == "*");
+
+ Dbc* pcursor = GetCursor();
+ if (!pcursor)
+ throw runtime_error("CWalletDB::ListAccountCreditDebit() : cannot create DB cursor");
+ unsigned int fFlags = DB_SET_RANGE;
+ loop
+ {
+ // Read next record
+ CDataStream ssKey;
+ if (fFlags == DB_SET_RANGE)
+ ssKey << boost::make_tuple(string("acentry"), (fAllAccounts? string("") : strAccount), uint64(0));
+ CDataStream ssValue;
+ int ret = ReadAtCursor(pcursor, ssKey, ssValue, fFlags);
+ fFlags = DB_NEXT;
+ if (ret == DB_NOTFOUND)
+ break;
+ else if (ret != 0)
+ {
+ pcursor->close();
+ throw runtime_error("CWalletDB::ListAccountCreditDebit() : error scanning DB");
+ }
+
+ // Unserialize
+ string strType;
+ ssKey >> strType;
+ if (strType != "acentry")
+ break;
+ CAccountingEntry acentry;
+ ssKey >> acentry.strAccount;
+ if (!fAllAccounts && acentry.strAccount != strAccount)
+ break;
+
+ ssValue >> acentry;
+ entries.push_back(acentry);
+ }
+
+ pcursor->close();
+}
+
+
+int CWalletDB::LoadWallet(CWallet* pwallet)
+{
+ pwallet->vchDefaultKey.clear();
+ int nFileVersion = 0;
+ vector<uint256> vWalletUpgrade;
+ bool fIsEncrypted = false;
+
+ // Modify defaults
+#ifndef WIN32
+ // Tray icon sometimes disappears on 9.10 karmic koala 64-bit, leaving no way to access the program
+ fMinimizeToTray = false;
+ fMinimizeOnClose = false;
+#endif
+
+ //// todo: shouldn't we catch exceptions and try to recover and continue?
+ CRITICAL_BLOCK(pwallet->cs_wallet)
+ {
+ // Get cursor
+ Dbc* pcursor = GetCursor();
+ if (!pcursor)
+ return DB_CORRUPT;
+
+ loop
+ {
+ // Read next record
+ CDataStream ssKey;
+ CDataStream ssValue;
+ int ret = ReadAtCursor(pcursor, ssKey, ssValue);
+ if (ret == DB_NOTFOUND)
+ break;
+ else if (ret != 0)
+ return DB_CORRUPT;
+
+ // Unserialize
+ // Taking advantage of the fact that pair serialization
+ // is just the two items serialized one after the other
+ string strType;
+ ssKey >> strType;
+ if (strType == "name")
+ {
+ string strAddress;
+ ssKey >> strAddress;
+ ssValue >> pwallet->mapAddressBook[strAddress];
+ }
+ else if (strType == "tx")
+ {
+ uint256 hash;
+ ssKey >> hash;
+ CWalletTx& wtx = pwallet->mapWallet[hash];
+ ssValue >> wtx;
+ wtx.pwallet = pwallet;
+
+ if (wtx.GetHash() != hash)
+ printf("Error in wallet.dat, hash mismatch\n");
+
+ // Undo serialize changes in 31600
+ if (31404 <= wtx.fTimeReceivedIsTxTime && wtx.fTimeReceivedIsTxTime <= 31703)
+ {
+ if (!ssValue.empty())
+ {
+ char fTmp;
+ char fUnused;
+ ssValue >> fTmp >> fUnused >> wtx.strFromAccount;
+ printf("LoadWallet() upgrading tx ver=%d %d '%s' %s\n", wtx.fTimeReceivedIsTxTime, fTmp, wtx.strFromAccount.c_str(), hash.ToString().c_str());
+ wtx.fTimeReceivedIsTxTime = fTmp;
+ }
+ else
+ {
+ printf("LoadWallet() repairing tx ver=%d %s\n", wtx.fTimeReceivedIsTxTime, hash.ToString().c_str());
+ wtx.fTimeReceivedIsTxTime = 0;
+ }
+ vWalletUpgrade.push_back(hash);
+ }
+
+ //// debug print
+ //printf("LoadWallet %s\n", wtx.GetHash().ToString().c_str());
+ //printf(" %12I64d %s %s %s\n",
+ // wtx.vout[0].nValue,
+ // DateTimeStrFormat("%x %H:%M:%S", wtx.GetBlockTime()).c_str(),
+ // wtx.hashBlock.ToString().substr(0,20).c_str(),
+ // wtx.mapValue["message"].c_str());
+ }
+ else if (strType == "acentry")
+ {
+ string strAccount;
+ ssKey >> strAccount;
+ uint64 nNumber;
+ ssKey >> nNumber;
+ if (nNumber > nAccountingEntryNumber)
+ nAccountingEntryNumber = nNumber;
+ }
+ else if (strType == "key" || strType == "wkey")
+ {
+ vector<unsigned char> vchPubKey;
+ ssKey >> vchPubKey;
+ CKey key;
+ if (strType == "key")
+ {
+ CPrivKey pkey;
+ ssValue >> pkey;
+ key.SetPrivKey(pkey);
+ if (key.GetPubKey() != vchPubKey || !key.IsValid())
+ return DB_CORRUPT;
+ }
+ else
+ {
+ CWalletKey wkey;
+ ssValue >> wkey;
+ key.SetPrivKey(wkey.vchPrivKey);
+ if (key.GetPubKey() != vchPubKey || !key.IsValid())
+ return DB_CORRUPT;
+ }
+ if (!pwallet->LoadKey(key))
+ return DB_CORRUPT;
+ }
+ else if (strType == "mkey")
+ {
+ unsigned int nID;
+ ssKey >> nID;
+ CMasterKey kMasterKey;
+ ssValue >> kMasterKey;
+ if(pwallet->mapMasterKeys.count(nID) != 0)
+ return DB_CORRUPT;
+ pwallet->mapMasterKeys[nID] = kMasterKey;
+ if (pwallet->nMasterKeyMaxID < nID)
+ pwallet->nMasterKeyMaxID = nID;
+ }
+ else if (strType == "ckey")
+ {
+ vector<unsigned char> vchPubKey;
+ ssKey >> vchPubKey;
+ vector<unsigned char> vchPrivKey;
+ ssValue >> vchPrivKey;
+ if (!pwallet->LoadCryptedKey(vchPubKey, vchPrivKey))
+ return DB_CORRUPT;
+ fIsEncrypted = true;
+ }
+ else if (strType == "defaultkey")
+ {
+ ssValue >> pwallet->vchDefaultKey;
+ }
+ else if (strType == "pool")
+ {
+ int64 nIndex;
+ ssKey >> nIndex;
+ pwallet->setKeyPool.insert(nIndex);
+ }
+ else if (strType == "version")
+ {
+ ssValue >> nFileVersion;
+ if (nFileVersion == 10300)
+ nFileVersion = 300;
+ }
+ else if (strType == "setting")
+ {
+ string strKey;
+ ssKey >> strKey;
+
+ // Options
+#ifndef QT_GUI
+ if (strKey == "fGenerateBitcoins") ssValue >> fGenerateBitcoins;
+#endif
+ if (strKey == "nTransactionFee") ssValue >> nTransactionFee;
+ if (strKey == "fLimitProcessors") ssValue >> fLimitProcessors;
+ if (strKey == "nLimitProcessors") ssValue >> nLimitProcessors;
+ if (strKey == "fMinimizeToTray") ssValue >> fMinimizeToTray;
+ if (strKey == "fMinimizeOnClose") ssValue >> fMinimizeOnClose;
+ if (strKey == "fUseProxy") ssValue >> fUseProxy;
+ if (strKey == "addrProxy") ssValue >> addrProxy;
+ if (fHaveUPnP && strKey == "fUseUPnP") ssValue >> fUseUPnP;
+ }
+ else if (strType == "minversion")
+ {
+ int nMinVersion = 0;
+ ssValue >> nMinVersion;
+ if (nMinVersion > VERSION)
+ return DB_TOO_NEW;
+ }
+ }
+ pcursor->close();
+ }
+
+ BOOST_FOREACH(uint256 hash, vWalletUpgrade)
+ WriteTx(hash, pwallet->mapWallet[hash]);
+
+ printf("nFileVersion = %d\n", nFileVersion);
+ printf("fGenerateBitcoins = %d\n", fGenerateBitcoins);
+ printf("nTransactionFee = %"PRI64d"\n", nTransactionFee);
+ printf("fMinimizeToTray = %d\n", fMinimizeToTray);
+ printf("fMinimizeOnClose = %d\n", fMinimizeOnClose);
+ printf("fUseProxy = %d\n", fUseProxy);
+ printf("addrProxy = %s\n", addrProxy.ToString().c_str());
+ if (fHaveUPnP)
+ printf("fUseUPnP = %d\n", fUseUPnP);
+
+
+ // Rewrite encrypted wallets of versions 0.4.0 and 0.5.0rc:
+ if (fIsEncrypted && (nFileVersion == 40000 || nFileVersion == 50000))
+ return DB_NEED_REWRITE;
+
+ if (nFileVersion < VERSION) // Update
+ {
+ // Get rid of old debug.log file in current directory
+ if (nFileVersion <= 105 && !pszSetDataDir[0])
+ unlink("debug.log");
+
+ WriteVersion(VERSION);
+ }
+
+ return DB_LOAD_OK;
+}
+
+void ThreadFlushWalletDB(void* parg)
+{
+ const string& strFile = ((const string*)parg)[0];
+ static bool fOneThread;
+ if (fOneThread)
+ return;
+ fOneThread = true;
+ if (mapArgs.count("-noflushwallet"))
+ return;
+
+ unsigned int nLastSeen = nWalletDBUpdated;
+ unsigned int nLastFlushed = nWalletDBUpdated;
+ int64 nLastWalletUpdate = GetTime();
+ while (!fShutdown)
+ {
+ Sleep(500);
+
+ if (nLastSeen != nWalletDBUpdated)
+ {
+ nLastSeen = nWalletDBUpdated;
+ nLastWalletUpdate = GetTime();
+ }
+
+ if (nLastFlushed != nWalletDBUpdated && GetTime() - nLastWalletUpdate >= 2)
+ {
+ TRY_CRITICAL_BLOCK(cs_db)
+ {
+ // Don't do this if any databases are in use
+ int nRefCount = 0;
+ map<string, int>::iterator mi = mapFileUseCount.begin();
+ while (mi != mapFileUseCount.end())
+ {
+ nRefCount += (*mi).second;
+ mi++;
+ }
+
+ if (nRefCount == 0 && !fShutdown)
+ {
+ map<string, int>::iterator mi = mapFileUseCount.find(strFile);
+ if (mi != mapFileUseCount.end())
+ {
+ printf("%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
+ printf("Flushing wallet.dat\n");
+ nLastFlushed = nWalletDBUpdated;
+ int64 nStart = GetTimeMillis();
+
+ // Flush wallet.dat so it's self contained
+ CloseDb(strFile);
+ dbenv.txn_checkpoint(0, 0, 0);
+ dbenv.lsn_reset(strFile.c_str(), 0);
+
+ mapFileUseCount.erase(mi++);
+ printf("Flushed wallet.dat %"PRI64d"ms\n", GetTimeMillis() - nStart);
+ }
+ }
+ }
+ }
+ }
+}
+
+bool BackupWallet(const CWallet& wallet, const string& strDest)
+{
+ if (!wallet.fFileBacked)
+ return false;
+ while (!fShutdown)
+ {
+ CRITICAL_BLOCK(cs_db)
+ {
+ if (!mapFileUseCount.count(wallet.strWalletFile) || mapFileUseCount[wallet.strWalletFile] == 0)
+ {
+ // Flush log data to the dat file
+ CloseDb(wallet.strWalletFile);
+ dbenv.txn_checkpoint(0, 0, 0);
+ dbenv.lsn_reset(wallet.strWalletFile.c_str(), 0);
+ mapFileUseCount.erase(wallet.strWalletFile);
+
+ // Copy wallet.dat
+ filesystem::path pathSrc(GetDataDir() + "/" + wallet.strWalletFile);
+ filesystem::path pathDest(strDest);
+ if (filesystem::is_directory(pathDest))
+ pathDest = pathDest / wallet.strWalletFile;
+#if BOOST_VERSION >= 104000
+ filesystem::copy_file(pathSrc, pathDest, filesystem::copy_option::overwrite_if_exists);
+#else
+ filesystem::copy_file(pathSrc, pathDest);
+#endif
+ printf("copied wallet.dat to %s\n", pathDest.string().c_str());
+
+ return true;
+ }
+ }
+ Sleep(100);
+ }
+ return false;
+}
diff --git a/bitcoin/src/db.h b/bitcoin/src/db.h
@@ -0,0 +1,485 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2011 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#ifndef BITCOIN_DB_H
+#define BITCOIN_DB_H
+
+#include "key.h"
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include <db_cxx.h>
+
+class CTxIndex;
+class CDiskBlockIndex;
+class CDiskTxPos;
+class COutPoint;
+class CAddress;
+class CWalletTx;
+class CWallet;
+class CAccount;
+class CAccountingEntry;
+class CBlockLocator;
+
+
+extern unsigned int nWalletDBUpdated;
+extern DbEnv dbenv;
+
+extern void DBFlush(bool fShutdown);
+void ThreadFlushWalletDB(void* parg);
+bool BackupWallet(const CWallet& wallet, const std::string& strDest);
+
+
+
+class CDB
+{
+protected:
+ Db* pdb;
+ std::string strFile;
+ std::vector<DbTxn*> vTxn;
+ bool fReadOnly;
+
+ explicit CDB(const char* pszFile, const char* pszMode="r+");
+ ~CDB() { Close(); }
+public:
+ void Close();
+private:
+ CDB(const CDB&);
+ void operator=(const CDB&);
+
+protected:
+ template<typename K, typename T>
+ bool Read(const K& key, T& value)
+ {
+ if (!pdb)
+ return false;
+
+ // Key
+ CDataStream ssKey(SER_DISK);
+ ssKey.reserve(1000);
+ ssKey << key;
+ Dbt datKey(&ssKey[0], ssKey.size());
+
+ // Read
+ Dbt datValue;
+ datValue.set_flags(DB_DBT_MALLOC);
+ int ret = pdb->get(GetTxn(), &datKey, &datValue, 0);
+ memset(datKey.get_data(), 0, datKey.get_size());
+ if (datValue.get_data() == NULL)
+ return false;
+
+ // Unserialize value
+ CDataStream ssValue((char*)datValue.get_data(), (char*)datValue.get_data() + datValue.get_size(), SER_DISK);
+ ssValue >> value;
+
+ // Clear and free memory
+ memset(datValue.get_data(), 0, datValue.get_size());
+ free(datValue.get_data());
+ return (ret == 0);
+ }
+
+ template<typename K, typename T>
+ bool Write(const K& key, const T& value, bool fOverwrite=true)
+ {
+ if (!pdb)
+ return false;
+ if (fReadOnly)
+ assert(!"Write called on database in read-only mode");
+
+ // Key
+ CDataStream ssKey(SER_DISK);
+ ssKey.reserve(1000);
+ ssKey << key;
+ Dbt datKey(&ssKey[0], ssKey.size());
+
+ // Value
+ CDataStream ssValue(SER_DISK);
+ ssValue.reserve(10000);
+ ssValue << value;
+ Dbt datValue(&ssValue[0], ssValue.size());
+
+ // Write
+ int ret = pdb->put(GetTxn(), &datKey, &datValue, (fOverwrite ? 0 : DB_NOOVERWRITE));
+
+ // Clear memory in case it was a private key
+ memset(datKey.get_data(), 0, datKey.get_size());
+ memset(datValue.get_data(), 0, datValue.get_size());
+ return (ret == 0);
+ }
+
+ template<typename K>
+ bool Erase(const K& key)
+ {
+ if (!pdb)
+ return false;
+ if (fReadOnly)
+ assert(!"Erase called on database in read-only mode");
+
+ // Key
+ CDataStream ssKey(SER_DISK);
+ ssKey.reserve(1000);
+ ssKey << key;
+ Dbt datKey(&ssKey[0], ssKey.size());
+
+ // Erase
+ int ret = pdb->del(GetTxn(), &datKey, 0);
+
+ // Clear memory
+ memset(datKey.get_data(), 0, datKey.get_size());
+ return (ret == 0 || ret == DB_NOTFOUND);
+ }
+
+ template<typename K>
+ bool Exists(const K& key)
+ {
+ if (!pdb)
+ return false;
+
+ // Key
+ CDataStream ssKey(SER_DISK);
+ ssKey.reserve(1000);
+ ssKey << key;
+ Dbt datKey(&ssKey[0], ssKey.size());
+
+ // Exists
+ int ret = pdb->exists(GetTxn(), &datKey, 0);
+
+ // Clear memory
+ memset(datKey.get_data(), 0, datKey.get_size());
+ return (ret == 0);
+ }
+
+ Dbc* GetCursor()
+ {
+ if (!pdb)
+ return NULL;
+ Dbc* pcursor = NULL;
+ int ret = pdb->cursor(NULL, &pcursor, 0);
+ if (ret != 0)
+ return NULL;
+ return pcursor;
+ }
+
+ int ReadAtCursor(Dbc* pcursor, CDataStream& ssKey, CDataStream& ssValue, unsigned int fFlags=DB_NEXT)
+ {
+ // Read at cursor
+ Dbt datKey;
+ if (fFlags == DB_SET || fFlags == DB_SET_RANGE || fFlags == DB_GET_BOTH || fFlags == DB_GET_BOTH_RANGE)
+ {
+ datKey.set_data(&ssKey[0]);
+ datKey.set_size(ssKey.size());
+ }
+ Dbt datValue;
+ if (fFlags == DB_GET_BOTH || fFlags == DB_GET_BOTH_RANGE)
+ {
+ datValue.set_data(&ssValue[0]);
+ datValue.set_size(ssValue.size());
+ }
+ datKey.set_flags(DB_DBT_MALLOC);
+ datValue.set_flags(DB_DBT_MALLOC);
+ int ret = pcursor->get(&datKey, &datValue, fFlags);
+ if (ret != 0)
+ return ret;
+ else if (datKey.get_data() == NULL || datValue.get_data() == NULL)
+ return 99999;
+
+ // Convert to streams
+ ssKey.SetType(SER_DISK);
+ ssKey.clear();
+ ssKey.write((char*)datKey.get_data(), datKey.get_size());
+ ssValue.SetType(SER_DISK);
+ ssValue.clear();
+ ssValue.write((char*)datValue.get_data(), datValue.get_size());
+
+ // Clear and free memory
+ memset(datKey.get_data(), 0, datKey.get_size());
+ memset(datValue.get_data(), 0, datValue.get_size());
+ free(datKey.get_data());
+ free(datValue.get_data());
+ return 0;
+ }
+
+ DbTxn* GetTxn()
+ {
+ if (!vTxn.empty())
+ return vTxn.back();
+ else
+ return NULL;
+ }
+
+public:
+ bool TxnBegin()
+ {
+ if (!pdb)
+ return false;
+ DbTxn* ptxn = NULL;
+ int ret = dbenv.txn_begin(GetTxn(), &ptxn, DB_TXN_NOSYNC);
+ if (!ptxn || ret != 0)
+ return false;
+ vTxn.push_back(ptxn);
+ return true;
+ }
+
+ bool TxnCommit()
+ {
+ if (!pdb)
+ return false;
+ if (vTxn.empty())
+ return false;
+ int ret = vTxn.back()->commit(0);
+ vTxn.pop_back();
+ return (ret == 0);
+ }
+
+ bool TxnAbort()
+ {
+ if (!pdb)
+ return false;
+ if (vTxn.empty())
+ return false;
+ int ret = vTxn.back()->abort();
+ vTxn.pop_back();
+ return (ret == 0);
+ }
+
+ bool ReadVersion(int& nVersion)
+ {
+ nVersion = 0;
+ return Read(std::string("version"), nVersion);
+ }
+
+ bool WriteVersion(int nVersion)
+ {
+ return Write(std::string("version"), nVersion);
+ }
+
+ bool static Rewrite(const std::string& strFile, const char* pszSkip = NULL);
+};
+
+
+
+
+
+
+
+
+class CTxDB : public CDB
+{
+public:
+ CTxDB(const char* pszMode="r+") : CDB("blkindex.dat", pszMode) { }
+private:
+ CTxDB(const CTxDB&);
+ void operator=(const CTxDB&);
+public:
+ bool ReadTxIndex(uint256 hash, CTxIndex& txindex);
+ bool UpdateTxIndex(uint256 hash, const CTxIndex& txindex);
+ bool AddTxIndex(const CTransaction& tx, const CDiskTxPos& pos, int nHeight);
+ bool EraseTxIndex(const CTransaction& tx);
+ bool ContainsTx(uint256 hash);
+ bool ReadOwnerTxes(uint160 hash160, int nHeight, std::vector<CTransaction>& vtx);
+ bool ReadDiskTx(uint256 hash, CTransaction& tx, CTxIndex& txindex);
+ bool ReadDiskTx(uint256 hash, CTransaction& tx);
+ bool ReadDiskTx(COutPoint outpoint, CTransaction& tx, CTxIndex& txindex);
+ bool ReadDiskTx(COutPoint outpoint, CTransaction& tx);
+ bool WriteBlockIndex(const CDiskBlockIndex& blockindex);
+ bool EraseBlockIndex(uint256 hash);
+ bool ReadHashBestChain(uint256& hashBestChain);
+ bool WriteHashBestChain(uint256 hashBestChain);
+ bool ReadBestInvalidWork(CBigNum& bnBestInvalidWork);
+ bool WriteBestInvalidWork(CBigNum bnBestInvalidWork);
+ bool LoadBlockIndex();
+};
+
+
+
+
+
+class CAddrDB : public CDB
+{
+public:
+ CAddrDB(const char* pszMode="r+") : CDB("addr.dat", pszMode) { }
+private:
+ CAddrDB(const CAddrDB&);
+ void operator=(const CAddrDB&);
+public:
+ bool WriteAddress(const CAddress& addr);
+ bool EraseAddress(const CAddress& addr);
+ bool LoadAddresses();
+};
+
+bool LoadAddresses();
+
+
+
+class CKeyPool
+{
+public:
+ int64 nTime;
+ std::vector<unsigned char> vchPubKey;
+
+ CKeyPool()
+ {
+ nTime = GetTime();
+ }
+
+ CKeyPool(const std::vector<unsigned char>& vchPubKeyIn)
+ {
+ nTime = GetTime();
+ vchPubKey = vchPubKeyIn;
+ }
+
+ IMPLEMENT_SERIALIZE
+ (
+ if (!(nType & SER_GETHASH))
+ READWRITE(nVersion);
+ READWRITE(nTime);
+ READWRITE(vchPubKey);
+ )
+};
+
+
+
+
+enum DBErrors
+{
+ DB_LOAD_OK,
+ DB_CORRUPT,
+ DB_TOO_NEW,
+ DB_LOAD_FAIL,
+ DB_NEED_REWRITE
+};
+
+class CWalletDB : public CDB
+{
+public:
+ CWalletDB(std::string strFilename, const char* pszMode="r+") : CDB(strFilename.c_str(), pszMode)
+ {
+ }
+private:
+ CWalletDB(const CWalletDB&);
+ void operator=(const CWalletDB&);
+public:
+ bool ReadName(const std::string& strAddress, std::string& strName)
+ {
+ strName = "";
+ return Read(std::make_pair(std::string("name"), strAddress), strName);
+ }
+
+ bool WriteName(const std::string& strAddress, const std::string& strName);
+
+ bool EraseName(const std::string& strAddress);
+
+ bool ReadTx(uint256 hash, CWalletTx& wtx)
+ {
+ return Read(std::make_pair(std::string("tx"), hash), wtx);
+ }
+
+ bool WriteTx(uint256 hash, const CWalletTx& wtx)
+ {
+ nWalletDBUpdated++;
+ return Write(std::make_pair(std::string("tx"), hash), wtx);
+ }
+
+ bool EraseTx(uint256 hash)
+ {
+ nWalletDBUpdated++;
+ return Erase(std::make_pair(std::string("tx"), hash));
+ }
+
+ bool ReadKey(const std::vector<unsigned char>& vchPubKey, CPrivKey& vchPrivKey)
+ {
+ vchPrivKey.clear();
+ return Read(std::make_pair(std::string("key"), vchPubKey), vchPrivKey);
+ }
+
+ bool WriteKey(const std::vector<unsigned char>& vchPubKey, const CPrivKey& vchPrivKey)
+ {
+ nWalletDBUpdated++;
+ return Write(std::make_pair(std::string("key"), vchPubKey), vchPrivKey, false);
+ }
+
+ bool WriteCryptedKey(const std::vector<unsigned char>& vchPubKey, const std::vector<unsigned char>& vchCryptedSecret, bool fEraseUnencryptedKey = true)
+ {
+ nWalletDBUpdated++;
+ if (!Write(std::make_pair(std::string("ckey"), vchPubKey), vchCryptedSecret, false))
+ return false;
+ if (fEraseUnencryptedKey)
+ {
+ Erase(std::make_pair(std::string("key"), vchPubKey));
+ Erase(std::make_pair(std::string("wkey"), vchPubKey));
+ }
+ return true;
+ }
+
+ bool WriteMasterKey(unsigned int nID, const CMasterKey& kMasterKey)
+ {
+ nWalletDBUpdated++;
+ return Write(std::make_pair(std::string("mkey"), nID), kMasterKey, true);
+ }
+
+ bool WriteBestBlock(const CBlockLocator& locator)
+ {
+ nWalletDBUpdated++;
+ return Write(std::string("bestblock"), locator);
+ }
+
+ bool ReadBestBlock(CBlockLocator& locator)
+ {
+ return Read(std::string("bestblock"), locator);
+ }
+
+ bool ReadDefaultKey(std::vector<unsigned char>& vchPubKey)
+ {
+ vchPubKey.clear();
+ return Read(std::string("defaultkey"), vchPubKey);
+ }
+
+ bool WriteDefaultKey(const std::vector<unsigned char>& vchPubKey)
+ {
+ nWalletDBUpdated++;
+ return Write(std::string("defaultkey"), vchPubKey);
+ }
+
+ bool ReadPool(int64 nPool, CKeyPool& keypool)
+ {
+ return Read(std::make_pair(std::string("pool"), nPool), keypool);
+ }
+
+ bool WritePool(int64 nPool, const CKeyPool& keypool)
+ {
+ nWalletDBUpdated++;
+ return Write(std::make_pair(std::string("pool"), nPool), keypool);
+ }
+
+ bool ErasePool(int64 nPool)
+ {
+ nWalletDBUpdated++;
+ return Erase(std::make_pair(std::string("pool"), nPool));
+ }
+
+ template<typename T>
+ bool ReadSetting(const std::string& strKey, T& value)
+ {
+ return Read(std::make_pair(std::string("setting"), strKey), value);
+ }
+
+ template<typename T>
+ bool WriteSetting(const std::string& strKey, const T& value)
+ {
+ nWalletDBUpdated++;
+ return Write(std::make_pair(std::string("setting"), strKey), value);
+ }
+
+ bool ReadAccount(const std::string& strAccount, CAccount& account);
+ bool WriteAccount(const std::string& strAccount, const CAccount& account);
+ bool WriteAccountingEntry(const CAccountingEntry& acentry);
+ int64 GetAccountCreditDebit(const std::string& strAccount);
+ void ListAccountCreditDebit(const std::string& strAccount, std::list<CAccountingEntry>& acentries);
+
+ int LoadWallet(CWallet* pwallet);
+};
+
+#endif
diff --git a/bitcoin/src/headers.h b/bitcoin/src/headers.h
@@ -0,0 +1,96 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2012 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+#ifdef _MSC_VER
+#pragma warning(disable:4786)
+#pragma warning(disable:4804)
+#pragma warning(disable:4805)
+#pragma warning(disable:4717)
+#endif
+#ifdef _WIN32_WINNT
+#undef _WIN32_WINNT
+#endif
+#define _WIN32_WINNT 0x0500
+#ifdef _WIN32_IE
+#undef _WIN32_IE
+#endif
+#define _WIN32_IE 0x0400
+#define WIN32_LEAN_AND_MEAN 1
+
+// Include boost/foreach here as it defines __STDC_LIMIT_MACROS on some systems.
+#include <boost/foreach.hpp>
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS // to enable UINT64_MAX from stdint.h
+#endif
+
+#if (defined(__unix__) || defined(unix)) && !defined(USG)
+#include <sys/param.h> // to get BSD define
+#endif
+#ifdef MAC_OSX
+#ifndef BSD
+#define BSD 1
+#endif
+#endif
+#include <openssl/buffer.h>
+#include <openssl/ecdsa.h>
+#include <openssl/evp.h>
+#include <openssl/rand.h>
+#include <openssl/sha.h>
+#include <openssl/ripemd.h>
+#include <db_cxx.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <math.h>
+#include <limits.h>
+#include <float.h>
+#include <assert.h>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
+#include <list>
+#include <deque>
+#include <map>
+
+#ifdef WIN32
+#include <windows.h>
+#include <winsock2.h>
+#include <mswsock.h>
+#include <shlobj.h>
+#include <shlwapi.h>
+#include <io.h>
+#include <process.h>
+#include <malloc.h>
+#else
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <errno.h>
+#include <net/if.h>
+#include <ifaddrs.h>
+#include <fcntl.h>
+#include <signal.h>
+#endif
+#ifdef BSD
+#include <netinet/in.h>
+#endif
+
+
+#include "serialize.h"
+#include "uint256.h"
+#include "util.h"
+#include "bignum.h"
+#include "base58.h"
+#include "main.h"
+#ifdef QT_GUI
+#include "qtui.h"
+#else
+#include "noui.h"
+#endif
diff --git a/bitcoin/src/init.cpp b/bitcoin/src/init.cpp
@@ -0,0 +1,550 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2012 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#include "headers.h"
+#include "db.h"
+#include "bitcoinrpc.h"
+#include "net.h"
+#include "init.h"
+#include "strlcpy.h"
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/interprocess/sync/file_lock.hpp>
+
+#if defined(BITCOIN_NEED_QT_PLUGINS) && !defined(_BITCOIN_QT_PLUGINS_INCLUDED)
+#define _BITCOIN_QT_PLUGINS_INCLUDED
+#define __INSURE__
+#include <QtPlugin>
+Q_IMPORT_PLUGIN(qcncodecs)
+Q_IMPORT_PLUGIN(qjpcodecs)
+Q_IMPORT_PLUGIN(qtwcodecs)
+Q_IMPORT_PLUGIN(qkrcodecs)
+Q_IMPORT_PLUGIN(qtaccessiblewidgets)
+#endif
+
+using namespace std;
+using namespace boost;
+
+CWallet* pwalletMain;
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Shutdown
+//
+
+void ExitTimeout(void* parg)
+{
+#ifdef WIN32
+ Sleep(5000);
+ ExitProcess(0);
+#endif
+}
+
+void Shutdown(void* parg)
+{
+ static CCriticalSection cs_Shutdown;
+ static bool fTaken;
+ bool fFirstThread = false;
+ TRY_CRITICAL_BLOCK(cs_Shutdown)
+ {
+ fFirstThread = !fTaken;
+ fTaken = true;
+ }
+ static bool fExit;
+ if (fFirstThread)
+ {
+ fShutdown = true;
+ nTransactionsUpdated++;
+ DBFlush(false);
+ StopNode();
+ DBFlush(true);
+ boost::filesystem::remove(GetPidFile());
+ UnregisterWallet(pwalletMain);
+ delete pwalletMain;
+ CreateThread(ExitTimeout, NULL);
+ Sleep(50);
+ printf("Bitcoin exiting\n\n");
+ fExit = true;
+ exit(0);
+ }
+ else
+ {
+ while (!fExit)
+ Sleep(500);
+ Sleep(100);
+ ExitThread(0);
+ }
+}
+
+void HandleSIGTERM(int)
+{
+ fRequestShutdown = true;
+}
+
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Start
+//
+#if !defined(QT_GUI)
+int main(int argc, char* argv[])
+{
+ bool fRet = false;
+ fRet = AppInit(argc, argv);
+
+ if (fRet && fDaemon)
+ return 0;
+
+ return 1;
+}
+#endif
+
+bool AppInit(int argc, char* argv[])
+{
+ bool fRet = false;
+ try
+ {
+ fRet = AppInit2(argc, argv);
+ }
+ catch (std::exception& e) {
+ PrintException(&e, "AppInit()");
+ } catch (...) {
+ PrintException(NULL, "AppInit()");
+ }
+ if (!fRet)
+ Shutdown(NULL);
+ return fRet;
+}
+
+bool AppInit2(int argc, char* argv[])
+{
+#ifdef _MSC_VER
+ // Turn off microsoft heap dump noise
+ _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
+ _CrtSetReportFile(_CRT_WARN, CreateFileA("NUL", GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0));
+#endif
+#if _MSC_VER >= 1400
+ // Disable confusing "helpful" text message on abort, ctrl-c
+ _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
+#endif
+#ifndef WIN32
+ umask(077);
+#endif
+#ifndef WIN32
+ // Clean shutdown on SIGTERM
+ struct sigaction sa;
+ sa.sa_handler = HandleSIGTERM;
+ sigemptyset(&sa.sa_mask);
+ sa.sa_flags = 0;
+ sigaction(SIGTERM, &sa, NULL);
+ sigaction(SIGINT, &sa, NULL);
+ sigaction(SIGHUP, &sa, NULL);
+#endif
+
+ //
+ // Parameters
+ //
+ ParseParameters(argc, argv);
+
+ if (mapArgs.count("-datadir"))
+ {
+ if (filesystem::is_directory(filesystem::system_complete(mapArgs["-datadir"])))
+ {
+ filesystem::path pathDataDir = filesystem::system_complete(mapArgs["-datadir"]);
+ strlcpy(pszSetDataDir, pathDataDir.string().c_str(), sizeof(pszSetDataDir));
+ }
+ else
+ {
+ fprintf(stderr, "Error: Specified directory does not exist\n");
+ Shutdown(NULL);
+ }
+ }
+
+
+ ReadConfigFile(mapArgs, mapMultiArgs); // Must be done after processing datadir
+
+ if (mapArgs.count("-?") || mapArgs.count("--help"))
+ {
+ string strUsage = string() +
+ _("Bitcoin version") + " " + FormatFullVersion() + "\n\n" +
+ _("Usage:") + "\t\t\t\t\t\t\t\t\t\t\n" +
+ " bitcoind [options] \t " + "\n" +
+ " bitcoind [options] <command> [params]\t " + _("Send command to -server or bitcoind\n") +
+ " bitcoind [options] help \t\t " + _("List commands\n") +
+ " bitcoind [options] help <command> \t\t " + _("Get help for a command\n") +
+ _("Options:\n") +
+ " -conf=<file> \t\t " + _("Specify configuration file (default: bitcoin.conf)\n") +
+ " -pid=<file> \t\t " + _("Specify pid file (default: bitcoind.pid)\n") +
+ " -gen \t\t " + _("Generate coins\n") +
+ " -gen=0 \t\t " + _("Don't generate coins\n") +
+ " -min \t\t " + _("Start minimized\n") +
+ " -datadir=<dir> \t\t " + _("Specify data directory\n") +
+ " -timeout=<n> \t " + _("Specify connection timeout (in milliseconds)\n") +
+ " -proxy=<ip:port> \t " + _("Connect through socks4 proxy\n") +
+ " -dns \t " + _("Allow DNS lookups for addnode and connect\n") +
+ " -port=<port> \t\t " + _("Listen for connections on <port> (default: 8333 or testnet: 18333)\n") +
+ " -maxconnections=<n>\t " + _("Maintain at most <n> connections to peers (default: 125)\n") +
+ " -addnode=<ip> \t " + _("Add a node to connect to\n") +
+ " -connect=<ip> \t\t " + _("Connect only to the specified node\n") +
+ " -noirc \t " + _("Don't find peers using internet relay chat\n") +
+ " -nolisten \t " + _("Don't accept connections from outside\n") +
+ " -nodnsseed \t " + _("Don't bootstrap list of peers using DNS\n") +
+ " -banscore=<n> \t " + _("Threshold for disconnecting misbehaving peers (default: 100)\n") +
+ " -bantime=<n> \t " + _("Number of seconds to keep misbehaving peers from reconnecting (default: 86400)\n") +
+ " -maxreceivebuffer=<n>\t " + _("Maximum per-connection receive buffer, <n>*1000 bytes (default: 10000)\n") +
+ " -maxsendbuffer=<n>\t " + _("Maximum per-connection send buffer, <n>*1000 bytes (default: 10000)\n") +
+#ifdef USE_UPNP
+#if USE_UPNP
+ " -noupnp \t " + _("Don't attempt to use UPnP to map the listening port\n") +
+#else
+ " -upnp \t " + _("Attempt to use UPnP to map the listening port\n") +
+#endif
+#endif
+ " -paytxfee=<amt> \t " + _("Fee per kB to add to transactions you send\n") +
+#ifdef QT_GUI
+ " -server \t\t " + _("Accept command line and JSON-RPC commands\n") +
+#endif
+#if !defined(WIN32) && !defined(QT_GUI)
+ " -daemon \t\t " + _("Run in the background as a daemon and accept commands\n") +
+#endif
+ " -testnet \t\t " + _("Use the test network\n") +
+ " -debug \t\t " + _("Output extra debugging information\n") +
+ " -logtimestamps \t " + _("Prepend debug output with timestamp\n") +
+ " -printtoconsole \t " + _("Send trace/debug info to console instead of debug.log file\n") +
+#ifdef WIN32
+ " -printtodebugger \t " + _("Send trace/debug info to debugger\n") +
+#endif
+ " -rpcuser=<user> \t " + _("Username for JSON-RPC connections\n") +
+ " -rpcpassword=<pw>\t " + _("Password for JSON-RPC connections\n") +
+ " -rpcport=<port> \t\t " + _("Listen for JSON-RPC connections on <port> (default: 8332)\n") +
+ " -rpcallowip=<ip> \t\t " + _("Allow JSON-RPC connections from specified IP address\n") +
+ " -rpcconnect=<ip> \t " + _("Send commands to node running on <ip> (default: 127.0.0.1)\n") +
+ " -keypool=<n> \t " + _("Set key pool size to <n> (default: 100)\n") +
+ " -rescan \t " + _("Rescan the block chain for missing wallet transactions\n");
+
+#ifdef USE_SSL
+ strUsage += string() +
+ _("\nSSL options: (see the Bitcoin Wiki for SSL setup instructions)\n") +
+ " -rpcssl \t " + _("Use OpenSSL (https) for JSON-RPC connections\n") +
+ " -rpcsslcertificatechainfile=<file.cert>\t " + _("Server certificate file (default: server.cert)\n") +
+ " -rpcsslprivatekeyfile=<file.pem> \t " + _("Server private key (default: server.pem)\n") +
+ " -rpcsslciphers=<ciphers> \t " + _("Acceptable ciphers (default: TLSv1+HIGH:!SSLv2:!aNULL:!eNULL:!AH:!3DES:@STRENGTH)\n");
+#endif
+
+ strUsage += string() +
+ " -? \t\t " + _("This help message\n");
+
+ // Remove tabs
+ strUsage.erase(std::remove(strUsage.begin(), strUsage.end(), '\t'), strUsage.end());
+#if defined(QT_GUI) && defined(WIN32)
+ // On windows, show a message box, as there is no stderr
+ wxMessageBox(strUsage, "Usage");
+#else
+ fprintf(stderr, "%s", strUsage.c_str());
+#endif
+ return false;
+ }
+
+ fTestNet = GetBoolArg("-testnet");
+ fDebug = GetBoolArg("-debug");
+
+#if !defined(WIN32) && !defined(QT_GUI)
+ fDaemon = GetBoolArg("-daemon");
+#else
+ fDaemon = false;
+#endif
+
+ if (fDaemon)
+ fServer = true;
+ else
+ fServer = GetBoolArg("-server");
+
+ /* force fServer when running without GUI */
+#if !defined(QT_GUI)
+ fServer = true;
+#endif
+ fPrintToConsole = GetBoolArg("-printtoconsole");
+ fPrintToDebugger = GetBoolArg("-printtodebugger");
+ fLogTimestamps = GetBoolArg("-logtimestamps");
+
+#ifndef QT_GUI
+ for (int i = 1; i < argc; i++)
+ if (!IsSwitchChar(argv[i][0]))
+ fCommandLine = true;
+
+ if (fCommandLine)
+ {
+ int ret = CommandLineRPC(argc, argv);
+ exit(ret);
+ }
+#endif
+
+#if !defined(WIN32) && !defined(QT_GUI)
+ if (fDaemon)
+ {
+ // Daemonize
+ pid_t pid = fork();
+ if (pid < 0)
+ {
+ fprintf(stderr, "Error: fork() returned %d errno %d\n", pid, errno);
+ return false;
+ }
+ if (pid > 0)
+ {
+ CreatePidFile(GetPidFile(), pid);
+ return true;
+ }
+
+ pid_t sid = setsid();
+ if (sid < 0)
+ fprintf(stderr, "Error: setsid() returned %d errno %d\n", sid, errno);
+ }
+#endif
+
+ if (!fDebug && !pszSetDataDir[0])
+ ShrinkDebugFile();
+ printf("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
+ printf("Bitcoin version %s\n", FormatFullVersion().c_str());
+ printf("Default data directory %s\n", GetDefaultDataDir().c_str());
+
+ if (GetBoolArg("-loadblockindextest"))
+ {
+ CTxDB txdb("r");
+ txdb.LoadBlockIndex();
+ PrintBlockTree();
+ return false;
+ }
+
+ // Make sure only a single bitcoin process is using the data directory.
+ string strLockFile = GetDataDir() + "/.lock";
+ FILE* file = fopen(strLockFile.c_str(), "a"); // empty lock file; created if it doesn't exist.
+ if (file) fclose(file);
+ static boost::interprocess::file_lock lock(strLockFile.c_str());
+ if (!lock.try_lock())
+ {
+ wxMessageBox(strprintf(_("Cannot obtain a lock on data directory %s. Bitcoin is probably already running."), GetDataDir().c_str()), "Bitcoin");
+ return false;
+ }
+
+ string strErrors;
+
+ //
+ // Load data files
+ //
+ if (fDaemon)
+ fprintf(stdout, "bitcoin server starting\n");
+ strErrors = "";
+ int64 nStart;
+
+ InitMessage(_("Loading addresses..."));
+ printf("Loading addresses...\n");
+ nStart = GetTimeMillis();
+ if (!LoadAddresses())
+ strErrors += _("Error loading addr.dat \n");
+ printf(" addresses %15"PRI64d"ms\n", GetTimeMillis() - nStart);
+
+ InitMessage(_("Loading block index..."));
+ printf("Loading block index...\n");
+ nStart = GetTimeMillis();
+ if (!LoadBlockIndex())
+ strErrors += _("Error loading blkindex.dat \n");
+ printf(" block index %15"PRI64d"ms\n", GetTimeMillis() - nStart);
+
+ InitMessage(_("Loading wallet..."));
+ printf("Loading wallet...\n");
+ nStart = GetTimeMillis();
+ bool fFirstRun;
+ pwalletMain = new CWallet("wallet.dat");
+ int nLoadWalletRet = pwalletMain->LoadWallet(fFirstRun);
+ if (nLoadWalletRet != DB_LOAD_OK)
+ {
+ if (nLoadWalletRet == DB_CORRUPT)
+ strErrors += _("Error loading wallet.dat: Wallet corrupted \n");
+ else if (nLoadWalletRet == DB_TOO_NEW)
+ strErrors += _("Error loading wallet.dat: Wallet requires newer version of Bitcoin \n");
+ else if (nLoadWalletRet == DB_NEED_REWRITE)
+ {
+ strErrors += _("Wallet needed to be rewritten: restart Bitcoin to complete \n");
+ wxMessageBox(strErrors, "Bitcoin", wxOK | wxICON_ERROR);
+ return false;
+ }
+ else
+ strErrors += _("Error loading wallet.dat \n");
+ }
+ printf(" wallet %15"PRI64d"ms\n", GetTimeMillis() - nStart);
+
+ RegisterWallet(pwalletMain);
+
+ CBlockIndex *pindexRescan = pindexBest;
+ if (GetBoolArg("-rescan"))
+ pindexRescan = pindexGenesisBlock;
+ else
+ {
+ CWalletDB walletdb("wallet.dat");
+ CBlockLocator locator;
+ if (walletdb.ReadBestBlock(locator))
+ pindexRescan = locator.GetBlockIndex();
+ }
+ if (pindexBest != pindexRescan)
+ {
+ InitMessage(_("Rescanning..."));
+ printf("Rescanning last %i blocks (from block %i)...\n", pindexBest->nHeight - pindexRescan->nHeight, pindexRescan->nHeight);
+ nStart = GetTimeMillis();
+ pwalletMain->ScanForWalletTransactions(pindexRescan, true);
+ printf(" rescan %15"PRI64d"ms\n", GetTimeMillis() - nStart);
+ }
+
+ InitMessage(_("Done loading"));
+ printf("Done loading\n");
+
+ //// debug print
+ printf("mapBlockIndex.size() = %d\n", mapBlockIndex.size());
+ printf("nBestHeight = %d\n", nBestHeight);
+ printf("setKeyPool.size() = %d\n", pwalletMain->setKeyPool.size());
+ printf("mapWallet.size() = %d\n", pwalletMain->mapWallet.size());
+ printf("mapAddressBook.size() = %d\n", pwalletMain->mapAddressBook.size());
+
+ if (!strErrors.empty())
+ {
+ wxMessageBox(strErrors, "Bitcoin", wxOK | wxICON_ERROR);
+ return false;
+ }
+
+ // Add wallet transactions that aren't already in a block to mapTransactions
+ pwalletMain->ReacceptWalletTransactions();
+
+ // Note: Bitcoin-QT stores several settings in the wallet, so we want
+ // to load the wallet BEFORE parsing command-line arguments, so
+ // the command-line/bitcoin.conf settings override GUI setting.
+
+ //
+ // Parameters
+ //
+ if (GetBoolArg("-printblockindex") || GetBoolArg("-printblocktree"))
+ {
+ PrintBlockTree();
+ return false;
+ }
+
+ if (mapArgs.count("-timeout"))
+ {
+ int nNewTimeout = GetArg("-timeout", 5000);
+ if (nNewTimeout > 0 && nNewTimeout < 600000)
+ nConnectTimeout = nNewTimeout;
+ }
+
+ if (mapArgs.count("-printblock"))
+ {
+ string strMatch = mapArgs["-printblock"];
+ int nFound = 0;
+ for (map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.begin(); mi != mapBlockIndex.end(); ++mi)
+ {
+ uint256 hash = (*mi).first;
+ if (strncmp(hash.ToString().c_str(), strMatch.c_str(), strMatch.size()) == 0)
+ {
+ CBlockIndex* pindex = (*mi).second;
+ CBlock block;
+ block.ReadFromDisk(pindex);
+ block.BuildMerkleTree();
+ block.print();
+ printf("\n");
+ nFound++;
+ }
+ }
+ if (nFound == 0)
+ printf("No blocks matching %s were found\n", strMatch.c_str());
+ return false;
+ }
+
+ fGenerateBitcoins = GetBoolArg("-gen");
+
+ if (mapArgs.count("-proxy"))
+ {
+ fUseProxy = true;
+ addrProxy = CAddress(mapArgs["-proxy"]);
+ if (!addrProxy.IsValid())
+ {
+ wxMessageBox(_("Invalid -proxy address"), "Bitcoin");
+ return false;
+ }
+ }
+
+ bool fTor = (fUseProxy && addrProxy.port == htons(9050));
+ if (fTor)
+ {
+ // Use SoftSetArg here so user can override any of these if they wish.
+ // Note: the GetBoolArg() calls for all of these must happen later.
+ SoftSetArg("-nolisten", true);
+ SoftSetArg("-noirc", true);
+ SoftSetArg("-nodnsseed", true);
+ SoftSetArg("-noupnp", true);
+ SoftSetArg("-upnp", false);
+ SoftSetArg("-dns", false);
+ }
+
+ fAllowDNS = GetBoolArg("-dns");
+ fNoListen = GetBoolArg("-nolisten");
+
+ // Command-line args override in-wallet settings:
+ if (mapArgs.count("-upnp"))
+ fUseUPnP = GetBoolArg("-upnp");
+ else if (mapArgs.count("-noupnp"))
+ fUseUPnP = !GetBoolArg("-noupnp");
+
+ if (!fNoListen)
+ {
+ if (!BindListenPort(strErrors))
+ {
+ wxMessageBox(strErrors, "Bitcoin");
+ return false;
+ }
+ }
+
+ if (mapArgs.count("-addnode"))
+ {
+ BOOST_FOREACH(string strAddr, mapMultiArgs["-addnode"])
+ {
+ CAddress addr(strAddr, fAllowDNS);
+ addr.nTime = 0; // so it won't relay unless successfully connected
+ if (addr.IsValid())
+ AddAddress(addr);
+ }
+ }
+
+ if (mapArgs.count("-paytxfee"))
+ {
+ if (!ParseMoney(mapArgs["-paytxfee"], nTransactionFee))
+ {
+ wxMessageBox(_("Invalid amount for -paytxfee=<amount>"), "Bitcoin");
+ return false;
+ }
+ if (nTransactionFee > 0.25 * COIN)
+ wxMessageBox(_("Warning: -paytxfee is set very high. This is the transaction fee you will pay if you send a transaction."), "Bitcoin", wxOK | wxICON_EXCLAMATION);
+ }
+
+ //
+ // Start the node
+ //
+ if (!CheckDiskSpace())
+ return false;
+
+ RandAddSeedPerfmon();
+
+ if (!CreateThread(StartNode, NULL))
+ wxMessageBox(_("Error: CreateThread(StartNode) failed"), "Bitcoin");
+
+ if (fServer)
+ CreateThread(ThreadRPCServer, NULL);
+
+#if !defined(QT_GUI)
+ while (1)
+ Sleep(5000);
+#endif
+
+ return true;
+}
diff --git a/bitcoin/src/init.h b/bitcoin/src/init.h
@@ -0,0 +1,14 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2011 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#ifndef BITCOIN_INIT_H
+#define BITCOIN_INIT_H
+
+extern CWallet* pwalletMain;
+
+void Shutdown(void* parg);
+bool AppInit(int argc, char* argv[]);
+bool AppInit2(int argc, char* argv[]);
+
+#endif
diff --git a/bitcoin/src/irc.cpp b/bitcoin/src/irc.cpp
@@ -0,0 +1,440 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2012 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+#include "headers.h"
+#include "irc.h"
+#include "net.h"
+#include "strlcpy.h"
+
+using namespace std;
+using namespace boost;
+
+int nGotIRCAddresses = 0;
+bool fGotExternalIP = false;
+
+void ThreadIRCSeed2(void* parg);
+
+
+
+
+#pragma pack(push, 1)
+struct ircaddr
+{
+ int ip;
+ short port;
+};
+#pragma pack(pop)
+
+string EncodeAddress(const CAddress& addr)
+{
+ struct ircaddr tmp;
+ tmp.ip = addr.ip;
+ tmp.port = addr.port;
+
+ vector<unsigned char> vch(UBEGIN(tmp), UEND(tmp));
+ return string("u") + EncodeBase58Check(vch);
+}
+
+bool DecodeAddress(string str, CAddress& addr)
+{
+ vector<unsigned char> vch;
+ if (!DecodeBase58Check(str.substr(1), vch))
+ return false;
+
+ struct ircaddr tmp;
+ if (vch.size() != sizeof(tmp))
+ return false;
+ memcpy(&tmp, &vch[0], sizeof(tmp));
+
+ addr = CAddress(tmp.ip, ntohs(tmp.port), NODE_NETWORK);
+ return true;
+}
+
+
+
+
+
+
+static bool Send(SOCKET hSocket, const char* pszSend)
+{
+ if (strstr(pszSend, "PONG") != pszSend)
+ printf("IRC SENDING: %s\n", pszSend);
+ const char* psz = pszSend;
+ const char* pszEnd = psz + strlen(psz);
+ while (psz < pszEnd)
+ {
+ int ret = send(hSocket, psz, pszEnd - psz, MSG_NOSIGNAL);
+ if (ret < 0)
+ return false;
+ psz += ret;
+ }
+ return true;
+}
+
+bool RecvLine(SOCKET hSocket, string& strLine)
+{
+ strLine = "";
+ loop
+ {
+ char c;
+ int nBytes = recv(hSocket, &c, 1, 0);
+ if (nBytes > 0)
+ {
+ if (c == '\n')
+ continue;
+ if (c == '\r')
+ return true;
+ strLine += c;
+ if (strLine.size() >= 9000)
+ return true;
+ }
+ else if (nBytes <= 0)
+ {
+ if (fShutdown)
+ return false;
+ if (nBytes < 0)
+ {
+ int nErr = WSAGetLastError();
+ if (nErr == WSAEMSGSIZE)
+ continue;
+ if (nErr == WSAEWOULDBLOCK || nErr == WSAEINTR || nErr == WSAEINPROGRESS)
+ {
+ Sleep(10);
+ continue;
+ }
+ }
+ if (!strLine.empty())
+ return true;
+ if (nBytes == 0)
+ {
+ // socket closed
+ printf("socket closed\n");
+ return false;
+ }
+ else
+ {
+ // socket error
+ int nErr = WSAGetLastError();
+ printf("recv failed: %d\n", nErr);
+ return false;
+ }
+ }
+ }
+}
+
+bool RecvLineIRC(SOCKET hSocket, string& strLine)
+{
+ loop
+ {
+ bool fRet = RecvLine(hSocket, strLine);
+ if (fRet)
+ {
+ if (fShutdown)
+ return false;
+ vector<string> vWords;
+ ParseString(strLine, ' ', vWords);
+ if (vWords.size() >= 1 && vWords[0] == "PING")
+ {
+ strLine[1] = 'O';
+ strLine += '\r';
+ Send(hSocket, strLine.c_str());
+ continue;
+ }
+ }
+ return fRet;
+ }
+}
+
+int RecvUntil(SOCKET hSocket, const char* psz1, const char* psz2=NULL, const char* psz3=NULL, const char* psz4=NULL)
+{
+ loop
+ {
+ string strLine;
+ strLine.reserve(10000);
+ if (!RecvLineIRC(hSocket, strLine))
+ return 0;
+ printf("IRC %s\n", strLine.c_str());
+ if (psz1 && strLine.find(psz1) != -1)
+ return 1;
+ if (psz2 && strLine.find(psz2) != -1)
+ return 2;
+ if (psz3 && strLine.find(psz3) != -1)
+ return 3;
+ if (psz4 && strLine.find(psz4) != -1)
+ return 4;
+ }
+}
+
+bool Wait(int nSeconds)
+{
+ if (fShutdown)
+ return false;
+ printf("IRC waiting %d seconds to reconnect\n", nSeconds);
+ for (int i = 0; i < nSeconds; i++)
+ {
+ if (fShutdown)
+ return false;
+ Sleep(1000);
+ }
+ return true;
+}
+
+bool RecvCodeLine(SOCKET hSocket, const char* psz1, string& strRet)
+{
+ strRet.clear();
+ loop
+ {
+ string strLine;
+ if (!RecvLineIRC(hSocket, strLine))
+ return false;
+
+ vector<string> vWords;
+ ParseString(strLine, ' ', vWords);
+ if (vWords.size() < 2)
+ continue;
+
+ if (vWords[1] == psz1)
+ {
+ printf("IRC %s\n", strLine.c_str());
+ strRet = strLine;
+ return true;
+ }
+ }
+}
+
+bool GetIPFromIRC(SOCKET hSocket, string strMyName, unsigned int& ipRet)
+{
+ Send(hSocket, strprintf("USERHOST %s\r", strMyName.c_str()).c_str());
+
+ string strLine;
+ if (!RecvCodeLine(hSocket, "302", strLine))
+ return false;
+
+ vector<string> vWords;
+ ParseString(strLine, ' ', vWords);
+ if (vWords.size() < 4)
+ return false;
+
+ string str = vWords[3];
+ if (str.rfind("@") == string::npos)
+ return false;
+ string strHost = str.substr(str.rfind("@")+1);
+
+ // Hybrid IRC used by lfnet always returns IP when you userhost yourself,
+ // but in case another IRC is ever used this should work.
+ printf("GetIPFromIRC() got userhost %s\n", strHost.c_str());
+ if (fUseProxy)
+ return false;
+ CAddress addr(strHost, 0, true);
+ if (!addr.IsValid())
+ return false;
+ ipRet = addr.ip;
+
+ return true;
+}
+
+
+
+void ThreadIRCSeed(void* parg)
+{
+ IMPLEMENT_RANDOMIZE_STACK(ThreadIRCSeed(parg));
+ try
+ {
+ ThreadIRCSeed2(parg);
+ }
+ catch (std::exception& e) {
+ PrintExceptionContinue(&e, "ThreadIRCSeed()");
+ } catch (...) {
+ PrintExceptionContinue(NULL, "ThreadIRCSeed()");
+ }
+ printf("ThreadIRCSeed exiting\n");
+}
+
+void ThreadIRCSeed2(void* parg)
+{
+ /* Dont advertise on IRC if we don't allow incoming connections */
+ if (mapArgs.count("-connect") || fNoListen)
+ return;
+
+ if (GetBoolArg("-noirc"))
+ return;
+ printf("ThreadIRCSeed started\n");
+ int nErrorWait = 10;
+ int nRetryWait = 10;
+ bool fNameInUse = false;
+
+ while (!fShutdown)
+ {
+ CAddress addrConnect("92.243.23.21", 6667); // irc.lfnet.org
+
+ CAddress addrIRC("irc.lfnet.org", 6667, true);
+ if (addrIRC.IsValid())
+ addrConnect = addrIRC;
+
+ SOCKET hSocket;
+ if (!ConnectSocket(addrConnect, hSocket))
+ {
+ printf("IRC connect failed\n");
+ nErrorWait = nErrorWait * 11 / 10;
+ if (Wait(nErrorWait += 60))
+ continue;
+ else
+ return;
+ }
+
+ if (!RecvUntil(hSocket, "Found your hostname", "using your IP address instead", "Couldn't look up your hostname", "ignoring hostname"))
+ {
+ closesocket(hSocket);
+ hSocket = INVALID_SOCKET;
+ nErrorWait = nErrorWait * 11 / 10;
+ if (Wait(nErrorWait += 60))
+ continue;
+ else
+ return;
+ }
+
+ string strMyName;
+ if (addrLocalHost.IsRoutable() && !fUseProxy && !fNameInUse)
+ strMyName = EncodeAddress(addrLocalHost);
+ else
+ strMyName = strprintf("x%u", GetRand(1000000000));
+
+ Send(hSocket, strprintf("NICK %s\r", strMyName.c_str()).c_str());
+ Send(hSocket, strprintf("USER %s 8 * : %s\r", strMyName.c_str(), strMyName.c_str()).c_str());
+
+ int nRet = RecvUntil(hSocket, " 004 ", " 433 ");
+ if (nRet != 1)
+ {
+ closesocket(hSocket);
+ hSocket = INVALID_SOCKET;
+ if (nRet == 2)
+ {
+ printf("IRC name already in use\n");
+ fNameInUse = true;
+ Wait(10);
+ continue;
+ }
+ nErrorWait = nErrorWait * 11 / 10;
+ if (Wait(nErrorWait += 60))
+ continue;
+ else
+ return;
+ }
+ Sleep(500);
+
+ // Get our external IP from the IRC server and re-nick before joining the channel
+ CAddress addrFromIRC;
+ if (GetIPFromIRC(hSocket, strMyName, addrFromIRC.ip))
+ {
+ printf("GetIPFromIRC() returned %s\n", addrFromIRC.ToStringIP().c_str());
+ if (!fUseProxy && addrFromIRC.IsRoutable())
+ {
+ // IRC lets you to re-nick
+ fGotExternalIP = true;
+ addrLocalHost.ip = addrFromIRC.ip;
+ strMyName = EncodeAddress(addrLocalHost);
+ Send(hSocket, strprintf("NICK %s\r", strMyName.c_str()).c_str());
+ }
+ }
+
+ if (fTestNet) {
+ Send(hSocket, "JOIN #bitcoinTEST\r");
+ Send(hSocket, "WHO #bitcoinTEST\r");
+ } else {
+ // randomly join #bitcoin00-#bitcoin99
+ int channel_number = GetRandInt(100);
+ Send(hSocket, strprintf("JOIN #bitcoin%02d\r", channel_number).c_str());
+ Send(hSocket, strprintf("WHO #bitcoin%02d\r", channel_number).c_str());
+ }
+
+ int64 nStart = GetTime();
+ string strLine;
+ strLine.reserve(10000);
+ while (!fShutdown && RecvLineIRC(hSocket, strLine))
+ {
+ if (strLine.empty() || strLine.size() > 900 || strLine[0] != ':')
+ continue;
+
+ vector<string> vWords;
+ ParseString(strLine, ' ', vWords);
+ if (vWords.size() < 2)
+ continue;
+
+ char pszName[10000];
+ pszName[0] = '\0';
+
+ if (vWords[1] == "352" && vWords.size() >= 8)
+ {
+ // index 7 is limited to 16 characters
+ // could get full length name at index 10, but would be different from join messages
+ strlcpy(pszName, vWords[7].c_str(), sizeof(pszName));
+ printf("IRC got who\n");
+ }
+
+ if (vWords[1] == "JOIN" && vWords[0].size() > 1)
+ {
+ // :username!username@50000007.F000000B.90000002.IP JOIN :#channelname
+ strlcpy(pszName, vWords[0].c_str() + 1, sizeof(pszName));
+ if (strchr(pszName, '!'))
+ *strchr(pszName, '!') = '\0';
+ printf("IRC got join\n");
+ }
+
+ if (pszName[0] == 'u')
+ {
+ CAddress addr;
+ if (DecodeAddress(pszName, addr))
+ {
+ addr.nTime = GetAdjustedTime();
+ if (AddAddress(addr, 51 * 60))
+ printf("IRC got new address: %s\n", addr.ToString().c_str());
+ nGotIRCAddresses++;
+ }
+ else
+ {
+ printf("IRC decode failed\n");
+ }
+ }
+ }
+ closesocket(hSocket);
+ hSocket = INVALID_SOCKET;
+
+ if (GetTime() - nStart > 20 * 60)
+ {
+ nErrorWait /= 3;
+ nRetryWait /= 3;
+ }
+
+ nRetryWait = nRetryWait * 11 / 10;
+ if (!Wait(nRetryWait += 60))
+ return;
+ }
+}
+
+
+
+
+
+
+
+
+
+
+#ifdef TEST
+int main(int argc, char *argv[])
+{
+ WSADATA wsadata;
+ if (WSAStartup(MAKEWORD(2,2), &wsadata) != NO_ERROR)
+ {
+ printf("Error at WSAStartup()\n");
+ return false;
+ }
+
+ ThreadIRCSeed(NULL);
+
+ WSACleanup();
+ return 0;
+}
+#endif
diff --git a/bitcoin/src/irc.h b/bitcoin/src/irc.h
@@ -0,0 +1,14 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2011 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#ifndef BITCOIN_IRC_H
+#define BITCOIN_IRC_H
+
+bool RecvLine(SOCKET hSocket, std::string& strLine);
+void ThreadIRCSeed(void* parg);
+
+extern int nGotIRCAddresses;
+extern bool fGotExternalIP;
+
+#endif
diff --git a/bitcoin/src/json/LICENSE.txt b/bitcoin/src/json/LICENSE.txt
@@ -0,0 +1,24 @@
+The MIT License
+
+Copyright (c) 2007 - 2009 John W. Wilkinson
+
+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.
diff --git a/bitcoin/src/json/json_spirit.h b/bitcoin/src/json/json_spirit.h
@@ -0,0 +1,18 @@
+#ifndef JSON_SPIRIT
+#define JSON_SPIRIT
+
+// Copyright John W. Wilkinson 2007 - 2009.
+// Distributed under the MIT License, see accompanying file LICENSE.txt
+
+// json spirit version 4.03
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include "json_spirit_value.h"
+#include "json_spirit_reader.h"
+#include "json_spirit_writer.h"
+#include "json_spirit_utils.h"
+
+#endif
diff --git a/bitcoin/src/json/json_spirit_error_position.h b/bitcoin/src/json/json_spirit_error_position.h
@@ -0,0 +1,54 @@
+#ifndef JSON_SPIRIT_ERROR_POSITION
+#define JSON_SPIRIT_ERROR_POSITION
+
+// Copyright John W. Wilkinson 2007 - 2009.
+// Distributed under the MIT License, see accompanying file LICENSE.txt
+
+// json spirit version 4.03
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <string>
+
+namespace json_spirit
+{
+ // An Error_position exception is thrown by the "read_or_throw" functions below on finding an error.
+ // Note the "read_or_throw" functions are around 3 times slower than the standard functions "read"
+ // functions that return a bool.
+ //
+ struct Error_position
+ {
+ Error_position();
+ Error_position( unsigned int line, unsigned int column, const std::string& reason );
+ bool operator==( const Error_position& lhs ) const;
+ unsigned int line_;
+ unsigned int column_;
+ std::string reason_;
+ };
+
+ inline Error_position::Error_position()
+ : line_( 0 )
+ , column_( 0 )
+ {
+ }
+
+ inline Error_position::Error_position( unsigned int line, unsigned int column, const std::string& reason )
+ : line_( line )
+ , column_( column )
+ , reason_( reason )
+ {
+ }
+
+ inline bool Error_position::operator==( const Error_position& lhs ) const
+ {
+ if( this == &lhs ) return true;
+
+ return ( reason_ == lhs.reason_ ) &&
+ ( line_ == lhs.line_ ) &&
+ ( column_ == lhs.column_ );
+}
+}
+
+#endif
diff --git a/bitcoin/src/json/json_spirit_reader.cpp b/bitcoin/src/json/json_spirit_reader.cpp
@@ -0,0 +1,137 @@
+// Copyright John W. Wilkinson 2007 - 2009.
+// Distributed under the MIT License, see accompanying file LICENSE.txt
+
+// json spirit version 4.03
+
+#include "json_spirit_reader.h"
+#include "json_spirit_reader_template.h"
+
+using namespace json_spirit;
+
+bool json_spirit::read( const std::string& s, Value& value )
+{
+ return read_string( s, value );
+}
+
+void json_spirit::read_or_throw( const std::string& s, Value& value )
+{
+ read_string_or_throw( s, value );
+}
+
+bool json_spirit::read( std::istream& is, Value& value )
+{
+ return read_stream( is, value );
+}
+
+void json_spirit::read_or_throw( std::istream& is, Value& value )
+{
+ read_stream_or_throw( is, value );
+}
+
+bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value )
+{
+ return read_range( begin, end, value );
+}
+
+void json_spirit::read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, Value& value )
+{
+ begin = read_range_or_throw( begin, end, value );
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+
+bool json_spirit::read( const std::wstring& s, wValue& value )
+{
+ return read_string( s, value );
+}
+
+void json_spirit::read_or_throw( const std::wstring& s, wValue& value )
+{
+ read_string_or_throw( s, value );
+}
+
+bool json_spirit::read( std::wistream& is, wValue& value )
+{
+ return read_stream( is, value );
+}
+
+void json_spirit::read_or_throw( std::wistream& is, wValue& value )
+{
+ read_stream_or_throw( is, value );
+}
+
+bool json_spirit::read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value )
+{
+ return read_range( begin, end, value );
+}
+
+void json_spirit::read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value )
+{
+ begin = read_range_or_throw( begin, end, value );
+}
+
+#endif
+
+bool json_spirit::read( const std::string& s, mValue& value )
+{
+ return read_string( s, value );
+}
+
+void json_spirit::read_or_throw( const std::string& s, mValue& value )
+{
+ read_string_or_throw( s, value );
+}
+
+bool json_spirit::read( std::istream& is, mValue& value )
+{
+ return read_stream( is, value );
+}
+
+void json_spirit::read_or_throw( std::istream& is, mValue& value )
+{
+ read_stream_or_throw( is, value );
+}
+
+bool json_spirit::read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value )
+{
+ return read_range( begin, end, value );
+}
+
+void json_spirit::read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value )
+{
+ begin = read_range_or_throw( begin, end, value );
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+
+bool json_spirit::read( const std::wstring& s, wmValue& value )
+{
+ return read_string( s, value );
+}
+
+void json_spirit::read_or_throw( const std::wstring& s, wmValue& value )
+{
+ read_string_or_throw( s, value );
+}
+
+bool json_spirit::read( std::wistream& is, wmValue& value )
+{
+ return read_stream( is, value );
+}
+
+void json_spirit::read_or_throw( std::wistream& is, wmValue& value )
+{
+ read_stream_or_throw( is, value );
+}
+
+bool json_spirit::read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value )
+{
+ return read_range( begin, end, value );
+}
+
+void json_spirit::read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value )
+{
+ begin = read_range_or_throw( begin, end, value );
+}
+
+#endif
diff --git a/bitcoin/src/json/json_spirit_reader.h b/bitcoin/src/json/json_spirit_reader.h
@@ -0,0 +1,62 @@
+#ifndef JSON_SPIRIT_READER
+#define JSON_SPIRIT_READER
+
+// Copyright John W. Wilkinson 2007 - 2009.
+// Distributed under the MIT License, see accompanying file LICENSE.txt
+
+// json spirit version 4.03
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include "json_spirit_value.h"
+#include "json_spirit_error_position.h"
+#include <iostream>
+
+namespace json_spirit
+{
+ // functions to reads a JSON values
+
+ bool read( const std::string& s, Value& value );
+ bool read( std::istream& is, Value& value );
+ bool read( std::string::const_iterator& begin, std::string::const_iterator end, Value& value );
+
+ void read_or_throw( const std::string& s, Value& value );
+ void read_or_throw( std::istream& is, Value& value );
+ void read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, Value& value );
+
+#ifndef BOOST_NO_STD_WSTRING
+
+ bool read( const std::wstring& s, wValue& value );
+ bool read( std::wistream& is, wValue& value );
+ bool read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value );
+
+ void read_or_throw( const std::wstring& s, wValue& value );
+ void read_or_throw( std::wistream& is, wValue& value );
+ void read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wValue& value );
+
+#endif
+
+ bool read( const std::string& s, mValue& value );
+ bool read( std::istream& is, mValue& value );
+ bool read( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value );
+
+ void read_or_throw( const std::string& s, mValue& value );
+ void read_or_throw( std::istream& is, mValue& value );
+ void read_or_throw( std::string::const_iterator& begin, std::string::const_iterator end, mValue& value );
+
+#ifndef BOOST_NO_STD_WSTRING
+
+ bool read( const std::wstring& s, wmValue& value );
+ bool read( std::wistream& is, wmValue& value );
+ bool read( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value );
+
+ void read_or_throw( const std::wstring& s, wmValue& value );
+ void read_or_throw( std::wistream& is, wmValue& value );
+ void read_or_throw( std::wstring::const_iterator& begin, std::wstring::const_iterator end, wmValue& value );
+
+#endif
+}
+
+#endif
diff --git a/bitcoin/src/json/json_spirit_reader_template.h b/bitcoin/src/json/json_spirit_reader_template.h
@@ -0,0 +1,612 @@
+#ifndef JSON_SPIRIT_READER_TEMPLATE
+#define JSON_SPIRIT_READER_TEMPLATE
+
+// Copyright John W. Wilkinson 2007 - 2009.
+// Distributed under the MIT License, see accompanying file LICENSE.txt
+
+// json spirit version 4.03
+
+#include "json_spirit_value.h"
+#include "json_spirit_error_position.h"
+
+//#define BOOST_SPIRIT_THREADSAFE // uncomment for multithreaded use, requires linking to boost.thread
+
+#include <boost/bind.hpp>
+#include <boost/function.hpp>
+#include <boost/version.hpp>
+
+#if BOOST_VERSION >= 103800
+ #include <boost/spirit/include/classic_core.hpp>
+ #include <boost/spirit/include/classic_confix.hpp>
+ #include <boost/spirit/include/classic_escape_char.hpp>
+ #include <boost/spirit/include/classic_multi_pass.hpp>
+ #include <boost/spirit/include/classic_position_iterator.hpp>
+ #define spirit_namespace boost::spirit::classic
+#else
+ #include <boost/spirit/core.hpp>
+ #include <boost/spirit/utility/confix.hpp>
+ #include <boost/spirit/utility/escape_char.hpp>
+ #include <boost/spirit/iterator/multi_pass.hpp>
+ #include <boost/spirit/iterator/position_iterator.hpp>
+ #define spirit_namespace boost::spirit
+#endif
+
+namespace json_spirit
+{
+ const spirit_namespace::int_parser < boost::int64_t > int64_p = spirit_namespace::int_parser < boost::int64_t >();
+ const spirit_namespace::uint_parser< boost::uint64_t > uint64_p = spirit_namespace::uint_parser< boost::uint64_t >();
+
+ template< class Iter_type >
+ bool is_eq( Iter_type first, Iter_type last, const char* c_str )
+ {
+ for( Iter_type i = first; i != last; ++i, ++c_str )
+ {
+ if( *c_str == 0 ) return false;
+
+ if( *i != *c_str ) return false;
+ }
+
+ return true;
+ }
+
+ template< class Char_type >
+ Char_type hex_to_num( const Char_type c )
+ {
+ if( ( c >= '0' ) && ( c <= '9' ) ) return c - '0';
+ if( ( c >= 'a' ) && ( c <= 'f' ) ) return c - 'a' + 10;
+ if( ( c >= 'A' ) && ( c <= 'F' ) ) return c - 'A' + 10;
+ return 0;
+ }
+
+ template< class Char_type, class Iter_type >
+ Char_type hex_str_to_char( Iter_type& begin )
+ {
+ const Char_type c1( *( ++begin ) );
+ const Char_type c2( *( ++begin ) );
+
+ return ( hex_to_num( c1 ) << 4 ) + hex_to_num( c2 );
+ }
+
+ template< class Char_type, class Iter_type >
+ Char_type unicode_str_to_char( Iter_type& begin )
+ {
+ const Char_type c1( *( ++begin ) );
+ const Char_type c2( *( ++begin ) );
+ const Char_type c3( *( ++begin ) );
+ const Char_type c4( *( ++begin ) );
+
+ return ( hex_to_num( c1 ) << 12 ) +
+ ( hex_to_num( c2 ) << 8 ) +
+ ( hex_to_num( c3 ) << 4 ) +
+ hex_to_num( c4 );
+ }
+
+ template< class String_type >
+ void append_esc_char_and_incr_iter( String_type& s,
+ typename String_type::const_iterator& begin,
+ typename String_type::const_iterator end )
+ {
+ typedef typename String_type::value_type Char_type;
+
+ const Char_type c2( *begin );
+
+ switch( c2 )
+ {
+ case 't': s += '\t'; break;
+ case 'b': s += '\b'; break;
+ case 'f': s += '\f'; break;
+ case 'n': s += '\n'; break;
+ case 'r': s += '\r'; break;
+ case '\\': s += '\\'; break;
+ case '/': s += '/'; break;
+ case '"': s += '"'; break;
+ case 'x':
+ {
+ if( end - begin >= 3 ) // expecting "xHH..."
+ {
+ s += hex_str_to_char< Char_type >( begin );
+ }
+ break;
+ }
+ case 'u':
+ {
+ if( end - begin >= 5 ) // expecting "uHHHH..."
+ {
+ s += unicode_str_to_char< Char_type >( begin );
+ }
+ break;
+ }
+ }
+ }
+
+ template< class String_type >
+ String_type substitute_esc_chars( typename String_type::const_iterator begin,
+ typename String_type::const_iterator end )
+ {
+ typedef typename String_type::const_iterator Iter_type;
+
+ if( end - begin < 2 ) return String_type( begin, end );
+
+ String_type result;
+
+ result.reserve( end - begin );
+
+ const Iter_type end_minus_1( end - 1 );
+
+ Iter_type substr_start = begin;
+ Iter_type i = begin;
+
+ for( ; i < end_minus_1; ++i )
+ {
+ if( *i == '\\' )
+ {
+ result.append( substr_start, i );
+
+ ++i; // skip the '\'
+
+ append_esc_char_and_incr_iter( result, i, end );
+
+ substr_start = i + 1;
+ }
+ }
+
+ result.append( substr_start, end );
+
+ return result;
+ }
+
+ template< class String_type >
+ String_type get_str_( typename String_type::const_iterator begin,
+ typename String_type::const_iterator end )
+ {
+ assert( end - begin >= 2 );
+
+ typedef typename String_type::const_iterator Iter_type;
+
+ Iter_type str_without_quotes( ++begin );
+ Iter_type end_without_quotes( --end );
+
+ return substitute_esc_chars< String_type >( str_without_quotes, end_without_quotes );
+ }
+
+ inline std::string get_str( std::string::const_iterator begin, std::string::const_iterator end )
+ {
+ return get_str_< std::string >( begin, end );
+ }
+
+ inline std::wstring get_str( std::wstring::const_iterator begin, std::wstring::const_iterator end )
+ {
+ return get_str_< std::wstring >( begin, end );
+ }
+
+ template< class String_type, class Iter_type >
+ String_type get_str( Iter_type begin, Iter_type end )
+ {
+ const String_type tmp( begin, end ); // convert multipass iterators to string iterators
+
+ return get_str( tmp.begin(), tmp.end() );
+ }
+
+ // this class's methods get called by the spirit parse resulting
+ // in the creation of a JSON object or array
+ //
+ // NB Iter_type could be a std::string iterator, wstring iterator, a position iterator or a multipass iterator
+ //
+ template< class Value_type, class Iter_type >
+ class Semantic_actions
+ {
+ public:
+
+ typedef typename Value_type::Config_type Config_type;
+ typedef typename Config_type::String_type String_type;
+ typedef typename Config_type::Object_type Object_type;
+ typedef typename Config_type::Array_type Array_type;
+ typedef typename String_type::value_type Char_type;
+
+ Semantic_actions( Value_type& value )
+ : value_( value )
+ , current_p_( 0 )
+ {
+ }
+
+ void begin_obj( Char_type c )
+ {
+ assert( c == '{' );
+
+ begin_compound< Object_type >();
+ }
+
+ void end_obj( Char_type c )
+ {
+ assert( c == '}' );
+
+ end_compound();
+ }
+
+ void begin_array( Char_type c )
+ {
+ assert( c == '[' );
+
+ begin_compound< Array_type >();
+ }
+
+ void end_array( Char_type c )
+ {
+ assert( c == ']' );
+
+ end_compound();
+ }
+
+ void new_name( Iter_type begin, Iter_type end )
+ {
+ assert( current_p_->type() == obj_type );
+
+ name_ = get_str< String_type >( begin, end );
+ }
+
+ void new_str( Iter_type begin, Iter_type end )
+ {
+ add_to_current( get_str< String_type >( begin, end ) );
+ }
+
+ void new_true( Iter_type begin, Iter_type end )
+ {
+ assert( is_eq( begin, end, "true" ) );
+
+ add_to_current( true );
+ }
+
+ void new_false( Iter_type begin, Iter_type end )
+ {
+ assert( is_eq( begin, end, "false" ) );
+
+ add_to_current( false );
+ }
+
+ void new_null( Iter_type begin, Iter_type end )
+ {
+ assert( is_eq( begin, end, "null" ) );
+
+ add_to_current( Value_type() );
+ }
+
+ void new_int( boost::int64_t i )
+ {
+ add_to_current( i );
+ }
+
+ void new_uint64( boost::uint64_t ui )
+ {
+ add_to_current( ui );
+ }
+
+ void new_real( double d )
+ {
+ add_to_current( d );
+ }
+
+ private:
+
+ Semantic_actions& operator=( const Semantic_actions& );
+ // to prevent "assignment operator could not be generated" warning
+
+ Value_type* add_first( const Value_type& value )
+ {
+ assert( current_p_ == 0 );
+
+ value_ = value;
+ current_p_ = &value_;
+ return current_p_;
+ }
+
+ template< class Array_or_obj >
+ void begin_compound()
+ {
+ if( current_p_ == 0 )
+ {
+ add_first( Array_or_obj() );
+ }
+ else
+ {
+ stack_.push_back( current_p_ );
+
+ Array_or_obj new_array_or_obj; // avoid copy by building new array or object in place
+
+ current_p_ = add_to_current( new_array_or_obj );
+ }
+ }
+
+ void end_compound()
+ {
+ if( current_p_ != &value_ )
+ {
+ current_p_ = stack_.back();
+
+ stack_.pop_back();
+ }
+ }
+
+ Value_type* add_to_current( const Value_type& value )
+ {
+ if( current_p_ == 0 )
+ {
+ return add_first( value );
+ }
+ else if( current_p_->type() == array_type )
+ {
+ current_p_->get_array().push_back( value );
+
+ return ¤t_p_->get_array().back();
+ }
+
+ assert( current_p_->type() == obj_type );
+
+ return &Config_type::add( current_p_->get_obj(), name_, value );
+ }
+
+ Value_type& value_; // this is the object or array that is being created
+ Value_type* current_p_; // the child object or array that is currently being constructed
+
+ std::vector< Value_type* > stack_; // previous child objects and arrays
+
+ String_type name_; // of current name/value pair
+ };
+
+ template< typename Iter_type >
+ void throw_error( spirit_namespace::position_iterator< Iter_type > i, const std::string& reason )
+ {
+ throw Error_position( i.get_position().line, i.get_position().column, reason );
+ }
+
+ template< typename Iter_type >
+ void throw_error( Iter_type i, const std::string& reason )
+ {
+ throw reason;
+ }
+
+ // the spirit grammer
+ //
+ template< class Value_type, class Iter_type >
+ class Json_grammer : public spirit_namespace::grammar< Json_grammer< Value_type, Iter_type > >
+ {
+ public:
+
+ typedef Semantic_actions< Value_type, Iter_type > Semantic_actions_t;
+
+ Json_grammer( Semantic_actions_t& semantic_actions )
+ : actions_( semantic_actions )
+ {
+ }
+
+ static void throw_not_value( Iter_type begin, Iter_type end )
+ {
+ throw_error( begin, "not a value" );
+ }
+
+ static void throw_not_array( Iter_type begin, Iter_type end )
+ {
+ throw_error( begin, "not an array" );
+ }
+
+ static void throw_not_object( Iter_type begin, Iter_type end )
+ {
+ throw_error( begin, "not an object" );
+ }
+
+ static void throw_not_pair( Iter_type begin, Iter_type end )
+ {
+ throw_error( begin, "not a pair" );
+ }
+
+ static void throw_not_colon( Iter_type begin, Iter_type end )
+ {
+ throw_error( begin, "no colon in pair" );
+ }
+
+ static void throw_not_string( Iter_type begin, Iter_type end )
+ {
+ throw_error( begin, "not a string" );
+ }
+
+ template< typename ScannerT >
+ class definition
+ {
+ public:
+
+ definition( const Json_grammer& self )
+ {
+ using namespace spirit_namespace;
+
+ typedef typename Value_type::String_type::value_type Char_type;
+
+ // first we convert the semantic action class methods to functors with the
+ // parameter signature expected by spirit
+
+ typedef boost::function< void( Char_type ) > Char_action;
+ typedef boost::function< void( Iter_type, Iter_type ) > Str_action;
+ typedef boost::function< void( double ) > Real_action;
+ typedef boost::function< void( boost::int64_t ) > Int_action;
+ typedef boost::function< void( boost::uint64_t ) > Uint64_action;
+
+ Char_action begin_obj ( boost::bind( &Semantic_actions_t::begin_obj, &self.actions_, _1 ) );
+ Char_action end_obj ( boost::bind( &Semantic_actions_t::end_obj, &self.actions_, _1 ) );
+ Char_action begin_array( boost::bind( &Semantic_actions_t::begin_array, &self.actions_, _1 ) );
+ Char_action end_array ( boost::bind( &Semantic_actions_t::end_array, &self.actions_, _1 ) );
+ Str_action new_name ( boost::bind( &Semantic_actions_t::new_name, &self.actions_, _1, _2 ) );
+ Str_action new_str ( boost::bind( &Semantic_actions_t::new_str, &self.actions_, _1, _2 ) );
+ Str_action new_true ( boost::bind( &Semantic_actions_t::new_true, &self.actions_, _1, _2 ) );
+ Str_action new_false ( boost::bind( &Semantic_actions_t::new_false, &self.actions_, _1, _2 ) );
+ Str_action new_null ( boost::bind( &Semantic_actions_t::new_null, &self.actions_, _1, _2 ) );
+ Real_action new_real ( boost::bind( &Semantic_actions_t::new_real, &self.actions_, _1 ) );
+ Int_action new_int ( boost::bind( &Semantic_actions_t::new_int, &self.actions_, _1 ) );
+ Uint64_action new_uint64 ( boost::bind( &Semantic_actions_t::new_uint64, &self.actions_, _1 ) );
+
+ // actual grammer
+
+ json_
+ = value_ | eps_p[ &throw_not_value ]
+ ;
+
+ value_
+ = string_[ new_str ]
+ | number_
+ | object_
+ | array_
+ | str_p( "true" ) [ new_true ]
+ | str_p( "false" )[ new_false ]
+ | str_p( "null" ) [ new_null ]
+ ;
+
+ object_
+ = ch_p('{')[ begin_obj ]
+ >> !members_
+ >> ( ch_p('}')[ end_obj ] | eps_p[ &throw_not_object ] )
+ ;
+
+ members_
+ = pair_ >> *( ',' >> pair_ )
+ ;
+
+ pair_
+ = string_[ new_name ]
+ >> ( ':' | eps_p[ &throw_not_colon ] )
+ >> ( value_ | eps_p[ &throw_not_value ] )
+ ;
+
+ array_
+ = ch_p('[')[ begin_array ]
+ >> !elements_
+ >> ( ch_p(']')[ end_array ] | eps_p[ &throw_not_array ] )
+ ;
+
+ elements_
+ = value_ >> *( ',' >> value_ )
+ ;
+
+ string_
+ = lexeme_d // this causes white space inside a string to be retained
+ [
+ confix_p
+ (
+ '"',
+ *lex_escape_ch_p,
+ '"'
+ )
+ ]
+ ;
+
+ number_
+ = strict_real_p[ new_real ]
+ | int64_p [ new_int ]
+ | uint64_p [ new_uint64 ]
+ ;
+ }
+
+ spirit_namespace::rule< ScannerT > json_, object_, members_, pair_, array_, elements_, value_, string_, number_;
+
+ const spirit_namespace::rule< ScannerT >& start() const { return json_; }
+ };
+
+ private:
+
+ Json_grammer& operator=( const Json_grammer& ); // to prevent "assignment operator could not be generated" warning
+
+ Semantic_actions_t& actions_;
+ };
+
+ template< class Iter_type, class Value_type >
+ Iter_type read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value )
+ {
+ Semantic_actions< Value_type, Iter_type > semantic_actions( value );
+
+ const spirit_namespace::parse_info< Iter_type > info =
+ spirit_namespace::parse( begin, end,
+ Json_grammer< Value_type, Iter_type >( semantic_actions ),
+ spirit_namespace::space_p );
+
+ if( !info.hit )
+ {
+ assert( false ); // in theory exception should already have been thrown
+ throw_error( info.stop, "error" );
+ }
+
+ return info.stop;
+ }
+
+ template< class Iter_type, class Value_type >
+ void add_posn_iter_and_read_range_or_throw( Iter_type begin, Iter_type end, Value_type& value )
+ {
+ typedef spirit_namespace::position_iterator< Iter_type > Posn_iter_t;
+
+ const Posn_iter_t posn_begin( begin, end );
+ const Posn_iter_t posn_end( end, end );
+
+ read_range_or_throw( posn_begin, posn_end, value );
+ }
+
+ template< class Iter_type, class Value_type >
+ bool read_range( Iter_type& begin, Iter_type end, Value_type& value )
+ {
+ try
+ {
+ begin = read_range_or_throw( begin, end, value );
+
+ return true;
+ }
+ catch( ... )
+ {
+ return false;
+ }
+ }
+
+ template< class String_type, class Value_type >
+ void read_string_or_throw( const String_type& s, Value_type& value )
+ {
+ add_posn_iter_and_read_range_or_throw( s.begin(), s.end(), value );
+ }
+
+ template< class String_type, class Value_type >
+ bool read_string( const String_type& s, Value_type& value )
+ {
+ typename String_type::const_iterator begin = s.begin();
+
+ return read_range( begin, s.end(), value );
+ }
+
+ template< class Istream_type >
+ struct Multi_pass_iters
+ {
+ typedef typename Istream_type::char_type Char_type;
+ typedef std::istream_iterator< Char_type, Char_type > istream_iter;
+ typedef spirit_namespace::multi_pass< istream_iter > Mp_iter;
+
+ Multi_pass_iters( Istream_type& is )
+ {
+ is.unsetf( std::ios::skipws );
+
+ begin_ = spirit_namespace::make_multi_pass( istream_iter( is ) );
+ end_ = spirit_namespace::make_multi_pass( istream_iter() );
+ }
+
+ Mp_iter begin_;
+ Mp_iter end_;
+ };
+
+ template< class Istream_type, class Value_type >
+ bool read_stream( Istream_type& is, Value_type& value )
+ {
+ Multi_pass_iters< Istream_type > mp_iters( is );
+
+ return read_range( mp_iters.begin_, mp_iters.end_, value );
+ }
+
+ template< class Istream_type, class Value_type >
+ void read_stream_or_throw( Istream_type& is, Value_type& value )
+ {
+ const Multi_pass_iters< Istream_type > mp_iters( is );
+
+ add_posn_iter_and_read_range_or_throw( mp_iters.begin_, mp_iters.end_, value );
+ }
+}
+
+#endif
diff --git a/bitcoin/src/json/json_spirit_stream_reader.h b/bitcoin/src/json/json_spirit_stream_reader.h
@@ -0,0 +1,70 @@
+#ifndef JSON_SPIRIT_READ_STREAM
+#define JSON_SPIRIT_READ_STREAM
+
+// Copyright John W. Wilkinson 2007 - 2009.
+// Distributed under the MIT License, see accompanying file LICENSE.txt
+
+// json spirit version 4.03
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include "json_spirit_reader_template.h"
+
+namespace json_spirit
+{
+ // these classes allows you to read multiple top level contiguous values from a stream,
+ // the normal stream read functions have a bug that prevent multiple top level values
+ // from being read unless they are separated by spaces
+
+ template< class Istream_type, class Value_type >
+ class Stream_reader
+ {
+ public:
+
+ Stream_reader( Istream_type& is )
+ : iters_( is )
+ {
+ }
+
+ bool read_next( Value_type& value )
+ {
+ return read_range( iters_.begin_, iters_.end_, value );
+ }
+
+ private:
+
+ typedef Multi_pass_iters< Istream_type > Mp_iters;
+
+ Mp_iters iters_;
+ };
+
+ template< class Istream_type, class Value_type >
+ class Stream_reader_thrower
+ {
+ public:
+
+ Stream_reader_thrower( Istream_type& is )
+ : iters_( is )
+ , posn_begin_( iters_.begin_, iters_.end_ )
+ , posn_end_( iters_.end_, iters_.end_ )
+ {
+ }
+
+ void read_next( Value_type& value )
+ {
+ posn_begin_ = read_range_or_throw( posn_begin_, posn_end_, value );
+ }
+
+ private:
+
+ typedef Multi_pass_iters< Istream_type > Mp_iters;
+ typedef spirit_namespace::position_iterator< typename Mp_iters::Mp_iter > Posn_iter_t;
+
+ Mp_iters iters_;
+ Posn_iter_t posn_begin_, posn_end_;
+ };
+}
+
+#endif
diff --git a/bitcoin/src/json/json_spirit_utils.h b/bitcoin/src/json/json_spirit_utils.h
@@ -0,0 +1,61 @@
+#ifndef JSON_SPIRIT_UTILS
+#define JSON_SPIRIT_UTILS
+
+// Copyright John W. Wilkinson 2007 - 2009.
+// Distributed under the MIT License, see accompanying file LICENSE.txt
+
+// json spirit version 4.03
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include "json_spirit_value.h"
+#include <map>
+
+namespace json_spirit
+{
+ template< class Obj_t, class Map_t >
+ void obj_to_map( const Obj_t& obj, Map_t& mp_obj )
+ {
+ mp_obj.clear();
+
+ for( typename Obj_t::const_iterator i = obj.begin(); i != obj.end(); ++i )
+ {
+ mp_obj[ i->name_ ] = i->value_;
+ }
+ }
+
+ template< class Obj_t, class Map_t >
+ void map_to_obj( const Map_t& mp_obj, Obj_t& obj )
+ {
+ obj.clear();
+
+ for( typename Map_t::const_iterator i = mp_obj.begin(); i != mp_obj.end(); ++i )
+ {
+ obj.push_back( typename Obj_t::value_type( i->first, i->second ) );
+ }
+ }
+
+ typedef std::map< std::string, Value > Mapped_obj;
+
+#ifndef BOOST_NO_STD_WSTRING
+ typedef std::map< std::wstring, wValue > wMapped_obj;
+#endif
+
+ template< class Object_type, class String_type >
+ const typename Object_type::value_type::Value_type& find_value( const Object_type& obj, const String_type& name )
+ {
+ for( typename Object_type::const_iterator i = obj.begin(); i != obj.end(); ++i )
+ {
+ if( i->name_ == name )
+ {
+ return i->value_;
+ }
+ }
+
+ return Object_type::value_type::Value_type::null;
+ }
+}
+
+#endif
diff --git a/bitcoin/src/json/json_spirit_value.cpp b/bitcoin/src/json/json_spirit_value.cpp
@@ -0,0 +1,8 @@
+/* Copyright (c) 2007 John W Wilkinson
+
+ This source code can be used for any purpose as long as
+ this comment is retained. */
+
+// json spirit version 2.00
+
+#include "json_spirit_value.h"
diff --git a/bitcoin/src/json/json_spirit_value.h b/bitcoin/src/json/json_spirit_value.h
@@ -0,0 +1,534 @@
+#ifndef JSON_SPIRIT_VALUE
+#define JSON_SPIRIT_VALUE
+
+// Copyright John W. Wilkinson 2007 - 2009.
+// Distributed under the MIT License, see accompanying file LICENSE.txt
+
+// json spirit version 4.03
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <vector>
+#include <map>
+#include <string>
+#include <cassert>
+#include <sstream>
+#include <stdexcept>
+#include <boost/config.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/variant.hpp>
+
+namespace json_spirit
+{
+ enum Value_type{ obj_type, array_type, str_type, bool_type, int_type, real_type, null_type };
+ static const char* Value_type_name[]={"obj", "array", "str", "bool", "int", "real", "null"};
+
+ template< class Config > // Config determines whether the value uses std::string or std::wstring and
+ // whether JSON Objects are represented as vectors or maps
+ class Value_impl
+ {
+ public:
+
+ typedef Config Config_type;
+ typedef typename Config::String_type String_type;
+ typedef typename Config::Object_type Object;
+ typedef typename Config::Array_type Array;
+ typedef typename String_type::const_pointer Const_str_ptr; // eg const char*
+
+ Value_impl(); // creates null value
+ Value_impl( Const_str_ptr value );
+ Value_impl( const String_type& value );
+ Value_impl( const Object& value );
+ Value_impl( const Array& value );
+ Value_impl( bool value );
+ Value_impl( int value );
+ Value_impl( boost::int64_t value );
+ Value_impl( boost::uint64_t value );
+ Value_impl( double value );
+
+ Value_impl( const Value_impl& other );
+
+ bool operator==( const Value_impl& lhs ) const;
+
+ Value_impl& operator=( const Value_impl& lhs );
+
+ Value_type type() const;
+
+ bool is_uint64() const;
+ bool is_null() const;
+
+ const String_type& get_str() const;
+ const Object& get_obj() const;
+ const Array& get_array() const;
+ bool get_bool() const;
+ int get_int() const;
+ boost::int64_t get_int64() const;
+ boost::uint64_t get_uint64() const;
+ double get_real() const;
+
+ Object& get_obj();
+ Array& get_array();
+
+ template< typename T > T get_value() const; // example usage: int i = value.get_value< int >();
+ // or double d = value.get_value< double >();
+
+ static const Value_impl null;
+
+ private:
+
+ void check_type( const Value_type vtype ) const;
+
+ typedef boost::variant< String_type,
+ boost::recursive_wrapper< Object >, boost::recursive_wrapper< Array >,
+ bool, boost::int64_t, double > Variant;
+
+ Value_type type_;
+ Variant v_;
+ bool is_uint64_;
+ };
+
+ // vector objects
+
+ template< class Config >
+ struct Pair_impl
+ {
+ typedef typename Config::String_type String_type;
+ typedef typename Config::Value_type Value_type;
+
+ Pair_impl( const String_type& name, const Value_type& value );
+
+ bool operator==( const Pair_impl& lhs ) const;
+
+ String_type name_;
+ Value_type value_;
+ };
+
+ template< class String >
+ struct Config_vector
+ {
+ typedef String String_type;
+ typedef Value_impl< Config_vector > Value_type;
+ typedef Pair_impl < Config_vector > Pair_type;
+ typedef std::vector< Value_type > Array_type;
+ typedef std::vector< Pair_type > Object_type;
+
+ static Value_type& add( Object_type& obj, const String_type& name, const Value_type& value )
+ {
+ obj.push_back( Pair_type( name , value ) );
+
+ return obj.back().value_;
+ }
+
+ static String_type get_name( const Pair_type& pair )
+ {
+ return pair.name_;
+ }
+
+ static Value_type get_value( const Pair_type& pair )
+ {
+ return pair.value_;
+ }
+ };
+
+ // typedefs for ASCII
+
+ typedef Config_vector< std::string > Config;
+
+ typedef Config::Value_type Value;
+ typedef Config::Pair_type Pair;
+ typedef Config::Object_type Object;
+ typedef Config::Array_type Array;
+
+ // typedefs for Unicode
+
+#ifndef BOOST_NO_STD_WSTRING
+
+ typedef Config_vector< std::wstring > wConfig;
+
+ typedef wConfig::Value_type wValue;
+ typedef wConfig::Pair_type wPair;
+ typedef wConfig::Object_type wObject;
+ typedef wConfig::Array_type wArray;
+#endif
+
+ // map objects
+
+ template< class String >
+ struct Config_map
+ {
+ typedef String String_type;
+ typedef Value_impl< Config_map > Value_type;
+ typedef std::vector< Value_type > Array_type;
+ typedef std::map< String_type, Value_type > Object_type;
+ typedef typename Object_type::value_type Pair_type;
+
+ static Value_type& add( Object_type& obj, const String_type& name, const Value_type& value )
+ {
+ return obj[ name ] = value;
+ }
+
+ static String_type get_name( const Pair_type& pair )
+ {
+ return pair.first;
+ }
+
+ static Value_type get_value( const Pair_type& pair )
+ {
+ return pair.second;
+ }
+ };
+
+ // typedefs for ASCII
+
+ typedef Config_map< std::string > mConfig;
+
+ typedef mConfig::Value_type mValue;
+ typedef mConfig::Object_type mObject;
+ typedef mConfig::Array_type mArray;
+
+ // typedefs for Unicode
+
+#ifndef BOOST_NO_STD_WSTRING
+
+ typedef Config_map< std::wstring > wmConfig;
+
+ typedef wmConfig::Value_type wmValue;
+ typedef wmConfig::Object_type wmObject;
+ typedef wmConfig::Array_type wmArray;
+
+#endif
+
+ ///////////////////////////////////////////////////////////////////////////////////////////////
+ //
+ // implementation
+
+ template< class Config >
+ const Value_impl< Config > Value_impl< Config >::null;
+
+ template< class Config >
+ Value_impl< Config >::Value_impl()
+ : type_( null_type )
+ , is_uint64_( false )
+ {
+ }
+
+ template< class Config >
+ Value_impl< Config >::Value_impl( const Const_str_ptr value )
+ : type_( str_type )
+ , v_( String_type( value ) )
+ , is_uint64_( false )
+ {
+ }
+
+ template< class Config >
+ Value_impl< Config >::Value_impl( const String_type& value )
+ : type_( str_type )
+ , v_( value )
+ , is_uint64_( false )
+ {
+ }
+
+ template< class Config >
+ Value_impl< Config >::Value_impl( const Object& value )
+ : type_( obj_type )
+ , v_( value )
+ , is_uint64_( false )
+ {
+ }
+
+ template< class Config >
+ Value_impl< Config >::Value_impl( const Array& value )
+ : type_( array_type )
+ , v_( value )
+ , is_uint64_( false )
+ {
+ }
+
+ template< class Config >
+ Value_impl< Config >::Value_impl( bool value )
+ : type_( bool_type )
+ , v_( value )
+ , is_uint64_( false )
+ {
+ }
+
+ template< class Config >
+ Value_impl< Config >::Value_impl( int value )
+ : type_( int_type )
+ , v_( static_cast< boost::int64_t >( value ) )
+ , is_uint64_( false )
+ {
+ }
+
+ template< class Config >
+ Value_impl< Config >::Value_impl( boost::int64_t value )
+ : type_( int_type )
+ , v_( value )
+ , is_uint64_( false )
+ {
+ }
+
+ template< class Config >
+ Value_impl< Config >::Value_impl( boost::uint64_t value )
+ : type_( int_type )
+ , v_( static_cast< boost::int64_t >( value ) )
+ , is_uint64_( true )
+ {
+ }
+
+ template< class Config >
+ Value_impl< Config >::Value_impl( double value )
+ : type_( real_type )
+ , v_( value )
+ , is_uint64_( false )
+ {
+ }
+
+ template< class Config >
+ Value_impl< Config >::Value_impl( const Value_impl< Config >& other )
+ : type_( other.type() )
+ , v_( other.v_ )
+ , is_uint64_( other.is_uint64_ )
+ {
+ }
+
+ template< class Config >
+ Value_impl< Config >& Value_impl< Config >::operator=( const Value_impl& lhs )
+ {
+ Value_impl tmp( lhs );
+
+ std::swap( type_, tmp.type_ );
+ std::swap( v_, tmp.v_ );
+ std::swap( is_uint64_, tmp.is_uint64_ );
+
+ return *this;
+ }
+
+ template< class Config >
+ bool Value_impl< Config >::operator==( const Value_impl& lhs ) const
+ {
+ if( this == &lhs ) return true;
+
+ if( type() != lhs.type() ) return false;
+
+ return v_ == lhs.v_;
+ }
+
+ template< class Config >
+ Value_type Value_impl< Config >::type() const
+ {
+ return type_;
+ }
+
+ template< class Config >
+ bool Value_impl< Config >::is_uint64() const
+ {
+ return is_uint64_;
+ }
+
+ template< class Config >
+ bool Value_impl< Config >::is_null() const
+ {
+ return type() == null_type;
+ }
+
+ template< class Config >
+ void Value_impl< Config >::check_type( const Value_type vtype ) const
+ {
+ if( type() != vtype )
+ {
+ std::ostringstream os;
+
+ ///// Bitcoin: Tell the types by name instead of by number
+ os << "value is type " << Value_type_name[type()] << ", expected " << Value_type_name[vtype];
+
+ throw std::runtime_error( os.str() );
+ }
+ }
+
+ template< class Config >
+ const typename Config::String_type& Value_impl< Config >::get_str() const
+ {
+ check_type( str_type );
+
+ return *boost::get< String_type >( &v_ );
+ }
+
+ template< class Config >
+ const typename Value_impl< Config >::Object& Value_impl< Config >::get_obj() const
+ {
+ check_type( obj_type );
+
+ return *boost::get< Object >( &v_ );
+ }
+
+ template< class Config >
+ const typename Value_impl< Config >::Array& Value_impl< Config >::get_array() const
+ {
+ check_type( array_type );
+
+ return *boost::get< Array >( &v_ );
+ }
+
+ template< class Config >
+ bool Value_impl< Config >::get_bool() const
+ {
+ check_type( bool_type );
+
+ return boost::get< bool >( v_ );
+ }
+
+ template< class Config >
+ int Value_impl< Config >::get_int() const
+ {
+ check_type( int_type );
+
+ return static_cast< int >( get_int64() );
+ }
+
+ template< class Config >
+ boost::int64_t Value_impl< Config >::get_int64() const
+ {
+ check_type( int_type );
+
+ return boost::get< boost::int64_t >( v_ );
+ }
+
+ template< class Config >
+ boost::uint64_t Value_impl< Config >::get_uint64() const
+ {
+ check_type( int_type );
+
+ return static_cast< boost::uint64_t >( get_int64() );
+ }
+
+ template< class Config >
+ double Value_impl< Config >::get_real() const
+ {
+ if( type() == int_type )
+ {
+ return is_uint64() ? static_cast< double >( get_uint64() )
+ : static_cast< double >( get_int64() );
+ }
+
+ check_type( real_type );
+
+ return boost::get< double >( v_ );
+ }
+
+ template< class Config >
+ typename Value_impl< Config >::Object& Value_impl< Config >::get_obj()
+ {
+ check_type( obj_type );
+
+ return *boost::get< Object >( &v_ );
+ }
+
+ template< class Config >
+ typename Value_impl< Config >::Array& Value_impl< Config >::get_array()
+ {
+ check_type( array_type );
+
+ return *boost::get< Array >( &v_ );
+ }
+
+ template< class Config >
+ Pair_impl< Config >::Pair_impl( const String_type& name, const Value_type& value )
+ : name_( name )
+ , value_( value )
+ {
+ }
+
+ template< class Config >
+ bool Pair_impl< Config >::operator==( const Pair_impl< Config >& lhs ) const
+ {
+ if( this == &lhs ) return true;
+
+ return ( name_ == lhs.name_ ) && ( value_ == lhs.value_ );
+ }
+
+ // converts a C string, ie. 8 bit char array, to a string object
+ //
+ template < class String_type >
+ String_type to_str( const char* c_str )
+ {
+ String_type result;
+
+ for( const char* p = c_str; *p != 0; ++p )
+ {
+ result += *p;
+ }
+
+ return result;
+ }
+
+ //
+
+ namespace internal_
+ {
+ template< typename T >
+ struct Type_to_type
+ {
+ };
+
+ template< class Value >
+ int get_value( const Value& value, Type_to_type< int > )
+ {
+ return value.get_int();
+ }
+
+ template< class Value >
+ boost::int64_t get_value( const Value& value, Type_to_type< boost::int64_t > )
+ {
+ return value.get_int64();
+ }
+
+ template< class Value >
+ boost::uint64_t get_value( const Value& value, Type_to_type< boost::uint64_t > )
+ {
+ return value.get_uint64();
+ }
+
+ template< class Value >
+ double get_value( const Value& value, Type_to_type< double > )
+ {
+ return value.get_real();
+ }
+
+ template< class Value >
+ typename Value::String_type get_value( const Value& value, Type_to_type< typename Value::String_type > )
+ {
+ return value.get_str();
+ }
+
+ template< class Value >
+ typename Value::Array get_value( const Value& value, Type_to_type< typename Value::Array > )
+ {
+ return value.get_array();
+ }
+
+ template< class Value >
+ typename Value::Object get_value( const Value& value, Type_to_type< typename Value::Object > )
+ {
+ return value.get_obj();
+ }
+
+ template< class Value >
+ bool get_value( const Value& value, Type_to_type< bool > )
+ {
+ return value.get_bool();
+ }
+ }
+
+ template< class Config >
+ template< typename T >
+ T Value_impl< Config >::get_value() const
+ {
+ return internal_::get_value( *this, internal_::Type_to_type< T >() );
+ }
+}
+
+#endif
diff --git a/bitcoin/src/json/json_spirit_writer.cpp b/bitcoin/src/json/json_spirit_writer.cpp
@@ -0,0 +1,95 @@
+// Copyright John W. Wilkinson 2007 - 2009.
+// Distributed under the MIT License, see accompanying file LICENSE.txt
+
+// json spirit version 4.03
+
+#include "json_spirit_writer.h"
+#include "json_spirit_writer_template.h"
+
+void json_spirit::write( const Value& value, std::ostream& os )
+{
+ write_stream( value, os, false );
+}
+
+void json_spirit::write_formatted( const Value& value, std::ostream& os )
+{
+ write_stream( value, os, true );
+}
+
+std::string json_spirit::write( const Value& value )
+{
+ return write_string( value, false );
+}
+
+std::string json_spirit::write_formatted( const Value& value )
+{
+ return write_string( value, true );
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+
+void json_spirit::write( const wValue& value, std::wostream& os )
+{
+ write_stream( value, os, false );
+}
+
+void json_spirit::write_formatted( const wValue& value, std::wostream& os )
+{
+ write_stream( value, os, true );
+}
+
+std::wstring json_spirit::write( const wValue& value )
+{
+ return write_string( value, false );
+}
+
+std::wstring json_spirit::write_formatted( const wValue& value )
+{
+ return write_string( value, true );
+}
+
+#endif
+
+void json_spirit::write( const mValue& value, std::ostream& os )
+{
+ write_stream( value, os, false );
+}
+
+void json_spirit::write_formatted( const mValue& value, std::ostream& os )
+{
+ write_stream( value, os, true );
+}
+
+std::string json_spirit::write( const mValue& value )
+{
+ return write_string( value, false );
+}
+
+std::string json_spirit::write_formatted( const mValue& value )
+{
+ return write_string( value, true );
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+
+void json_spirit::write( const wmValue& value, std::wostream& os )
+{
+ write_stream( value, os, false );
+}
+
+void json_spirit::write_formatted( const wmValue& value, std::wostream& os )
+{
+ write_stream( value, os, true );
+}
+
+std::wstring json_spirit::write( const wmValue& value )
+{
+ return write_string( value, false );
+}
+
+std::wstring json_spirit::write_formatted( const wmValue& value )
+{
+ return write_string( value, true );
+}
+
+#endif
diff --git a/bitcoin/src/json/json_spirit_writer.h b/bitcoin/src/json/json_spirit_writer.h
@@ -0,0 +1,50 @@
+#ifndef JSON_SPIRIT_WRITER
+#define JSON_SPIRIT_WRITER
+
+// Copyright John W. Wilkinson 2007 - 2009.
+// Distributed under the MIT License, see accompanying file LICENSE.txt
+
+// json spirit version 4.03
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include "json_spirit_value.h"
+#include <iostream>
+
+namespace json_spirit
+{
+ // functions to convert JSON Values to text,
+ // the "formatted" versions add whitespace to format the output nicely
+
+ void write ( const Value& value, std::ostream& os );
+ void write_formatted( const Value& value, std::ostream& os );
+ std::string write ( const Value& value );
+ std::string write_formatted( const Value& value );
+
+#ifndef BOOST_NO_STD_WSTRING
+
+ void write ( const wValue& value, std::wostream& os );
+ void write_formatted( const wValue& value, std::wostream& os );
+ std::wstring write ( const wValue& value );
+ std::wstring write_formatted( const wValue& value );
+
+#endif
+
+ void write ( const mValue& value, std::ostream& os );
+ void write_formatted( const mValue& value, std::ostream& os );
+ std::string write ( const mValue& value );
+ std::string write_formatted( const mValue& value );
+
+#ifndef BOOST_NO_STD_WSTRING
+
+ void write ( const wmValue& value, std::wostream& os );
+ void write_formatted( const wmValue& value, std::wostream& os );
+ std::wstring write ( const wmValue& value );
+ std::wstring write_formatted( const wmValue& value );
+
+#endif
+}
+
+#endif
diff --git a/bitcoin/src/json/json_spirit_writer_template.h b/bitcoin/src/json/json_spirit_writer_template.h
@@ -0,0 +1,248 @@
+#ifndef JSON_SPIRIT_WRITER_TEMPLATE
+#define JSON_SPIRIT_WRITER_TEMPLATE
+
+// Copyright John W. Wilkinson 2007 - 2009.
+// Distributed under the MIT License, see accompanying file LICENSE.txt
+
+// json spirit version 4.03
+
+#include "json_spirit_value.h"
+
+#include <cassert>
+#include <sstream>
+#include <iomanip>
+
+namespace json_spirit
+{
+ inline char to_hex_char( unsigned int c )
+ {
+ assert( c <= 0xF );
+
+ const char ch = static_cast< char >( c );
+
+ if( ch < 10 ) return '0' + ch;
+
+ return 'A' - 10 + ch;
+ }
+
+ template< class String_type >
+ String_type non_printable_to_string( unsigned int c )
+ {
+ typedef typename String_type::value_type Char_type;
+
+ String_type result( 6, '\\' );
+
+ result[1] = 'u';
+
+ result[ 5 ] = to_hex_char( c & 0x000F ); c >>= 4;
+ result[ 4 ] = to_hex_char( c & 0x000F ); c >>= 4;
+ result[ 3 ] = to_hex_char( c & 0x000F ); c >>= 4;
+ result[ 2 ] = to_hex_char( c & 0x000F );
+
+ return result;
+ }
+
+ template< typename Char_type, class String_type >
+ bool add_esc_char( Char_type c, String_type& s )
+ {
+ switch( c )
+ {
+ case '"': s += to_str< String_type >( "\\\"" ); return true;
+ case '\\': s += to_str< String_type >( "\\\\" ); return true;
+ case '\b': s += to_str< String_type >( "\\b" ); return true;
+ case '\f': s += to_str< String_type >( "\\f" ); return true;
+ case '\n': s += to_str< String_type >( "\\n" ); return true;
+ case '\r': s += to_str< String_type >( "\\r" ); return true;
+ case '\t': s += to_str< String_type >( "\\t" ); return true;
+ }
+
+ return false;
+ }
+
+ template< class String_type >
+ String_type add_esc_chars( const String_type& s )
+ {
+ typedef typename String_type::const_iterator Iter_type;
+ typedef typename String_type::value_type Char_type;
+
+ String_type result;
+
+ const Iter_type end( s.end() );
+
+ for( Iter_type i = s.begin(); i != end; ++i )
+ {
+ const Char_type c( *i );
+
+ if( add_esc_char( c, result ) ) continue;
+
+ const wint_t unsigned_c( ( c >= 0 ) ? c : 256 + c );
+
+ if( iswprint( unsigned_c ) )
+ {
+ result += c;
+ }
+ else
+ {
+ result += non_printable_to_string< String_type >( unsigned_c );
+ }
+ }
+
+ return result;
+ }
+
+ // this class generates the JSON text,
+ // it keeps track of the indentation level etc.
+ //
+ template< class Value_type, class Ostream_type >
+ class Generator
+ {
+ typedef typename Value_type::Config_type Config_type;
+ typedef typename Config_type::String_type String_type;
+ typedef typename Config_type::Object_type Object_type;
+ typedef typename Config_type::Array_type Array_type;
+ typedef typename String_type::value_type Char_type;
+ typedef typename Object_type::value_type Obj_member_type;
+
+ public:
+
+ Generator( const Value_type& value, Ostream_type& os, bool pretty )
+ : os_( os )
+ , indentation_level_( 0 )
+ , pretty_( pretty )
+ {
+ output( value );
+ }
+
+ private:
+
+ void output( const Value_type& value )
+ {
+ switch( value.type() )
+ {
+ case obj_type: output( value.get_obj() ); break;
+ case array_type: output( value.get_array() ); break;
+ case str_type: output( value.get_str() ); break;
+ case bool_type: output( value.get_bool() ); break;
+ case int_type: output_int( value ); break;
+
+ /// Bitcoin: Added std::fixed and changed precision from 16 to 8
+ case real_type: os_ << std::showpoint << std::fixed << std::setprecision(8)
+ << value.get_real(); break;
+
+ case null_type: os_ << "null"; break;
+ default: assert( false );
+ }
+ }
+
+ void output( const Object_type& obj )
+ {
+ output_array_or_obj( obj, '{', '}' );
+ }
+
+ void output( const Array_type& arr )
+ {
+ output_array_or_obj( arr, '[', ']' );
+ }
+
+ void output( const Obj_member_type& member )
+ {
+ output( Config_type::get_name( member ) ); space();
+ os_ << ':'; space();
+ output( Config_type::get_value( member ) );
+ }
+
+ void output_int( const Value_type& value )
+ {
+ if( value.is_uint64() )
+ {
+ os_ << value.get_uint64();
+ }
+ else
+ {
+ os_ << value.get_int64();
+ }
+ }
+
+ void output( const String_type& s )
+ {
+ os_ << '"' << add_esc_chars( s ) << '"';
+ }
+
+ void output( bool b )
+ {
+ os_ << to_str< String_type >( b ? "true" : "false" );
+ }
+
+ template< class T >
+ void output_array_or_obj( const T& t, Char_type start_char, Char_type end_char )
+ {
+ os_ << start_char; new_line();
+
+ ++indentation_level_;
+
+ for( typename T::const_iterator i = t.begin(); i != t.end(); ++i )
+ {
+ indent(); output( *i );
+
+ typename T::const_iterator next = i;
+
+ if( ++next != t.end())
+ {
+ os_ << ',';
+ }
+
+ new_line();
+ }
+
+ --indentation_level_;
+
+ indent(); os_ << end_char;
+ }
+
+ void indent()
+ {
+ if( !pretty_ ) return;
+
+ for( int i = 0; i < indentation_level_; ++i )
+ {
+ os_ << " ";
+ }
+ }
+
+ void space()
+ {
+ if( pretty_ ) os_ << ' ';
+ }
+
+ void new_line()
+ {
+ if( pretty_ ) os_ << '\n';
+ }
+
+ Generator& operator=( const Generator& ); // to prevent "assignment operator could not be generated" warning
+
+ Ostream_type& os_;
+ int indentation_level_;
+ bool pretty_;
+ };
+
+ template< class Value_type, class Ostream_type >
+ void write_stream( const Value_type& value, Ostream_type& os, bool pretty )
+ {
+ Generator< Value_type, Ostream_type >( value, os, pretty );
+ }
+
+ template< class Value_type >
+ typename Value_type::String_type write_string( const Value_type& value, bool pretty )
+ {
+ typedef typename Value_type::String_type::value_type Char_type;
+
+ std::basic_ostringstream< Char_type > os;
+
+ write_stream( value, os, pretty );
+
+ return os.str();
+ }
+}
+
+#endif
diff --git a/bitcoin/src/key.h b/bitcoin/src/key.h
@@ -0,0 +1,406 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2012 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#ifndef BITCOIN_KEY_H
+#define BITCOIN_KEY_H
+
+#include <stdexcept>
+#include <vector>
+
+#include <openssl/ec.h>
+#include <openssl/ecdsa.h>
+#include <openssl/obj_mac.h>
+
+#include "serialize.h"
+#include "uint256.h"
+#include "base58.h"
+
+// secp160k1
+// const unsigned int PRIVATE_KEY_SIZE = 192;
+// const unsigned int PUBLIC_KEY_SIZE = 41;
+// const unsigned int SIGNATURE_SIZE = 48;
+//
+// secp192k1
+// const unsigned int PRIVATE_KEY_SIZE = 222;
+// const unsigned int PUBLIC_KEY_SIZE = 49;
+// const unsigned int SIGNATURE_SIZE = 57;
+//
+// secp224k1
+// const unsigned int PRIVATE_KEY_SIZE = 250;
+// const unsigned int PUBLIC_KEY_SIZE = 57;
+// const unsigned int SIGNATURE_SIZE = 66;
+//
+// secp256k1:
+// const unsigned int PRIVATE_KEY_SIZE = 279;
+// const unsigned int PUBLIC_KEY_SIZE = 65;
+// const unsigned int SIGNATURE_SIZE = 72;
+//
+// see www.keylength.com
+// script supports up to 75 for single byte push
+
+// Generate a private key from just the secret parameter
+int static inline EC_KEY_regenerate_key(EC_KEY *eckey, BIGNUM *priv_key)
+{
+ int ok = 0;
+ BN_CTX *ctx = NULL;
+ EC_POINT *pub_key = NULL;
+
+ if (!eckey) return 0;
+
+ const EC_GROUP *group = EC_KEY_get0_group(eckey);
+
+ if ((ctx = BN_CTX_new()) == NULL)
+ goto err;
+
+ pub_key = EC_POINT_new(group);
+
+ if (pub_key == NULL)
+ goto err;
+
+ if (!EC_POINT_mul(group, pub_key, priv_key, NULL, NULL, ctx))
+ goto err;
+
+ EC_KEY_set_private_key(eckey,priv_key);
+ EC_KEY_set_public_key(eckey,pub_key);
+
+ ok = 1;
+
+err:
+
+ if (pub_key)
+ EC_POINT_free(pub_key);
+ if (ctx != NULL)
+ BN_CTX_free(ctx);
+
+ return(ok);
+}
+
+// Perform ECDSA key recovery (see SEC1 4.1.6) for curves over (mod p)-fields
+// recid selects which key is recovered
+// if check is nonzero, additional checks are performed
+int static inline ECDSA_SIG_recover_key_GFp(EC_KEY *eckey, ECDSA_SIG *ecsig, const unsigned char *msg, int msglen, int recid, int check)
+{
+ if (!eckey) return 0;
+
+ int ret = 0;
+ BN_CTX *ctx = NULL;
+
+ BIGNUM *x = NULL;
+ BIGNUM *e = NULL;
+ BIGNUM *order = NULL;
+ BIGNUM *sor = NULL;
+ BIGNUM *eor = NULL;
+ BIGNUM *field = NULL;
+ EC_POINT *R = NULL;
+ EC_POINT *O = NULL;
+ EC_POINT *Q = NULL;
+ BIGNUM *rr = NULL;
+ BIGNUM *zero = NULL;
+ int n = 0;
+ int i = recid / 2;
+
+ const EC_GROUP *group = EC_KEY_get0_group(eckey);
+ if ((ctx = BN_CTX_new()) == NULL) { ret = -1; goto err; }
+ BN_CTX_start(ctx);
+ order = BN_CTX_get(ctx);
+ if (!EC_GROUP_get_order(group, order, ctx)) { ret = -2; goto err; }
+ x = BN_CTX_get(ctx);
+ if (!BN_copy(x, order)) { ret=-1; goto err; }
+ if (!BN_mul_word(x, i)) { ret=-1; goto err; }
+ if (!BN_add(x, x, ecsig->r)) { ret=-1; goto err; }
+ field = BN_CTX_get(ctx);
+ if (!EC_GROUP_get_curve_GFp(group, field, NULL, NULL, ctx)) { ret=-2; goto err; }
+ if (BN_cmp(x, field) >= 0) { ret=0; goto err; }
+ if ((R = EC_POINT_new(group)) == NULL) { ret = -2; goto err; }
+ if (!EC_POINT_set_compressed_coordinates_GFp(group, R, x, recid % 2, ctx)) { ret=0; goto err; }
+ if (check)
+ {
+ if ((O = EC_POINT_new(group)) == NULL) { ret = -2; goto err; }
+ if (!EC_POINT_mul(group, O, NULL, R, order, ctx)) { ret=-2; goto err; }
+ if (!EC_POINT_is_at_infinity(group, O)) { ret = 0; goto err; }
+ }
+ if ((Q = EC_POINT_new(group)) == NULL) { ret = -2; goto err; }
+ n = EC_GROUP_get_degree(group);
+ e = BN_CTX_get(ctx);
+ if (!BN_bin2bn(msg, msglen, e)) { ret=-1; goto err; }
+ if (8*msglen > n) BN_rshift(e, e, 8-(n & 7));
+ zero = BN_CTX_get(ctx);
+ if (!BN_zero(zero)) { ret=-1; goto err; }
+ if (!BN_mod_sub(e, zero, e, order, ctx)) { ret=-1; goto err; }
+ rr = BN_CTX_get(ctx);
+ if (!BN_mod_inverse(rr, ecsig->r, order, ctx)) { ret=-1; goto err; }
+ sor = BN_CTX_get(ctx);
+ if (!BN_mod_mul(sor, ecsig->s, rr, order, ctx)) { ret=-1; goto err; }
+ eor = BN_CTX_get(ctx);
+ if (!BN_mod_mul(eor, e, rr, order, ctx)) { ret=-1; goto err; }
+ if (!EC_POINT_mul(group, Q, eor, R, sor, ctx)) { ret=-2; goto err; }
+ if (!EC_KEY_set_public_key(eckey, Q)) { ret=-2; goto err; }
+
+ ret = 1;
+
+err:
+ if (ctx) {
+ BN_CTX_end(ctx);
+ BN_CTX_free(ctx);
+ }
+ if (R != NULL) EC_POINT_free(R);
+ if (O != NULL) EC_POINT_free(O);
+ if (Q != NULL) EC_POINT_free(Q);
+ return ret;
+}
+
+class key_error : public std::runtime_error
+{
+public:
+ explicit key_error(const std::string& str) : std::runtime_error(str) {}
+};
+
+
+// secure_allocator is defined in serialize.h
+// CPrivKey is a serialized private key, with all parameters included (279 bytes)
+typedef std::vector<unsigned char, secure_allocator<unsigned char> > CPrivKey;
+// CSecret is a serialization of just the secret parameter (32 bytes)
+typedef std::vector<unsigned char, secure_allocator<unsigned char> > CSecret;
+
+class CKey
+{
+protected:
+ EC_KEY* pkey;
+ bool fSet;
+
+public:
+ CKey()
+ {
+ pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
+ if (pkey == NULL)
+ throw key_error("CKey::CKey() : EC_KEY_new_by_curve_name failed");
+ fSet = false;
+ }
+
+ CKey(const CKey& b)
+ {
+ pkey = EC_KEY_dup(b.pkey);
+ if (pkey == NULL)
+ throw key_error("CKey::CKey(const CKey&) : EC_KEY_dup failed");
+ fSet = b.fSet;
+ }
+
+ CKey& operator=(const CKey& b)
+ {
+ if (!EC_KEY_copy(pkey, b.pkey))
+ throw key_error("CKey::operator=(const CKey&) : EC_KEY_copy failed");
+ fSet = b.fSet;
+ return (*this);
+ }
+
+ ~CKey()
+ {
+ EC_KEY_free(pkey);
+ }
+
+ bool IsNull() const
+ {
+ return !fSet;
+ }
+
+ void MakeNewKey()
+ {
+ if (!EC_KEY_generate_key(pkey))
+ throw key_error("CKey::MakeNewKey() : EC_KEY_generate_key failed");
+ fSet = true;
+ }
+
+ bool SetPrivKey(const CPrivKey& vchPrivKey)
+ {
+ const unsigned char* pbegin = &vchPrivKey[0];
+ if (!d2i_ECPrivateKey(&pkey, &pbegin, vchPrivKey.size()))
+ return false;
+ fSet = true;
+ return true;
+ }
+
+ bool SetSecret(const CSecret& vchSecret)
+ {
+ EC_KEY_free(pkey);
+ pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
+ if (pkey == NULL)
+ throw key_error("CKey::SetSecret() : EC_KEY_new_by_curve_name failed");
+ if (vchSecret.size() != 32)
+ throw key_error("CKey::SetSecret() : secret must be 32 bytes");
+ BIGNUM *bn = BN_bin2bn(&vchSecret[0],32,BN_new());
+ if (bn == NULL)
+ throw key_error("CKey::SetSecret() : BN_bin2bn failed");
+ if (!EC_KEY_regenerate_key(pkey,bn))
+ {
+ BN_clear_free(bn);
+ throw key_error("CKey::SetSecret() : EC_KEY_regenerate_key failed");
+ }
+ BN_clear_free(bn);
+ fSet = true;
+ return true;
+ }
+
+ CSecret GetSecret() const
+ {
+ CSecret vchRet;
+ vchRet.resize(32);
+ const BIGNUM *bn = EC_KEY_get0_private_key(pkey);
+ int nBytes = BN_num_bytes(bn);
+ if (bn == NULL)
+ throw key_error("CKey::GetSecret() : EC_KEY_get0_private_key failed");
+ int n=BN_bn2bin(bn,&vchRet[32 - nBytes]);
+ if (n != nBytes)
+ throw key_error("CKey::GetSecret(): BN_bn2bin failed");
+ return vchRet;
+ }
+
+ CPrivKey GetPrivKey() const
+ {
+ unsigned int nSize = i2d_ECPrivateKey(pkey, NULL);
+ if (!nSize)
+ throw key_error("CKey::GetPrivKey() : i2d_ECPrivateKey failed");
+ CPrivKey vchPrivKey(nSize, 0);
+ unsigned char* pbegin = &vchPrivKey[0];
+ if (i2d_ECPrivateKey(pkey, &pbegin) != nSize)
+ throw key_error("CKey::GetPrivKey() : i2d_ECPrivateKey returned unexpected size");
+ return vchPrivKey;
+ }
+
+ bool SetPubKey(const std::vector<unsigned char>& vchPubKey)
+ {
+ const unsigned char* pbegin = &vchPubKey[0];
+ if (!o2i_ECPublicKey(&pkey, &pbegin, vchPubKey.size()))
+ return false;
+ fSet = true;
+ return true;
+ }
+
+ std::vector<unsigned char> GetPubKey() const
+ {
+ unsigned int nSize = i2o_ECPublicKey(pkey, NULL);
+ if (!nSize)
+ throw key_error("CKey::GetPubKey() : i2o_ECPublicKey failed");
+ std::vector<unsigned char> vchPubKey(nSize, 0);
+ unsigned char* pbegin = &vchPubKey[0];
+ if (i2o_ECPublicKey(pkey, &pbegin) != nSize)
+ throw key_error("CKey::GetPubKey() : i2o_ECPublicKey returned unexpected size");
+ return vchPubKey;
+ }
+
+ bool Sign(uint256 hash, std::vector<unsigned char>& vchSig)
+ {
+ vchSig.clear();
+ unsigned char pchSig[10000];
+ unsigned int nSize = 0;
+ if (!ECDSA_sign(0, (unsigned char*)&hash, sizeof(hash), pchSig, &nSize, pkey))
+ return false;
+ vchSig.resize(nSize);
+ memcpy(&vchSig[0], pchSig, nSize);
+ return true;
+ }
+
+ // create a compact signature (65 bytes), which allows reconstructing the used public key
+ // The format is one header byte, followed by two times 32 bytes for the serialized r and s values.
+ // The header byte: 0x1B = first key with even y, 0x1C = first key with odd y,
+ // 0x1D = second key with even y, 0x1E = second key with odd y
+ bool SignCompact(uint256 hash, std::vector<unsigned char>& vchSig)
+ {
+ bool fOk = false;
+ ECDSA_SIG *sig = ECDSA_do_sign((unsigned char*)&hash, sizeof(hash), pkey);
+ if (sig==NULL)
+ return false;
+ vchSig.clear();
+ vchSig.resize(65,0);
+ int nBitsR = BN_num_bits(sig->r);
+ int nBitsS = BN_num_bits(sig->s);
+ if (nBitsR <= 256 && nBitsS <= 256)
+ {
+ int nRecId = -1;
+ for (int i=0; i<4; i++)
+ {
+ CKey keyRec;
+ keyRec.fSet = true;
+ if (ECDSA_SIG_recover_key_GFp(keyRec.pkey, sig, (unsigned char*)&hash, sizeof(hash), i, 1) == 1)
+ if (keyRec.GetPubKey() == this->GetPubKey())
+ {
+ nRecId = i;
+ break;
+ }
+ }
+
+ if (nRecId == -1)
+ throw key_error("CKey::SignCompact() : unable to construct recoverable key");
+
+ vchSig[0] = nRecId+27;
+ BN_bn2bin(sig->r,&vchSig[33-(nBitsR+7)/8]);
+ BN_bn2bin(sig->s,&vchSig[65-(nBitsS+7)/8]);
+ fOk = true;
+ }
+ ECDSA_SIG_free(sig);
+ return fOk;
+ }
+
+ // reconstruct public key from a compact signature
+ // This is only slightly more CPU intensive than just verifying it.
+ // If this function succeeds, the recovered public key is guaranteed to be valid
+ // (the signature is a valid signature of the given data for that key)
+ bool SetCompactSignature(uint256 hash, const std::vector<unsigned char>& vchSig)
+ {
+ if (vchSig.size() != 65)
+ return false;
+ if (vchSig[0]<27 || vchSig[0]>=31)
+ return false;
+ ECDSA_SIG *sig = ECDSA_SIG_new();
+ BN_bin2bn(&vchSig[1],32,sig->r);
+ BN_bin2bn(&vchSig[33],32,sig->s);
+
+ EC_KEY_free(pkey);
+ pkey = EC_KEY_new_by_curve_name(NID_secp256k1);
+ if (ECDSA_SIG_recover_key_GFp(pkey, sig, (unsigned char*)&hash, sizeof(hash), vchSig[0] - 27, 0) == 1)
+ {
+ fSet = true;
+ ECDSA_SIG_free(sig);
+ return true;
+ }
+ return false;
+ }
+
+ bool Verify(uint256 hash, const std::vector<unsigned char>& vchSig)
+ {
+ // -1 = error, 0 = bad sig, 1 = good
+ if (ECDSA_verify(0, (unsigned char*)&hash, sizeof(hash), &vchSig[0], vchSig.size(), pkey) != 1)
+ return false;
+ return true;
+ }
+
+ // Verify a compact signature
+ bool VerifyCompact(uint256 hash, const std::vector<unsigned char>& vchSig)
+ {
+ CKey key;
+ if (!key.SetCompactSignature(hash, vchSig))
+ return false;
+ if (GetPubKey() != key.GetPubKey())
+ return false;
+ return true;
+ }
+
+ // Get the address corresponding to this key
+ CBitcoinAddress GetAddress() const
+ {
+ return CBitcoinAddress(GetPubKey());
+ }
+
+ bool IsValid()
+ {
+ if (!fSet)
+ return false;
+
+ CSecret secret = GetSecret();
+ CKey key2;
+ key2.SetSecret(secret);
+ return GetPubKey() == key2.GetPubKey();
+ }
+};
+
+#endif
diff --git a/bitcoin/src/keystore.cpp b/bitcoin/src/keystore.cpp
@@ -0,0 +1,181 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2011 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+#include "headers.h"
+#include "db.h"
+#include "crypter.h"
+
+std::vector<unsigned char> CKeyStore::GenerateNewKey()
+{
+ RandAddSeedPerfmon();
+ CKey key;
+ key.MakeNewKey();
+ if (!AddKey(key))
+ throw std::runtime_error("CKeyStore::GenerateNewKey() : AddKey failed");
+ return key.GetPubKey();
+}
+
+bool CKeyStore::GetPubKey(const CBitcoinAddress &address, std::vector<unsigned char> &vchPubKeyOut) const
+{
+ CKey key;
+ if (!GetKey(address, key))
+ return false;
+ vchPubKeyOut = key.GetPubKey();
+ return true;
+}
+
+bool CBasicKeyStore::AddKey(const CKey& key)
+{
+ CRITICAL_BLOCK(cs_KeyStore)
+ mapKeys[key.GetAddress()] = key.GetSecret();
+ return true;
+}
+
+bool CCryptoKeyStore::SetCrypted()
+{
+ CRITICAL_BLOCK(cs_KeyStore)
+ {
+ if (fUseCrypto)
+ return true;
+ if (!mapKeys.empty())
+ return false;
+ fUseCrypto = true;
+ }
+ return true;
+}
+
+std::vector<unsigned char> CCryptoKeyStore::GenerateNewKey()
+{
+ RandAddSeedPerfmon();
+ CKey key;
+ key.MakeNewKey();
+ if (!AddKey(key))
+ throw std::runtime_error("CCryptoKeyStore::GenerateNewKey() : AddKey failed");
+ return key.GetPubKey();
+}
+
+bool CCryptoKeyStore::Unlock(const CKeyingMaterial& vMasterKeyIn)
+{
+ CRITICAL_BLOCK(cs_KeyStore)
+ {
+ if (!SetCrypted())
+ return false;
+
+ CryptedKeyMap::const_iterator mi = mapCryptedKeys.begin();
+ for (; mi != mapCryptedKeys.end(); ++mi)
+ {
+ const std::vector<unsigned char> &vchPubKey = (*mi).second.first;
+ const std::vector<unsigned char> &vchCryptedSecret = (*mi).second.second;
+ CSecret vchSecret;
+ if(!DecryptSecret(vMasterKeyIn, vchCryptedSecret, Hash(vchPubKey.begin(), vchPubKey.end()), vchSecret))
+ return false;
+ CKey key;
+ key.SetSecret(vchSecret);
+ if (key.GetPubKey() == vchPubKey)
+ break;
+ return false;
+ }
+ vMasterKey = vMasterKeyIn;
+ }
+ return true;
+}
+
+bool CCryptoKeyStore::AddKey(const CKey& key)
+{
+ CRITICAL_BLOCK(cs_KeyStore)
+ {
+ if (!IsCrypted())
+ return CBasicKeyStore::AddKey(key);
+
+ if (IsLocked())
+ return false;
+
+ std::vector<unsigned char> vchCryptedSecret;
+ std::vector<unsigned char> vchPubKey = key.GetPubKey();
+ if (!EncryptSecret(vMasterKey, key.GetSecret(), Hash(vchPubKey.begin(), vchPubKey.end()), vchCryptedSecret))
+ return false;
+
+ if (!AddCryptedKey(key.GetPubKey(), vchCryptedSecret))
+ return false;
+ }
+ return true;
+}
+
+
+bool CCryptoKeyStore::AddCryptedKey(const std::vector<unsigned char> &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret)
+{
+ CRITICAL_BLOCK(cs_KeyStore)
+ {
+ if (!SetCrypted())
+ return false;
+
+ mapCryptedKeys[CBitcoinAddress(vchPubKey)] = make_pair(vchPubKey, vchCryptedSecret);
+ }
+ return true;
+}
+
+bool CCryptoKeyStore::GetKey(const CBitcoinAddress &address, CKey& keyOut) const
+{
+ CRITICAL_BLOCK(cs_KeyStore)
+ {
+ if (!IsCrypted())
+ return CBasicKeyStore::GetKey(address, keyOut);
+
+ CryptedKeyMap::const_iterator mi = mapCryptedKeys.find(address);
+ if (mi != mapCryptedKeys.end())
+ {
+ const std::vector<unsigned char> &vchPubKey = (*mi).second.first;
+ const std::vector<unsigned char> &vchCryptedSecret = (*mi).second.second;
+ CSecret vchSecret;
+ if (!DecryptSecret(vMasterKey, vchCryptedSecret, Hash(vchPubKey.begin(), vchPubKey.end()), vchSecret))
+ return false;
+ keyOut.SetSecret(vchSecret);
+ return true;
+ }
+ }
+ return false;
+}
+
+bool CCryptoKeyStore::GetPubKey(const CBitcoinAddress &address, std::vector<unsigned char>& vchPubKeyOut) const
+{
+ CRITICAL_BLOCK(cs_KeyStore)
+ {
+ if (!IsCrypted())
+ return CKeyStore::GetPubKey(address, vchPubKeyOut);
+
+ CryptedKeyMap::const_iterator mi = mapCryptedKeys.find(address);
+ if (mi != mapCryptedKeys.end())
+ {
+ vchPubKeyOut = (*mi).second.first;
+ return true;
+ }
+ }
+ return false;
+}
+
+bool CCryptoKeyStore::EncryptKeys(CKeyingMaterial& vMasterKeyIn)
+{
+ CRITICAL_BLOCK(cs_KeyStore)
+ {
+ if (!mapCryptedKeys.empty() || IsCrypted())
+ return false;
+
+ fUseCrypto = true;
+ CKey key;
+ BOOST_FOREACH(KeyMap::value_type& mKey, mapKeys)
+ {
+ if (!key.SetSecret(mKey.second))
+ return false;
+ const std::vector<unsigned char> vchPubKey = key.GetPubKey();
+ std::vector<unsigned char> vchCryptedSecret;
+ if (!EncryptSecret(vMasterKeyIn, key.GetSecret(), Hash(vchPubKey.begin(), vchPubKey.end()), vchCryptedSecret))
+ return false;
+ if (!AddCryptedKey(vchPubKey, vchCryptedSecret))
+ return false;
+ }
+ mapKeys.clear();
+ }
+ return true;
+}
diff --git a/bitcoin/src/keystore.h b/bitcoin/src/keystore.h
@@ -0,0 +1,138 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2011 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#ifndef BITCOIN_KEYSTORE_H
+#define BITCOIN_KEYSTORE_H
+
+#include "crypter.h"
+
+// A virtual base class for key stores
+class CKeyStore
+{
+protected:
+ mutable CCriticalSection cs_KeyStore;
+
+public:
+ // Add a key to the store.
+ virtual bool AddKey(const CKey& key) =0;
+
+ // Check whether a key corresponding to a given address is present in the store.
+ virtual bool HaveKey(const CBitcoinAddress &address) const =0;
+
+ // Retrieve a key corresponding to a given address from the store.
+ // Return true if succesful.
+ virtual bool GetKey(const CBitcoinAddress &address, CKey& keyOut) const =0;
+
+ // Retrieve only the public key corresponding to a given address.
+ // This may succeed even if GetKey fails (e.g., encrypted wallets)
+ virtual bool GetPubKey(const CBitcoinAddress &address, std::vector<unsigned char>& vchPubKeyOut) const;
+
+ // Generate a new key, and add it to the store
+ virtual std::vector<unsigned char> GenerateNewKey();
+};
+
+typedef std::map<CBitcoinAddress, CSecret> KeyMap;
+
+// Basic key store, that keeps keys in an address->secret map
+class CBasicKeyStore : public CKeyStore
+{
+protected:
+ KeyMap mapKeys;
+
+public:
+ bool AddKey(const CKey& key);
+ bool HaveKey(const CBitcoinAddress &address) const
+ {
+ bool result;
+ CRITICAL_BLOCK(cs_KeyStore)
+ result = (mapKeys.count(address) > 0);
+ return result;
+ }
+ bool GetKey(const CBitcoinAddress &address, CKey& keyOut) const
+ {
+ CRITICAL_BLOCK(cs_KeyStore)
+ {
+ KeyMap::const_iterator mi = mapKeys.find(address);
+ if (mi != mapKeys.end())
+ {
+ keyOut.SetSecret((*mi).second);
+ return true;
+ }
+ }
+ return false;
+ }
+};
+
+typedef std::map<CBitcoinAddress, std::pair<std::vector<unsigned char>, std::vector<unsigned char> > > CryptedKeyMap;
+
+// Keystore which keeps the private keys encrypted
+// It derives from the basic key store, which is used if no encryption is active.
+class CCryptoKeyStore : public CBasicKeyStore
+{
+private:
+ CryptedKeyMap mapCryptedKeys;
+
+ CKeyingMaterial vMasterKey;
+
+ // if fUseCrypto is true, mapKeys must be empty
+ // if fUseCrypto is false, vMasterKey must be empty
+ bool fUseCrypto;
+
+protected:
+ bool SetCrypted();
+
+ // will encrypt previously unencrypted keys
+ bool EncryptKeys(CKeyingMaterial& vMasterKeyIn);
+
+ bool Unlock(const CKeyingMaterial& vMasterKeyIn);
+
+public:
+ CCryptoKeyStore() : fUseCrypto(false)
+ {
+ }
+
+ bool IsCrypted() const
+ {
+ return fUseCrypto;
+ }
+
+ bool IsLocked() const
+ {
+ if (!IsCrypted())
+ return false;
+ bool result;
+ CRITICAL_BLOCK(cs_KeyStore)
+ result = vMasterKey.empty();
+ return result;
+ }
+
+ bool Lock()
+ {
+ if (!SetCrypted())
+ return false;
+
+ CRITICAL_BLOCK(cs_KeyStore)
+ vMasterKey.clear();
+
+ return true;
+ }
+
+ virtual bool AddCryptedKey(const std::vector<unsigned char> &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret);
+ std::vector<unsigned char> GenerateNewKey();
+ bool AddKey(const CKey& key);
+ bool HaveKey(const CBitcoinAddress &address) const
+ {
+ CRITICAL_BLOCK(cs_KeyStore)
+ {
+ if (!IsCrypted())
+ return CBasicKeyStore::HaveKey(address);
+ return mapCryptedKeys.count(address) > 0;
+ }
+ return false;
+ }
+ bool GetKey(const CBitcoinAddress &address, CKey& keyOut) const;
+ bool GetPubKey(const CBitcoinAddress &address, std::vector<unsigned char>& vchPubKeyOut) const;
+};
+
+#endif
diff --git a/bitcoin/src/main.cpp b/bitcoin/src/main.cpp
@@ -0,0 +1,3250 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2012 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#include "headers.h"
+#include "checkpoints.h"
+#include "db.h"
+#include "net.h"
+#include "init.h"
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+
+using namespace std;
+using namespace boost;
+
+//
+// Global state
+//
+
+CCriticalSection cs_setpwalletRegistered;
+set<CWallet*> setpwalletRegistered;
+
+CCriticalSection cs_main;
+
+static map<uint256, CTransaction> mapTransactions;
+CCriticalSection cs_mapTransactions;
+unsigned int nTransactionsUpdated = 0;
+map<COutPoint, CInPoint> mapNextTx;
+
+map<uint256, CBlockIndex*> mapBlockIndex;
+uint256 hashGenesisBlock("0x000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f");
+static CBigNum bnProofOfWorkLimit(~uint256(0) >> 32);
+CBlockIndex* pindexGenesisBlock = NULL;
+int nBestHeight = -1;
+CBigNum bnBestChainWork = 0;
+CBigNum bnBestInvalidWork = 0;
+uint256 hashBestChain = 0;
+CBlockIndex* pindexBest = NULL;
+int64 nTimeBestReceived = 0;
+
+CMedianFilter<int> cPeerBlockCounts(5, 0); // Amount of blocks that other nodes claim to have
+
+map<uint256, CBlock*> mapOrphanBlocks;
+multimap<uint256, CBlock*> mapOrphanBlocksByPrev;
+
+map<uint256, CDataStream*> mapOrphanTransactions;
+multimap<uint256, CDataStream*> mapOrphanTransactionsByPrev;
+
+
+double dHashesPerSec;
+int64 nHPSTimerStart;
+
+// Settings
+int fGenerateBitcoins = false;
+int64 nTransactionFee = 0;
+int fLimitProcessors = false;
+int nLimitProcessors = 1;
+int fMinimizeToTray = true;
+int fMinimizeOnClose = true;
+#if USE_UPNP
+int fUseUPnP = true;
+#else
+int fUseUPnP = false;
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// dispatching functions
+//
+
+// These functions dispatch to one or all registered wallets
+
+
+void RegisterWallet(CWallet* pwalletIn)
+{
+ CRITICAL_BLOCK(cs_setpwalletRegistered)
+ {
+ setpwalletRegistered.insert(pwalletIn);
+ }
+}
+
+void UnregisterWallet(CWallet* pwalletIn)
+{
+ CRITICAL_BLOCK(cs_setpwalletRegistered)
+ {
+ setpwalletRegistered.erase(pwalletIn);
+ }
+}
+
+// check whether the passed transaction is from us
+bool static IsFromMe(CTransaction& tx)
+{
+ BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
+ if (pwallet->IsFromMe(tx))
+ return true;
+ return false;
+}
+
+// get the wallet transaction with the given hash (if it exists)
+bool static GetTransaction(const uint256& hashTx, CWalletTx& wtx)
+{
+ BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
+ if (pwallet->GetTransaction(hashTx,wtx))
+ return true;
+ return false;
+}
+
+// erases transaction with the given hash from all wallets
+void static EraseFromWallets(uint256 hash)
+{
+ BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
+ pwallet->EraseFromWallet(hash);
+}
+
+// make sure all wallets know about the given transaction, in the given block
+void static SyncWithWallets(const CTransaction& tx, const CBlock* pblock = NULL, bool fUpdate = false)
+{
+ BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
+ pwallet->AddToWalletIfInvolvingMe(tx, pblock, fUpdate);
+}
+
+// notify wallets about a new best chain
+void static SetBestChain(const CBlockLocator& loc)
+{
+ BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
+ pwallet->SetBestChain(loc);
+}
+
+// notify wallets about an updated transaction
+void static UpdatedTransaction(const uint256& hashTx)
+{
+ BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
+ pwallet->UpdatedTransaction(hashTx);
+}
+
+// dump all wallets
+void static PrintWallets(const CBlock& block)
+{
+ BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
+ pwallet->PrintWallet(block);
+}
+
+// notify wallets about an incoming inventory (for request counts)
+void static Inventory(const uint256& hash)
+{
+ BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
+ pwallet->Inventory(hash);
+}
+
+// ask wallets to resend their transactions
+void static ResendWalletTransactions()
+{
+ BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
+ pwallet->ResendWalletTransactions();
+}
+
+
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// mapOrphanTransactions
+//
+
+void AddOrphanTx(const CDataStream& vMsg)
+{
+ CTransaction tx;
+ CDataStream(vMsg) >> tx;
+ uint256 hash = tx.GetHash();
+ if (mapOrphanTransactions.count(hash))
+ return;
+
+ CDataStream* pvMsg = mapOrphanTransactions[hash] = new CDataStream(vMsg);
+ BOOST_FOREACH(const CTxIn& txin, tx.vin)
+ mapOrphanTransactionsByPrev.insert(make_pair(txin.prevout.hash, pvMsg));
+}
+
+void static EraseOrphanTx(uint256 hash)
+{
+ if (!mapOrphanTransactions.count(hash))
+ return;
+ const CDataStream* pvMsg = mapOrphanTransactions[hash];
+ CTransaction tx;
+ CDataStream(*pvMsg) >> tx;
+ BOOST_FOREACH(const CTxIn& txin, tx.vin)
+ {
+ for (multimap<uint256, CDataStream*>::iterator mi = mapOrphanTransactionsByPrev.lower_bound(txin.prevout.hash);
+ mi != mapOrphanTransactionsByPrev.upper_bound(txin.prevout.hash);)
+ {
+ if ((*mi).second == pvMsg)
+ mapOrphanTransactionsByPrev.erase(mi++);
+ else
+ mi++;
+ }
+ }
+ delete pvMsg;
+ mapOrphanTransactions.erase(hash);
+}
+
+int LimitOrphanTxSize(int nMaxOrphans)
+{
+ int nEvicted = 0;
+ while (mapOrphanTransactions.size() > nMaxOrphans)
+ {
+ // Evict a random orphan:
+ std::vector<unsigned char> randbytes(32);
+ RAND_bytes(&randbytes[0], 32);
+ uint256 randomhash(randbytes);
+ map<uint256, CDataStream*>::iterator it = mapOrphanTransactions.lower_bound(randomhash);
+ if (it == mapOrphanTransactions.end())
+ it = mapOrphanTransactions.begin();
+ EraseOrphanTx(it->first);
+ ++nEvicted;
+ }
+ return nEvicted;
+}
+
+
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// CTransaction and CTxIndex
+//
+
+bool CTransaction::ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet)
+{
+ SetNull();
+ if (!txdb.ReadTxIndex(prevout.hash, txindexRet))
+ return false;
+ if (!ReadFromDisk(txindexRet.pos))
+ return false;
+ if (prevout.n >= vout.size())
+ {
+ SetNull();
+ return false;
+ }
+ return true;
+}
+
+bool CTransaction::ReadFromDisk(CTxDB& txdb, COutPoint prevout)
+{
+ CTxIndex txindex;
+ return ReadFromDisk(txdb, prevout, txindex);
+}
+
+bool CTransaction::ReadFromDisk(COutPoint prevout)
+{
+ CTxDB txdb("r");
+ CTxIndex txindex;
+ return ReadFromDisk(txdb, prevout, txindex);
+}
+
+
+
+int CMerkleTx::SetMerkleBranch(const CBlock* pblock)
+{
+ if (fClient)
+ {
+ if (hashBlock == 0)
+ return 0;
+ }
+ else
+ {
+ CBlock blockTmp;
+ if (pblock == NULL)
+ {
+ // Load the block this tx is in
+ CTxIndex txindex;
+ if (!CTxDB("r").ReadTxIndex(GetHash(), txindex))
+ return 0;
+ if (!blockTmp.ReadFromDisk(txindex.pos.nFile, txindex.pos.nBlockPos))
+ return 0;
+ pblock = &blockTmp;
+ }
+
+ // Update the tx's hashBlock
+ hashBlock = pblock->GetHash();
+
+ // Locate the transaction
+ for (nIndex = 0; nIndex < pblock->vtx.size(); nIndex++)
+ if (pblock->vtx[nIndex] == *(CTransaction*)this)
+ break;
+ if (nIndex == pblock->vtx.size())
+ {
+ vMerkleBranch.clear();
+ nIndex = -1;
+ printf("ERROR: SetMerkleBranch() : couldn't find tx in block\n");
+ return 0;
+ }
+
+ // Fill in merkle branch
+ vMerkleBranch = pblock->GetMerkleBranch(nIndex);
+ }
+
+ // Is the tx in a block that's in the main chain
+ map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
+ if (mi == mapBlockIndex.end())
+ return 0;
+ CBlockIndex* pindex = (*mi).second;
+ if (!pindex || !pindex->IsInMainChain())
+ return 0;
+
+ return pindexBest->nHeight - pindex->nHeight + 1;
+}
+
+
+
+
+
+
+
+bool CTransaction::CheckTransaction() const
+{
+ // Basic checks that don't depend on any context
+ if (vin.empty())
+ return DoS(10, error("CTransaction::CheckTransaction() : vin empty"));
+ if (vout.empty())
+ return DoS(10, error("CTransaction::CheckTransaction() : vout empty"));
+ // Size limits
+ if (::GetSerializeSize(*this, SER_NETWORK) > MAX_BLOCK_SIZE)
+ return DoS(100, error("CTransaction::CheckTransaction() : size limits failed"));
+
+ // Check for negative or overflow output values
+ int64 nValueOut = 0;
+ BOOST_FOREACH(const CTxOut& txout, vout)
+ {
+ if (txout.nValue < 0)
+ return DoS(100, error("CTransaction::CheckTransaction() : txout.nValue negative"));
+ if (txout.nValue > MAX_MONEY)
+ return DoS(100, error("CTransaction::CheckTransaction() : txout.nValue too high"));
+ nValueOut += txout.nValue;
+ if (!MoneyRange(nValueOut))
+ return DoS(100, error("CTransaction::CheckTransaction() : txout total out of range"));
+ }
+
+ // Check for duplicate inputs
+ set<COutPoint> vInOutPoints;
+ BOOST_FOREACH(const CTxIn& txin, vin)
+ {
+ if (vInOutPoints.count(txin.prevout))
+ return false;
+ vInOutPoints.insert(txin.prevout);
+ }
+
+ if (IsCoinBase())
+ {
+ if (vin[0].scriptSig.size() < 2 || vin[0].scriptSig.size() > 100)
+ return DoS(100, error("CTransaction::CheckTransaction() : coinbase script size"));
+ }
+ else
+ {
+ BOOST_FOREACH(const CTxIn& txin, vin)
+ if (txin.prevout.IsNull())
+ return DoS(10, error("CTransaction::CheckTransaction() : prevout is null"));
+ }
+
+ return true;
+}
+
+bool CTransaction::AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs, bool* pfMissingInputs)
+{
+ if (pfMissingInputs)
+ *pfMissingInputs = false;
+
+ if (!CheckTransaction())
+ return error("AcceptToMemoryPool() : CheckTransaction failed");
+
+ // Coinbase is only valid in a block, not as a loose transaction
+ if (IsCoinBase())
+ return DoS(100, error("AcceptToMemoryPool() : coinbase as individual tx"));
+
+ // To help v0.1.5 clients who would see it as a negative number
+ if ((int64)nLockTime > INT_MAX)
+ return error("AcceptToMemoryPool() : not accepting nLockTime beyond 2038 yet");
+
+ // Safety limits
+ unsigned int nSize = ::GetSerializeSize(*this, SER_NETWORK);
+ // Checking ECDSA signatures is a CPU bottleneck, so to avoid denial-of-service
+ // attacks disallow transactions with more than one SigOp per 34 bytes.
+ // 34 bytes because a TxOut is:
+ // 20-byte address + 8 byte bitcoin amount + 5 bytes of ops + 1 byte script length
+ if (GetSigOpCount() > nSize / 34 || nSize < 100)
+ return error("AcceptToMemoryPool() : transaction with out-of-bounds SigOpCount");
+
+ // Rather not work on nonstandard transactions (unless -testnet)
+ if (!fTestNet && !IsStandard())
+ return error("AcceptToMemoryPool() : nonstandard transaction type");
+
+ // Do we already have it?
+ uint256 hash = GetHash();
+ CRITICAL_BLOCK(cs_mapTransactions)
+ if (mapTransactions.count(hash))
+ return false;
+ if (fCheckInputs)
+ if (txdb.ContainsTx(hash))
+ return false;
+
+ // Check for conflicts with in-memory transactions
+ CTransaction* ptxOld = NULL;
+ for (int i = 0; i < vin.size(); i++)
+ {
+ COutPoint outpoint = vin[i].prevout;
+ if (mapNextTx.count(outpoint))
+ {
+ // Disable replacement feature for now
+ return false;
+
+ // Allow replacing with a newer version of the same transaction
+ if (i != 0)
+ return false;
+ ptxOld = mapNextTx[outpoint].ptx;
+ if (ptxOld->IsFinal())
+ return false;
+ if (!IsNewerThan(*ptxOld))
+ return false;
+ for (int i = 0; i < vin.size(); i++)
+ {
+ COutPoint outpoint = vin[i].prevout;
+ if (!mapNextTx.count(outpoint) || mapNextTx[outpoint].ptx != ptxOld)
+ return false;
+ }
+ break;
+ }
+ }
+
+ if (fCheckInputs)
+ {
+ // Check against previous transactions
+ map<uint256, CTxIndex> mapUnused;
+ int64 nFees = 0;
+ bool fInvalid = false;
+ if (!ConnectInputs(txdb, mapUnused, CDiskTxPos(1,1,1), pindexBest, nFees, false, false, 0, fInvalid))
+ {
+ if (fInvalid)
+ return error("AcceptToMemoryPool() : FetchInputs found invalid tx %s", hash.ToString().substr(0,10).c_str());
+ return error("AcceptToMemoryPool() : ConnectInputs failed %s", hash.ToString().substr(0,10).c_str());
+ }
+
+ // Don't accept it if it can't get into a block
+ if (nFees < GetMinFee(1000, true, true))
+ return error("AcceptToMemoryPool() : not enough fees");
+
+ // Continuously rate-limit free transactions
+ // This mitigates 'penny-flooding' -- sending thousands of free transactions just to
+ // be annoying or make other's transactions take longer to confirm.
+ if (nFees < MIN_RELAY_TX_FEE)
+ {
+ static CCriticalSection cs;
+ static double dFreeCount;
+ static int64 nLastTime;
+ int64 nNow = GetTime();
+
+ CRITICAL_BLOCK(cs)
+ {
+ // Use an exponentially decaying ~10-minute window:
+ dFreeCount *= pow(1.0 - 1.0/600.0, (double)(nNow - nLastTime));
+ nLastTime = nNow;
+ // -limitfreerelay unit is thousand-bytes-per-minute
+ // At default rate it would take over a month to fill 1GB
+ if (dFreeCount > GetArg("-limitfreerelay", 15)*10*1000 && !IsFromMe(*this))
+ return error("AcceptToMemoryPool() : free transaction rejected by rate limiter");
+ if (fDebug)
+ printf("Rate limit dFreeCount: %g => %g\n", dFreeCount, dFreeCount+nSize);
+ dFreeCount += nSize;
+ }
+ }
+ }
+
+ // Store transaction in memory
+ CRITICAL_BLOCK(cs_mapTransactions)
+ {
+ if (ptxOld)
+ {
+ printf("AcceptToMemoryPool() : replacing tx %s with new version\n", ptxOld->GetHash().ToString().c_str());
+ ptxOld->RemoveFromMemoryPool();
+ }
+ AddToMemoryPoolUnchecked();
+ }
+
+ ///// are we sure this is ok when loading transactions or restoring block txes
+ // If updated, erase old tx from wallet
+ if (ptxOld)
+ EraseFromWallets(ptxOld->GetHash());
+
+ printf("AcceptToMemoryPool(): accepted %s\n", hash.ToString().substr(0,10).c_str());
+ return true;
+}
+
+bool CTransaction::AcceptToMemoryPool(bool fCheckInputs, bool* pfMissingInputs)
+{
+ CTxDB txdb("r");
+ return AcceptToMemoryPool(txdb, fCheckInputs, pfMissingInputs);
+}
+
+bool CTransaction::AddToMemoryPoolUnchecked()
+{
+ // Add to memory pool without checking anything. Don't call this directly,
+ // call AcceptToMemoryPool to properly check the transaction first.
+ CRITICAL_BLOCK(cs_mapTransactions)
+ {
+ uint256 hash = GetHash();
+ mapTransactions[hash] = *this;
+ for (int i = 0; i < vin.size(); i++)
+ mapNextTx[vin[i].prevout] = CInPoint(&mapTransactions[hash], i);
+ nTransactionsUpdated++;
+ }
+ return true;
+}
+
+
+bool CTransaction::RemoveFromMemoryPool()
+{
+ // Remove transaction from memory pool
+ CRITICAL_BLOCK(cs_mapTransactions)
+ {
+ BOOST_FOREACH(const CTxIn& txin, vin)
+ mapNextTx.erase(txin.prevout);
+ mapTransactions.erase(GetHash());
+ nTransactionsUpdated++;
+ }
+ return true;
+}
+
+
+
+
+
+
+int CMerkleTx::GetDepthInMainChain(int& nHeightRet) const
+{
+ if (hashBlock == 0 || nIndex == -1)
+ return 0;
+
+ // Find the block it claims to be in
+ map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
+ if (mi == mapBlockIndex.end())
+ return 0;
+ CBlockIndex* pindex = (*mi).second;
+ if (!pindex || !pindex->IsInMainChain())
+ return 0;
+
+ // Make sure the merkle branch connects to this block
+ if (!fMerkleVerified)
+ {
+ if (CBlock::CheckMerkleBranch(GetHash(), vMerkleBranch, nIndex) != pindex->hashMerkleRoot)
+ return 0;
+ fMerkleVerified = true;
+ }
+
+ nHeightRet = pindex->nHeight;
+ return pindexBest->nHeight - pindex->nHeight + 1;
+}
+
+
+int CMerkleTx::GetBlocksToMaturity() const
+{
+ if (!IsCoinBase())
+ return 0;
+ return max(0, (COINBASE_MATURITY+20) - GetDepthInMainChain());
+}
+
+
+bool CMerkleTx::AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs)
+{
+ if (fClient)
+ {
+ if (!IsInMainChain() && !ClientConnectInputs())
+ return false;
+ return CTransaction::AcceptToMemoryPool(txdb, false);
+ }
+ else
+ {
+ return CTransaction::AcceptToMemoryPool(txdb, fCheckInputs);
+ }
+}
+
+bool CMerkleTx::AcceptToMemoryPool()
+{
+ CTxDB txdb("r");
+ return AcceptToMemoryPool(txdb);
+}
+
+
+
+bool CWalletTx::AcceptWalletTransaction(CTxDB& txdb, bool fCheckInputs)
+{
+ CRITICAL_BLOCK(cs_mapTransactions)
+ {
+ // Add previous supporting transactions first
+ BOOST_FOREACH(CMerkleTx& tx, vtxPrev)
+ {
+ if (!tx.IsCoinBase())
+ {
+ uint256 hash = tx.GetHash();
+ if (!mapTransactions.count(hash) && !txdb.ContainsTx(hash))
+ tx.AcceptToMemoryPool(txdb, fCheckInputs);
+ }
+ }
+ return AcceptToMemoryPool(txdb, fCheckInputs);
+ }
+ return false;
+}
+
+bool CWalletTx::AcceptWalletTransaction()
+{
+ CTxDB txdb("r");
+ return AcceptWalletTransaction(txdb);
+}
+
+int CTxIndex::GetDepthInMainChain() const
+{
+ // Read block header
+ CBlock block;
+ if (!block.ReadFromDisk(pos.nFile, pos.nBlockPos, false))
+ return 0;
+ // Find the block in the index
+ map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(block.GetHash());
+ if (mi == mapBlockIndex.end())
+ return 0;
+ CBlockIndex* pindex = (*mi).second;
+ if (!pindex || !pindex->IsInMainChain())
+ return 0;
+ return 1 + nBestHeight - pindex->nHeight;
+}
+
+
+
+
+
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// CBlock and CBlockIndex
+//
+
+bool CBlock::ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions)
+{
+ if (!fReadTransactions)
+ {
+ *this = pindex->GetBlockHeader();
+ return true;
+ }
+ if (!ReadFromDisk(pindex->nFile, pindex->nBlockPos, fReadTransactions))
+ return false;
+ if (GetHash() != pindex->GetBlockHash())
+ return error("CBlock::ReadFromDisk() : GetHash() doesn't match index");
+ return true;
+}
+
+uint256 static GetOrphanRoot(const CBlock* pblock)
+{
+ // Work back to the first block in the orphan chain
+ while (mapOrphanBlocks.count(pblock->hashPrevBlock))
+ pblock = mapOrphanBlocks[pblock->hashPrevBlock];
+ return pblock->GetHash();
+}
+
+int64 static GetBlockValue(int nHeight, int64 nFees)
+{
+ int64 nSubsidy = 50 * COIN;
+
+ // Subsidy is cut in half every 4 years
+ nSubsidy >>= (nHeight / 210000);
+
+ return nSubsidy + nFees;
+}
+
+static const int64 nTargetTimespan = 14 * 24 * 60 * 60; // two weeks
+static const int64 nTargetSpacing = 10 * 60;
+static const int64 nInterval = nTargetTimespan / nTargetSpacing;
+
+//
+// minimum amount of work that could possibly be required nTime after
+// minimum work required was nBase
+//
+unsigned int ComputeMinWork(unsigned int nBase, int64 nTime)
+{
+ // Testnet has min-difficulty blocks
+ // after nTargetSpacing*2 time between blocks:
+ if (fTestNet && nTime > nTargetSpacing*2)
+ return bnProofOfWorkLimit.GetCompact();
+
+ CBigNum bnResult;
+ bnResult.SetCompact(nBase);
+ while (nTime > 0 && bnResult < bnProofOfWorkLimit)
+ {
+ // Maximum 400% adjustment...
+ bnResult *= 4;
+ // ... in best-case exactly 4-times-normal target time
+ nTime -= nTargetTimespan*4;
+ }
+ if (bnResult > bnProofOfWorkLimit)
+ bnResult = bnProofOfWorkLimit;
+ return bnResult.GetCompact();
+}
+
+unsigned int static GetNextWorkRequired(const CBlockIndex* pindexLast, const CBlock *pblock)
+{
+ unsigned int nProofOfWorkLimit = bnProofOfWorkLimit.GetCompact();
+
+ // Genesis block
+ if (pindexLast == NULL)
+ return nProofOfWorkLimit;
+
+ // Only change once per interval
+ if ((pindexLast->nHeight+1) % nInterval != 0)
+ {
+ // Special rules for testnet after 15 Feb 2012:
+ if (fTestNet && pblock->nTime > 1329264000)
+ {
+ // If the new block's timestamp is more than 2* 10 minutes
+ // then allow mining of a min-difficulty block.
+ if (pblock->nTime - pindexLast->nTime > nTargetSpacing*2)
+ return nProofOfWorkLimit;
+ else
+ {
+ // Return the last non-special-min-difficulty-rules-block
+ const CBlockIndex* pindex = pindexLast;
+ while (pindex->pprev && pindex->nHeight % nInterval != 0 && pindex->nBits == nProofOfWorkLimit)
+ pindex = pindex->pprev;
+ return pindex->nBits;
+ }
+ }
+
+ return pindexLast->nBits;
+ }
+
+ // Go back by what we want to be 14 days worth of blocks
+ const CBlockIndex* pindexFirst = pindexLast;
+ for (int i = 0; pindexFirst && i < nInterval-1; i++)
+ pindexFirst = pindexFirst->pprev;
+ assert(pindexFirst);
+
+ // Limit adjustment step
+ int64 nActualTimespan = pindexLast->GetBlockTime() - pindexFirst->GetBlockTime();
+ printf(" nActualTimespan = %"PRI64d" before bounds\n", nActualTimespan);
+ if (nActualTimespan < nTargetTimespan/4)
+ nActualTimespan = nTargetTimespan/4;
+ if (nActualTimespan > nTargetTimespan*4)
+ nActualTimespan = nTargetTimespan*4;
+
+ // Retarget
+ CBigNum bnNew;
+ bnNew.SetCompact(pindexLast->nBits);
+ bnNew *= nActualTimespan;
+ bnNew /= nTargetTimespan;
+
+ if (bnNew > bnProofOfWorkLimit)
+ bnNew = bnProofOfWorkLimit;
+
+ /// debug print
+ printf("GetNextWorkRequired RETARGET\n");
+ printf("nTargetTimespan = %"PRI64d" nActualTimespan = %"PRI64d"\n", nTargetTimespan, nActualTimespan);
+ printf("Before: %08x %s\n", pindexLast->nBits, CBigNum().SetCompact(pindexLast->nBits).getuint256().ToString().c_str());
+ printf("After: %08x %s\n", bnNew.GetCompact(), bnNew.getuint256().ToString().c_str());
+
+ return bnNew.GetCompact();
+}
+
+bool CheckProofOfWork(uint256 hash, unsigned int nBits)
+{
+ CBigNum bnTarget;
+ bnTarget.SetCompact(nBits);
+
+ // Check range
+ if (bnTarget <= 0 || bnTarget > bnProofOfWorkLimit)
+ return error("CheckProofOfWork() : nBits below minimum work");
+
+ // Check proof of work matches claimed amount
+ if (hash > bnTarget.getuint256())
+ return error("CheckProofOfWork() : hash doesn't match nBits");
+
+ return true;
+}
+
+// Return maximum amount of blocks that other nodes claim to have
+int GetNumBlocksOfPeers()
+{
+ return std::max(cPeerBlockCounts.median(), Checkpoints::GetTotalBlocksEstimate());
+}
+
+bool IsInitialBlockDownload()
+{
+ if (pindexBest == NULL || nBestHeight < Checkpoints::GetTotalBlocksEstimate())
+ return true;
+ static int64 nLastUpdate;
+ static CBlockIndex* pindexLastBest;
+ if (pindexBest != pindexLastBest)
+ {
+ pindexLastBest = pindexBest;
+ nLastUpdate = GetTime();
+ }
+ return (GetTime() - nLastUpdate < 10 &&
+ pindexBest->GetBlockTime() < GetTime() - 24 * 60 * 60);
+}
+
+void static InvalidChainFound(CBlockIndex* pindexNew)
+{
+ if (pindexNew->bnChainWork > bnBestInvalidWork)
+ {
+ bnBestInvalidWork = pindexNew->bnChainWork;
+ CTxDB().WriteBestInvalidWork(bnBestInvalidWork);
+ MainFrameRepaint();
+ }
+ printf("InvalidChainFound: invalid block=%s height=%d work=%s\n", pindexNew->GetBlockHash().ToString().substr(0,20).c_str(), pindexNew->nHeight, pindexNew->bnChainWork.ToString().c_str());
+ printf("InvalidChainFound: current best=%s height=%d work=%s\n", hashBestChain.ToString().substr(0,20).c_str(), nBestHeight, bnBestChainWork.ToString().c_str());
+ if (pindexBest && bnBestInvalidWork > bnBestChainWork + pindexBest->GetBlockWork() * 6)
+ printf("InvalidChainFound: WARNING: Displayed transactions may not be correct! You may need to upgrade, or other nodes may need to upgrade.\n");
+}
+
+
+
+
+
+
+
+
+
+
+
+bool CTransaction::DisconnectInputs(CTxDB& txdb)
+{
+ // Relinquish previous transactions' spent pointers
+ if (!IsCoinBase())
+ {
+ BOOST_FOREACH(const CTxIn& txin, vin)
+ {
+ COutPoint prevout = txin.prevout;
+
+ // Get prev txindex from disk
+ CTxIndex txindex;
+ if (!txdb.ReadTxIndex(prevout.hash, txindex))
+ return error("DisconnectInputs() : ReadTxIndex failed");
+
+ if (prevout.n >= txindex.vSpent.size())
+ return error("DisconnectInputs() : prevout.n out of range");
+
+ // Mark outpoint as not spent
+ txindex.vSpent[prevout.n].SetNull();
+
+ // Write back
+ if (!txdb.UpdateTxIndex(prevout.hash, txindex))
+ return error("DisconnectInputs() : UpdateTxIndex failed");
+ }
+ }
+
+ // Remove transaction from index
+ // This can fail if a duplicate of this transaction was in a chain that got
+ // reorganized away. This is only possible if this transaction was completely
+ // spent, so erasing it would be a no-op anway.
+ txdb.EraseTxIndex(*this);
+
+ return true;
+}
+
+
+bool CTransaction::ConnectInputs(CTxDB& txdb, map<uint256, CTxIndex>& mapTestPool, CDiskTxPos posThisTx,
+ CBlockIndex* pindexBlock, int64& nFees, bool fBlock, bool fMiner, int64 nMinFee,
+ bool& fInvalid)
+{
+ // FetchInputs can return false either because we just haven't seen some inputs
+ // (in which case the transaction should be stored as an orphan)
+ // or because the transaction is malformed (in which case the transaction should
+ // be dropped). If tx is definitely invalid, fInvalid will be set to true.
+ fInvalid = false;
+
+ // Take over previous transactions' spent pointers
+ // fBlock is true when this is called from AcceptBlock when a new best-block is added to the blockchain
+ // fMiner is true when called from the internal bitcoin miner
+ // ... both are false when called from CTransaction::AcceptToMemoryPool
+ if (!IsCoinBase())
+ {
+ int64 nValueIn = 0;
+ for (int i = 0; i < vin.size(); i++)
+ {
+ COutPoint prevout = vin[i].prevout;
+
+ // Read txindex
+ CTxIndex txindex;
+ bool fFound = true;
+ if ((fBlock || fMiner) && mapTestPool.count(prevout.hash))
+ {
+ // Get txindex from current proposed changes
+ txindex = mapTestPool[prevout.hash];
+ }
+ else
+ {
+ // Read txindex from txdb
+ fFound = txdb.ReadTxIndex(prevout.hash, txindex);
+ }
+ if (!fFound && (fBlock || fMiner))
+ return fMiner ? false : error("ConnectInputs() : %s prev tx %s index entry not found", GetHash().ToString().substr(0,10).c_str(), prevout.hash.ToString().substr(0,10).c_str());
+
+ // Read txPrev
+ CTransaction txPrev;
+ if (!fFound || txindex.pos == CDiskTxPos(1,1,1))
+ {
+ // Get prev tx from single transactions in memory
+ CRITICAL_BLOCK(cs_mapTransactions)
+ {
+ if (!mapTransactions.count(prevout.hash))
+ return error("ConnectInputs() : %s mapTransactions prev not found %s", GetHash().ToString().substr(0,10).c_str(), prevout.hash.ToString().substr(0,10).c_str());
+ txPrev = mapTransactions[prevout.hash];
+ }
+ if (!fFound)
+ txindex.vSpent.resize(txPrev.vout.size());
+ }
+ else
+ {
+ // Get prev tx from disk
+ if (!txPrev.ReadFromDisk(txindex.pos))
+ return error("ConnectInputs() : %s ReadFromDisk prev tx %s failed", GetHash().ToString().substr(0,10).c_str(), prevout.hash.ToString().substr(0,10).c_str());
+ }
+
+ if (prevout.n >= txPrev.vout.size() || prevout.n >= txindex.vSpent.size())
+ {
+ // Revisit this if/when transaction replacement is implemented and allows
+ // adding inputs:
+ fInvalid = true;
+ return DoS(100, error("ConnectInputs() : %s prevout.n out of range %d %d %d prev tx %s\n%s", GetHash().ToString().substr(0,10).c_str(), prevout.n, txPrev.vout.size(), txindex.vSpent.size(), prevout.hash.ToString().substr(0,10).c_str(), txPrev.ToString().c_str()));
+ }
+
+ // If prev is coinbase, check that it's matured
+ if (txPrev.IsCoinBase())
+ for (CBlockIndex* pindex = pindexBlock; pindex && pindexBlock->nHeight - pindex->nHeight < COINBASE_MATURITY; pindex = pindex->pprev)
+ if (pindex->nBlockPos == txindex.pos.nBlockPos && pindex->nFile == txindex.pos.nFile)
+ return error("ConnectInputs() : tried to spend coinbase at depth %d", pindexBlock->nHeight - pindex->nHeight);
+
+ // Skip ECDSA signature verification when connecting blocks (fBlock=true)
+ // before the last blockchain checkpoint. This is safe because block merkle hashes are
+ // still computed and checked, and any change will be caught at the next checkpoint.
+ if (!(fBlock && (nBestHeight < Checkpoints::GetTotalBlocksEstimate())))
+ // Verify signature
+ if (!VerifySignature(txPrev, *this, i))
+ return DoS(100,error("ConnectInputs() : %s VerifySignature failed", GetHash().ToString().substr(0,10).c_str()));
+
+ // Check for conflicts (double-spend)
+ // This doesn't trigger the DoS code on purpose; if it did, it would make it easier
+ // for an attacker to attempt to split the network.
+ if (!txindex.vSpent[prevout.n].IsNull())
+ return fMiner ? false : error("ConnectInputs() : %s prev tx already used at %s", GetHash().ToString().substr(0,10).c_str(), txindex.vSpent[prevout.n].ToString().c_str());
+
+ // Check for negative or overflow input values
+ nValueIn += txPrev.vout[prevout.n].nValue;
+ if (!MoneyRange(txPrev.vout[prevout.n].nValue) || !MoneyRange(nValueIn))
+ return DoS(100, error("ConnectInputs() : txin values out of range"));
+
+ // Mark outpoints as spent
+ txindex.vSpent[prevout.n] = posThisTx;
+
+ // Write back
+ if (fBlock || fMiner)
+ {
+ mapTestPool[prevout.hash] = txindex;
+ }
+ }
+
+ if (nValueIn < GetValueOut())
+ return DoS(100, error("ConnectInputs() : %s value in < value out", GetHash().ToString().substr(0,10).c_str()));
+
+ // Tally transaction fees
+ int64 nTxFee = nValueIn - GetValueOut();
+ if (nTxFee < 0)
+ return DoS(100, error("ConnectInputs() : %s nTxFee < 0", GetHash().ToString().substr(0,10).c_str()));
+ if (nTxFee < nMinFee)
+ return false;
+ nFees += nTxFee;
+ if (!MoneyRange(nFees))
+ return DoS(100, error("ConnectInputs() : nFees out of range"));
+ }
+
+ if (fBlock)
+ {
+ // Add transaction to changes
+ mapTestPool[GetHash()] = CTxIndex(posThisTx, vout.size());
+ }
+ else if (fMiner)
+ {
+ // Add transaction to test pool
+ mapTestPool[GetHash()] = CTxIndex(CDiskTxPos(1,1,1), vout.size());
+ }
+
+ return true;
+}
+
+
+bool CTransaction::ClientConnectInputs()
+{
+ if (IsCoinBase())
+ return false;
+
+ // Take over previous transactions' spent pointers
+ CRITICAL_BLOCK(cs_mapTransactions)
+ {
+ int64 nValueIn = 0;
+ for (int i = 0; i < vin.size(); i++)
+ {
+ // Get prev tx from single transactions in memory
+ COutPoint prevout = vin[i].prevout;
+ if (!mapTransactions.count(prevout.hash))
+ return false;
+ CTransaction& txPrev = mapTransactions[prevout.hash];
+
+ if (prevout.n >= txPrev.vout.size())
+ return false;
+
+ // Verify signature
+ if (!VerifySignature(txPrev, *this, i))
+ return error("ConnectInputs() : VerifySignature failed");
+
+ ///// this is redundant with the mapNextTx stuff, not sure which I want to get rid of
+ ///// this has to go away now that posNext is gone
+ // // Check for conflicts
+ // if (!txPrev.vout[prevout.n].posNext.IsNull())
+ // return error("ConnectInputs() : prev tx already used");
+ //
+ // // Flag outpoints as used
+ // txPrev.vout[prevout.n].posNext = posThisTx;
+
+ nValueIn += txPrev.vout[prevout.n].nValue;
+
+ if (!MoneyRange(txPrev.vout[prevout.n].nValue) || !MoneyRange(nValueIn))
+ return error("ClientConnectInputs() : txin values out of range");
+ }
+ if (GetValueOut() > nValueIn)
+ return false;
+ }
+
+ return true;
+}
+
+
+
+
+bool CBlock::DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex)
+{
+ // Disconnect in reverse order
+ for (int i = vtx.size()-1; i >= 0; i--)
+ if (!vtx[i].DisconnectInputs(txdb))
+ return false;
+
+ // Update block index on disk without changing it in memory.
+ // The memory index structure will be changed after the db commits.
+ if (pindex->pprev)
+ {
+ CDiskBlockIndex blockindexPrev(pindex->pprev);
+ blockindexPrev.hashNext = 0;
+ if (!txdb.WriteBlockIndex(blockindexPrev))
+ return error("DisconnectBlock() : WriteBlockIndex failed");
+ }
+
+ return true;
+}
+
+bool CBlock::ConnectBlock(CTxDB& txdb, CBlockIndex* pindex)
+{
+ // Check it again in case a previous version let a bad block in
+ if (!CheckBlock())
+ return false;
+
+ // Do not allow blocks that contain transactions which 'overwrite' older transactions,
+ // unless those are already completely spent.
+ // If such overwrites are allowed, coinbases and transactions depending upon those
+ // can be duplicated to remove the ability to spend the first instance -- even after
+ // being sent to another address.
+ // See BIP30 and http://r6.ca/blog/20120206T005236Z.html for more information.
+ // This logic is not necessary for memory pool transactions, as AcceptToMemoryPool
+ // already refuses previously-known transaction id's entirely.
+ // This rule applies to all blocks whose timestamp is after March 15, 2012, 0:00 UTC.
+ // On testnet it is enabled as of februari 20, 2012, 0:00 UTC.
+ if (pindex->nTime > 1331769600 || (fTestNet && pindex->nTime > 1329696000))
+ BOOST_FOREACH(CTransaction& tx, vtx)
+ {
+ CTxIndex txindexOld;
+ if (txdb.ReadTxIndex(tx.GetHash(), txindexOld))
+ BOOST_FOREACH(CDiskTxPos &pos, txindexOld.vSpent)
+ if (pos.IsNull())
+ return false;
+ }
+
+ //// issue here: it doesn't know the version
+ unsigned int nTxPos = pindex->nBlockPos + ::GetSerializeSize(CBlock(), SER_DISK) - 1 + GetSizeOfCompactSize(vtx.size());
+
+ map<uint256, CTxIndex> mapQueuedChanges;
+ int64 nFees = 0;
+ BOOST_FOREACH(CTransaction& tx, vtx)
+ {
+ CDiskTxPos posThisTx(pindex->nFile, pindex->nBlockPos, nTxPos);
+ nTxPos += ::GetSerializeSize(tx, SER_DISK);
+
+ bool fInvalid;
+ if (!tx.ConnectInputs(txdb, mapQueuedChanges, posThisTx, pindex, nFees, true, false, 0, fInvalid))
+ return false;
+ }
+ // Write queued txindex changes
+ for (map<uint256, CTxIndex>::iterator mi = mapQueuedChanges.begin(); mi != mapQueuedChanges.end(); ++mi)
+ {
+ if (!txdb.UpdateTxIndex((*mi).first, (*mi).second))
+ return error("ConnectBlock() : UpdateTxIndex failed");
+ }
+
+ if (vtx[0].GetValueOut() > GetBlockValue(pindex->nHeight, nFees))
+ return false;
+
+ // Update block index on disk without changing it in memory.
+ // The memory index structure will be changed after the db commits.
+ if (pindex->pprev)
+ {
+ CDiskBlockIndex blockindexPrev(pindex->pprev);
+ blockindexPrev.hashNext = pindex->GetBlockHash();
+ if (!txdb.WriteBlockIndex(blockindexPrev))
+ return error("ConnectBlock() : WriteBlockIndex failed");
+ }
+
+ // Watch for transactions paying to me
+ BOOST_FOREACH(CTransaction& tx, vtx)
+ SyncWithWallets(tx, this, true);
+
+ return true;
+}
+
+bool static Reorganize(CTxDB& txdb, CBlockIndex* pindexNew)
+{
+ printf("REORGANIZE\n");
+
+ // Find the fork
+ CBlockIndex* pfork = pindexBest;
+ CBlockIndex* plonger = pindexNew;
+ while (pfork != plonger)
+ {
+ while (plonger->nHeight > pfork->nHeight)
+ if (!(plonger = plonger->pprev))
+ return error("Reorganize() : plonger->pprev is null");
+ if (pfork == plonger)
+ break;
+ if (!(pfork = pfork->pprev))
+ return error("Reorganize() : pfork->pprev is null");
+ }
+
+ // List of what to disconnect
+ vector<CBlockIndex*> vDisconnect;
+ for (CBlockIndex* pindex = pindexBest; pindex != pfork; pindex = pindex->pprev)
+ vDisconnect.push_back(pindex);
+
+ // List of what to connect
+ vector<CBlockIndex*> vConnect;
+ for (CBlockIndex* pindex = pindexNew; pindex != pfork; pindex = pindex->pprev)
+ vConnect.push_back(pindex);
+ reverse(vConnect.begin(), vConnect.end());
+
+ // Disconnect shorter branch
+ vector<CTransaction> vResurrect;
+ BOOST_FOREACH(CBlockIndex* pindex, vDisconnect)
+ {
+ CBlock block;
+ if (!block.ReadFromDisk(pindex))
+ return error("Reorganize() : ReadFromDisk for disconnect failed");
+ if (!block.DisconnectBlock(txdb, pindex))
+ return error("Reorganize() : DisconnectBlock failed");
+
+ // Queue memory transactions to resurrect
+ BOOST_FOREACH(const CTransaction& tx, block.vtx)
+ if (!tx.IsCoinBase())
+ vResurrect.push_back(tx);
+ }
+
+ // Connect longer branch
+ vector<CTransaction> vDelete;
+ for (int i = 0; i < vConnect.size(); i++)
+ {
+ CBlockIndex* pindex = vConnect[i];
+ CBlock block;
+ if (!block.ReadFromDisk(pindex))
+ return error("Reorganize() : ReadFromDisk for connect failed");
+ if (!block.ConnectBlock(txdb, pindex))
+ {
+ // Invalid block
+ txdb.TxnAbort();
+ return error("Reorganize() : ConnectBlock failed");
+ }
+
+ // Queue memory transactions to delete
+ BOOST_FOREACH(const CTransaction& tx, block.vtx)
+ vDelete.push_back(tx);
+ }
+ if (!txdb.WriteHashBestChain(pindexNew->GetBlockHash()))
+ return error("Reorganize() : WriteHashBestChain failed");
+
+ // Make sure it's successfully written to disk before changing memory structure
+ if (!txdb.TxnCommit())
+ return error("Reorganize() : TxnCommit failed");
+
+ // Disconnect shorter branch
+ BOOST_FOREACH(CBlockIndex* pindex, vDisconnect)
+ if (pindex->pprev)
+ pindex->pprev->pnext = NULL;
+
+ // Connect longer branch
+ BOOST_FOREACH(CBlockIndex* pindex, vConnect)
+ if (pindex->pprev)
+ pindex->pprev->pnext = pindex;
+
+ // Resurrect memory transactions that were in the disconnected branch
+ BOOST_FOREACH(CTransaction& tx, vResurrect)
+ tx.AcceptToMemoryPool(txdb, false);
+
+ // Delete redundant memory transactions that are in the connected branch
+ BOOST_FOREACH(CTransaction& tx, vDelete)
+ tx.RemoveFromMemoryPool();
+
+ return true;
+}
+
+
+bool CBlock::SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew)
+{
+ uint256 hash = GetHash();
+
+ txdb.TxnBegin();
+ if (pindexGenesisBlock == NULL && hash == hashGenesisBlock)
+ {
+ txdb.WriteHashBestChain(hash);
+ if (!txdb.TxnCommit())
+ return error("SetBestChain() : TxnCommit failed");
+ pindexGenesisBlock = pindexNew;
+ }
+ else if (hashPrevBlock == hashBestChain)
+ {
+ // Adding to current best branch
+ if (!ConnectBlock(txdb, pindexNew) || !txdb.WriteHashBestChain(hash))
+ {
+ txdb.TxnAbort();
+ InvalidChainFound(pindexNew);
+ return error("SetBestChain() : ConnectBlock failed");
+ }
+ if (!txdb.TxnCommit())
+ return error("SetBestChain() : TxnCommit failed");
+
+ // Add to current best branch
+ pindexNew->pprev->pnext = pindexNew;
+
+ // Delete redundant memory transactions
+ BOOST_FOREACH(CTransaction& tx, vtx)
+ tx.RemoveFromMemoryPool();
+ }
+ else
+ {
+ // New best branch
+ if (!Reorganize(txdb, pindexNew))
+ {
+ txdb.TxnAbort();
+ InvalidChainFound(pindexNew);
+ return error("SetBestChain() : Reorganize failed");
+ }
+ }
+
+ // Update best block in wallet (so we can detect restored wallets)
+ if (!IsInitialBlockDownload())
+ {
+ const CBlockLocator locator(pindexNew);
+ ::SetBestChain(locator);
+ }
+
+ // New best block
+ hashBestChain = hash;
+ pindexBest = pindexNew;
+ nBestHeight = pindexBest->nHeight;
+ bnBestChainWork = pindexNew->bnChainWork;
+ nTimeBestReceived = GetTime();
+ nTransactionsUpdated++;
+ printf("SetBestChain: new best=%s height=%d work=%s\n", hashBestChain.ToString().substr(0,20).c_str(), nBestHeight, bnBestChainWork.ToString().c_str());
+
+ return true;
+}
+
+
+bool CBlock::AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos)
+{
+ // Check for duplicate
+ uint256 hash = GetHash();
+ if (mapBlockIndex.count(hash))
+ return error("AddToBlockIndex() : %s already exists", hash.ToString().substr(0,20).c_str());
+
+ // Construct new block index object
+ CBlockIndex* pindexNew = new CBlockIndex(nFile, nBlockPos, *this);
+ if (!pindexNew)
+ return error("AddToBlockIndex() : new CBlockIndex failed");
+ map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.insert(make_pair(hash, pindexNew)).first;
+ pindexNew->phashBlock = &((*mi).first);
+ map<uint256, CBlockIndex*>::iterator miPrev = mapBlockIndex.find(hashPrevBlock);
+ if (miPrev != mapBlockIndex.end())
+ {
+ pindexNew->pprev = (*miPrev).second;
+ pindexNew->nHeight = pindexNew->pprev->nHeight + 1;
+ }
+ pindexNew->bnChainWork = (pindexNew->pprev ? pindexNew->pprev->bnChainWork : 0) + pindexNew->GetBlockWork();
+
+ CTxDB txdb;
+ txdb.TxnBegin();
+ txdb.WriteBlockIndex(CDiskBlockIndex(pindexNew));
+ if (!txdb.TxnCommit())
+ return false;
+
+ // New best
+ if (pindexNew->bnChainWork > bnBestChainWork)
+ if (!SetBestChain(txdb, pindexNew))
+ return false;
+
+ txdb.Close();
+
+ if (pindexNew == pindexBest)
+ {
+ // Notify UI to display prev block's coinbase if it was ours
+ static uint256 hashPrevBestCoinBase;
+ UpdatedTransaction(hashPrevBestCoinBase);
+ hashPrevBestCoinBase = vtx[0].GetHash();
+ }
+
+ MainFrameRepaint();
+ return true;
+}
+
+
+
+
+bool CBlock::CheckBlock() const
+{
+ // These are checks that are independent of context
+ // that can be verified before saving an orphan block.
+
+ // Size limits
+ if (vtx.empty() || vtx.size() > MAX_BLOCK_SIZE || ::GetSerializeSize(*this, SER_NETWORK) > MAX_BLOCK_SIZE)
+ return DoS(100, error("CheckBlock() : size limits failed"));
+
+ // Check proof of work matches claimed amount
+ if (!CheckProofOfWork(GetHash(), nBits))
+ return DoS(50, error("CheckBlock() : proof of work failed"));
+
+ // Check timestamp
+ if (GetBlockTime() > GetAdjustedTime() + 2 * 60 * 60)
+ return error("CheckBlock() : block timestamp too far in the future");
+
+ // First transaction must be coinbase, the rest must not be
+ if (vtx.empty() || !vtx[0].IsCoinBase())
+ return DoS(100, error("CheckBlock() : first tx is not coinbase"));
+ for (int i = 1; i < vtx.size(); i++)
+ if (vtx[i].IsCoinBase())
+ return DoS(100, error("CheckBlock() : more than one coinbase"));
+
+ // Check transactions
+ BOOST_FOREACH(const CTransaction& tx, vtx)
+ if (!tx.CheckTransaction())
+ return DoS(tx.nDoS, error("CheckBlock() : CheckTransaction failed"));
+
+ // Check that it's not full of nonstandard transactions
+ if (GetSigOpCount() > MAX_BLOCK_SIGOPS)
+ return DoS(100, error("CheckBlock() : out-of-bounds SigOpCount"));
+
+ // Check merkleroot
+ if (hashMerkleRoot != BuildMerkleTree())
+ return DoS(100, error("CheckBlock() : hashMerkleRoot mismatch"));
+
+ return true;
+}
+
+bool CBlock::AcceptBlock()
+{
+ // Check for duplicate
+ uint256 hash = GetHash();
+ if (mapBlockIndex.count(hash))
+ return error("AcceptBlock() : block already in mapBlockIndex");
+
+ // Get prev block index
+ map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashPrevBlock);
+ if (mi == mapBlockIndex.end())
+ return DoS(10, error("AcceptBlock() : prev block not found"));
+ CBlockIndex* pindexPrev = (*mi).second;
+ int nHeight = pindexPrev->nHeight+1;
+
+ // Check proof of work
+ if (nBits != GetNextWorkRequired(pindexPrev, this))
+ return DoS(100, error("AcceptBlock() : incorrect proof of work"));
+
+ // Check timestamp against prev
+ if (GetBlockTime() <= pindexPrev->GetMedianTimePast())
+ return error("AcceptBlock() : block's timestamp is too early");
+
+ // Check that all transactions are finalized
+ BOOST_FOREACH(const CTransaction& tx, vtx)
+ if (!tx.IsFinal(nHeight, GetBlockTime()))
+ return DoS(10, error("AcceptBlock() : contains a non-final transaction"));
+
+ // Check that the block chain matches the known block chain up to a checkpoint
+ if (!Checkpoints::CheckBlock(nHeight, hash))
+ return DoS(100, error("AcceptBlock() : rejected by checkpoint lockin at %d", nHeight));
+
+ // Write block to history file
+ if (!CheckDiskSpace(::GetSerializeSize(*this, SER_DISK)))
+ return error("AcceptBlock() : out of disk space");
+ unsigned int nFile = -1;
+ unsigned int nBlockPos = 0;
+ if (!WriteToDisk(nFile, nBlockPos))
+ return error("AcceptBlock() : WriteToDisk failed");
+ if (!AddToBlockIndex(nFile, nBlockPos))
+ return error("AcceptBlock() : AddToBlockIndex failed");
+
+ // Relay inventory, but don't relay old inventory during initial block download
+ if (hashBestChain == hash)
+ CRITICAL_BLOCK(cs_vNodes)
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ if (nBestHeight > (pnode->nStartingHeight != -1 ? pnode->nStartingHeight - 2000 : 140700))
+ pnode->PushInventory(CInv(MSG_BLOCK, hash));
+
+ return true;
+}
+
+bool ProcessBlock(CNode* pfrom, CBlock* pblock)
+{
+ // Check for duplicate
+ uint256 hash = pblock->GetHash();
+ if (mapBlockIndex.count(hash))
+ return error("ProcessBlock() : already have block %d %s", mapBlockIndex[hash]->nHeight, hash.ToString().substr(0,20).c_str());
+ if (mapOrphanBlocks.count(hash))
+ return error("ProcessBlock() : already have block (orphan) %s", hash.ToString().substr(0,20).c_str());
+
+ // Preliminary checks
+ if (!pblock->CheckBlock())
+ return error("ProcessBlock() : CheckBlock FAILED");
+
+ CBlockIndex* pcheckpoint = Checkpoints::GetLastCheckpoint(mapBlockIndex);
+ if (pcheckpoint && pblock->hashPrevBlock != hashBestChain)
+ {
+ // Extra checks to prevent "fill up memory by spamming with bogus blocks"
+ int64 deltaTime = pblock->GetBlockTime() - pcheckpoint->nTime;
+ if (deltaTime < 0)
+ {
+ if (pfrom)
+ pfrom->Misbehaving(100);
+ return error("ProcessBlock() : block with timestamp before last checkpoint");
+ }
+ CBigNum bnNewBlock;
+ bnNewBlock.SetCompact(pblock->nBits);
+ CBigNum bnRequired;
+ bnRequired.SetCompact(ComputeMinWork(pcheckpoint->nBits, deltaTime));
+ if (bnNewBlock > bnRequired)
+ {
+ if (pfrom)
+ pfrom->Misbehaving(100);
+ return error("ProcessBlock() : block with too little proof-of-work");
+ }
+ }
+
+
+ // If don't already have its previous block, shunt it off to holding area until we get it
+ if (!mapBlockIndex.count(pblock->hashPrevBlock))
+ {
+ printf("ProcessBlock: ORPHAN BLOCK, prev=%s\n", pblock->hashPrevBlock.ToString().substr(0,20).c_str());
+ CBlock* pblock2 = new CBlock(*pblock);
+ mapOrphanBlocks.insert(make_pair(hash, pblock2));
+ mapOrphanBlocksByPrev.insert(make_pair(pblock2->hashPrevBlock, pblock2));
+
+ // Ask this guy to fill in what we're missing
+ if (pfrom)
+ pfrom->PushGetBlocks(pindexBest, GetOrphanRoot(pblock2));
+ return true;
+ }
+
+ // Store to disk
+ if (!pblock->AcceptBlock())
+ return error("ProcessBlock() : AcceptBlock FAILED");
+
+ // Recursively process any orphan blocks that depended on this one
+ vector<uint256> vWorkQueue;
+ vWorkQueue.push_back(hash);
+ for (int i = 0; i < vWorkQueue.size(); i++)
+ {
+ uint256 hashPrev = vWorkQueue[i];
+ for (multimap<uint256, CBlock*>::iterator mi = mapOrphanBlocksByPrev.lower_bound(hashPrev);
+ mi != mapOrphanBlocksByPrev.upper_bound(hashPrev);
+ ++mi)
+ {
+ CBlock* pblockOrphan = (*mi).second;
+ if (pblockOrphan->AcceptBlock())
+ vWorkQueue.push_back(pblockOrphan->GetHash());
+ mapOrphanBlocks.erase(pblockOrphan->GetHash());
+ delete pblockOrphan;
+ }
+ mapOrphanBlocksByPrev.erase(hashPrev);
+ }
+
+ printf("ProcessBlock: ACCEPTED\n");
+ return true;
+}
+
+
+
+
+
+
+
+
+bool CheckDiskSpace(uint64 nAdditionalBytes)
+{
+ uint64 nFreeBytesAvailable = filesystem::space(GetDataDir()).available;
+
+ // Check for 15MB because database could create another 10MB log file at any time
+ if (nFreeBytesAvailable < (uint64)15000000 + nAdditionalBytes)
+ {
+ fShutdown = true;
+ string strMessage = _("Warning: Disk space is low ");
+ strMiscWarning = strMessage;
+ printf("*** %s\n", strMessage.c_str());
+ ThreadSafeMessageBox(strMessage, "Bitcoin", wxOK | wxICON_EXCLAMATION);
+ CreateThread(Shutdown, NULL);
+ return false;
+ }
+ return true;
+}
+
+FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode)
+{
+ if (nFile == -1)
+ return NULL;
+ FILE* file = fopen(strprintf("%s/blk%04d.dat", GetDataDir().c_str(), nFile).c_str(), pszMode);
+ if (!file)
+ return NULL;
+ if (nBlockPos != 0 && !strchr(pszMode, 'a') && !strchr(pszMode, 'w'))
+ {
+ if (fseek(file, nBlockPos, SEEK_SET) != 0)
+ {
+ fclose(file);
+ return NULL;
+ }
+ }
+ return file;
+}
+
+static unsigned int nCurrentBlockFile = 1;
+
+FILE* AppendBlockFile(unsigned int& nFileRet)
+{
+ nFileRet = 0;
+ loop
+ {
+ FILE* file = OpenBlockFile(nCurrentBlockFile, 0, "ab");
+ if (!file)
+ return NULL;
+ if (fseek(file, 0, SEEK_END) != 0)
+ return NULL;
+ // FAT32 filesize max 4GB, fseek and ftell max 2GB, so we must stay under 2GB
+ if (ftell(file) < 0x7F000000 - MAX_SIZE)
+ {
+ nFileRet = nCurrentBlockFile;
+ return file;
+ }
+ fclose(file);
+ nCurrentBlockFile++;
+ }
+}
+
+bool LoadBlockIndex(bool fAllowNew)
+{
+ if (fTestNet)
+ {
+ hashGenesisBlock = uint256("0x00000007199508e34a9ff81e6ec0c477a4cccff2a4767a8eee39c11db367b008");
+ bnProofOfWorkLimit = CBigNum(~uint256(0) >> 28);
+ pchMessageStart[0] = 0xfa;
+ pchMessageStart[1] = 0xbf;
+ pchMessageStart[2] = 0xb5;
+ pchMessageStart[3] = 0xda;
+ }
+
+ //
+ // Load block index
+ //
+ CTxDB txdb("cr");
+ if (!txdb.LoadBlockIndex())
+ return false;
+ txdb.Close();
+
+ //
+ // Init with genesis block
+ //
+ if (mapBlockIndex.empty())
+ {
+ if (!fAllowNew)
+ return false;
+
+ // Genesis Block:
+ // CBlock(hash=000000000019d6, ver=1, hashPrevBlock=00000000000000, hashMerkleRoot=4a5e1e, nTime=1231006505, nBits=1d00ffff, nNonce=2083236893, vtx=1)
+ // CTransaction(hash=4a5e1e, ver=1, vin.size=1, vout.size=1, nLockTime=0)
+ // CTxIn(COutPoint(000000, -1), coinbase 04ffff001d0104455468652054696d65732030332f4a616e2f32303039204368616e63656c6c6f72206f6e206272696e6b206f66207365636f6e64206261696c6f757420666f722062616e6b73)
+ // CTxOut(nValue=50.00000000, scriptPubKey=0x5F1DF16B2B704C8A578D0B)
+ // vMerkleTree: 4a5e1e
+
+ // Genesis block
+ const char* pszTimestamp = "The Times 03/Jan/2009 Chancellor on brink of second bailout for banks";
+ CTransaction txNew;
+ txNew.vin.resize(1);
+ txNew.vout.resize(1);
+ txNew.vin[0].scriptSig = CScript() << 486604799 << CBigNum(4) << vector<unsigned char>((const unsigned char*)pszTimestamp, (const unsigned char*)pszTimestamp + strlen(pszTimestamp));
+ txNew.vout[0].nValue = 50 * COIN;
+ txNew.vout[0].scriptPubKey = CScript() << ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f") << OP_CHECKSIG;
+ CBlock block;
+ block.vtx.push_back(txNew);
+ block.hashPrevBlock = 0;
+ block.hashMerkleRoot = block.BuildMerkleTree();
+ block.nVersion = 1;
+ block.nTime = 1231006505;
+ block.nBits = 0x1d00ffff;
+ block.nNonce = 2083236893;
+
+ if (fTestNet)
+ {
+ block.nTime = 1296688602;
+ block.nBits = 0x1d07fff8;
+ block.nNonce = 384568319;
+ }
+
+ //// debug print
+ printf("%s\n", block.GetHash().ToString().c_str());
+ printf("%s\n", hashGenesisBlock.ToString().c_str());
+ printf("%s\n", block.hashMerkleRoot.ToString().c_str());
+ assert(block.hashMerkleRoot == uint256("0x4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b"));
+ block.print();
+ assert(block.GetHash() == hashGenesisBlock);
+
+ // Start new block file
+ unsigned int nFile;
+ unsigned int nBlockPos;
+ if (!block.WriteToDisk(nFile, nBlockPos))
+ return error("LoadBlockIndex() : writing genesis block to disk failed");
+ if (!block.AddToBlockIndex(nFile, nBlockPos))
+ return error("LoadBlockIndex() : genesis block not accepted");
+ }
+
+ return true;
+}
+
+
+
+void PrintBlockTree()
+{
+ // precompute tree structure
+ map<CBlockIndex*, vector<CBlockIndex*> > mapNext;
+ for (map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.begin(); mi != mapBlockIndex.end(); ++mi)
+ {
+ CBlockIndex* pindex = (*mi).second;
+ mapNext[pindex->pprev].push_back(pindex);
+ // test
+ //while (rand() % 3 == 0)
+ // mapNext[pindex->pprev].push_back(pindex);
+ }
+
+ vector<pair<int, CBlockIndex*> > vStack;
+ vStack.push_back(make_pair(0, pindexGenesisBlock));
+
+ int nPrevCol = 0;
+ while (!vStack.empty())
+ {
+ int nCol = vStack.back().first;
+ CBlockIndex* pindex = vStack.back().second;
+ vStack.pop_back();
+
+ // print split or gap
+ if (nCol > nPrevCol)
+ {
+ for (int i = 0; i < nCol-1; i++)
+ printf("| ");
+ printf("|\\\n");
+ }
+ else if (nCol < nPrevCol)
+ {
+ for (int i = 0; i < nCol; i++)
+ printf("| ");
+ printf("|\n");
+ }
+ nPrevCol = nCol;
+
+ // print columns
+ for (int i = 0; i < nCol; i++)
+ printf("| ");
+
+ // print item
+ CBlock block;
+ block.ReadFromDisk(pindex);
+ printf("%d (%u,%u) %s %s tx %d",
+ pindex->nHeight,
+ pindex->nFile,
+ pindex->nBlockPos,
+ block.GetHash().ToString().substr(0,20).c_str(),
+ DateTimeStrFormat("%x %H:%M:%S", block.GetBlockTime()).c_str(),
+ block.vtx.size());
+
+ PrintWallets(block);
+
+ // put the main timechain first
+ vector<CBlockIndex*>& vNext = mapNext[pindex];
+ for (int i = 0; i < vNext.size(); i++)
+ {
+ if (vNext[i]->pnext)
+ {
+ swap(vNext[0], vNext[i]);
+ break;
+ }
+ }
+
+ // iterate children
+ for (int i = 0; i < vNext.size(); i++)
+ vStack.push_back(make_pair(nCol+i, vNext[i]));
+ }
+}
+
+
+
+
+
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// CAlert
+//
+
+map<uint256, CAlert> mapAlerts;
+CCriticalSection cs_mapAlerts;
+
+string GetWarnings(string strFor)
+{
+ int nPriority = 0;
+ string strStatusBar;
+ string strRPC;
+ if (GetBoolArg("-testsafemode"))
+ strRPC = "test";
+
+ // Misc warnings like out of disk space and clock is wrong
+ if (strMiscWarning != "")
+ {
+ nPriority = 1000;
+ strStatusBar = strMiscWarning;
+ }
+
+ // Longer invalid proof-of-work chain
+ if (pindexBest && bnBestInvalidWork > bnBestChainWork + pindexBest->GetBlockWork() * 6)
+ {
+ nPriority = 2000;
+ strStatusBar = strRPC = "WARNING: Displayed transactions may not be correct! You may need to upgrade, or other nodes may need to upgrade.";
+ }
+
+ // Alerts
+ CRITICAL_BLOCK(cs_mapAlerts)
+ {
+ BOOST_FOREACH(PAIRTYPE(const uint256, CAlert)& item, mapAlerts)
+ {
+ const CAlert& alert = item.second;
+ if (alert.AppliesToMe() && alert.nPriority > nPriority)
+ {
+ nPriority = alert.nPriority;
+ strStatusBar = alert.strStatusBar;
+ }
+ }
+ }
+
+ if (strFor == "statusbar")
+ return strStatusBar;
+ else if (strFor == "rpc")
+ return strRPC;
+ assert(!"GetWarnings() : invalid parameter");
+ return "error";
+}
+
+bool CAlert::ProcessAlert()
+{
+ if (!CheckSignature())
+ return false;
+ if (!IsInEffect())
+ return false;
+
+ CRITICAL_BLOCK(cs_mapAlerts)
+ {
+ // Cancel previous alerts
+ for (map<uint256, CAlert>::iterator mi = mapAlerts.begin(); mi != mapAlerts.end();)
+ {
+ const CAlert& alert = (*mi).second;
+ if (Cancels(alert))
+ {
+ printf("cancelling alert %d\n", alert.nID);
+ mapAlerts.erase(mi++);
+ }
+ else if (!alert.IsInEffect())
+ {
+ printf("expiring alert %d\n", alert.nID);
+ mapAlerts.erase(mi++);
+ }
+ else
+ mi++;
+ }
+
+ // Check if this alert has been cancelled
+ BOOST_FOREACH(PAIRTYPE(const uint256, CAlert)& item, mapAlerts)
+ {
+ const CAlert& alert = item.second;
+ if (alert.Cancels(*this))
+ {
+ printf("alert already cancelled by %d\n", alert.nID);
+ return false;
+ }
+ }
+
+ // Add to mapAlerts
+ mapAlerts.insert(make_pair(GetHash(), *this));
+ }
+
+ printf("accepted alert %d, AppliesToMe()=%d\n", nID, AppliesToMe());
+ MainFrameRepaint();
+ return true;
+}
+
+
+
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Messages
+//
+
+
+bool static AlreadyHave(CTxDB& txdb, const CInv& inv)
+{
+ switch (inv.type)
+ {
+ case MSG_TX: return mapTransactions.count(inv.hash) || mapOrphanTransactions.count(inv.hash) || txdb.ContainsTx(inv.hash);
+ case MSG_BLOCK: return mapBlockIndex.count(inv.hash) || mapOrphanBlocks.count(inv.hash);
+ }
+ // Don't know what it is, just say we already got one
+ return true;
+}
+
+
+
+
+// The message start string is designed to be unlikely to occur in normal data.
+// The characters are rarely used upper ascii, not valid as UTF-8, and produce
+// a large 4-byte int at any alignment.
+unsigned char pchMessageStart[4] = { 0xf9, 0xbe, 0xb4, 0xd9 };
+
+
+bool static ProcessMessage(CNode* pfrom, string strCommand, CDataStream& vRecv)
+{
+ static map<unsigned int, vector<unsigned char> > mapReuseKey;
+ RandAddSeedPerfmon();
+ if (fDebug) {
+ printf("%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
+ printf("received: %s (%d bytes)\n", strCommand.c_str(), vRecv.size());
+ }
+ if (mapArgs.count("-dropmessagestest") && GetRand(atoi(mapArgs["-dropmessagestest"])) == 0)
+ {
+ printf("dropmessagestest DROPPING RECV MESSAGE\n");
+ return true;
+ }
+
+
+
+
+
+ if (strCommand == "version")
+ {
+ // Each connection can only send one version message
+ if (pfrom->nVersion != 0)
+ {
+ pfrom->Misbehaving(1);
+ return false;
+ }
+
+ int64 nTime;
+ CAddress addrMe;
+ CAddress addrFrom;
+ uint64 nNonce = 1;
+ vRecv >> pfrom->nVersion >> pfrom->nServices >> nTime >> addrMe;
+ if (pfrom->nVersion == 10300)
+ pfrom->nVersion = 300;
+ if (pfrom->nVersion >= 106 && !vRecv.empty())
+ vRecv >> addrFrom >> nNonce;
+ if (pfrom->nVersion >= 106 && !vRecv.empty())
+ vRecv >> pfrom->strSubVer;
+ if (pfrom->nVersion >= 209 && !vRecv.empty())
+ vRecv >> pfrom->nStartingHeight;
+
+ if (pfrom->nVersion == 0)
+ return false;
+
+ // Disconnect if we connected to ourself
+ if (nNonce == nLocalHostNonce && nNonce > 1)
+ {
+ printf("connected to self at %s, disconnecting\n", pfrom->addr.ToString().c_str());
+ pfrom->fDisconnect = true;
+ return true;
+ }
+
+ // Be shy and don't send version until we hear
+ if (pfrom->fInbound)
+ pfrom->PushVersion();
+
+ pfrom->fClient = !(pfrom->nServices & NODE_NETWORK);
+
+ AddTimeData(pfrom->addr.ip, nTime);
+
+ // Change version
+ if (pfrom->nVersion >= 209)
+ pfrom->PushMessage("verack");
+ pfrom->vSend.SetVersion(min(pfrom->nVersion, VERSION));
+ if (pfrom->nVersion < 209)
+ pfrom->vRecv.SetVersion(min(pfrom->nVersion, VERSION));
+
+ if (!pfrom->fInbound)
+ {
+ // Advertise our address
+ if (addrLocalHost.IsRoutable() && !fUseProxy)
+ {
+ CAddress addr(addrLocalHost);
+ addr.nTime = GetAdjustedTime();
+ pfrom->PushAddress(addr);
+ }
+
+ // Get recent addresses
+ if (pfrom->nVersion >= 31402 || mapAddresses.size() < 1000)
+ {
+ pfrom->PushMessage("getaddr");
+ pfrom->fGetAddr = true;
+ }
+ }
+
+ // Ask the first connected node for block updates
+ static int nAskedForBlocks;
+ if (!pfrom->fClient &&
+ (pfrom->nVersion < 32000 || pfrom->nVersion >= 32400) &&
+ (nAskedForBlocks < 1 || vNodes.size() <= 1))
+ {
+ nAskedForBlocks++;
+ pfrom->PushGetBlocks(pindexBest, uint256(0));
+ }
+
+ // Relay alerts
+ CRITICAL_BLOCK(cs_mapAlerts)
+ BOOST_FOREACH(PAIRTYPE(const uint256, CAlert)& item, mapAlerts)
+ item.second.RelayTo(pfrom);
+
+ pfrom->fSuccessfullyConnected = true;
+
+ printf("version message: version %d, blocks=%d\n", pfrom->nVersion, pfrom->nStartingHeight);
+
+ cPeerBlockCounts.input(pfrom->nStartingHeight);
+ }
+
+
+ else if (pfrom->nVersion == 0)
+ {
+ // Must have a version message before anything else
+ pfrom->Misbehaving(1);
+ return false;
+ }
+
+
+ else if (strCommand == "verack")
+ {
+ pfrom->vRecv.SetVersion(min(pfrom->nVersion, VERSION));
+ }
+
+
+ else if (strCommand == "addr")
+ {
+ vector<CAddress> vAddr;
+ vRecv >> vAddr;
+
+ // Don't want addr from older versions unless seeding
+ if (pfrom->nVersion < 209)
+ return true;
+ if (pfrom->nVersion < 31402 && mapAddresses.size() > 1000)
+ return true;
+ if (vAddr.size() > 1000)
+ {
+ pfrom->Misbehaving(20);
+ return error("message addr size() = %d", vAddr.size());
+ }
+
+ // Store the new addresses
+ CAddrDB addrDB;
+ addrDB.TxnBegin();
+ int64 nNow = GetAdjustedTime();
+ int64 nSince = nNow - 10 * 60;
+ BOOST_FOREACH(CAddress& addr, vAddr)
+ {
+ if (fShutdown)
+ return true;
+ // ignore IPv6 for now, since it isn't implemented anyway
+ if (!addr.IsIPv4())
+ continue;
+ if (addr.nTime <= 100000000 || addr.nTime > nNow + 10 * 60)
+ addr.nTime = nNow - 5 * 24 * 60 * 60;
+ AddAddress(addr, 2 * 60 * 60, &addrDB);
+ pfrom->AddAddressKnown(addr);
+ if (addr.nTime > nSince && !pfrom->fGetAddr && vAddr.size() <= 10 && addr.IsRoutable())
+ {
+ // Relay to a limited number of other nodes
+ CRITICAL_BLOCK(cs_vNodes)
+ {
+ // Use deterministic randomness to send to the same nodes for 24 hours
+ // at a time so the setAddrKnowns of the chosen nodes prevent repeats
+ static uint256 hashSalt;
+ if (hashSalt == 0)
+ RAND_bytes((unsigned char*)&hashSalt, sizeof(hashSalt));
+ uint256 hashRand = hashSalt ^ (((int64)addr.ip)<<32) ^ ((GetTime()+addr.ip)/(24*60*60));
+ hashRand = Hash(BEGIN(hashRand), END(hashRand));
+ multimap<uint256, CNode*> mapMix;
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ {
+ if (pnode->nVersion < 31402)
+ continue;
+ unsigned int nPointer;
+ memcpy(&nPointer, &pnode, sizeof(nPointer));
+ uint256 hashKey = hashRand ^ nPointer;
+ hashKey = Hash(BEGIN(hashKey), END(hashKey));
+ mapMix.insert(make_pair(hashKey, pnode));
+ }
+ int nRelayNodes = 2;
+ for (multimap<uint256, CNode*>::iterator mi = mapMix.begin(); mi != mapMix.end() && nRelayNodes-- > 0; ++mi)
+ ((*mi).second)->PushAddress(addr);
+ }
+ }
+ }
+ addrDB.TxnCommit(); // Save addresses (it's ok if this fails)
+ if (vAddr.size() < 1000)
+ pfrom->fGetAddr = false;
+ }
+
+
+ else if (strCommand == "inv")
+ {
+ vector<CInv> vInv;
+ vRecv >> vInv;
+ if (vInv.size() > 50000)
+ {
+ pfrom->Misbehaving(20);
+ return error("message inv size() = %d", vInv.size());
+ }
+
+ CTxDB txdb("r");
+ BOOST_FOREACH(const CInv& inv, vInv)
+ {
+ if (fShutdown)
+ return true;
+ pfrom->AddInventoryKnown(inv);
+
+ bool fAlreadyHave = AlreadyHave(txdb, inv);
+ if (fDebug)
+ printf(" got inventory: %s %s\n", inv.ToString().c_str(), fAlreadyHave ? "have" : "new");
+
+ if (!fAlreadyHave)
+ pfrom->AskFor(inv);
+ else if (inv.type == MSG_BLOCK && mapOrphanBlocks.count(inv.hash))
+ pfrom->PushGetBlocks(pindexBest, GetOrphanRoot(mapOrphanBlocks[inv.hash]));
+
+ // Track requests for our stuff
+ Inventory(inv.hash);
+ }
+ }
+
+
+ else if (strCommand == "getdata")
+ {
+ vector<CInv> vInv;
+ vRecv >> vInv;
+ if (vInv.size() > 50000)
+ {
+ pfrom->Misbehaving(20);
+ return error("message getdata size() = %d", vInv.size());
+ }
+
+ BOOST_FOREACH(const CInv& inv, vInv)
+ {
+ if (fShutdown)
+ return true;
+ printf("received getdata for: %s\n", inv.ToString().c_str());
+
+ if (inv.type == MSG_BLOCK)
+ {
+ // Send block from disk
+ map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(inv.hash);
+ if (mi != mapBlockIndex.end())
+ {
+ CBlock block;
+ block.ReadFromDisk((*mi).second);
+ pfrom->PushMessage("block", block);
+
+ // Trigger them to send a getblocks request for the next batch of inventory
+ if (inv.hash == pfrom->hashContinue)
+ {
+ // Bypass PushInventory, this must send even if redundant,
+ // and we want it right after the last block so they don't
+ // wait for other stuff first.
+ vector<CInv> vInv;
+ vInv.push_back(CInv(MSG_BLOCK, hashBestChain));
+ pfrom->PushMessage("inv", vInv);
+ pfrom->hashContinue = 0;
+ }
+ }
+ }
+ else if (inv.IsKnownType())
+ {
+ // Send stream from relay memory
+ CRITICAL_BLOCK(cs_mapRelay)
+ {
+ map<CInv, CDataStream>::iterator mi = mapRelay.find(inv);
+ if (mi != mapRelay.end())
+ pfrom->PushMessage(inv.GetCommand(), (*mi).second);
+ }
+ }
+
+ // Track requests for our stuff
+ Inventory(inv.hash);
+ }
+ }
+
+
+ else if (strCommand == "getblocks")
+ {
+ CBlockLocator locator;
+ uint256 hashStop;
+ vRecv >> locator >> hashStop;
+
+ // Find the last block the caller has in the main chain
+ CBlockIndex* pindex = locator.GetBlockIndex();
+
+ // Send the rest of the chain
+ if (pindex)
+ pindex = pindex->pnext;
+ int nLimit = 500 + locator.GetDistanceBack();
+ unsigned int nBytes = 0;
+ printf("getblocks %d to %s limit %d\n", (pindex ? pindex->nHeight : -1), hashStop.ToString().substr(0,20).c_str(), nLimit);
+ for (; pindex; pindex = pindex->pnext)
+ {
+ if (pindex->GetBlockHash() == hashStop)
+ {
+ printf(" getblocks stopping at %d %s (%u bytes)\n", pindex->nHeight, pindex->GetBlockHash().ToString().substr(0,20).c_str(), nBytes);
+ break;
+ }
+ pfrom->PushInventory(CInv(MSG_BLOCK, pindex->GetBlockHash()));
+ CBlock block;
+ block.ReadFromDisk(pindex, true);
+ nBytes += block.GetSerializeSize(SER_NETWORK);
+ if (--nLimit <= 0 || nBytes >= SendBufferSize()/2)
+ {
+ // When this block is requested, we'll send an inv that'll make them
+ // getblocks the next batch of inventory.
+ printf(" getblocks stopping at limit %d %s (%u bytes)\n", pindex->nHeight, pindex->GetBlockHash().ToString().substr(0,20).c_str(), nBytes);
+ pfrom->hashContinue = pindex->GetBlockHash();
+ break;
+ }
+ }
+ }
+
+
+ else if (strCommand == "getheaders")
+ {
+ CBlockLocator locator;
+ uint256 hashStop;
+ vRecv >> locator >> hashStop;
+
+ CBlockIndex* pindex = NULL;
+ if (locator.IsNull())
+ {
+ // If locator is null, return the hashStop block
+ map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashStop);
+ if (mi == mapBlockIndex.end())
+ return true;
+ pindex = (*mi).second;
+ }
+ else
+ {
+ // Find the last block the caller has in the main chain
+ pindex = locator.GetBlockIndex();
+ if (pindex)
+ pindex = pindex->pnext;
+ }
+
+ vector<CBlock> vHeaders;
+ int nLimit = 2000 + locator.GetDistanceBack();
+ printf("getheaders %d to %s limit %d\n", (pindex ? pindex->nHeight : -1), hashStop.ToString().substr(0,20).c_str(), nLimit);
+ for (; pindex; pindex = pindex->pnext)
+ {
+ vHeaders.push_back(pindex->GetBlockHeader());
+ if (--nLimit <= 0 || pindex->GetBlockHash() == hashStop)
+ break;
+ }
+ pfrom->PushMessage("headers", vHeaders);
+ }
+
+
+ else if (strCommand == "tx")
+ {
+ vector<uint256> vWorkQueue;
+ CDataStream vMsg(vRecv);
+ CTransaction tx;
+ vRecv >> tx;
+
+ CInv inv(MSG_TX, tx.GetHash());
+ pfrom->AddInventoryKnown(inv);
+
+ bool fMissingInputs = false;
+ if (tx.AcceptToMemoryPool(true, &fMissingInputs))
+ {
+ SyncWithWallets(tx, NULL, true);
+ RelayMessage(inv, vMsg);
+ mapAlreadyAskedFor.erase(inv);
+ vWorkQueue.push_back(inv.hash);
+
+ // Recursively process any orphan transactions that depended on this one
+ for (int i = 0; i < vWorkQueue.size(); i++)
+ {
+ uint256 hashPrev = vWorkQueue[i];
+ for (multimap<uint256, CDataStream*>::iterator mi = mapOrphanTransactionsByPrev.lower_bound(hashPrev);
+ mi != mapOrphanTransactionsByPrev.upper_bound(hashPrev);
+ ++mi)
+ {
+ const CDataStream& vMsg = *((*mi).second);
+ CTransaction tx;
+ CDataStream(vMsg) >> tx;
+ CInv inv(MSG_TX, tx.GetHash());
+
+ if (tx.AcceptToMemoryPool(true))
+ {
+ printf(" accepted orphan tx %s\n", inv.hash.ToString().substr(0,10).c_str());
+ SyncWithWallets(tx, NULL, true);
+ RelayMessage(inv, vMsg);
+ mapAlreadyAskedFor.erase(inv);
+ vWorkQueue.push_back(inv.hash);
+ }
+ }
+ }
+
+ BOOST_FOREACH(uint256 hash, vWorkQueue)
+ EraseOrphanTx(hash);
+ }
+ else if (fMissingInputs)
+ {
+ printf("storing orphan tx %s\n", inv.hash.ToString().substr(0,10).c_str());
+ AddOrphanTx(vMsg);
+
+ // DoS prevention: do not allow mapOrphanTransactions to grow unbounded
+ int nEvicted = LimitOrphanTxSize(MAX_ORPHAN_TRANSACTIONS);
+ if (nEvicted > 0)
+ printf("mapOrphan overflow, removed %d tx\n", nEvicted);
+ }
+ if (tx.nDoS) pfrom->Misbehaving(tx.nDoS);
+ }
+
+
+ else if (strCommand == "block")
+ {
+ CBlock block;
+ vRecv >> block;
+
+ printf("received block %s\n", block.GetHash().ToString().substr(0,20).c_str());
+ // block.print();
+
+ CInv inv(MSG_BLOCK, block.GetHash());
+ pfrom->AddInventoryKnown(inv);
+
+ if (ProcessBlock(pfrom, &block))
+ mapAlreadyAskedFor.erase(inv);
+ if (block.nDoS) pfrom->Misbehaving(block.nDoS);
+ }
+
+
+ else if (strCommand == "getaddr")
+ {
+ // Nodes rebroadcast an addr every 24 hours
+ pfrom->vAddrToSend.clear();
+ int64 nSince = GetAdjustedTime() - 3 * 60 * 60; // in the last 3 hours
+ CRITICAL_BLOCK(cs_mapAddresses)
+ {
+ unsigned int nCount = 0;
+ BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
+ {
+ const CAddress& addr = item.second;
+ if (addr.nTime > nSince)
+ nCount++;
+ }
+ BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
+ {
+ const CAddress& addr = item.second;
+ if (addr.nTime > nSince && GetRand(nCount) < 2500)
+ pfrom->PushAddress(addr);
+ }
+ }
+ }
+
+
+ else if (strCommand == "checkorder")
+ {
+ uint256 hashReply;
+ vRecv >> hashReply;
+
+ if (!GetBoolArg("-allowreceivebyip"))
+ {
+ pfrom->PushMessage("reply", hashReply, (int)2, string(""));
+ return true;
+ }
+
+ CWalletTx order;
+ vRecv >> order;
+
+ /// we have a chance to check the order here
+
+ // Keep giving the same key to the same ip until they use it
+ if (!mapReuseKey.count(pfrom->addr.ip))
+ pwalletMain->GetKeyFromPool(mapReuseKey[pfrom->addr.ip], true);
+
+ // Send back approval of order and pubkey to use
+ CScript scriptPubKey;
+ scriptPubKey << mapReuseKey[pfrom->addr.ip] << OP_CHECKSIG;
+ pfrom->PushMessage("reply", hashReply, (int)0, scriptPubKey);
+ }
+
+
+ else if (strCommand == "reply")
+ {
+ uint256 hashReply;
+ vRecv >> hashReply;
+
+ CRequestTracker tracker;
+ CRITICAL_BLOCK(pfrom->cs_mapRequests)
+ {
+ map<uint256, CRequestTracker>::iterator mi = pfrom->mapRequests.find(hashReply);
+ if (mi != pfrom->mapRequests.end())
+ {
+ tracker = (*mi).second;
+ pfrom->mapRequests.erase(mi);
+ }
+ }
+ if (!tracker.IsNull())
+ tracker.fn(tracker.param1, vRecv);
+ }
+
+
+ else if (strCommand == "ping")
+ {
+ }
+
+
+ else if (strCommand == "alert")
+ {
+ CAlert alert;
+ vRecv >> alert;
+
+ if (alert.ProcessAlert())
+ {
+ // Relay
+ pfrom->setKnown.insert(alert.GetHash());
+ CRITICAL_BLOCK(cs_vNodes)
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ alert.RelayTo(pnode);
+ }
+ }
+
+
+ else
+ {
+ // Ignore unknown commands for extensibility
+ }
+
+
+ // Update the last seen time for this node's address
+ if (pfrom->fNetworkNode)
+ if (strCommand == "version" || strCommand == "addr" || strCommand == "inv" || strCommand == "getdata" || strCommand == "ping")
+ AddressCurrentlyConnected(pfrom->addr);
+
+
+ return true;
+}
+
+bool ProcessMessages(CNode* pfrom)
+{
+ CDataStream& vRecv = pfrom->vRecv;
+ if (vRecv.empty())
+ return true;
+ //if (fDebug)
+ // printf("ProcessMessages(%u bytes)\n", vRecv.size());
+
+ //
+ // Message format
+ // (4) message start
+ // (12) command
+ // (4) size
+ // (4) checksum
+ // (x) data
+ //
+
+ loop
+ {
+ // Scan for message start
+ CDataStream::iterator pstart = search(vRecv.begin(), vRecv.end(), BEGIN(pchMessageStart), END(pchMessageStart));
+ int nHeaderSize = vRecv.GetSerializeSize(CMessageHeader());
+ if (vRecv.end() - pstart < nHeaderSize)
+ {
+ if (vRecv.size() > nHeaderSize)
+ {
+ printf("\n\nPROCESSMESSAGE MESSAGESTART NOT FOUND\n\n");
+ vRecv.erase(vRecv.begin(), vRecv.end() - nHeaderSize);
+ }
+ break;
+ }
+ if (pstart - vRecv.begin() > 0)
+ printf("\n\nPROCESSMESSAGE SKIPPED %d BYTES\n\n", pstart - vRecv.begin());
+ vRecv.erase(vRecv.begin(), pstart);
+
+ // Read header
+ vector<char> vHeaderSave(vRecv.begin(), vRecv.begin() + nHeaderSize);
+ CMessageHeader hdr;
+ vRecv >> hdr;
+ if (!hdr.IsValid())
+ {
+ printf("\n\nPROCESSMESSAGE: ERRORS IN HEADER %s\n\n\n", hdr.GetCommand().c_str());
+ continue;
+ }
+ string strCommand = hdr.GetCommand();
+
+ // Message size
+ unsigned int nMessageSize = hdr.nMessageSize;
+ if (nMessageSize > MAX_SIZE)
+ {
+ printf("ProcessMessage(%s, %u bytes) : nMessageSize > MAX_SIZE\n", strCommand.c_str(), nMessageSize);
+ continue;
+ }
+ if (nMessageSize > vRecv.size())
+ {
+ // Rewind and wait for rest of message
+ vRecv.insert(vRecv.begin(), vHeaderSave.begin(), vHeaderSave.end());
+ break;
+ }
+
+ // Checksum
+ if (vRecv.GetVersion() >= 209)
+ {
+ uint256 hash = Hash(vRecv.begin(), vRecv.begin() + nMessageSize);
+ unsigned int nChecksum = 0;
+ memcpy(&nChecksum, &hash, sizeof(nChecksum));
+ if (nChecksum != hdr.nChecksum)
+ {
+ printf("ProcessMessage(%s, %u bytes) : CHECKSUM ERROR nChecksum=%08x hdr.nChecksum=%08x\n",
+ strCommand.c_str(), nMessageSize, nChecksum, hdr.nChecksum);
+ continue;
+ }
+ }
+
+ // Copy message to its own buffer
+ CDataStream vMsg(vRecv.begin(), vRecv.begin() + nMessageSize, vRecv.nType, vRecv.nVersion);
+ vRecv.ignore(nMessageSize);
+
+ // Process message
+ bool fRet = false;
+ try
+ {
+ CRITICAL_BLOCK(cs_main)
+ fRet = ProcessMessage(pfrom, strCommand, vMsg);
+ if (fShutdown)
+ return true;
+ }
+ catch (std::ios_base::failure& e)
+ {
+ if (strstr(e.what(), "end of data"))
+ {
+ // Allow exceptions from underlength message on vRecv
+ printf("ProcessMessage(%s, %u bytes) : Exception '%s' caught, normally caused by a message being shorter than its stated length\n", strCommand.c_str(), nMessageSize, e.what());
+ }
+ else if (strstr(e.what(), "size too large"))
+ {
+ // Allow exceptions from overlong size
+ printf("ProcessMessage(%s, %u bytes) : Exception '%s' caught\n", strCommand.c_str(), nMessageSize, e.what());
+ }
+ else
+ {
+ PrintExceptionContinue(&e, "ProcessMessage()");
+ }
+ }
+ catch (std::exception& e) {
+ PrintExceptionContinue(&e, "ProcessMessage()");
+ } catch (...) {
+ PrintExceptionContinue(NULL, "ProcessMessage()");
+ }
+
+ if (!fRet)
+ printf("ProcessMessage(%s, %u bytes) FAILED\n", strCommand.c_str(), nMessageSize);
+ }
+
+ vRecv.Compact();
+ return true;
+}
+
+
+bool SendMessages(CNode* pto, bool fSendTrickle)
+{
+ CRITICAL_BLOCK(cs_main)
+ {
+ // Don't send anything until we get their version message
+ if (pto->nVersion == 0)
+ return true;
+
+ // Keep-alive ping
+ if (pto->nLastSend && GetTime() - pto->nLastSend > 30 * 60 && pto->vSend.empty())
+ pto->PushMessage("ping");
+
+ // Resend wallet transactions that haven't gotten in a block yet
+ ResendWalletTransactions();
+
+ // Address refresh broadcast
+ static int64 nLastRebroadcast;
+ if (GetTime() - nLastRebroadcast > 24 * 60 * 60)
+ {
+ nLastRebroadcast = GetTime();
+ CRITICAL_BLOCK(cs_vNodes)
+ {
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ {
+ // Periodically clear setAddrKnown to allow refresh broadcasts
+ pnode->setAddrKnown.clear();
+
+ // Rebroadcast our address
+ if (addrLocalHost.IsRoutable() && !fUseProxy)
+ {
+ CAddress addr(addrLocalHost);
+ addr.nTime = GetAdjustedTime();
+ pnode->PushAddress(addr);
+ }
+ }
+ }
+ }
+
+ // Clear out old addresses periodically so it's not too much work at once
+ static int64 nLastClear;
+ if (nLastClear == 0)
+ nLastClear = GetTime();
+ if (GetTime() - nLastClear > 10 * 60 && vNodes.size() >= 3)
+ {
+ nLastClear = GetTime();
+ CRITICAL_BLOCK(cs_mapAddresses)
+ {
+ CAddrDB addrdb;
+ int64 nSince = GetAdjustedTime() - 14 * 24 * 60 * 60;
+ for (map<vector<unsigned char>, CAddress>::iterator mi = mapAddresses.begin();
+ mi != mapAddresses.end();)
+ {
+ const CAddress& addr = (*mi).second;
+ if (addr.nTime < nSince)
+ {
+ if (mapAddresses.size() < 1000 || GetTime() > nLastClear + 20)
+ break;
+ addrdb.EraseAddress(addr);
+ mapAddresses.erase(mi++);
+ }
+ else
+ mi++;
+ }
+ }
+ }
+
+
+ //
+ // Message: addr
+ //
+ if (fSendTrickle)
+ {
+ vector<CAddress> vAddr;
+ vAddr.reserve(pto->vAddrToSend.size());
+ BOOST_FOREACH(const CAddress& addr, pto->vAddrToSend)
+ {
+ // returns true if wasn't already contained in the set
+ if (pto->setAddrKnown.insert(addr).second)
+ {
+ vAddr.push_back(addr);
+ // receiver rejects addr messages larger than 1000
+ if (vAddr.size() >= 1000)
+ {
+ pto->PushMessage("addr", vAddr);
+ vAddr.clear();
+ }
+ }
+ }
+ pto->vAddrToSend.clear();
+ if (!vAddr.empty())
+ pto->PushMessage("addr", vAddr);
+ }
+
+
+ //
+ // Message: inventory
+ //
+ vector<CInv> vInv;
+ vector<CInv> vInvWait;
+ CRITICAL_BLOCK(pto->cs_inventory)
+ {
+ vInv.reserve(pto->vInventoryToSend.size());
+ vInvWait.reserve(pto->vInventoryToSend.size());
+ BOOST_FOREACH(const CInv& inv, pto->vInventoryToSend)
+ {
+ if (pto->setInventoryKnown.count(inv))
+ continue;
+
+ // trickle out tx inv to protect privacy
+ if (inv.type == MSG_TX && !fSendTrickle)
+ {
+ // 1/4 of tx invs blast to all immediately
+ static uint256 hashSalt;
+ if (hashSalt == 0)
+ RAND_bytes((unsigned char*)&hashSalt, sizeof(hashSalt));
+ uint256 hashRand = inv.hash ^ hashSalt;
+ hashRand = Hash(BEGIN(hashRand), END(hashRand));
+ bool fTrickleWait = ((hashRand & 3) != 0);
+
+ // always trickle our own transactions
+ if (!fTrickleWait)
+ {
+ CWalletTx wtx;
+ if (GetTransaction(inv.hash, wtx))
+ if (wtx.fFromMe)
+ fTrickleWait = true;
+ }
+
+ if (fTrickleWait)
+ {
+ vInvWait.push_back(inv);
+ continue;
+ }
+ }
+
+ // returns true if wasn't already contained in the set
+ if (pto->setInventoryKnown.insert(inv).second)
+ {
+ vInv.push_back(inv);
+ if (vInv.size() >= 1000)
+ {
+ pto->PushMessage("inv", vInv);
+ vInv.clear();
+ }
+ }
+ }
+ pto->vInventoryToSend = vInvWait;
+ }
+ if (!vInv.empty())
+ pto->PushMessage("inv", vInv);
+
+
+ //
+ // Message: getdata
+ //
+ vector<CInv> vGetData;
+ int64 nNow = GetTime() * 1000000;
+ CTxDB txdb("r");
+ while (!pto->mapAskFor.empty() && (*pto->mapAskFor.begin()).first <= nNow)
+ {
+ const CInv& inv = (*pto->mapAskFor.begin()).second;
+ if (!AlreadyHave(txdb, inv))
+ {
+ printf("sending getdata: %s\n", inv.ToString().c_str());
+ vGetData.push_back(inv);
+ if (vGetData.size() >= 1000)
+ {
+ pto->PushMessage("getdata", vGetData);
+ vGetData.clear();
+ }
+ }
+ mapAlreadyAskedFor[inv] = nNow;
+ pto->mapAskFor.erase(pto->mapAskFor.begin());
+ }
+ if (!vGetData.empty())
+ pto->PushMessage("getdata", vGetData);
+
+ }
+ return true;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// BitcoinMiner
+//
+
+int static FormatHashBlocks(void* pbuffer, unsigned int len)
+{
+ unsigned char* pdata = (unsigned char*)pbuffer;
+ unsigned int blocks = 1 + ((len + 8) / 64);
+ unsigned char* pend = pdata + 64 * blocks;
+ memset(pdata + len, 0, 64 * blocks - len);
+ pdata[len] = 0x80;
+ unsigned int bits = len * 8;
+ pend[-1] = (bits >> 0) & 0xff;
+ pend[-2] = (bits >> 8) & 0xff;
+ pend[-3] = (bits >> 16) & 0xff;
+ pend[-4] = (bits >> 24) & 0xff;
+ return blocks;
+}
+
+static const unsigned int pSHA256InitState[8] =
+{0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
+
+void SHA256Transform(void* pstate, void* pinput, const void* pinit)
+{
+ SHA256_CTX ctx;
+ unsigned char data[64];
+
+ SHA256_Init(&ctx);
+
+ for (int i = 0; i < 16; i++)
+ ((uint32_t*)data)[i] = ByteReverse(((uint32_t*)pinput)[i]);
+
+ for (int i = 0; i < 8; i++)
+ ctx.h[i] = ((uint32_t*)pinit)[i];
+
+ SHA256_Update(&ctx, data, sizeof(data));
+ for (int i = 0; i < 8; i++)
+ ((uint32_t*)pstate)[i] = ctx.h[i];
+}
+
+//
+// ScanHash scans nonces looking for a hash with at least some zero bits.
+// It operates on big endian data. Caller does the byte reversing.
+// All input buffers are 16-byte aligned. nNonce is usually preserved
+// between calls, but periodically or if nNonce is 0xffff0000 or above,
+// the block is rebuilt and nNonce starts over at zero.
+//
+unsigned int static ScanHash_CryptoPP(char* pmidstate, char* pdata, char* phash1, char* phash, unsigned int& nHashesDone)
+{
+ unsigned int& nNonce = *(unsigned int*)(pdata + 12);
+ for (;;)
+ {
+ // Crypto++ SHA-256
+ // Hash pdata using pmidstate as the starting state into
+ // preformatted buffer phash1, then hash phash1 into phash
+ nNonce++;
+ SHA256Transform(phash1, pdata, pmidstate);
+ SHA256Transform(phash, phash1, pSHA256InitState);
+
+ // Return the nonce if the hash has at least some zero bits,
+ // caller will check if it has enough to reach the target
+ if (((unsigned short*)phash)[14] == 0)
+ return nNonce;
+
+ // If nothing found after trying for a while, return -1
+ if ((nNonce & 0xffff) == 0)
+ {
+ nHashesDone = 0xffff+1;
+ return -1;
+ }
+ }
+}
+
+// Some explaining would be appreciated
+class COrphan
+{
+public:
+ CTransaction* ptx;
+ set<uint256> setDependsOn;
+ double dPriority;
+
+ COrphan(CTransaction* ptxIn)
+ {
+ ptx = ptxIn;
+ dPriority = 0;
+ }
+
+ void print() const
+ {
+ printf("COrphan(hash=%s, dPriority=%.1f)\n", ptx->GetHash().ToString().substr(0,10).c_str(), dPriority);
+ BOOST_FOREACH(uint256 hash, setDependsOn)
+ printf(" setDependsOn %s\n", hash.ToString().substr(0,10).c_str());
+ }
+};
+
+
+CBlock* CreateNewBlock(CReserveKey& reservekey)
+{
+ CBlockIndex* pindexPrev = pindexBest;
+
+ // Create new block
+ auto_ptr<CBlock> pblock(new CBlock());
+ if (!pblock.get())
+ return NULL;
+
+ // Create coinbase tx
+ CTransaction txNew;
+ txNew.vin.resize(1);
+ txNew.vin[0].prevout.SetNull();
+ txNew.vout.resize(1);
+ txNew.vout[0].scriptPubKey << reservekey.GetReservedKey() << OP_CHECKSIG;
+
+ // Add our coinbase tx as first transaction
+ pblock->vtx.push_back(txNew);
+
+ // Collect memory pool transactions into the block
+ int64 nFees = 0;
+ CRITICAL_BLOCK(cs_main)
+ CRITICAL_BLOCK(cs_mapTransactions)
+ {
+ CTxDB txdb("r");
+
+ // Priority order to process transactions
+ list<COrphan> vOrphan; // list memory doesn't move
+ map<uint256, vector<COrphan*> > mapDependers;
+ multimap<double, CTransaction*> mapPriority;
+ for (map<uint256, CTransaction>::iterator mi = mapTransactions.begin(); mi != mapTransactions.end(); ++mi)
+ {
+ CTransaction& tx = (*mi).second;
+ if (tx.IsCoinBase() || !tx.IsFinal())
+ continue;
+
+ COrphan* porphan = NULL;
+ double dPriority = 0;
+ BOOST_FOREACH(const CTxIn& txin, tx.vin)
+ {
+ // Read prev transaction
+ CTransaction txPrev;
+ CTxIndex txindex;
+ if (!txPrev.ReadFromDisk(txdb, txin.prevout, txindex))
+ {
+ // Has to wait for dependencies
+ if (!porphan)
+ {
+ // Use list for automatic deletion
+ vOrphan.push_back(COrphan(&tx));
+ porphan = &vOrphan.back();
+ }
+ mapDependers[txin.prevout.hash].push_back(porphan);
+ porphan->setDependsOn.insert(txin.prevout.hash);
+ continue;
+ }
+ int64 nValueIn = txPrev.vout[txin.prevout.n].nValue;
+
+ // Read block header
+ int nConf = txindex.GetDepthInMainChain();
+
+ dPriority += (double)nValueIn * nConf;
+
+ if (fDebug && GetBoolArg("-printpriority"))
+ printf("priority nValueIn=%-12I64d nConf=%-5d dPriority=%-20.1f\n", nValueIn, nConf, dPriority);
+ }
+
+ // Priority is sum(valuein * age) / txsize
+ dPriority /= ::GetSerializeSize(tx, SER_NETWORK);
+
+ if (porphan)
+ porphan->dPriority = dPriority;
+ else
+ mapPriority.insert(make_pair(-dPriority, &(*mi).second));
+
+ if (fDebug && GetBoolArg("-printpriority"))
+ {
+ printf("priority %-20.1f %s\n%s", dPriority, tx.GetHash().ToString().substr(0,10).c_str(), tx.ToString().c_str());
+ if (porphan)
+ porphan->print();
+ printf("\n");
+ }
+ }
+
+ // Collect transactions into block
+ map<uint256, CTxIndex> mapTestPool;
+ uint64 nBlockSize = 1000;
+ int nBlockSigOps = 100;
+ while (!mapPriority.empty())
+ {
+ // Take highest priority transaction off priority queue
+ double dPriority = -(*mapPriority.begin()).first;
+ CTransaction& tx = *(*mapPriority.begin()).second;
+ mapPriority.erase(mapPriority.begin());
+
+ // Size limits
+ unsigned int nTxSize = ::GetSerializeSize(tx, SER_NETWORK);
+ if (nBlockSize + nTxSize >= MAX_BLOCK_SIZE_GEN)
+ continue;
+ int nTxSigOps = tx.GetSigOpCount();
+ if (nBlockSigOps + nTxSigOps >= MAX_BLOCK_SIGOPS)
+ continue;
+
+ // Transaction fee required depends on block size
+ bool fAllowFree = (nBlockSize + nTxSize < 4000 || CTransaction::AllowFree(dPriority));
+ int64 nMinFee = tx.GetMinFee(nBlockSize, fAllowFree);
+
+ // Connecting shouldn't fail due to dependency on other memory pool transactions
+ // because we're already processing them in order of dependency
+ map<uint256, CTxIndex> mapTestPoolTmp(mapTestPool);
+ bool fInvalid;
+ if (!tx.ConnectInputs(txdb, mapTestPoolTmp, CDiskTxPos(1,1,1), pindexPrev, nFees, false, true, nMinFee, fInvalid))
+ continue;
+ swap(mapTestPool, mapTestPoolTmp);
+
+ // Added
+ pblock->vtx.push_back(tx);
+ nBlockSize += nTxSize;
+ nBlockSigOps += nTxSigOps;
+
+ // Add transactions that depend on this one to the priority queue
+ uint256 hash = tx.GetHash();
+ if (mapDependers.count(hash))
+ {
+ BOOST_FOREACH(COrphan* porphan, mapDependers[hash])
+ {
+ if (!porphan->setDependsOn.empty())
+ {
+ porphan->setDependsOn.erase(hash);
+ if (porphan->setDependsOn.empty())
+ mapPriority.insert(make_pair(-porphan->dPriority, porphan->ptx));
+ }
+ }
+ }
+ }
+ }
+ pblock->vtx[0].vout[0].nValue = GetBlockValue(pindexPrev->nHeight+1, nFees);
+
+ // Fill in header
+ pblock->hashPrevBlock = pindexPrev->GetBlockHash();
+ pblock->hashMerkleRoot = pblock->BuildMerkleTree();
+ pblock->nTime = max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
+ pblock->nBits = GetNextWorkRequired(pindexPrev, pblock.get());
+ pblock->nNonce = 0;
+
+ return pblock.release();
+}
+
+
+void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce)
+{
+ // Update nExtraNonce
+ static uint256 hashPrevBlock;
+ if (hashPrevBlock != pblock->hashPrevBlock)
+ {
+ nExtraNonce = 0;
+ hashPrevBlock = pblock->hashPrevBlock;
+ }
+ ++nExtraNonce;
+ pblock->vtx[0].vin[0].scriptSig = CScript() << pblock->nTime << CBigNum(nExtraNonce);
+ pblock->hashMerkleRoot = pblock->BuildMerkleTree();
+}
+
+
+void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1)
+{
+ //
+ // Prebuild hash buffers
+ //
+ struct
+ {
+ struct unnamed2
+ {
+ int nVersion;
+ uint256 hashPrevBlock;
+ uint256 hashMerkleRoot;
+ unsigned int nTime;
+ unsigned int nBits;
+ unsigned int nNonce;
+ }
+ block;
+ unsigned char pchPadding0[64];
+ uint256 hash1;
+ unsigned char pchPadding1[64];
+ }
+ tmp;
+ memset(&tmp, 0, sizeof(tmp));
+
+ tmp.block.nVersion = pblock->nVersion;
+ tmp.block.hashPrevBlock = pblock->hashPrevBlock;
+ tmp.block.hashMerkleRoot = pblock->hashMerkleRoot;
+ tmp.block.nTime = pblock->nTime;
+ tmp.block.nBits = pblock->nBits;
+ tmp.block.nNonce = pblock->nNonce;
+
+ FormatHashBlocks(&tmp.block, sizeof(tmp.block));
+ FormatHashBlocks(&tmp.hash1, sizeof(tmp.hash1));
+
+ // Byte swap all the input buffer
+ for (int i = 0; i < sizeof(tmp)/4; i++)
+ ((unsigned int*)&tmp)[i] = ByteReverse(((unsigned int*)&tmp)[i]);
+
+ // Precalc the first half of the first hash, which stays constant
+ SHA256Transform(pmidstate, &tmp.block, pSHA256InitState);
+
+ memcpy(pdata, &tmp.block, 128);
+ memcpy(phash1, &tmp.hash1, 64);
+}
+
+
+bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey)
+{
+ uint256 hash = pblock->GetHash();
+ uint256 hashTarget = CBigNum().SetCompact(pblock->nBits).getuint256();
+
+ if (hash > hashTarget)
+ return false;
+
+ //// debug print
+ printf("BitcoinMiner:\n");
+ printf("proof-of-work found \n hash: %s \ntarget: %s\n", hash.GetHex().c_str(), hashTarget.GetHex().c_str());
+ pblock->print();
+ printf("%s ", DateTimeStrFormat("%x %H:%M", GetTime()).c_str());
+ printf("generated %s\n", FormatMoney(pblock->vtx[0].vout[0].nValue).c_str());
+
+ // Found a solution
+ CRITICAL_BLOCK(cs_main)
+ {
+ if (pblock->hashPrevBlock != hashBestChain)
+ return error("BitcoinMiner : generated block is stale");
+
+ // Remove key from key pool
+ reservekey.KeepKey();
+
+ // Track how many getdata requests this block gets
+ CRITICAL_BLOCK(wallet.cs_wallet)
+ wallet.mapRequestCount[pblock->GetHash()] = 0;
+
+ // Process this block the same as if we had received it from another node
+ if (!ProcessBlock(NULL, pblock))
+ return error("BitcoinMiner : ProcessBlock, block not accepted");
+ }
+
+ return true;
+}
+
+void static ThreadBitcoinMiner(void* parg);
+
+void static BitcoinMiner(CWallet *pwallet)
+{
+ printf("BitcoinMiner started\n");
+ SetThreadPriority(THREAD_PRIORITY_LOWEST);
+
+ // Each thread has its own key and counter
+ CReserveKey reservekey(pwallet);
+ unsigned int nExtraNonce = 0;
+
+ while (fGenerateBitcoins)
+ {
+ if (AffinityBugWorkaround(ThreadBitcoinMiner))
+ return;
+ if (fShutdown)
+ return;
+ while (vNodes.empty() || IsInitialBlockDownload())
+ {
+ Sleep(1000);
+ if (fShutdown)
+ return;
+ if (!fGenerateBitcoins)
+ return;
+ }
+
+
+ //
+ // Create new block
+ //
+ unsigned int nTransactionsUpdatedLast = nTransactionsUpdated;
+ CBlockIndex* pindexPrev = pindexBest;
+
+ auto_ptr<CBlock> pblock(CreateNewBlock(reservekey));
+ if (!pblock.get())
+ return;
+ IncrementExtraNonce(pblock.get(), pindexPrev, nExtraNonce);
+
+ printf("Running BitcoinMiner with %d transactions in block\n", pblock->vtx.size());
+
+
+ //
+ // Prebuild hash buffers
+ //
+ char pmidstatebuf[32+16]; char* pmidstate = alignup<16>(pmidstatebuf);
+ char pdatabuf[128+16]; char* pdata = alignup<16>(pdatabuf);
+ char phash1buf[64+16]; char* phash1 = alignup<16>(phash1buf);
+
+ FormatHashBuffers(pblock.get(), pmidstate, pdata, phash1);
+
+ unsigned int& nBlockTime = *(unsigned int*)(pdata + 64 + 4);
+ unsigned int& nBlockNonce = *(unsigned int*)(pdata + 64 + 12);
+
+
+ //
+ // Search
+ //
+ int64 nStart = GetTime();
+ uint256 hashTarget = CBigNum().SetCompact(pblock->nBits).getuint256();
+ uint256 hashbuf[2];
+ uint256& hash = *alignup<16>(hashbuf);
+ loop
+ {
+ unsigned int nHashesDone = 0;
+ unsigned int nNonceFound;
+
+ // Crypto++ SHA-256
+ nNonceFound = ScanHash_CryptoPP(pmidstate, pdata + 64, phash1,
+ (char*)&hash, nHashesDone);
+
+ // Check if something found
+ if (nNonceFound != -1)
+ {
+ for (int i = 0; i < sizeof(hash)/4; i++)
+ ((unsigned int*)&hash)[i] = ByteReverse(((unsigned int*)&hash)[i]);
+
+ if (hash <= hashTarget)
+ {
+ // Found a solution
+ pblock->nNonce = ByteReverse(nNonceFound);
+ assert(hash == pblock->GetHash());
+
+ SetThreadPriority(THREAD_PRIORITY_NORMAL);
+ CheckWork(pblock.get(), *pwalletMain, reservekey);
+ SetThreadPriority(THREAD_PRIORITY_LOWEST);
+ break;
+ }
+ }
+
+ // Meter hashes/sec
+ static int64 nHashCounter;
+ if (nHPSTimerStart == 0)
+ {
+ nHPSTimerStart = GetTimeMillis();
+ nHashCounter = 0;
+ }
+ else
+ nHashCounter += nHashesDone;
+ if (GetTimeMillis() - nHPSTimerStart > 4000)
+ {
+ static CCriticalSection cs;
+ CRITICAL_BLOCK(cs)
+ {
+ if (GetTimeMillis() - nHPSTimerStart > 4000)
+ {
+ dHashesPerSec = 1000.0 * nHashCounter / (GetTimeMillis() - nHPSTimerStart);
+ nHPSTimerStart = GetTimeMillis();
+ nHashCounter = 0;
+ string strStatus = strprintf(" %.0f khash/s", dHashesPerSec/1000.0);
+ UIThreadCall(boost::bind(CalledSetStatusBar, strStatus, 0));
+ static int64 nLogTime;
+ if (GetTime() - nLogTime > 30 * 60)
+ {
+ nLogTime = GetTime();
+ printf("%s ", DateTimeStrFormat("%x %H:%M", GetTime()).c_str());
+ printf("hashmeter %3d CPUs %6.0f khash/s\n", vnThreadsRunning[3], dHashesPerSec/1000.0);
+ }
+ }
+ }
+ }
+
+ // Check for stop or if block needs to be rebuilt
+ if (fShutdown)
+ return;
+ if (!fGenerateBitcoins)
+ return;
+ if (fLimitProcessors && vnThreadsRunning[3] > nLimitProcessors)
+ return;
+ if (vNodes.empty())
+ break;
+ if (nBlockNonce >= 0xffff0000)
+ break;
+ if (nTransactionsUpdated != nTransactionsUpdatedLast && GetTime() - nStart > 60)
+ break;
+ if (pindexPrev != pindexBest)
+ break;
+
+ // Update nTime every few seconds
+ pblock->nTime = max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime());
+ nBlockTime = ByteReverse(pblock->nTime);
+ }
+ }
+}
+
+void static ThreadBitcoinMiner(void* parg)
+{
+ CWallet* pwallet = (CWallet*)parg;
+ try
+ {
+ vnThreadsRunning[3]++;
+ BitcoinMiner(pwallet);
+ vnThreadsRunning[3]--;
+ }
+ catch (std::exception& e) {
+ vnThreadsRunning[3]--;
+ PrintException(&e, "ThreadBitcoinMiner()");
+ } catch (...) {
+ vnThreadsRunning[3]--;
+ PrintException(NULL, "ThreadBitcoinMiner()");
+ }
+ UIThreadCall(boost::bind(CalledSetStatusBar, "", 0));
+ nHPSTimerStart = 0;
+ if (vnThreadsRunning[3] == 0)
+ dHashesPerSec = 0;
+ printf("ThreadBitcoinMiner exiting, %d threads remaining\n", vnThreadsRunning[3]);
+}
+
+
+void GenerateBitcoins(bool fGenerate, CWallet* pwallet)
+{
+ if (fGenerateBitcoins != fGenerate)
+ {
+ fGenerateBitcoins = fGenerate;
+ WriteSetting("fGenerateBitcoins", fGenerateBitcoins);
+ MainFrameRepaint();
+ }
+ if (fGenerateBitcoins)
+ {
+ int nProcessors = boost::thread::hardware_concurrency();
+ printf("%d processors\n", nProcessors);
+ if (nProcessors < 1)
+ nProcessors = 1;
+ if (fLimitProcessors && nProcessors > nLimitProcessors)
+ nProcessors = nLimitProcessors;
+ int nAddThreads = nProcessors - vnThreadsRunning[3];
+ printf("Starting %d BitcoinMiner threads\n", nAddThreads);
+ for (int i = 0; i < nAddThreads; i++)
+ {
+ if (!CreateThread(ThreadBitcoinMiner, pwallet))
+ printf("Error: CreateThread(ThreadBitcoinMiner) failed\n");
+ Sleep(10);
+ }
+ }
+}
diff --git a/bitcoin/src/main.h b/bitcoin/src/main.h
@@ -0,0 +1,1571 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2012 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#ifndef BITCOIN_MAIN_H
+#define BITCOIN_MAIN_H
+
+#include "bignum.h"
+#include "net.h"
+#include "key.h"
+#include "script.h"
+#include "db.h"
+
+#include <list>
+
+class CBlock;
+class CBlockIndex;
+class CWalletTx;
+class CWallet;
+class CKeyItem;
+class CReserveKey;
+class CWalletDB;
+
+class CAddress;
+class CInv;
+class CRequestTracker;
+class CNode;
+class CBlockIndex;
+
+static const unsigned int MAX_BLOCK_SIZE = 1000000;
+static const unsigned int MAX_BLOCK_SIZE_GEN = MAX_BLOCK_SIZE/2;
+static const int MAX_BLOCK_SIGOPS = MAX_BLOCK_SIZE/50;
+static const int MAX_ORPHAN_TRANSACTIONS = MAX_BLOCK_SIZE/100;
+static const int64 COIN = 100000000;
+static const int64 CENT = 1000000;
+static const int64 MIN_TX_FEE = 50000;
+static const int64 MIN_RELAY_TX_FEE = 10000;
+static const int64 MAX_MONEY = 21000000 * COIN;
+inline bool MoneyRange(int64 nValue) { return (nValue >= 0 && nValue <= MAX_MONEY); }
+static const int COINBASE_MATURITY = 100;
+// Threshold for nLockTime: below this value it is interpreted as block number, otherwise as UNIX timestamp.
+static const int LOCKTIME_THRESHOLD = 500000000; // Tue Nov 5 00:53:20 1985 UTC
+#ifdef USE_UPNP
+static const int fHaveUPnP = true;
+#else
+static const int fHaveUPnP = false;
+#endif
+
+
+
+
+
+
+extern CCriticalSection cs_main;
+extern std::map<uint256, CBlockIndex*> mapBlockIndex;
+extern uint256 hashGenesisBlock;
+extern CBlockIndex* pindexGenesisBlock;
+extern int nBestHeight;
+extern CBigNum bnBestChainWork;
+extern CBigNum bnBestInvalidWork;
+extern uint256 hashBestChain;
+extern CBlockIndex* pindexBest;
+extern unsigned int nTransactionsUpdated;
+extern double dHashesPerSec;
+extern int64 nHPSTimerStart;
+extern int64 nTimeBestReceived;
+extern CCriticalSection cs_setpwalletRegistered;
+extern std::set<CWallet*> setpwalletRegistered;
+
+// Settings
+extern int fGenerateBitcoins;
+extern int64 nTransactionFee;
+extern int fLimitProcessors;
+extern int nLimitProcessors;
+extern int fMinimizeToTray;
+extern int fMinimizeOnClose;
+extern int fUseUPnP;
+
+
+
+
+
+class CReserveKey;
+class CTxDB;
+class CTxIndex;
+
+void RegisterWallet(CWallet* pwalletIn);
+void UnregisterWallet(CWallet* pwalletIn);
+bool ProcessBlock(CNode* pfrom, CBlock* pblock);
+bool CheckDiskSpace(uint64 nAdditionalBytes=0);
+FILE* OpenBlockFile(unsigned int nFile, unsigned int nBlockPos, const char* pszMode="rb");
+FILE* AppendBlockFile(unsigned int& nFileRet);
+bool LoadBlockIndex(bool fAllowNew=true);
+void PrintBlockTree();
+bool ProcessMessages(CNode* pfrom);
+bool SendMessages(CNode* pto, bool fSendTrickle);
+void GenerateBitcoins(bool fGenerate, CWallet* pwallet);
+CBlock* CreateNewBlock(CReserveKey& reservekey);
+void IncrementExtraNonce(CBlock* pblock, CBlockIndex* pindexPrev, unsigned int& nExtraNonce);
+void FormatHashBuffers(CBlock* pblock, char* pmidstate, char* pdata, char* phash1);
+bool CheckWork(CBlock* pblock, CWallet& wallet, CReserveKey& reservekey);
+bool CheckProofOfWork(uint256 hash, unsigned int nBits);
+unsigned int ComputeMinWork(unsigned int nBase, int64 nTime);
+int GetNumBlocksOfPeers();
+bool IsInitialBlockDownload();
+std::string GetWarnings(std::string strFor);
+
+
+
+
+
+
+
+
+
+
+
+
+bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
+
+template<typename T>
+bool WriteSetting(const std::string& strKey, const T& value)
+{
+ bool fOk = false;
+ BOOST_FOREACH(CWallet* pwallet, setpwalletRegistered)
+ {
+ std::string strWalletFile;
+ if (!GetWalletFile(pwallet, strWalletFile))
+ continue;
+ fOk |= CWalletDB(strWalletFile).WriteSetting(strKey, value);
+ }
+ return fOk;
+}
+
+
+class CDiskTxPos
+{
+public:
+ unsigned int nFile;
+ unsigned int nBlockPos;
+ unsigned int nTxPos;
+
+ CDiskTxPos()
+ {
+ SetNull();
+ }
+
+ CDiskTxPos(unsigned int nFileIn, unsigned int nBlockPosIn, unsigned int nTxPosIn)
+ {
+ nFile = nFileIn;
+ nBlockPos = nBlockPosIn;
+ nTxPos = nTxPosIn;
+ }
+
+ IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
+ void SetNull() { nFile = -1; nBlockPos = 0; nTxPos = 0; }
+ bool IsNull() const { return (nFile == -1); }
+
+ friend bool operator==(const CDiskTxPos& a, const CDiskTxPos& b)
+ {
+ return (a.nFile == b.nFile &&
+ a.nBlockPos == b.nBlockPos &&
+ a.nTxPos == b.nTxPos);
+ }
+
+ friend bool operator!=(const CDiskTxPos& a, const CDiskTxPos& b)
+ {
+ return !(a == b);
+ }
+
+ std::string ToString() const
+ {
+ if (IsNull())
+ return strprintf("null");
+ else
+ return strprintf("(nFile=%d, nBlockPos=%d, nTxPos=%d)", nFile, nBlockPos, nTxPos);
+ }
+
+ void print() const
+ {
+ printf("%s", ToString().c_str());
+ }
+};
+
+
+
+
+class CInPoint
+{
+public:
+ CTransaction* ptx;
+ unsigned int n;
+
+ CInPoint() { SetNull(); }
+ CInPoint(CTransaction* ptxIn, unsigned int nIn) { ptx = ptxIn; n = nIn; }
+ void SetNull() { ptx = NULL; n = -1; }
+ bool IsNull() const { return (ptx == NULL && n == -1); }
+};
+
+
+
+
+class COutPoint
+{
+public:
+ uint256 hash;
+ unsigned int n;
+
+ COutPoint() { SetNull(); }
+ COutPoint(uint256 hashIn, unsigned int nIn) { hash = hashIn; n = nIn; }
+ IMPLEMENT_SERIALIZE( READWRITE(FLATDATA(*this)); )
+ void SetNull() { hash = 0; n = -1; }
+ bool IsNull() const { return (hash == 0 && n == -1); }
+
+ friend bool operator<(const COutPoint& a, const COutPoint& b)
+ {
+ return (a.hash < b.hash || (a.hash == b.hash && a.n < b.n));
+ }
+
+ friend bool operator==(const COutPoint& a, const COutPoint& b)
+ {
+ return (a.hash == b.hash && a.n == b.n);
+ }
+
+ friend bool operator!=(const COutPoint& a, const COutPoint& b)
+ {
+ return !(a == b);
+ }
+
+ std::string ToString() const
+ {
+ return strprintf("COutPoint(%s, %d)", hash.ToString().substr(0,10).c_str(), n);
+ }
+
+ void print() const
+ {
+ printf("%s\n", ToString().c_str());
+ }
+};
+
+
+
+
+//
+// An input of a transaction. It contains the location of the previous
+// transaction's output that it claims and a signature that matches the
+// output's public key.
+//
+class CTxIn
+{
+public:
+ COutPoint prevout;
+ CScript scriptSig;
+ unsigned int nSequence;
+
+ CTxIn()
+ {
+ nSequence = UINT_MAX;
+ }
+
+ explicit CTxIn(COutPoint prevoutIn, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=UINT_MAX)
+ {
+ prevout = prevoutIn;
+ scriptSig = scriptSigIn;
+ nSequence = nSequenceIn;
+ }
+
+ CTxIn(uint256 hashPrevTx, unsigned int nOut, CScript scriptSigIn=CScript(), unsigned int nSequenceIn=UINT_MAX)
+ {
+ prevout = COutPoint(hashPrevTx, nOut);
+ scriptSig = scriptSigIn;
+ nSequence = nSequenceIn;
+ }
+
+ IMPLEMENT_SERIALIZE
+ (
+ READWRITE(prevout);
+ READWRITE(scriptSig);
+ READWRITE(nSequence);
+ )
+
+ bool IsFinal() const
+ {
+ return (nSequence == UINT_MAX);
+ }
+
+ friend bool operator==(const CTxIn& a, const CTxIn& b)
+ {
+ return (a.prevout == b.prevout &&
+ a.scriptSig == b.scriptSig &&
+ a.nSequence == b.nSequence);
+ }
+
+ friend bool operator!=(const CTxIn& a, const CTxIn& b)
+ {
+ return !(a == b);
+ }
+
+ std::string ToString() const
+ {
+ std::string str;
+ str += strprintf("CTxIn(");
+ str += prevout.ToString();
+ if (prevout.IsNull())
+ str += strprintf(", coinbase %s", HexStr(scriptSig).c_str());
+ else
+ str += strprintf(", scriptSig=%s", scriptSig.ToString().substr(0,24).c_str());
+ if (nSequence != UINT_MAX)
+ str += strprintf(", nSequence=%u", nSequence);
+ str += ")";
+ return str;
+ }
+
+ void print() const
+ {
+ printf("%s\n", ToString().c_str());
+ }
+};
+
+
+
+
+//
+// An output of a transaction. It contains the public key that the next input
+// must be able to sign with to claim it.
+//
+class CTxOut
+{
+public:
+ int64 nValue;
+ CScript scriptPubKey;
+
+ CTxOut()
+ {
+ SetNull();
+ }
+
+ CTxOut(int64 nValueIn, CScript scriptPubKeyIn)
+ {
+ nValue = nValueIn;
+ scriptPubKey = scriptPubKeyIn;
+ }
+
+ IMPLEMENT_SERIALIZE
+ (
+ READWRITE(nValue);
+ READWRITE(scriptPubKey);
+ )
+
+ void SetNull()
+ {
+ nValue = -1;
+ scriptPubKey.clear();
+ }
+
+ bool IsNull()
+ {
+ return (nValue == -1);
+ }
+
+ uint256 GetHash() const
+ {
+ return SerializeHash(*this);
+ }
+
+ friend bool operator==(const CTxOut& a, const CTxOut& b)
+ {
+ return (a.nValue == b.nValue &&
+ a.scriptPubKey == b.scriptPubKey);
+ }
+
+ friend bool operator!=(const CTxOut& a, const CTxOut& b)
+ {
+ return !(a == b);
+ }
+
+ std::string ToString() const
+ {
+ if (scriptPubKey.size() < 6)
+ return "CTxOut(error)";
+ return strprintf("CTxOut(nValue=%"PRI64d".%08"PRI64d", scriptPubKey=%s)", nValue / COIN, nValue % COIN, scriptPubKey.ToString().substr(0,30).c_str());
+ }
+
+ void print() const
+ {
+ printf("%s\n", ToString().c_str());
+ }
+};
+
+
+
+
+//
+// The basic transaction that is broadcasted on the network and contained in
+// blocks. A transaction can contain multiple inputs and outputs.
+//
+class CTransaction
+{
+public:
+ int nVersion;
+ std::vector<CTxIn> vin;
+ std::vector<CTxOut> vout;
+ unsigned int nLockTime;
+
+ // Denial-of-service detection:
+ mutable int nDoS;
+ bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
+
+ CTransaction()
+ {
+ SetNull();
+ }
+
+ IMPLEMENT_SERIALIZE
+ (
+ READWRITE(this->nVersion);
+ nVersion = this->nVersion;
+ READWRITE(vin);
+ READWRITE(vout);
+ READWRITE(nLockTime);
+ )
+
+ void SetNull()
+ {
+ nVersion = 1;
+ vin.clear();
+ vout.clear();
+ nLockTime = 0;
+ nDoS = 0; // Denial-of-service prevention
+ }
+
+ bool IsNull() const
+ {
+ return (vin.empty() && vout.empty());
+ }
+
+ uint256 GetHash() const
+ {
+ return SerializeHash(*this);
+ }
+
+ bool IsFinal(int nBlockHeight=0, int64 nBlockTime=0) const
+ {
+ // Time based nLockTime implemented in 0.1.6
+ if (nLockTime == 0)
+ return true;
+ if (nBlockHeight == 0)
+ nBlockHeight = nBestHeight;
+ if (nBlockTime == 0)
+ nBlockTime = GetAdjustedTime();
+ if ((int64)nLockTime < (nLockTime < LOCKTIME_THRESHOLD ? (int64)nBlockHeight : nBlockTime))
+ return true;
+ BOOST_FOREACH(const CTxIn& txin, vin)
+ if (!txin.IsFinal())
+ return false;
+ return true;
+ }
+
+ bool IsNewerThan(const CTransaction& old) const
+ {
+ if (vin.size() != old.vin.size())
+ return false;
+ for (int i = 0; i < vin.size(); i++)
+ if (vin[i].prevout != old.vin[i].prevout)
+ return false;
+
+ bool fNewer = false;
+ unsigned int nLowest = UINT_MAX;
+ for (int i = 0; i < vin.size(); i++)
+ {
+ if (vin[i].nSequence != old.vin[i].nSequence)
+ {
+ if (vin[i].nSequence <= nLowest)
+ {
+ fNewer = false;
+ nLowest = vin[i].nSequence;
+ }
+ if (old.vin[i].nSequence < nLowest)
+ {
+ fNewer = true;
+ nLowest = old.vin[i].nSequence;
+ }
+ }
+ }
+ return fNewer;
+ }
+
+ bool IsCoinBase() const
+ {
+ return (vin.size() == 1 && vin[0].prevout.IsNull());
+ }
+
+ int GetSigOpCount() const
+ {
+ int n = 0;
+ BOOST_FOREACH(const CTxIn& txin, vin)
+ n += txin.scriptSig.GetSigOpCount();
+ BOOST_FOREACH(const CTxOut& txout, vout)
+ n += txout.scriptPubKey.GetSigOpCount();
+ return n;
+ }
+
+ bool IsStandard() const
+ {
+ BOOST_FOREACH(const CTxIn& txin, vin)
+ if (!txin.scriptSig.IsPushOnly())
+ return error("nonstandard txin: %s", txin.scriptSig.ToString().c_str());
+ BOOST_FOREACH(const CTxOut& txout, vout)
+ if (!::IsStandard(txout.scriptPubKey))
+ return error("nonstandard txout: %s", txout.scriptPubKey.ToString().c_str());
+ return true;
+ }
+
+ int64 GetValueOut() const
+ {
+ int64 nValueOut = 0;
+ BOOST_FOREACH(const CTxOut& txout, vout)
+ {
+ nValueOut += txout.nValue;
+ if (!MoneyRange(txout.nValue) || !MoneyRange(nValueOut))
+ throw std::runtime_error("CTransaction::GetValueOut() : value out of range");
+ }
+ return nValueOut;
+ }
+
+ static bool AllowFree(double dPriority)
+ {
+ // Large (in bytes) low-priority (new, small-coin) transactions
+ // need a fee.
+ return dPriority > COIN * 144 / 250;
+ }
+
+ int64 GetMinFee(unsigned int nBlockSize=1, bool fAllowFree=true, bool fForRelay=false) const
+ {
+ // Base fee is either MIN_TX_FEE or MIN_RELAY_TX_FEE
+ int64 nBaseFee = fForRelay ? MIN_RELAY_TX_FEE : MIN_TX_FEE;
+
+ unsigned int nBytes = ::GetSerializeSize(*this, SER_NETWORK);
+ unsigned int nNewBlockSize = nBlockSize + nBytes;
+ int64 nMinFee = (1 + (int64)nBytes / 1000) * nBaseFee;
+
+ if (fAllowFree)
+ {
+ if (nBlockSize == 1)
+ {
+ // Transactions under 10K are free
+ // (about 4500bc if made of 50bc inputs)
+ if (nBytes < 10000)
+ nMinFee = 0;
+ }
+ else
+ {
+ // Free transaction area
+ if (nNewBlockSize < 27000)
+ nMinFee = 0;
+ }
+ }
+
+ // To limit dust spam, require MIN_TX_FEE/MIN_RELAY_TX_FEE if any output is less than 0.01
+ if (nMinFee < nBaseFee)
+ BOOST_FOREACH(const CTxOut& txout, vout)
+ if (txout.nValue < CENT)
+ nMinFee = nBaseFee;
+
+ // Raise the price as the block approaches full
+ if (nBlockSize != 1 && nNewBlockSize >= MAX_BLOCK_SIZE_GEN/2)
+ {
+ if (nNewBlockSize >= MAX_BLOCK_SIZE_GEN)
+ return MAX_MONEY;
+ nMinFee *= MAX_BLOCK_SIZE_GEN / (MAX_BLOCK_SIZE_GEN - nNewBlockSize);
+ }
+
+ if (!MoneyRange(nMinFee))
+ nMinFee = MAX_MONEY;
+ return nMinFee;
+ }
+
+
+ bool ReadFromDisk(CDiskTxPos pos, FILE** pfileRet=NULL)
+ {
+ CAutoFile filein = OpenBlockFile(pos.nFile, 0, pfileRet ? "rb+" : "rb");
+ if (!filein)
+ return error("CTransaction::ReadFromDisk() : OpenBlockFile failed");
+
+ // Read transaction
+ if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
+ return error("CTransaction::ReadFromDisk() : fseek failed");
+ filein >> *this;
+
+ // Return file pointer
+ if (pfileRet)
+ {
+ if (fseek(filein, pos.nTxPos, SEEK_SET) != 0)
+ return error("CTransaction::ReadFromDisk() : second fseek failed");
+ *pfileRet = filein.release();
+ }
+ return true;
+ }
+
+ friend bool operator==(const CTransaction& a, const CTransaction& b)
+ {
+ return (a.nVersion == b.nVersion &&
+ a.vin == b.vin &&
+ a.vout == b.vout &&
+ a.nLockTime == b.nLockTime);
+ }
+
+ friend bool operator!=(const CTransaction& a, const CTransaction& b)
+ {
+ return !(a == b);
+ }
+
+
+ std::string ToString() const
+ {
+ std::string str;
+ str += strprintf("CTransaction(hash=%s, ver=%d, vin.size=%d, vout.size=%d, nLockTime=%d)\n",
+ GetHash().ToString().substr(0,10).c_str(),
+ nVersion,
+ vin.size(),
+ vout.size(),
+ nLockTime);
+ for (int i = 0; i < vin.size(); i++)
+ str += " " + vin[i].ToString() + "\n";
+ for (int i = 0; i < vout.size(); i++)
+ str += " " + vout[i].ToString() + "\n";
+ return str;
+ }
+
+ void print() const
+ {
+ printf("%s", ToString().c_str());
+ }
+
+
+ bool ReadFromDisk(CTxDB& txdb, COutPoint prevout, CTxIndex& txindexRet);
+ bool ReadFromDisk(CTxDB& txdb, COutPoint prevout);
+ bool ReadFromDisk(COutPoint prevout);
+ bool DisconnectInputs(CTxDB& txdb);
+ bool ConnectInputs(CTxDB& txdb, std::map<uint256, CTxIndex>& mapTestPool, CDiskTxPos posThisTx,
+ CBlockIndex* pindexBlock, int64& nFees, bool fBlock, bool fMiner, int64 nMinFee,
+ bool& fInvalid);
+ bool ClientConnectInputs();
+ bool CheckTransaction() const;
+ bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true, bool* pfMissingInputs=NULL);
+ bool AcceptToMemoryPool(bool fCheckInputs=true, bool* pfMissingInputs=NULL);
+protected:
+ bool AddToMemoryPoolUnchecked();
+public:
+ bool RemoveFromMemoryPool();
+};
+
+
+
+
+
+//
+// A transaction with a merkle branch linking it to the block chain
+//
+class CMerkleTx : public CTransaction
+{
+public:
+ uint256 hashBlock;
+ std::vector<uint256> vMerkleBranch;
+ int nIndex;
+
+ // memory only
+ mutable char fMerkleVerified;
+
+
+ CMerkleTx()
+ {
+ Init();
+ }
+
+ CMerkleTx(const CTransaction& txIn) : CTransaction(txIn)
+ {
+ Init();
+ }
+
+ void Init()
+ {
+ hashBlock = 0;
+ nIndex = -1;
+ fMerkleVerified = false;
+ }
+
+
+ IMPLEMENT_SERIALIZE
+ (
+ nSerSize += SerReadWrite(s, *(CTransaction*)this, nType, nVersion, ser_action);
+ nVersion = this->nVersion;
+ READWRITE(hashBlock);
+ READWRITE(vMerkleBranch);
+ READWRITE(nIndex);
+ )
+
+
+ int SetMerkleBranch(const CBlock* pblock=NULL);
+ int GetDepthInMainChain(int& nHeightRet) const;
+ int GetDepthInMainChain() const { int nHeight; return GetDepthInMainChain(nHeight); }
+ bool IsInMainChain() const { return GetDepthInMainChain() > 0; }
+ int GetBlocksToMaturity() const;
+ bool AcceptToMemoryPool(CTxDB& txdb, bool fCheckInputs=true);
+ bool AcceptToMemoryPool();
+};
+
+
+
+
+//
+// A txdb record that contains the disk location of a transaction and the
+// locations of transactions that spend its outputs. vSpent is really only
+// used as a flag, but having the location is very helpful for debugging.
+//
+class CTxIndex
+{
+public:
+ CDiskTxPos pos;
+ std::vector<CDiskTxPos> vSpent;
+
+ CTxIndex()
+ {
+ SetNull();
+ }
+
+ CTxIndex(const CDiskTxPos& posIn, unsigned int nOutputs)
+ {
+ pos = posIn;
+ vSpent.resize(nOutputs);
+ }
+
+ IMPLEMENT_SERIALIZE
+ (
+ if (!(nType & SER_GETHASH))
+ READWRITE(nVersion);
+ READWRITE(pos);
+ READWRITE(vSpent);
+ )
+
+ void SetNull()
+ {
+ pos.SetNull();
+ vSpent.clear();
+ }
+
+ bool IsNull()
+ {
+ return pos.IsNull();
+ }
+
+ friend bool operator==(const CTxIndex& a, const CTxIndex& b)
+ {
+ return (a.pos == b.pos &&
+ a.vSpent == b.vSpent);
+ }
+
+ friend bool operator!=(const CTxIndex& a, const CTxIndex& b)
+ {
+ return !(a == b);
+ }
+ int GetDepthInMainChain() const;
+};
+
+
+
+
+
+//
+// Nodes collect new transactions into a block, hash them into a hash tree,
+// and scan through nonce values to make the block's hash satisfy proof-of-work
+// requirements. When they solve the proof-of-work, they broadcast the block
+// to everyone and the block is added to the block chain. The first transaction
+// in the block is a special one that creates a new coin owned by the creator
+// of the block.
+//
+// Blocks are appended to blk0001.dat files on disk. Their location on disk
+// is indexed by CBlockIndex objects in memory.
+//
+class CBlock
+{
+public:
+ // header
+ int nVersion;
+ uint256 hashPrevBlock;
+ uint256 hashMerkleRoot;
+ unsigned int nTime;
+ unsigned int nBits;
+ unsigned int nNonce;
+
+ // network and disk
+ std::vector<CTransaction> vtx;
+
+ // memory only
+ mutable std::vector<uint256> vMerkleTree;
+
+ // Denial-of-service detection:
+ mutable int nDoS;
+ bool DoS(int nDoSIn, bool fIn) const { nDoS += nDoSIn; return fIn; }
+
+ CBlock()
+ {
+ SetNull();
+ }
+
+ IMPLEMENT_SERIALIZE
+ (
+ READWRITE(this->nVersion);
+ nVersion = this->nVersion;
+ READWRITE(hashPrevBlock);
+ READWRITE(hashMerkleRoot);
+ READWRITE(nTime);
+ READWRITE(nBits);
+ READWRITE(nNonce);
+
+ // ConnectBlock depends on vtx being last so it can calculate offset
+ if (!(nType & (SER_GETHASH|SER_BLOCKHEADERONLY)))
+ READWRITE(vtx);
+ else if (fRead)
+ const_cast<CBlock*>(this)->vtx.clear();
+ )
+
+ void SetNull()
+ {
+ nVersion = 1;
+ hashPrevBlock = 0;
+ hashMerkleRoot = 0;
+ nTime = 0;
+ nBits = 0;
+ nNonce = 0;
+ vtx.clear();
+ vMerkleTree.clear();
+ nDoS = 0;
+ }
+
+ bool IsNull() const
+ {
+ return (nBits == 0);
+ }
+
+ uint256 GetHash() const
+ {
+ return Hash(BEGIN(nVersion), END(nNonce));
+ }
+
+ int64 GetBlockTime() const
+ {
+ return (int64)nTime;
+ }
+
+ int GetSigOpCount() const
+ {
+ int n = 0;
+ BOOST_FOREACH(const CTransaction& tx, vtx)
+ n += tx.GetSigOpCount();
+ return n;
+ }
+
+
+ uint256 BuildMerkleTree() const
+ {
+ vMerkleTree.clear();
+ BOOST_FOREACH(const CTransaction& tx, vtx)
+ vMerkleTree.push_back(tx.GetHash());
+ int j = 0;
+ for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
+ {
+ for (int i = 0; i < nSize; i += 2)
+ {
+ int i2 = std::min(i+1, nSize-1);
+ vMerkleTree.push_back(Hash(BEGIN(vMerkleTree[j+i]), END(vMerkleTree[j+i]),
+ BEGIN(vMerkleTree[j+i2]), END(vMerkleTree[j+i2])));
+ }
+ j += nSize;
+ }
+ return (vMerkleTree.empty() ? 0 : vMerkleTree.back());
+ }
+
+ std::vector<uint256> GetMerkleBranch(int nIndex) const
+ {
+ if (vMerkleTree.empty())
+ BuildMerkleTree();
+ std::vector<uint256> vMerkleBranch;
+ int j = 0;
+ for (int nSize = vtx.size(); nSize > 1; nSize = (nSize + 1) / 2)
+ {
+ int i = std::min(nIndex^1, nSize-1);
+ vMerkleBranch.push_back(vMerkleTree[j+i]);
+ nIndex >>= 1;
+ j += nSize;
+ }
+ return vMerkleBranch;
+ }
+
+ static uint256 CheckMerkleBranch(uint256 hash, const std::vector<uint256>& vMerkleBranch, int nIndex)
+ {
+ if (nIndex == -1)
+ return 0;
+ BOOST_FOREACH(const uint256& otherside, vMerkleBranch)
+ {
+ if (nIndex & 1)
+ hash = Hash(BEGIN(otherside), END(otherside), BEGIN(hash), END(hash));
+ else
+ hash = Hash(BEGIN(hash), END(hash), BEGIN(otherside), END(otherside));
+ nIndex >>= 1;
+ }
+ return hash;
+ }
+
+
+ bool WriteToDisk(unsigned int& nFileRet, unsigned int& nBlockPosRet)
+ {
+ // Open history file to append
+ CAutoFile fileout = AppendBlockFile(nFileRet);
+ if (!fileout)
+ return error("CBlock::WriteToDisk() : AppendBlockFile failed");
+
+ // Write index header
+ unsigned int nSize = fileout.GetSerializeSize(*this);
+ fileout << FLATDATA(pchMessageStart) << nSize;
+
+ // Write block
+ nBlockPosRet = ftell(fileout);
+ if (nBlockPosRet == -1)
+ return error("CBlock::WriteToDisk() : ftell failed");
+ fileout << *this;
+
+ // Flush stdio buffers and commit to disk before returning
+ fflush(fileout);
+ if (!IsInitialBlockDownload() || (nBestHeight+1) % 500 == 0)
+ {
+#ifdef WIN32
+ _commit(_fileno(fileout));
+#else
+ fsync(fileno(fileout));
+#endif
+ }
+
+ return true;
+ }
+
+ bool ReadFromDisk(unsigned int nFile, unsigned int nBlockPos, bool fReadTransactions=true)
+ {
+ SetNull();
+
+ // Open history file to read
+ CAutoFile filein = OpenBlockFile(nFile, nBlockPos, "rb");
+ if (!filein)
+ return error("CBlock::ReadFromDisk() : OpenBlockFile failed");
+ if (!fReadTransactions)
+ filein.nType |= SER_BLOCKHEADERONLY;
+
+ // Read block
+ filein >> *this;
+
+ // Check the header
+ if (!CheckProofOfWork(GetHash(), nBits))
+ return error("CBlock::ReadFromDisk() : errors in block header");
+
+ return true;
+ }
+
+
+
+ void print() const
+ {
+ printf("CBlock(hash=%s, ver=%d, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%d)\n",
+ GetHash().ToString().substr(0,20).c_str(),
+ nVersion,
+ hashPrevBlock.ToString().substr(0,20).c_str(),
+ hashMerkleRoot.ToString().substr(0,10).c_str(),
+ nTime, nBits, nNonce,
+ vtx.size());
+ for (int i = 0; i < vtx.size(); i++)
+ {
+ printf(" ");
+ vtx[i].print();
+ }
+ printf(" vMerkleTree: ");
+ for (int i = 0; i < vMerkleTree.size(); i++)
+ printf("%s ", vMerkleTree[i].ToString().substr(0,10).c_str());
+ printf("\n");
+ }
+
+
+ bool DisconnectBlock(CTxDB& txdb, CBlockIndex* pindex);
+ bool ConnectBlock(CTxDB& txdb, CBlockIndex* pindex);
+ bool ReadFromDisk(const CBlockIndex* pindex, bool fReadTransactions=true);
+ bool SetBestChain(CTxDB& txdb, CBlockIndex* pindexNew);
+ bool AddToBlockIndex(unsigned int nFile, unsigned int nBlockPos);
+ bool CheckBlock() const;
+ bool AcceptBlock();
+};
+
+
+
+
+
+
+//
+// The block chain is a tree shaped structure starting with the
+// genesis block at the root, with each block potentially having multiple
+// candidates to be the next block. pprev and pnext link a path through the
+// main/longest chain. A blockindex may have multiple pprev pointing back
+// to it, but pnext will only point forward to the longest branch, or will
+// be null if the block is not part of the longest chain.
+//
+class CBlockIndex
+{
+public:
+ const uint256* phashBlock;
+ CBlockIndex* pprev;
+ CBlockIndex* pnext;
+ unsigned int nFile;
+ unsigned int nBlockPos;
+ int nHeight;
+ CBigNum bnChainWork;
+
+ // block header
+ int nVersion;
+ uint256 hashMerkleRoot;
+ unsigned int nTime;
+ unsigned int nBits;
+ unsigned int nNonce;
+
+
+ CBlockIndex()
+ {
+ phashBlock = NULL;
+ pprev = NULL;
+ pnext = NULL;
+ nFile = 0;
+ nBlockPos = 0;
+ nHeight = 0;
+ bnChainWork = 0;
+
+ nVersion = 0;
+ hashMerkleRoot = 0;
+ nTime = 0;
+ nBits = 0;
+ nNonce = 0;
+ }
+
+ CBlockIndex(unsigned int nFileIn, unsigned int nBlockPosIn, CBlock& block)
+ {
+ phashBlock = NULL;
+ pprev = NULL;
+ pnext = NULL;
+ nFile = nFileIn;
+ nBlockPos = nBlockPosIn;
+ nHeight = 0;
+ bnChainWork = 0;
+
+ nVersion = block.nVersion;
+ hashMerkleRoot = block.hashMerkleRoot;
+ nTime = block.nTime;
+ nBits = block.nBits;
+ nNonce = block.nNonce;
+ }
+
+ CBlock GetBlockHeader() const
+ {
+ CBlock block;
+ block.nVersion = nVersion;
+ if (pprev)
+ block.hashPrevBlock = pprev->GetBlockHash();
+ block.hashMerkleRoot = hashMerkleRoot;
+ block.nTime = nTime;
+ block.nBits = nBits;
+ block.nNonce = nNonce;
+ return block;
+ }
+
+ uint256 GetBlockHash() const
+ {
+ return *phashBlock;
+ }
+
+ int64 GetBlockTime() const
+ {
+ return (int64)nTime;
+ }
+
+ CBigNum GetBlockWork() const
+ {
+ CBigNum bnTarget;
+ bnTarget.SetCompact(nBits);
+ if (bnTarget <= 0)
+ return 0;
+ return (CBigNum(1)<<256) / (bnTarget+1);
+ }
+
+ bool IsInMainChain() const
+ {
+ return (pnext || this == pindexBest);
+ }
+
+ bool CheckIndex() const
+ {
+ return CheckProofOfWork(GetBlockHash(), nBits);
+ }
+
+ bool EraseBlockFromDisk()
+ {
+ // Open history file
+ CAutoFile fileout = OpenBlockFile(nFile, nBlockPos, "rb+");
+ if (!fileout)
+ return false;
+
+ // Overwrite with empty null block
+ CBlock block;
+ block.SetNull();
+ fileout << block;
+
+ return true;
+ }
+
+ enum { nMedianTimeSpan=11 };
+
+ int64 GetMedianTimePast() const
+ {
+ int64 pmedian[nMedianTimeSpan];
+ int64* pbegin = &pmedian[nMedianTimeSpan];
+ int64* pend = &pmedian[nMedianTimeSpan];
+
+ const CBlockIndex* pindex = this;
+ for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev)
+ *(--pbegin) = pindex->GetBlockTime();
+
+ std::sort(pbegin, pend);
+ return pbegin[(pend - pbegin)/2];
+ }
+
+ int64 GetMedianTime() const
+ {
+ const CBlockIndex* pindex = this;
+ for (int i = 0; i < nMedianTimeSpan/2; i++)
+ {
+ if (!pindex->pnext)
+ return GetBlockTime();
+ pindex = pindex->pnext;
+ }
+ return pindex->GetMedianTimePast();
+ }
+
+
+
+ std::string ToString() const
+ {
+ return strprintf("CBlockIndex(nprev=%08x, pnext=%08x, nFile=%d, nBlockPos=%-6d nHeight=%d, merkle=%s, hashBlock=%s)",
+ pprev, pnext, nFile, nBlockPos, nHeight,
+ hashMerkleRoot.ToString().substr(0,10).c_str(),
+ GetBlockHash().ToString().substr(0,20).c_str());
+ }
+
+ void print() const
+ {
+ printf("%s\n", ToString().c_str());
+ }
+};
+
+
+
+//
+// Used to marshal pointers into hashes for db storage.
+//
+class CDiskBlockIndex : public CBlockIndex
+{
+public:
+ uint256 hashPrev;
+ uint256 hashNext;
+
+ CDiskBlockIndex()
+ {
+ hashPrev = 0;
+ hashNext = 0;
+ }
+
+ explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
+ {
+ hashPrev = (pprev ? pprev->GetBlockHash() : 0);
+ hashNext = (pnext ? pnext->GetBlockHash() : 0);
+ }
+
+ IMPLEMENT_SERIALIZE
+ (
+ if (!(nType & SER_GETHASH))
+ READWRITE(nVersion);
+
+ READWRITE(hashNext);
+ READWRITE(nFile);
+ READWRITE(nBlockPos);
+ READWRITE(nHeight);
+
+ // block header
+ READWRITE(this->nVersion);
+ READWRITE(hashPrev);
+ READWRITE(hashMerkleRoot);
+ READWRITE(nTime);
+ READWRITE(nBits);
+ READWRITE(nNonce);
+ )
+
+ uint256 GetBlockHash() const
+ {
+ CBlock block;
+ block.nVersion = nVersion;
+ block.hashPrevBlock = hashPrev;
+ block.hashMerkleRoot = hashMerkleRoot;
+ block.nTime = nTime;
+ block.nBits = nBits;
+ block.nNonce = nNonce;
+ return block.GetHash();
+ }
+
+
+ std::string ToString() const
+ {
+ std::string str = "CDiskBlockIndex(";
+ str += CBlockIndex::ToString();
+ str += strprintf("\n hashBlock=%s, hashPrev=%s, hashNext=%s)",
+ GetBlockHash().ToString().c_str(),
+ hashPrev.ToString().substr(0,20).c_str(),
+ hashNext.ToString().substr(0,20).c_str());
+ return str;
+ }
+
+ void print() const
+ {
+ printf("%s\n", ToString().c_str());
+ }
+};
+
+
+
+
+
+
+
+
+//
+// Describes a place in the block chain to another node such that if the
+// other node doesn't have the same branch, it can find a recent common trunk.
+// The further back it is, the further before the fork it may be.
+//
+class CBlockLocator
+{
+protected:
+ std::vector<uint256> vHave;
+public:
+
+ CBlockLocator()
+ {
+ }
+
+ explicit CBlockLocator(const CBlockIndex* pindex)
+ {
+ Set(pindex);
+ }
+
+ explicit CBlockLocator(uint256 hashBlock)
+ {
+ std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hashBlock);
+ if (mi != mapBlockIndex.end())
+ Set((*mi).second);
+ }
+
+ IMPLEMENT_SERIALIZE
+ (
+ if (!(nType & SER_GETHASH))
+ READWRITE(nVersion);
+ READWRITE(vHave);
+ )
+
+ void SetNull()
+ {
+ vHave.clear();
+ }
+
+ bool IsNull()
+ {
+ return vHave.empty();
+ }
+
+ void Set(const CBlockIndex* pindex)
+ {
+ vHave.clear();
+ int nStep = 1;
+ while (pindex)
+ {
+ vHave.push_back(pindex->GetBlockHash());
+
+ // Exponentially larger steps back
+ for (int i = 0; pindex && i < nStep; i++)
+ pindex = pindex->pprev;
+ if (vHave.size() > 10)
+ nStep *= 2;
+ }
+ vHave.push_back(hashGenesisBlock);
+ }
+
+ int GetDistanceBack()
+ {
+ // Retrace how far back it was in the sender's branch
+ int nDistance = 0;
+ int nStep = 1;
+ BOOST_FOREACH(const uint256& hash, vHave)
+ {
+ std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
+ if (mi != mapBlockIndex.end())
+ {
+ CBlockIndex* pindex = (*mi).second;
+ if (pindex->IsInMainChain())
+ return nDistance;
+ }
+ nDistance += nStep;
+ if (nDistance > 10)
+ nStep *= 2;
+ }
+ return nDistance;
+ }
+
+ CBlockIndex* GetBlockIndex()
+ {
+ // Find the first block the caller has in the main chain
+ BOOST_FOREACH(const uint256& hash, vHave)
+ {
+ std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
+ if (mi != mapBlockIndex.end())
+ {
+ CBlockIndex* pindex = (*mi).second;
+ if (pindex->IsInMainChain())
+ return pindex;
+ }
+ }
+ return pindexGenesisBlock;
+ }
+
+ uint256 GetBlockHash()
+ {
+ // Find the first block the caller has in the main chain
+ BOOST_FOREACH(const uint256& hash, vHave)
+ {
+ std::map<uint256, CBlockIndex*>::iterator mi = mapBlockIndex.find(hash);
+ if (mi != mapBlockIndex.end())
+ {
+ CBlockIndex* pindex = (*mi).second;
+ if (pindex->IsInMainChain())
+ return hash;
+ }
+ }
+ return hashGenesisBlock;
+ }
+
+ int GetHeight()
+ {
+ CBlockIndex* pindex = GetBlockIndex();
+ if (!pindex)
+ return 0;
+ return pindex->nHeight;
+ }
+};
+
+
+
+
+
+
+
+
+
+//
+// Alerts are for notifying old versions if they become too obsolete and
+// need to upgrade. The message is displayed in the status bar.
+// Alert messages are broadcast as a vector of signed data. Unserializing may
+// not read the entire buffer if the alert is for a newer version, but older
+// versions can still relay the original data.
+//
+class CUnsignedAlert
+{
+public:
+ int nVersion;
+ int64 nRelayUntil; // when newer nodes stop relaying to newer nodes
+ int64 nExpiration;
+ int nID;
+ int nCancel;
+ std::set<int> setCancel;
+ int nMinVer; // lowest version inclusive
+ int nMaxVer; // highest version inclusive
+ std::set<std::string> setSubVer; // empty matches all
+ int nPriority;
+
+ // Actions
+ std::string strComment;
+ std::string strStatusBar;
+ std::string strReserved;
+
+ IMPLEMENT_SERIALIZE
+ (
+ READWRITE(this->nVersion);
+ nVersion = this->nVersion;
+ READWRITE(nRelayUntil);
+ READWRITE(nExpiration);
+ READWRITE(nID);
+ READWRITE(nCancel);
+ READWRITE(setCancel);
+ READWRITE(nMinVer);
+ READWRITE(nMaxVer);
+ READWRITE(setSubVer);
+ READWRITE(nPriority);
+
+ READWRITE(strComment);
+ READWRITE(strStatusBar);
+ READWRITE(strReserved);
+ )
+
+ void SetNull()
+ {
+ nVersion = 1;
+ nRelayUntil = 0;
+ nExpiration = 0;
+ nID = 0;
+ nCancel = 0;
+ setCancel.clear();
+ nMinVer = 0;
+ nMaxVer = 0;
+ setSubVer.clear();
+ nPriority = 0;
+
+ strComment.clear();
+ strStatusBar.clear();
+ strReserved.clear();
+ }
+
+ std::string ToString() const
+ {
+ std::string strSetCancel;
+ BOOST_FOREACH(int n, setCancel)
+ strSetCancel += strprintf("%d ", n);
+ std::string strSetSubVer;
+ BOOST_FOREACH(std::string str, setSubVer)
+ strSetSubVer += "\"" + str + "\" ";
+ return strprintf(
+ "CAlert(\n"
+ " nVersion = %d\n"
+ " nRelayUntil = %"PRI64d"\n"
+ " nExpiration = %"PRI64d"\n"
+ " nID = %d\n"
+ " nCancel = %d\n"
+ " setCancel = %s\n"
+ " nMinVer = %d\n"
+ " nMaxVer = %d\n"
+ " setSubVer = %s\n"
+ " nPriority = %d\n"
+ " strComment = \"%s\"\n"
+ " strStatusBar = \"%s\"\n"
+ ")\n",
+ nVersion,
+ nRelayUntil,
+ nExpiration,
+ nID,
+ nCancel,
+ strSetCancel.c_str(),
+ nMinVer,
+ nMaxVer,
+ strSetSubVer.c_str(),
+ nPriority,
+ strComment.c_str(),
+ strStatusBar.c_str());
+ }
+
+ void print() const
+ {
+ printf("%s", ToString().c_str());
+ }
+};
+
+class CAlert : public CUnsignedAlert
+{
+public:
+ std::vector<unsigned char> vchMsg;
+ std::vector<unsigned char> vchSig;
+
+ CAlert()
+ {
+ SetNull();
+ }
+
+ IMPLEMENT_SERIALIZE
+ (
+ READWRITE(vchMsg);
+ READWRITE(vchSig);
+ )
+
+ void SetNull()
+ {
+ CUnsignedAlert::SetNull();
+ vchMsg.clear();
+ vchSig.clear();
+ }
+
+ bool IsNull() const
+ {
+ return (nExpiration == 0);
+ }
+
+ uint256 GetHash() const
+ {
+ return SerializeHash(*this);
+ }
+
+ bool IsInEffect() const
+ {
+ return (GetAdjustedTime() < nExpiration);
+ }
+
+ bool Cancels(const CAlert& alert) const
+ {
+ if (!IsInEffect())
+ return false; // this was a no-op before 31403
+ return (alert.nID <= nCancel || setCancel.count(alert.nID));
+ }
+
+ bool AppliesTo(int nVersion, std::string strSubVerIn) const
+ {
+ return (IsInEffect() &&
+ nMinVer <= nVersion && nVersion <= nMaxVer &&
+ (setSubVer.empty() || setSubVer.count(strSubVerIn)));
+ }
+
+ bool AppliesToMe() const
+ {
+ return AppliesTo(VERSION, ::pszSubVer);
+ }
+
+ bool RelayTo(CNode* pnode) const
+ {
+ if (!IsInEffect())
+ return false;
+ // returns true if wasn't already contained in the set
+ if (pnode->setKnown.insert(GetHash()).second)
+ {
+ if (AppliesTo(pnode->nVersion, pnode->strSubVer) ||
+ AppliesToMe() ||
+ GetAdjustedTime() < nRelayUntil)
+ {
+ pnode->PushMessage("alert", *this);
+ return true;
+ }
+ }
+ return false;
+ }
+
+ bool CheckSignature()
+ {
+ CKey key;
+ if (!key.SetPubKey(ParseHex("04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284")))
+ return error("CAlert::CheckSignature() : SetPubKey failed");
+ if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
+ return error("CAlert::CheckSignature() : verify signature failed");
+
+ // Now unserialize the data
+ CDataStream sMsg(vchMsg);
+ sMsg >> *(CUnsignedAlert*)this;
+ return true;
+ }
+
+ bool ProcessAlert();
+};
+
+#endif
diff --git a/bitcoin/src/makefile.linux-mingw b/bitcoin/src/makefile.linux-mingw
@@ -0,0 +1,102 @@
+# Copyright (c) 2009-2010 Satoshi Nakamoto
+# Distributed under the MIT/X11 software license, see the accompanying
+# file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+DEPSDIR:=/usr/i586-mingw32msvc
+
+USE_UPNP:=0
+
+INCLUDEPATHS= \
+ -I"$(DEPSDIR)/boost_1_47_0" \
+ -I"$(DEPSDIR)/db-4.8.30.NC/build_unix" \
+ -I"$(DEPSDIR)/openssl-1.0.0e/include" \
+ -I"$(DEPSDIR)"
+
+LIBPATHS= \
+ -L"$(DEPSDIR)/boost_1_47_0/stage/lib" \
+ -L"$(DEPSDIR)/db-4.8.30.NC/build_unix" \
+ -L"$(DEPSDIR)/openssl-1.0.0e"
+
+LIBS= \
+ -l boost_system-mt-s \
+ -l boost_filesystem-mt-s \
+ -l boost_program_options-mt-s \
+ -l boost_thread_win32-mt-s \
+ -l db_cxx \
+ -l ssl \
+ -l crypto
+
+DEFS=-D_MT -DWIN32 -D_WINDOWS -DNOPCH -DUSE_SSL -DBOOST_THREAD_USE_LIB
+DEBUGFLAGS=-g
+CFLAGS=-O2 -w -Wno-invalid-offsetof -Wformat $(DEBUGFLAGS) $(DEFS) $(INCLUDEPATHS)
+HEADERS = \
+ base58.h \
+ bignum.h \
+ checkpoints.h \
+ crypter.h \
+ db.h \
+ headers.h \
+ init.h \
+ irc.h \
+ key.h \
+ keystore.h \
+ main.h \
+ net.h \
+ noui.h \
+ protocol.h \
+ bitcoinrpc.h \
+ script.h \
+ serialize.h \
+ strlcpy.h \
+ uint256.h \
+ util.h \
+ wallet.h
+
+
+ifdef USE_UPNP
+ LIBPATHS += -L"$(DEPSDIR)/miniupnpc"
+ LIBS += -l miniupnpc -l iphlpapi
+ DEFS += -DSTATICLIB -DUSE_UPNP=$(USE_UPNP)
+endif
+
+LIBS += -l mingwthrd -l kernel32 -l user32 -l gdi32 -l comdlg32 -l winspool -l winmm -l shell32 -l comctl32 -l ole32 -l oleaut32 -l uuid -l rpcrt4 -l advapi32 -l ws2_32 -l shlwapi
+
+OBJS= \
+ obj/checkpoints.o \
+ obj/crypter.o \
+ obj/db.o \
+ obj/init.o \
+ obj/irc.o \
+ obj/keystore.o \
+ obj/main.o \
+ obj/net.o \
+ obj/protocol.o \
+ obj/bitcoinrpc.o \
+ obj/script.o \
+ obj/util.o \
+ obj/wallet.o
+
+all: bitcoind.exe
+
+obj/nogui/%.o: %.cpp $(HEADERS)
+ i586-mingw32msvc-g++ -c $(CFLAGS) -o $@ $<
+
+bitcoind.exe: $(OBJS:obj/%=obj/nogui/%)
+ i586-mingw32msvc-g++ $(CFLAGS) -o $@ $(LIBPATHS) $^ $(LIBS)
+
+
+obj/test/%.o: obj/test/%.cpp $(HEADERS)
+ i586-mingw32msvc-g++ -c $(CFLAGS) -o $@ $<
+
+test_bitcoin.exe: obj/test/test_bitcoin.o $(filter-out obj/nogui/init.o,$(OBJS:obj/%=obj/nogui/%))
+ i586-mingw32msvc-g++ $(CFLAGS) -o $@ $(LIBPATHS) $^ $(LIBS) -lboost_unit_test_framework-mt-s
+
+
+clean:
+ -rm -f obj/*.o
+ -rm -f obj/nogui/*.o
+ -rm -f obj/test/*.o
+ -rm -f test/*.o
+ -rm -f headers.h.gch
+ -rm -f bitcoind.exe
+ -rm -f test_bitcoin.exe
diff --git a/bitcoin/src/makefile.unix b/bitcoin/src/makefile.unix
@@ -0,0 +1,161 @@
+# Copyright (c) 2009-2010 Satoshi Nakamoto
+# Distributed under the MIT/X11 software license, see the accompanying
+# file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+USE_UPNP:=0
+
+DEFS=-DNOPCH
+
+DEFS += $(addprefix -I,$(BOOST_INCLUDE_PATH) $(BDB_INCLUDE_PATH) $(OPENSSL_INCLUDE_PATH))
+LIBS = $(addprefix -L,$(BOOST_LIB_PATH) $(BDB_LIB_PATH) $(OPENSSL_LIB_PATH))
+
+LMODE = dynamic
+LMODE2 = dynamic
+ifdef STATIC
+ LMODE = static
+ ifeq (${STATIC}, all)
+ LMODE2 = static
+ endif
+else
+ TESTDEFS += -DBOOST_TEST_DYN_LINK
+endif
+
+# for boost 1.37, add -mt to the boost libraries
+LIBS += \
+ -Wl,-B$(LMODE) \
+ -l boost_system$(BOOST_LIB_SUFFIX) \
+ -l boost_filesystem$(BOOST_LIB_SUFFIX) \
+ -l boost_program_options$(BOOST_LIB_SUFFIX) \
+ -l boost_thread$(BOOST_LIB_SUFFIX) \
+ -l db_cxx$(BDB_LIB_SUFFIX) \
+ -l ssl \
+ -l crypto
+
+ifndef USE_UPNP
+ override USE_UPNP = -
+endif
+ifneq (${USE_UPNP}, -)
+ LIBS += -l miniupnpc
+ DEFS += -DUSE_UPNP=$(USE_UPNP)
+endif
+
+ifneq (${USE_SSL}, 0)
+ DEFS += -DUSE_SSL
+endif
+
+LIBS+= \
+ -Wl,-B$(LMODE2) \
+ -l z \
+ -l dl \
+ -l pthread
+
+
+# Hardening
+# Make some classes of vulnerabilities unexploitable in case one is discovered.
+#
+ # This is a workaround for Ubuntu bug #691722, the default -fstack-protector causes
+ # -fstack-protector-all to be ignored unless -fno-stack-protector is used first.
+ # see: https://bugs.launchpad.net/ubuntu/+source/gcc-4.5/+bug/691722
+ HARDENING=-fno-stack-protector
+
+ # Stack Canaries
+ # Put numbers at the beginning of each stack frame and check that they are the same.
+ # If a stack buffer if overflowed, it writes over the canary number and then on return
+ # when that number is checked, it won't be the same and the program will exit with
+ # a "Stack smashing detected" error instead of being exploited.
+ HARDENING+=-fstack-protector-all -Wstack-protector
+
+ # Make some important things such as the global offset table read only as soon as
+ # the dynamic linker is finished building it. This will prevent overwriting of addresses
+ # which would later be jumped to.
+ HARDENING+=-Wl,-z,relro -Wl,-z,now
+
+ # Build position independent code to take advantage of Address Space Layout Randomization
+ # offered by some kernels.
+ # see doc/build-unix.txt for more information.
+ ifdef PIE
+ HARDENING+=-fPIE -pie
+ endif
+
+ # -D_FORTIFY_SOURCE=2 does some checking for potentially exploitable code patterns in
+ # the source such overflowing a statically defined buffer.
+ HARDENING+=-D_FORTIFY_SOURCE=2
+#
+
+
+DEBUGFLAGS=-g
+CXXFLAGS=-O2
+xCXXFLAGS=-pthread -Wno-invalid-offsetof -Wformat $(DEBUGFLAGS) $(DEFS) $(HARDENING) $(CXXFLAGS)
+HEADERS = \
+ base58.h \
+ bignum.h \
+ checkpoints.h \
+ crypter.h \
+ db.h \
+ headers.h \
+ init.h \
+ irc.h \
+ key.h \
+ keystore.h \
+ main.h \
+ net.h \
+ noui.h \
+ protocol.h \
+ bitcoinrpc.h \
+ script.h \
+ serialize.h \
+ strlcpy.h \
+ uint256.h \
+ util.h \
+ wallet.h
+
+OBJS= \
+ obj/checkpoints.o \
+ obj/crypter.o \
+ obj/db.o \
+ obj/init.o \
+ obj/irc.o \
+ obj/keystore.o \
+ obj/main.o \
+ obj/net.o \
+ obj/protocol.o \
+ obj/bitcoinrpc.o \
+ obj/script.o \
+ obj/util.o \
+ obj/wallet.o
+
+
+all: bitcoind
+
+# auto-generated dependencies:
+-include obj/nogui/*.P
+-include obj-test/*.P
+
+obj/nogui/%.o: %.cpp
+ $(CXX) -c $(xCXXFLAGS) -MMD -o $@ $<
+ @cp $(@:%.o=%.d) $(@:%.o=%.P); \
+ sed -e 's/#.*//' -e 's/^[^:]*: *//' -e 's/ *\\$$//' \
+ -e '/^$$/ d' -e 's/$$/ :/' < $(@:%.o=%.d) >> $(@:%.o=%.P); \
+ rm -f $(@:%.o=%.d)
+
+bitcoind: $(OBJS:obj/%=obj/nogui/%)
+ $(CXX) $(xCXXFLAGS) -o $@ $^ $(LDFLAGS) $(LIBS)
+
+obj-test/%.o: test/%.cpp
+ $(CXX) -c $(TESTDEFS) $(xCXXFLAGS) -MMD -o $@ $<
+ @cp $(@:%.o=%.d) $(@:%.o=%.P); \
+ sed -e 's/#.*//' -e 's/^[^:]*: *//' -e 's/ *\\$$//' \
+ -e '/^$$/ d' -e 's/$$/ :/' < $(@:%.o=%.d) >> $(@:%.o=%.P); \
+ rm -f $(@:%.o=%.d)
+
+test_bitcoin: obj-test/test_bitcoin.o $(filter-out obj/nogui/init.o,$(OBJS:obj/%=obj/nogui/%))
+ $(CXX) $(xCXXFLAGS) -o $@ $(LIBPATHS) $^ -Wl,-B$(LMODE) -lboost_unit_test_framework $(LDFLAGS) $(LIBS)
+
+clean:
+ -rm -f bitcoind test_bitcoin
+ -rm -f obj/*.o
+ -rm -f obj/nogui/*.o
+ -rm -f obj-test/*.o
+ -rm -f obj/*.P
+ -rm -f obj/nogui/*.P
+ -rm -f obj-test/*.P
diff --git a/bitcoin/src/net.cpp b/bitcoin/src/net.cpp
@@ -0,0 +1,1951 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2012 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+#include "headers.h"
+#include "irc.h"
+#include "db.h"
+#include "net.h"
+#include "init.h"
+#include "strlcpy.h"
+
+#ifdef WIN32
+#include <string.h>
+#endif
+
+#ifdef USE_UPNP
+#include <miniupnpc/miniwget.h>
+#include <miniupnpc/miniupnpc.h>
+#include <miniupnpc/upnpcommands.h>
+#include <miniupnpc/upnperrors.h>
+#endif
+
+using namespace std;
+using namespace boost;
+
+static const int MAX_OUTBOUND_CONNECTIONS = 8;
+
+void ThreadMessageHandler2(void* parg);
+void ThreadSocketHandler2(void* parg);
+void ThreadOpenConnections2(void* parg);
+#ifdef USE_UPNP
+void ThreadMapPort2(void* parg);
+#endif
+void ThreadDNSAddressSeed2(void* parg);
+bool OpenNetworkConnection(const CAddress& addrConnect);
+
+
+
+
+
+//
+// Global state variables
+//
+bool fClient = false;
+bool fAllowDNS = false;
+uint64 nLocalServices = (fClient ? 0 : NODE_NETWORK);
+CAddress addrLocalHost("0.0.0.0", 0, false, nLocalServices);
+static CNode* pnodeLocalHost = NULL;
+uint64 nLocalHostNonce = 0;
+array<int, 10> vnThreadsRunning;
+static SOCKET hListenSocket = INVALID_SOCKET;
+
+vector<CNode*> vNodes;
+CCriticalSection cs_vNodes;
+map<vector<unsigned char>, CAddress> mapAddresses;
+CCriticalSection cs_mapAddresses;
+map<CInv, CDataStream> mapRelay;
+deque<pair<int64, CInv> > vRelayExpiration;
+CCriticalSection cs_mapRelay;
+map<CInv, int64> mapAlreadyAskedFor;
+
+// Settings
+int fUseProxy = false;
+int nConnectTimeout = 5000;
+CAddress addrProxy("127.0.0.1",9050);
+
+
+
+
+unsigned short GetListenPort()
+{
+ return (unsigned short)(GetArg("-port", GetDefaultPort()));
+}
+
+void CNode::PushGetBlocks(CBlockIndex* pindexBegin, uint256 hashEnd)
+{
+ // Filter out duplicate requests
+ if (pindexBegin == pindexLastGetBlocksBegin && hashEnd == hashLastGetBlocksEnd)
+ return;
+ pindexLastGetBlocksBegin = pindexBegin;
+ hashLastGetBlocksEnd = hashEnd;
+
+ PushMessage("getblocks", CBlockLocator(pindexBegin), hashEnd);
+}
+
+
+
+
+
+bool ConnectSocket(const CAddress& addrConnect, SOCKET& hSocketRet, int nTimeout)
+{
+ hSocketRet = INVALID_SOCKET;
+
+ SOCKET hSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+ if (hSocket == INVALID_SOCKET)
+ return false;
+#ifdef SO_NOSIGPIPE
+ int set = 1;
+ setsockopt(hSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&set, sizeof(int));
+#endif
+
+ bool fProxy = (fUseProxy && addrConnect.IsRoutable());
+ struct sockaddr_in sockaddr = (fProxy ? addrProxy.GetSockAddr() : addrConnect.GetSockAddr());
+
+#ifdef WIN32
+ u_long fNonblock = 1;
+ if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
+#else
+ int fFlags = fcntl(hSocket, F_GETFL, 0);
+ if (fcntl(hSocket, F_SETFL, fFlags | O_NONBLOCK) == -1)
+#endif
+ {
+ closesocket(hSocket);
+ return false;
+ }
+
+
+ if (connect(hSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
+ {
+ // WSAEINVAL is here because some legacy version of winsock uses it
+ if (WSAGetLastError() == WSAEINPROGRESS || WSAGetLastError() == WSAEWOULDBLOCK || WSAGetLastError() == WSAEINVAL)
+ {
+ struct timeval timeout;
+ timeout.tv_sec = nTimeout / 1000;
+ timeout.tv_usec = (nTimeout % 1000) * 1000;
+
+ fd_set fdset;
+ FD_ZERO(&fdset);
+ FD_SET(hSocket, &fdset);
+ int nRet = select(hSocket + 1, NULL, &fdset, NULL, &timeout);
+ if (nRet == 0)
+ {
+ printf("connection timeout\n");
+ closesocket(hSocket);
+ return false;
+ }
+ if (nRet == SOCKET_ERROR)
+ {
+ printf("select() for connection failed: %i\n",WSAGetLastError());
+ closesocket(hSocket);
+ return false;
+ }
+ socklen_t nRetSize = sizeof(nRet);
+#ifdef WIN32
+ if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, (char*)(&nRet), &nRetSize) == SOCKET_ERROR)
+#else
+ if (getsockopt(hSocket, SOL_SOCKET, SO_ERROR, &nRet, &nRetSize) == SOCKET_ERROR)
+#endif
+ {
+ printf("getsockopt() for connection failed: %i\n",WSAGetLastError());
+ closesocket(hSocket);
+ return false;
+ }
+ if (nRet != 0)
+ {
+ printf("connect() failed after select(): %s\n",strerror(nRet));
+ closesocket(hSocket);
+ return false;
+ }
+ }
+#ifdef WIN32
+ else if (WSAGetLastError() != WSAEISCONN)
+#else
+ else
+#endif
+ {
+ printf("connect() failed: %i\n",WSAGetLastError());
+ closesocket(hSocket);
+ return false;
+ }
+ }
+
+ /*
+ this isn't even strictly necessary
+ CNode::ConnectNode immediately turns the socket back to non-blocking
+ but we'll turn it back to blocking just in case
+ */
+#ifdef WIN32
+ fNonblock = 0;
+ if (ioctlsocket(hSocket, FIONBIO, &fNonblock) == SOCKET_ERROR)
+#else
+ fFlags = fcntl(hSocket, F_GETFL, 0);
+ if (fcntl(hSocket, F_SETFL, fFlags & !O_NONBLOCK) == SOCKET_ERROR)
+#endif
+ {
+ closesocket(hSocket);
+ return false;
+ }
+
+ if (fProxy)
+ {
+ printf("proxy connecting %s\n", addrConnect.ToString().c_str());
+ char pszSocks4IP[] = "\4\1\0\0\0\0\0\0user";
+ memcpy(pszSocks4IP + 2, &addrConnect.port, 2);
+ memcpy(pszSocks4IP + 4, &addrConnect.ip, 4);
+ char* pszSocks4 = pszSocks4IP;
+ int nSize = sizeof(pszSocks4IP);
+
+ int ret = send(hSocket, pszSocks4, nSize, MSG_NOSIGNAL);
+ if (ret != nSize)
+ {
+ closesocket(hSocket);
+ return error("Error sending to proxy");
+ }
+ char pchRet[8];
+ if (recv(hSocket, pchRet, 8, 0) != 8)
+ {
+ closesocket(hSocket);
+ return error("Error reading proxy response");
+ }
+ if (pchRet[1] != 0x5a)
+ {
+ closesocket(hSocket);
+ if (pchRet[1] != 0x5b)
+ printf("ERROR: Proxy returned error %d\n", pchRet[1]);
+ return false;
+ }
+ printf("proxy connected %s\n", addrConnect.ToString().c_str());
+ }
+
+ hSocketRet = hSocket;
+ return true;
+}
+
+// portDefault is in host order
+bool Lookup(const char *pszName, vector<CAddress>& vaddr, int nServices, int nMaxSolutions, bool fAllowLookup, int portDefault, bool fAllowPort)
+{
+ vaddr.clear();
+ if (pszName[0] == 0)
+ return false;
+ int port = portDefault;
+ char psz[256];
+ char *pszHost = psz;
+ strlcpy(psz, pszName, sizeof(psz));
+ if (fAllowPort)
+ {
+ char* pszColon = strrchr(psz+1,':');
+ char *pszPortEnd = NULL;
+ int portParsed = pszColon ? strtoul(pszColon+1, &pszPortEnd, 10) : 0;
+ if (pszColon && pszPortEnd && pszPortEnd[0] == 0)
+ {
+ if (psz[0] == '[' && pszColon[-1] == ']')
+ {
+ // Future: enable IPv6 colon-notation inside []
+ pszHost = psz+1;
+ pszColon[-1] = 0;
+ }
+ else
+ pszColon[0] = 0;
+ port = portParsed;
+ if (port < 0 || port > USHRT_MAX)
+ port = USHRT_MAX;
+ }
+ }
+
+ unsigned int addrIP = inet_addr(pszHost);
+ if (addrIP != INADDR_NONE)
+ {
+ // valid IP address passed
+ vaddr.push_back(CAddress(addrIP, port, nServices));
+ return true;
+ }
+
+ if (!fAllowLookup)
+ return false;
+
+ struct hostent* phostent = gethostbyname(pszHost);
+ if (!phostent)
+ return false;
+
+ if (phostent->h_addrtype != AF_INET)
+ return false;
+
+ char** ppAddr = phostent->h_addr_list;
+ while (*ppAddr != NULL && vaddr.size() != nMaxSolutions)
+ {
+ CAddress addr(((struct in_addr*)ppAddr[0])->s_addr, port, nServices);
+ if (addr.IsValid())
+ vaddr.push_back(addr);
+ ppAddr++;
+ }
+
+ return (vaddr.size() > 0);
+}
+
+// portDefault is in host order
+bool Lookup(const char *pszName, CAddress& addr, int nServices, bool fAllowLookup, int portDefault, bool fAllowPort)
+{
+ vector<CAddress> vaddr;
+ bool fRet = Lookup(pszName, vaddr, nServices, 1, fAllowLookup, portDefault, fAllowPort);
+ if (fRet)
+ addr = vaddr[0];
+ return fRet;
+}
+
+bool GetMyExternalIP2(const CAddress& addrConnect, const char* pszGet, const char* pszKeyword, unsigned int& ipRet)
+{
+ SOCKET hSocket;
+ if (!ConnectSocket(addrConnect, hSocket))
+ return error("GetMyExternalIP() : connection to %s failed", addrConnect.ToString().c_str());
+
+ send(hSocket, pszGet, strlen(pszGet), MSG_NOSIGNAL);
+
+ string strLine;
+ while (RecvLine(hSocket, strLine))
+ {
+ if (strLine.empty()) // HTTP response is separated from headers by blank line
+ {
+ loop
+ {
+ if (!RecvLine(hSocket, strLine))
+ {
+ closesocket(hSocket);
+ return false;
+ }
+ if (pszKeyword == NULL)
+ break;
+ if (strLine.find(pszKeyword) != -1)
+ {
+ strLine = strLine.substr(strLine.find(pszKeyword) + strlen(pszKeyword));
+ break;
+ }
+ }
+ closesocket(hSocket);
+ if (strLine.find("<") != -1)
+ strLine = strLine.substr(0, strLine.find("<"));
+ strLine = strLine.substr(strspn(strLine.c_str(), " \t\n\r"));
+ while (strLine.size() > 0 && isspace(strLine[strLine.size()-1]))
+ strLine.resize(strLine.size()-1);
+ CAddress addr(strLine,0,true);
+ printf("GetMyExternalIP() received [%s] %s\n", strLine.c_str(), addr.ToString().c_str());
+ if (addr.ip == 0 || addr.ip == INADDR_NONE || !addr.IsRoutable())
+ return false;
+ ipRet = addr.ip;
+ return true;
+ }
+ }
+ closesocket(hSocket);
+ return error("GetMyExternalIP() : connection closed");
+}
+
+// We now get our external IP from the IRC server first and only use this as a backup
+bool GetMyExternalIP(unsigned int& ipRet)
+{
+ CAddress addrConnect;
+ const char* pszGet;
+ const char* pszKeyword;
+
+ if (fUseProxy)
+ return false;
+
+ for (int nLookup = 0; nLookup <= 1; nLookup++)
+ for (int nHost = 1; nHost <= 2; nHost++)
+ {
+ // We should be phasing out our use of sites like these. If we need
+ // replacements, we should ask for volunteers to put this simple
+ // php file on their webserver that prints the client IP:
+ // <?php echo $_SERVER["REMOTE_ADDR"]; ?>
+ if (nHost == 1)
+ {
+ addrConnect = CAddress("91.198.22.70",80); // checkip.dyndns.org
+
+ if (nLookup == 1)
+ {
+ CAddress addrIP("checkip.dyndns.org", 80, true);
+ if (addrIP.IsValid())
+ addrConnect = addrIP;
+ }
+
+ pszGet = "GET / HTTP/1.1\r\n"
+ "Host: checkip.dyndns.org\r\n"
+ "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
+ "Connection: close\r\n"
+ "\r\n";
+
+ pszKeyword = "Address:";
+ }
+ else if (nHost == 2)
+ {
+ addrConnect = CAddress("74.208.43.192", 80); // www.showmyip.com
+
+ if (nLookup == 1)
+ {
+ CAddress addrIP("www.showmyip.com", 80, true);
+ if (addrIP.IsValid())
+ addrConnect = addrIP;
+ }
+
+ pszGet = "GET /simple/ HTTP/1.1\r\n"
+ "Host: www.showmyip.com\r\n"
+ "User-Agent: Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 5.1)\r\n"
+ "Connection: close\r\n"
+ "\r\n";
+
+ pszKeyword = NULL; // Returns just IP address
+ }
+
+ if (GetMyExternalIP2(addrConnect, pszGet, pszKeyword, ipRet))
+ return true;
+ }
+
+ return false;
+}
+
+void ThreadGetMyExternalIP(void* parg)
+{
+ // Wait for IRC to get it first
+ if (!GetBoolArg("-noirc"))
+ {
+ for (int i = 0; i < 2 * 60; i++)
+ {
+ Sleep(1000);
+ if (fGotExternalIP || fShutdown)
+ return;
+ }
+ }
+
+ // Fallback in case IRC fails to get it
+ if (GetMyExternalIP(addrLocalHost.ip))
+ {
+ printf("GetMyExternalIP() returned %s\n", addrLocalHost.ToStringIP().c_str());
+ if (addrLocalHost.IsRoutable())
+ {
+ // If we already connected to a few before we had our IP, go back and addr them.
+ // setAddrKnown automatically filters any duplicate sends.
+ CAddress addr(addrLocalHost);
+ addr.nTime = GetAdjustedTime();
+ CRITICAL_BLOCK(cs_vNodes)
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ pnode->PushAddress(addr);
+ }
+ }
+}
+
+
+
+
+
+bool AddAddress(CAddress addr, int64 nTimePenalty, CAddrDB *pAddrDB)
+{
+ if (!addr.IsRoutable())
+ return false;
+ if (addr.ip == addrLocalHost.ip)
+ return false;
+ addr.nTime = max((int64)0, (int64)addr.nTime - nTimePenalty);
+ bool fUpdated = false;
+ bool fNew = false;
+ CAddress addrFound = addr;
+
+ CRITICAL_BLOCK(cs_mapAddresses)
+ {
+ map<vector<unsigned char>, CAddress>::iterator it = mapAddresses.find(addr.GetKey());
+ if (it == mapAddresses.end())
+ {
+ // New address
+ printf("AddAddress(%s)\n", addr.ToString().c_str());
+ mapAddresses.insert(make_pair(addr.GetKey(), addr));
+ fUpdated = true;
+ fNew = true;
+ }
+ else
+ {
+ addrFound = (*it).second;
+ if ((addrFound.nServices | addr.nServices) != addrFound.nServices)
+ {
+ // Services have been added
+ addrFound.nServices |= addr.nServices;
+ fUpdated = true;
+ }
+ bool fCurrentlyOnline = (GetAdjustedTime() - addr.nTime < 24 * 60 * 60);
+ int64 nUpdateInterval = (fCurrentlyOnline ? 60 * 60 : 24 * 60 * 60);
+ if (addrFound.nTime < addr.nTime - nUpdateInterval)
+ {
+ // Periodically update most recently seen time
+ addrFound.nTime = addr.nTime;
+ fUpdated = true;
+ }
+ }
+ }
+ // There is a nasty deadlock bug if this is done inside the cs_mapAddresses
+ // CRITICAL_BLOCK:
+ // Thread 1: begin db transaction (locks inside-db-mutex)
+ // then AddAddress (locks cs_mapAddresses)
+ // Thread 2: AddAddress (locks cs_mapAddresses)
+ // ... then db operation hangs waiting for inside-db-mutex
+ if (fUpdated)
+ {
+ if (pAddrDB)
+ pAddrDB->WriteAddress(addrFound);
+ else
+ CAddrDB().WriteAddress(addrFound);
+ }
+ return fNew;
+}
+
+void AddressCurrentlyConnected(const CAddress& addr)
+{
+ CAddress *paddrFound = NULL;
+
+ CRITICAL_BLOCK(cs_mapAddresses)
+ {
+ // Only if it's been published already
+ map<vector<unsigned char>, CAddress>::iterator it = mapAddresses.find(addr.GetKey());
+ if (it != mapAddresses.end())
+ paddrFound = &(*it).second;
+ }
+
+ if (paddrFound)
+ {
+ int64 nUpdateInterval = 20 * 60;
+ if (paddrFound->nTime < GetAdjustedTime() - nUpdateInterval)
+ {
+ // Periodically update most recently seen time
+ paddrFound->nTime = GetAdjustedTime();
+ CAddrDB addrdb;
+ addrdb.WriteAddress(*paddrFound);
+ }
+ }
+}
+
+
+
+
+
+void AbandonRequests(void (*fn)(void*, CDataStream&), void* param1)
+{
+ // If the dialog might get closed before the reply comes back,
+ // call this in the destructor so it doesn't get called after it's deleted.
+ CRITICAL_BLOCK(cs_vNodes)
+ {
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ {
+ CRITICAL_BLOCK(pnode->cs_mapRequests)
+ {
+ for (map<uint256, CRequestTracker>::iterator mi = pnode->mapRequests.begin(); mi != pnode->mapRequests.end();)
+ {
+ CRequestTracker& tracker = (*mi).second;
+ if (tracker.fn == fn && tracker.param1 == param1)
+ pnode->mapRequests.erase(mi++);
+ else
+ mi++;
+ }
+ }
+ }
+ }
+}
+
+
+
+
+
+
+
+//
+// Subscription methods for the broadcast and subscription system.
+// Channel numbers are message numbers, i.e. MSG_TABLE and MSG_PRODUCT.
+//
+// The subscription system uses a meet-in-the-middle strategy.
+// With 100,000 nodes, if senders broadcast to 1000 random nodes and receivers
+// subscribe to 1000 random nodes, 99.995% (1 - 0.99^1000) of messages will get through.
+//
+
+bool AnySubscribed(unsigned int nChannel)
+{
+ if (pnodeLocalHost->IsSubscribed(nChannel))
+ return true;
+ CRITICAL_BLOCK(cs_vNodes)
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ if (pnode->IsSubscribed(nChannel))
+ return true;
+ return false;
+}
+
+bool CNode::IsSubscribed(unsigned int nChannel)
+{
+ if (nChannel >= vfSubscribe.size())
+ return false;
+ return vfSubscribe[nChannel];
+}
+
+void CNode::Subscribe(unsigned int nChannel, unsigned int nHops)
+{
+ if (nChannel >= vfSubscribe.size())
+ return;
+
+ if (!AnySubscribed(nChannel))
+ {
+ // Relay subscribe
+ CRITICAL_BLOCK(cs_vNodes)
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ if (pnode != this)
+ pnode->PushMessage("subscribe", nChannel, nHops);
+ }
+
+ vfSubscribe[nChannel] = true;
+}
+
+void CNode::CancelSubscribe(unsigned int nChannel)
+{
+ if (nChannel >= vfSubscribe.size())
+ return;
+
+ // Prevent from relaying cancel if wasn't subscribed
+ if (!vfSubscribe[nChannel])
+ return;
+ vfSubscribe[nChannel] = false;
+
+ if (!AnySubscribed(nChannel))
+ {
+ // Relay subscription cancel
+ CRITICAL_BLOCK(cs_vNodes)
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ if (pnode != this)
+ pnode->PushMessage("sub-cancel", nChannel);
+ }
+}
+
+
+
+
+
+
+
+
+
+CNode* FindNode(unsigned int ip)
+{
+ CRITICAL_BLOCK(cs_vNodes)
+ {
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ if (pnode->addr.ip == ip)
+ return (pnode);
+ }
+ return NULL;
+}
+
+CNode* FindNode(CAddress addr)
+{
+ CRITICAL_BLOCK(cs_vNodes)
+ {
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ if (pnode->addr == addr)
+ return (pnode);
+ }
+ return NULL;
+}
+
+CNode* ConnectNode(CAddress addrConnect, int64 nTimeout)
+{
+ if (addrConnect.ip == addrLocalHost.ip)
+ return NULL;
+
+ // Look for an existing connection
+ CNode* pnode = FindNode(addrConnect.ip);
+ if (pnode)
+ {
+ if (nTimeout != 0)
+ pnode->AddRef(nTimeout);
+ else
+ pnode->AddRef();
+ return pnode;
+ }
+
+ /// debug print
+ printf("trying connection %s lastseen=%.1fhrs lasttry=%.1fhrs\n",
+ addrConnect.ToString().c_str(),
+ (double)(addrConnect.nTime - GetAdjustedTime())/3600.0,
+ (double)(addrConnect.nLastTry - GetAdjustedTime())/3600.0);
+
+ CRITICAL_BLOCK(cs_mapAddresses)
+ mapAddresses[addrConnect.GetKey()].nLastTry = GetAdjustedTime();
+
+ // Connect
+ SOCKET hSocket;
+ if (ConnectSocket(addrConnect, hSocket))
+ {
+ /// debug print
+ printf("connected %s\n", addrConnect.ToString().c_str());
+
+ // Set to nonblocking
+#ifdef WIN32
+ u_long nOne = 1;
+ if (ioctlsocket(hSocket, FIONBIO, &nOne) == SOCKET_ERROR)
+ printf("ConnectSocket() : ioctlsocket nonblocking setting failed, error %d\n", WSAGetLastError());
+#else
+ if (fcntl(hSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
+ printf("ConnectSocket() : fcntl nonblocking setting failed, error %d\n", errno);
+#endif
+
+ // Add node
+ CNode* pnode = new CNode(hSocket, addrConnect, false);
+ if (nTimeout != 0)
+ pnode->AddRef(nTimeout);
+ else
+ pnode->AddRef();
+ CRITICAL_BLOCK(cs_vNodes)
+ vNodes.push_back(pnode);
+
+ pnode->nTimeConnected = GetTime();
+ return pnode;
+ }
+ else
+ {
+ return NULL;
+ }
+}
+
+void CNode::CloseSocketDisconnect()
+{
+ fDisconnect = true;
+ if (hSocket != INVALID_SOCKET)
+ {
+ if (fDebug)
+ printf("%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
+ printf("disconnecting node %s\n", addr.ToString().c_str());
+ closesocket(hSocket);
+ hSocket = INVALID_SOCKET;
+ }
+}
+
+void CNode::Cleanup()
+{
+ // All of a nodes broadcasts and subscriptions are automatically torn down
+ // when it goes down, so a node has to stay up to keep its broadcast going.
+
+ // Cancel subscriptions
+ for (unsigned int nChannel = 0; nChannel < vfSubscribe.size(); nChannel++)
+ if (vfSubscribe[nChannel])
+ CancelSubscribe(nChannel);
+}
+
+
+std::map<unsigned int, int64> CNode::setBanned;
+CCriticalSection CNode::cs_setBanned;
+
+void CNode::ClearBanned()
+{
+ setBanned.clear();
+}
+
+bool CNode::IsBanned(unsigned int ip)
+{
+ bool fResult = false;
+ CRITICAL_BLOCK(cs_setBanned)
+ {
+ std::map<unsigned int, int64>::iterator i = setBanned.find(ip);
+ if (i != setBanned.end())
+ {
+ int64 t = (*i).second;
+ if (GetTime() < t)
+ fResult = true;
+ }
+ }
+ return fResult;
+}
+
+bool CNode::Misbehaving(int howmuch)
+{
+ if (addr.IsLocal())
+ {
+ printf("Warning: local node %s misbehaving\n", addr.ToString().c_str());
+ return false;
+ }
+
+ nMisbehavior += howmuch;
+ if (nMisbehavior >= GetArg("-banscore", 100))
+ {
+ int64 banTime = GetTime()+GetArg("-bantime", 60*60*24); // Default 24-hour ban
+ CRITICAL_BLOCK(cs_setBanned)
+ if (setBanned[addr.ip] < banTime)
+ setBanned[addr.ip] = banTime;
+ CloseSocketDisconnect();
+ printf("Disconnected %s for misbehavior (score=%d)\n", addr.ToString().c_str(), nMisbehavior);
+ return true;
+ }
+ return false;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+void ThreadSocketHandler(void* parg)
+{
+ IMPLEMENT_RANDOMIZE_STACK(ThreadSocketHandler(parg));
+ try
+ {
+ vnThreadsRunning[0]++;
+ ThreadSocketHandler2(parg);
+ vnThreadsRunning[0]--;
+ }
+ catch (std::exception& e) {
+ vnThreadsRunning[0]--;
+ PrintException(&e, "ThreadSocketHandler()");
+ } catch (...) {
+ vnThreadsRunning[0]--;
+ throw; // support pthread_cancel()
+ }
+ printf("ThreadSocketHandler exiting\n");
+}
+
+void ThreadSocketHandler2(void* parg)
+{
+ printf("ThreadSocketHandler started\n");
+ list<CNode*> vNodesDisconnected;
+ int nPrevNodeCount = 0;
+
+ loop
+ {
+ //
+ // Disconnect nodes
+ //
+ CRITICAL_BLOCK(cs_vNodes)
+ {
+ // Disconnect unused nodes
+ vector<CNode*> vNodesCopy = vNodes;
+ BOOST_FOREACH(CNode* pnode, vNodesCopy)
+ {
+ if (pnode->fDisconnect ||
+ (pnode->GetRefCount() <= 0 && pnode->vRecv.empty() && pnode->vSend.empty()))
+ {
+ // remove from vNodes
+ vNodes.erase(remove(vNodes.begin(), vNodes.end(), pnode), vNodes.end());
+
+ // close socket and cleanup
+ pnode->CloseSocketDisconnect();
+ pnode->Cleanup();
+
+ // hold in disconnected pool until all refs are released
+ pnode->nReleaseTime = max(pnode->nReleaseTime, GetTime() + 15 * 60);
+ if (pnode->fNetworkNode || pnode->fInbound)
+ pnode->Release();
+ vNodesDisconnected.push_back(pnode);
+ }
+ }
+
+ // Delete disconnected nodes
+ list<CNode*> vNodesDisconnectedCopy = vNodesDisconnected;
+ BOOST_FOREACH(CNode* pnode, vNodesDisconnectedCopy)
+ {
+ // wait until threads are done using it
+ if (pnode->GetRefCount() <= 0)
+ {
+ bool fDelete = false;
+ TRY_CRITICAL_BLOCK(pnode->cs_vSend)
+ TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
+ TRY_CRITICAL_BLOCK(pnode->cs_mapRequests)
+ TRY_CRITICAL_BLOCK(pnode->cs_inventory)
+ fDelete = true;
+ if (fDelete)
+ {
+ vNodesDisconnected.remove(pnode);
+ delete pnode;
+ }
+ }
+ }
+ }
+ if (vNodes.size() != nPrevNodeCount)
+ {
+ nPrevNodeCount = vNodes.size();
+ MainFrameRepaint();
+ }
+
+
+ //
+ // Find which sockets have data to receive
+ //
+ struct timeval timeout;
+ timeout.tv_sec = 0;
+ timeout.tv_usec = 50000; // frequency to poll pnode->vSend
+
+ fd_set fdsetRecv;
+ fd_set fdsetSend;
+ fd_set fdsetError;
+ FD_ZERO(&fdsetRecv);
+ FD_ZERO(&fdsetSend);
+ FD_ZERO(&fdsetError);
+ SOCKET hSocketMax = 0;
+
+ if(hListenSocket != INVALID_SOCKET)
+ FD_SET(hListenSocket, &fdsetRecv);
+ hSocketMax = max(hSocketMax, hListenSocket);
+ CRITICAL_BLOCK(cs_vNodes)
+ {
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ {
+ if (pnode->hSocket == INVALID_SOCKET)
+ continue;
+ FD_SET(pnode->hSocket, &fdsetRecv);
+ FD_SET(pnode->hSocket, &fdsetError);
+ hSocketMax = max(hSocketMax, pnode->hSocket);
+ TRY_CRITICAL_BLOCK(pnode->cs_vSend)
+ if (!pnode->vSend.empty())
+ FD_SET(pnode->hSocket, &fdsetSend);
+ }
+ }
+
+ vnThreadsRunning[0]--;
+ int nSelect = select(hSocketMax + 1, &fdsetRecv, &fdsetSend, &fdsetError, &timeout);
+ vnThreadsRunning[0]++;
+ if (fShutdown)
+ return;
+ if (nSelect == SOCKET_ERROR)
+ {
+ int nErr = WSAGetLastError();
+ if (hSocketMax > -1)
+ {
+ printf("socket select error %d\n", nErr);
+ for (int i = 0; i <= hSocketMax; i++)
+ FD_SET(i, &fdsetRecv);
+ }
+ FD_ZERO(&fdsetSend);
+ FD_ZERO(&fdsetError);
+ Sleep(timeout.tv_usec/1000);
+ }
+
+
+ //
+ // Accept new connections
+ //
+ if (hListenSocket != INVALID_SOCKET && FD_ISSET(hListenSocket, &fdsetRecv))
+ {
+ struct sockaddr_in sockaddr;
+ socklen_t len = sizeof(sockaddr);
+ SOCKET hSocket = accept(hListenSocket, (struct sockaddr*)&sockaddr, &len);
+ CAddress addr;
+ int nInbound = 0;
+
+ if (hSocket != INVALID_SOCKET)
+ addr = CAddress(sockaddr);
+
+ CRITICAL_BLOCK(cs_vNodes)
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ if (pnode->fInbound)
+ nInbound++;
+
+ if (hSocket == INVALID_SOCKET)
+ {
+ if (WSAGetLastError() != WSAEWOULDBLOCK)
+ printf("socket error accept failed: %d\n", WSAGetLastError());
+ }
+ else if (nInbound >= GetArg("-maxconnections", 125) - MAX_OUTBOUND_CONNECTIONS)
+ {
+ closesocket(hSocket);
+ }
+ else if (CNode::IsBanned(addr.ip))
+ {
+ printf("connection from %s dropped (banned)\n", addr.ToString().c_str());
+ closesocket(hSocket);
+ }
+ else
+ {
+ printf("accepted connection %s\n", addr.ToString().c_str());
+ CNode* pnode = new CNode(hSocket, addr, true);
+ pnode->AddRef();
+ CRITICAL_BLOCK(cs_vNodes)
+ vNodes.push_back(pnode);
+ }
+ }
+
+
+ //
+ // Service each socket
+ //
+ vector<CNode*> vNodesCopy;
+ CRITICAL_BLOCK(cs_vNodes)
+ {
+ vNodesCopy = vNodes;
+ BOOST_FOREACH(CNode* pnode, vNodesCopy)
+ pnode->AddRef();
+ }
+ BOOST_FOREACH(CNode* pnode, vNodesCopy)
+ {
+ if (fShutdown)
+ return;
+
+ //
+ // Receive
+ //
+ if (pnode->hSocket == INVALID_SOCKET)
+ continue;
+ if (FD_ISSET(pnode->hSocket, &fdsetRecv) || FD_ISSET(pnode->hSocket, &fdsetError))
+ {
+ TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
+ {
+ CDataStream& vRecv = pnode->vRecv;
+ unsigned int nPos = vRecv.size();
+
+ if (nPos > ReceiveBufferSize()) {
+ if (!pnode->fDisconnect)
+ printf("socket recv flood control disconnect (%d bytes)\n", vRecv.size());
+ pnode->CloseSocketDisconnect();
+ }
+ else {
+ // typical socket buffer is 8K-64K
+ char pchBuf[0x10000];
+ int nBytes = recv(pnode->hSocket, pchBuf, sizeof(pchBuf), MSG_DONTWAIT);
+ if (nBytes > 0)
+ {
+ vRecv.resize(nPos + nBytes);
+ memcpy(&vRecv[nPos], pchBuf, nBytes);
+ pnode->nLastRecv = GetTime();
+ }
+ else if (nBytes == 0)
+ {
+ // socket closed gracefully
+ if (!pnode->fDisconnect)
+ printf("socket closed\n");
+ pnode->CloseSocketDisconnect();
+ }
+ else if (nBytes < 0)
+ {
+ // error
+ int nErr = WSAGetLastError();
+ if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
+ {
+ if (!pnode->fDisconnect)
+ printf("socket recv error %d\n", nErr);
+ pnode->CloseSocketDisconnect();
+ }
+ }
+ }
+ }
+ }
+
+ //
+ // Send
+ //
+ if (pnode->hSocket == INVALID_SOCKET)
+ continue;
+ if (FD_ISSET(pnode->hSocket, &fdsetSend))
+ {
+ TRY_CRITICAL_BLOCK(pnode->cs_vSend)
+ {
+ CDataStream& vSend = pnode->vSend;
+ if (!vSend.empty())
+ {
+ int nBytes = send(pnode->hSocket, &vSend[0], vSend.size(), MSG_NOSIGNAL | MSG_DONTWAIT);
+ if (nBytes > 0)
+ {
+ vSend.erase(vSend.begin(), vSend.begin() + nBytes);
+ pnode->nLastSend = GetTime();
+ }
+ else if (nBytes < 0)
+ {
+ // error
+ int nErr = WSAGetLastError();
+ if (nErr != WSAEWOULDBLOCK && nErr != WSAEMSGSIZE && nErr != WSAEINTR && nErr != WSAEINPROGRESS)
+ {
+ printf("socket send error %d\n", nErr);
+ pnode->CloseSocketDisconnect();
+ }
+ }
+ if (vSend.size() > SendBufferSize()) {
+ if (!pnode->fDisconnect)
+ printf("socket send flood control disconnect (%d bytes)\n", vSend.size());
+ pnode->CloseSocketDisconnect();
+ }
+ }
+ }
+ }
+
+ //
+ // Inactivity checking
+ //
+ if (pnode->vSend.empty())
+ pnode->nLastSendEmpty = GetTime();
+ if (GetTime() - pnode->nTimeConnected > 60)
+ {
+ if (pnode->nLastRecv == 0 || pnode->nLastSend == 0)
+ {
+ printf("socket no message in first 60 seconds, %d %d\n", pnode->nLastRecv != 0, pnode->nLastSend != 0);
+ pnode->fDisconnect = true;
+ }
+ else if (GetTime() - pnode->nLastSend > 90*60 && GetTime() - pnode->nLastSendEmpty > 90*60)
+ {
+ printf("socket not sending\n");
+ pnode->fDisconnect = true;
+ }
+ else if (GetTime() - pnode->nLastRecv > 90*60)
+ {
+ printf("socket inactivity timeout\n");
+ pnode->fDisconnect = true;
+ }
+ }
+ }
+ CRITICAL_BLOCK(cs_vNodes)
+ {
+ BOOST_FOREACH(CNode* pnode, vNodesCopy)
+ pnode->Release();
+ }
+
+ Sleep(10);
+ }
+}
+
+
+
+
+
+
+
+
+
+#ifdef USE_UPNP
+void ThreadMapPort(void* parg)
+{
+ IMPLEMENT_RANDOMIZE_STACK(ThreadMapPort(parg));
+ try
+ {
+ vnThreadsRunning[5]++;
+ ThreadMapPort2(parg);
+ vnThreadsRunning[5]--;
+ }
+ catch (std::exception& e) {
+ vnThreadsRunning[5]--;
+ PrintException(&e, "ThreadMapPort()");
+ } catch (...) {
+ vnThreadsRunning[5]--;
+ PrintException(NULL, "ThreadMapPort()");
+ }
+ printf("ThreadMapPort exiting\n");
+}
+
+void ThreadMapPort2(void* parg)
+{
+ printf("ThreadMapPort started\n");
+
+ char port[6];
+ sprintf(port, "%d", GetListenPort());
+
+ const char * multicastif = 0;
+ const char * minissdpdpath = 0;
+ struct UPNPDev * devlist = 0;
+ char lanaddr[64];
+
+#ifndef UPNPDISCOVER_SUCCESS
+ /* miniupnpc 1.5 */
+ devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0);
+#else
+ /* miniupnpc 1.6 */
+ int error = 0;
+ devlist = upnpDiscover(2000, multicastif, minissdpdpath, 0, 0, &error);
+#endif
+
+ struct UPNPUrls urls;
+ struct IGDdatas data;
+ int r;
+
+ r = UPNP_GetValidIGD(devlist, &urls, &data, lanaddr, sizeof(lanaddr));
+ if (r == 1)
+ {
+ if (!addrLocalHost.IsRoutable())
+ {
+ char externalIPAddress[40];
+ r = UPNP_GetExternalIPAddress(urls.controlURL, data.first.servicetype, externalIPAddress);
+ if(r != UPNPCOMMAND_SUCCESS)
+ printf("UPnP: GetExternalIPAddress() returned %d\n", r);
+ else
+ {
+ if(externalIPAddress[0])
+ {
+ printf("UPnP: ExternalIPAddress = %s\n", externalIPAddress);
+ CAddress addrExternalFromUPnP(externalIPAddress, 0, false, nLocalServices);
+ if (addrExternalFromUPnP.IsRoutable())
+ addrLocalHost = addrExternalFromUPnP;
+ }
+ else
+ printf("UPnP: GetExternalIPAddress failed.\n");
+ }
+ }
+
+ string strDesc = "Bitcoin " + FormatFullVersion();
+#ifndef UPNPDISCOVER_SUCCESS
+ /* miniupnpc 1.5 */
+ r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
+ port, port, lanaddr, strDesc.c_str(), "TCP", 0);
+#else
+ /* miniupnpc 1.6 */
+ r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
+ port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
+#endif
+
+ if(r!=UPNPCOMMAND_SUCCESS)
+ printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
+ port, port, lanaddr, r, strupnperror(r));
+ else
+ printf("UPnP Port Mapping successful.\n");
+ int i = 1;
+ loop {
+ if (fShutdown || !fUseUPnP)
+ {
+ r = UPNP_DeletePortMapping(urls.controlURL, data.first.servicetype, port, "TCP", 0);
+ printf("UPNP_DeletePortMapping() returned : %d\n", r);
+ freeUPNPDevlist(devlist); devlist = 0;
+ FreeUPNPUrls(&urls);
+ return;
+ }
+ if (i % 600 == 0) // Refresh every 20 minutes
+ {
+#ifndef UPNPDISCOVER_SUCCESS
+ /* miniupnpc 1.5 */
+ r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
+ port, port, lanaddr, strDesc.c_str(), "TCP", 0);
+#else
+ /* miniupnpc 1.6 */
+ r = UPNP_AddPortMapping(urls.controlURL, data.first.servicetype,
+ port, port, lanaddr, strDesc.c_str(), "TCP", 0, "0");
+#endif
+
+ if(r!=UPNPCOMMAND_SUCCESS)
+ printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",
+ port, port, lanaddr, r, strupnperror(r));
+ else
+ printf("UPnP Port Mapping successful.\n");;
+ }
+ Sleep(2000);
+ i++;
+ }
+ } else {
+ printf("No valid UPnP IGDs found\n");
+ freeUPNPDevlist(devlist); devlist = 0;
+ if (r != 0)
+ FreeUPNPUrls(&urls);
+ loop {
+ if (fShutdown || !fUseUPnP)
+ return;
+ Sleep(2000);
+ }
+ }
+}
+
+void MapPort(bool fMapPort)
+{
+ if (fUseUPnP != fMapPort)
+ {
+ fUseUPnP = fMapPort;
+ WriteSetting("fUseUPnP", fUseUPnP);
+ }
+ if (fUseUPnP && vnThreadsRunning[5] < 1)
+ {
+ if (!CreateThread(ThreadMapPort, NULL))
+ printf("Error: ThreadMapPort(ThreadMapPort) failed\n");
+ }
+}
+#else
+void MapPort(bool /* unused fMapPort */)
+{
+ // Intentionally left blank.
+}
+#endif
+
+
+
+
+
+
+
+
+
+
+static const char *strDNSSeed[] = {
+ "bitseed.xf2.org",
+ "dnsseed.bluematt.me",
+ "seed.bitcoin.sipa.be",
+ "dnsseed.bitcoin.dashjr.org",
+};
+
+void ThreadDNSAddressSeed(void* parg)
+{
+ IMPLEMENT_RANDOMIZE_STACK(ThreadDNSAddressSeed(parg));
+ try
+ {
+ vnThreadsRunning[6]++;
+ ThreadDNSAddressSeed2(parg);
+ vnThreadsRunning[6]--;
+ }
+ catch (std::exception& e) {
+ vnThreadsRunning[6]--;
+ PrintException(&e, "ThreadDNSAddressSeed()");
+ } catch (...) {
+ vnThreadsRunning[6]--;
+ throw; // support pthread_cancel()
+ }
+ printf("ThreadDNSAddressSeed exiting\n");
+}
+
+void ThreadDNSAddressSeed2(void* parg)
+{
+ printf("ThreadDNSAddressSeed started\n");
+ int found = 0;
+
+ if (!fTestNet)
+ {
+ printf("Loading addresses from DNS seeds (could take a while)\n");
+
+ for (int seed_idx = 0; seed_idx < ARRAYLEN(strDNSSeed); seed_idx++) {
+ vector<CAddress> vaddr;
+ if (Lookup(strDNSSeed[seed_idx], vaddr, NODE_NETWORK, -1, true))
+ {
+ CAddrDB addrDB;
+ addrDB.TxnBegin();
+ BOOST_FOREACH (CAddress& addr, vaddr)
+ {
+ if (addr.GetByte(3) != 127)
+ {
+ addr.nTime = 0;
+ AddAddress(addr, 0, &addrDB);
+ found++;
+ }
+ }
+ addrDB.TxnCommit(); // Save addresses (it's ok if this fails)
+ }
+ }
+ }
+
+ printf("%d addresses found from DNS seeds\n", found);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+unsigned int pnSeed[] =
+{
+ 0x959bd347, 0xf8de42b2, 0x73bc0518, 0xea6edc50, 0x21b00a4d, 0xc725b43d, 0xd665464d, 0x1a2a770e,
+ 0x27c93946, 0x65b2fa46, 0xb80ae255, 0x66b3b446, 0xb1877a3e, 0x6ee89e3e, 0xc3175b40, 0x2a01a83c,
+ 0x95b1363a, 0xa079ad3d, 0xe6ca801f, 0x027f4f4a, 0x34f7f03a, 0xf790f04a, 0x16ca801f, 0x2f4d5e40,
+ 0x3a4d5e40, 0xc43a322e, 0xc8159753, 0x14d4724c, 0x7919a118, 0xe0bdb34e, 0x68a16b2e, 0xff64b44d,
+ 0x6099115b, 0x9b57b05b, 0x7bd1b4ad, 0xdf95944f, 0x29d2b73d, 0xafa8db79, 0xe247ba41, 0x24078348,
+ 0xf722f03c, 0x33567ebc, 0xace64ed4, 0x984d3932, 0xb5f34e55, 0x27b7024d, 0x94579247, 0x8894042e,
+ 0x9357d34c, 0x1063c24b, 0xcaa228b1, 0xa3c5a8b2, 0x5dc64857, 0xa2c23643, 0xa8369a54, 0x31203077,
+ 0x00707c5c, 0x09fc0b3a, 0x272e9e2e, 0xf80f043e, 0x9449ca3e, 0x5512c33e, 0xd106b555, 0xe8024157,
+ 0xe288ec29, 0xc79c5461, 0xafb63932, 0xdb02ab4b, 0x0e512777, 0x8a145a4c, 0xb201ff4f, 0x5e09314b,
+ 0xcd9bfbcd, 0x1c023765, 0x4394e75c, 0xa728bd4d, 0x65331552, 0xa98420b1, 0x89ecf559, 0x6e80801f,
+ 0xf404f118, 0xefd62b51, 0x05918346, 0x9b186d5f, 0xacabab46, 0xf912e255, 0xc188ea62, 0xcc55734e,
+ 0xc668064d, 0xd77a4558, 0x46201c55, 0xf17dfc80, 0xf7142f2e, 0x87bfb718, 0x8aa54fb2, 0xc451d518,
+ 0xc4ae8831, 0x8dd44d55, 0x5bbd206c, 0x64536b5d, 0x5c667e60, 0x3b064242, 0xfe963a42, 0xa28e6dc8,
+ 0xe8a9604a, 0xc989464e, 0xd124a659, 0x50065140, 0xa44dfe5e, 0x1079e655, 0x3fb986d5, 0x47895b18,
+ 0x7d3ce4ad, 0x4561ba50, 0x296eec62, 0x255b41ad, 0xaed35ec9, 0x55556f12, 0xc7d3154d, 0x3297b65d,
+ 0x8930121f, 0xabf42e4e, 0x4a29e044, 0x1212685d, 0x676c1e40, 0xce009744, 0x383a8948, 0xa2dbd0ad,
+ 0xecc2564d, 0x07dbc252, 0x887ee24b, 0x5171644c, 0x6bb798c1, 0x847f495d, 0x4cbb7145, 0x3bb81c32,
+ 0x45eb262e, 0xc8015a4e, 0x250a361b, 0xf694f946, 0xd64a183e, 0xd4f1dd59, 0x8f20ffd4, 0x51d9e55c,
+ 0x09521763, 0x5e02002e, 0x32c8074d, 0xe685762e, 0x8290b0bc, 0x762a922e, 0xfc5ee754, 0x83a24829,
+ 0x775b224d, 0x6295bb4d, 0x38ec0555, 0xbffbba50, 0xe5560260, 0x86b16a7c, 0xd372234e, 0x49a3c24b,
+ 0x2f6a171f, 0x4d75ed60, 0xae94115b, 0xcb543744, 0x63080c59, 0x3f9c724c, 0xc977ce18, 0x532efb18,
+ 0x69dc3b2e, 0x5f94d929, 0x1732bb4d, 0x9c814b4d, 0xe6b3762e, 0xc024f662, 0x8face35b, 0x6b5b044d,
+ 0x798c7b57, 0x79a6b44c, 0x067d3057, 0xf9e94e5f, 0x91cbe15b, 0x71405eb2, 0x2662234e, 0xcbcc4a6d,
+ 0xbf69d54b, 0xa79b4e55, 0xec6d3e51, 0x7c0b3c02, 0x60f83653, 0x24c1e15c, 0x1110b62e, 0x10350f59,
+ 0xa56f1d55, 0x3509e7a9, 0xeb128354, 0x14268e2e, 0x934e28bc, 0x8e32692e, 0x8331a21f, 0x3e633932,
+ 0xc812b12e, 0xc684bf2e, 0x80112d2e, 0xe0ddc96c, 0xc630ca4a, 0x5c09b3b2, 0x0b580518, 0xc8e9d54b,
+ 0xd169aa43, 0x17d0d655, 0x1d029963, 0x7ff87559, 0xcb701f1f, 0x6fa3e85d, 0xe45e9a54, 0xf05d1802,
+ 0x44d03b2e, 0x837b692e, 0xccd4354e, 0x3d6da13c, 0x3423084d, 0xf707c34a, 0x55f6db3a, 0xad26e442,
+ 0x6233a21f, 0x09e80e59, 0x8caeb54d, 0xbe870941, 0xb407d20e, 0x20b51018, 0x56fb152e, 0x460d2a4e,
+ 0xbb9a2946, 0x560eb12e, 0xed83dd29, 0xd6724f53, 0xa50aafb8, 0x451346d9, 0x88348e2e, 0x7312fead,
+ 0x8ecaf96f, 0x1bda4e5f, 0xf1671e40, 0x3c8c3e3b, 0x4716324d, 0xdde24ede, 0xf98cd17d, 0xa91d4644,
+ 0x28124eb2, 0x147d5129, 0xd022042e, 0x61733d3b, 0xad0d5e02, 0x8ce2932e, 0xe5c18502, 0x549c1e32,
+ 0x9685801f, 0x86e217ad, 0xd948214b, 0x4110f462, 0x3a2e894e, 0xbd35492e, 0x87e0d558, 0x64b8ef7d,
+ 0x7c3eb962, 0x72a84b3e, 0x7cd667c9, 0x28370a2e, 0x4bc60e7b, 0x6fc1ec60, 0x14a6983f, 0x86739a4b,
+ 0x46954e5f, 0x32e2e15c, 0x2e9326cf, 0xe5801c5e, 0x379607b2, 0x32151145, 0xf0e39744, 0xacb54c55,
+ 0xa37dfb60, 0x83b55cc9, 0x388f7ca5, 0x15034f5f, 0x3e94965b, 0x68e0ffad, 0x35280f59, 0x8fe190cf,
+ 0x7c6ba5b2, 0xa5e9db43, 0x4ee1fc60, 0xd9d94e5f, 0x04040677, 0x0ea9b35e, 0x5961f14f, 0x67fda063,
+ 0xa48a5a31, 0xc6524e55, 0x283d325e, 0x3f37515f, 0x96b94b3e, 0xacce620e, 0x6481cc5b, 0xa4a06d4b,
+ 0x9e95d2d9, 0xe40c03d5, 0xc2f4514b, 0xb79aad44, 0xf64be843, 0xb2064070, 0xfca00455, 0x429dfa4e,
+ 0x2323f173, 0xeda4185e, 0xabd5227d, 0x9efd4d58, 0xb1104758, 0x4811e955, 0xbd9ab355, 0xe921f44b,
+ 0x9f166dce, 0x09e279b2, 0xe0c9ac7b, 0x7901a5ad, 0xa145d4b0, 0x79104671, 0xec31e35a, 0x4fe0b555,
+ 0xc7d9cbad, 0xad057f55, 0xe94cc759, 0x7fe0b043, 0xe4529f2e, 0x0d4dd4b2, 0x9f11a54d, 0x031e2e4e,
+ 0xe6014f5f, 0x11d1ca6c, 0x26bd7f61, 0xeb86854f, 0x4d347b57, 0x116bbe2e, 0xdba7234e, 0x7bcbfd2e,
+ 0x174dd4b2, 0x6686762e, 0xb089ba50, 0xc6258246, 0x087e767b, 0xc4a8cb4a, 0x595dba50, 0x7f0ae502,
+ 0x7b1dbd5a, 0xa0603492, 0x57d1af4b, 0x9e21ffd4, 0x6393064d, 0x7407376e, 0xe484762e, 0x122a4e53,
+ 0x4a37aa43, 0x3888a6be, 0xee77864e, 0x039c8dd5, 0x688d89af, 0x0e988f62, 0x08218246, 0xfc2f8246,
+ 0xd1d97040, 0xd64cd4b2, 0x5ae4a6b8, 0x7d0de9bc, 0x8d304d61, 0x06c5c672, 0xa4c8bd4d, 0xe0fd373b,
+ 0x575ebe4d, 0x72d26277, 0x55570f55, 0x77b154d9, 0xe214293a, 0xfc740f4b, 0xfe3f6a57, 0xa9c55f02,
+ 0xae4054db, 0x2394d918, 0xb511b24a, 0xb8741ab2, 0x0758e65e, 0xc7b5795b, 0xb0a30a4c, 0xaf7f170c,
+ 0xf3b4762e, 0x8179576d, 0x738a1581, 0x4b95b64c, 0x9829b618, 0x1bea932e, 0x7bdeaa4b, 0xcb5e0281,
+ 0x65618f54, 0x0658474b, 0x27066acf, 0x40556d65, 0x7d204d53, 0xf28bc244, 0xdce23455, 0xadc0ff54,
+ 0x3863c948, 0xcee34e5f, 0xdeb85e02, 0x2ed17a61, 0x6a7b094d, 0x7f0cfc40, 0x59603f54, 0x3220afbc,
+ 0xb5dfd962, 0x125d21c0, 0x13f8d243, 0xacfefb4e, 0x86c2c147, 0x3d8bbd59, 0xbd02a21f, 0x2593042e,
+ 0xc6a17a7c, 0x28925861, 0xb487ed44, 0xb5f4fd6d, 0x90c28a45, 0x5a14f74d, 0x43d71b4c, 0x728ebb5d,
+ 0x885bf950, 0x08134dd0, 0x38ec046e, 0xc575684b, 0x50082d2e, 0xa2f47757, 0x270f86ae, 0xf3ff6462,
+ 0x10ed3f4e, 0x4b58d462, 0xe01ce23e, 0x8c5b092e, 0x63e52f4e, 0x22c1e85d, 0xa908f54e, 0x8591624f,
+ 0x2c0fb94e, 0xa280ba3c, 0xb6f41b4c, 0x24f9aa47, 0x27201647, 0x3a3ea6dc, 0xa14fc3be, 0x3c34bdd5,
+ 0x5b8d4f5b, 0xaadeaf4b, 0xc71cab50, 0x15697a4c, 0x9a1a734c, 0x2a037d81, 0x2590bd59, 0x48ec2741,
+ 0x53489c5b, 0x7f00314b, 0x2170d362, 0xf2e92542, 0x42c10b44, 0x98f0f118, 0x883a3456, 0x099a932e,
+ 0xea38f7bc, 0x644e9247, 0xbb61b62e, 0x30e0863d, 0x5f51be54, 0x207215c7, 0x5f306c45, 0xaa7f3932,
+ 0x98da7d45, 0x4e339b59, 0x2e411581, 0xa808f618, 0xad2c0c59, 0x54476741, 0x09e99fd1, 0x5db8f752,
+ 0xc16df8bd, 0x1dd4b44f, 0x106edf2e, 0x9e15c180, 0x2ad6b56f, 0x633a5332, 0xff33787c, 0x077cb545,
+ 0x6610be6d, 0x75aad2c4, 0x72fb4d5b, 0xe81e0f59, 0x576f6332, 0x47333373, 0x351ed783, 0x2d90fb50,
+ 0x8d5e0f6c, 0x5b27a552, 0xdb293ebb, 0xe55ef950, 0x4b133ad8, 0x75df975a, 0x7b6a8740, 0xa899464b,
+ 0xfab15161, 0x10f8b64d, 0xd055ea4d, 0xee8e146b, 0x4b14afb8, 0x4bc1c44a, 0x9b961dcc, 0xd111ff43,
+ 0xfca0b745, 0xc800e412, 0x0afad9d1, 0xf751c350, 0xf9f0cccf, 0xa290a545, 0x8ef13763, 0x7ec70d59,
+ 0x2b066acf, 0x65496c45, 0xade02c1b, 0xae6eb077, 0x92c1e65b, 0xc064e6a9, 0xc649e56d, 0x5287a243,
+ 0x36de4f5b, 0x5b1df6ad, 0x65c39a59, 0xdba805b2, 0x20067aa8, 0x6457e56d, 0x3cee26cf, 0xfd3ff26d,
+ 0x04f86d4a, 0x06b8e048, 0xa93bcd5c, 0x91135852, 0xbe90a643, 0x8fa0094d, 0x06d8215f, 0x2677094d,
+ 0xd735685c, 0x164a00c9, 0x5209ac5f, 0xa9564c5c, 0x3b504f5f, 0xcc826bd0, 0x4615042e, 0x5fe13b4a,
+ 0x8c81b86d, 0x879ab68c, 0x1de564b8, 0x434487d8, 0x2dcb1b63, 0x82ab524a, 0xb0676abb, 0xa13d9c62,
+ 0xdbb5b86d, 0x5b7f4b59, 0xaddfb44d, 0xad773532, 0x3997054c, 0x72cebd89, 0xb194544c, 0xc5b8046e,
+ 0x6e1adeb2, 0xaa5abb51, 0xefb54b44, 0x15efc54f, 0xe9f1bc4d, 0x5f401b6c, 0x97f018ad, 0xc82f9252,
+ 0x2cdc762e, 0x8e52e56d, 0x1827175e, 0x9b7d7d80, 0xb2ad6845, 0x51065140, 0x71180a18, 0x5b27006c,
+ 0x0621e255, 0x721cbe58, 0x670c0cb8, 0xf8bd715d, 0xe0bdc5d9, 0xed843501, 0x4b84554d, 0x7f1a18bc,
+ 0x53bcaf47, 0x5729d35f, 0xf0dda246, 0x22382bd0, 0x4d641fb0, 0x316afcde, 0x50a22f1f, 0x73608046,
+ 0xc461d84a, 0xb2dbe247,
+};
+
+
+
+void ThreadOpenConnections(void* parg)
+{
+ IMPLEMENT_RANDOMIZE_STACK(ThreadOpenConnections(parg));
+ try
+ {
+ vnThreadsRunning[1]++;
+ ThreadOpenConnections2(parg);
+ vnThreadsRunning[1]--;
+ }
+ catch (std::exception& e) {
+ vnThreadsRunning[1]--;
+ PrintException(&e, "ThreadOpenConnections()");
+ } catch (...) {
+ vnThreadsRunning[1]--;
+ PrintException(NULL, "ThreadOpenConnections()");
+ }
+ printf("ThreadOpenConnections exiting\n");
+}
+
+void ThreadOpenConnections2(void* parg)
+{
+ printf("ThreadOpenConnections started\n");
+
+ // Connect to specific addresses
+ if (mapArgs.count("-connect"))
+ {
+ for (int64 nLoop = 0;; nLoop++)
+ {
+ BOOST_FOREACH(string strAddr, mapMultiArgs["-connect"])
+ {
+ CAddress addr(strAddr, fAllowDNS);
+ if (addr.IsValid())
+ OpenNetworkConnection(addr);
+ for (int i = 0; i < 10 && i < nLoop; i++)
+ {
+ Sleep(500);
+ if (fShutdown)
+ return;
+ }
+ }
+ }
+ }
+
+ // Connect to manually added nodes first
+ if (mapArgs.count("-addnode"))
+ {
+ BOOST_FOREACH(string strAddr, mapMultiArgs["-addnode"])
+ {
+ CAddress addr(strAddr, fAllowDNS);
+ if (addr.IsValid())
+ {
+ OpenNetworkConnection(addr);
+ Sleep(500);
+ if (fShutdown)
+ return;
+ }
+ }
+ }
+
+ // Initiate network connections
+ int64 nStart = GetTime();
+ loop
+ {
+ vnThreadsRunning[1]--;
+ Sleep(500);
+ vnThreadsRunning[1]++;
+ if (fShutdown)
+ return;
+
+ // Limit outbound connections
+ loop
+ {
+ int nOutbound = 0;
+ CRITICAL_BLOCK(cs_vNodes)
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ if (!pnode->fInbound)
+ nOutbound++;
+ int nMaxOutboundConnections = MAX_OUTBOUND_CONNECTIONS;
+ nMaxOutboundConnections = min(nMaxOutboundConnections, (int)GetArg("-maxconnections", 125));
+ if (nOutbound < nMaxOutboundConnections)
+ break;
+ vnThreadsRunning[1]--;
+ Sleep(2000);
+ vnThreadsRunning[1]++;
+ if (fShutdown)
+ return;
+ }
+
+ bool fAddSeeds = false;
+
+ CRITICAL_BLOCK(cs_mapAddresses)
+ {
+ // Add seed nodes if IRC isn't working
+ bool fTOR = (fUseProxy && addrProxy.port == htons(9050));
+ if (mapAddresses.empty() && (GetTime() - nStart > 60 || fUseProxy) && !fTestNet)
+ fAddSeeds = true;
+ }
+
+ if (fAddSeeds)
+ {
+ for (int i = 0; i < ARRAYLEN(pnSeed); i++)
+ {
+ // It'll only connect to one or two seed nodes because once it connects,
+ // it'll get a pile of addresses with newer timestamps.
+ // Seed nodes are given a random 'last seen time' of between one and two
+ // weeks ago.
+ const int64 nOneWeek = 7*24*60*60;
+ CAddress addr;
+ addr.ip = pnSeed[i];
+ addr.nTime = GetTime()-GetRand(nOneWeek)-nOneWeek;
+ AddAddress(addr);
+ }
+ }
+
+ //
+ // Choose an address to connect to based on most recently seen
+ //
+ CAddress addrConnect;
+ int64 nBest = INT64_MIN;
+
+ // Only connect to one address per a.b.?.? range.
+ // Do this here so we don't have to critsect vNodes inside mapAddresses critsect.
+ set<unsigned int> setConnected;
+ CRITICAL_BLOCK(cs_vNodes)
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ setConnected.insert(pnode->addr.ip & 0x0000ffff);
+
+ int64 nANow = GetAdjustedTime();
+
+ CRITICAL_BLOCK(cs_mapAddresses)
+ {
+ BOOST_FOREACH(const PAIRTYPE(vector<unsigned char>, CAddress)& item, mapAddresses)
+ {
+ const CAddress& addr = item.second;
+ if (!addr.IsIPv4() || !addr.IsValid() || setConnected.count(addr.ip & 0x0000ffff))
+ continue;
+ int64 nSinceLastSeen = nANow - addr.nTime;
+ int64 nSinceLastTry = nANow - addr.nLastTry;
+
+ // Randomize the order in a deterministic way, putting the standard port first
+ int64 nRandomizer = (uint64)(nStart * 4951 + addr.nLastTry * 9567851 + addr.ip * 7789) % (2 * 60 * 60);
+ if (addr.port != htons(GetDefaultPort()))
+ nRandomizer += 2 * 60 * 60;
+
+ // Last seen Base retry frequency
+ // <1 hour 10 min
+ // 1 hour 1 hour
+ // 4 hours 2 hours
+ // 24 hours 5 hours
+ // 48 hours 7 hours
+ // 7 days 13 hours
+ // 30 days 27 hours
+ // 90 days 46 hours
+ // 365 days 93 hours
+ int64 nDelay = (int64)(3600.0 * sqrt(fabs((double)nSinceLastSeen) / 3600.0) + nRandomizer);
+
+ // Fast reconnect for one hour after last seen
+ if (nSinceLastSeen < 60 * 60)
+ nDelay = 10 * 60;
+
+ // Limit retry frequency
+ if (nSinceLastTry < nDelay)
+ continue;
+
+ // If we have IRC, we'll be notified when they first come online,
+ // and again every 24 hours by the refresh broadcast.
+ if (nGotIRCAddresses > 0 && vNodes.size() >= 2 && nSinceLastSeen > 24 * 60 * 60)
+ continue;
+
+ // Only try the old stuff if we don't have enough connections
+ if (vNodes.size() >= 8 && nSinceLastSeen > 24 * 60 * 60)
+ continue;
+
+ // If multiple addresses are ready, prioritize by time since
+ // last seen and time since last tried.
+ int64 nScore = min(nSinceLastTry, (int64)24 * 60 * 60) - nSinceLastSeen - nRandomizer;
+ if (nScore > nBest)
+ {
+ nBest = nScore;
+ addrConnect = addr;
+ }
+ }
+ }
+
+ if (addrConnect.IsValid())
+ OpenNetworkConnection(addrConnect);
+ }
+}
+
+bool OpenNetworkConnection(const CAddress& addrConnect)
+{
+ //
+ // Initiate outbound network connection
+ //
+ if (fShutdown)
+ return false;
+ if (addrConnect.ip == addrLocalHost.ip || !addrConnect.IsIPv4() ||
+ FindNode(addrConnect.ip) || CNode::IsBanned(addrConnect.ip))
+ return false;
+
+ vnThreadsRunning[1]--;
+ CNode* pnode = ConnectNode(addrConnect);
+ vnThreadsRunning[1]++;
+ if (fShutdown)
+ return false;
+ if (!pnode)
+ return false;
+ pnode->fNetworkNode = true;
+
+ return true;
+}
+
+
+
+
+
+
+
+
+void ThreadMessageHandler(void* parg)
+{
+ IMPLEMENT_RANDOMIZE_STACK(ThreadMessageHandler(parg));
+ try
+ {
+ vnThreadsRunning[2]++;
+ ThreadMessageHandler2(parg);
+ vnThreadsRunning[2]--;
+ }
+ catch (std::exception& e) {
+ vnThreadsRunning[2]--;
+ PrintException(&e, "ThreadMessageHandler()");
+ } catch (...) {
+ vnThreadsRunning[2]--;
+ PrintException(NULL, "ThreadMessageHandler()");
+ }
+ printf("ThreadMessageHandler exiting\n");
+}
+
+void ThreadMessageHandler2(void* parg)
+{
+ printf("ThreadMessageHandler started\n");
+ SetThreadPriority(THREAD_PRIORITY_BELOW_NORMAL);
+ while (!fShutdown)
+ {
+ vector<CNode*> vNodesCopy;
+ CRITICAL_BLOCK(cs_vNodes)
+ {
+ vNodesCopy = vNodes;
+ BOOST_FOREACH(CNode* pnode, vNodesCopy)
+ pnode->AddRef();
+ }
+
+ // Poll the connected nodes for messages
+ CNode* pnodeTrickle = NULL;
+ if (!vNodesCopy.empty())
+ pnodeTrickle = vNodesCopy[GetRand(vNodesCopy.size())];
+ BOOST_FOREACH(CNode* pnode, vNodesCopy)
+ {
+ // Receive messages
+ TRY_CRITICAL_BLOCK(pnode->cs_vRecv)
+ ProcessMessages(pnode);
+ if (fShutdown)
+ return;
+
+ // Send messages
+ TRY_CRITICAL_BLOCK(pnode->cs_vSend)
+ SendMessages(pnode, pnode == pnodeTrickle);
+ if (fShutdown)
+ return;
+ }
+
+ CRITICAL_BLOCK(cs_vNodes)
+ {
+ BOOST_FOREACH(CNode* pnode, vNodesCopy)
+ pnode->Release();
+ }
+
+ // Wait and allow messages to bunch up.
+ // Reduce vnThreadsRunning so StopNode has permission to exit while
+ // we're sleeping, but we must always check fShutdown after doing this.
+ vnThreadsRunning[2]--;
+ Sleep(100);
+ if (fRequestShutdown)
+ Shutdown(NULL);
+ vnThreadsRunning[2]++;
+ if (fShutdown)
+ return;
+ }
+}
+
+
+
+
+
+
+bool BindListenPort(string& strError)
+{
+ strError = "";
+ int nOne = 1;
+ addrLocalHost.port = htons(GetListenPort());
+
+#ifdef WIN32
+ // Initialize Windows Sockets
+ WSADATA wsadata;
+ int ret = WSAStartup(MAKEWORD(2,2), &wsadata);
+ if (ret != NO_ERROR)
+ {
+ strError = strprintf("Error: TCP/IP socket library failed to start (WSAStartup returned error %d)", ret);
+ printf("%s\n", strError.c_str());
+ return false;
+ }
+#endif
+
+ // Create socket for listening for incoming connections
+ hListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+ if (hListenSocket == INVALID_SOCKET)
+ {
+ strError = strprintf("Error: Couldn't open socket for incoming connections (socket returned error %d)", WSAGetLastError());
+ printf("%s\n", strError.c_str());
+ return false;
+ }
+
+#ifdef SO_NOSIGPIPE
+ // Different way of disabling SIGPIPE on BSD
+ setsockopt(hListenSocket, SOL_SOCKET, SO_NOSIGPIPE, (void*)&nOne, sizeof(int));
+#endif
+
+#ifndef WIN32
+ // Allow binding if the port is still in TIME_WAIT state after
+ // the program was closed and restarted. Not an issue on windows.
+ setsockopt(hListenSocket, SOL_SOCKET, SO_REUSEADDR, (void*)&nOne, sizeof(int));
+#endif
+
+#ifdef WIN32
+ // Set to nonblocking, incoming connections will also inherit this
+ if (ioctlsocket(hListenSocket, FIONBIO, (u_long*)&nOne) == SOCKET_ERROR)
+#else
+ if (fcntl(hListenSocket, F_SETFL, O_NONBLOCK) == SOCKET_ERROR)
+#endif
+ {
+ strError = strprintf("Error: Couldn't set properties on socket for incoming connections (error %d)", WSAGetLastError());
+ printf("%s\n", strError.c_str());
+ return false;
+ }
+
+ // The sockaddr_in structure specifies the address family,
+ // IP address, and port for the socket that is being bound
+ struct sockaddr_in sockaddr;
+ memset(&sockaddr, 0, sizeof(sockaddr));
+ sockaddr.sin_family = AF_INET;
+ sockaddr.sin_addr.s_addr = INADDR_ANY; // bind to all IPs on this computer
+ sockaddr.sin_port = htons(GetListenPort());
+ if (::bind(hListenSocket, (struct sockaddr*)&sockaddr, sizeof(sockaddr)) == SOCKET_ERROR)
+ {
+ int nErr = WSAGetLastError();
+ if (nErr == WSAEADDRINUSE)
+ strError = strprintf(_("Unable to bind to port %d on this computer. Bitcoin is probably already running."), ntohs(sockaddr.sin_port));
+ else
+ strError = strprintf("Error: Unable to bind to port %d on this computer (bind returned error %d)", ntohs(sockaddr.sin_port), nErr);
+ printf("%s\n", strError.c_str());
+ return false;
+ }
+ printf("Bound to port %d\n", ntohs(sockaddr.sin_port));
+
+ // Listen for incoming connections
+ if (listen(hListenSocket, SOMAXCONN) == SOCKET_ERROR)
+ {
+ strError = strprintf("Error: Listening for incoming connections failed (listen returned error %d)", WSAGetLastError());
+ printf("%s\n", strError.c_str());
+ return false;
+ }
+
+ return true;
+}
+
+void StartNode(void* parg)
+{
+ if (pnodeLocalHost == NULL)
+ pnodeLocalHost = new CNode(INVALID_SOCKET, CAddress("127.0.0.1", 0, false, nLocalServices));
+
+#ifdef WIN32
+ // Get local host ip
+ char pszHostName[1000] = "";
+ if (gethostname(pszHostName, sizeof(pszHostName)) != SOCKET_ERROR)
+ {
+ vector<CAddress> vaddr;
+ if (Lookup(pszHostName, vaddr, nLocalServices, -1, true))
+ BOOST_FOREACH (const CAddress &addr, vaddr)
+ if (addr.GetByte(3) != 127)
+ {
+ addrLocalHost = addr;
+ break;
+ }
+ }
+#else
+ // Get local host ip
+ struct ifaddrs* myaddrs;
+ if (getifaddrs(&myaddrs) == 0)
+ {
+ for (struct ifaddrs* ifa = myaddrs; ifa != NULL; ifa = ifa->ifa_next)
+ {
+ if (ifa->ifa_addr == NULL) continue;
+ if ((ifa->ifa_flags & IFF_UP) == 0) continue;
+ if (strcmp(ifa->ifa_name, "lo") == 0) continue;
+ if (strcmp(ifa->ifa_name, "lo0") == 0) continue;
+ char pszIP[100];
+ if (ifa->ifa_addr->sa_family == AF_INET)
+ {
+ struct sockaddr_in* s4 = (struct sockaddr_in*)(ifa->ifa_addr);
+ if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s4->sin_addr), pszIP, sizeof(pszIP)) != NULL)
+ printf("ipv4 %s: %s\n", ifa->ifa_name, pszIP);
+
+ // Take the first IP that isn't loopback 127.x.x.x
+ CAddress addr(*(unsigned int*)&s4->sin_addr, GetListenPort(), nLocalServices);
+ if (addr.IsValid() && addr.GetByte(3) != 127)
+ {
+ addrLocalHost = addr;
+ break;
+ }
+ }
+ else if (ifa->ifa_addr->sa_family == AF_INET6)
+ {
+ struct sockaddr_in6* s6 = (struct sockaddr_in6*)(ifa->ifa_addr);
+ if (inet_ntop(ifa->ifa_addr->sa_family, (void*)&(s6->sin6_addr), pszIP, sizeof(pszIP)) != NULL)
+ printf("ipv6 %s: %s\n", ifa->ifa_name, pszIP);
+ }
+ }
+ freeifaddrs(myaddrs);
+ }
+#endif
+ printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
+
+ if (fUseProxy || mapArgs.count("-connect") || fNoListen)
+ {
+ // Proxies can't take incoming connections
+ addrLocalHost.ip = CAddress("0.0.0.0").ip;
+ printf("addrLocalHost = %s\n", addrLocalHost.ToString().c_str());
+ }
+ else
+ {
+ CreateThread(ThreadGetMyExternalIP, NULL);
+ }
+
+ //
+ // Start threads
+ //
+
+ if (GetBoolArg("-nodnsseed"))
+ printf("DNS seeding disabled\n");
+ else
+ if (!CreateThread(ThreadDNSAddressSeed, NULL))
+ printf("Error: CreateThread(ThreadDNSAddressSeed) failed\n");
+
+ // Map ports with UPnP
+ if (fHaveUPnP)
+ MapPort(fUseUPnP);
+
+ // Get addresses from IRC and advertise ours
+ if (!CreateThread(ThreadIRCSeed, NULL))
+ printf("Error: CreateThread(ThreadIRCSeed) failed\n");
+
+ // Send and receive from sockets, accept connections
+ if (!CreateThread(ThreadSocketHandler, NULL))
+ printf("Error: CreateThread(ThreadSocketHandler) failed\n");
+
+ // Initiate outbound connections
+ if (!CreateThread(ThreadOpenConnections, NULL))
+ printf("Error: CreateThread(ThreadOpenConnections) failed\n");
+
+ // Process messages
+ if (!CreateThread(ThreadMessageHandler, NULL))
+ printf("Error: CreateThread(ThreadMessageHandler) failed\n");
+
+ // Generate coins in the background
+ GenerateBitcoins(fGenerateBitcoins, pwalletMain);
+}
+
+bool StopNode()
+{
+ printf("StopNode()\n");
+ fShutdown = true;
+ nTransactionsUpdated++;
+ int64 nStart = GetTime();
+ while (vnThreadsRunning[0] > 0 || vnThreadsRunning[1] > 0 || vnThreadsRunning[2] > 0 || vnThreadsRunning[3] > 0 || vnThreadsRunning[4] > 0
+#ifdef USE_UPNP
+ || vnThreadsRunning[5] > 0
+#endif
+ )
+ {
+ if (GetTime() - nStart > 20)
+ break;
+ Sleep(20);
+ }
+ if (vnThreadsRunning[0] > 0) printf("ThreadSocketHandler still running\n");
+ if (vnThreadsRunning[1] > 0) printf("ThreadOpenConnections still running\n");
+ if (vnThreadsRunning[2] > 0) printf("ThreadMessageHandler still running\n");
+ if (vnThreadsRunning[3] > 0) printf("ThreadBitcoinMiner still running\n");
+ if (vnThreadsRunning[4] > 0) printf("ThreadRPCServer still running\n");
+ if (fHaveUPnP && vnThreadsRunning[5] > 0) printf("ThreadMapPort still running\n");
+ if (vnThreadsRunning[6] > 0) printf("ThreadDNSAddressSeed still running\n");
+ while (vnThreadsRunning[2] > 0 || vnThreadsRunning[4] > 0)
+ Sleep(20);
+ Sleep(50);
+
+ return true;
+}
+
+class CNetCleanup
+{
+public:
+ CNetCleanup()
+ {
+ }
+ ~CNetCleanup()
+ {
+ // Close sockets
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ if (pnode->hSocket != INVALID_SOCKET)
+ closesocket(pnode->hSocket);
+ if (hListenSocket != INVALID_SOCKET)
+ if (closesocket(hListenSocket) == SOCKET_ERROR)
+ printf("closesocket(hListenSocket) failed with error %d\n", WSAGetLastError());
+
+#ifdef WIN32
+ // Shutdown Windows Sockets
+ WSACleanup();
+#endif
+ }
+}
+instance_of_cnetcleanup;
diff --git a/bitcoin/src/net.h b/bitcoin/src/net.h
@@ -0,0 +1,701 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2012 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#ifndef BITCOIN_NET_H
+#define BITCOIN_NET_H
+
+#include <deque>
+#include <boost/array.hpp>
+#include <boost/foreach.hpp>
+#include <openssl/rand.h>
+
+#ifndef WIN32
+#include <arpa/inet.h>
+#endif
+
+#include "protocol.h"
+
+class CAddrDB;
+class CRequestTracker;
+class CNode;
+class CBlockIndex;
+extern int nBestHeight;
+extern int nConnectTimeout;
+
+
+
+inline unsigned int ReceiveBufferSize() { return 1000*GetArg("-maxreceivebuffer", 10*1000); }
+inline unsigned int SendBufferSize() { return 1000*GetArg("-maxsendbuffer", 10*1000); }
+static const unsigned int PUBLISH_HOPS = 5;
+
+bool ConnectSocket(const CAddress& addrConnect, SOCKET& hSocketRet, int nTimeout=nConnectTimeout);
+bool Lookup(const char *pszName, std::vector<CAddress>& vaddr, int nServices, int nMaxSolutions, bool fAllowLookup = false, int portDefault = 0, bool fAllowPort = false);
+bool Lookup(const char *pszName, CAddress& addr, int nServices, bool fAllowLookup = false, int portDefault = 0, bool fAllowPort = false);
+bool GetMyExternalIP(unsigned int& ipRet);
+bool AddAddress(CAddress addr, int64 nTimePenalty=0, CAddrDB *pAddrDB=NULL);
+void AddressCurrentlyConnected(const CAddress& addr);
+CNode* FindNode(unsigned int ip);
+CNode* ConnectNode(CAddress addrConnect, int64 nTimeout=0);
+void AbandonRequests(void (*fn)(void*, CDataStream&), void* param1);
+bool AnySubscribed(unsigned int nChannel);
+void MapPort(bool fMapPort);
+bool BindListenPort(std::string& strError=REF(std::string()));
+void StartNode(void* parg);
+bool StopNode();
+
+enum
+{
+ MSG_TX = 1,
+ MSG_BLOCK,
+};
+
+class CRequestTracker
+{
+public:
+ void (*fn)(void*, CDataStream&);
+ void* param1;
+
+ explicit CRequestTracker(void (*fnIn)(void*, CDataStream&)=NULL, void* param1In=NULL)
+ {
+ fn = fnIn;
+ param1 = param1In;
+ }
+
+ bool IsNull()
+ {
+ return fn == NULL;
+ }
+};
+
+
+
+
+
+extern bool fClient;
+extern bool fAllowDNS;
+extern uint64 nLocalServices;
+extern CAddress addrLocalHost;
+extern uint64 nLocalHostNonce;
+extern boost::array<int, 10> vnThreadsRunning;
+
+extern std::vector<CNode*> vNodes;
+extern CCriticalSection cs_vNodes;
+extern std::map<std::vector<unsigned char>, CAddress> mapAddresses;
+extern CCriticalSection cs_mapAddresses;
+extern std::map<CInv, CDataStream> mapRelay;
+extern std::deque<std::pair<int64, CInv> > vRelayExpiration;
+extern CCriticalSection cs_mapRelay;
+extern std::map<CInv, int64> mapAlreadyAskedFor;
+
+// Settings
+extern int fUseProxy;
+extern CAddress addrProxy;
+
+
+
+
+
+
+class CNode
+{
+public:
+ // socket
+ uint64 nServices;
+ SOCKET hSocket;
+ CDataStream vSend;
+ CDataStream vRecv;
+ CCriticalSection cs_vSend;
+ CCriticalSection cs_vRecv;
+ int64 nLastSend;
+ int64 nLastRecv;
+ int64 nLastSendEmpty;
+ int64 nTimeConnected;
+ unsigned int nHeaderStart;
+ unsigned int nMessageStart;
+ CAddress addr;
+ int nVersion;
+ std::string strSubVer;
+ bool fClient;
+ bool fInbound;
+ bool fNetworkNode;
+ bool fSuccessfullyConnected;
+ bool fDisconnect;
+protected:
+ int nRefCount;
+
+ // Denial-of-service detection/prevention
+ // Key is ip address, value is banned-until-time
+ static std::map<unsigned int, int64> setBanned;
+ static CCriticalSection cs_setBanned;
+ int nMisbehavior;
+
+public:
+ int64 nReleaseTime;
+ std::map<uint256, CRequestTracker> mapRequests;
+ CCriticalSection cs_mapRequests;
+ uint256 hashContinue;
+ CBlockIndex* pindexLastGetBlocksBegin;
+ uint256 hashLastGetBlocksEnd;
+ int nStartingHeight;
+
+ // flood relay
+ std::vector<CAddress> vAddrToSend;
+ std::set<CAddress> setAddrKnown;
+ bool fGetAddr;
+ std::set<uint256> setKnown;
+
+ // inventory based relay
+ std::set<CInv> setInventoryKnown;
+ std::vector<CInv> vInventoryToSend;
+ CCriticalSection cs_inventory;
+ std::multimap<int64, CInv> mapAskFor;
+
+ // publish and subscription
+ std::vector<char> vfSubscribe;
+
+ CNode(SOCKET hSocketIn, CAddress addrIn, bool fInboundIn=false)
+ {
+ nServices = 0;
+ hSocket = hSocketIn;
+ vSend.SetType(SER_NETWORK);
+ vSend.SetVersion(0);
+ vRecv.SetType(SER_NETWORK);
+ vRecv.SetVersion(0);
+ // Version 0.2 obsoletes 20 Feb 2012
+ if (GetTime() > 1329696000)
+ {
+ vSend.SetVersion(209);
+ vRecv.SetVersion(209);
+ }
+ nLastSend = 0;
+ nLastRecv = 0;
+ nLastSendEmpty = GetTime();
+ nTimeConnected = GetTime();
+ nHeaderStart = -1;
+ nMessageStart = -1;
+ addr = addrIn;
+ nVersion = 0;
+ strSubVer = "";
+ fClient = false; // set by version message
+ fInbound = fInboundIn;
+ fNetworkNode = false;
+ fSuccessfullyConnected = false;
+ fDisconnect = false;
+ nRefCount = 0;
+ nReleaseTime = 0;
+ hashContinue = 0;
+ pindexLastGetBlocksBegin = 0;
+ hashLastGetBlocksEnd = 0;
+ nStartingHeight = -1;
+ fGetAddr = false;
+ vfSubscribe.assign(256, false);
+ nMisbehavior = 0;
+
+ // Be shy and don't send version until we hear
+ if (!fInbound)
+ PushVersion();
+ }
+
+ ~CNode()
+ {
+ if (hSocket != INVALID_SOCKET)
+ {
+ closesocket(hSocket);
+ hSocket = INVALID_SOCKET;
+ }
+ }
+
+private:
+ CNode(const CNode&);
+ void operator=(const CNode&);
+public:
+
+
+ int GetRefCount()
+ {
+ return std::max(nRefCount, 0) + (GetTime() < nReleaseTime ? 1 : 0);
+ }
+
+ CNode* AddRef(int64 nTimeout=0)
+ {
+ if (nTimeout != 0)
+ nReleaseTime = std::max(nReleaseTime, GetTime() + nTimeout);
+ else
+ nRefCount++;
+ return this;
+ }
+
+ void Release()
+ {
+ nRefCount--;
+ }
+
+
+
+ void AddAddressKnown(const CAddress& addr)
+ {
+ setAddrKnown.insert(addr);
+ }
+
+ void PushAddress(const CAddress& addr)
+ {
+ // Known checking here is only to save space from duplicates.
+ // SendMessages will filter it again for knowns that were added
+ // after addresses were pushed.
+ if (addr.IsValid() && !setAddrKnown.count(addr))
+ vAddrToSend.push_back(addr);
+ }
+
+
+ void AddInventoryKnown(const CInv& inv)
+ {
+ CRITICAL_BLOCK(cs_inventory)
+ setInventoryKnown.insert(inv);
+ }
+
+ void PushInventory(const CInv& inv)
+ {
+ CRITICAL_BLOCK(cs_inventory)
+ if (!setInventoryKnown.count(inv))
+ vInventoryToSend.push_back(inv);
+ }
+
+ void AskFor(const CInv& inv)
+ {
+ // We're using mapAskFor as a priority queue,
+ // the key is the earliest time the request can be sent
+ int64& nRequestTime = mapAlreadyAskedFor[inv];
+ printf("askfor %s %"PRI64d"\n", inv.ToString().c_str(), nRequestTime);
+
+ // Make sure not to reuse time indexes to keep things in the same order
+ int64 nNow = (GetTime() - 1) * 1000000;
+ static int64 nLastTime;
+ ++nLastTime;
+ nNow = std::max(nNow, nLastTime);
+ nLastTime = nNow;
+
+ // Each retry is 2 minutes after the last
+ nRequestTime = std::max(nRequestTime + 2 * 60 * 1000000, nNow);
+ mapAskFor.insert(std::make_pair(nRequestTime, inv));
+ }
+
+
+
+ void BeginMessage(const char* pszCommand)
+ {
+ ENTER_CRITICAL_SECTION(cs_vSend);
+ if (nHeaderStart != -1)
+ AbortMessage();
+ nHeaderStart = vSend.size();
+ vSend << CMessageHeader(pszCommand, 0);
+ nMessageStart = vSend.size();
+ if (fDebug) {
+ printf("%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
+ printf("sending: %s ", pszCommand);
+ }
+ }
+
+ void AbortMessage()
+ {
+ if (nHeaderStart == -1)
+ return;
+ vSend.resize(nHeaderStart);
+ nHeaderStart = -1;
+ nMessageStart = -1;
+ LEAVE_CRITICAL_SECTION(cs_vSend);
+
+ if (fDebug)
+ printf("(aborted)\n");
+ }
+
+ void EndMessage()
+ {
+ if (mapArgs.count("-dropmessagestest") && GetRand(atoi(mapArgs["-dropmessagestest"])) == 0)
+ {
+ printf("dropmessages DROPPING SEND MESSAGE\n");
+ AbortMessage();
+ return;
+ }
+
+ if (nHeaderStart == -1)
+ return;
+
+ // Set the size
+ unsigned int nSize = vSend.size() - nMessageStart;
+ memcpy((char*)&vSend[nHeaderStart] + offsetof(CMessageHeader, nMessageSize), &nSize, sizeof(nSize));
+
+ // Set the checksum
+ if (vSend.GetVersion() >= 209)
+ {
+ uint256 hash = Hash(vSend.begin() + nMessageStart, vSend.end());
+ unsigned int nChecksum = 0;
+ memcpy(&nChecksum, &hash, sizeof(nChecksum));
+ assert(nMessageStart - nHeaderStart >= offsetof(CMessageHeader, nChecksum) + sizeof(nChecksum));
+ memcpy((char*)&vSend[nHeaderStart] + offsetof(CMessageHeader, nChecksum), &nChecksum, sizeof(nChecksum));
+ }
+
+ if (fDebug) {
+ printf("(%d bytes)\n", nSize);
+ }
+
+ nHeaderStart = -1;
+ nMessageStart = -1;
+ LEAVE_CRITICAL_SECTION(cs_vSend);
+ }
+
+ void EndMessageAbortIfEmpty()
+ {
+ if (nHeaderStart == -1)
+ return;
+ int nSize = vSend.size() - nMessageStart;
+ if (nSize > 0)
+ EndMessage();
+ else
+ AbortMessage();
+ }
+
+
+
+ void PushVersion()
+ {
+ /// when NTP implemented, change to just nTime = GetAdjustedTime()
+ int64 nTime = (fInbound ? GetAdjustedTime() : GetTime());
+ CAddress addrYou = (fUseProxy ? CAddress("0.0.0.0") : addr);
+ CAddress addrMe = (fUseProxy || !addrLocalHost.IsRoutable() ? CAddress("0.0.0.0") : addrLocalHost);
+ RAND_bytes((unsigned char*)&nLocalHostNonce, sizeof(nLocalHostNonce));
+ PushMessage("version", VERSION, nLocalServices, nTime, addrYou, addrMe,
+ nLocalHostNonce, std::string(pszSubVer), nBestHeight);
+ }
+
+
+
+
+ void PushMessage(const char* pszCommand)
+ {
+ try
+ {
+ BeginMessage(pszCommand);
+ EndMessage();
+ }
+ catch (...)
+ {
+ AbortMessage();
+ throw;
+ }
+ }
+
+ template<typename T1>
+ void PushMessage(const char* pszCommand, const T1& a1)
+ {
+ try
+ {
+ BeginMessage(pszCommand);
+ vSend << a1;
+ EndMessage();
+ }
+ catch (...)
+ {
+ AbortMessage();
+ throw;
+ }
+ }
+
+ template<typename T1, typename T2>
+ void PushMessage(const char* pszCommand, const T1& a1, const T2& a2)
+ {
+ try
+ {
+ BeginMessage(pszCommand);
+ vSend << a1 << a2;
+ EndMessage();
+ }
+ catch (...)
+ {
+ AbortMessage();
+ throw;
+ }
+ }
+
+ template<typename T1, typename T2, typename T3>
+ void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3)
+ {
+ try
+ {
+ BeginMessage(pszCommand);
+ vSend << a1 << a2 << a3;
+ EndMessage();
+ }
+ catch (...)
+ {
+ AbortMessage();
+ throw;
+ }
+ }
+
+ template<typename T1, typename T2, typename T3, typename T4>
+ void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4)
+ {
+ try
+ {
+ BeginMessage(pszCommand);
+ vSend << a1 << a2 << a3 << a4;
+ EndMessage();
+ }
+ catch (...)
+ {
+ AbortMessage();
+ throw;
+ }
+ }
+
+ template<typename T1, typename T2, typename T3, typename T4, typename T5>
+ void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5)
+ {
+ try
+ {
+ BeginMessage(pszCommand);
+ vSend << a1 << a2 << a3 << a4 << a5;
+ EndMessage();
+ }
+ catch (...)
+ {
+ AbortMessage();
+ throw;
+ }
+ }
+
+ template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+ void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6)
+ {
+ try
+ {
+ BeginMessage(pszCommand);
+ vSend << a1 << a2 << a3 << a4 << a5 << a6;
+ EndMessage();
+ }
+ catch (...)
+ {
+ AbortMessage();
+ throw;
+ }
+ }
+
+ template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+ void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6, const T7& a7)
+ {
+ try
+ {
+ BeginMessage(pszCommand);
+ vSend << a1 << a2 << a3 << a4 << a5 << a6 << a7;
+ EndMessage();
+ }
+ catch (...)
+ {
+ AbortMessage();
+ throw;
+ }
+ }
+
+ template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+ void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6, const T7& a7, const T8& a8)
+ {
+ try
+ {
+ BeginMessage(pszCommand);
+ vSend << a1 << a2 << a3 << a4 << a5 << a6 << a7 << a8;
+ EndMessage();
+ }
+ catch (...)
+ {
+ AbortMessage();
+ throw;
+ }
+ }
+
+ template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+ void PushMessage(const char* pszCommand, const T1& a1, const T2& a2, const T3& a3, const T4& a4, const T5& a5, const T6& a6, const T7& a7, const T8& a8, const T9& a9)
+ {
+ try
+ {
+ BeginMessage(pszCommand);
+ vSend << a1 << a2 << a3 << a4 << a5 << a6 << a7 << a8 << a9;
+ EndMessage();
+ }
+ catch (...)
+ {
+ AbortMessage();
+ throw;
+ }
+ }
+
+
+ void PushRequest(const char* pszCommand,
+ void (*fn)(void*, CDataStream&), void* param1)
+ {
+ uint256 hashReply;
+ RAND_bytes((unsigned char*)&hashReply, sizeof(hashReply));
+
+ CRITICAL_BLOCK(cs_mapRequests)
+ mapRequests[hashReply] = CRequestTracker(fn, param1);
+
+ PushMessage(pszCommand, hashReply);
+ }
+
+ template<typename T1>
+ void PushRequest(const char* pszCommand, const T1& a1,
+ void (*fn)(void*, CDataStream&), void* param1)
+ {
+ uint256 hashReply;
+ RAND_bytes((unsigned char*)&hashReply, sizeof(hashReply));
+
+ CRITICAL_BLOCK(cs_mapRequests)
+ mapRequests[hashReply] = CRequestTracker(fn, param1);
+
+ PushMessage(pszCommand, hashReply, a1);
+ }
+
+ template<typename T1, typename T2>
+ void PushRequest(const char* pszCommand, const T1& a1, const T2& a2,
+ void (*fn)(void*, CDataStream&), void* param1)
+ {
+ uint256 hashReply;
+ RAND_bytes((unsigned char*)&hashReply, sizeof(hashReply));
+
+ CRITICAL_BLOCK(cs_mapRequests)
+ mapRequests[hashReply] = CRequestTracker(fn, param1);
+
+ PushMessage(pszCommand, hashReply, a1, a2);
+ }
+
+
+
+ void PushGetBlocks(CBlockIndex* pindexBegin, uint256 hashEnd);
+ bool IsSubscribed(unsigned int nChannel);
+ void Subscribe(unsigned int nChannel, unsigned int nHops=0);
+ void CancelSubscribe(unsigned int nChannel);
+ void CloseSocketDisconnect();
+ void Cleanup();
+
+
+ // Denial-of-service detection/prevention
+ // The idea is to detect peers that are behaving
+ // badly and disconnect/ban them, but do it in a
+ // one-coding-mistake-won't-shatter-the-entire-network
+ // way.
+ // IMPORTANT: There should be nothing I can give a
+ // node that it will forward on that will make that
+ // node's peers drop it. If there is, an attacker
+ // can isolate a node and/or try to split the network.
+ // Dropping a node for sending stuff that is invalid
+ // now but might be valid in a later version is also
+ // dangerous, because it can cause a network split
+ // between nodes running old code and nodes running
+ // new code.
+ static void ClearBanned(); // needed for unit testing
+ static bool IsBanned(unsigned int ip);
+ bool Misbehaving(int howmuch); // 1 == a little, 100 == a lot
+};
+
+
+
+
+
+
+
+
+
+
+inline void RelayInventory(const CInv& inv)
+{
+ // Put on lists to offer to the other nodes
+ CRITICAL_BLOCK(cs_vNodes)
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ pnode->PushInventory(inv);
+}
+
+template<typename T>
+void RelayMessage(const CInv& inv, const T& a)
+{
+ CDataStream ss(SER_NETWORK);
+ ss.reserve(10000);
+ ss << a;
+ RelayMessage(inv, ss);
+}
+
+template<>
+inline void RelayMessage<>(const CInv& inv, const CDataStream& ss)
+{
+ CRITICAL_BLOCK(cs_mapRelay)
+ {
+ // Expire old relay messages
+ while (!vRelayExpiration.empty() && vRelayExpiration.front().first < GetTime())
+ {
+ mapRelay.erase(vRelayExpiration.front().second);
+ vRelayExpiration.pop_front();
+ }
+
+ // Save original serialized message so newer versions are preserved
+ mapRelay[inv] = ss;
+ vRelayExpiration.push_back(std::make_pair(GetTime() + 15 * 60, inv));
+ }
+
+ RelayInventory(inv);
+}
+
+
+
+
+
+
+
+
+//
+// Templates for the publish and subscription system.
+// The object being published as T& obj needs to have:
+// a set<unsigned int> setSources member
+// specializations of AdvertInsert and AdvertErase
+// Currently implemented for CTable and CProduct.
+//
+
+template<typename T>
+void AdvertStartPublish(CNode* pfrom, unsigned int nChannel, unsigned int nHops, T& obj)
+{
+ // Add to sources
+ obj.setSources.insert(pfrom->addr.ip);
+
+ if (!AdvertInsert(obj))
+ return;
+
+ // Relay
+ CRITICAL_BLOCK(cs_vNodes)
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ if (pnode != pfrom && (nHops < PUBLISH_HOPS || pnode->IsSubscribed(nChannel)))
+ pnode->PushMessage("publish", nChannel, nHops, obj);
+}
+
+template<typename T>
+void AdvertStopPublish(CNode* pfrom, unsigned int nChannel, unsigned int nHops, T& obj)
+{
+ uint256 hash = obj.GetHash();
+
+ CRITICAL_BLOCK(cs_vNodes)
+ BOOST_FOREACH(CNode* pnode, vNodes)
+ if (pnode != pfrom && (nHops < PUBLISH_HOPS || pnode->IsSubscribed(nChannel)))
+ pnode->PushMessage("pub-cancel", nChannel, nHops, hash);
+
+ AdvertErase(obj);
+}
+
+template<typename T>
+void AdvertRemoveSource(CNode* pfrom, unsigned int nChannel, unsigned int nHops, T& obj)
+{
+ // Remove a source
+ obj.setSources.erase(pfrom->addr.ip);
+
+ // If no longer supported by any sources, cancel it
+ if (obj.setSources.empty())
+ AdvertStopPublish(pfrom, nChannel, nHops, obj);
+}
+
+#endif
diff --git a/bitcoin/src/noui.h b/bitcoin/src/noui.h
@@ -0,0 +1,74 @@
+// Copyright (c) 2010 Satoshi Nakamoto
+// Copyright (c) 2011 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#ifndef BITCOIN_NOUI_H
+#define BITCOIN_NOUI_H
+
+#include <string>
+#include <boost/function.hpp>
+#include "wallet.h"
+
+typedef void wxWindow;
+#define wxYES 0x00000002
+#define wxOK 0x00000004
+#define wxNO 0x00000008
+#define wxYES_NO (wxYES|wxNO)
+#define wxCANCEL 0x00000010
+#define wxAPPLY 0x00000020
+#define wxCLOSE 0x00000040
+#define wxOK_DEFAULT 0x00000000
+#define wxYES_DEFAULT 0x00000000
+#define wxNO_DEFAULT 0x00000080
+#define wxCANCEL_DEFAULT 0x80000000
+#define wxICON_EXCLAMATION 0x00000100
+#define wxICON_HAND 0x00000200
+#define wxICON_WARNING wxICON_EXCLAMATION
+#define wxICON_ERROR wxICON_HAND
+#define wxICON_QUESTION 0x00000400
+#define wxICON_INFORMATION 0x00000800
+#define wxICON_STOP wxICON_HAND
+#define wxICON_ASTERISK wxICON_INFORMATION
+#define wxICON_MASK (0x00000100|0x00000200|0x00000400|0x00000800)
+#define wxFORWARD 0x00001000
+#define wxBACKWARD 0x00002000
+#define wxRESET 0x00004000
+#define wxHELP 0x00008000
+#define wxMORE 0x00010000
+#define wxSETUP 0x00020000
+
+inline int MyMessageBox(const std::string& message, const std::string& caption="Message", int style=wxOK, wxWindow* parent=NULL, int x=-1, int y=-1)
+{
+ printf("%s: %s\n", caption.c_str(), message.c_str());
+ fprintf(stderr, "%s: %s\n", caption.c_str(), message.c_str());
+ return 4;
+}
+#define wxMessageBox MyMessageBox
+
+inline int ThreadSafeMessageBox(const std::string& message, const std::string& caption, int style=wxOK, wxWindow* parent=NULL, int x=-1, int y=-1)
+{
+ return MyMessageBox(message, caption, style, parent, x, y);
+}
+
+inline bool ThreadSafeAskFee(int64 nFeeRequired, const std::string& strCaption, wxWindow* parent)
+{
+ return true;
+}
+
+inline void CalledSetStatusBar(const std::string& strText, int nField)
+{
+}
+
+inline void UIThreadCall(boost::function0<void> fn)
+{
+}
+
+inline void MainFrameRepaint()
+{
+}
+
+inline void InitMessage(const std::string &message)
+{
+}
+
+#endif
diff --git a/bitcoin/src/obj-test/.gitignore b/bitcoin/src/obj-test/.gitignore
@@ -0,0 +1,2 @@
+*
+!.gitignore
diff --git a/bitcoin/src/obj/.gitignore b/bitcoin/src/obj/.gitignore
@@ -0,0 +1,2 @@
+*
+!.gitignore
diff --git a/bitcoin/src/protocol.cpp b/bitcoin/src/protocol.cpp
@@ -0,0 +1,312 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2011 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+#include "protocol.h"
+#include "util.h"
+
+#ifndef WIN32
+# include <arpa/inet.h>
+#endif
+
+// Prototypes from net.h, but that header (currently) stinks, can't #include it without breaking things
+bool Lookup(const char *pszName, std::vector<CAddress>& vaddr, int nServices, int nMaxSolutions, bool fAllowLookup = false, int portDefault = 0, bool fAllowPort = false);
+bool Lookup(const char *pszName, CAddress& addr, int nServices, bool fAllowLookup = false, int portDefault = 0, bool fAllowPort = false);
+
+static const unsigned char pchIPv4[12] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff };
+static const char* ppszTypeName[] =
+{
+ "ERROR",
+ "tx",
+ "block",
+};
+
+CMessageHeader::CMessageHeader()
+{
+ memcpy(pchMessageStart, ::pchMessageStart, sizeof(pchMessageStart));
+ memset(pchCommand, 0, sizeof(pchCommand));
+ pchCommand[1] = 1;
+ nMessageSize = -1;
+ nChecksum = 0;
+}
+
+CMessageHeader::CMessageHeader(const char* pszCommand, unsigned int nMessageSizeIn)
+{
+ memcpy(pchMessageStart, ::pchMessageStart, sizeof(pchMessageStart));
+ strncpy(pchCommand, pszCommand, COMMAND_SIZE);
+ nMessageSize = nMessageSizeIn;
+ nChecksum = 0;
+}
+
+std::string CMessageHeader::GetCommand() const
+{
+ if (pchCommand[COMMAND_SIZE-1] == 0)
+ return std::string(pchCommand, pchCommand + strlen(pchCommand));
+ else
+ return std::string(pchCommand, pchCommand + COMMAND_SIZE);
+}
+
+bool CMessageHeader::IsValid() const
+{
+ // Check start string
+ if (memcmp(pchMessageStart, ::pchMessageStart, sizeof(pchMessageStart)) != 0)
+ return false;
+
+ // Check the command string for errors
+ for (const char* p1 = pchCommand; p1 < pchCommand + COMMAND_SIZE; p1++)
+ {
+ if (*p1 == 0)
+ {
+ // Must be all zeros after the first zero
+ for (; p1 < pchCommand + COMMAND_SIZE; p1++)
+ if (*p1 != 0)
+ return false;
+ }
+ else if (*p1 < ' ' || *p1 > 0x7E)
+ return false;
+ }
+
+ // Message size
+ if (nMessageSize > MAX_SIZE)
+ {
+ printf("CMessageHeader::IsValid() : (%s, %u bytes) nMessageSize > MAX_SIZE\n", GetCommand().c_str(), nMessageSize);
+ return false;
+ }
+
+ return true;
+}
+
+CAddress::CAddress()
+{
+ Init();
+}
+
+CAddress::CAddress(unsigned int ipIn, unsigned short portIn, uint64 nServicesIn)
+{
+ Init();
+ ip = ipIn;
+ port = htons(portIn == 0 ? GetDefaultPort() : portIn);
+ nServices = nServicesIn;
+}
+
+CAddress::CAddress(const struct sockaddr_in& sockaddr, uint64 nServicesIn)
+{
+ Init();
+ ip = sockaddr.sin_addr.s_addr;
+ port = sockaddr.sin_port;
+ nServices = nServicesIn;
+}
+
+CAddress::CAddress(const char* pszIn, int portIn, bool fNameLookup, uint64 nServicesIn)
+{
+ Init();
+ Lookup(pszIn, *this, nServicesIn, fNameLookup, portIn);
+}
+
+CAddress::CAddress(const char* pszIn, bool fNameLookup, uint64 nServicesIn)
+{
+ Init();
+ Lookup(pszIn, *this, nServicesIn, fNameLookup, 0, true);
+}
+
+CAddress::CAddress(std::string strIn, int portIn, bool fNameLookup, uint64 nServicesIn)
+{
+ Init();
+ Lookup(strIn.c_str(), *this, nServicesIn, fNameLookup, portIn);
+}
+
+CAddress::CAddress(std::string strIn, bool fNameLookup, uint64 nServicesIn)
+{
+ Init();
+ Lookup(strIn.c_str(), *this, nServicesIn, fNameLookup, 0, true);
+}
+
+void CAddress::Init()
+{
+ nServices = NODE_NETWORK;
+ memcpy(pchReserved, pchIPv4, sizeof(pchReserved));
+ ip = INADDR_NONE;
+ port = htons(GetDefaultPort());
+ nTime = 100000000;
+ nLastTry = 0;
+}
+
+bool operator==(const CAddress& a, const CAddress& b)
+{
+ return (memcmp(a.pchReserved, b.pchReserved, sizeof(a.pchReserved)) == 0 &&
+ a.ip == b.ip &&
+ a.port == b.port);
+}
+
+bool operator!=(const CAddress& a, const CAddress& b)
+{
+ return (!(a == b));
+}
+
+bool operator<(const CAddress& a, const CAddress& b)
+{
+ int ret = memcmp(a.pchReserved, b.pchReserved, sizeof(a.pchReserved));
+ if (ret < 0)
+ return true;
+ else if (ret == 0)
+ {
+ if (ntohl(a.ip) < ntohl(b.ip))
+ return true;
+ else if (a.ip == b.ip)
+ return ntohs(a.port) < ntohs(b.port);
+ }
+ return false;
+}
+
+std::vector<unsigned char> CAddress::GetKey() const
+{
+ CDataStream ss;
+ ss.reserve(18);
+ ss << FLATDATA(pchReserved) << ip << port;
+
+ #if defined(_MSC_VER) && _MSC_VER < 1300
+ return std::vector<unsigned char>((unsigned char*)&ss.begin()[0], (unsigned char*)&ss.end()[0]);
+ #else
+ return std::vector<unsigned char>(ss.begin(), ss.end());
+ #endif
+}
+
+struct sockaddr_in CAddress::GetSockAddr() const
+{
+ struct sockaddr_in sockaddr;
+ memset(&sockaddr, 0, sizeof(sockaddr));
+ sockaddr.sin_family = AF_INET;
+ sockaddr.sin_addr.s_addr = ip;
+ sockaddr.sin_port = port;
+ return sockaddr;
+}
+
+bool CAddress::IsIPv4() const
+{
+ return (memcmp(pchReserved, pchIPv4, sizeof(pchIPv4)) == 0);
+}
+
+bool CAddress::IsRFC1918() const
+{
+ return IsIPv4() && (GetByte(3) == 10 ||
+ (GetByte(3) == 192 && GetByte(2) == 168) ||
+ (GetByte(3) == 172 &&
+ (GetByte(2) >= 16 && GetByte(2) <= 31)));
+}
+
+bool CAddress::IsRFC3927() const
+{
+ return IsIPv4() && (GetByte(3) == 169 && GetByte(2) == 254);
+}
+
+bool CAddress::IsLocal() const
+{
+ return IsIPv4() && (GetByte(3) == 127 ||
+ GetByte(3) == 0);
+}
+
+bool CAddress::IsRoutable() const
+{
+ return IsValid() &&
+ !(IsRFC1918() || IsRFC3927() || IsLocal());
+}
+
+bool CAddress::IsValid() const
+{
+ // Clean up 3-byte shifted addresses caused by garbage in size field
+ // of addr messages from versions before 0.2.9 checksum.
+ // Two consecutive addr messages look like this:
+ // header20 vectorlen3 addr26 addr26 addr26 header20 vectorlen3 addr26 addr26 addr26...
+ // so if the first length field is garbled, it reads the second batch
+ // of addr misaligned by 3 bytes.
+ if (memcmp(pchReserved, pchIPv4+3, sizeof(pchIPv4)-3) == 0)
+ return false;
+
+ return (ip != 0 && ip != INADDR_NONE && port != htons(USHRT_MAX));
+}
+
+unsigned char CAddress::GetByte(int n) const
+{
+ return ((unsigned char*)&ip)[3-n];
+}
+
+std::string CAddress::ToStringIPPort() const
+{
+ return strprintf("%u.%u.%u.%u:%u", GetByte(3), GetByte(2), GetByte(1), GetByte(0), ntohs(port));
+}
+
+std::string CAddress::ToStringIP() const
+{
+ return strprintf("%u.%u.%u.%u", GetByte(3), GetByte(2), GetByte(1), GetByte(0));
+}
+
+std::string CAddress::ToStringPort() const
+{
+ return strprintf("%u", ntohs(port));
+}
+
+std::string CAddress::ToString() const
+{
+ return strprintf("%u.%u.%u.%u:%u", GetByte(3), GetByte(2), GetByte(1), GetByte(0), ntohs(port));
+}
+
+void CAddress::print() const
+{
+ printf("CAddress(%s)\n", ToString().c_str());
+}
+
+CInv::CInv()
+{
+ type = 0;
+ hash = 0;
+}
+
+CInv::CInv(int typeIn, const uint256& hashIn)
+{
+ type = typeIn;
+ hash = hashIn;
+}
+
+CInv::CInv(const std::string& strType, const uint256& hashIn)
+{
+ int i;
+ for (i = 1; i < ARRAYLEN(ppszTypeName); i++)
+ {
+ if (strType == ppszTypeName[i])
+ {
+ type = i;
+ break;
+ }
+ }
+ if (i == ARRAYLEN(ppszTypeName))
+ throw std::out_of_range(strprintf("CInv::CInv(string, uint256) : unknown type '%s'", strType.c_str()));
+ hash = hashIn;
+}
+
+bool operator<(const CInv& a, const CInv& b)
+{
+ return (a.type < b.type || (a.type == b.type && a.hash < b.hash));
+}
+
+bool CInv::IsKnownType() const
+{
+ return (type >= 1 && type < ARRAYLEN(ppszTypeName));
+}
+
+const char* CInv::GetCommand() const
+{
+ if (!IsKnownType())
+ throw std::out_of_range(strprintf("CInv::GetCommand() : type=%d unknown type", type));
+ return ppszTypeName[type];
+}
+
+std::string CInv::ToString() const
+{
+ return strprintf("%s %s", GetCommand(), hash.ToString().substr(0,20).c_str());
+}
+
+void CInv::print() const
+{
+ printf("CInv(%s)\n", ToString().c_str());
+}
diff --git a/bitcoin/src/protocol.h b/bitcoin/src/protocol.h
@@ -0,0 +1,150 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2011 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef __cplusplus
+# error This header can only be compiled as C++.
+#endif
+
+#ifndef __INCLUDED_PROTOCOL_H__
+#define __INCLUDED_PROTOCOL_H__
+
+#include "serialize.h"
+#include <string>
+#include "uint256.h"
+
+extern bool fTestNet;
+static inline unsigned short GetDefaultPort(const bool testnet = fTestNet)
+{
+ return testnet ? 18333 : 8333;
+}
+
+//
+// Message header
+// (4) message start
+// (12) command
+// (4) size
+// (4) checksum
+
+extern unsigned char pchMessageStart[4];
+
+class CMessageHeader
+{
+ public:
+ CMessageHeader();
+ CMessageHeader(const char* pszCommand, unsigned int nMessageSizeIn);
+
+ std::string GetCommand() const;
+ bool IsValid() const;
+
+ IMPLEMENT_SERIALIZE
+ (
+ READWRITE(FLATDATA(pchMessageStart));
+ READWRITE(FLATDATA(pchCommand));
+ READWRITE(nMessageSize);
+ if (nVersion >= 209)
+ READWRITE(nChecksum);
+ )
+
+ // TODO: make private (improves encapsulation)
+ public:
+ enum { COMMAND_SIZE=12 };
+ char pchMessageStart[sizeof(::pchMessageStart)];
+ char pchCommand[COMMAND_SIZE];
+ unsigned int nMessageSize;
+ unsigned int nChecksum;
+};
+
+enum
+{
+ NODE_NETWORK = (1 << 0),
+};
+
+class CAddress
+{
+ public:
+ CAddress();
+ CAddress(unsigned int ipIn, unsigned short portIn=0, uint64 nServicesIn=NODE_NETWORK);
+ explicit CAddress(const struct sockaddr_in& sockaddr, uint64 nServicesIn=NODE_NETWORK);
+ explicit CAddress(const char* pszIn, int portIn, bool fNameLookup = false, uint64 nServicesIn=NODE_NETWORK);
+ explicit CAddress(const char* pszIn, bool fNameLookup = false, uint64 nServicesIn=NODE_NETWORK);
+ explicit CAddress(std::string strIn, int portIn, bool fNameLookup = false, uint64 nServicesIn=NODE_NETWORK);
+ explicit CAddress(std::string strIn, bool fNameLookup = false, uint64 nServicesIn=NODE_NETWORK);
+
+ void Init();
+
+ IMPLEMENT_SERIALIZE
+ (
+ if (fRead)
+ const_cast<CAddress*>(this)->Init();
+ if (nType & SER_DISK)
+ READWRITE(nVersion);
+ if ((nType & SER_DISK) || (nVersion >= 31402 && !(nType & SER_GETHASH)))
+ READWRITE(nTime);
+ READWRITE(nServices);
+ READWRITE(FLATDATA(pchReserved)); // for IPv6
+ READWRITE(ip);
+ READWRITE(port);
+ )
+
+ friend bool operator==(const CAddress& a, const CAddress& b);
+ friend bool operator!=(const CAddress& a, const CAddress& b);
+ friend bool operator<(const CAddress& a, const CAddress& b);
+
+ std::vector<unsigned char> GetKey() const;
+ struct sockaddr_in GetSockAddr() const;
+ bool IsIPv4() const;
+ bool IsRFC1918() const;
+ bool IsRFC3927() const;
+ bool IsLocal() const;
+ bool IsRoutable() const;
+ bool IsValid() const;
+ unsigned char GetByte(int n) const;
+ std::string ToStringIPPort() const;
+ std::string ToStringIP() const;
+ std::string ToStringPort() const;
+ std::string ToString() const;
+ void print() const;
+
+ // TODO: make private (improves encapsulation)
+ public:
+ uint64 nServices;
+ unsigned char pchReserved[12];
+ unsigned int ip;
+ unsigned short port;
+
+ // disk and network only
+ unsigned int nTime;
+
+ // memory only
+ unsigned int nLastTry;
+};
+
+class CInv
+{
+ public:
+ CInv();
+ CInv(int typeIn, const uint256& hashIn);
+ CInv(const std::string& strType, const uint256& hashIn);
+
+ IMPLEMENT_SERIALIZE
+ (
+ READWRITE(type);
+ READWRITE(hash);
+ )
+
+ friend bool operator<(const CInv& a, const CInv& b);
+
+ bool IsKnownType() const;
+ const char* GetCommand() const;
+ std::string ToString() const;
+ void print() const;
+
+ // TODO: make private (improves encapsulation)
+ public:
+ int type;
+ uint256 hash;
+};
+
+#endif // __INCLUDED_PROTOCOL_H__
diff --git a/bitcoin/src/qtui.h b/bitcoin/src/qtui.h
@@ -0,0 +1,49 @@
+// Copyright (c) 2010 Satoshi Nakamoto
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#ifndef BITCOIN_EXTERNUI_H
+#define BITCOIN_EXTERNUI_H
+
+#include <string>
+#include <boost/function/function0.hpp>
+#include "wallet.h"
+
+typedef void wxWindow;
+#define wxYES 0x00000002
+#define wxOK 0x00000004
+#define wxNO 0x00000008
+#define wxYES_NO (wxYES|wxNO)
+#define wxCANCEL 0x00000010
+#define wxAPPLY 0x00000020
+#define wxCLOSE 0x00000040
+#define wxOK_DEFAULT 0x00000000
+#define wxYES_DEFAULT 0x00000000
+#define wxNO_DEFAULT 0x00000080
+#define wxCANCEL_DEFAULT 0x80000000
+#define wxICON_EXCLAMATION 0x00000100
+#define wxICON_HAND 0x00000200
+#define wxICON_WARNING wxICON_EXCLAMATION
+#define wxICON_ERROR wxICON_HAND
+#define wxICON_QUESTION 0x00000400
+#define wxICON_INFORMATION 0x00000800
+#define wxICON_STOP wxICON_HAND
+#define wxICON_ASTERISK wxICON_INFORMATION
+#define wxICON_MASK (0x00000100|0x00000200|0x00000400|0x00000800)
+#define wxFORWARD 0x00001000
+#define wxBACKWARD 0x00002000
+#define wxRESET 0x00004000
+#define wxHELP 0x00008000
+#define wxMORE 0x00010000
+#define wxSETUP 0x00020000
+
+extern int MyMessageBox(const std::string& message, const std::string& caption="Message", int style=wxOK, wxWindow* parent=NULL, int x=-1, int y=-1);
+#define wxMessageBox MyMessageBox
+extern int ThreadSafeMessageBox(const std::string& message, const std::string& caption, int style=wxOK, wxWindow* parent=NULL, int x=-1, int y=-1);
+extern bool ThreadSafeAskFee(int64 nFeeRequired, const std::string& strCaption, wxWindow* parent);
+extern void CalledSetStatusBar(const std::string& strText, int nField);
+extern void UIThreadCall(boost::function0<void> fn);
+extern void MainFrameRepaint();
+extern void InitMessage(const std::string &message);
+extern std::string _(const char* psz);
+
+#endif
diff --git a/bitcoin/src/script.cpp b/bitcoin/src/script.cpp
@@ -0,0 +1,1203 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2011 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#include "headers.h"
+
+using namespace std;
+using namespace boost;
+
+bool CheckSig(vector<unsigned char> vchSig, vector<unsigned char> vchPubKey, CScript scriptCode, const CTransaction& txTo, unsigned int nIn, int nHashType);
+
+
+
+typedef vector<unsigned char> valtype;
+static const valtype vchFalse(0);
+static const valtype vchZero(0);
+static const valtype vchTrue(1, 1);
+static const CBigNum bnZero(0);
+static const CBigNum bnOne(1);
+static const CBigNum bnFalse(0);
+static const CBigNum bnTrue(1);
+static const size_t nMaxNumSize = 4;
+
+
+CBigNum CastToBigNum(const valtype& vch)
+{
+ if (vch.size() > nMaxNumSize)
+ throw runtime_error("CastToBigNum() : overflow");
+ // Get rid of extra leading zeros
+ return CBigNum(CBigNum(vch).getvch());
+}
+
+bool CastToBool(const valtype& vch)
+{
+ for (int i = 0; i < vch.size(); i++)
+ {
+ if (vch[i] != 0)
+ {
+ // Can be negative zero
+ if (i == vch.size()-1 && vch[i] == 0x80)
+ return false;
+ return true;
+ }
+ }
+ return false;
+}
+
+void MakeSameSize(valtype& vch1, valtype& vch2)
+{
+ // Lengthen the shorter one
+ if (vch1.size() < vch2.size())
+ vch1.resize(vch2.size(), 0);
+ if (vch2.size() < vch1.size())
+ vch2.resize(vch1.size(), 0);
+}
+
+
+
+//
+// Script is a stack machine (like Forth) that evaluates a predicate
+// returning a bool indicating valid or not. There are no loops.
+//
+#define stacktop(i) (stack.at(stack.size()+(i)))
+#define altstacktop(i) (altstack.at(altstack.size()+(i)))
+static inline void popstack(vector<valtype>& stack)
+{
+ if (stack.empty())
+ throw runtime_error("popstack() : stack empty");
+ stack.pop_back();
+}
+
+
+bool EvalScript(vector<vector<unsigned char> >& stack, const CScript& script, const CTransaction& txTo, unsigned int nIn, int nHashType)
+{
+ CAutoBN_CTX pctx;
+ CScript::const_iterator pc = script.begin();
+ CScript::const_iterator pend = script.end();
+ CScript::const_iterator pbegincodehash = script.begin();
+ opcodetype opcode;
+ valtype vchPushValue;
+ vector<bool> vfExec;
+ vector<valtype> altstack;
+ if (script.size() > 10000)
+ return false;
+ int nOpCount = 0;
+
+
+ try
+ {
+ while (pc < pend)
+ {
+ bool fExec = !count(vfExec.begin(), vfExec.end(), false);
+
+ //
+ // Read instruction
+ //
+ if (!script.GetOp(pc, opcode, vchPushValue))
+ return false;
+ if (vchPushValue.size() > 520)
+ return false;
+ if (opcode > OP_16 && ++nOpCount > 201)
+ return false;
+
+ if (opcode == OP_CAT ||
+ opcode == OP_SUBSTR ||
+ opcode == OP_LEFT ||
+ opcode == OP_RIGHT ||
+ opcode == OP_INVERT ||
+ opcode == OP_AND ||
+ opcode == OP_OR ||
+ opcode == OP_XOR ||
+ opcode == OP_2MUL ||
+ opcode == OP_2DIV ||
+ opcode == OP_MUL ||
+ opcode == OP_DIV ||
+ opcode == OP_MOD ||
+ opcode == OP_LSHIFT ||
+ opcode == OP_RSHIFT)
+ return false;
+
+ if (fExec && 0 <= opcode && opcode <= OP_PUSHDATA4)
+ stack.push_back(vchPushValue);
+ else if (fExec || (OP_IF <= opcode && opcode <= OP_ENDIF))
+ switch (opcode)
+ {
+ //
+ // Push value
+ //
+ case OP_1NEGATE:
+ case OP_1:
+ case OP_2:
+ case OP_3:
+ case OP_4:
+ case OP_5:
+ case OP_6:
+ case OP_7:
+ case OP_8:
+ case OP_9:
+ case OP_10:
+ case OP_11:
+ case OP_12:
+ case OP_13:
+ case OP_14:
+ case OP_15:
+ case OP_16:
+ {
+ // ( -- value)
+ CBigNum bn((int)opcode - (int)(OP_1 - 1));
+ stack.push_back(bn.getvch());
+ }
+ break;
+
+
+ //
+ // Control
+ //
+ case OP_NOP:
+ case OP_NOP1: case OP_NOP2: case OP_NOP3: case OP_NOP4: case OP_NOP5:
+ case OP_NOP6: case OP_NOP7: case OP_NOP8: case OP_NOP9: case OP_NOP10:
+ break;
+
+ case OP_IF:
+ case OP_NOTIF:
+ {
+ // <expression> if [statements] [else [statements]] endif
+ bool fValue = false;
+ if (fExec)
+ {
+ if (stack.size() < 1)
+ return false;
+ valtype& vch = stacktop(-1);
+ fValue = CastToBool(vch);
+ if (opcode == OP_NOTIF)
+ fValue = !fValue;
+ popstack(stack);
+ }
+ vfExec.push_back(fValue);
+ }
+ break;
+
+ case OP_ELSE:
+ {
+ if (vfExec.empty())
+ return false;
+ vfExec.back() = !vfExec.back();
+ }
+ break;
+
+ case OP_ENDIF:
+ {
+ if (vfExec.empty())
+ return false;
+ vfExec.pop_back();
+ }
+ break;
+
+ case OP_VERIFY:
+ {
+ // (true -- ) or
+ // (false -- false) and return
+ if (stack.size() < 1)
+ return false;
+ bool fValue = CastToBool(stacktop(-1));
+ if (fValue)
+ popstack(stack);
+ else
+ return false;
+ }
+ break;
+
+ case OP_RETURN:
+ {
+ return false;
+ }
+ break;
+
+
+ //
+ // Stack ops
+ //
+ case OP_TOALTSTACK:
+ {
+ if (stack.size() < 1)
+ return false;
+ altstack.push_back(stacktop(-1));
+ popstack(stack);
+ }
+ break;
+
+ case OP_FROMALTSTACK:
+ {
+ if (altstack.size() < 1)
+ return false;
+ stack.push_back(altstacktop(-1));
+ popstack(altstack);
+ }
+ break;
+
+ case OP_2DROP:
+ {
+ // (x1 x2 -- )
+ if (stack.size() < 2)
+ return false;
+ popstack(stack);
+ popstack(stack);
+ }
+ break;
+
+ case OP_2DUP:
+ {
+ // (x1 x2 -- x1 x2 x1 x2)
+ if (stack.size() < 2)
+ return false;
+ valtype vch1 = stacktop(-2);
+ valtype vch2 = stacktop(-1);
+ stack.push_back(vch1);
+ stack.push_back(vch2);
+ }
+ break;
+
+ case OP_3DUP:
+ {
+ // (x1 x2 x3 -- x1 x2 x3 x1 x2 x3)
+ if (stack.size() < 3)
+ return false;
+ valtype vch1 = stacktop(-3);
+ valtype vch2 = stacktop(-2);
+ valtype vch3 = stacktop(-1);
+ stack.push_back(vch1);
+ stack.push_back(vch2);
+ stack.push_back(vch3);
+ }
+ break;
+
+ case OP_2OVER:
+ {
+ // (x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2)
+ if (stack.size() < 4)
+ return false;
+ valtype vch1 = stacktop(-4);
+ valtype vch2 = stacktop(-3);
+ stack.push_back(vch1);
+ stack.push_back(vch2);
+ }
+ break;
+
+ case OP_2ROT:
+ {
+ // (x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2)
+ if (stack.size() < 6)
+ return false;
+ valtype vch1 = stacktop(-6);
+ valtype vch2 = stacktop(-5);
+ stack.erase(stack.end()-6, stack.end()-4);
+ stack.push_back(vch1);
+ stack.push_back(vch2);
+ }
+ break;
+
+ case OP_2SWAP:
+ {
+ // (x1 x2 x3 x4 -- x3 x4 x1 x2)
+ if (stack.size() < 4)
+ return false;
+ swap(stacktop(-4), stacktop(-2));
+ swap(stacktop(-3), stacktop(-1));
+ }
+ break;
+
+ case OP_IFDUP:
+ {
+ // (x - 0 | x x)
+ if (stack.size() < 1)
+ return false;
+ valtype vch = stacktop(-1);
+ if (CastToBool(vch))
+ stack.push_back(vch);
+ }
+ break;
+
+ case OP_DEPTH:
+ {
+ // -- stacksize
+ CBigNum bn(stack.size());
+ stack.push_back(bn.getvch());
+ }
+ break;
+
+ case OP_DROP:
+ {
+ // (x -- )
+ if (stack.size() < 1)
+ return false;
+ popstack(stack);
+ }
+ break;
+
+ case OP_DUP:
+ {
+ // (x -- x x)
+ if (stack.size() < 1)
+ return false;
+ valtype vch = stacktop(-1);
+ stack.push_back(vch);
+ }
+ break;
+
+ case OP_NIP:
+ {
+ // (x1 x2 -- x2)
+ if (stack.size() < 2)
+ return false;
+ stack.erase(stack.end() - 2);
+ }
+ break;
+
+ case OP_OVER:
+ {
+ // (x1 x2 -- x1 x2 x1)
+ if (stack.size() < 2)
+ return false;
+ valtype vch = stacktop(-2);
+ stack.push_back(vch);
+ }
+ break;
+
+ case OP_PICK:
+ case OP_ROLL:
+ {
+ // (xn ... x2 x1 x0 n - xn ... x2 x1 x0 xn)
+ // (xn ... x2 x1 x0 n - ... x2 x1 x0 xn)
+ if (stack.size() < 2)
+ return false;
+ int n = CastToBigNum(stacktop(-1)).getint();
+ popstack(stack);
+ if (n < 0 || n >= stack.size())
+ return false;
+ valtype vch = stacktop(-n-1);
+ if (opcode == OP_ROLL)
+ stack.erase(stack.end()-n-1);
+ stack.push_back(vch);
+ }
+ break;
+
+ case OP_ROT:
+ {
+ // (x1 x2 x3 -- x2 x3 x1)
+ // x2 x1 x3 after first swap
+ // x2 x3 x1 after second swap
+ if (stack.size() < 3)
+ return false;
+ swap(stacktop(-3), stacktop(-2));
+ swap(stacktop(-2), stacktop(-1));
+ }
+ break;
+
+ case OP_SWAP:
+ {
+ // (x1 x2 -- x2 x1)
+ if (stack.size() < 2)
+ return false;
+ swap(stacktop(-2), stacktop(-1));
+ }
+ break;
+
+ case OP_TUCK:
+ {
+ // (x1 x2 -- x2 x1 x2)
+ if (stack.size() < 2)
+ return false;
+ valtype vch = stacktop(-1);
+ stack.insert(stack.end()-2, vch);
+ }
+ break;
+
+
+ //
+ // Splice ops
+ //
+ case OP_CAT:
+ {
+ // (x1 x2 -- out)
+ if (stack.size() < 2)
+ return false;
+ valtype& vch1 = stacktop(-2);
+ valtype& vch2 = stacktop(-1);
+ vch1.insert(vch1.end(), vch2.begin(), vch2.end());
+ popstack(stack);
+ if (stacktop(-1).size() > 520)
+ return false;
+ }
+ break;
+
+ case OP_SUBSTR:
+ {
+ // (in begin size -- out)
+ if (stack.size() < 3)
+ return false;
+ valtype& vch = stacktop(-3);
+ int nBegin = CastToBigNum(stacktop(-2)).getint();
+ int nEnd = nBegin + CastToBigNum(stacktop(-1)).getint();
+ if (nBegin < 0 || nEnd < nBegin)
+ return false;
+ if (nBegin > vch.size())
+ nBegin = vch.size();
+ if (nEnd > vch.size())
+ nEnd = vch.size();
+ vch.erase(vch.begin() + nEnd, vch.end());
+ vch.erase(vch.begin(), vch.begin() + nBegin);
+ popstack(stack);
+ popstack(stack);
+ }
+ break;
+
+ case OP_LEFT:
+ case OP_RIGHT:
+ {
+ // (in size -- out)
+ if (stack.size() < 2)
+ return false;
+ valtype& vch = stacktop(-2);
+ int nSize = CastToBigNum(stacktop(-1)).getint();
+ if (nSize < 0)
+ return false;
+ if (nSize > vch.size())
+ nSize = vch.size();
+ if (opcode == OP_LEFT)
+ vch.erase(vch.begin() + nSize, vch.end());
+ else
+ vch.erase(vch.begin(), vch.end() - nSize);
+ popstack(stack);
+ }
+ break;
+
+ case OP_SIZE:
+ {
+ // (in -- in size)
+ if (stack.size() < 1)
+ return false;
+ CBigNum bn(stacktop(-1).size());
+ stack.push_back(bn.getvch());
+ }
+ break;
+
+
+ //
+ // Bitwise logic
+ //
+ case OP_INVERT:
+ {
+ // (in - out)
+ if (stack.size() < 1)
+ return false;
+ valtype& vch = stacktop(-1);
+ for (int i = 0; i < vch.size(); i++)
+ vch[i] = ~vch[i];
+ }
+ break;
+
+ case OP_AND:
+ case OP_OR:
+ case OP_XOR:
+ {
+ // (x1 x2 - out)
+ if (stack.size() < 2)
+ return false;
+ valtype& vch1 = stacktop(-2);
+ valtype& vch2 = stacktop(-1);
+ MakeSameSize(vch1, vch2);
+ if (opcode == OP_AND)
+ {
+ for (int i = 0; i < vch1.size(); i++)
+ vch1[i] &= vch2[i];
+ }
+ else if (opcode == OP_OR)
+ {
+ for (int i = 0; i < vch1.size(); i++)
+ vch1[i] |= vch2[i];
+ }
+ else if (opcode == OP_XOR)
+ {
+ for (int i = 0; i < vch1.size(); i++)
+ vch1[i] ^= vch2[i];
+ }
+ popstack(stack);
+ }
+ break;
+
+ case OP_EQUAL:
+ case OP_EQUALVERIFY:
+ //case OP_NOTEQUAL: // use OP_NUMNOTEQUAL
+ {
+ // (x1 x2 - bool)
+ if (stack.size() < 2)
+ return false;
+ valtype& vch1 = stacktop(-2);
+ valtype& vch2 = stacktop(-1);
+ bool fEqual = (vch1 == vch2);
+ // OP_NOTEQUAL is disabled because it would be too easy to say
+ // something like n != 1 and have some wiseguy pass in 1 with extra
+ // zero bytes after it (numerically, 0x01 == 0x0001 == 0x000001)
+ //if (opcode == OP_NOTEQUAL)
+ // fEqual = !fEqual;
+ popstack(stack);
+ popstack(stack);
+ stack.push_back(fEqual ? vchTrue : vchFalse);
+ if (opcode == OP_EQUALVERIFY)
+ {
+ if (fEqual)
+ popstack(stack);
+ else
+ return false;
+ }
+ }
+ break;
+
+
+ //
+ // Numeric
+ //
+ case OP_1ADD:
+ case OP_1SUB:
+ case OP_2MUL:
+ case OP_2DIV:
+ case OP_NEGATE:
+ case OP_ABS:
+ case OP_NOT:
+ case OP_0NOTEQUAL:
+ {
+ // (in -- out)
+ if (stack.size() < 1)
+ return false;
+ CBigNum bn = CastToBigNum(stacktop(-1));
+ switch (opcode)
+ {
+ case OP_1ADD: bn += bnOne; break;
+ case OP_1SUB: bn -= bnOne; break;
+ case OP_2MUL: bn <<= 1; break;
+ case OP_2DIV: bn >>= 1; break;
+ case OP_NEGATE: bn = -bn; break;
+ case OP_ABS: if (bn < bnZero) bn = -bn; break;
+ case OP_NOT: bn = (bn == bnZero); break;
+ case OP_0NOTEQUAL: bn = (bn != bnZero); break;
+ default: assert(!"invalid opcode"); break;
+ }
+ popstack(stack);
+ stack.push_back(bn.getvch());
+ }
+ break;
+
+ case OP_ADD:
+ case OP_SUB:
+ case OP_MUL:
+ case OP_DIV:
+ case OP_MOD:
+ case OP_LSHIFT:
+ case OP_RSHIFT:
+ case OP_BOOLAND:
+ case OP_BOOLOR:
+ case OP_NUMEQUAL:
+ case OP_NUMEQUALVERIFY:
+ case OP_NUMNOTEQUAL:
+ case OP_LESSTHAN:
+ case OP_GREATERTHAN:
+ case OP_LESSTHANOREQUAL:
+ case OP_GREATERTHANOREQUAL:
+ case OP_MIN:
+ case OP_MAX:
+ {
+ // (x1 x2 -- out)
+ if (stack.size() < 2)
+ return false;
+ CBigNum bn1 = CastToBigNum(stacktop(-2));
+ CBigNum bn2 = CastToBigNum(stacktop(-1));
+ CBigNum bn;
+ switch (opcode)
+ {
+ case OP_ADD:
+ bn = bn1 + bn2;
+ break;
+
+ case OP_SUB:
+ bn = bn1 - bn2;
+ break;
+
+ case OP_MUL:
+ if (!BN_mul(&bn, &bn1, &bn2, pctx))
+ return false;
+ break;
+
+ case OP_DIV:
+ if (!BN_div(&bn, NULL, &bn1, &bn2, pctx))
+ return false;
+ break;
+
+ case OP_MOD:
+ if (!BN_mod(&bn, &bn1, &bn2, pctx))
+ return false;
+ break;
+
+ case OP_LSHIFT:
+ if (bn2 < bnZero || bn2 > CBigNum(2048))
+ return false;
+ bn = bn1 << bn2.getulong();
+ break;
+
+ case OP_RSHIFT:
+ if (bn2 < bnZero || bn2 > CBigNum(2048))
+ return false;
+ bn = bn1 >> bn2.getulong();
+ break;
+
+ case OP_BOOLAND: bn = (bn1 != bnZero && bn2 != bnZero); break;
+ case OP_BOOLOR: bn = (bn1 != bnZero || bn2 != bnZero); break;
+ case OP_NUMEQUAL: bn = (bn1 == bn2); break;
+ case OP_NUMEQUALVERIFY: bn = (bn1 == bn2); break;
+ case OP_NUMNOTEQUAL: bn = (bn1 != bn2); break;
+ case OP_LESSTHAN: bn = (bn1 < bn2); break;
+ case OP_GREATERTHAN: bn = (bn1 > bn2); break;
+ case OP_LESSTHANOREQUAL: bn = (bn1 <= bn2); break;
+ case OP_GREATERTHANOREQUAL: bn = (bn1 >= bn2); break;
+ case OP_MIN: bn = (bn1 < bn2 ? bn1 : bn2); break;
+ case OP_MAX: bn = (bn1 > bn2 ? bn1 : bn2); break;
+ default: assert(!"invalid opcode"); break;
+ }
+ popstack(stack);
+ popstack(stack);
+ stack.push_back(bn.getvch());
+
+ if (opcode == OP_NUMEQUALVERIFY)
+ {
+ if (CastToBool(stacktop(-1)))
+ popstack(stack);
+ else
+ return false;
+ }
+ }
+ break;
+
+ case OP_WITHIN:
+ {
+ // (x min max -- out)
+ if (stack.size() < 3)
+ return false;
+ CBigNum bn1 = CastToBigNum(stacktop(-3));
+ CBigNum bn2 = CastToBigNum(stacktop(-2));
+ CBigNum bn3 = CastToBigNum(stacktop(-1));
+ bool fValue = (bn2 <= bn1 && bn1 < bn3);
+ popstack(stack);
+ popstack(stack);
+ popstack(stack);
+ stack.push_back(fValue ? vchTrue : vchFalse);
+ }
+ break;
+
+
+ //
+ // Crypto
+ //
+ case OP_RIPEMD160:
+ case OP_SHA1:
+ case OP_SHA256:
+ case OP_HASH160:
+ case OP_HASH256:
+ {
+ // (in -- hash)
+ if (stack.size() < 1)
+ return false;
+ valtype& vch = stacktop(-1);
+ valtype vchHash((opcode == OP_RIPEMD160 || opcode == OP_SHA1 || opcode == OP_HASH160) ? 20 : 32);
+ if (opcode == OP_RIPEMD160)
+ RIPEMD160(&vch[0], vch.size(), &vchHash[0]);
+ else if (opcode == OP_SHA1)
+ SHA1(&vch[0], vch.size(), &vchHash[0]);
+ else if (opcode == OP_SHA256)
+ SHA256(&vch[0], vch.size(), &vchHash[0]);
+ else if (opcode == OP_HASH160)
+ {
+ uint160 hash160 = Hash160(vch);
+ memcpy(&vchHash[0], &hash160, sizeof(hash160));
+ }
+ else if (opcode == OP_HASH256)
+ {
+ uint256 hash = Hash(vch.begin(), vch.end());
+ memcpy(&vchHash[0], &hash, sizeof(hash));
+ }
+ popstack(stack);
+ stack.push_back(vchHash);
+ }
+ break;
+
+ case OP_CODESEPARATOR:
+ {
+ // Hash starts after the code separator
+ pbegincodehash = pc;
+ }
+ break;
+
+ case OP_CHECKSIG:
+ case OP_CHECKSIGVERIFY:
+ {
+ // (sig pubkey -- bool)
+ if (stack.size() < 2)
+ return false;
+
+ valtype& vchSig = stacktop(-2);
+ valtype& vchPubKey = stacktop(-1);
+
+ ////// debug print
+ //PrintHex(vchSig.begin(), vchSig.end(), "sig: %s\n");
+ //PrintHex(vchPubKey.begin(), vchPubKey.end(), "pubkey: %s\n");
+
+ // Subset of script starting at the most recent codeseparator
+ CScript scriptCode(pbegincodehash, pend);
+
+ // Drop the signature, since there's no way for a signature to sign itself
+ scriptCode.FindAndDelete(CScript(vchSig));
+
+ bool fSuccess = CheckSig(vchSig, vchPubKey, scriptCode, txTo, nIn, nHashType);
+
+ popstack(stack);
+ popstack(stack);
+ stack.push_back(fSuccess ? vchTrue : vchFalse);
+ if (opcode == OP_CHECKSIGVERIFY)
+ {
+ if (fSuccess)
+ popstack(stack);
+ else
+ return false;
+ }
+ }
+ break;
+
+ case OP_CHECKMULTISIG:
+ case OP_CHECKMULTISIGVERIFY:
+ {
+ // ([sig ...] num_of_signatures [pubkey ...] num_of_pubkeys -- bool)
+
+ int i = 1;
+ if (stack.size() < i)
+ return false;
+
+ int nKeysCount = CastToBigNum(stacktop(-i)).getint();
+ if (nKeysCount < 0 || nKeysCount > 20)
+ return false;
+ nOpCount += nKeysCount;
+ if (nOpCount > 201)
+ return false;
+ int ikey = ++i;
+ i += nKeysCount;
+ if (stack.size() < i)
+ return false;
+
+ int nSigsCount = CastToBigNum(stacktop(-i)).getint();
+ if (nSigsCount < 0 || nSigsCount > nKeysCount)
+ return false;
+ int isig = ++i;
+ i += nSigsCount;
+ if (stack.size() < i)
+ return false;
+
+ // Subset of script starting at the most recent codeseparator
+ CScript scriptCode(pbegincodehash, pend);
+
+ // Drop the signatures, since there's no way for a signature to sign itself
+ for (int k = 0; k < nSigsCount; k++)
+ {
+ valtype& vchSig = stacktop(-isig-k);
+ scriptCode.FindAndDelete(CScript(vchSig));
+ }
+
+ bool fSuccess = true;
+ while (fSuccess && nSigsCount > 0)
+ {
+ valtype& vchSig = stacktop(-isig);
+ valtype& vchPubKey = stacktop(-ikey);
+
+ // Check signature
+ if (CheckSig(vchSig, vchPubKey, scriptCode, txTo, nIn, nHashType))
+ {
+ isig++;
+ nSigsCount--;
+ }
+ ikey++;
+ nKeysCount--;
+
+ // If there are more signatures left than keys left,
+ // then too many signatures have failed
+ if (nSigsCount > nKeysCount)
+ fSuccess = false;
+ }
+
+ while (i-- > 0)
+ popstack(stack);
+ stack.push_back(fSuccess ? vchTrue : vchFalse);
+
+ if (opcode == OP_CHECKMULTISIGVERIFY)
+ {
+ if (fSuccess)
+ popstack(stack);
+ else
+ return false;
+ }
+ }
+ break;
+
+ default:
+ return false;
+ }
+
+ // Size limits
+ if (stack.size() + altstack.size() > 1000)
+ return false;
+ }
+ }
+ catch (...)
+ {
+ return false;
+ }
+
+
+ if (!vfExec.empty())
+ return false;
+
+ return true;
+}
+
+
+
+
+
+
+
+
+
+uint256 SignatureHash(CScript scriptCode, const CTransaction& txTo, unsigned int nIn, int nHashType)
+{
+ if (nIn >= txTo.vin.size())
+ {
+ printf("ERROR: SignatureHash() : nIn=%d out of range\n", nIn);
+ return 1;
+ }
+ CTransaction txTmp(txTo);
+
+ // In case concatenating two scripts ends up with two codeseparators,
+ // or an extra one at the end, this prevents all those possible incompatibilities.
+ scriptCode.FindAndDelete(CScript(OP_CODESEPARATOR));
+
+ // Blank out other inputs' signatures
+ for (int i = 0; i < txTmp.vin.size(); i++)
+ txTmp.vin[i].scriptSig = CScript();
+ txTmp.vin[nIn].scriptSig = scriptCode;
+
+ // Blank out some of the outputs
+ if ((nHashType & 0x1f) == SIGHASH_NONE)
+ {
+ // Wildcard payee
+ txTmp.vout.clear();
+
+ // Let the others update at will
+ for (int i = 0; i < txTmp.vin.size(); i++)
+ if (i != nIn)
+ txTmp.vin[i].nSequence = 0;
+ }
+ else if ((nHashType & 0x1f) == SIGHASH_SINGLE)
+ {
+ // Only lockin the txout payee at same index as txin
+ unsigned int nOut = nIn;
+ if (nOut >= txTmp.vout.size())
+ {
+ printf("ERROR: SignatureHash() : nOut=%d out of range\n", nOut);
+ return 1;
+ }
+ txTmp.vout.resize(nOut+1);
+ for (int i = 0; i < nOut; i++)
+ txTmp.vout[i].SetNull();
+
+ // Let the others update at will
+ for (int i = 0; i < txTmp.vin.size(); i++)
+ if (i != nIn)
+ txTmp.vin[i].nSequence = 0;
+ }
+
+ // Blank out other inputs completely, not recommended for open transactions
+ if (nHashType & SIGHASH_ANYONECANPAY)
+ {
+ txTmp.vin[0] = txTmp.vin[nIn];
+ txTmp.vin.resize(1);
+ }
+
+ // Serialize and hash
+ CDataStream ss(SER_GETHASH);
+ ss.reserve(10000);
+ ss << txTmp << nHashType;
+ return Hash(ss.begin(), ss.end());
+}
+
+
+bool CheckSig(vector<unsigned char> vchSig, vector<unsigned char> vchPubKey, CScript scriptCode,
+ const CTransaction& txTo, unsigned int nIn, int nHashType)
+{
+ CKey key;
+ if (!key.SetPubKey(vchPubKey))
+ return false;
+
+ // Hash type is one byte tacked on to the end of the signature
+ if (vchSig.empty())
+ return false;
+ if (nHashType == 0)
+ nHashType = vchSig.back();
+ else if (nHashType != vchSig.back())
+ return false;
+ vchSig.pop_back();
+
+ return key.Verify(SignatureHash(scriptCode, txTo, nIn, nHashType), vchSig);
+}
+
+
+
+
+
+
+
+
+
+
+bool Solver(const CScript& scriptPubKey, vector<pair<opcodetype, valtype> >& vSolutionRet)
+{
+ // Templates
+ static vector<CScript> vTemplates;
+ if (vTemplates.empty())
+ {
+ // Standard tx, sender provides pubkey, receiver adds signature
+ vTemplates.push_back(CScript() << OP_PUBKEY << OP_CHECKSIG);
+
+ // Bitcoin address tx, sender provides hash of pubkey, receiver provides signature and pubkey
+ vTemplates.push_back(CScript() << OP_DUP << OP_HASH160 << OP_PUBKEYHASH << OP_EQUALVERIFY << OP_CHECKSIG);
+ }
+
+ // Scan templates
+ const CScript& script1 = scriptPubKey;
+ BOOST_FOREACH(const CScript& script2, vTemplates)
+ {
+ vSolutionRet.clear();
+ opcodetype opcode1, opcode2;
+ vector<unsigned char> vch1, vch2;
+
+ // Compare
+ CScript::const_iterator pc1 = script1.begin();
+ CScript::const_iterator pc2 = script2.begin();
+ loop
+ {
+ if (pc1 == script1.end() && pc2 == script2.end())
+ {
+ // Found a match
+ reverse(vSolutionRet.begin(), vSolutionRet.end());
+ return true;
+ }
+ if (!script1.GetOp(pc1, opcode1, vch1))
+ break;
+ if (!script2.GetOp(pc2, opcode2, vch2))
+ break;
+ if (opcode2 == OP_PUBKEY)
+ {
+ if (vch1.size() < 33 || vch1.size() > 120)
+ break;
+ vSolutionRet.push_back(make_pair(opcode2, vch1));
+ }
+ else if (opcode2 == OP_PUBKEYHASH)
+ {
+ if (vch1.size() != sizeof(uint160))
+ break;
+ vSolutionRet.push_back(make_pair(opcode2, vch1));
+ }
+ else if (opcode1 != opcode2 || vch1 != vch2)
+ {
+ break;
+ }
+ }
+ }
+
+ vSolutionRet.clear();
+ return false;
+}
+
+
+bool Solver(const CKeyStore& keystore, const CScript& scriptPubKey, uint256 hash, int nHashType, CScript& scriptSigRet)
+{
+ scriptSigRet.clear();
+
+ vector<pair<opcodetype, valtype> > vSolution;
+ if (!Solver(scriptPubKey, vSolution))
+ return false;
+
+ // Compile solution
+ BOOST_FOREACH(PAIRTYPE(opcodetype, valtype)& item, vSolution)
+ {
+ if (item.first == OP_PUBKEY)
+ {
+ // Sign
+ const valtype& vchPubKey = item.second;
+ CKey key;
+ if (!keystore.GetKey(Hash160(vchPubKey), key))
+ return false;
+ if (key.GetPubKey() != vchPubKey)
+ return false;
+ if (hash != 0)
+ {
+ vector<unsigned char> vchSig;
+ if (!key.Sign(hash, vchSig))
+ return false;
+ vchSig.push_back((unsigned char)nHashType);
+ scriptSigRet << vchSig;
+ }
+ }
+ else if (item.first == OP_PUBKEYHASH)
+ {
+ // Sign and give pubkey
+ CKey key;
+ if (!keystore.GetKey(uint160(item.second), key))
+ return false;
+ if (hash != 0)
+ {
+ vector<unsigned char> vchSig;
+ if (!key.Sign(hash, vchSig))
+ return false;
+ vchSig.push_back((unsigned char)nHashType);
+ scriptSigRet << vchSig << key.GetPubKey();
+ }
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+
+bool IsStandard(const CScript& scriptPubKey)
+{
+ vector<pair<opcodetype, valtype> > vSolution;
+ return Solver(scriptPubKey, vSolution);
+}
+
+
+bool IsMine(const CKeyStore &keystore, const CScript& scriptPubKey)
+{
+ vector<pair<opcodetype, valtype> > vSolution;
+ if (!Solver(scriptPubKey, vSolution))
+ return false;
+
+ // Compile solution
+ BOOST_FOREACH(PAIRTYPE(opcodetype, valtype)& item, vSolution)
+ {
+ if (item.first == OP_PUBKEY)
+ {
+ const valtype& vchPubKey = item.second;
+ vector<unsigned char> vchPubKeyFound;
+ if (!keystore.GetPubKey(Hash160(vchPubKey), vchPubKeyFound))
+ return false;
+ if (vchPubKeyFound != vchPubKey)
+ return false;
+ }
+ else if (item.first == OP_PUBKEYHASH)
+ {
+ if (!keystore.HaveKey(uint160(item.second)))
+ return false;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool static ExtractAddressInner(const CScript& scriptPubKey, const CKeyStore* keystore, CBitcoinAddress& addressRet)
+{
+ vector<pair<opcodetype, valtype> > vSolution;
+ if (!Solver(scriptPubKey, vSolution))
+ return false;
+
+ BOOST_FOREACH(PAIRTYPE(opcodetype, valtype)& item, vSolution)
+ {
+ if (item.first == OP_PUBKEY)
+ addressRet.SetPubKey(item.second);
+ else if (item.first == OP_PUBKEYHASH)
+ addressRet.SetHash160((uint160)item.second);
+ if (keystore == NULL || keystore->HaveKey(addressRet))
+ return true;
+ }
+
+ return false;
+}
+
+
+bool ExtractAddress(const CScript& scriptPubKey, const CKeyStore* keystore, CBitcoinAddress& addressRet)
+{
+ if (keystore)
+ return ExtractAddressInner(scriptPubKey, keystore, addressRet);
+ else
+ return ExtractAddressInner(scriptPubKey, NULL, addressRet);
+ return false;
+}
+
+
+bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, const CTransaction& txTo, unsigned int nIn, int nHashType)
+{
+ vector<vector<unsigned char> > stack;
+ if (!EvalScript(stack, scriptSig, txTo, nIn, nHashType))
+ return false;
+ if (!EvalScript(stack, scriptPubKey, txTo, nIn, nHashType))
+ return false;
+ if (stack.empty())
+ return false;
+ return CastToBool(stack.back());
+}
+
+
+bool SignSignature(const CKeyStore &keystore, const CTransaction& txFrom, CTransaction& txTo, unsigned int nIn, int nHashType, CScript scriptPrereq)
+{
+ assert(nIn < txTo.vin.size());
+ CTxIn& txin = txTo.vin[nIn];
+ assert(txin.prevout.n < txFrom.vout.size());
+ const CTxOut& txout = txFrom.vout[txin.prevout.n];
+
+ // Leave out the signature from the hash, since a signature can't sign itself.
+ // The checksig op will also drop the signatures from its hash.
+ uint256 hash = SignatureHash(scriptPrereq + txout.scriptPubKey, txTo, nIn, nHashType);
+
+ if (!Solver(keystore, txout.scriptPubKey, hash, nHashType, txin.scriptSig))
+ return false;
+
+ txin.scriptSig = scriptPrereq + txin.scriptSig;
+
+ // Test solution
+ if (scriptPrereq.empty())
+ if (!VerifyScript(txin.scriptSig, txout.scriptPubKey, txTo, nIn, 0))
+ return false;
+
+ return true;
+}
+
+
+bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, int nHashType)
+{
+ assert(nIn < txTo.vin.size());
+ const CTxIn& txin = txTo.vin[nIn];
+ if (txin.prevout.n >= txFrom.vout.size())
+ return false;
+ const CTxOut& txout = txFrom.vout[txin.prevout.n];
+
+ if (txin.prevout.hash != txFrom.GetHash())
+ return false;
+
+ if (!VerifyScript(txin.scriptSig, txout.scriptPubKey, txTo, nIn, nHashType))
+ return false;
+
+ return true;
+}
diff --git a/bitcoin/src/script.h b/bitcoin/src/script.h
@@ -0,0 +1,703 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2011 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#ifndef H_BITCOIN_SCRIPT
+#define H_BITCOIN_SCRIPT
+
+#include "base58.h"
+#include "keystore.h"
+
+#include <string>
+#include <vector>
+
+#include <boost/foreach.hpp>
+
+class CTransaction;
+
+enum
+{
+ SIGHASH_ALL = 1,
+ SIGHASH_NONE = 2,
+ SIGHASH_SINGLE = 3,
+ SIGHASH_ANYONECANPAY = 0x80,
+};
+
+
+
+enum opcodetype
+{
+ // push value
+ OP_0=0,
+ OP_FALSE=OP_0,
+ OP_PUSHDATA1=76,
+ OP_PUSHDATA2,
+ OP_PUSHDATA4,
+ OP_1NEGATE,
+ OP_RESERVED,
+ OP_1,
+ OP_TRUE=OP_1,
+ OP_2,
+ OP_3,
+ OP_4,
+ OP_5,
+ OP_6,
+ OP_7,
+ OP_8,
+ OP_9,
+ OP_10,
+ OP_11,
+ OP_12,
+ OP_13,
+ OP_14,
+ OP_15,
+ OP_16,
+
+ // control
+ OP_NOP,
+ OP_VER,
+ OP_IF,
+ OP_NOTIF,
+ OP_VERIF,
+ OP_VERNOTIF,
+ OP_ELSE,
+ OP_ENDIF,
+ OP_VERIFY,
+ OP_RETURN,
+
+ // stack ops
+ OP_TOALTSTACK,
+ OP_FROMALTSTACK,
+ OP_2DROP,
+ OP_2DUP,
+ OP_3DUP,
+ OP_2OVER,
+ OP_2ROT,
+ OP_2SWAP,
+ OP_IFDUP,
+ OP_DEPTH,
+ OP_DROP,
+ OP_DUP,
+ OP_NIP,
+ OP_OVER,
+ OP_PICK,
+ OP_ROLL,
+ OP_ROT,
+ OP_SWAP,
+ OP_TUCK,
+
+ // splice ops
+ OP_CAT,
+ OP_SUBSTR,
+ OP_LEFT,
+ OP_RIGHT,
+ OP_SIZE,
+
+ // bit logic
+ OP_INVERT,
+ OP_AND,
+ OP_OR,
+ OP_XOR,
+ OP_EQUAL,
+ OP_EQUALVERIFY,
+ OP_RESERVED1,
+ OP_RESERVED2,
+
+ // numeric
+ OP_1ADD,
+ OP_1SUB,
+ OP_2MUL,
+ OP_2DIV,
+ OP_NEGATE,
+ OP_ABS,
+ OP_NOT,
+ OP_0NOTEQUAL,
+
+ OP_ADD,
+ OP_SUB,
+ OP_MUL,
+ OP_DIV,
+ OP_MOD,
+ OP_LSHIFT,
+ OP_RSHIFT,
+
+ OP_BOOLAND,
+ OP_BOOLOR,
+ OP_NUMEQUAL,
+ OP_NUMEQUALVERIFY,
+ OP_NUMNOTEQUAL,
+ OP_LESSTHAN,
+ OP_GREATERTHAN,
+ OP_LESSTHANOREQUAL,
+ OP_GREATERTHANOREQUAL,
+ OP_MIN,
+ OP_MAX,
+
+ OP_WITHIN,
+
+ // crypto
+ OP_RIPEMD160,
+ OP_SHA1,
+ OP_SHA256,
+ OP_HASH160,
+ OP_HASH256,
+ OP_CODESEPARATOR,
+ OP_CHECKSIG,
+ OP_CHECKSIGVERIFY,
+ OP_CHECKMULTISIG,
+ OP_CHECKMULTISIGVERIFY,
+
+ // expansion
+ OP_NOP1,
+ OP_NOP2,
+ OP_NOP3,
+ OP_NOP4,
+ OP_NOP5,
+ OP_NOP6,
+ OP_NOP7,
+ OP_NOP8,
+ OP_NOP9,
+ OP_NOP10,
+
+
+
+ // template matching params
+ OP_PUBKEYHASH = 0xfd,
+ OP_PUBKEY = 0xfe,
+
+ OP_INVALIDOPCODE = 0xff,
+};
+
+
+
+
+
+
+
+
+inline const char* GetOpName(opcodetype opcode)
+{
+ switch (opcode)
+ {
+ // push value
+ case OP_0 : return "0";
+ case OP_PUSHDATA1 : return "OP_PUSHDATA1";
+ case OP_PUSHDATA2 : return "OP_PUSHDATA2";
+ case OP_PUSHDATA4 : return "OP_PUSHDATA4";
+ case OP_1NEGATE : return "-1";
+ case OP_RESERVED : return "OP_RESERVED";
+ case OP_1 : return "1";
+ case OP_2 : return "2";
+ case OP_3 : return "3";
+ case OP_4 : return "4";
+ case OP_5 : return "5";
+ case OP_6 : return "6";
+ case OP_7 : return "7";
+ case OP_8 : return "8";
+ case OP_9 : return "9";
+ case OP_10 : return "10";
+ case OP_11 : return "11";
+ case OP_12 : return "12";
+ case OP_13 : return "13";
+ case OP_14 : return "14";
+ case OP_15 : return "15";
+ case OP_16 : return "16";
+
+ // control
+ case OP_NOP : return "OP_NOP";
+ case OP_VER : return "OP_VER";
+ case OP_IF : return "OP_IF";
+ case OP_NOTIF : return "OP_NOTIF";
+ case OP_VERIF : return "OP_VERIF";
+ case OP_VERNOTIF : return "OP_VERNOTIF";
+ case OP_ELSE : return "OP_ELSE";
+ case OP_ENDIF : return "OP_ENDIF";
+ case OP_VERIFY : return "OP_VERIFY";
+ case OP_RETURN : return "OP_RETURN";
+
+ // stack ops
+ case OP_TOALTSTACK : return "OP_TOALTSTACK";
+ case OP_FROMALTSTACK : return "OP_FROMALTSTACK";
+ case OP_2DROP : return "OP_2DROP";
+ case OP_2DUP : return "OP_2DUP";
+ case OP_3DUP : return "OP_3DUP";
+ case OP_2OVER : return "OP_2OVER";
+ case OP_2ROT : return "OP_2ROT";
+ case OP_2SWAP : return "OP_2SWAP";
+ case OP_IFDUP : return "OP_IFDUP";
+ case OP_DEPTH : return "OP_DEPTH";
+ case OP_DROP : return "OP_DROP";
+ case OP_DUP : return "OP_DUP";
+ case OP_NIP : return "OP_NIP";
+ case OP_OVER : return "OP_OVER";
+ case OP_PICK : return "OP_PICK";
+ case OP_ROLL : return "OP_ROLL";
+ case OP_ROT : return "OP_ROT";
+ case OP_SWAP : return "OP_SWAP";
+ case OP_TUCK : return "OP_TUCK";
+
+ // splice ops
+ case OP_CAT : return "OP_CAT";
+ case OP_SUBSTR : return "OP_SUBSTR";
+ case OP_LEFT : return "OP_LEFT";
+ case OP_RIGHT : return "OP_RIGHT";
+ case OP_SIZE : return "OP_SIZE";
+
+ // bit logic
+ case OP_INVERT : return "OP_INVERT";
+ case OP_AND : return "OP_AND";
+ case OP_OR : return "OP_OR";
+ case OP_XOR : return "OP_XOR";
+ case OP_EQUAL : return "OP_EQUAL";
+ case OP_EQUALVERIFY : return "OP_EQUALVERIFY";
+ case OP_RESERVED1 : return "OP_RESERVED1";
+ case OP_RESERVED2 : return "OP_RESERVED2";
+
+ // numeric
+ case OP_1ADD : return "OP_1ADD";
+ case OP_1SUB : return "OP_1SUB";
+ case OP_2MUL : return "OP_2MUL";
+ case OP_2DIV : return "OP_2DIV";
+ case OP_NEGATE : return "OP_NEGATE";
+ case OP_ABS : return "OP_ABS";
+ case OP_NOT : return "OP_NOT";
+ case OP_0NOTEQUAL : return "OP_0NOTEQUAL";
+ case OP_ADD : return "OP_ADD";
+ case OP_SUB : return "OP_SUB";
+ case OP_MUL : return "OP_MUL";
+ case OP_DIV : return "OP_DIV";
+ case OP_MOD : return "OP_MOD";
+ case OP_LSHIFT : return "OP_LSHIFT";
+ case OP_RSHIFT : return "OP_RSHIFT";
+ case OP_BOOLAND : return "OP_BOOLAND";
+ case OP_BOOLOR : return "OP_BOOLOR";
+ case OP_NUMEQUAL : return "OP_NUMEQUAL";
+ case OP_NUMEQUALVERIFY : return "OP_NUMEQUALVERIFY";
+ case OP_NUMNOTEQUAL : return "OP_NUMNOTEQUAL";
+ case OP_LESSTHAN : return "OP_LESSTHAN";
+ case OP_GREATERTHAN : return "OP_GREATERTHAN";
+ case OP_LESSTHANOREQUAL : return "OP_LESSTHANOREQUAL";
+ case OP_GREATERTHANOREQUAL : return "OP_GREATERTHANOREQUAL";
+ case OP_MIN : return "OP_MIN";
+ case OP_MAX : return "OP_MAX";
+ case OP_WITHIN : return "OP_WITHIN";
+
+ // crypto
+ case OP_RIPEMD160 : return "OP_RIPEMD160";
+ case OP_SHA1 : return "OP_SHA1";
+ case OP_SHA256 : return "OP_SHA256";
+ case OP_HASH160 : return "OP_HASH160";
+ case OP_HASH256 : return "OP_HASH256";
+ case OP_CODESEPARATOR : return "OP_CODESEPARATOR";
+ case OP_CHECKSIG : return "OP_CHECKSIG";
+ case OP_CHECKSIGVERIFY : return "OP_CHECKSIGVERIFY";
+ case OP_CHECKMULTISIG : return "OP_CHECKMULTISIG";
+ case OP_CHECKMULTISIGVERIFY : return "OP_CHECKMULTISIGVERIFY";
+
+ // expanson
+ case OP_NOP1 : return "OP_NOP1";
+ case OP_NOP2 : return "OP_NOP2";
+ case OP_NOP3 : return "OP_NOP3";
+ case OP_NOP4 : return "OP_NOP4";
+ case OP_NOP5 : return "OP_NOP5";
+ case OP_NOP6 : return "OP_NOP6";
+ case OP_NOP7 : return "OP_NOP7";
+ case OP_NOP8 : return "OP_NOP8";
+ case OP_NOP9 : return "OP_NOP9";
+ case OP_NOP10 : return "OP_NOP10";
+
+
+
+ // template matching params
+ case OP_PUBKEYHASH : return "OP_PUBKEYHASH";
+ case OP_PUBKEY : return "OP_PUBKEY";
+
+ case OP_INVALIDOPCODE : return "OP_INVALIDOPCODE";
+ default:
+ return "OP_UNKNOWN";
+ }
+};
+
+
+
+
+inline std::string ValueString(const std::vector<unsigned char>& vch)
+{
+ if (vch.size() <= 4)
+ return strprintf("%d", CBigNum(vch).getint());
+ else
+ return HexStr(vch);
+}
+
+inline std::string StackString(const std::vector<std::vector<unsigned char> >& vStack)
+{
+ std::string str;
+ BOOST_FOREACH(const std::vector<unsigned char>& vch, vStack)
+ {
+ if (!str.empty())
+ str += " ";
+ str += ValueString(vch);
+ }
+ return str;
+}
+
+
+
+
+
+
+
+
+
+class CScript : public std::vector<unsigned char>
+{
+protected:
+ CScript& push_int64(int64 n)
+ {
+ if (n == -1 || (n >= 1 && n <= 16))
+ {
+ push_back(n + (OP_1 - 1));
+ }
+ else
+ {
+ CBigNum bn(n);
+ *this << bn.getvch();
+ }
+ return *this;
+ }
+
+ CScript& push_uint64(uint64 n)
+ {
+ if (n >= 1 && n <= 16)
+ {
+ push_back(n + (OP_1 - 1));
+ }
+ else
+ {
+ CBigNum bn(n);
+ *this << bn.getvch();
+ }
+ return *this;
+ }
+
+public:
+ CScript() { }
+ CScript(const CScript& b) : std::vector<unsigned char>(b.begin(), b.end()) { }
+ CScript(const_iterator pbegin, const_iterator pend) : std::vector<unsigned char>(pbegin, pend) { }
+#ifndef _MSC_VER
+ CScript(const unsigned char* pbegin, const unsigned char* pend) : std::vector<unsigned char>(pbegin, pend) { }
+#endif
+
+ CScript& operator+=(const CScript& b)
+ {
+ insert(end(), b.begin(), b.end());
+ return *this;
+ }
+
+ friend CScript operator+(const CScript& a, const CScript& b)
+ {
+ CScript ret = a;
+ ret += b;
+ return ret;
+ }
+
+
+ explicit CScript(char b) { operator<<(b); }
+ explicit CScript(short b) { operator<<(b); }
+ explicit CScript(int b) { operator<<(b); }
+ explicit CScript(long b) { operator<<(b); }
+ explicit CScript(int64 b) { operator<<(b); }
+ explicit CScript(unsigned char b) { operator<<(b); }
+ explicit CScript(unsigned int b) { operator<<(b); }
+ explicit CScript(unsigned short b) { operator<<(b); }
+ explicit CScript(unsigned long b) { operator<<(b); }
+ explicit CScript(uint64 b) { operator<<(b); }
+
+ explicit CScript(opcodetype b) { operator<<(b); }
+ explicit CScript(const uint256& b) { operator<<(b); }
+ explicit CScript(const CBigNum& b) { operator<<(b); }
+ explicit CScript(const std::vector<unsigned char>& b) { operator<<(b); }
+
+
+ CScript& operator<<(char b) { return push_int64(b); }
+ CScript& operator<<(short b) { return push_int64(b); }
+ CScript& operator<<(int b) { return push_int64(b); }
+ CScript& operator<<(long b) { return push_int64(b); }
+ CScript& operator<<(int64 b) { return push_int64(b); }
+ CScript& operator<<(unsigned char b) { return push_uint64(b); }
+ CScript& operator<<(unsigned int b) { return push_uint64(b); }
+ CScript& operator<<(unsigned short b) { return push_uint64(b); }
+ CScript& operator<<(unsigned long b) { return push_uint64(b); }
+ CScript& operator<<(uint64 b) { return push_uint64(b); }
+
+ CScript& operator<<(opcodetype opcode)
+ {
+ if (opcode < 0 || opcode > 0xff)
+ throw std::runtime_error("CScript::operator<<() : invalid opcode");
+ insert(end(), (unsigned char)opcode);
+ return *this;
+ }
+
+ CScript& operator<<(const uint160& b)
+ {
+ insert(end(), sizeof(b));
+ insert(end(), (unsigned char*)&b, (unsigned char*)&b + sizeof(b));
+ return *this;
+ }
+
+ CScript& operator<<(const uint256& b)
+ {
+ insert(end(), sizeof(b));
+ insert(end(), (unsigned char*)&b, (unsigned char*)&b + sizeof(b));
+ return *this;
+ }
+
+ CScript& operator<<(const CBigNum& b)
+ {
+ *this << b.getvch();
+ return *this;
+ }
+
+ CScript& operator<<(const std::vector<unsigned char>& b)
+ {
+ if (b.size() < OP_PUSHDATA1)
+ {
+ insert(end(), (unsigned char)b.size());
+ }
+ else if (b.size() <= 0xff)
+ {
+ insert(end(), OP_PUSHDATA1);
+ insert(end(), (unsigned char)b.size());
+ }
+ else if (b.size() <= 0xffff)
+ {
+ insert(end(), OP_PUSHDATA2);
+ unsigned short nSize = b.size();
+ insert(end(), (unsigned char*)&nSize, (unsigned char*)&nSize + sizeof(nSize));
+ }
+ else
+ {
+ insert(end(), OP_PUSHDATA4);
+ unsigned int nSize = b.size();
+ insert(end(), (unsigned char*)&nSize, (unsigned char*)&nSize + sizeof(nSize));
+ }
+ insert(end(), b.begin(), b.end());
+ return *this;
+ }
+
+ CScript& operator<<(const CScript& b)
+ {
+ // I'm not sure if this should push the script or concatenate scripts.
+ // If there's ever a use for pushing a script onto a script, delete this member fn
+ assert(!"warning: pushing a CScript onto a CScript with << is probably not intended, use + to concatenate");
+ return *this;
+ }
+
+
+ bool GetOp(iterator& pc, opcodetype& opcodeRet, std::vector<unsigned char>& vchRet)
+ {
+ // Wrapper so it can be called with either iterator or const_iterator
+ const_iterator pc2 = pc;
+ bool fRet = GetOp2(pc2, opcodeRet, &vchRet);
+ pc = begin() + (pc2 - begin());
+ return fRet;
+ }
+
+ bool GetOp(iterator& pc, opcodetype& opcodeRet)
+ {
+ const_iterator pc2 = pc;
+ bool fRet = GetOp2(pc2, opcodeRet, NULL);
+ pc = begin() + (pc2 - begin());
+ return fRet;
+ }
+
+ bool GetOp(const_iterator& pc, opcodetype& opcodeRet, std::vector<unsigned char>& vchRet) const
+ {
+ return GetOp2(pc, opcodeRet, &vchRet);
+ }
+
+ bool GetOp(const_iterator& pc, opcodetype& opcodeRet) const
+ {
+ return GetOp2(pc, opcodeRet, NULL);
+ }
+
+ bool GetOp2(const_iterator& pc, opcodetype& opcodeRet, std::vector<unsigned char>* pvchRet) const
+ {
+ opcodeRet = OP_INVALIDOPCODE;
+ if (pvchRet)
+ pvchRet->clear();
+ if (pc >= end())
+ return false;
+
+ // Read instruction
+ if (end() - pc < 1)
+ return false;
+ unsigned int opcode = *pc++;
+
+ // Immediate operand
+ if (opcode <= OP_PUSHDATA4)
+ {
+ unsigned int nSize;
+ if (opcode < OP_PUSHDATA1)
+ {
+ nSize = opcode;
+ }
+ else if (opcode == OP_PUSHDATA1)
+ {
+ if (end() - pc < 1)
+ return false;
+ nSize = *pc++;
+ }
+ else if (opcode == OP_PUSHDATA2)
+ {
+ if (end() - pc < 2)
+ return false;
+ nSize = 0;
+ memcpy(&nSize, &pc[0], 2);
+ pc += 2;
+ }
+ else if (opcode == OP_PUSHDATA4)
+ {
+ if (end() - pc < 4)
+ return false;
+ memcpy(&nSize, &pc[0], 4);
+ pc += 4;
+ }
+ if (end() - pc < nSize)
+ return false;
+ if (pvchRet)
+ pvchRet->assign(pc, pc + nSize);
+ pc += nSize;
+ }
+
+ opcodeRet = (opcodetype)opcode;
+ return true;
+ }
+
+
+ void FindAndDelete(const CScript& b)
+ {
+ if (b.empty())
+ return;
+ iterator pc = begin();
+ opcodetype opcode;
+ do
+ {
+ while (end() - pc >= b.size() && memcmp(&pc[0], &b[0], b.size()) == 0)
+ erase(pc, pc + b.size());
+ }
+ while (GetOp(pc, opcode));
+ }
+
+
+ int GetSigOpCount() const
+ {
+ int n = 0;
+ const_iterator pc = begin();
+ while (pc < end())
+ {
+ opcodetype opcode;
+ if (!GetOp(pc, opcode))
+ break;
+ if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY)
+ n++;
+ else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY)
+ n += 20;
+ }
+ return n;
+ }
+
+
+ bool IsPushOnly() const
+ {
+ if (size() > 200)
+ return false;
+ const_iterator pc = begin();
+ while (pc < end())
+ {
+ opcodetype opcode;
+ if (!GetOp(pc, opcode))
+ return false;
+ if (opcode > OP_16)
+ return false;
+ }
+ return true;
+ }
+
+
+ CBitcoinAddress GetBitcoinAddress() const
+ {
+ opcodetype opcode;
+ std::vector<unsigned char> vch;
+ CScript::const_iterator pc = begin();
+ if (!GetOp(pc, opcode, vch) || opcode != OP_DUP) return 0;
+ if (!GetOp(pc, opcode, vch) || opcode != OP_HASH160) return 0;
+ if (!GetOp(pc, opcode, vch) || vch.size() != sizeof(uint160)) return 0;
+ uint160 hash160 = uint160(vch);
+ if (!GetOp(pc, opcode, vch) || opcode != OP_EQUALVERIFY) return 0;
+ if (!GetOp(pc, opcode, vch) || opcode != OP_CHECKSIG) return 0;
+ if (pc != end()) return 0;
+ return CBitcoinAddress(hash160);
+ }
+
+ void SetBitcoinAddress(const CBitcoinAddress& address)
+ {
+ this->clear();
+ *this << OP_DUP << OP_HASH160 << address.GetHash160() << OP_EQUALVERIFY << OP_CHECKSIG;
+ }
+
+ void SetBitcoinAddress(const std::vector<unsigned char>& vchPubKey)
+ {
+ SetBitcoinAddress(CBitcoinAddress(vchPubKey));
+ }
+
+
+ void PrintHex() const
+ {
+ printf("CScript(%s)\n", HexStr(begin(), end(), true).c_str());
+ }
+
+ std::string ToString() const
+ {
+ std::string str;
+ opcodetype opcode;
+ std::vector<unsigned char> vch;
+ const_iterator pc = begin();
+ while (pc < end())
+ {
+ if (!str.empty())
+ str += " ";
+ if (!GetOp(pc, opcode, vch))
+ {
+ str += "[error]";
+ return str;
+ }
+ if (0 <= opcode && opcode <= OP_PUSHDATA4)
+ str += ValueString(vch);
+ else
+ str += GetOpName(opcode);
+ }
+ return str;
+ }
+
+ void print() const
+ {
+ printf("%s\n", ToString().c_str());
+ }
+};
+
+
+
+
+
+
+
+bool EvalScript(std::vector<std::vector<unsigned char> >& stack, const CScript& script, const CTransaction& txTo, unsigned int nIn, int nHashType);
+
+bool IsStandard(const CScript& scriptPubKey);
+bool IsMine(const CKeyStore& keystore, const CScript& scriptPubKey);
+bool ExtractAddress(const CScript& scriptPubKey, const CKeyStore* pkeystore, CBitcoinAddress& addressRet);
+bool SignSignature(const CKeyStore& keystore, const CTransaction& txFrom, CTransaction& txTo, unsigned int nIn, int nHashType=SIGHASH_ALL, CScript scriptPrereq=CScript());
+bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, int nHashType=0);
+
+#endif
diff --git a/bitcoin/src/serialize.h b/bitcoin/src/serialize.h
@@ -0,0 +1,1349 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2012 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#ifndef BITCOIN_SERIALIZE_H
+#define BITCOIN_SERIALIZE_H
+
+#include <string>
+#include <vector>
+#include <map>
+#include <set>
+#include <cassert>
+#include <climits>
+#include <cstring>
+#include <cstdio>
+
+#include <boost/type_traits/is_fundamental.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <boost/tuple/tuple_comparison.hpp>
+#include <boost/tuple/tuple_io.hpp>
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+typedef __int64 int64;
+typedef unsigned __int64 uint64;
+#else
+typedef long long int64;
+typedef unsigned long long uint64;
+#endif
+#if defined(_MSC_VER) && _MSC_VER < 1300
+#define for if (false) ; else for
+#endif
+
+#ifdef WIN32
+#include <windows.h>
+// This is used to attempt to keep keying material out of swap
+// Note that VirtualLock does not provide this as a guarantee on Windows,
+// but, in practice, memory that has been VirtualLock'd almost never gets written to
+// the pagefile except in rare circumstances where memory is extremely low.
+#include <windows.h>
+#define mlock(p, n) VirtualLock((p), (n));
+#define munlock(p, n) VirtualUnlock((p), (n));
+#else
+#include <sys/mman.h>
+#include <limits.h>
+/* This comes from limits.h if it's not defined there set a sane default */
+#ifndef PAGESIZE
+#include <unistd.h>
+#define PAGESIZE sysconf(_SC_PAGESIZE)
+#endif
+#define mlock(a,b) \
+ mlock(((void *)(((size_t)(a)) & (~((PAGESIZE)-1)))),\
+ (((((size_t)(a)) + (b) - 1) | ((PAGESIZE) - 1)) + 1) - (((size_t)(a)) & (~((PAGESIZE) - 1))))
+#define munlock(a,b) \
+ munlock(((void *)(((size_t)(a)) & (~((PAGESIZE)-1)))),\
+ (((((size_t)(a)) + (b) - 1) | ((PAGESIZE) - 1)) + 1) - (((size_t)(a)) & (~((PAGESIZE) - 1))))
+#endif
+
+class CScript;
+class CDataStream;
+class CAutoFile;
+static const unsigned int MAX_SIZE = 0x02000000;
+
+static const int VERSION = 50300;
+static const char* pszSubVer = "";
+static const bool VERSION_IS_BETA = true;
+
+// Used to bypass the rule against non-const reference to temporary
+// where it makes sense with wrappers such as CFlatData or CTxDB
+template<typename T>
+inline T& REF(const T& val)
+{
+ return const_cast<T&>(val);
+}
+
+/////////////////////////////////////////////////////////////////
+//
+// Templates for serializing to anything that looks like a stream,
+// i.e. anything that supports .read(char*, int) and .write(char*, int)
+//
+
+enum
+{
+ // primary actions
+ SER_NETWORK = (1 << 0),
+ SER_DISK = (1 << 1),
+ SER_GETHASH = (1 << 2),
+
+ // modifiers
+ SER_SKIPSIG = (1 << 16),
+ SER_BLOCKHEADERONLY = (1 << 17),
+};
+
+#define IMPLEMENT_SERIALIZE(statements) \
+ unsigned int GetSerializeSize(int nType=0, int nVersion=VERSION) const \
+ { \
+ CSerActionGetSerializeSize ser_action; \
+ const bool fGetSize = true; \
+ const bool fWrite = false; \
+ const bool fRead = false; \
+ unsigned int nSerSize = 0; \
+ ser_streamplaceholder s; \
+ assert(fGetSize||fWrite||fRead); /* suppress warning */ \
+ s.nType = nType; \
+ s.nVersion = nVersion; \
+ {statements} \
+ return nSerSize; \
+ } \
+ template<typename Stream> \
+ void Serialize(Stream& s, int nType=0, int nVersion=VERSION) const \
+ { \
+ CSerActionSerialize ser_action; \
+ const bool fGetSize = false; \
+ const bool fWrite = true; \
+ const bool fRead = false; \
+ unsigned int nSerSize = 0; \
+ assert(fGetSize||fWrite||fRead); /* suppress warning */ \
+ {statements} \
+ } \
+ template<typename Stream> \
+ void Unserialize(Stream& s, int nType=0, int nVersion=VERSION) \
+ { \
+ CSerActionUnserialize ser_action; \
+ const bool fGetSize = false; \
+ const bool fWrite = false; \
+ const bool fRead = true; \
+ unsigned int nSerSize = 0; \
+ assert(fGetSize||fWrite||fRead); /* suppress warning */ \
+ {statements} \
+ }
+
+#define READWRITE(obj) (nSerSize += ::SerReadWrite(s, (obj), nType, nVersion, ser_action))
+
+
+
+
+
+
+//
+// Basic types
+//
+#define WRITEDATA(s, obj) s.write((char*)&(obj), sizeof(obj))
+#define READDATA(s, obj) s.read((char*)&(obj), sizeof(obj))
+
+inline unsigned int GetSerializeSize(char a, int, int=0) { return sizeof(a); }
+inline unsigned int GetSerializeSize(signed char a, int, int=0) { return sizeof(a); }
+inline unsigned int GetSerializeSize(unsigned char a, int, int=0) { return sizeof(a); }
+inline unsigned int GetSerializeSize(signed short a, int, int=0) { return sizeof(a); }
+inline unsigned int GetSerializeSize(unsigned short a, int, int=0) { return sizeof(a); }
+inline unsigned int GetSerializeSize(signed int a, int, int=0) { return sizeof(a); }
+inline unsigned int GetSerializeSize(unsigned int a, int, int=0) { return sizeof(a); }
+inline unsigned int GetSerializeSize(signed long a, int, int=0) { return sizeof(a); }
+inline unsigned int GetSerializeSize(unsigned long a, int, int=0) { return sizeof(a); }
+inline unsigned int GetSerializeSize(int64 a, int, int=0) { return sizeof(a); }
+inline unsigned int GetSerializeSize(uint64 a, int, int=0) { return sizeof(a); }
+inline unsigned int GetSerializeSize(float a, int, int=0) { return sizeof(a); }
+inline unsigned int GetSerializeSize(double a, int, int=0) { return sizeof(a); }
+
+template<typename Stream> inline void Serialize(Stream& s, char a, int, int=0) { WRITEDATA(s, a); }
+template<typename Stream> inline void Serialize(Stream& s, signed char a, int, int=0) { WRITEDATA(s, a); }
+template<typename Stream> inline void Serialize(Stream& s, unsigned char a, int, int=0) { WRITEDATA(s, a); }
+template<typename Stream> inline void Serialize(Stream& s, signed short a, int, int=0) { WRITEDATA(s, a); }
+template<typename Stream> inline void Serialize(Stream& s, unsigned short a, int, int=0) { WRITEDATA(s, a); }
+template<typename Stream> inline void Serialize(Stream& s, signed int a, int, int=0) { WRITEDATA(s, a); }
+template<typename Stream> inline void Serialize(Stream& s, unsigned int a, int, int=0) { WRITEDATA(s, a); }
+template<typename Stream> inline void Serialize(Stream& s, signed long a, int, int=0) { WRITEDATA(s, a); }
+template<typename Stream> inline void Serialize(Stream& s, unsigned long a, int, int=0) { WRITEDATA(s, a); }
+template<typename Stream> inline void Serialize(Stream& s, int64 a, int, int=0) { WRITEDATA(s, a); }
+template<typename Stream> inline void Serialize(Stream& s, uint64 a, int, int=0) { WRITEDATA(s, a); }
+template<typename Stream> inline void Serialize(Stream& s, float a, int, int=0) { WRITEDATA(s, a); }
+template<typename Stream> inline void Serialize(Stream& s, double a, int, int=0) { WRITEDATA(s, a); }
+
+template<typename Stream> inline void Unserialize(Stream& s, char& a, int, int=0) { READDATA(s, a); }
+template<typename Stream> inline void Unserialize(Stream& s, signed char& a, int, int=0) { READDATA(s, a); }
+template<typename Stream> inline void Unserialize(Stream& s, unsigned char& a, int, int=0) { READDATA(s, a); }
+template<typename Stream> inline void Unserialize(Stream& s, signed short& a, int, int=0) { READDATA(s, a); }
+template<typename Stream> inline void Unserialize(Stream& s, unsigned short& a, int, int=0) { READDATA(s, a); }
+template<typename Stream> inline void Unserialize(Stream& s, signed int& a, int, int=0) { READDATA(s, a); }
+template<typename Stream> inline void Unserialize(Stream& s, unsigned int& a, int, int=0) { READDATA(s, a); }
+template<typename Stream> inline void Unserialize(Stream& s, signed long& a, int, int=0) { READDATA(s, a); }
+template<typename Stream> inline void Unserialize(Stream& s, unsigned long& a, int, int=0) { READDATA(s, a); }
+template<typename Stream> inline void Unserialize(Stream& s, int64& a, int, int=0) { READDATA(s, a); }
+template<typename Stream> inline void Unserialize(Stream& s, uint64& a, int, int=0) { READDATA(s, a); }
+template<typename Stream> inline void Unserialize(Stream& s, float& a, int, int=0) { READDATA(s, a); }
+template<typename Stream> inline void Unserialize(Stream& s, double& a, int, int=0) { READDATA(s, a); }
+
+inline unsigned int GetSerializeSize(bool a, int, int=0) { return sizeof(char); }
+template<typename Stream> inline void Serialize(Stream& s, bool a, int, int=0) { char f=a; WRITEDATA(s, f); }
+template<typename Stream> inline void Unserialize(Stream& s, bool& a, int, int=0) { char f; READDATA(s, f); a=f; }
+
+
+
+
+
+
+//
+// Compact size
+// size < 253 -- 1 byte
+// size <= USHRT_MAX -- 3 bytes (253 + 2 bytes)
+// size <= UINT_MAX -- 5 bytes (254 + 4 bytes)
+// size > UINT_MAX -- 9 bytes (255 + 8 bytes)
+//
+inline unsigned int GetSizeOfCompactSize(uint64 nSize)
+{
+ if (nSize < 253) return sizeof(unsigned char);
+ else if (nSize <= USHRT_MAX) return sizeof(unsigned char) + sizeof(unsigned short);
+ else if (nSize <= UINT_MAX) return sizeof(unsigned char) + sizeof(unsigned int);
+ else return sizeof(unsigned char) + sizeof(uint64);
+}
+
+template<typename Stream>
+void WriteCompactSize(Stream& os, uint64 nSize)
+{
+ if (nSize < 253)
+ {
+ unsigned char chSize = nSize;
+ WRITEDATA(os, chSize);
+ }
+ else if (nSize <= USHRT_MAX)
+ {
+ unsigned char chSize = 253;
+ unsigned short xSize = nSize;
+ WRITEDATA(os, chSize);
+ WRITEDATA(os, xSize);
+ }
+ else if (nSize <= UINT_MAX)
+ {
+ unsigned char chSize = 254;
+ unsigned int xSize = nSize;
+ WRITEDATA(os, chSize);
+ WRITEDATA(os, xSize);
+ }
+ else
+ {
+ unsigned char chSize = 255;
+ uint64 xSize = nSize;
+ WRITEDATA(os, chSize);
+ WRITEDATA(os, xSize);
+ }
+ return;
+}
+
+template<typename Stream>
+uint64 ReadCompactSize(Stream& is)
+{
+ unsigned char chSize;
+ READDATA(is, chSize);
+ uint64 nSizeRet = 0;
+ if (chSize < 253)
+ {
+ nSizeRet = chSize;
+ }
+ else if (chSize == 253)
+ {
+ unsigned short xSize;
+ READDATA(is, xSize);
+ nSizeRet = xSize;
+ }
+ else if (chSize == 254)
+ {
+ unsigned int xSize;
+ READDATA(is, xSize);
+ nSizeRet = xSize;
+ }
+ else
+ {
+ uint64 xSize;
+ READDATA(is, xSize);
+ nSizeRet = xSize;
+ }
+ if (nSizeRet > (uint64)MAX_SIZE)
+ throw std::ios_base::failure("ReadCompactSize() : size too large");
+ return nSizeRet;
+}
+
+
+
+//
+// Wrapper for serializing arrays and POD
+// There's a clever template way to make arrays serialize normally, but MSVC6 doesn't support it
+//
+#define FLATDATA(obj) REF(CFlatData((char*)&(obj), (char*)&(obj) + sizeof(obj)))
+class CFlatData
+{
+protected:
+ char* pbegin;
+ char* pend;
+public:
+ CFlatData(void* pbeginIn, void* pendIn) : pbegin((char*)pbeginIn), pend((char*)pendIn) { }
+ char* begin() { return pbegin; }
+ const char* begin() const { return pbegin; }
+ char* end() { return pend; }
+ const char* end() const { return pend; }
+
+ unsigned int GetSerializeSize(int, int=0) const
+ {
+ return pend - pbegin;
+ }
+
+ template<typename Stream>
+ void Serialize(Stream& s, int, int=0) const
+ {
+ s.write(pbegin, pend - pbegin);
+ }
+
+ template<typename Stream>
+ void Unserialize(Stream& s, int, int=0)
+ {
+ s.read(pbegin, pend - pbegin);
+ }
+};
+
+
+
+//
+// string stored as a fixed length field
+//
+template<std::size_t LEN>
+class CFixedFieldString
+{
+protected:
+ const std::string* pcstr;
+ std::string* pstr;
+public:
+ explicit CFixedFieldString(const std::string& str) : pcstr(&str), pstr(NULL) { }
+ explicit CFixedFieldString(std::string& str) : pcstr(&str), pstr(&str) { }
+
+ unsigned int GetSerializeSize(int, int=0) const
+ {
+ return LEN;
+ }
+
+ template<typename Stream>
+ void Serialize(Stream& s, int, int=0) const
+ {
+ char pszBuf[LEN];
+ strncpy(pszBuf, pcstr->c_str(), LEN);
+ s.write(pszBuf, LEN);
+ }
+
+ template<typename Stream>
+ void Unserialize(Stream& s, int, int=0)
+ {
+ if (pstr == NULL)
+ throw std::ios_base::failure("CFixedFieldString::Unserialize : trying to unserialize to const string");
+ char pszBuf[LEN+1];
+ s.read(pszBuf, LEN);
+ pszBuf[LEN] = '\0';
+ *pstr = pszBuf;
+ }
+};
+
+
+
+
+
+//
+// Forward declarations
+//
+
+// string
+template<typename C> unsigned int GetSerializeSize(const std::basic_string<C>& str, int, int=0);
+template<typename Stream, typename C> void Serialize(Stream& os, const std::basic_string<C>& str, int, int=0);
+template<typename Stream, typename C> void Unserialize(Stream& is, std::basic_string<C>& str, int, int=0);
+
+// vector
+template<typename T, typename A> unsigned int GetSerializeSize_impl(const std::vector<T, A>& v, int nType, int nVersion, const boost::true_type&);
+template<typename T, typename A> unsigned int GetSerializeSize_impl(const std::vector<T, A>& v, int nType, int nVersion, const boost::false_type&);
+template<typename T, typename A> inline unsigned int GetSerializeSize(const std::vector<T, A>& v, int nType, int nVersion=VERSION);
+template<typename Stream, typename T, typename A> void Serialize_impl(Stream& os, const std::vector<T, A>& v, int nType, int nVersion, const boost::true_type&);
+template<typename Stream, typename T, typename A> void Serialize_impl(Stream& os, const std::vector<T, A>& v, int nType, int nVersion, const boost::false_type&);
+template<typename Stream, typename T, typename A> inline void Serialize(Stream& os, const std::vector<T, A>& v, int nType, int nVersion=VERSION);
+template<typename Stream, typename T, typename A> void Unserialize_impl(Stream& is, std::vector<T, A>& v, int nType, int nVersion, const boost::true_type&);
+template<typename Stream, typename T, typename A> void Unserialize_impl(Stream& is, std::vector<T, A>& v, int nType, int nVersion, const boost::false_type&);
+template<typename Stream, typename T, typename A> inline void Unserialize(Stream& is, std::vector<T, A>& v, int nType, int nVersion=VERSION);
+
+// others derived from vector
+extern inline unsigned int GetSerializeSize(const CScript& v, int nType, int nVersion=VERSION);
+template<typename Stream> void Serialize(Stream& os, const CScript& v, int nType, int nVersion=VERSION);
+template<typename Stream> void Unserialize(Stream& is, CScript& v, int nType, int nVersion=VERSION);
+
+// pair
+template<typename K, typename T> unsigned int GetSerializeSize(const std::pair<K, T>& item, int nType, int nVersion=VERSION);
+template<typename Stream, typename K, typename T> void Serialize(Stream& os, const std::pair<K, T>& item, int nType, int nVersion=VERSION);
+template<typename Stream, typename K, typename T> void Unserialize(Stream& is, std::pair<K, T>& item, int nType, int nVersion=VERSION);
+
+// 3 tuple
+template<typename T0, typename T1, typename T2> unsigned int GetSerializeSize(const boost::tuple<T0, T1, T2>& item, int nType, int nVersion=VERSION);
+template<typename Stream, typename T0, typename T1, typename T2> void Serialize(Stream& os, const boost::tuple<T0, T1, T2>& item, int nType, int nVersion=VERSION);
+template<typename Stream, typename T0, typename T1, typename T2> void Unserialize(Stream& is, boost::tuple<T0, T1, T2>& item, int nType, int nVersion=VERSION);
+
+// 4 tuple
+template<typename T0, typename T1, typename T2, typename T3> unsigned int GetSerializeSize(const boost::tuple<T0, T1, T2, T3>& item, int nType, int nVersion=VERSION);
+template<typename Stream, typename T0, typename T1, typename T2, typename T3> void Serialize(Stream& os, const boost::tuple<T0, T1, T2, T3>& item, int nType, int nVersion=VERSION);
+template<typename Stream, typename T0, typename T1, typename T2, typename T3> void Unserialize(Stream& is, boost::tuple<T0, T1, T2, T3>& item, int nType, int nVersion=VERSION);
+
+// map
+template<typename K, typename T, typename Pred, typename A> unsigned int GetSerializeSize(const std::map<K, T, Pred, A>& m, int nType, int nVersion=VERSION);
+template<typename Stream, typename K, typename T, typename Pred, typename A> void Serialize(Stream& os, const std::map<K, T, Pred, A>& m, int nType, int nVersion=VERSION);
+template<typename Stream, typename K, typename T, typename Pred, typename A> void Unserialize(Stream& is, std::map<K, T, Pred, A>& m, int nType, int nVersion=VERSION);
+
+// set
+template<typename K, typename Pred, typename A> unsigned int GetSerializeSize(const std::set<K, Pred, A>& m, int nType, int nVersion=VERSION);
+template<typename Stream, typename K, typename Pred, typename A> void Serialize(Stream& os, const std::set<K, Pred, A>& m, int nType, int nVersion=VERSION);
+template<typename Stream, typename K, typename Pred, typename A> void Unserialize(Stream& is, std::set<K, Pred, A>& m, int nType, int nVersion=VERSION);
+
+
+
+
+
+//
+// If none of the specialized versions above matched, default to calling member function.
+// "int nType" is changed to "long nType" to keep from getting an ambiguous overload error.
+// The compiler will only cast int to long if none of the other templates matched.
+// Thanks to Boost serialization for this idea.
+//
+template<typename T>
+inline unsigned int GetSerializeSize(const T& a, long nType, int nVersion=VERSION)
+{
+ return a.GetSerializeSize((int)nType, nVersion);
+}
+
+template<typename Stream, typename T>
+inline void Serialize(Stream& os, const T& a, long nType, int nVersion=VERSION)
+{
+ a.Serialize(os, (int)nType, nVersion);
+}
+
+template<typename Stream, typename T>
+inline void Unserialize(Stream& is, T& a, long nType, int nVersion=VERSION)
+{
+ a.Unserialize(is, (int)nType, nVersion);
+}
+
+
+
+
+
+//
+// string
+//
+template<typename C>
+unsigned int GetSerializeSize(const std::basic_string<C>& str, int, int)
+{
+ return GetSizeOfCompactSize(str.size()) + str.size() * sizeof(str[0]);
+}
+
+template<typename Stream, typename C>
+void Serialize(Stream& os, const std::basic_string<C>& str, int, int)
+{
+ WriteCompactSize(os, str.size());
+ if (!str.empty())
+ os.write((char*)&str[0], str.size() * sizeof(str[0]));
+}
+
+template<typename Stream, typename C>
+void Unserialize(Stream& is, std::basic_string<C>& str, int, int)
+{
+ unsigned int nSize = ReadCompactSize(is);
+ str.resize(nSize);
+ if (nSize != 0)
+ is.read((char*)&str[0], nSize * sizeof(str[0]));
+}
+
+
+
+//
+// vector
+//
+template<typename T, typename A>
+unsigned int GetSerializeSize_impl(const std::vector<T, A>& v, int nType, int nVersion, const boost::true_type&)
+{
+ return (GetSizeOfCompactSize(v.size()) + v.size() * sizeof(T));
+}
+
+template<typename T, typename A>
+unsigned int GetSerializeSize_impl(const std::vector<T, A>& v, int nType, int nVersion, const boost::false_type&)
+{
+ unsigned int nSize = GetSizeOfCompactSize(v.size());
+ for (typename std::vector<T, A>::const_iterator vi = v.begin(); vi != v.end(); ++vi)
+ nSize += GetSerializeSize((*vi), nType, nVersion);
+ return nSize;
+}
+
+template<typename T, typename A>
+inline unsigned int GetSerializeSize(const std::vector<T, A>& v, int nType, int nVersion)
+{
+ return GetSerializeSize_impl(v, nType, nVersion, boost::is_fundamental<T>());
+}
+
+
+template<typename Stream, typename T, typename A>
+void Serialize_impl(Stream& os, const std::vector<T, A>& v, int nType, int nVersion, const boost::true_type&)
+{
+ WriteCompactSize(os, v.size());
+ if (!v.empty())
+ os.write((char*)&v[0], v.size() * sizeof(T));
+}
+
+template<typename Stream, typename T, typename A>
+void Serialize_impl(Stream& os, const std::vector<T, A>& v, int nType, int nVersion, const boost::false_type&)
+{
+ WriteCompactSize(os, v.size());
+ for (typename std::vector<T, A>::const_iterator vi = v.begin(); vi != v.end(); ++vi)
+ ::Serialize(os, (*vi), nType, nVersion);
+}
+
+template<typename Stream, typename T, typename A>
+inline void Serialize(Stream& os, const std::vector<T, A>& v, int nType, int nVersion)
+{
+ Serialize_impl(os, v, nType, nVersion, boost::is_fundamental<T>());
+}
+
+
+template<typename Stream, typename T, typename A>
+void Unserialize_impl(Stream& is, std::vector<T, A>& v, int nType, int nVersion, const boost::true_type&)
+{
+ //unsigned int nSize = ReadCompactSize(is);
+ //v.resize(nSize);
+ //is.read((char*)&v[0], nSize * sizeof(T));
+
+ // Limit size per read so bogus size value won't cause out of memory
+ v.clear();
+ unsigned int nSize = ReadCompactSize(is);
+ unsigned int i = 0;
+ while (i < nSize)
+ {
+ unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T)));
+ v.resize(i + blk);
+ is.read((char*)&v[i], blk * sizeof(T));
+ i += blk;
+ }
+}
+
+template<typename Stream, typename T, typename A>
+void Unserialize_impl(Stream& is, std::vector<T, A>& v, int nType, int nVersion, const boost::false_type&)
+{
+ //unsigned int nSize = ReadCompactSize(is);
+ //v.resize(nSize);
+ //for (std::vector<T, A>::iterator vi = v.begin(); vi != v.end(); ++vi)
+ // Unserialize(is, (*vi), nType, nVersion);
+
+ v.clear();
+ unsigned int nSize = ReadCompactSize(is);
+ unsigned int i = 0;
+ unsigned int nMid = 0;
+ while (nMid < nSize)
+ {
+ nMid += 5000000 / sizeof(T);
+ if (nMid > nSize)
+ nMid = nSize;
+ v.resize(nMid);
+ for (; i < nMid; i++)
+ Unserialize(is, v[i], nType, nVersion);
+ }
+}
+
+template<typename Stream, typename T, typename A>
+inline void Unserialize(Stream& is, std::vector<T, A>& v, int nType, int nVersion)
+{
+ Unserialize_impl(is, v, nType, nVersion, boost::is_fundamental<T>());
+}
+
+
+
+//
+// others derived from vector
+//
+inline unsigned int GetSerializeSize(const CScript& v, int nType, int nVersion)
+{
+ return GetSerializeSize((const std::vector<unsigned char>&)v, nType, nVersion);
+}
+
+template<typename Stream>
+void Serialize(Stream& os, const CScript& v, int nType, int nVersion)
+{
+ Serialize(os, (const std::vector<unsigned char>&)v, nType, nVersion);
+}
+
+template<typename Stream>
+void Unserialize(Stream& is, CScript& v, int nType, int nVersion)
+{
+ Unserialize(is, (std::vector<unsigned char>&)v, nType, nVersion);
+}
+
+
+
+//
+// pair
+//
+template<typename K, typename T>
+unsigned int GetSerializeSize(const std::pair<K, T>& item, int nType, int nVersion)
+{
+ return GetSerializeSize(item.first, nType, nVersion) + GetSerializeSize(item.second, nType, nVersion);
+}
+
+template<typename Stream, typename K, typename T>
+void Serialize(Stream& os, const std::pair<K, T>& item, int nType, int nVersion)
+{
+ Serialize(os, item.first, nType, nVersion);
+ Serialize(os, item.second, nType, nVersion);
+}
+
+template<typename Stream, typename K, typename T>
+void Unserialize(Stream& is, std::pair<K, T>& item, int nType, int nVersion)
+{
+ Unserialize(is, item.first, nType, nVersion);
+ Unserialize(is, item.second, nType, nVersion);
+}
+
+
+
+//
+// 3 tuple
+//
+template<typename T0, typename T1, typename T2>
+unsigned int GetSerializeSize(const boost::tuple<T0, T1, T2>& item, int nType, int nVersion)
+{
+ unsigned int nSize = 0;
+ nSize += GetSerializeSize(boost::get<0>(item), nType, nVersion);
+ nSize += GetSerializeSize(boost::get<1>(item), nType, nVersion);
+ nSize += GetSerializeSize(boost::get<2>(item), nType, nVersion);
+ return nSize;
+}
+
+template<typename Stream, typename T0, typename T1, typename T2>
+void Serialize(Stream& os, const boost::tuple<T0, T1, T2>& item, int nType, int nVersion)
+{
+ Serialize(os, boost::get<0>(item), nType, nVersion);
+ Serialize(os, boost::get<1>(item), nType, nVersion);
+ Serialize(os, boost::get<2>(item), nType, nVersion);
+}
+
+template<typename Stream, typename T0, typename T1, typename T2>
+void Unserialize(Stream& is, boost::tuple<T0, T1, T2>& item, int nType, int nVersion)
+{
+ Unserialize(is, boost::get<0>(item), nType, nVersion);
+ Unserialize(is, boost::get<1>(item), nType, nVersion);
+ Unserialize(is, boost::get<2>(item), nType, nVersion);
+}
+
+
+
+//
+// 4 tuple
+//
+template<typename T0, typename T1, typename T2, typename T3>
+unsigned int GetSerializeSize(const boost::tuple<T0, T1, T2, T3>& item, int nType, int nVersion)
+{
+ unsigned int nSize = 0;
+ nSize += GetSerializeSize(boost::get<0>(item), nType, nVersion);
+ nSize += GetSerializeSize(boost::get<1>(item), nType, nVersion);
+ nSize += GetSerializeSize(boost::get<2>(item), nType, nVersion);
+ nSize += GetSerializeSize(boost::get<3>(item), nType, nVersion);
+ return nSize;
+}
+
+template<typename Stream, typename T0, typename T1, typename T2, typename T3>
+void Serialize(Stream& os, const boost::tuple<T0, T1, T2, T3>& item, int nType, int nVersion)
+{
+ Serialize(os, boost::get<0>(item), nType, nVersion);
+ Serialize(os, boost::get<1>(item), nType, nVersion);
+ Serialize(os, boost::get<2>(item), nType, nVersion);
+ Serialize(os, boost::get<3>(item), nType, nVersion);
+}
+
+template<typename Stream, typename T0, typename T1, typename T2, typename T3>
+void Unserialize(Stream& is, boost::tuple<T0, T1, T2, T3>& item, int nType, int nVersion)
+{
+ Unserialize(is, boost::get<0>(item), nType, nVersion);
+ Unserialize(is, boost::get<1>(item), nType, nVersion);
+ Unserialize(is, boost::get<2>(item), nType, nVersion);
+ Unserialize(is, boost::get<3>(item), nType, nVersion);
+}
+
+
+
+//
+// map
+//
+template<typename K, typename T, typename Pred, typename A>
+unsigned int GetSerializeSize(const std::map<K, T, Pred, A>& m, int nType, int nVersion)
+{
+ unsigned int nSize = GetSizeOfCompactSize(m.size());
+ for (typename std::map<K, T, Pred, A>::const_iterator mi = m.begin(); mi != m.end(); ++mi)
+ nSize += GetSerializeSize((*mi), nType, nVersion);
+ return nSize;
+}
+
+template<typename Stream, typename K, typename T, typename Pred, typename A>
+void Serialize(Stream& os, const std::map<K, T, Pred, A>& m, int nType, int nVersion)
+{
+ WriteCompactSize(os, m.size());
+ for (typename std::map<K, T, Pred, A>::const_iterator mi = m.begin(); mi != m.end(); ++mi)
+ Serialize(os, (*mi), nType, nVersion);
+}
+
+template<typename Stream, typename K, typename T, typename Pred, typename A>
+void Unserialize(Stream& is, std::map<K, T, Pred, A>& m, int nType, int nVersion)
+{
+ m.clear();
+ unsigned int nSize = ReadCompactSize(is);
+ typename std::map<K, T, Pred, A>::iterator mi = m.begin();
+ for (unsigned int i = 0; i < nSize; i++)
+ {
+ std::pair<K, T> item;
+ Unserialize(is, item, nType, nVersion);
+ mi = m.insert(mi, item);
+ }
+}
+
+
+
+//
+// set
+//
+template<typename K, typename Pred, typename A>
+unsigned int GetSerializeSize(const std::set<K, Pred, A>& m, int nType, int nVersion)
+{
+ unsigned int nSize = GetSizeOfCompactSize(m.size());
+ for (typename std::set<K, Pred, A>::const_iterator it = m.begin(); it != m.end(); ++it)
+ nSize += GetSerializeSize((*it), nType, nVersion);
+ return nSize;
+}
+
+template<typename Stream, typename K, typename Pred, typename A>
+void Serialize(Stream& os, const std::set<K, Pred, A>& m, int nType, int nVersion)
+{
+ WriteCompactSize(os, m.size());
+ for (typename std::set<K, Pred, A>::const_iterator it = m.begin(); it != m.end(); ++it)
+ Serialize(os, (*it), nType, nVersion);
+}
+
+template<typename Stream, typename K, typename Pred, typename A>
+void Unserialize(Stream& is, std::set<K, Pred, A>& m, int nType, int nVersion)
+{
+ m.clear();
+ unsigned int nSize = ReadCompactSize(is);
+ typename std::set<K, Pred, A>::iterator it = m.begin();
+ for (unsigned int i = 0; i < nSize; i++)
+ {
+ K key;
+ Unserialize(is, key, nType, nVersion);
+ it = m.insert(it, key);
+ }
+}
+
+
+
+//
+// Support for IMPLEMENT_SERIALIZE and READWRITE macro
+//
+class CSerActionGetSerializeSize { };
+class CSerActionSerialize { };
+class CSerActionUnserialize { };
+
+template<typename Stream, typename T>
+inline unsigned int SerReadWrite(Stream& s, const T& obj, int nType, int nVersion, CSerActionGetSerializeSize ser_action)
+{
+ return ::GetSerializeSize(obj, nType, nVersion);
+}
+
+template<typename Stream, typename T>
+inline unsigned int SerReadWrite(Stream& s, const T& obj, int nType, int nVersion, CSerActionSerialize ser_action)
+{
+ ::Serialize(s, obj, nType, nVersion);
+ return 0;
+}
+
+template<typename Stream, typename T>
+inline unsigned int SerReadWrite(Stream& s, T& obj, int nType, int nVersion, CSerActionUnserialize ser_action)
+{
+ ::Unserialize(s, obj, nType, nVersion);
+ return 0;
+}
+
+struct ser_streamplaceholder
+{
+ int nType;
+ int nVersion;
+};
+
+
+
+
+
+
+
+
+
+//
+// Allocator that locks its contents from being paged
+// out of memory and clears its contents before deletion.
+//
+template<typename T>
+struct secure_allocator : public std::allocator<T>
+{
+ // MSVC8 default copy constructor is broken
+ typedef std::allocator<T> base;
+ typedef typename base::size_type size_type;
+ typedef typename base::difference_type difference_type;
+ typedef typename base::pointer pointer;
+ typedef typename base::const_pointer const_pointer;
+ typedef typename base::reference reference;
+ typedef typename base::const_reference const_reference;
+ typedef typename base::value_type value_type;
+ secure_allocator() throw() {}
+ secure_allocator(const secure_allocator& a) throw() : base(a) {}
+ template <typename U>
+ secure_allocator(const secure_allocator<U>& a) throw() : base(a) {}
+ ~secure_allocator() throw() {}
+ template<typename _Other> struct rebind
+ { typedef secure_allocator<_Other> other; };
+
+ T* allocate(std::size_t n, const void *hint = 0)
+ {
+ T *p;
+ p = std::allocator<T>::allocate(n, hint);
+ if (p != NULL)
+ mlock(p, sizeof(T) * n);
+ return p;
+ }
+
+ void deallocate(T* p, std::size_t n)
+ {
+ if (p != NULL)
+ {
+ memset(p, 0, sizeof(T) * n);
+ munlock(p, sizeof(T) * n);
+ }
+ std::allocator<T>::deallocate(p, n);
+ }
+};
+
+
+//
+// Allocator that clears its contents before deletion.
+//
+template<typename T>
+struct zero_after_free_allocator : public std::allocator<T>
+{
+ // MSVC8 default copy constructor is broken
+ typedef std::allocator<T> base;
+ typedef typename base::size_type size_type;
+ typedef typename base::difference_type difference_type;
+ typedef typename base::pointer pointer;
+ typedef typename base::const_pointer const_pointer;
+ typedef typename base::reference reference;
+ typedef typename base::const_reference const_reference;
+ typedef typename base::value_type value_type;
+ zero_after_free_allocator() throw() {}
+ zero_after_free_allocator(const zero_after_free_allocator& a) throw() : base(a) {}
+ template <typename U>
+ zero_after_free_allocator(const zero_after_free_allocator<U>& a) throw() : base(a) {}
+ ~zero_after_free_allocator() throw() {}
+ template<typename _Other> struct rebind
+ { typedef zero_after_free_allocator<_Other> other; };
+
+ void deallocate(T* p, std::size_t n)
+ {
+ if (p != NULL)
+ memset(p, 0, sizeof(T) * n);
+ std::allocator<T>::deallocate(p, n);
+ }
+};
+
+
+
+//
+// Double ended buffer combining vector and stream-like interfaces.
+// >> and << read and write unformatted data using the above serialization templates.
+// Fills with data in linear time; some stringstream implementations take N^2 time.
+//
+class CDataStream
+{
+protected:
+ typedef std::vector<char, zero_after_free_allocator<char> > vector_type;
+ vector_type vch;
+ unsigned int nReadPos;
+ short state;
+ short exceptmask;
+public:
+ int nType;
+ int nVersion;
+
+ typedef vector_type::allocator_type allocator_type;
+ typedef vector_type::size_type size_type;
+ typedef vector_type::difference_type difference_type;
+ typedef vector_type::reference reference;
+ typedef vector_type::const_reference const_reference;
+ typedef vector_type::value_type value_type;
+ typedef vector_type::iterator iterator;
+ typedef vector_type::const_iterator const_iterator;
+ typedef vector_type::reverse_iterator reverse_iterator;
+
+ explicit CDataStream(int nTypeIn=SER_NETWORK, int nVersionIn=VERSION)
+ {
+ Init(nTypeIn, nVersionIn);
+ }
+
+ CDataStream(const_iterator pbegin, const_iterator pend, int nTypeIn=SER_NETWORK, int nVersionIn=VERSION) : vch(pbegin, pend)
+ {
+ Init(nTypeIn, nVersionIn);
+ }
+
+#if !defined(_MSC_VER) || _MSC_VER >= 1300
+ CDataStream(const char* pbegin, const char* pend, int nTypeIn=SER_NETWORK, int nVersionIn=VERSION) : vch(pbegin, pend)
+ {
+ Init(nTypeIn, nVersionIn);
+ }
+#endif
+
+ CDataStream(const vector_type& vchIn, int nTypeIn=SER_NETWORK, int nVersionIn=VERSION) : vch(vchIn.begin(), vchIn.end())
+ {
+ Init(nTypeIn, nVersionIn);
+ }
+
+ CDataStream(const std::vector<char>& vchIn, int nTypeIn=SER_NETWORK, int nVersionIn=VERSION) : vch(vchIn.begin(), vchIn.end())
+ {
+ Init(nTypeIn, nVersionIn);
+ }
+
+ CDataStream(const std::vector<unsigned char>& vchIn, int nTypeIn=SER_NETWORK, int nVersionIn=VERSION) : vch((char*)&vchIn.begin()[0], (char*)&vchIn.end()[0])
+ {
+ Init(nTypeIn, nVersionIn);
+ }
+
+ void Init(int nTypeIn=SER_NETWORK, int nVersionIn=VERSION)
+ {
+ nReadPos = 0;
+ nType = nTypeIn;
+ nVersion = nVersionIn;
+ state = 0;
+ exceptmask = std::ios::badbit | std::ios::failbit;
+ }
+
+ CDataStream& operator+=(const CDataStream& b)
+ {
+ vch.insert(vch.end(), b.begin(), b.end());
+ return *this;
+ }
+
+ friend CDataStream operator+(const CDataStream& a, const CDataStream& b)
+ {
+ CDataStream ret = a;
+ ret += b;
+ return (ret);
+ }
+
+ std::string str() const
+ {
+ return (std::string(begin(), end()));
+ }
+
+
+ //
+ // Vector subset
+ //
+ const_iterator begin() const { return vch.begin() + nReadPos; }
+ iterator begin() { return vch.begin() + nReadPos; }
+ const_iterator end() const { return vch.end(); }
+ iterator end() { return vch.end(); }
+ size_type size() const { return vch.size() - nReadPos; }
+ bool empty() const { return vch.size() == nReadPos; }
+ void resize(size_type n, value_type c=0) { vch.resize(n + nReadPos, c); }
+ void reserve(size_type n) { vch.reserve(n + nReadPos); }
+ const_reference operator[](size_type pos) const { return vch[pos + nReadPos]; }
+ reference operator[](size_type pos) { return vch[pos + nReadPos]; }
+ void clear() { vch.clear(); nReadPos = 0; }
+ iterator insert(iterator it, const char& x=char()) { return vch.insert(it, x); }
+ void insert(iterator it, size_type n, const char& x) { vch.insert(it, n, x); }
+
+ void insert(iterator it, const_iterator first, const_iterator last)
+ {
+ if (it == vch.begin() + nReadPos && last - first <= nReadPos)
+ {
+ // special case for inserting at the front when there's room
+ nReadPos -= (last - first);
+ memcpy(&vch[nReadPos], &first[0], last - first);
+ }
+ else
+ vch.insert(it, first, last);
+ }
+
+ void insert(iterator it, std::vector<char>::const_iterator first, std::vector<char>::const_iterator last)
+ {
+ if (it == vch.begin() + nReadPos && last - first <= nReadPos)
+ {
+ // special case for inserting at the front when there's room
+ nReadPos -= (last - first);
+ memcpy(&vch[nReadPos], &first[0], last - first);
+ }
+ else
+ vch.insert(it, first, last);
+ }
+
+#if !defined(_MSC_VER) || _MSC_VER >= 1300
+ void insert(iterator it, const char* first, const char* last)
+ {
+ if (it == vch.begin() + nReadPos && last - first <= nReadPos)
+ {
+ // special case for inserting at the front when there's room
+ nReadPos -= (last - first);
+ memcpy(&vch[nReadPos], &first[0], last - first);
+ }
+ else
+ vch.insert(it, first, last);
+ }
+#endif
+
+ iterator erase(iterator it)
+ {
+ if (it == vch.begin() + nReadPos)
+ {
+ // special case for erasing from the front
+ if (++nReadPos >= vch.size())
+ {
+ // whenever we reach the end, we take the opportunity to clear the buffer
+ nReadPos = 0;
+ return vch.erase(vch.begin(), vch.end());
+ }
+ return vch.begin() + nReadPos;
+ }
+ else
+ return vch.erase(it);
+ }
+
+ iterator erase(iterator first, iterator last)
+ {
+ if (first == vch.begin() + nReadPos)
+ {
+ // special case for erasing from the front
+ if (last == vch.end())
+ {
+ nReadPos = 0;
+ return vch.erase(vch.begin(), vch.end());
+ }
+ else
+ {
+ nReadPos = (last - vch.begin());
+ return last;
+ }
+ }
+ else
+ return vch.erase(first, last);
+ }
+
+ inline void Compact()
+ {
+ vch.erase(vch.begin(), vch.begin() + nReadPos);
+ nReadPos = 0;
+ }
+
+ bool Rewind(size_type n)
+ {
+ // Rewind by n characters if the buffer hasn't been compacted yet
+ if (n > nReadPos)
+ return false;
+ nReadPos -= n;
+ return true;
+ }
+
+
+ //
+ // Stream subset
+ //
+ void setstate(short bits, const char* psz)
+ {
+ state |= bits;
+ if (state & exceptmask)
+ throw std::ios_base::failure(psz);
+ }
+
+ bool eof() const { return size() == 0; }
+ bool fail() const { return state & (std::ios::badbit | std::ios::failbit); }
+ bool good() const { return !eof() && (state == 0); }
+ void clear(short n) { state = n; } // name conflict with vector clear()
+ short exceptions() { return exceptmask; }
+ short exceptions(short mask) { short prev = exceptmask; exceptmask = mask; setstate(0, "CDataStream"); return prev; }
+ CDataStream* rdbuf() { return this; }
+ int in_avail() { return size(); }
+
+ void SetType(int n) { nType = n; }
+ int GetType() { return nType; }
+ void SetVersion(int n) { nVersion = n; }
+ int GetVersion() { return nVersion; }
+ void ReadVersion() { *this >> nVersion; }
+ void WriteVersion() { *this << nVersion; }
+
+ CDataStream& read(char* pch, int nSize)
+ {
+ // Read from the beginning of the buffer
+ assert(nSize >= 0);
+ unsigned int nReadPosNext = nReadPos + nSize;
+ if (nReadPosNext >= vch.size())
+ {
+ if (nReadPosNext > vch.size())
+ {
+ setstate(std::ios::failbit, "CDataStream::read() : end of data");
+ memset(pch, 0, nSize);
+ nSize = vch.size() - nReadPos;
+ }
+ memcpy(pch, &vch[nReadPos], nSize);
+ nReadPos = 0;
+ vch.clear();
+ return (*this);
+ }
+ memcpy(pch, &vch[nReadPos], nSize);
+ nReadPos = nReadPosNext;
+ return (*this);
+ }
+
+ CDataStream& ignore(int nSize)
+ {
+ // Ignore from the beginning of the buffer
+ assert(nSize >= 0);
+ unsigned int nReadPosNext = nReadPos + nSize;
+ if (nReadPosNext >= vch.size())
+ {
+ if (nReadPosNext > vch.size())
+ {
+ setstate(std::ios::failbit, "CDataStream::ignore() : end of data");
+ nSize = vch.size() - nReadPos;
+ }
+ nReadPos = 0;
+ vch.clear();
+ return (*this);
+ }
+ nReadPos = nReadPosNext;
+ return (*this);
+ }
+
+ CDataStream& write(const char* pch, int nSize)
+ {
+ // Write to the end of the buffer
+ assert(nSize >= 0);
+ vch.insert(vch.end(), pch, pch + nSize);
+ return (*this);
+ }
+
+ template<typename Stream>
+ void Serialize(Stream& s, int nType=0, int nVersion=VERSION) const
+ {
+ // Special case: stream << stream concatenates like stream += stream
+ if (!vch.empty())
+ s.write((char*)&vch[0], vch.size() * sizeof(vch[0]));
+ }
+
+ template<typename T>
+ unsigned int GetSerializeSize(const T& obj)
+ {
+ // Tells the size of the object if serialized to this stream
+ return ::GetSerializeSize(obj, nType, nVersion);
+ }
+
+ template<typename T>
+ CDataStream& operator<<(const T& obj)
+ {
+ // Serialize to this stream
+ ::Serialize(*this, obj, nType, nVersion);
+ return (*this);
+ }
+
+ template<typename T>
+ CDataStream& operator>>(T& obj)
+ {
+ // Unserialize from this stream
+ ::Unserialize(*this, obj, nType, nVersion);
+ return (*this);
+ }
+};
+
+#ifdef TESTCDATASTREAM
+// VC6sp6
+// CDataStream:
+// n=1000 0 seconds
+// n=2000 0 seconds
+// n=4000 0 seconds
+// n=8000 0 seconds
+// n=16000 0 seconds
+// n=32000 0 seconds
+// n=64000 1 seconds
+// n=128000 1 seconds
+// n=256000 2 seconds
+// n=512000 4 seconds
+// n=1024000 8 seconds
+// n=2048000 16 seconds
+// n=4096000 32 seconds
+// stringstream:
+// n=1000 1 seconds
+// n=2000 1 seconds
+// n=4000 13 seconds
+// n=8000 87 seconds
+// n=16000 400 seconds
+// n=32000 1660 seconds
+// n=64000 6749 seconds
+// n=128000 27241 seconds
+// n=256000 109804 seconds
+#include <iostream>
+int main(int argc, char *argv[])
+{
+ vector<unsigned char> vch(0xcc, 250);
+ printf("CDataStream:\n");
+ for (int n = 1000; n <= 4500000; n *= 2)
+ {
+ CDataStream ss;
+ time_t nStart = time(NULL);
+ for (int i = 0; i < n; i++)
+ ss.write((char*)&vch[0], vch.size());
+ printf("n=%-10d %d seconds\n", n, time(NULL) - nStart);
+ }
+ printf("stringstream:\n");
+ for (int n = 1000; n <= 4500000; n *= 2)
+ {
+ stringstream ss;
+ time_t nStart = time(NULL);
+ for (int i = 0; i < n; i++)
+ ss.write((char*)&vch[0], vch.size());
+ printf("n=%-10d %d seconds\n", n, time(NULL) - nStart);
+ }
+}
+#endif
+
+
+
+
+
+
+
+
+
+
+//
+// Automatic closing wrapper for FILE*
+// - Will automatically close the file when it goes out of scope if not null.
+// - If you're returning the file pointer, return file.release().
+// - If you need to close the file early, use file.fclose() instead of fclose(file).
+//
+class CAutoFile
+{
+protected:
+ FILE* file;
+ short state;
+ short exceptmask;
+public:
+ int nType;
+ int nVersion;
+
+ typedef FILE element_type;
+
+ CAutoFile(FILE* filenew=NULL, int nTypeIn=SER_DISK, int nVersionIn=VERSION)
+ {
+ file = filenew;
+ nType = nTypeIn;
+ nVersion = nVersionIn;
+ state = 0;
+ exceptmask = std::ios::badbit | std::ios::failbit;
+ }
+
+ ~CAutoFile()
+ {
+ fclose();
+ }
+
+ void fclose()
+ {
+ if (file != NULL && file != stdin && file != stdout && file != stderr)
+ ::fclose(file);
+ file = NULL;
+ }
+
+ FILE* release() { FILE* ret = file; file = NULL; return ret; }
+ operator FILE*() { return file; }
+ FILE* operator->() { return file; }
+ FILE& operator*() { return *file; }
+ FILE** operator&() { return &file; }
+ FILE* operator=(FILE* pnew) { return file = pnew; }
+ bool operator!() { return (file == NULL); }
+
+
+ //
+ // Stream subset
+ //
+ void setstate(short bits, const char* psz)
+ {
+ state |= bits;
+ if (state & exceptmask)
+ throw std::ios_base::failure(psz);
+ }
+
+ bool fail() const { return state & (std::ios::badbit | std::ios::failbit); }
+ bool good() const { return state == 0; }
+ void clear(short n = 0) { state = n; }
+ short exceptions() { return exceptmask; }
+ short exceptions(short mask) { short prev = exceptmask; exceptmask = mask; setstate(0, "CAutoFile"); return prev; }
+
+ void SetType(int n) { nType = n; }
+ int GetType() { return nType; }
+ void SetVersion(int n) { nVersion = n; }
+ int GetVersion() { return nVersion; }
+ void ReadVersion() { *this >> nVersion; }
+ void WriteVersion() { *this << nVersion; }
+
+ CAutoFile& read(char* pch, int nSize)
+ {
+ if (!file)
+ throw std::ios_base::failure("CAutoFile::read : file handle is NULL");
+ if (fread(pch, 1, nSize, file) != nSize)
+ setstate(std::ios::failbit, feof(file) ? "CAutoFile::read : end of file" : "CAutoFile::read : fread failed");
+ return (*this);
+ }
+
+ CAutoFile& write(const char* pch, int nSize)
+ {
+ if (!file)
+ throw std::ios_base::failure("CAutoFile::write : file handle is NULL");
+ if (fwrite(pch, 1, nSize, file) != nSize)
+ setstate(std::ios::failbit, "CAutoFile::write : write failed");
+ return (*this);
+ }
+
+ template<typename T>
+ unsigned int GetSerializeSize(const T& obj)
+ {
+ // Tells the size of the object if serialized to this stream
+ return ::GetSerializeSize(obj, nType, nVersion);
+ }
+
+ template<typename T>
+ CAutoFile& operator<<(const T& obj)
+ {
+ // Serialize to this stream
+ if (!file)
+ throw std::ios_base::failure("CAutoFile::operator<< : file handle is NULL");
+ ::Serialize(*this, obj, nType, nVersion);
+ return (*this);
+ }
+
+ template<typename T>
+ CAutoFile& operator>>(T& obj)
+ {
+ // Unserialize from this stream
+ if (!file)
+ throw std::ios_base::failure("CAutoFile::operator>> : file handle is NULL");
+ ::Unserialize(*this, obj, nType, nVersion);
+ return (*this);
+ }
+};
+
+#endif
diff --git a/bitcoin/src/strlcpy.h b/bitcoin/src/strlcpy.h
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+#ifndef BITCOIN_STRLCPY_H
+#define BITCOIN_STRLCPY_H
+/*
+ * Copy src to string dst of size siz. At most siz-1 characters
+ * will be copied. Always NUL terminates (unless siz == 0).
+ * Returns strlen(src); if retval >= siz, truncation occurred.
+ */
+inline size_t strlcpy(char *dst, const char *src, size_t siz)
+{
+ char *d = dst;
+ const char *s = src;
+ size_t n = siz;
+
+ /* Copy as many bytes as will fit */
+ if (n != 0)
+ {
+ while (--n != 0)
+ {
+ if ((*d++ = *s++) == '\0')
+ break;
+ }
+ }
+
+ /* Not enough room in dst, add NUL and traverse rest of src */
+ if (n == 0)
+ {
+ if (siz != 0)
+ *d = '\0'; /* NUL-terminate dst */
+ while (*s++)
+ ;
+ }
+
+ return(s - src - 1); /* count does not include NUL */
+}
+
+/*
+ * Appends src to string dst of size siz (unlike strncat, siz is the
+ * full size of dst, not space left). At most siz-1 characters
+ * will be copied. Always NUL terminates (unless siz <= strlen(dst)).
+ * Returns strlen(src) + MIN(siz, strlen(initial dst)).
+ * If retval >= siz, truncation occurred.
+ */
+inline size_t strlcat(char *dst, const char *src, size_t siz)
+{
+ char *d = dst;
+ const char *s = src;
+ size_t n = siz;
+ size_t dlen;
+
+ /* Find the end of dst and adjust bytes left but don't go past end */
+ while (n-- != 0 && *d != '\0')
+ d++;
+ dlen = d - dst;
+ n = siz - dlen;
+
+ if (n == 0)
+ return(dlen + strlen(s));
+ while (*s != '\0')
+ {
+ if (n != 1)
+ {
+ *d++ = *s;
+ n--;
+ }
+ s++;
+ }
+ *d = '\0';
+
+ return(dlen + (s - src)); /* count does not include NUL */
+}
+#endif
diff --git a/bitcoin/src/test/Checkpoints_tests.cpp b/bitcoin/src/test/Checkpoints_tests.cpp
@@ -0,0 +1,34 @@
+//
+// Unit tests for block-chain checkpoints
+//
+#include <boost/assign/list_of.hpp> // for 'map_list_of()'
+#include <boost/test/unit_test.hpp>
+#include <boost/foreach.hpp>
+
+#include "../checkpoints.h"
+#include "../util.h"
+
+using namespace std;
+
+BOOST_AUTO_TEST_SUITE(Checkpoints_tests)
+
+BOOST_AUTO_TEST_CASE(sanity)
+{
+ uint256 p11111 = uint256("0x0000000069e244f73d78e8fd29ba2fd2ed618bd6fa2ee92559f542fdb26e7c1d");
+ uint256 p140700 = uint256("0x000000000000033b512028abb90e1626d8b346fd0ed598ac0a3c371138dce2bd");
+ BOOST_CHECK(Checkpoints::CheckBlock(11111, p11111));
+ BOOST_CHECK(Checkpoints::CheckBlock(140700, p140700));
+
+
+ // Wrong hashes at checkpoints should fail:
+ BOOST_CHECK(!Checkpoints::CheckBlock(11111, p140700));
+ BOOST_CHECK(!Checkpoints::CheckBlock(140700, p11111));
+
+ // ... but any hash not at a checkpoint should succeed:
+ BOOST_CHECK(Checkpoints::CheckBlock(11111+1, p140700));
+ BOOST_CHECK(Checkpoints::CheckBlock(140700+1, p11111));
+
+ BOOST_CHECK(Checkpoints::GetTotalBlocksEstimate() >= 140700);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/bitcoin/src/test/DoS_tests.cpp b/bitcoin/src/test/DoS_tests.cpp
@@ -0,0 +1,118 @@
+//
+// Unit tests for denial-of-service detection/prevention code
+//
+#include <boost/assign/list_of.hpp> // for 'map_list_of()'
+#include <boost/test/unit_test.hpp>
+#include <boost/foreach.hpp>
+
+#include "../main.h"
+#include "../net.h"
+#include "../util.h"
+
+using namespace std;
+
+BOOST_AUTO_TEST_SUITE(DoS_tests)
+
+BOOST_AUTO_TEST_CASE(DoS_banning)
+{
+ CNode::ClearBanned();
+ CAddress addr1(0xa0b0c001);
+ CNode dummyNode1(INVALID_SOCKET, addr1, true);
+ dummyNode1.Misbehaving(100); // Should get banned
+ BOOST_CHECK(CNode::IsBanned(addr1.ip));
+ BOOST_CHECK(!CNode::IsBanned(addr1.ip|0x0000ff00)); // Different ip, not banned
+
+ CAddress addr2(0xa0b0c002);
+ CNode dummyNode2(INVALID_SOCKET, addr2, true);
+ dummyNode2.Misbehaving(50);
+ BOOST_CHECK(!CNode::IsBanned(addr2.ip)); // 2 not banned yet...
+ BOOST_CHECK(CNode::IsBanned(addr1.ip)); // ... but 1 still should be
+ dummyNode2.Misbehaving(50);
+ BOOST_CHECK(CNode::IsBanned(addr2.ip));
+}
+
+BOOST_AUTO_TEST_CASE(DoS_banscore)
+{
+ CNode::ClearBanned();
+ mapArgs["-banscore"] = "111"; // because 11 is my favorite number
+ CAddress addr1(0xa0b0c001);
+ CNode dummyNode1(INVALID_SOCKET, addr1, true);
+ dummyNode1.Misbehaving(100);
+ BOOST_CHECK(!CNode::IsBanned(addr1.ip));
+ dummyNode1.Misbehaving(10);
+ BOOST_CHECK(!CNode::IsBanned(addr1.ip));
+ dummyNode1.Misbehaving(1);
+ BOOST_CHECK(CNode::IsBanned(addr1.ip));
+ mapArgs["-banscore"] = "100";
+}
+
+BOOST_AUTO_TEST_CASE(DoS_bantime)
+{
+ CNode::ClearBanned();
+ int64 nStartTime = GetTime();
+ SetMockTime(nStartTime); // Overrides future calls to GetTime()
+
+ CAddress addr(0xa0b0c001);
+ CNode dummyNode(INVALID_SOCKET, addr, true);
+
+ dummyNode.Misbehaving(100);
+ BOOST_CHECK(CNode::IsBanned(addr.ip));
+
+ SetMockTime(nStartTime+60*60);
+ BOOST_CHECK(CNode::IsBanned(addr.ip));
+
+ SetMockTime(nStartTime+60*60*24+1);
+ BOOST_CHECK(!CNode::IsBanned(addr.ip));
+}
+
+static bool CheckNBits(unsigned int nbits1, int64 time1, unsigned int nbits2, int64 time2)
+{
+ if (time1 > time2)
+ return CheckNBits(nbits2, time2, nbits1, time1);
+ int64 deltaTime = time2-time1;
+
+ CBigNum required;
+ required.SetCompact(ComputeMinWork(nbits1, deltaTime));
+ CBigNum have;
+ have.SetCompact(nbits2);
+ return (have <= required);
+}
+
+BOOST_AUTO_TEST_CASE(DoS_checknbits)
+{
+ using namespace boost::assign; // for 'map_list_of()'
+
+ // Timestamps,nBits from the bitcoin blockchain.
+ // These are the block-chain checkpoint blocks
+ typedef std::map<int64, unsigned int> BlockData;
+ BlockData chainData =
+ map_list_of(1239852051,486604799)(1262749024,486594666)
+ (1279305360,469854461)(1280200847,469830746)(1281678674,469809688)
+ (1296207707,453179945)(1302624061,453036989)(1309640330,437004818)
+ (1313172719,436789733);
+
+ // Make sure CheckNBits considers every combination of block-chain-lock-in-points
+ // "sane":
+ BOOST_FOREACH(const BlockData::value_type& i, chainData)
+ {
+ BOOST_FOREACH(const BlockData::value_type& j, chainData)
+ {
+ BOOST_CHECK(CheckNBits(i.second, i.first, j.second, j.first));
+ }
+ }
+
+ // Test a couple of insane combinations:
+ BlockData::value_type firstcheck = *(chainData.begin());
+ BlockData::value_type lastcheck = *(chainData.rbegin());
+
+ // First checkpoint difficulty at or a while after the last checkpoint time should fail when
+ // compared to last checkpoint
+ BOOST_CHECK(!CheckNBits(firstcheck.second, lastcheck.first+60*10, lastcheck.second, lastcheck.first));
+ BOOST_CHECK(!CheckNBits(firstcheck.second, lastcheck.first+60*60*24*14, lastcheck.second, lastcheck.first));
+
+ // ... but OK if enough time passed for difficulty to adjust downward:
+ BOOST_CHECK(CheckNBits(firstcheck.second, lastcheck.first+60*60*24*365*4, lastcheck.second, lastcheck.first));
+
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/bitcoin/src/test/README b/bitcoin/src/test/README
@@ -0,0 +1,21 @@
+The sources in this directory are unit test cases. Boost includes a
+unit testing framework, and since bitcoin already uses boost, it makes
+sense to simply use this framework rather than require developers to
+configure some other framework (we want as few impediments to creating
+unit tests as possible).
+
+The build system is setup to compile an executable called "test_bitcoin"
+that runs all of the unit tests. The main source file is called
+test_bitcoin.cpp, which simply includes other files that contain the
+actual unit tests (outside of a couple required preprocessor
+directives). The pattern is to create one test file for each class or
+source file for which you want to create unit tests. The file naming
+convention is "<source_filename>_tests.cpp" and such files should wrap
+their tests in a test suite called "<source_filename>_tests". For an
+examples of this pattern, examine uint160_tests.cpp and
+uint256_tests.cpp.
+
+For further reading, I found the following website to be helpful in
+explaining how the boost unit test framework works:
+
+http://www.alittlemadness.com/2009/03/31/c-unit-testing-with-boosttest/
diff --git a/bitcoin/src/test/base58_tests.cpp b/bitcoin/src/test/base58_tests.cpp
@@ -0,0 +1,87 @@
+#include <boost/test/unit_test.hpp>
+
+#include "../util.h"
+
+BOOST_AUTO_TEST_SUITE(base58_tests)
+
+// TODO:
+// EncodeBase58Check
+// DecodeBase58Check
+// CBase58Data
+// bool SetString(const char* psz)
+ // bool SetString(const std::string& str)
+ // std::string ToString() const
+ // int CompareTo(const CBase58Data& b58) const
+ // bool operator==(const CBase58Data& b58) const
+ // bool operator<=(const CBase58Data& b58) const
+ // bool operator>=(const CBase58Data& b58) const
+ // bool operator< (const CBase58Data& b58) const
+ // bool operator> (const CBase58Data& b58) const
+
+// CBitcoinAddress
+ // bool SetHash160(const uint160& hash160)
+ // bool SetPubKey(const std::vector<unsigned char>& vchPubKey)
+ // bool IsValid() const
+ // CBitcoinAddress()
+ // CBitcoinAddress(uint160 hash160In)
+ // CBitcoinAddress(const std::vector<unsigned char>& vchPubKey)
+ // CBitcoinAddress(const std::string& strAddress)
+ // CBitcoinAddress(const char* pszAddress)
+ // uint160 GetHash160() const
+
+#define U(x) (reinterpret_cast<const unsigned char*>(x))
+static struct {
+ const unsigned char *data;
+ int size;
+} vstrIn[] = {
+{U(""), 0},
+{U("\x61"), 1},
+{U("\x62\x62\x62"), 3},
+{U("\x63\x63\x63"), 3},
+{U("\x73\x69\x6d\x70\x6c\x79\x20\x61\x20\x6c\x6f\x6e\x67\x20\x73\x74\x72\x69\x6e\x67"), 20},
+{U("\x00\xeb\x15\x23\x1d\xfc\xeb\x60\x92\x58\x86\xb6\x7d\x06\x52\x99\x92\x59\x15\xae\xb1\x72\xc0\x66\x47"), 25},
+{U("\x51\x6b\x6f\xcd\x0f"), 5},
+{U("\xbf\x4f\x89\x00\x1e\x67\x02\x74\xdd"), 9},
+{U("\x57\x2e\x47\x94"), 4},
+{U("\xec\xac\x89\xca\xd9\x39\x23\xc0\x23\x21"), 10},
+{U("\x10\xc8\x51\x1e"), 4},
+{U("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"), 10},
+};
+
+const char *vstrOut[] = {
+"",
+"2g",
+"a3gV",
+"aPEr",
+"2cFupjhnEsSn59qHXstmK2ffpLv2",
+"1NS17iag9jJgTHD1VXjvLCEnZuQ3rJDE9L",
+"ABnLTmg",
+"3SEo3LWLoPntC",
+"3EFU7m",
+"EJDM8drfXA6uyA",
+"Rt5zm",
+"1111111111"
+};
+
+BOOST_AUTO_TEST_CASE(base58_EncodeBase58)
+{
+ for (int i=0; i<sizeof(vstrIn)/sizeof(vstrIn[0]); i++)
+ {
+ BOOST_CHECK_EQUAL(EncodeBase58(vstrIn[i].data, vstrIn[i].data + vstrIn[i].size), vstrOut[i]);
+ }
+}
+
+BOOST_AUTO_TEST_CASE(base58_DecodeBase58)
+{
+ std::vector<unsigned char> result;
+ for (int i=0; i<sizeof(vstrIn)/sizeof(vstrIn[0]); i++)
+ {
+ std::vector<unsigned char> expected(vstrIn[i].data, vstrIn[i].data + vstrIn[i].size);
+ BOOST_CHECK(DecodeBase58(vstrOut[i], result));
+ BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
+ }
+ BOOST_CHECK(!DecodeBase58("invalid", result));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
diff --git a/bitcoin/src/test/base64_tests.cpp b/bitcoin/src/test/base64_tests.cpp
@@ -0,0 +1,20 @@
+#include <boost/test/unit_test.hpp>
+
+#include "../util.h"
+
+BOOST_AUTO_TEST_SUITE(base64_tests)
+
+BOOST_AUTO_TEST_CASE(base64_testvectors)
+{
+ static const string vstrIn[] = {"","f","fo","foo","foob","fooba","foobar"};
+ static const string vstrOut[] = {"","Zg==","Zm8=","Zm9v","Zm9vYg==","Zm9vYmE=","Zm9vYmFy"};
+ for (int i=0; i<sizeof(vstrIn)/sizeof(vstrIn[0]); i++)
+ {
+ string strEnc = EncodeBase64(vstrIn[i]);
+ BOOST_CHECK(strEnc == vstrOut[i]);
+ string strDec = DecodeBase64(strEnc);
+ BOOST_CHECK(strDec == vstrIn[i]);
+ }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/bitcoin/src/test/miner_tests.cpp b/bitcoin/src/test/miner_tests.cpp
@@ -0,0 +1,35 @@
+#include <boost/test/unit_test.hpp>
+
+#include "../uint256.h"
+
+extern void SHA256Transform(void* pstate, void* pinput, const void* pinit);
+
+BOOST_AUTO_TEST_SUITE(miner_tests)
+
+BOOST_AUTO_TEST_CASE(sha256transform_equality)
+{
+ unsigned int pSHA256InitState[8] = {0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
+
+
+ unsigned char pstate[32];
+ unsigned char pinput[64];
+
+ int i;
+
+ for (i = 0; i < 32; i++) {
+ pinput[i] = i;
+ pinput[i+32] = 0;
+ }
+
+ uint256 hash;
+
+ SHA256Transform(&hash, pinput, pSHA256InitState);
+
+ BOOST_TEST_MESSAGE(hash.GetHex());
+
+ uint256 hash_reference("0x2df5e1c65ef9f8cde240d23cae2ec036d31a15ec64bc68f64be242b1da6631f3");
+
+ BOOST_CHECK(hash == hash_reference);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/bitcoin/src/test/script_tests.cpp b/bitcoin/src/test/script_tests.cpp
@@ -0,0 +1,173 @@
+#include <vector>
+#include <boost/test/unit_test.hpp>
+#include <boost/foreach.hpp>
+
+#include "../main.h"
+#include "../wallet.h"
+
+using namespace std;
+extern uint256 SignatureHash(CScript scriptCode, const CTransaction& txTo, unsigned int nIn, int nHashType);
+extern bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, const CTransaction& txTo, unsigned int nIn, int nHashType);
+extern bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, int nHashType);
+
+BOOST_AUTO_TEST_SUITE(script_tests)
+
+BOOST_AUTO_TEST_CASE(script_PushData)
+{
+ // Check that PUSHDATA1, PUSHDATA2, and PUSHDATA4 create the same value on
+ // the stack as the 1-75 opcodes do.
+ static const unsigned char direct[] = { 1, 0x5a };
+ static const unsigned char pushdata1[] = { OP_PUSHDATA1, 1, 0x5a };
+ static const unsigned char pushdata2[] = { OP_PUSHDATA2, 1, 0, 0x5a };
+ static const unsigned char pushdata4[] = { OP_PUSHDATA4, 1, 0, 0, 0, 0x5a };
+
+ vector<vector<unsigned char> > directStack;
+ BOOST_CHECK(EvalScript(directStack, CScript(&direct[0], &direct[sizeof(direct)]), CTransaction(), 0, 0));
+
+ vector<vector<unsigned char> > pushdata1Stack;
+ BOOST_CHECK(EvalScript(pushdata1Stack, CScript(&pushdata1[0], &pushdata1[sizeof(pushdata1)]), CTransaction(), 0, 0));
+ BOOST_CHECK(pushdata1Stack == directStack);
+
+ vector<vector<unsigned char> > pushdata2Stack;
+ BOOST_CHECK(EvalScript(pushdata2Stack, CScript(&pushdata2[0], &pushdata2[sizeof(pushdata2)]), CTransaction(), 0, 0));
+ BOOST_CHECK(pushdata2Stack == directStack);
+
+ vector<vector<unsigned char> > pushdata4Stack;
+ BOOST_CHECK(EvalScript(pushdata4Stack, CScript(&pushdata4[0], &pushdata4[sizeof(pushdata4)]), CTransaction(), 0, 0));
+ BOOST_CHECK(pushdata4Stack == directStack);
+}
+
+CScript
+sign_multisig(CScript scriptPubKey, std::vector<CKey> keys, CTransaction transaction)
+{
+ uint256 hash = SignatureHash(scriptPubKey, transaction, 0, SIGHASH_ALL);
+
+ CScript result;
+ //
+ // NOTE: CHECKMULTISIG has an unfortunate bug; it requires
+ // one extra item on the stack, before the signatures.
+ // Putting OP_0 on the stack is the workaround;
+ // fixing the bug would mean splitting the blockchain (old
+ // clients would not accept new CHECKMULTISIG transactions,
+ // and vice-versa)
+ //
+ result << OP_0;
+ BOOST_FOREACH(CKey key, keys)
+ {
+ vector<unsigned char> vchSig;
+ BOOST_CHECK(key.Sign(hash, vchSig));
+ vchSig.push_back((unsigned char)SIGHASH_ALL);
+ result << vchSig;
+ }
+ return result;
+}
+CScript
+sign_multisig(CScript scriptPubKey, CKey key, CTransaction transaction)
+{
+ std::vector<CKey> keys;
+ keys.push_back(key);
+ return sign_multisig(scriptPubKey, keys, transaction);
+}
+
+BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG12)
+{
+ CKey key1, key2, key3;
+ key1.MakeNewKey();
+ key2.MakeNewKey();
+ key3.MakeNewKey();
+
+ CScript scriptPubKey12;
+ scriptPubKey12 << OP_1 << key1.GetPubKey() << key2.GetPubKey() << OP_2 << OP_CHECKMULTISIG;
+
+ CTransaction txFrom12;
+ txFrom12.vout.resize(1);
+ txFrom12.vout[0].scriptPubKey = scriptPubKey12;
+
+ CTransaction txTo12;
+ txTo12.vin.resize(1);
+ txTo12.vout.resize(1);
+ txTo12.vin[0].prevout.n = 0;
+ txTo12.vin[0].prevout.hash = txFrom12.GetHash();
+ txTo12.vout[0].nValue = 1;
+
+ CScript goodsig1 = sign_multisig(scriptPubKey12, key1, txTo12);
+ BOOST_CHECK(VerifyScript(goodsig1, scriptPubKey12, txTo12, 0, 0));
+ txTo12.vout[0].nValue = 2;
+ BOOST_CHECK(!VerifyScript(goodsig1, scriptPubKey12, txTo12, 0, 0));
+
+ CScript goodsig2 = sign_multisig(scriptPubKey12, key2, txTo12);
+ BOOST_CHECK(VerifyScript(goodsig2, scriptPubKey12, txTo12, 0, 0));
+
+ CScript badsig1 = sign_multisig(scriptPubKey12, key3, txTo12);
+ BOOST_CHECK(!VerifyScript(badsig1, scriptPubKey12, txTo12, 0, 0));
+}
+
+BOOST_AUTO_TEST_CASE(script_CHECKMULTISIG23)
+{
+ CKey key1, key2, key3, key4;
+ key1.MakeNewKey();
+ key2.MakeNewKey();
+ key3.MakeNewKey();
+ key4.MakeNewKey();
+
+ CScript scriptPubKey23;
+ scriptPubKey23 << OP_2 << key1.GetPubKey() << key2.GetPubKey() << key3.GetPubKey() << OP_3 << OP_CHECKMULTISIG;
+
+ CTransaction txFrom23;
+ txFrom23.vout.resize(1);
+ txFrom23.vout[0].scriptPubKey = scriptPubKey23;
+
+ CTransaction txTo23;
+ txTo23.vin.resize(1);
+ txTo23.vout.resize(1);
+ txTo23.vin[0].prevout.n = 0;
+ txTo23.vin[0].prevout.hash = txFrom23.GetHash();
+ txTo23.vout[0].nValue = 1;
+
+ std::vector<CKey> keys;
+ keys.push_back(key1); keys.push_back(key2);
+ CScript goodsig1 = sign_multisig(scriptPubKey23, keys, txTo23);
+ BOOST_CHECK(VerifyScript(goodsig1, scriptPubKey23, txTo23, 0, 0));
+
+ keys.clear();
+ keys.push_back(key1); keys.push_back(key3);
+ CScript goodsig2 = sign_multisig(scriptPubKey23, keys, txTo23);
+ BOOST_CHECK(VerifyScript(goodsig2, scriptPubKey23, txTo23, 0, 0));
+
+ keys.clear();
+ keys.push_back(key2); keys.push_back(key3);
+ CScript goodsig3 = sign_multisig(scriptPubKey23, keys, txTo23);
+ BOOST_CHECK(VerifyScript(goodsig3, scriptPubKey23, txTo23, 0, 0));
+
+ keys.clear();
+ keys.push_back(key2); keys.push_back(key2); // Can't re-use sig
+ CScript badsig1 = sign_multisig(scriptPubKey23, keys, txTo23);
+ BOOST_CHECK(!VerifyScript(badsig1, scriptPubKey23, txTo23, 0, 0));
+
+ keys.clear();
+ keys.push_back(key2); keys.push_back(key1); // sigs must be in correct order
+ CScript badsig2 = sign_multisig(scriptPubKey23, keys, txTo23);
+ BOOST_CHECK(!VerifyScript(badsig2, scriptPubKey23, txTo23, 0, 0));
+
+ keys.clear();
+ keys.push_back(key3); keys.push_back(key2); // sigs must be in correct order
+ CScript badsig3 = sign_multisig(scriptPubKey23, keys, txTo23);
+ BOOST_CHECK(!VerifyScript(badsig3, scriptPubKey23, txTo23, 0, 0));
+
+ keys.clear();
+ keys.push_back(key4); keys.push_back(key2); // sigs must match pubkeys
+ CScript badsig4 = sign_multisig(scriptPubKey23, keys, txTo23);
+ BOOST_CHECK(!VerifyScript(badsig4, scriptPubKey23, txTo23, 0, 0));
+
+ keys.clear();
+ keys.push_back(key1); keys.push_back(key4); // sigs must match pubkeys
+ CScript badsig5 = sign_multisig(scriptPubKey23, keys, txTo23);
+ BOOST_CHECK(!VerifyScript(badsig5, scriptPubKey23, txTo23, 0, 0));
+
+ keys.clear(); // Must have signatures
+ CScript badsig6 = sign_multisig(scriptPubKey23, keys, txTo23);
+ BOOST_CHECK(!VerifyScript(badsig6, scriptPubKey23, txTo23, 0, 0));
+}
+
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/bitcoin/src/test/test_bitcoin.cpp b/bitcoin/src/test/test_bitcoin.cpp
@@ -0,0 +1,23 @@
+#define BOOST_TEST_MODULE Bitcoin Test Suite
+#include <boost/test/unit_test.hpp>
+
+#include "../main.h"
+#include "../wallet.h"
+
+#include "uint160_tests.cpp"
+#include "uint256_tests.cpp"
+#include "script_tests.cpp"
+#include "transaction_tests.cpp"
+#include "DoS_tests.cpp"
+#include "base64_tests.cpp"
+#include "util_tests.cpp"
+#include "base58_tests.cpp"
+#include "miner_tests.cpp"
+#include "Checkpoints_tests.cpp"
+
+CWallet* pwalletMain;
+
+void Shutdown(void* parg)
+{
+ exit(0);
+}
diff --git a/bitcoin/src/test/transaction_tests.cpp b/bitcoin/src/test/transaction_tests.cpp
@@ -0,0 +1,25 @@
+#include <boost/test/unit_test.hpp>
+
+#include "../main.h"
+#include "../wallet.h"
+
+using namespace std;
+
+BOOST_AUTO_TEST_SUITE(transaction_tests)
+
+BOOST_AUTO_TEST_CASE(basic_transaction_tests)
+{
+ // Random real transaction (e2769b09e784f32f62ef849763d4f45b98e07ba658647343b915ff832b110436)
+ unsigned char ch[] = {0x01, 0x00, 0x00, 0x00, 0x01, 0x6b, 0xff, 0x7f, 0xcd, 0x4f, 0x85, 0x65, 0xef, 0x40, 0x6d, 0xd5, 0xd6, 0x3d, 0x4f, 0xf9, 0x4f, 0x31, 0x8f, 0xe8, 0x20, 0x27, 0xfd, 0x4d, 0xc4, 0x51, 0xb0, 0x44, 0x74, 0x01, 0x9f, 0x74, 0xb4, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x49, 0x30, 0x46, 0x02, 0x21, 0x00, 0xda, 0x0d, 0xc6, 0xae, 0xce, 0xfe, 0x1e, 0x06, 0xef, 0xdf, 0x05, 0x77, 0x37, 0x57, 0xde, 0xb1, 0x68, 0x82, 0x09, 0x30, 0xe3, 0xb0, 0xd0, 0x3f, 0x46, 0xf5, 0xfc, 0xf1, 0x50, 0xbf, 0x99, 0x0c, 0x02, 0x21, 0x00, 0xd2, 0x5b, 0x5c, 0x87, 0x04, 0x00, 0x76, 0xe4, 0xf2, 0x53, 0xf8, 0x26, 0x2e, 0x76, 0x3e, 0x2d, 0xd5, 0x1e, 0x7f, 0xf0, 0xbe, 0x15, 0x77, 0x27, 0xc4, 0xbc, 0x42, 0x80, 0x7f, 0x17, 0xbd, 0x39, 0x01, 0x41, 0x04, 0xe6, 0xc2, 0x6e, 0xf6, 0x7d, 0xc6, 0x10, 0xd2, 0xcd, 0x19, 0x24, 0x84, 0x78, 0x9a, 0x6c, 0xf9, 0xae, 0xa9, 0x93, 0x0b, 0x94, 0x4b, 0x7e, 0x2d, 0xb5, 0x34, 0x2b, 0x9d, 0x9e, 0x5b, 0x9f, 0xf7, 0x9a, 0xff, 0x9a, 0x2e, 0xe1, 0x97, 0x8d, 0xd7, 0xfd, 0x01, 0xdf, 0xc5, 0x22, 0xee, 0x02, 0x28, 0x3d, 0x3b, 0x06, 0xa9, 0xd0, 0x3a, 0xcf, 0x80, 0x96, 0x96, 0x8d, 0x7d, 0xbb, 0x0f, 0x91, 0x78, 0xff, 0xff, 0xff, 0xff, 0x02, 0x8b, 0xa7, 0x94, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14, 0xba, 0xde, 0xec, 0xfd, 0xef, 0x05, 0x07, 0x24, 0x7f, 0xc8, 0xf7, 0x42, 0x41, 0xd7, 0x3b, 0xc0, 0x39, 0x97, 0x2d, 0x7b, 0x88, 0xac, 0x40, 0x94, 0xa8, 0x02, 0x00, 0x00, 0x00, 0x00, 0x19, 0x76, 0xa9, 0x14, 0xc1, 0x09, 0x32, 0x48, 0x3f, 0xec, 0x93, 0xed, 0x51, 0xf5, 0xfe, 0x95, 0xe7, 0x25, 0x59, 0xf2, 0xcc, 0x70, 0x43, 0xf9, 0x88, 0xac, 0x00, 0x00, 0x00, 0x00, 0x00};
+ vector<unsigned char> vch(ch, ch + sizeof(ch) -1);
+ CDataStream stream(vch);
+ CTransaction tx;
+ stream >> tx;
+ BOOST_CHECK_MESSAGE(tx.CheckTransaction(), "Simple deserialized transaction should be valid.");
+
+ // Check that duplicate txins fail
+ tx.vin.push_back(tx.vin[0]);
+ BOOST_CHECK_MESSAGE(!tx.CheckTransaction(), "Transaction with duplicate txins should be invalid.");
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/bitcoin/src/test/uint160_tests.cpp b/bitcoin/src/test/uint160_tests.cpp
@@ -0,0 +1,18 @@
+#include <boost/test/unit_test.hpp>
+
+#include "../uint256.h"
+
+BOOST_AUTO_TEST_SUITE(uint160_tests)
+
+BOOST_AUTO_TEST_CASE(uint160_equality)
+{
+ uint160 num1 = 10;
+ uint160 num2 = 11;
+ BOOST_CHECK(num1+1 == num2);
+
+ uint64 num3 = 10;
+ BOOST_CHECK(num1 == num3);
+ BOOST_CHECK(num1+num2 == num3+num2);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/bitcoin/src/test/uint256_tests.cpp b/bitcoin/src/test/uint256_tests.cpp
@@ -0,0 +1,18 @@
+#include <boost/test/unit_test.hpp>
+
+#include "../uint256.h"
+
+BOOST_AUTO_TEST_SUITE(uint256_tests)
+
+BOOST_AUTO_TEST_CASE(uint256_equality)
+{
+ uint256 num1 = 10;
+ uint256 num2 = 11;
+ BOOST_CHECK(num1+1 == num2);
+
+ uint64 num3 = 10;
+ BOOST_CHECK(num1 == num3);
+ BOOST_CHECK(num1+num2 == num3+num2);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/bitcoin/src/test/util_tests.cpp b/bitcoin/src/test/util_tests.cpp
@@ -0,0 +1,233 @@
+#include <vector>
+#include <boost/test/unit_test.hpp>
+#include <boost/foreach.hpp>
+
+#include "../util.h"
+
+using namespace std;
+
+BOOST_AUTO_TEST_SUITE(util_tests)
+
+BOOST_AUTO_TEST_CASE(util_criticalsection)
+{
+ CCriticalSection cs;
+
+ do {
+ CRITICAL_BLOCK(cs)
+ break;
+
+ BOOST_ERROR("break was swallowed!");
+ } while(0);
+
+ do {
+ TRY_CRITICAL_BLOCK(cs)
+ break;
+
+ BOOST_ERROR("break was swallowed!");
+ } while(0);
+}
+
+BOOST_AUTO_TEST_CASE(util_MedianFilter)
+{
+ CMedianFilter<int> filter(5, 15);
+
+ BOOST_CHECK_EQUAL(filter.median(), 15);
+
+ filter.input(20); // [15 20]
+ BOOST_CHECK_EQUAL(filter.median(), 17);
+
+ filter.input(30); // [15 20 30]
+ BOOST_CHECK_EQUAL(filter.median(), 20);
+
+ filter.input(3); // [3 15 20 30]
+ BOOST_CHECK_EQUAL(filter.median(), 17);
+
+ filter.input(7); // [3 7 15 20 30]
+ BOOST_CHECK_EQUAL(filter.median(), 15);
+
+ filter.input(18); // [3 7 18 20 30]
+ BOOST_CHECK_EQUAL(filter.median(), 18);
+
+ filter.input(0); // [0 3 7 18 30]
+ BOOST_CHECK_EQUAL(filter.median(), 7);
+}
+
+static const unsigned char ParseHex_expected[65] = {
+ 0x04, 0x67, 0x8a, 0xfd, 0xb0, 0xfe, 0x55, 0x48, 0x27, 0x19, 0x67, 0xf1, 0xa6, 0x71, 0x30, 0xb7,
+ 0x10, 0x5c, 0xd6, 0xa8, 0x28, 0xe0, 0x39, 0x09, 0xa6, 0x79, 0x62, 0xe0, 0xea, 0x1f, 0x61, 0xde,
+ 0xb6, 0x49, 0xf6, 0xbc, 0x3f, 0x4c, 0xef, 0x38, 0xc4, 0xf3, 0x55, 0x04, 0xe5, 0x1e, 0xc1, 0x12,
+ 0xde, 0x5c, 0x38, 0x4d, 0xf7, 0xba, 0x0b, 0x8d, 0x57, 0x8a, 0x4c, 0x70, 0x2b, 0x6b, 0xf1, 0x1d,
+ 0x5f
+};
+BOOST_AUTO_TEST_CASE(util_ParseHex)
+{
+ std::vector<unsigned char> result;
+ std::vector<unsigned char> expected(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected));
+ // Basic test vector
+ result = ParseHex("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
+ BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), expected.begin(), expected.end());
+
+ // Spaces between bytes must be supported
+ result = ParseHex("12 34 56 78");
+ BOOST_CHECK(result.size() == 4 && result[0] == 0x12 && result[1] == 0x34 && result[2] == 0x56 && result[3] == 0x78);
+
+ // Stop parsing at invalid value
+ result = ParseHex("1234 invalid 1234");
+ BOOST_CHECK(result.size() == 2 && result[0] == 0x12 && result[1] == 0x34);
+}
+
+BOOST_AUTO_TEST_CASE(util_HexStr)
+{
+ BOOST_CHECK_EQUAL(
+ HexStr(ParseHex_expected, ParseHex_expected + sizeof(ParseHex_expected)),
+ "04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
+
+ BOOST_CHECK_EQUAL(
+ HexStr(ParseHex_expected, ParseHex_expected + 5, true),
+ "04 67 8a fd b0");
+}
+
+BOOST_AUTO_TEST_CASE(util_DateTimeStrFormat)
+{
+ BOOST_CHECK_EQUAL(DateTimeStrFormat("%x %H:%M:%S", 0), "01/01/70 00:00:00");
+ BOOST_CHECK_EQUAL(DateTimeStrFormat("%x %H:%M:%S", 0x7FFFFFFF), "01/19/38 03:14:07");
+ // Formats used within bitcoin
+ BOOST_CHECK_EQUAL(DateTimeStrFormat("%x %H:%M:%S", 1317425777), "09/30/11 23:36:17");
+ BOOST_CHECK_EQUAL(DateTimeStrFormat("%x %H:%M", 1317425777), "09/30/11 23:36");
+}
+
+BOOST_AUTO_TEST_CASE(util_ParseParameters)
+{
+ const char *argv_test[] = {"-ignored", "-a", "-b", "-ccc=argument", "-ccc=multiple", "f", "-d=e"};
+
+ ParseParameters(0, (char**)argv_test);
+ BOOST_CHECK(mapArgs.empty() && mapMultiArgs.empty());
+
+ ParseParameters(1, (char**)argv_test);
+ BOOST_CHECK(mapArgs.empty() && mapMultiArgs.empty());
+
+ ParseParameters(5, (char**)argv_test);
+ // expectation: -ignored is ignored (program name argument),
+ // -a, -b and -ccc end up in map, -d ignored because it is after
+ // a non-option argument (non-GNU option parsing)
+ BOOST_CHECK(mapArgs.size() == 3 && mapMultiArgs.size() == 3);
+ BOOST_CHECK(mapArgs.count("-a") && mapArgs.count("-b") && mapArgs.count("-ccc")
+ && !mapArgs.count("f") && !mapArgs.count("-d"));
+ BOOST_CHECK(mapMultiArgs.count("-a") && mapMultiArgs.count("-b") && mapMultiArgs.count("-ccc")
+ && !mapMultiArgs.count("f") && !mapMultiArgs.count("-d"));
+
+ BOOST_CHECK(mapArgs["-a"] == "" && mapArgs["-ccc"] == "multiple");
+ BOOST_CHECK(mapMultiArgs["-ccc"].size() == 2);
+}
+
+BOOST_AUTO_TEST_CASE(util_GetArg)
+{
+ mapArgs.clear();
+ mapArgs["strtest1"] = "string...";
+ // strtest2 undefined on purpose
+ mapArgs["inttest1"] = "12345";
+ mapArgs["inttest2"] = "81985529216486895";
+ // inttest3 undefined on purpose
+ mapArgs["booltest1"] = "";
+ // booltest2 undefined on purpose
+ mapArgs["booltest3"] = "0";
+ mapArgs["booltest4"] = "1";
+
+ BOOST_CHECK_EQUAL(GetArg("strtest1", "default"), "string...");
+ BOOST_CHECK_EQUAL(GetArg("strtest2", "default"), "default");
+ BOOST_CHECK_EQUAL(GetArg("inttest1", -1), 12345);
+ BOOST_CHECK_EQUAL(GetArg("inttest2", -1), 81985529216486895LL);
+ BOOST_CHECK_EQUAL(GetArg("inttest3", -1), -1);
+ BOOST_CHECK_EQUAL(GetBoolArg("booltest1"), true);
+ BOOST_CHECK_EQUAL(GetBoolArg("booltest2"), false);
+ BOOST_CHECK_EQUAL(GetBoolArg("booltest3"), false);
+ BOOST_CHECK_EQUAL(GetBoolArg("booltest4"), true);
+}
+
+BOOST_AUTO_TEST_CASE(util_WildcardMatch)
+{
+ BOOST_CHECK(WildcardMatch("127.0.0.1", "*"));
+ BOOST_CHECK(WildcardMatch("127.0.0.1", "127.*"));
+ BOOST_CHECK(WildcardMatch("abcdef", "a?cde?"));
+ BOOST_CHECK(!WildcardMatch("abcdef", "a?cde??"));
+ BOOST_CHECK(WildcardMatch("abcdef", "a*f"));
+ BOOST_CHECK(!WildcardMatch("abcdef", "a*x"));
+ BOOST_CHECK(WildcardMatch("", "*"));
+}
+
+BOOST_AUTO_TEST_CASE(util_FormatMoney)
+{
+ BOOST_CHECK_EQUAL(FormatMoney(0, false), "0.00");
+ BOOST_CHECK_EQUAL(FormatMoney((COIN/10000)*123456789, false), "12345.6789");
+ BOOST_CHECK_EQUAL(FormatMoney(COIN, true), "+1.00");
+ BOOST_CHECK_EQUAL(FormatMoney(-COIN, false), "-1.00");
+ BOOST_CHECK_EQUAL(FormatMoney(-COIN, true), "-1.00");
+
+ BOOST_CHECK_EQUAL(FormatMoney(COIN*100000000, false), "100000000.00");
+ BOOST_CHECK_EQUAL(FormatMoney(COIN*10000000, false), "10000000.00");
+ BOOST_CHECK_EQUAL(FormatMoney(COIN*1000000, false), "1000000.00");
+ BOOST_CHECK_EQUAL(FormatMoney(COIN*100000, false), "100000.00");
+ BOOST_CHECK_EQUAL(FormatMoney(COIN*10000, false), "10000.00");
+ BOOST_CHECK_EQUAL(FormatMoney(COIN*1000, false), "1000.00");
+ BOOST_CHECK_EQUAL(FormatMoney(COIN*100, false), "100.00");
+ BOOST_CHECK_EQUAL(FormatMoney(COIN*10, false), "10.00");
+ BOOST_CHECK_EQUAL(FormatMoney(COIN, false), "1.00");
+ BOOST_CHECK_EQUAL(FormatMoney(COIN/10, false), "0.10");
+ BOOST_CHECK_EQUAL(FormatMoney(COIN/100, false), "0.01");
+ BOOST_CHECK_EQUAL(FormatMoney(COIN/1000, false), "0.001");
+ BOOST_CHECK_EQUAL(FormatMoney(COIN/10000, false), "0.0001");
+ BOOST_CHECK_EQUAL(FormatMoney(COIN/100000, false), "0.00001");
+ BOOST_CHECK_EQUAL(FormatMoney(COIN/1000000, false), "0.000001");
+ BOOST_CHECK_EQUAL(FormatMoney(COIN/10000000, false), "0.0000001");
+ BOOST_CHECK_EQUAL(FormatMoney(COIN/100000000, false), "0.00000001");
+}
+
+BOOST_AUTO_TEST_CASE(util_ParseMoney)
+{
+ int64 ret = 0;
+ BOOST_CHECK(ParseMoney("0.0", ret));
+ BOOST_CHECK_EQUAL(ret, 0);
+
+ BOOST_CHECK(ParseMoney("12345.6789", ret));
+ BOOST_CHECK_EQUAL(ret, (COIN/10000)*123456789);
+
+ BOOST_CHECK(ParseMoney("100000000.00", ret));
+ BOOST_CHECK_EQUAL(ret, COIN*100000000);
+ BOOST_CHECK(ParseMoney("10000000.00", ret));
+ BOOST_CHECK_EQUAL(ret, COIN*10000000);
+ BOOST_CHECK(ParseMoney("1000000.00", ret));
+ BOOST_CHECK_EQUAL(ret, COIN*1000000);
+ BOOST_CHECK(ParseMoney("100000.00", ret));
+ BOOST_CHECK_EQUAL(ret, COIN*100000);
+ BOOST_CHECK(ParseMoney("10000.00", ret));
+ BOOST_CHECK_EQUAL(ret, COIN*10000);
+ BOOST_CHECK(ParseMoney("1000.00", ret));
+ BOOST_CHECK_EQUAL(ret, COIN*1000);
+ BOOST_CHECK(ParseMoney("100.00", ret));
+ BOOST_CHECK_EQUAL(ret, COIN*100);
+ BOOST_CHECK(ParseMoney("10.00", ret));
+ BOOST_CHECK_EQUAL(ret, COIN*10);
+ BOOST_CHECK(ParseMoney("1.00", ret));
+ BOOST_CHECK_EQUAL(ret, COIN);
+ BOOST_CHECK(ParseMoney("0.1", ret));
+ BOOST_CHECK_EQUAL(ret, COIN/10);
+ BOOST_CHECK(ParseMoney("0.01", ret));
+ BOOST_CHECK_EQUAL(ret, COIN/100);
+ BOOST_CHECK(ParseMoney("0.001", ret));
+ BOOST_CHECK_EQUAL(ret, COIN/1000);
+ BOOST_CHECK(ParseMoney("0.0001", ret));
+ BOOST_CHECK_EQUAL(ret, COIN/10000);
+ BOOST_CHECK(ParseMoney("0.00001", ret));
+ BOOST_CHECK_EQUAL(ret, COIN/100000);
+ BOOST_CHECK(ParseMoney("0.000001", ret));
+ BOOST_CHECK_EQUAL(ret, COIN/1000000);
+ BOOST_CHECK(ParseMoney("0.0000001", ret));
+ BOOST_CHECK_EQUAL(ret, COIN/10000000);
+ BOOST_CHECK(ParseMoney("0.00000001", ret));
+ BOOST_CHECK_EQUAL(ret, COIN/100000000);
+
+ // Attempted 63 bit overflow should fail
+ BOOST_CHECK(!ParseMoney("92233720368.54775808", ret));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/bitcoin/src/uint256.h b/bitcoin/src/uint256.h
@@ -0,0 +1,759 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2011 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#ifndef BITCOIN_UINT256_H
+#define BITCOIN_UINT256_H
+
+#include "serialize.h"
+
+#include <limits.h>
+#include <string>
+#include <vector>
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+typedef __int64 int64;
+typedef unsigned __int64 uint64;
+#else
+typedef long long int64;
+typedef unsigned long long uint64;
+#endif
+#if defined(_MSC_VER) && _MSC_VER < 1300
+#define for if (false) ; else for
+#endif
+
+
+inline int Testuint256AdHoc(std::vector<std::string> vArg);
+
+
+
+// We have to keep a separate base class without constructors
+// so the compiler will let us use it in a union
+template<unsigned int BITS>
+class base_uint
+{
+protected:
+ enum { WIDTH=BITS/32 };
+ unsigned int pn[WIDTH];
+public:
+
+ bool operator!() const
+ {
+ for (int i = 0; i < WIDTH; i++)
+ if (pn[i] != 0)
+ return false;
+ return true;
+ }
+
+ const base_uint operator~() const
+ {
+ base_uint ret;
+ for (int i = 0; i < WIDTH; i++)
+ ret.pn[i] = ~pn[i];
+ return ret;
+ }
+
+ const base_uint operator-() const
+ {
+ base_uint ret;
+ for (int i = 0; i < WIDTH; i++)
+ ret.pn[i] = ~pn[i];
+ ret++;
+ return ret;
+ }
+
+
+ base_uint& operator=(uint64 b)
+ {
+ pn[0] = (unsigned int)b;
+ pn[1] = (unsigned int)(b >> 32);
+ for (int i = 2; i < WIDTH; i++)
+ pn[i] = 0;
+ return *this;
+ }
+
+ base_uint& operator^=(const base_uint& b)
+ {
+ for (int i = 0; i < WIDTH; i++)
+ pn[i] ^= b.pn[i];
+ return *this;
+ }
+
+ base_uint& operator&=(const base_uint& b)
+ {
+ for (int i = 0; i < WIDTH; i++)
+ pn[i] &= b.pn[i];
+ return *this;
+ }
+
+ base_uint& operator|=(const base_uint& b)
+ {
+ for (int i = 0; i < WIDTH; i++)
+ pn[i] |= b.pn[i];
+ return *this;
+ }
+
+ base_uint& operator^=(uint64 b)
+ {
+ pn[0] ^= (unsigned int)b;
+ pn[1] ^= (unsigned int)(b >> 32);
+ return *this;
+ }
+
+ base_uint& operator|=(uint64 b)
+ {
+ pn[0] |= (unsigned int)b;
+ pn[1] |= (unsigned int)(b >> 32);
+ return *this;
+ }
+
+ base_uint& operator<<=(unsigned int shift)
+ {
+ base_uint a(*this);
+ for (int i = 0; i < WIDTH; i++)
+ pn[i] = 0;
+ int k = shift / 32;
+ shift = shift % 32;
+ for (int i = 0; i < WIDTH; i++)
+ {
+ if (i+k+1 < WIDTH && shift != 0)
+ pn[i+k+1] |= (a.pn[i] >> (32-shift));
+ if (i+k < WIDTH)
+ pn[i+k] |= (a.pn[i] << shift);
+ }
+ return *this;
+ }
+
+ base_uint& operator>>=(unsigned int shift)
+ {
+ base_uint a(*this);
+ for (int i = 0; i < WIDTH; i++)
+ pn[i] = 0;
+ int k = shift / 32;
+ shift = shift % 32;
+ for (int i = 0; i < WIDTH; i++)
+ {
+ if (i-k-1 >= 0 && shift != 0)
+ pn[i-k-1] |= (a.pn[i] << (32-shift));
+ if (i-k >= 0)
+ pn[i-k] |= (a.pn[i] >> shift);
+ }
+ return *this;
+ }
+
+ base_uint& operator+=(const base_uint& b)
+ {
+ uint64 carry = 0;
+ for (int i = 0; i < WIDTH; i++)
+ {
+ uint64 n = carry + pn[i] + b.pn[i];
+ pn[i] = n & 0xffffffff;
+ carry = n >> 32;
+ }
+ return *this;
+ }
+
+ base_uint& operator-=(const base_uint& b)
+ {
+ *this += -b;
+ return *this;
+ }
+
+ base_uint& operator+=(uint64 b64)
+ {
+ base_uint b;
+ b = b64;
+ *this += b;
+ return *this;
+ }
+
+ base_uint& operator-=(uint64 b64)
+ {
+ base_uint b;
+ b = b64;
+ *this += -b;
+ return *this;
+ }
+
+
+ base_uint& operator++()
+ {
+ // prefix operator
+ int i = 0;
+ while (++pn[i] == 0 && i < WIDTH-1)
+ i++;
+ return *this;
+ }
+
+ const base_uint operator++(int)
+ {
+ // postfix operator
+ const base_uint ret = *this;
+ ++(*this);
+ return ret;
+ }
+
+ base_uint& operator--()
+ {
+ // prefix operator
+ int i = 0;
+ while (--pn[i] == -1 && i < WIDTH-1)
+ i++;
+ return *this;
+ }
+
+ const base_uint operator--(int)
+ {
+ // postfix operator
+ const base_uint ret = *this;
+ --(*this);
+ return ret;
+ }
+
+
+ friend inline bool operator<(const base_uint& a, const base_uint& b)
+ {
+ for (int i = base_uint::WIDTH-1; i >= 0; i--)
+ {
+ if (a.pn[i] < b.pn[i])
+ return true;
+ else if (a.pn[i] > b.pn[i])
+ return false;
+ }
+ return false;
+ }
+
+ friend inline bool operator<=(const base_uint& a, const base_uint& b)
+ {
+ for (int i = base_uint::WIDTH-1; i >= 0; i--)
+ {
+ if (a.pn[i] < b.pn[i])
+ return true;
+ else if (a.pn[i] > b.pn[i])
+ return false;
+ }
+ return true;
+ }
+
+ friend inline bool operator>(const base_uint& a, const base_uint& b)
+ {
+ for (int i = base_uint::WIDTH-1; i >= 0; i--)
+ {
+ if (a.pn[i] > b.pn[i])
+ return true;
+ else if (a.pn[i] < b.pn[i])
+ return false;
+ }
+ return false;
+ }
+
+ friend inline bool operator>=(const base_uint& a, const base_uint& b)
+ {
+ for (int i = base_uint::WIDTH-1; i >= 0; i--)
+ {
+ if (a.pn[i] > b.pn[i])
+ return true;
+ else if (a.pn[i] < b.pn[i])
+ return false;
+ }
+ return true;
+ }
+
+ friend inline bool operator==(const base_uint& a, const base_uint& b)
+ {
+ for (int i = 0; i < base_uint::WIDTH; i++)
+ if (a.pn[i] != b.pn[i])
+ return false;
+ return true;
+ }
+
+ friend inline bool operator==(const base_uint& a, uint64 b)
+ {
+ if (a.pn[0] != (unsigned int)b)
+ return false;
+ if (a.pn[1] != (unsigned int)(b >> 32))
+ return false;
+ for (int i = 2; i < base_uint::WIDTH; i++)
+ if (a.pn[i] != 0)
+ return false;
+ return true;
+ }
+
+ friend inline bool operator!=(const base_uint& a, const base_uint& b)
+ {
+ return (!(a == b));
+ }
+
+ friend inline bool operator!=(const base_uint& a, uint64 b)
+ {
+ return (!(a == b));
+ }
+
+
+
+ std::string GetHex() const
+ {
+ char psz[sizeof(pn)*2 + 1];
+ for (int i = 0; i < sizeof(pn); i++)
+ sprintf(psz + i*2, "%02x", ((unsigned char*)pn)[sizeof(pn) - i - 1]);
+ return std::string(psz, psz + sizeof(pn)*2);
+ }
+
+ void SetHex(const char* psz)
+ {
+ for (int i = 0; i < WIDTH; i++)
+ pn[i] = 0;
+
+ // skip leading spaces
+ while (isspace(*psz))
+ psz++;
+
+ // skip 0x
+ if (psz[0] == '0' && tolower(psz[1]) == 'x')
+ psz += 2;
+
+ // hex string to uint
+ static char phexdigit[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0 };
+ const char* pbegin = psz;
+ while (phexdigit[*psz] || *psz == '0')
+ psz++;
+ psz--;
+ unsigned char* p1 = (unsigned char*)pn;
+ unsigned char* pend = p1 + WIDTH * 4;
+ while (psz >= pbegin && p1 < pend)
+ {
+ *p1 = phexdigit[(unsigned char)*psz--];
+ if (psz >= pbegin)
+ {
+ *p1 |= (phexdigit[(unsigned char)*psz--] << 4);
+ p1++;
+ }
+ }
+ }
+
+ void SetHex(const std::string& str)
+ {
+ SetHex(str.c_str());
+ }
+
+ std::string ToString() const
+ {
+ return (GetHex());
+ }
+
+ unsigned char* begin()
+ {
+ return (unsigned char*)&pn[0];
+ }
+
+ unsigned char* end()
+ {
+ return (unsigned char*)&pn[WIDTH];
+ }
+
+ unsigned int size()
+ {
+ return sizeof(pn);
+ }
+
+
+ unsigned int GetSerializeSize(int nType=0, int nVersion=VERSION) const
+ {
+ return sizeof(pn);
+ }
+
+ template<typename Stream>
+ void Serialize(Stream& s, int nType=0, int nVersion=VERSION) const
+ {
+ s.write((char*)pn, sizeof(pn));
+ }
+
+ template<typename Stream>
+ void Unserialize(Stream& s, int nType=0, int nVersion=VERSION)
+ {
+ s.read((char*)pn, sizeof(pn));
+ }
+
+
+ friend class uint160;
+ friend class uint256;
+ friend inline int Testuint256AdHoc(std::vector<std::string> vArg);
+};
+
+typedef base_uint<160> base_uint160;
+typedef base_uint<256> base_uint256;
+
+
+
+//
+// uint160 and uint256 could be implemented as templates, but to keep
+// compile errors and debugging cleaner, they're copy and pasted.
+//
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// uint160
+//
+
+class uint160 : public base_uint160
+{
+public:
+ typedef base_uint160 basetype;
+
+ uint160()
+ {
+ for (int i = 0; i < WIDTH; i++)
+ pn[i] = 0;
+ }
+
+ uint160(const basetype& b)
+ {
+ for (int i = 0; i < WIDTH; i++)
+ pn[i] = b.pn[i];
+ }
+
+ uint160& operator=(const basetype& b)
+ {
+ for (int i = 0; i < WIDTH; i++)
+ pn[i] = b.pn[i];
+ return *this;
+ }
+
+ uint160(uint64 b)
+ {
+ pn[0] = (unsigned int)b;
+ pn[1] = (unsigned int)(b >> 32);
+ for (int i = 2; i < WIDTH; i++)
+ pn[i] = 0;
+ }
+
+ uint160& operator=(uint64 b)
+ {
+ pn[0] = (unsigned int)b;
+ pn[1] = (unsigned int)(b >> 32);
+ for (int i = 2; i < WIDTH; i++)
+ pn[i] = 0;
+ return *this;
+ }
+
+ explicit uint160(const std::string& str)
+ {
+ SetHex(str);
+ }
+
+ explicit uint160(const std::vector<unsigned char>& vch)
+ {
+ if (vch.size() == sizeof(pn))
+ memcpy(pn, &vch[0], sizeof(pn));
+ else
+ *this = 0;
+ }
+};
+
+inline bool operator==(const uint160& a, uint64 b) { return (base_uint160)a == b; }
+inline bool operator!=(const uint160& a, uint64 b) { return (base_uint160)a != b; }
+inline const uint160 operator<<(const base_uint160& a, unsigned int shift) { return uint160(a) <<= shift; }
+inline const uint160 operator>>(const base_uint160& a, unsigned int shift) { return uint160(a) >>= shift; }
+inline const uint160 operator<<(const uint160& a, unsigned int shift) { return uint160(a) <<= shift; }
+inline const uint160 operator>>(const uint160& a, unsigned int shift) { return uint160(a) >>= shift; }
+
+inline const uint160 operator^(const base_uint160& a, const base_uint160& b) { return uint160(a) ^= b; }
+inline const uint160 operator&(const base_uint160& a, const base_uint160& b) { return uint160(a) &= b; }
+inline const uint160 operator|(const base_uint160& a, const base_uint160& b) { return uint160(a) |= b; }
+inline const uint160 operator+(const base_uint160& a, const base_uint160& b) { return uint160(a) += b; }
+inline const uint160 operator-(const base_uint160& a, const base_uint160& b) { return uint160(a) -= b; }
+
+inline bool operator<(const base_uint160& a, const uint160& b) { return (base_uint160)a < (base_uint160)b; }
+inline bool operator<=(const base_uint160& a, const uint160& b) { return (base_uint160)a <= (base_uint160)b; }
+inline bool operator>(const base_uint160& a, const uint160& b) { return (base_uint160)a > (base_uint160)b; }
+inline bool operator>=(const base_uint160& a, const uint160& b) { return (base_uint160)a >= (base_uint160)b; }
+inline bool operator==(const base_uint160& a, const uint160& b) { return (base_uint160)a == (base_uint160)b; }
+inline bool operator!=(const base_uint160& a, const uint160& b) { return (base_uint160)a != (base_uint160)b; }
+inline const uint160 operator^(const base_uint160& a, const uint160& b) { return (base_uint160)a ^ (base_uint160)b; }
+inline const uint160 operator&(const base_uint160& a, const uint160& b) { return (base_uint160)a & (base_uint160)b; }
+inline const uint160 operator|(const base_uint160& a, const uint160& b) { return (base_uint160)a | (base_uint160)b; }
+inline const uint160 operator+(const base_uint160& a, const uint160& b) { return (base_uint160)a + (base_uint160)b; }
+inline const uint160 operator-(const base_uint160& a, const uint160& b) { return (base_uint160)a - (base_uint160)b; }
+
+inline bool operator<(const uint160& a, const base_uint160& b) { return (base_uint160)a < (base_uint160)b; }
+inline bool operator<=(const uint160& a, const base_uint160& b) { return (base_uint160)a <= (base_uint160)b; }
+inline bool operator>(const uint160& a, const base_uint160& b) { return (base_uint160)a > (base_uint160)b; }
+inline bool operator>=(const uint160& a, const base_uint160& b) { return (base_uint160)a >= (base_uint160)b; }
+inline bool operator==(const uint160& a, const base_uint160& b) { return (base_uint160)a == (base_uint160)b; }
+inline bool operator!=(const uint160& a, const base_uint160& b) { return (base_uint160)a != (base_uint160)b; }
+inline const uint160 operator^(const uint160& a, const base_uint160& b) { return (base_uint160)a ^ (base_uint160)b; }
+inline const uint160 operator&(const uint160& a, const base_uint160& b) { return (base_uint160)a & (base_uint160)b; }
+inline const uint160 operator|(const uint160& a, const base_uint160& b) { return (base_uint160)a | (base_uint160)b; }
+inline const uint160 operator+(const uint160& a, const base_uint160& b) { return (base_uint160)a + (base_uint160)b; }
+inline const uint160 operator-(const uint160& a, const base_uint160& b) { return (base_uint160)a - (base_uint160)b; }
+
+inline bool operator<(const uint160& a, const uint160& b) { return (base_uint160)a < (base_uint160)b; }
+inline bool operator<=(const uint160& a, const uint160& b) { return (base_uint160)a <= (base_uint160)b; }
+inline bool operator>(const uint160& a, const uint160& b) { return (base_uint160)a > (base_uint160)b; }
+inline bool operator>=(const uint160& a, const uint160& b) { return (base_uint160)a >= (base_uint160)b; }
+inline bool operator==(const uint160& a, const uint160& b) { return (base_uint160)a == (base_uint160)b; }
+inline bool operator!=(const uint160& a, const uint160& b) { return (base_uint160)a != (base_uint160)b; }
+inline const uint160 operator^(const uint160& a, const uint160& b) { return (base_uint160)a ^ (base_uint160)b; }
+inline const uint160 operator&(const uint160& a, const uint160& b) { return (base_uint160)a & (base_uint160)b; }
+inline const uint160 operator|(const uint160& a, const uint160& b) { return (base_uint160)a | (base_uint160)b; }
+inline const uint160 operator+(const uint160& a, const uint160& b) { return (base_uint160)a + (base_uint160)b; }
+inline const uint160 operator-(const uint160& a, const uint160& b) { return (base_uint160)a - (base_uint160)b; }
+
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// uint256
+//
+
+class uint256 : public base_uint256
+{
+public:
+ typedef base_uint256 basetype;
+
+ uint256()
+ {
+ for (int i = 0; i < WIDTH; i++)
+ pn[i] = 0;
+ }
+
+ uint256(const basetype& b)
+ {
+ for (int i = 0; i < WIDTH; i++)
+ pn[i] = b.pn[i];
+ }
+
+ uint256& operator=(const basetype& b)
+ {
+ for (int i = 0; i < WIDTH; i++)
+ pn[i] = b.pn[i];
+ return *this;
+ }
+
+ uint256(uint64 b)
+ {
+ pn[0] = (unsigned int)b;
+ pn[1] = (unsigned int)(b >> 32);
+ for (int i = 2; i < WIDTH; i++)
+ pn[i] = 0;
+ }
+
+ uint256& operator=(uint64 b)
+ {
+ pn[0] = (unsigned int)b;
+ pn[1] = (unsigned int)(b >> 32);
+ for (int i = 2; i < WIDTH; i++)
+ pn[i] = 0;
+ return *this;
+ }
+
+ explicit uint256(const std::string& str)
+ {
+ SetHex(str);
+ }
+
+ explicit uint256(const std::vector<unsigned char>& vch)
+ {
+ if (vch.size() == sizeof(pn))
+ memcpy(pn, &vch[0], sizeof(pn));
+ else
+ *this = 0;
+ }
+};
+
+inline bool operator==(const uint256& a, uint64 b) { return (base_uint256)a == b; }
+inline bool operator!=(const uint256& a, uint64 b) { return (base_uint256)a != b; }
+inline const uint256 operator<<(const base_uint256& a, unsigned int shift) { return uint256(a) <<= shift; }
+inline const uint256 operator>>(const base_uint256& a, unsigned int shift) { return uint256(a) >>= shift; }
+inline const uint256 operator<<(const uint256& a, unsigned int shift) { return uint256(a) <<= shift; }
+inline const uint256 operator>>(const uint256& a, unsigned int shift) { return uint256(a) >>= shift; }
+
+inline const uint256 operator^(const base_uint256& a, const base_uint256& b) { return uint256(a) ^= b; }
+inline const uint256 operator&(const base_uint256& a, const base_uint256& b) { return uint256(a) &= b; }
+inline const uint256 operator|(const base_uint256& a, const base_uint256& b) { return uint256(a) |= b; }
+inline const uint256 operator+(const base_uint256& a, const base_uint256& b) { return uint256(a) += b; }
+inline const uint256 operator-(const base_uint256& a, const base_uint256& b) { return uint256(a) -= b; }
+
+inline bool operator<(const base_uint256& a, const uint256& b) { return (base_uint256)a < (base_uint256)b; }
+inline bool operator<=(const base_uint256& a, const uint256& b) { return (base_uint256)a <= (base_uint256)b; }
+inline bool operator>(const base_uint256& a, const uint256& b) { return (base_uint256)a > (base_uint256)b; }
+inline bool operator>=(const base_uint256& a, const uint256& b) { return (base_uint256)a >= (base_uint256)b; }
+inline bool operator==(const base_uint256& a, const uint256& b) { return (base_uint256)a == (base_uint256)b; }
+inline bool operator!=(const base_uint256& a, const uint256& b) { return (base_uint256)a != (base_uint256)b; }
+inline const uint256 operator^(const base_uint256& a, const uint256& b) { return (base_uint256)a ^ (base_uint256)b; }
+inline const uint256 operator&(const base_uint256& a, const uint256& b) { return (base_uint256)a & (base_uint256)b; }
+inline const uint256 operator|(const base_uint256& a, const uint256& b) { return (base_uint256)a | (base_uint256)b; }
+inline const uint256 operator+(const base_uint256& a, const uint256& b) { return (base_uint256)a + (base_uint256)b; }
+inline const uint256 operator-(const base_uint256& a, const uint256& b) { return (base_uint256)a - (base_uint256)b; }
+
+inline bool operator<(const uint256& a, const base_uint256& b) { return (base_uint256)a < (base_uint256)b; }
+inline bool operator<=(const uint256& a, const base_uint256& b) { return (base_uint256)a <= (base_uint256)b; }
+inline bool operator>(const uint256& a, const base_uint256& b) { return (base_uint256)a > (base_uint256)b; }
+inline bool operator>=(const uint256& a, const base_uint256& b) { return (base_uint256)a >= (base_uint256)b; }
+inline bool operator==(const uint256& a, const base_uint256& b) { return (base_uint256)a == (base_uint256)b; }
+inline bool operator!=(const uint256& a, const base_uint256& b) { return (base_uint256)a != (base_uint256)b; }
+inline const uint256 operator^(const uint256& a, const base_uint256& b) { return (base_uint256)a ^ (base_uint256)b; }
+inline const uint256 operator&(const uint256& a, const base_uint256& b) { return (base_uint256)a & (base_uint256)b; }
+inline const uint256 operator|(const uint256& a, const base_uint256& b) { return (base_uint256)a | (base_uint256)b; }
+inline const uint256 operator+(const uint256& a, const base_uint256& b) { return (base_uint256)a + (base_uint256)b; }
+inline const uint256 operator-(const uint256& a, const base_uint256& b) { return (base_uint256)a - (base_uint256)b; }
+
+inline bool operator<(const uint256& a, const uint256& b) { return (base_uint256)a < (base_uint256)b; }
+inline bool operator<=(const uint256& a, const uint256& b) { return (base_uint256)a <= (base_uint256)b; }
+inline bool operator>(const uint256& a, const uint256& b) { return (base_uint256)a > (base_uint256)b; }
+inline bool operator>=(const uint256& a, const uint256& b) { return (base_uint256)a >= (base_uint256)b; }
+inline bool operator==(const uint256& a, const uint256& b) { return (base_uint256)a == (base_uint256)b; }
+inline bool operator!=(const uint256& a, const uint256& b) { return (base_uint256)a != (base_uint256)b; }
+inline const uint256 operator^(const uint256& a, const uint256& b) { return (base_uint256)a ^ (base_uint256)b; }
+inline const uint256 operator&(const uint256& a, const uint256& b) { return (base_uint256)a & (base_uint256)b; }
+inline const uint256 operator|(const uint256& a, const uint256& b) { return (base_uint256)a | (base_uint256)b; }
+inline const uint256 operator+(const uint256& a, const uint256& b) { return (base_uint256)a + (base_uint256)b; }
+inline const uint256 operator-(const uint256& a, const uint256& b) { return (base_uint256)a - (base_uint256)b; }
+
+
+
+
+
+
+
+
+
+
+
+
+inline int Testuint256AdHoc(std::vector<std::string> vArg)
+{
+ uint256 g(0);
+
+
+ printf("%s\n", g.ToString().c_str());
+ g--; printf("g--\n");
+ printf("%s\n", g.ToString().c_str());
+ g--; printf("g--\n");
+ printf("%s\n", g.ToString().c_str());
+ g++; printf("g++\n");
+ printf("%s\n", g.ToString().c_str());
+ g++; printf("g++\n");
+ printf("%s\n", g.ToString().c_str());
+ g++; printf("g++\n");
+ printf("%s\n", g.ToString().c_str());
+ g++; printf("g++\n");
+ printf("%s\n", g.ToString().c_str());
+
+
+
+ uint256 a(7);
+ printf("a=7\n");
+ printf("%s\n", a.ToString().c_str());
+
+ uint256 b;
+ printf("b undefined\n");
+ printf("%s\n", b.ToString().c_str());
+ int c = 3;
+
+ a = c;
+ a.pn[3] = 15;
+ printf("%s\n", a.ToString().c_str());
+ uint256 k(c);
+
+ a = 5;
+ a.pn[3] = 15;
+ printf("%s\n", a.ToString().c_str());
+ b = 1;
+ b <<= 52;
+
+ a |= b;
+
+ a ^= 0x500;
+
+ printf("a %s\n", a.ToString().c_str());
+
+ a = a | b | (uint256)0x1000;
+
+
+ printf("a %s\n", a.ToString().c_str());
+ printf("b %s\n", b.ToString().c_str());
+
+ a = 0xfffffffe;
+ a.pn[4] = 9;
+
+ printf("%s\n", a.ToString().c_str());
+ a++;
+ printf("%s\n", a.ToString().c_str());
+ a++;
+ printf("%s\n", a.ToString().c_str());
+ a++;
+ printf("%s\n", a.ToString().c_str());
+ a++;
+ printf("%s\n", a.ToString().c_str());
+
+ a--;
+ printf("%s\n", a.ToString().c_str());
+ a--;
+ printf("%s\n", a.ToString().c_str());
+ a--;
+ printf("%s\n", a.ToString().c_str());
+ uint256 d = a--;
+ printf("%s\n", d.ToString().c_str());
+ printf("%s\n", a.ToString().c_str());
+ a--;
+ printf("%s\n", a.ToString().c_str());
+ a--;
+ printf("%s\n", a.ToString().c_str());
+
+ d = a;
+
+ printf("%s\n", d.ToString().c_str());
+ for (int i = uint256::WIDTH-1; i >= 0; i--) printf("%08x", d.pn[i]); printf("\n");
+
+ uint256 neg = d;
+ neg = ~neg;
+ printf("%s\n", neg.ToString().c_str());
+
+
+ uint256 e = uint256("0xABCDEF123abcdef12345678909832180000011111111");
+ printf("\n");
+ printf("%s\n", e.ToString().c_str());
+
+
+ printf("\n");
+ uint256 x1 = uint256("0xABCDEF123abcdef12345678909832180000011111111");
+ uint256 x2;
+ printf("%s\n", x1.ToString().c_str());
+ for (int i = 0; i < 270; i += 4)
+ {
+ x2 = x1 << i;
+ printf("%s\n", x2.ToString().c_str());
+ }
+
+ printf("\n");
+ printf("%s\n", x1.ToString().c_str());
+ for (int i = 0; i < 270; i += 4)
+ {
+ x2 = x1;
+ x2 >>= i;
+ printf("%s\n", x2.ToString().c_str());
+ }
+
+
+ for (int i = 0; i < 100; i++)
+ {
+ uint256 k = (~uint256(0) >> i);
+ printf("%s\n", k.ToString().c_str());
+ }
+
+ for (int i = 0; i < 100; i++)
+ {
+ uint256 k = (~uint256(0) << i);
+ printf("%s\n", k.ToString().c_str());
+ }
+
+ return (0);
+}
+
+#endif
diff --git a/bitcoin/src/util.cpp b/bitcoin/src/util.cpp
@@ -0,0 +1,1177 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2012 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#include "headers.h"
+#include "strlcpy.h"
+#include <boost/program_options/detail/config_file.hpp>
+#include <boost/program_options/parsers.hpp>
+#include <boost/filesystem.hpp>
+#include <boost/filesystem/fstream.hpp>
+#include <boost/interprocess/sync/interprocess_mutex.hpp>
+#include <boost/interprocess/sync/interprocess_recursive_mutex.hpp>
+#include <boost/foreach.hpp>
+
+using namespace std;
+using namespace boost;
+
+map<string, string> mapArgs;
+map<string, vector<string> > mapMultiArgs;
+bool fDebug = false;
+bool fPrintToConsole = false;
+bool fPrintToDebugger = false;
+char pszSetDataDir[MAX_PATH] = "";
+bool fRequestShutdown = false;
+bool fShutdown = false;
+bool fDaemon = false;
+bool fServer = false;
+bool fCommandLine = false;
+string strMiscWarning;
+bool fTestNet = false;
+bool fNoListen = false;
+bool fLogTimestamps = false;
+
+
+
+
+// Workaround for "multiple definition of `_tls_used'"
+// http://svn.boost.org/trac/boost/ticket/4258
+extern "C" void tss_cleanup_implemented() { }
+
+
+
+
+
+// Init openssl library multithreading support
+static boost::interprocess::interprocess_mutex** ppmutexOpenSSL;
+void locking_callback(int mode, int i, const char* file, int line)
+{
+ if (mode & CRYPTO_LOCK)
+ ppmutexOpenSSL[i]->lock();
+ else
+ ppmutexOpenSSL[i]->unlock();
+}
+
+// Init
+class CInit
+{
+public:
+ CInit()
+ {
+ // Init openssl library multithreading support
+ ppmutexOpenSSL = (boost::interprocess::interprocess_mutex**)OPENSSL_malloc(CRYPTO_num_locks() * sizeof(boost::interprocess::interprocess_mutex*));
+ for (int i = 0; i < CRYPTO_num_locks(); i++)
+ ppmutexOpenSSL[i] = new boost::interprocess::interprocess_mutex();
+ CRYPTO_set_locking_callback(locking_callback);
+
+#ifdef WIN32
+ // Seed random number generator with screen scrape and other hardware sources
+ RAND_screen();
+#endif
+
+ // Seed random number generator with performance counter
+ RandAddSeed();
+ }
+ ~CInit()
+ {
+ // Shutdown openssl library multithreading support
+ CRYPTO_set_locking_callback(NULL);
+ for (int i = 0; i < CRYPTO_num_locks(); i++)
+ delete ppmutexOpenSSL[i];
+ OPENSSL_free(ppmutexOpenSSL);
+ }
+}
+instance_of_cinit;
+
+
+
+
+
+
+
+
+void RandAddSeed()
+{
+ // Seed with CPU performance counter
+ int64 nCounter = GetPerformanceCounter();
+ RAND_add(&nCounter, sizeof(nCounter), 1.5);
+ memset(&nCounter, 0, sizeof(nCounter));
+}
+
+void RandAddSeedPerfmon()
+{
+ RandAddSeed();
+
+ // This can take up to 2 seconds, so only do it every 10 minutes
+ static int64 nLastPerfmon;
+ if (GetTime() < nLastPerfmon + 10 * 60)
+ return;
+ nLastPerfmon = GetTime();
+
+#ifdef WIN32
+ // Don't need this on Linux, OpenSSL automatically uses /dev/urandom
+ // Seed with the entire set of perfmon data
+ unsigned char pdata[250000];
+ memset(pdata, 0, sizeof(pdata));
+ unsigned long nSize = sizeof(pdata);
+ long ret = RegQueryValueExA(HKEY_PERFORMANCE_DATA, "Global", NULL, NULL, pdata, &nSize);
+ RegCloseKey(HKEY_PERFORMANCE_DATA);
+ if (ret == ERROR_SUCCESS)
+ {
+ RAND_add(pdata, nSize, nSize/100.0);
+ memset(pdata, 0, nSize);
+ printf("%s RandAddSeed() %d bytes\n", DateTimeStrFormat("%x %H:%M", GetTime()).c_str(), nSize);
+ }
+#endif
+}
+
+uint64 GetRand(uint64 nMax)
+{
+ if (nMax == 0)
+ return 0;
+
+ // The range of the random source must be a multiple of the modulus
+ // to give every possible output value an equal possibility
+ uint64 nRange = (UINT64_MAX / nMax) * nMax;
+ uint64 nRand = 0;
+ do
+ RAND_bytes((unsigned char*)&nRand, sizeof(nRand));
+ while (nRand >= nRange);
+ return (nRand % nMax);
+}
+
+int GetRandInt(int nMax)
+{
+ return GetRand(nMax);
+}
+
+
+
+
+
+
+
+
+
+
+
+inline int OutputDebugStringF(const char* pszFormat, ...)
+{
+ int ret = 0;
+ if (fPrintToConsole)
+ {
+ // print to console
+ va_list arg_ptr;
+ va_start(arg_ptr, pszFormat);
+ ret = vprintf(pszFormat, arg_ptr);
+ va_end(arg_ptr);
+ }
+ else
+ {
+ // print to debug.log
+ static FILE* fileout = NULL;
+
+ if (!fileout)
+ {
+ char pszFile[MAX_PATH+100];
+ GetDataDir(pszFile);
+ strlcat(pszFile, "/debug.log", sizeof(pszFile));
+ fileout = fopen(pszFile, "a");
+ if (fileout) setbuf(fileout, NULL); // unbuffered
+ }
+ if (fileout)
+ {
+ static bool fStartedNewLine = true;
+
+ // Debug print useful for profiling
+ if (fLogTimestamps && fStartedNewLine)
+ fprintf(fileout, "%s ", DateTimeStrFormat("%x %H:%M:%S", GetTime()).c_str());
+ if (pszFormat[strlen(pszFormat) - 1] == '\n')
+ fStartedNewLine = true;
+ else
+ fStartedNewLine = false;
+
+ va_list arg_ptr;
+ va_start(arg_ptr, pszFormat);
+ ret = vfprintf(fileout, pszFormat, arg_ptr);
+ va_end(arg_ptr);
+ }
+ }
+
+#ifdef WIN32
+ if (fPrintToDebugger)
+ {
+ static CCriticalSection cs_OutputDebugStringF;
+
+ // accumulate a line at a time
+ CRITICAL_BLOCK(cs_OutputDebugStringF)
+ {
+ static char pszBuffer[50000];
+ static char* pend;
+ if (pend == NULL)
+ pend = pszBuffer;
+ va_list arg_ptr;
+ va_start(arg_ptr, pszFormat);
+ int limit = END(pszBuffer) - pend - 2;
+ int ret = _vsnprintf(pend, limit, pszFormat, arg_ptr);
+ va_end(arg_ptr);
+ if (ret < 0 || ret >= limit)
+ {
+ pend = END(pszBuffer) - 2;
+ *pend++ = '\n';
+ }
+ else
+ pend += ret;
+ *pend = '\0';
+ char* p1 = pszBuffer;
+ char* p2;
+ while (p2 = strchr(p1, '\n'))
+ {
+ p2++;
+ char c = *p2;
+ *p2 = '\0';
+ OutputDebugStringA(p1);
+ *p2 = c;
+ p1 = p2;
+ }
+ if (p1 != pszBuffer)
+ memmove(pszBuffer, p1, pend - p1 + 1);
+ pend -= (p1 - pszBuffer);
+ }
+ }
+#endif
+ return ret;
+}
+
+
+// Safer snprintf
+// - prints up to limit-1 characters
+// - output string is always null terminated even if limit reached
+// - return value is the number of characters actually printed
+int my_snprintf(char* buffer, size_t limit, const char* format, ...)
+{
+ if (limit == 0)
+ return 0;
+ va_list arg_ptr;
+ va_start(arg_ptr, format);
+ int ret = _vsnprintf(buffer, limit, format, arg_ptr);
+ va_end(arg_ptr);
+ if (ret < 0 || ret >= limit)
+ {
+ ret = limit - 1;
+ buffer[limit-1] = 0;
+ }
+ return ret;
+}
+
+string strprintf(const std::string &format, ...)
+{
+ char buffer[50000];
+ char* p = buffer;
+ int limit = sizeof(buffer);
+ int ret;
+ loop
+ {
+ va_list arg_ptr;
+ va_start(arg_ptr, format);
+ ret = _vsnprintf(p, limit, format.c_str(), arg_ptr);
+ va_end(arg_ptr);
+ if (ret >= 0 && ret < limit)
+ break;
+ if (p != buffer)
+ delete[] p;
+ limit *= 2;
+ p = new char[limit];
+ if (p == NULL)
+ throw std::bad_alloc();
+ }
+ string str(p, p+ret);
+ if (p != buffer)
+ delete[] p;
+ return str;
+}
+
+bool error(const std::string &format, ...)
+{
+ char buffer[50000];
+ int limit = sizeof(buffer);
+ va_list arg_ptr;
+ va_start(arg_ptr, format);
+ int ret = _vsnprintf(buffer, limit, format.c_str(), arg_ptr);
+ va_end(arg_ptr);
+ if (ret < 0 || ret >= limit)
+ {
+ ret = limit - 1;
+ buffer[limit-1] = 0;
+ }
+ printf("ERROR: %s\n", buffer);
+ return false;
+}
+
+
+void ParseString(const string& str, char c, vector<string>& v)
+{
+ if (str.empty())
+ return;
+ string::size_type i1 = 0;
+ string::size_type i2;
+ loop
+ {
+ i2 = str.find(c, i1);
+ if (i2 == str.npos)
+ {
+ v.push_back(str.substr(i1));
+ return;
+ }
+ v.push_back(str.substr(i1, i2-i1));
+ i1 = i2+1;
+ }
+}
+
+
+string FormatMoney(int64 n, bool fPlus)
+{
+ // Note: not using straight sprintf here because we do NOT want
+ // localized number formatting.
+ int64 n_abs = (n > 0 ? n : -n);
+ int64 quotient = n_abs/COIN;
+ int64 remainder = n_abs%COIN;
+ string str = strprintf("%"PRI64d".%08"PRI64d, quotient, remainder);
+
+ // Right-trim excess 0's before the decimal point:
+ int nTrim = 0;
+ for (int i = str.size()-1; (str[i] == '0' && isdigit(str[i-2])); --i)
+ ++nTrim;
+ if (nTrim)
+ str.erase(str.size()-nTrim, nTrim);
+
+ if (n < 0)
+ str.insert((unsigned int)0, 1, '-');
+ else if (fPlus && n > 0)
+ str.insert((unsigned int)0, 1, '+');
+ return str;
+}
+
+
+bool ParseMoney(const string& str, int64& nRet)
+{
+ return ParseMoney(str.c_str(), nRet);
+}
+
+bool ParseMoney(const char* pszIn, int64& nRet)
+{
+ string strWhole;
+ int64 nUnits = 0;
+ const char* p = pszIn;
+ while (isspace(*p))
+ p++;
+ for (; *p; p++)
+ {
+ if (*p == '.')
+ {
+ p++;
+ int64 nMult = CENT*10;
+ while (isdigit(*p) && (nMult > 0))
+ {
+ nUnits += nMult * (*p++ - '0');
+ nMult /= 10;
+ }
+ break;
+ }
+ if (isspace(*p))
+ break;
+ if (!isdigit(*p))
+ return false;
+ strWhole.insert(strWhole.end(), *p);
+ }
+ for (; *p; p++)
+ if (!isspace(*p))
+ return false;
+ if (strWhole.size() > 10) // guard against 63 bit overflow
+ return false;
+ if (nUnits < 0 || nUnits > COIN)
+ return false;
+ int64 nWhole = atoi64(strWhole);
+ int64 nValue = nWhole*COIN + nUnits;
+
+ nRet = nValue;
+ return true;
+}
+
+
+vector<unsigned char> ParseHex(const char* psz)
+{
+ static char phexdigit[256] =
+ { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ 0,1,2,3,4,5,6,7,8,9,-1,-1,-1,-1,-1,-1,
+ -1,0xa,0xb,0xc,0xd,0xe,0xf,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,0xa,0xb,0xc,0xd,0xe,0xf,-1,-1,-1,-1,-1,-1,-1,-1,-1
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, };
+
+ // convert hex dump to vector
+ vector<unsigned char> vch;
+ loop
+ {
+ while (isspace(*psz))
+ psz++;
+ char c = phexdigit[(unsigned char)*psz++];
+ if (c == (char)-1)
+ break;
+ unsigned char n = (c << 4);
+ c = phexdigit[(unsigned char)*psz++];
+ if (c == (char)-1)
+ break;
+ n |= c;
+ vch.push_back(n);
+ }
+ return vch;
+}
+
+vector<unsigned char> ParseHex(const string& str)
+{
+ return ParseHex(str.c_str());
+}
+
+void ParseParameters(int argc, char* argv[])
+{
+ mapArgs.clear();
+ mapMultiArgs.clear();
+ for (int i = 1; i < argc; i++)
+ {
+ char psz[10000];
+ strlcpy(psz, argv[i], sizeof(psz));
+ char* pszValue = (char*)"";
+ if (strchr(psz, '='))
+ {
+ pszValue = strchr(psz, '=');
+ *pszValue++ = '\0';
+ }
+ #ifdef WIN32
+ _strlwr(psz);
+ if (psz[0] == '/')
+ psz[0] = '-';
+ #endif
+ if (psz[0] != '-')
+ break;
+ mapArgs[psz] = pszValue;
+ mapMultiArgs[psz].push_back(pszValue);
+ }
+}
+
+bool SoftSetArg(const std::string& strArg, const std::string& strValue)
+{
+ if (mapArgs.count(strArg))
+ return false;
+ mapArgs[strArg] = strValue;
+ return true;
+}
+
+bool SoftSetArg(const std::string& strArg, bool fValue)
+{
+ if (fValue)
+ return SoftSetArg(strArg, std::string("1"));
+ else
+ return SoftSetArg(strArg, std::string("0"));
+}
+
+
+string EncodeBase64(const unsigned char* pch, size_t len)
+{
+ static const char *pbase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+ string strRet="";
+ strRet.reserve((len+2)/3*4);
+
+ int mode=0, left=0;
+ const unsigned char *pchEnd = pch+len;
+
+ while (pch<pchEnd)
+ {
+ int enc = *(pch++);
+ switch (mode)
+ {
+ case 0: // we have no bits
+ strRet += pbase64[enc >> 2];
+ left = (enc & 3) << 4;
+ mode = 1;
+ break;
+
+ case 1: // we have two bits
+ strRet += pbase64[left | (enc >> 4)];
+ left = (enc & 15) << 2;
+ mode = 2;
+ break;
+
+ case 2: // we have four bits
+ strRet += pbase64[left | (enc >> 6)];
+ strRet += pbase64[enc & 63];
+ mode = 0;
+ break;
+ }
+ }
+
+ if (mode)
+ {
+ strRet += pbase64[left];
+ strRet += '=';
+ if (mode == 1)
+ strRet += '=';
+ }
+
+ return strRet;
+}
+
+string EncodeBase64(const string& str)
+{
+ return EncodeBase64((const unsigned char*)str.c_str(), str.size());
+}
+
+vector<unsigned char> DecodeBase64(const char* p, bool* pfInvalid)
+{
+ static const int decode64_table[256] =
+ {
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1,
+ -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28,
+ 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
+ 49, 50, 51, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+ };
+
+ if (pfInvalid)
+ *pfInvalid = false;
+
+ vector<unsigned char> vchRet;
+ vchRet.reserve(strlen(p)*3/4);
+
+ int mode = 0;
+ int left = 0;
+
+ while (1)
+ {
+ int dec = decode64_table[*p];
+ if (dec == -1) break;
+ p++;
+ switch (mode)
+ {
+ case 0: // we have no bits and get 6
+ left = dec;
+ mode = 1;
+ break;
+
+ case 1: // we have 6 bits and keep 4
+ vchRet.push_back((left<<2) | (dec>>4));
+ left = dec & 15;
+ mode = 2;
+ break;
+
+ case 2: // we have 4 bits and get 6, we keep 2
+ vchRet.push_back((left<<4) | (dec>>2));
+ left = dec & 3;
+ mode = 3;
+ break;
+
+ case 3: // we have 2 bits and get 6
+ vchRet.push_back((left<<6) | dec);
+ mode = 0;
+ break;
+ }
+ }
+
+ if (pfInvalid)
+ switch (mode)
+ {
+ case 0: // 4n base64 characters processed: ok
+ break;
+
+ case 1: // 4n+1 base64 character processed: impossible
+ *pfInvalid = true;
+ break;
+
+ case 2: // 4n+2 base64 characters processed: require '=='
+ if (left || p[0] != '=' || p[1] != '=' || decode64_table[p[2]] != -1)
+ *pfInvalid = true;
+ break;
+
+ case 3: // 4n+3 base64 characters processed: require '='
+ if (left || p[0] != '=' || decode64_table[p[1]] != -1)
+ *pfInvalid = true;
+ break;
+ }
+
+ return vchRet;
+}
+
+string DecodeBase64(const string& str)
+{
+ vector<unsigned char> vchRet = DecodeBase64(str.c_str());
+ return string((const char*)&vchRet[0], vchRet.size());
+}
+
+
+bool WildcardMatch(const char* psz, const char* mask)
+{
+ loop
+ {
+ switch (*mask)
+ {
+ case '\0':
+ return (*psz == '\0');
+ case '*':
+ return WildcardMatch(psz, mask+1) || (*psz && WildcardMatch(psz+1, mask));
+ case '?':
+ if (*psz == '\0')
+ return false;
+ break;
+ default:
+ if (*psz != *mask)
+ return false;
+ break;
+ }
+ psz++;
+ mask++;
+ }
+}
+
+bool WildcardMatch(const string& str, const string& mask)
+{
+ return WildcardMatch(str.c_str(), mask.c_str());
+}
+
+
+
+
+
+
+
+
+void FormatException(char* pszMessage, std::exception* pex, const char* pszThread)
+{
+#ifdef WIN32
+ char pszModule[MAX_PATH];
+ pszModule[0] = '\0';
+ GetModuleFileNameA(NULL, pszModule, sizeof(pszModule));
+#else
+ const char* pszModule = "bitcoin";
+#endif
+ if (pex)
+ snprintf(pszMessage, 1000,
+ "EXCEPTION: %s \n%s \n%s in %s \n", typeid(*pex).name(), pex->what(), pszModule, pszThread);
+ else
+ snprintf(pszMessage, 1000,
+ "UNKNOWN EXCEPTION \n%s in %s \n", pszModule, pszThread);
+}
+
+void LogException(std::exception* pex, const char* pszThread)
+{
+ char pszMessage[10000];
+ FormatException(pszMessage, pex, pszThread);
+ printf("\n%s", pszMessage);
+}
+
+void PrintException(std::exception* pex, const char* pszThread)
+{
+ char pszMessage[10000];
+ FormatException(pszMessage, pex, pszThread);
+ printf("\n\n************************\n%s\n", pszMessage);
+ fprintf(stderr, "\n\n************************\n%s\n", pszMessage);
+ strMiscWarning = pszMessage;
+ throw;
+}
+
+void ThreadOneMessageBox(string strMessage)
+{
+ // Skip message boxes if one is already open
+ static bool fMessageBoxOpen;
+ if (fMessageBoxOpen)
+ return;
+ fMessageBoxOpen = true;
+ ThreadSafeMessageBox(strMessage, "Bitcoin", wxOK | wxICON_EXCLAMATION);
+ fMessageBoxOpen = false;
+}
+
+void PrintExceptionContinue(std::exception* pex, const char* pszThread)
+{
+ char pszMessage[10000];
+ FormatException(pszMessage, pex, pszThread);
+ printf("\n\n************************\n%s\n", pszMessage);
+ fprintf(stderr, "\n\n************************\n%s\n", pszMessage);
+ strMiscWarning = pszMessage;
+}
+
+
+
+
+
+
+
+
+#ifdef WIN32
+typedef WINSHELLAPI BOOL (WINAPI *PSHGETSPECIALFOLDERPATHA)(HWND hwndOwner, LPSTR lpszPath, int nFolder, BOOL fCreate);
+
+string MyGetSpecialFolderPath(int nFolder, bool fCreate)
+{
+ char pszPath[MAX_PATH+100] = "";
+
+ // SHGetSpecialFolderPath isn't always available on old Windows versions
+ HMODULE hShell32 = LoadLibraryA("shell32.dll");
+ if (hShell32)
+ {
+ PSHGETSPECIALFOLDERPATHA pSHGetSpecialFolderPath =
+ (PSHGETSPECIALFOLDERPATHA)GetProcAddress(hShell32, "SHGetSpecialFolderPathA");
+ bool fSuccess = false;
+ if (pSHGetSpecialFolderPath)
+ fSuccess =
+ (*pSHGetSpecialFolderPath)(NULL, pszPath, nFolder, fCreate);
+ FreeModule(hShell32);
+ if (fSuccess)
+ return pszPath;
+ }
+
+ // Backup option
+ std::string strPath;
+ {
+ const char *pszEnv;
+ if (nFolder == CSIDL_STARTUP)
+ {
+ pszEnv = getenv("USERPROFILE");
+ if (pszEnv)
+ strPath = pszEnv;
+ strPath += "\\Start Menu\\Programs\\Startup";
+ }
+ else if (nFolder == CSIDL_APPDATA)
+ {
+ pszEnv = getenv("APPDATA");
+ if (pszEnv)
+ strPath = pszEnv;
+ }
+ }
+
+ return strPath;
+}
+#endif
+
+string GetDefaultDataDir()
+{
+ // Windows: C:\Documents and Settings\username\Application Data\Bitcoin
+ // Mac: ~/Library/Application Support/Bitcoin
+ // Unix: ~/.bitcoin
+#ifdef WIN32
+ // Windows
+ return MyGetSpecialFolderPath(CSIDL_APPDATA, true) + "\\Bitcoin";
+#else
+ char* pszHome = getenv("HOME");
+ if (pszHome == NULL || strlen(pszHome) == 0)
+ pszHome = (char*)"/";
+ string strHome = pszHome;
+ if (strHome[strHome.size()-1] != '/')
+ strHome += '/';
+#ifdef MAC_OSX
+ // Mac
+ strHome += "Library/Application Support/";
+ filesystem::create_directory(strHome.c_str());
+ return strHome + "Bitcoin";
+#else
+ // Unix
+ return strHome + ".bitcoin";
+#endif
+#endif
+}
+
+void GetDataDir(char* pszDir)
+{
+ // pszDir must be at least MAX_PATH length.
+ int nVariation;
+ if (pszSetDataDir[0] != 0)
+ {
+ strlcpy(pszDir, pszSetDataDir, MAX_PATH);
+ nVariation = 0;
+ }
+ else
+ {
+ // This can be called during exceptions by printf, so we cache the
+ // value so we don't have to do memory allocations after that.
+ static char pszCachedDir[MAX_PATH];
+ if (pszCachedDir[0] == 0)
+ strlcpy(pszCachedDir, GetDefaultDataDir().c_str(), sizeof(pszCachedDir));
+ strlcpy(pszDir, pszCachedDir, MAX_PATH);
+ nVariation = 1;
+ }
+ if (fTestNet)
+ {
+ char* p = pszDir + strlen(pszDir);
+ if (p > pszDir && p[-1] != '/' && p[-1] != '\\')
+ *p++ = '/';
+ strcpy(p, "testnet");
+ nVariation += 2;
+ }
+ static bool pfMkdir[4];
+ if (!pfMkdir[nVariation])
+ {
+ pfMkdir[nVariation] = true;
+ boost::filesystem::create_directory(pszDir);
+ }
+}
+
+string GetDataDir()
+{
+ char pszDir[MAX_PATH];
+ GetDataDir(pszDir);
+ return pszDir;
+}
+
+string GetConfigFile()
+{
+ namespace fs = boost::filesystem;
+ fs::path pathConfig(GetArg("-conf", "bitcoin.conf"));
+ if (!pathConfig.is_complete())
+ pathConfig = fs::path(GetDataDir()) / pathConfig;
+ return pathConfig.string();
+}
+
+void ReadConfigFile(map<string, string>& mapSettingsRet,
+ map<string, vector<string> >& mapMultiSettingsRet)
+{
+ namespace fs = boost::filesystem;
+ namespace pod = boost::program_options::detail;
+
+ fs::ifstream streamConfig(GetConfigFile());
+ if (!streamConfig.good())
+ return;
+
+ set<string> setOptions;
+ setOptions.insert("*");
+
+ for (pod::config_file_iterator it(streamConfig, setOptions), end; it != end; ++it)
+ {
+ // Don't overwrite existing settings so command line settings override bitcoin.conf
+ string strKey = string("-") + it->string_key;
+ if (mapSettingsRet.count(strKey) == 0)
+ mapSettingsRet[strKey] = it->value[0];
+ mapMultiSettingsRet[strKey].push_back(it->value[0]);
+ }
+}
+
+string GetPidFile()
+{
+ namespace fs = boost::filesystem;
+ fs::path pathConfig(GetArg("-pid", "bitcoind.pid"));
+ if (!pathConfig.is_complete())
+ pathConfig = fs::path(GetDataDir()) / pathConfig;
+ return pathConfig.string();
+}
+
+void CreatePidFile(string pidFile, pid_t pid)
+{
+ FILE* file = fopen(pidFile.c_str(), "w");
+ if (file)
+ {
+ fprintf(file, "%d\n", pid);
+ fclose(file);
+ }
+}
+
+int GetFilesize(FILE* file)
+{
+ int nSavePos = ftell(file);
+ int nFilesize = -1;
+ if (fseek(file, 0, SEEK_END) == 0)
+ nFilesize = ftell(file);
+ fseek(file, nSavePos, SEEK_SET);
+ return nFilesize;
+}
+
+void ShrinkDebugFile()
+{
+ // Scroll debug.log if it's getting too big
+ string strFile = GetDataDir() + "/debug.log";
+ FILE* file = fopen(strFile.c_str(), "r");
+ if (file && GetFilesize(file) > 10 * 1000000)
+ {
+ // Restart the file with some of the end
+ char pch[200000];
+ fseek(file, -sizeof(pch), SEEK_END);
+ int nBytes = fread(pch, 1, sizeof(pch), file);
+ fclose(file);
+
+ file = fopen(strFile.c_str(), "w");
+ if (file)
+ {
+ fwrite(pch, 1, nBytes, file);
+ fclose(file);
+ }
+ }
+}
+
+
+
+
+
+
+
+
+//
+// "Never go to sea with two chronometers; take one or three."
+// Our three time sources are:
+// - System clock
+// - Median of other nodes's clocks
+// - The user (asking the user to fix the system clock if the first two disagree)
+//
+static int64 nMockTime = 0; // For unit testing
+
+int64 GetTime()
+{
+ if (nMockTime) return nMockTime;
+
+ return time(NULL);
+}
+
+void SetMockTime(int64 nMockTimeIn)
+{
+ nMockTime = nMockTimeIn;
+}
+
+static int64 nTimeOffset = 0;
+
+int64 GetAdjustedTime()
+{
+ return GetTime() + nTimeOffset;
+}
+
+void AddTimeData(unsigned int ip, int64 nTime)
+{
+ int64 nOffsetSample = nTime - GetTime();
+
+ // Ignore duplicates
+ static set<unsigned int> setKnown;
+ if (!setKnown.insert(ip).second)
+ return;
+
+ // Add data
+ static vector<int64> vTimeOffsets;
+ if (vTimeOffsets.empty())
+ vTimeOffsets.push_back(0);
+ vTimeOffsets.push_back(nOffsetSample);
+ printf("Added time data, samples %d, offset %+"PRI64d" (%+"PRI64d" minutes)\n", vTimeOffsets.size(), vTimeOffsets.back(), vTimeOffsets.back()/60);
+ if (vTimeOffsets.size() >= 5 && vTimeOffsets.size() % 2 == 1)
+ {
+ sort(vTimeOffsets.begin(), vTimeOffsets.end());
+ int64 nMedian = vTimeOffsets[vTimeOffsets.size()/2];
+ // Only let other nodes change our time by so much
+ if (abs64(nMedian) < 70 * 60)
+ {
+ nTimeOffset = nMedian;
+ }
+ else
+ {
+ nTimeOffset = 0;
+
+ static bool fDone;
+ if (!fDone)
+ {
+ // If nobody has a time different than ours but within 5 minutes of ours, give a warning
+ bool fMatch = false;
+ BOOST_FOREACH(int64 nOffset, vTimeOffsets)
+ if (nOffset != 0 && abs64(nOffset) < 5 * 60)
+ fMatch = true;
+
+ if (!fMatch)
+ {
+ fDone = true;
+ string strMessage = _("Warning: Please check that your computer's date and time are correct. If your clock is wrong Bitcoin will not work properly.");
+ strMiscWarning = strMessage;
+ printf("*** %s\n", strMessage.c_str());
+ boost::thread(boost::bind(ThreadSafeMessageBox, strMessage+" ", string("Bitcoin"), wxOK | wxICON_EXCLAMATION, (wxWindow*)NULL, -1, -1));
+ }
+ }
+ }
+ BOOST_FOREACH(int64 n, vTimeOffsets)
+ printf("%+"PRI64d" ", n);
+ printf("| nTimeOffset = %+"PRI64d" (%+"PRI64d" minutes)\n", nTimeOffset, nTimeOffset/60);
+ }
+}
+
+
+
+
+
+
+
+
+
+string FormatVersion(int nVersion)
+{
+ if (nVersion%100 == 0)
+ return strprintf("%d.%d.%d", nVersion/1000000, (nVersion/10000)%100, (nVersion/100)%100);
+ else
+ return strprintf("%d.%d.%d.%d", nVersion/1000000, (nVersion/10000)%100, (nVersion/100)%100, nVersion%100);
+}
+
+string FormatFullVersion()
+{
+ string s = FormatVersion(VERSION) + pszSubVer;
+ if (VERSION_IS_BETA) {
+ s += "-";
+ s += _("beta");
+ }
+ return s;
+}
+
+
+
+
+#ifdef DEBUG_LOCKORDER
+//
+// Early deadlock detection.
+// Problem being solved:
+// Thread 1 locks A, then B, then C
+// Thread 2 locks D, then C, then A
+// --> may result in deadlock between the two threads, depending on when they run.
+// Solution implemented here:
+// Keep track of pairs of locks: (A before B), (A before C), etc.
+// Complain if any thread trys to lock in a different order.
+//
+
+struct CLockLocation
+{
+ CLockLocation(const char* pszName, const char* pszFile, int nLine)
+ {
+ mutexName = pszName;
+ sourceFile = pszFile;
+ sourceLine = nLine;
+ }
+
+ std::string ToString() const
+ {
+ return mutexName+" "+sourceFile+":"+itostr(sourceLine);
+ }
+
+private:
+ std::string mutexName;
+ std::string sourceFile;
+ int sourceLine;
+};
+
+typedef std::vector< std::pair<CCriticalSection*, CLockLocation> > LockStack;
+
+static boost::interprocess::interprocess_mutex dd_mutex;
+static std::map<std::pair<CCriticalSection*, CCriticalSection*>, LockStack> lockorders;
+static boost::thread_specific_ptr<LockStack> lockstack;
+
+
+static void potential_deadlock_detected(const std::pair<CCriticalSection*, CCriticalSection*>& mismatch, const LockStack& s1, const LockStack& s2)
+{
+ printf("POTENTIAL DEADLOCK DETECTED\n");
+ printf("Previous lock order was:\n");
+ BOOST_FOREACH(const PAIRTYPE(CCriticalSection*, CLockLocation)& i, s2)
+ {
+ if (i.first == mismatch.first) printf(" (1)");
+ if (i.first == mismatch.second) printf(" (2)");
+ printf(" %s\n", i.second.ToString().c_str());
+ }
+ printf("Current lock order is:\n");
+ BOOST_FOREACH(const PAIRTYPE(CCriticalSection*, CLockLocation)& i, s1)
+ {
+ if (i.first == mismatch.first) printf(" (1)");
+ if (i.first == mismatch.second) printf(" (2)");
+ printf(" %s\n", i.second.ToString().c_str());
+ }
+}
+
+static void push_lock(CCriticalSection* c, const CLockLocation& locklocation)
+{
+ bool fOrderOK = true;
+ if (lockstack.get() == NULL)
+ lockstack.reset(new LockStack);
+
+ if (fDebug) printf("Locking: %s\n", locklocation.ToString().c_str());
+ dd_mutex.lock();
+
+ (*lockstack).push_back(std::make_pair(c, locklocation));
+
+ BOOST_FOREACH(const PAIRTYPE(CCriticalSection*, CLockLocation)& i, (*lockstack))
+ {
+ if (i.first == c) break;
+
+ std::pair<CCriticalSection*, CCriticalSection*> p1 = std::make_pair(i.first, c);
+ if (lockorders.count(p1))
+ continue;
+ lockorders[p1] = (*lockstack);
+
+ std::pair<CCriticalSection*, CCriticalSection*> p2 = std::make_pair(c, i.first);
+ if (lockorders.count(p2))
+ {
+ potential_deadlock_detected(p1, lockorders[p2], lockorders[p1]);
+ break;
+ }
+ }
+ dd_mutex.unlock();
+}
+
+static void pop_lock()
+{
+ if (fDebug)
+ {
+ const CLockLocation& locklocation = (*lockstack).rbegin()->second;
+ printf("Unlocked: %s\n", locklocation.ToString().c_str());
+ }
+ dd_mutex.lock();
+ (*lockstack).pop_back();
+ dd_mutex.unlock();
+}
+
+void CCriticalSection::Enter(const char* pszName, const char* pszFile, int nLine)
+{
+ push_lock(this, CLockLocation(pszName, pszFile, nLine));
+ mutex.lock();
+}
+void CCriticalSection::Leave()
+{
+ mutex.unlock();
+ pop_lock();
+}
+bool CCriticalSection::TryEnter(const char* pszName, const char* pszFile, int nLine)
+{
+ push_lock(this, CLockLocation(pszName, pszFile, nLine));
+ bool result = mutex.try_lock();
+ if (!result) pop_lock();
+ return result;
+}
+
+#else
+
+void CCriticalSection::Enter(const char*, const char*, int)
+{
+ mutex.lock();
+}
+
+void CCriticalSection::Leave()
+{
+ mutex.unlock();
+}
+
+bool CCriticalSection::TryEnter(const char*, const char*, int)
+{
+ bool result = mutex.try_lock();
+ return result;
+}
+
+#endif /* DEBUG_LOCKORDER */
diff --git a/bitcoin/src/util.h b/bitcoin/src/util.h
@@ -0,0 +1,774 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2012 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#ifndef BITCOIN_UTIL_H
+#define BITCOIN_UTIL_H
+
+#include "uint256.h"
+
+#ifndef WIN32
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#endif
+#include <map>
+#include <vector>
+#include <string>
+
+#include <boost/thread.hpp>
+#include <boost/interprocess/sync/interprocess_recursive_mutex.hpp>
+#include <boost/date_time/gregorian/gregorian_types.hpp>
+#include <boost/date_time/posix_time/posix_time_types.hpp>
+
+#include <openssl/sha.h>
+#include <openssl/ripemd.h>
+
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+typedef __int64 int64;
+typedef unsigned __int64 uint64;
+#else
+typedef long long int64;
+typedef unsigned long long uint64;
+#endif
+#if defined(_MSC_VER) && _MSC_VER < 1300
+#define for if (false) ; else for
+#endif
+#ifndef _MSC_VER
+#define __forceinline inline
+#endif
+
+#define loop for (;;)
+#define BEGIN(a) ((char*)&(a))
+#define END(a) ((char*)&((&(a))[1]))
+#define UBEGIN(a) ((unsigned char*)&(a))
+#define UEND(a) ((unsigned char*)&((&(a))[1]))
+#define ARRAYLEN(array) (sizeof(array)/sizeof((array)[0]))
+#define printf OutputDebugStringF
+
+#ifdef snprintf
+#undef snprintf
+#endif
+#define snprintf my_snprintf
+
+#ifndef PRI64d
+#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MSVCRT__)
+#define PRI64d "I64d"
+#define PRI64u "I64u"
+#define PRI64x "I64x"
+#else
+#define PRI64d "lld"
+#define PRI64u "llu"
+#define PRI64x "llx"
+#endif
+#endif
+
+// This is needed because the foreach macro can't get over the comma in pair<t1, t2>
+#define PAIRTYPE(t1, t2) std::pair<t1, t2>
+
+// Align by increasing pointer, must have extra space at end of buffer
+template <size_t nBytes, typename T>
+T* alignup(T* p)
+{
+ union
+ {
+ T* ptr;
+ size_t n;
+ } u;
+ u.ptr = p;
+ u.n = (u.n + (nBytes-1)) & ~(nBytes-1);
+ return u.ptr;
+}
+
+#ifdef WIN32
+#define MSG_NOSIGNAL 0
+#define MSG_DONTWAIT 0
+#ifndef UINT64_MAX
+#define UINT64_MAX _UI64_MAX
+#define INT64_MAX _I64_MAX
+#define INT64_MIN _I64_MIN
+#endif
+#ifndef S_IRUSR
+#define S_IRUSR 0400
+#define S_IWUSR 0200
+#endif
+#define unlink _unlink
+typedef int socklen_t;
+#else
+#define WSAGetLastError() errno
+#define WSAEINVAL EINVAL
+#define WSAEALREADY EALREADY
+#define WSAEWOULDBLOCK EWOULDBLOCK
+#define WSAEMSGSIZE EMSGSIZE
+#define WSAEINTR EINTR
+#define WSAEINPROGRESS EINPROGRESS
+#define WSAEADDRINUSE EADDRINUSE
+#define WSAENOTSOCK EBADF
+#define INVALID_SOCKET (SOCKET)(~0)
+#define SOCKET_ERROR -1
+typedef u_int SOCKET;
+#define _vsnprintf(a,b,c,d) vsnprintf(a,b,c,d)
+#define strlwr(psz) to_lower(psz)
+#define _strlwr(psz) to_lower(psz)
+#define MAX_PATH 1024
+#define Beep(n1,n2) (0)
+inline void Sleep(int64 n)
+{
+ /*Boost has a year 2038 problem- if the request sleep time is past epoch+2^31 seconds the sleep returns instantly.
+ So we clamp our sleeps here to 10 years and hope that boost is fixed by 2028.*/
+ boost::thread::sleep(boost::get_system_time() + boost::posix_time::milliseconds(n>315576000000LL?315576000000LL:n));
+}
+#endif
+
+inline int myclosesocket(SOCKET& hSocket)
+{
+ if (hSocket == INVALID_SOCKET)
+ return WSAENOTSOCK;
+#ifdef WIN32
+ int ret = closesocket(hSocket);
+#else
+ int ret = close(hSocket);
+#endif
+ hSocket = INVALID_SOCKET;
+ return ret;
+}
+#define closesocket(s) myclosesocket(s)
+#if !defined(QT_GUI)
+inline const char* _(const char* psz)
+{
+ return psz;
+}
+#endif
+
+
+
+
+
+
+
+
+
+extern std::map<std::string, std::string> mapArgs;
+extern std::map<std::string, std::vector<std::string> > mapMultiArgs;
+extern bool fDebug;
+extern bool fPrintToConsole;
+extern bool fPrintToDebugger;
+extern char pszSetDataDir[MAX_PATH];
+extern bool fRequestShutdown;
+extern bool fShutdown;
+extern bool fDaemon;
+extern bool fServer;
+extern bool fCommandLine;
+extern std::string strMiscWarning;
+extern bool fTestNet;
+extern bool fNoListen;
+extern bool fLogTimestamps;
+
+void RandAddSeed();
+void RandAddSeedPerfmon();
+int OutputDebugStringF(const char* pszFormat, ...);
+int my_snprintf(char* buffer, size_t limit, const char* format, ...);
+std::string strprintf(const std::string &format, ...);
+bool error(const std::string &format, ...);
+void LogException(std::exception* pex, const char* pszThread);
+void PrintException(std::exception* pex, const char* pszThread);
+void PrintExceptionContinue(std::exception* pex, const char* pszThread);
+void ParseString(const std::string& str, char c, std::vector<std::string>& v);
+std::string FormatMoney(int64 n, bool fPlus=false);
+bool ParseMoney(const std::string& str, int64& nRet);
+bool ParseMoney(const char* pszIn, int64& nRet);
+std::vector<unsigned char> ParseHex(const char* psz);
+std::vector<unsigned char> ParseHex(const std::string& str);
+std::vector<unsigned char> DecodeBase64(const char* p, bool* pfInvalid = NULL);
+std::string DecodeBase64(const std::string& str);
+std::string EncodeBase64(const unsigned char* pch, size_t len);
+std::string EncodeBase64(const std::string& str);
+void ParseParameters(int argc, char* argv[]);
+const char* wxGetTranslation(const char* psz);
+bool WildcardMatch(const char* psz, const char* mask);
+bool WildcardMatch(const std::string& str, const std::string& mask);
+int GetFilesize(FILE* file);
+void GetDataDir(char* pszDirRet);
+std::string GetConfigFile();
+std::string GetPidFile();
+void CreatePidFile(std::string pidFile, pid_t pid);
+void ReadConfigFile(std::map<std::string, std::string>& mapSettingsRet, std::map<std::string, std::vector<std::string> >& mapMultiSettingsRet);
+#ifdef WIN32
+std::string MyGetSpecialFolderPath(int nFolder, bool fCreate);
+#endif
+std::string GetDefaultDataDir();
+std::string GetDataDir();
+void ShrinkDebugFile();
+int GetRandInt(int nMax);
+uint64 GetRand(uint64 nMax);
+int64 GetTime();
+void SetMockTime(int64 nMockTimeIn);
+int64 GetAdjustedTime();
+void AddTimeData(unsigned int ip, int64 nTime);
+std::string FormatFullVersion();
+
+
+
+
+
+
+
+
+
+
+
+
+
+// Wrapper to automatically initialize mutex
+class CCriticalSection
+{
+protected:
+ boost::interprocess::interprocess_recursive_mutex mutex;
+public:
+ explicit CCriticalSection() { }
+ ~CCriticalSection() { }
+ void Enter(const char* pszName, const char* pszFile, int nLine);
+ void Leave();
+ bool TryEnter(const char* pszName, const char* pszFile, int nLine);
+};
+
+// Automatically leave critical section when leaving block, needed for exception safety
+class CCriticalBlock
+{
+protected:
+ CCriticalSection* pcs;
+
+public:
+ CCriticalBlock(CCriticalSection& csIn, const char* pszName, const char* pszFile, int nLine)
+ {
+ pcs = &csIn;
+ pcs->Enter(pszName, pszFile, nLine);
+ }
+
+ operator bool() const
+ {
+ return true;
+ }
+
+ ~CCriticalBlock()
+ {
+ pcs->Leave();
+ }
+};
+
+#define CRITICAL_BLOCK(cs) \
+ if (CCriticalBlock criticalblock = CCriticalBlock(cs, #cs, __FILE__, __LINE__))
+
+#define ENTER_CRITICAL_SECTION(cs) \
+ (cs).Enter(#cs, __FILE__, __LINE__)
+
+#define LEAVE_CRITICAL_SECTION(cs) \
+ (cs).Leave()
+
+class CTryCriticalBlock
+{
+protected:
+ CCriticalSection* pcs;
+
+public:
+ CTryCriticalBlock(CCriticalSection& csIn, const char* pszName, const char* pszFile, int nLine)
+ {
+ pcs = (csIn.TryEnter(pszName, pszFile, nLine) ? &csIn : NULL);
+ }
+
+ operator bool() const
+ {
+ return Entered();
+ }
+
+ ~CTryCriticalBlock()
+ {
+ if (pcs)
+ {
+ pcs->Leave();
+ }
+ }
+ bool Entered() const { return pcs != NULL; }
+};
+
+#define TRY_CRITICAL_BLOCK(cs) \
+ if (CTryCriticalBlock criticalblock = CTryCriticalBlock(cs, #cs, __FILE__, __LINE__))
+
+
+
+
+
+
+// This is exactly like std::string, but with a custom allocator.
+// (secure_allocator<> is defined in serialize.h)
+typedef std::basic_string<char, std::char_traits<char>, secure_allocator<char> > SecureString;
+
+// This is exactly like std::string, but with a custom allocator.
+// (secure_allocator<> is defined in serialize.h)
+typedef std::basic_string<char, std::char_traits<char>, secure_allocator<char> > SecureString;
+
+
+
+
+
+inline std::string i64tostr(int64 n)
+{
+ return strprintf("%"PRI64d, n);
+}
+
+inline std::string itostr(int n)
+{
+ return strprintf("%d", n);
+}
+
+inline int64 atoi64(const char* psz)
+{
+#ifdef _MSC_VER
+ return _atoi64(psz);
+#else
+ return strtoll(psz, NULL, 10);
+#endif
+}
+
+inline int64 atoi64(const std::string& str)
+{
+#ifdef _MSC_VER
+ return _atoi64(str.c_str());
+#else
+ return strtoll(str.c_str(), NULL, 10);
+#endif
+}
+
+inline int atoi(const std::string& str)
+{
+ return atoi(str.c_str());
+}
+
+inline int roundint(double d)
+{
+ return (int)(d > 0 ? d + 0.5 : d - 0.5);
+}
+
+inline int64 roundint64(double d)
+{
+ return (int64)(d > 0 ? d + 0.5 : d - 0.5);
+}
+
+inline int64 abs64(int64 n)
+{
+ return (n >= 0 ? n : -n);
+}
+
+template<typename T>
+std::string HexStr(const T itbegin, const T itend, bool fSpaces=false)
+{
+ if (itbegin == itend)
+ return "";
+ const unsigned char* pbegin = (const unsigned char*)&itbegin[0];
+ const unsigned char* pend = pbegin + (itend - itbegin) * sizeof(itbegin[0]);
+ std::string str;
+ str.reserve((pend-pbegin) * (fSpaces ? 3 : 2));
+ for (const unsigned char* p = pbegin; p != pend; p++)
+ str += strprintf((fSpaces && p != pend-1 ? "%02x " : "%02x"), *p);
+ return str;
+}
+
+inline std::string HexStr(const std::vector<unsigned char>& vch, bool fSpaces=false)
+{
+ return HexStr(vch.begin(), vch.end(), fSpaces);
+}
+
+template<typename T>
+std::string HexNumStr(const T itbegin, const T itend, bool f0x=true)
+{
+ if (itbegin == itend)
+ return "";
+ const unsigned char* pbegin = (const unsigned char*)&itbegin[0];
+ const unsigned char* pend = pbegin + (itend - itbegin) * sizeof(itbegin[0]);
+ std::string str = (f0x ? "0x" : "");
+ str.reserve(str.size() + (pend-pbegin) * 2);
+ for (const unsigned char* p = pend-1; p >= pbegin; p--)
+ str += strprintf("%02x", *p);
+ return str;
+}
+
+inline std::string HexNumStr(const std::vector<unsigned char>& vch, bool f0x=true)
+{
+ return HexNumStr(vch.begin(), vch.end(), f0x);
+}
+
+template<typename T>
+void PrintHex(const T pbegin, const T pend, const char* pszFormat="%s", bool fSpaces=true)
+{
+ printf(pszFormat, HexStr(pbegin, pend, fSpaces).c_str());
+}
+
+inline void PrintHex(const std::vector<unsigned char>& vch, const char* pszFormat="%s", bool fSpaces=true)
+{
+ printf(pszFormat, HexStr(vch, fSpaces).c_str());
+}
+
+inline int64 GetPerformanceCounter()
+{
+ int64 nCounter = 0;
+#ifdef WIN32
+ QueryPerformanceCounter((LARGE_INTEGER*)&nCounter);
+#else
+ timeval t;
+ gettimeofday(&t, NULL);
+ nCounter = t.tv_sec * 1000000 + t.tv_usec;
+#endif
+ return nCounter;
+}
+
+inline int64 GetTimeMillis()
+{
+ return (boost::posix_time::ptime(boost::posix_time::microsec_clock::universal_time()) -
+ boost::posix_time::ptime(boost::gregorian::date(1970,1,1))).total_milliseconds();
+}
+
+inline std::string DateTimeStrFormat(const char* pszFormat, int64 nTime)
+{
+ time_t n = nTime;
+ struct tm* ptmTime = gmtime(&n);
+ char pszTime[200];
+ strftime(pszTime, sizeof(pszTime), pszFormat, ptmTime);
+ return pszTime;
+}
+
+template<typename T>
+void skipspaces(T& it)
+{
+ while (isspace(*it))
+ ++it;
+}
+
+inline bool IsSwitchChar(char c)
+{
+#ifdef WIN32
+ return c == '-' || c == '/';
+#else
+ return c == '-';
+#endif
+}
+
+inline std::string GetArg(const std::string& strArg, const std::string& strDefault)
+{
+ if (mapArgs.count(strArg))
+ return mapArgs[strArg];
+ return strDefault;
+}
+
+inline int64 GetArg(const std::string& strArg, int64 nDefault)
+{
+ if (mapArgs.count(strArg))
+ return atoi64(mapArgs[strArg]);
+ return nDefault;
+}
+
+inline bool GetBoolArg(const std::string& strArg, bool fDefault=false)
+{
+ if (mapArgs.count(strArg))
+ {
+ if (mapArgs[strArg].empty())
+ return true;
+ return (atoi(mapArgs[strArg]) != 0);
+ }
+ return fDefault;
+}
+
+/**
+ * Set an argument if it doesn't already have a value
+ *
+ * @param strArg Argument to set (e.g. "-foo")
+ * @param strValue Value (e.g. "1")
+ * @return true if argument gets set, false if it already had a value
+ */
+bool SoftSetArg(const std::string& strArg, const std::string& strValue);
+
+/**
+ * Set a boolean argument if it doesn't already have a value
+ *
+ * @param strArg Argument to set (e.g. "-foo")
+ * @param fValue Value (e.g. false)
+ * @return true if argument gets set, false if it already had a value
+ */
+bool SoftSetArg(const std::string& strArg, bool fValue);
+
+
+
+
+
+
+
+
+
+inline void heapchk()
+{
+#ifdef WIN32
+ /// for debugging
+ //if (_heapchk() != _HEAPOK)
+ // DebugBreak();
+#endif
+}
+
+// Randomize the stack to help protect against buffer overrun exploits
+#define IMPLEMENT_RANDOMIZE_STACK(ThreadFn) \
+ { \
+ static char nLoops; \
+ if (nLoops <= 0) \
+ nLoops = GetRand(20) + 1; \
+ if (nLoops-- > 1) \
+ { \
+ ThreadFn; \
+ return; \
+ } \
+ }
+
+#define CATCH_PRINT_EXCEPTION(pszFn) \
+ catch (std::exception& e) { \
+ PrintException(&e, (pszFn)); \
+ } catch (...) { \
+ PrintException(NULL, (pszFn)); \
+ }
+
+
+
+
+
+
+
+
+
+
+template<typename T1>
+inline uint256 Hash(const T1 pbegin, const T1 pend)
+{
+ static unsigned char pblank[1];
+ uint256 hash1;
+ SHA256((pbegin == pend ? pblank : (unsigned char*)&pbegin[0]), (pend - pbegin) * sizeof(pbegin[0]), (unsigned char*)&hash1);
+ uint256 hash2;
+ SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);
+ return hash2;
+}
+
+template<typename T1, typename T2>
+inline uint256 Hash(const T1 p1begin, const T1 p1end,
+ const T2 p2begin, const T2 p2end)
+{
+ static unsigned char pblank[1];
+ uint256 hash1;
+ SHA256_CTX ctx;
+ SHA256_Init(&ctx);
+ SHA256_Update(&ctx, (p1begin == p1end ? pblank : (unsigned char*)&p1begin[0]), (p1end - p1begin) * sizeof(p1begin[0]));
+ SHA256_Update(&ctx, (p2begin == p2end ? pblank : (unsigned char*)&p2begin[0]), (p2end - p2begin) * sizeof(p2begin[0]));
+ SHA256_Final((unsigned char*)&hash1, &ctx);
+ uint256 hash2;
+ SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);
+ return hash2;
+}
+
+template<typename T1, typename T2, typename T3>
+inline uint256 Hash(const T1 p1begin, const T1 p1end,
+ const T2 p2begin, const T2 p2end,
+ const T3 p3begin, const T3 p3end)
+{
+ static unsigned char pblank[1];
+ uint256 hash1;
+ SHA256_CTX ctx;
+ SHA256_Init(&ctx);
+ SHA256_Update(&ctx, (p1begin == p1end ? pblank : (unsigned char*)&p1begin[0]), (p1end - p1begin) * sizeof(p1begin[0]));
+ SHA256_Update(&ctx, (p2begin == p2end ? pblank : (unsigned char*)&p2begin[0]), (p2end - p2begin) * sizeof(p2begin[0]));
+ SHA256_Update(&ctx, (p3begin == p3end ? pblank : (unsigned char*)&p3begin[0]), (p3end - p3begin) * sizeof(p3begin[0]));
+ SHA256_Final((unsigned char*)&hash1, &ctx);
+ uint256 hash2;
+ SHA256((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);
+ return hash2;
+}
+
+template<typename T>
+uint256 SerializeHash(const T& obj, int nType=SER_GETHASH, int nVersion=VERSION)
+{
+ // Most of the time is spent allocating and deallocating CDataStream's
+ // buffer. If this ever needs to be optimized further, make a CStaticStream
+ // class with its buffer on the stack.
+ CDataStream ss(nType, nVersion);
+ ss.reserve(10000);
+ ss << obj;
+ return Hash(ss.begin(), ss.end());
+}
+
+inline uint160 Hash160(const std::vector<unsigned char>& vch)
+{
+ uint256 hash1;
+ SHA256(&vch[0], vch.size(), (unsigned char*)&hash1);
+ uint160 hash2;
+ RIPEMD160((unsigned char*)&hash1, sizeof(hash1), (unsigned char*)&hash2);
+ return hash2;
+}
+
+
+// Median filter over a stream of values
+// Returns the median of the last N numbers
+template <typename T> class CMedianFilter
+{
+private:
+ std::vector<T> vValues;
+ std::vector<T> vSorted;
+ int nSize;
+public:
+ CMedianFilter(int size, T initial_value):
+ nSize(size)
+ {
+ vValues.reserve(size);
+ vValues.push_back(initial_value);
+ vSorted = vValues;
+ }
+
+ void input(T value)
+ {
+ if(vValues.size() == nSize)
+ {
+ vValues.erase(vValues.begin());
+ }
+ vValues.push_back(value);
+
+ vSorted.resize(vValues.size());
+ std::copy(vValues.begin(), vValues.end(), vSorted.begin());
+ std::sort(vSorted.begin(), vSorted.end());
+ }
+
+ T median() const
+ {
+ int size = vSorted.size();
+ assert(size>0);
+ if(size & 1) // Odd number of elements
+ {
+ return vSorted[size/2];
+ }
+ else // Even number of elements
+ {
+ return (vSorted[size/2-1] + vSorted[size/2]) / 2;
+ }
+ }
+};
+
+
+
+
+
+
+
+
+
+
+// Note: It turns out we might have been able to use boost::thread
+// by using TerminateThread(boost::thread.native_handle(), 0);
+#ifdef WIN32
+typedef HANDLE pthread_t;
+
+inline pthread_t CreateThread(void(*pfn)(void*), void* parg, bool fWantHandle=false)
+{
+ DWORD nUnused = 0;
+ HANDLE hthread =
+ CreateThread(
+ NULL, // default security
+ 0, // inherit stack size from parent
+ (LPTHREAD_START_ROUTINE)pfn, // function pointer
+ parg, // argument
+ 0, // creation option, start immediately
+ &nUnused); // thread identifier
+ if (hthread == NULL)
+ {
+ printf("Error: CreateThread() returned %d\n", GetLastError());
+ return (pthread_t)0;
+ }
+ if (!fWantHandle)
+ {
+ CloseHandle(hthread);
+ return (pthread_t)-1;
+ }
+ return hthread;
+}
+
+inline void SetThreadPriority(int nPriority)
+{
+ SetThreadPriority(GetCurrentThread(), nPriority);
+}
+#else
+inline pthread_t CreateThread(void(*pfn)(void*), void* parg, bool fWantHandle=false)
+{
+ pthread_t hthread = 0;
+ int ret = pthread_create(&hthread, NULL, (void*(*)(void*))pfn, parg);
+ if (ret != 0)
+ {
+ printf("Error: pthread_create() returned %d\n", ret);
+ return (pthread_t)0;
+ }
+ if (!fWantHandle)
+ {
+ pthread_detach(hthread);
+ return (pthread_t)-1;
+ }
+ return hthread;
+}
+
+#define THREAD_PRIORITY_LOWEST PRIO_MAX
+#define THREAD_PRIORITY_BELOW_NORMAL 2
+#define THREAD_PRIORITY_NORMAL 0
+#define THREAD_PRIORITY_ABOVE_NORMAL 0
+
+inline void SetThreadPriority(int nPriority)
+{
+ // It's unclear if it's even possible to change thread priorities on Linux,
+ // but we really and truly need it for the generation threads.
+#ifdef PRIO_THREAD
+ setpriority(PRIO_THREAD, 0, nPriority);
+#else
+ setpriority(PRIO_PROCESS, 0, nPriority);
+#endif
+}
+
+inline bool TerminateThread(pthread_t hthread, unsigned int nExitCode)
+{
+ return (pthread_cancel(hthread) == 0);
+}
+
+inline void ExitThread(size_t nExitCode)
+{
+ pthread_exit((void*)nExitCode);
+}
+#endif
+
+
+
+
+
+inline bool AffinityBugWorkaround(void(*pfn)(void*))
+{
+#ifdef WIN32
+ // Sometimes after a few hours affinity gets stuck on one processor
+ DWORD_PTR dwProcessAffinityMask = -1;
+ DWORD_PTR dwSystemAffinityMask = -1;
+ GetProcessAffinityMask(GetCurrentProcess(), &dwProcessAffinityMask, &dwSystemAffinityMask);
+ DWORD dwPrev1 = SetThreadAffinityMask(GetCurrentThread(), dwProcessAffinityMask);
+ DWORD dwPrev2 = SetThreadAffinityMask(GetCurrentThread(), dwProcessAffinityMask);
+ if (dwPrev2 != dwProcessAffinityMask)
+ {
+ printf("AffinityBugWorkaround() : SetThreadAffinityMask=%d, ProcessAffinityMask=%d, restarting thread\n", dwPrev2, dwProcessAffinityMask);
+ if (!CreateThread(pfn, NULL))
+ printf("Error: CreateThread() failed\n");
+ return true;
+ }
+#endif
+ return false;
+}
+
+inline uint32_t ByteReverse(uint32_t value)
+{
+ value = ((value & 0xFF00FF00) >> 8) | ((value & 0x00FF00FF) << 8);
+ return (value<<16) | (value>>16);
+}
+
+#endif
diff --git a/bitcoin/src/wallet.cpp b/bitcoin/src/wallet.cpp
@@ -0,0 +1,1415 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2011 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+
+#include "headers.h"
+#include "db.h"
+#include "crypter.h"
+
+using namespace std;
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// mapWallet
+//
+
+bool CWallet::AddKey(const CKey& key)
+{
+ if (!CCryptoKeyStore::AddKey(key))
+ return false;
+ if (!fFileBacked)
+ return true;
+ if (!IsCrypted())
+ return CWalletDB(strWalletFile).WriteKey(key.GetPubKey(), key.GetPrivKey());
+ return true;
+}
+
+bool CWallet::AddCryptedKey(const vector<unsigned char> &vchPubKey, const vector<unsigned char> &vchCryptedSecret)
+{
+ if (!CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret))
+ return false;
+ if (!fFileBacked)
+ return true;
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ if (pwalletdbEncryption)
+ return pwalletdbEncryption->WriteCryptedKey(vchPubKey, vchCryptedSecret);
+ else
+ return CWalletDB(strWalletFile).WriteCryptedKey(vchPubKey, vchCryptedSecret);
+ }
+ return false;
+}
+
+bool CWallet::Unlock(const SecureString& strWalletPassphrase)
+{
+ if (!IsLocked())
+ return false;
+
+ CCrypter crypter;
+ CKeyingMaterial vMasterKey;
+
+ CRITICAL_BLOCK(cs_wallet)
+ BOOST_FOREACH(const MasterKeyMap::value_type& pMasterKey, mapMasterKeys)
+ {
+ if(!crypter.SetKeyFromPassphrase(strWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
+ return false;
+ if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, vMasterKey))
+ return false;
+ if (CCryptoKeyStore::Unlock(vMasterKey))
+ return true;
+ }
+ return false;
+}
+
+bool CWallet::ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase)
+{
+ bool fWasLocked = IsLocked();
+
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ Lock();
+
+ CCrypter crypter;
+ CKeyingMaterial vMasterKey;
+ BOOST_FOREACH(MasterKeyMap::value_type& pMasterKey, mapMasterKeys)
+ {
+ if(!crypter.SetKeyFromPassphrase(strOldWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
+ return false;
+ if (!crypter.Decrypt(pMasterKey.second.vchCryptedKey, vMasterKey))
+ return false;
+ if (CCryptoKeyStore::Unlock(vMasterKey))
+ {
+ int64 nStartTime = GetTimeMillis();
+ crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
+ pMasterKey.second.nDeriveIterations = pMasterKey.second.nDeriveIterations * (100 / ((double)(GetTimeMillis() - nStartTime)));
+
+ nStartTime = GetTimeMillis();
+ crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod);
+ pMasterKey.second.nDeriveIterations = (pMasterKey.second.nDeriveIterations + pMasterKey.second.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime))) / 2;
+
+ if (pMasterKey.second.nDeriveIterations < 25000)
+ pMasterKey.second.nDeriveIterations = 25000;
+
+ printf("Wallet passphrase changed to an nDeriveIterations of %i\n", pMasterKey.second.nDeriveIterations);
+
+ if (!crypter.SetKeyFromPassphrase(strNewWalletPassphrase, pMasterKey.second.vchSalt, pMasterKey.second.nDeriveIterations, pMasterKey.second.nDerivationMethod))
+ return false;
+ if (!crypter.Encrypt(vMasterKey, pMasterKey.second.vchCryptedKey))
+ return false;
+ CWalletDB(strWalletFile).WriteMasterKey(pMasterKey.first, pMasterKey.second);
+ if (fWasLocked)
+ Lock();
+ return true;
+ }
+ }
+ }
+
+ return false;
+}
+
+
+// This class implements an addrIncoming entry that causes pre-0.4
+// clients to crash on startup if reading a private-key-encrypted wallet.
+class CCorruptAddress
+{
+public:
+ IMPLEMENT_SERIALIZE
+ (
+ if (nType & SER_DISK)
+ READWRITE(nVersion);
+ )
+};
+
+bool CWallet::EncryptWallet(const SecureString& strWalletPassphrase)
+{
+ if (IsCrypted())
+ return false;
+
+ CKeyingMaterial vMasterKey;
+ RandAddSeedPerfmon();
+
+ vMasterKey.resize(WALLET_CRYPTO_KEY_SIZE);
+ RAND_bytes(&vMasterKey[0], WALLET_CRYPTO_KEY_SIZE);
+
+ CMasterKey kMasterKey;
+
+ RandAddSeedPerfmon();
+ kMasterKey.vchSalt.resize(WALLET_CRYPTO_SALT_SIZE);
+ RAND_bytes(&kMasterKey.vchSalt[0], WALLET_CRYPTO_SALT_SIZE);
+
+ CCrypter crypter;
+ int64 nStartTime = GetTimeMillis();
+ crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, 25000, kMasterKey.nDerivationMethod);
+ kMasterKey.nDeriveIterations = 2500000 / ((double)(GetTimeMillis() - nStartTime));
+
+ nStartTime = GetTimeMillis();
+ crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, kMasterKey.nDeriveIterations, kMasterKey.nDerivationMethod);
+ kMasterKey.nDeriveIterations = (kMasterKey.nDeriveIterations + kMasterKey.nDeriveIterations * 100 / ((double)(GetTimeMillis() - nStartTime))) / 2;
+
+ if (kMasterKey.nDeriveIterations < 25000)
+ kMasterKey.nDeriveIterations = 25000;
+
+ printf("Encrypting Wallet with an nDeriveIterations of %i\n", kMasterKey.nDeriveIterations);
+
+ if (!crypter.SetKeyFromPassphrase(strWalletPassphrase, kMasterKey.vchSalt, kMasterKey.nDeriveIterations, kMasterKey.nDerivationMethod))
+ return false;
+ if (!crypter.Encrypt(vMasterKey, kMasterKey.vchCryptedKey))
+ return false;
+
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ mapMasterKeys[++nMasterKeyMaxID] = kMasterKey;
+ if (fFileBacked)
+ {
+ pwalletdbEncryption = new CWalletDB(strWalletFile);
+ pwalletdbEncryption->TxnBegin();
+ pwalletdbEncryption->WriteMasterKey(nMasterKeyMaxID, kMasterKey);
+ }
+
+ if (!EncryptKeys(vMasterKey))
+ {
+ if (fFileBacked)
+ pwalletdbEncryption->TxnAbort();
+ exit(1); //We now probably have half of our keys encrypted in memory, and half not...die and let the user reload their unencrypted wallet.
+ }
+
+ if (fFileBacked)
+ {
+ CCorruptAddress corruptAddress;
+ pwalletdbEncryption->WriteSetting("addrIncoming", corruptAddress);
+ if (!pwalletdbEncryption->TxnCommit())
+ exit(1); //We now have keys encrypted in memory, but no on disk...die to avoid confusion and let the user reload their unencrypted wallet.
+
+ delete pwalletdbEncryption;
+ pwalletdbEncryption = NULL;
+ }
+
+ Lock();
+ Unlock(strWalletPassphrase);
+ NewKeyPool();
+ Lock();
+
+ // Need to completely rewrite the wallet file; if we don't, bdb might keep
+ // bits of the unencrypted private key in slack space in the database file.
+ CDB::Rewrite(strWalletFile);
+ }
+
+ return true;
+}
+
+void CWallet::WalletUpdateSpent(const CTransaction &tx)
+{
+ // Anytime a signature is successfully verified, it's proof the outpoint is spent.
+ // Update the wallet spent flag if it doesn't know due to wallet.dat being
+ // restored from backup or the user making copies of wallet.dat.
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ BOOST_FOREACH(const CTxIn& txin, tx.vin)
+ {
+ map<uint256, CWalletTx>::iterator mi = mapWallet.find(txin.prevout.hash);
+ if (mi != mapWallet.end())
+ {
+ CWalletTx& wtx = (*mi).second;
+ if (!wtx.IsSpent(txin.prevout.n) && IsMine(wtx.vout[txin.prevout.n]))
+ {
+ printf("WalletUpdateSpent found spent coin %sbc %s\n", FormatMoney(wtx.GetCredit()).c_str(), wtx.GetHash().ToString().c_str());
+ wtx.MarkSpent(txin.prevout.n);
+ wtx.WriteToDisk();
+ vWalletUpdated.push_back(txin.prevout.hash);
+ }
+ }
+ }
+ }
+}
+
+bool CWallet::AddToWallet(const CWalletTx& wtxIn)
+{
+ uint256 hash = wtxIn.GetHash();
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ // Inserts only if not already there, returns tx inserted or tx found
+ pair<map<uint256, CWalletTx>::iterator, bool> ret = mapWallet.insert(make_pair(hash, wtxIn));
+ CWalletTx& wtx = (*ret.first).second;
+ wtx.pwallet = this;
+ bool fInsertedNew = ret.second;
+ if (fInsertedNew)
+ wtx.nTimeReceived = GetAdjustedTime();
+
+ bool fUpdated = false;
+ if (!fInsertedNew)
+ {
+ // Merge
+ if (wtxIn.hashBlock != 0 && wtxIn.hashBlock != wtx.hashBlock)
+ {
+ wtx.hashBlock = wtxIn.hashBlock;
+ fUpdated = true;
+ }
+ if (wtxIn.nIndex != -1 && (wtxIn.vMerkleBranch != wtx.vMerkleBranch || wtxIn.nIndex != wtx.nIndex))
+ {
+ wtx.vMerkleBranch = wtxIn.vMerkleBranch;
+ wtx.nIndex = wtxIn.nIndex;
+ fUpdated = true;
+ }
+ if (wtxIn.fFromMe && wtxIn.fFromMe != wtx.fFromMe)
+ {
+ wtx.fFromMe = wtxIn.fFromMe;
+ fUpdated = true;
+ }
+ fUpdated |= wtx.UpdateSpent(wtxIn.vfSpent);
+ }
+
+ //// debug print
+ printf("AddToWallet %s %s%s\n", wtxIn.GetHash().ToString().substr(0,10).c_str(), (fInsertedNew ? "new" : ""), (fUpdated ? "update" : ""));
+
+ // Write to disk
+ if (fInsertedNew || fUpdated)
+ if (!wtx.WriteToDisk())
+ return false;
+#ifndef QT_GUI
+ // If default receiving address gets used, replace it with a new one
+ CScript scriptDefaultKey;
+ scriptDefaultKey.SetBitcoinAddress(vchDefaultKey);
+ BOOST_FOREACH(const CTxOut& txout, wtx.vout)
+ {
+ if (txout.scriptPubKey == scriptDefaultKey)
+ {
+ std::vector<unsigned char> newDefaultKey;
+ if (GetKeyFromPool(newDefaultKey, false))
+ {
+ SetDefaultKey(newDefaultKey);
+ SetAddressBookName(CBitcoinAddress(vchDefaultKey), "");
+ }
+ }
+ }
+#endif
+ // Notify UI
+ vWalletUpdated.push_back(hash);
+
+ // since AddToWallet is called directly for self-originating transactions, check for consumption of own coins
+ WalletUpdateSpent(wtx);
+ }
+
+ // Refresh UI
+ MainFrameRepaint();
+ return true;
+}
+
+// Add a transaction to the wallet, or update it.
+// pblock is optional, but should be provided if the transaction is known to be in a block.
+// If fUpdate is true, existing transactions will be updated.
+bool CWallet::AddToWalletIfInvolvingMe(const CTransaction& tx, const CBlock* pblock, bool fUpdate)
+{
+ uint256 hash = tx.GetHash();
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ bool fExisted = mapWallet.count(hash);
+ if (fExisted && !fUpdate) return false;
+ if (fExisted || IsMine(tx) || IsFromMe(tx))
+ {
+ CWalletTx wtx(this,tx);
+ // Get merkle branch if transaction was found in a block
+ if (pblock)
+ wtx.SetMerkleBranch(pblock);
+ return AddToWallet(wtx);
+ }
+ else
+ WalletUpdateSpent(tx);
+ }
+ return false;
+}
+
+bool CWallet::EraseFromWallet(uint256 hash)
+{
+ if (!fFileBacked)
+ return false;
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ if (mapWallet.erase(hash))
+ CWalletDB(strWalletFile).EraseTx(hash);
+ }
+ return true;
+}
+
+
+bool CWallet::IsMine(const CTxIn &txin) const
+{
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(txin.prevout.hash);
+ if (mi != mapWallet.end())
+ {
+ const CWalletTx& prev = (*mi).second;
+ if (txin.prevout.n < prev.vout.size())
+ if (IsMine(prev.vout[txin.prevout.n]))
+ return true;
+ }
+ }
+ return false;
+}
+
+int64 CWallet::GetDebit(const CTxIn &txin) const
+{
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ map<uint256, CWalletTx>::const_iterator mi = mapWallet.find(txin.prevout.hash);
+ if (mi != mapWallet.end())
+ {
+ const CWalletTx& prev = (*mi).second;
+ if (txin.prevout.n < prev.vout.size())
+ if (IsMine(prev.vout[txin.prevout.n]))
+ return prev.vout[txin.prevout.n].nValue;
+ }
+ }
+ return 0;
+}
+
+int64 CWalletTx::GetTxTime() const
+{
+ return nTimeReceived;
+}
+
+int CWalletTx::GetRequestCount() const
+{
+ // Returns -1 if it wasn't being tracked
+ int nRequests = -1;
+ CRITICAL_BLOCK(pwallet->cs_wallet)
+ {
+ if (IsCoinBase())
+ {
+ // Generated block
+ if (hashBlock != 0)
+ {
+ map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(hashBlock);
+ if (mi != pwallet->mapRequestCount.end())
+ nRequests = (*mi).second;
+ }
+ }
+ else
+ {
+ // Did anyone request this transaction?
+ map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(GetHash());
+ if (mi != pwallet->mapRequestCount.end())
+ {
+ nRequests = (*mi).second;
+
+ // How about the block it's in?
+ if (nRequests == 0 && hashBlock != 0)
+ {
+ map<uint256, int>::const_iterator mi = pwallet->mapRequestCount.find(hashBlock);
+ if (mi != pwallet->mapRequestCount.end())
+ nRequests = (*mi).second;
+ else
+ nRequests = 1; // If it's in someone else's block it must have got out
+ }
+ }
+ }
+ }
+ return nRequests;
+}
+
+void CWalletTx::GetAmounts(int64& nGeneratedImmature, int64& nGeneratedMature, list<pair<CBitcoinAddress, int64> >& listReceived,
+ list<pair<CBitcoinAddress, int64> >& listSent, int64& nFee, string& strSentAccount) const
+{
+ nGeneratedImmature = nGeneratedMature = nFee = 0;
+ listReceived.clear();
+ listSent.clear();
+ strSentAccount = strFromAccount;
+
+ if (IsCoinBase())
+ {
+ if (GetBlocksToMaturity() > 0)
+ nGeneratedImmature = pwallet->GetCredit(*this);
+ else
+ nGeneratedMature = GetCredit();
+ return;
+ }
+
+ // Compute fee:
+ int64 nDebit = GetDebit();
+ if (nDebit > 0) // debit>0 means we signed/sent this transaction
+ {
+ int64 nValueOut = GetValueOut();
+ nFee = nDebit - nValueOut;
+ }
+
+ // Sent/received. Standard client will never generate a send-to-multiple-recipients,
+ // but non-standard clients might (so return a list of address/amount pairs)
+ BOOST_FOREACH(const CTxOut& txout, vout)
+ {
+ CBitcoinAddress address;
+ vector<unsigned char> vchPubKey;
+ if (!ExtractAddress(txout.scriptPubKey, NULL, address))
+ {
+ printf("CWalletTx::GetAmounts: Unknown transaction type found, txid %s\n",
+ this->GetHash().ToString().c_str());
+ address = " unknown ";
+ }
+
+ // Don't report 'change' txouts
+ if (nDebit > 0 && pwallet->IsChange(txout))
+ continue;
+
+ if (nDebit > 0)
+ listSent.push_back(make_pair(address, txout.nValue));
+
+ if (pwallet->IsMine(txout))
+ listReceived.push_back(make_pair(address, txout.nValue));
+ }
+
+}
+
+void CWalletTx::GetAccountAmounts(const string& strAccount, int64& nGenerated, int64& nReceived,
+ int64& nSent, int64& nFee) const
+{
+ nGenerated = nReceived = nSent = nFee = 0;
+
+ int64 allGeneratedImmature, allGeneratedMature, allFee;
+ allGeneratedImmature = allGeneratedMature = allFee = 0;
+ string strSentAccount;
+ list<pair<CBitcoinAddress, int64> > listReceived;
+ list<pair<CBitcoinAddress, int64> > listSent;
+ GetAmounts(allGeneratedImmature, allGeneratedMature, listReceived, listSent, allFee, strSentAccount);
+
+ if (strAccount == "")
+ nGenerated = allGeneratedMature;
+ if (strAccount == strSentAccount)
+ {
+ BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress,int64)& s, listSent)
+ nSent += s.second;
+ nFee = allFee;
+ }
+ CRITICAL_BLOCK(pwallet->cs_wallet)
+ {
+ BOOST_FOREACH(const PAIRTYPE(CBitcoinAddress,int64)& r, listReceived)
+ {
+ if (pwallet->mapAddressBook.count(r.first))
+ {
+ map<CBitcoinAddress, string>::const_iterator mi = pwallet->mapAddressBook.find(r.first);
+ if (mi != pwallet->mapAddressBook.end() && (*mi).second == strAccount)
+ nReceived += r.second;
+ }
+ else if (strAccount.empty())
+ {
+ nReceived += r.second;
+ }
+ }
+ }
+}
+
+void CWalletTx::AddSupportingTransactions(CTxDB& txdb)
+{
+ vtxPrev.clear();
+
+ const int COPY_DEPTH = 3;
+ if (SetMerkleBranch() < COPY_DEPTH)
+ {
+ vector<uint256> vWorkQueue;
+ BOOST_FOREACH(const CTxIn& txin, vin)
+ vWorkQueue.push_back(txin.prevout.hash);
+
+ // This critsect is OK because txdb is already open
+ CRITICAL_BLOCK(pwallet->cs_wallet)
+ {
+ map<uint256, const CMerkleTx*> mapWalletPrev;
+ set<uint256> setAlreadyDone;
+ for (int i = 0; i < vWorkQueue.size(); i++)
+ {
+ uint256 hash = vWorkQueue[i];
+ if (setAlreadyDone.count(hash))
+ continue;
+ setAlreadyDone.insert(hash);
+
+ CMerkleTx tx;
+ map<uint256, CWalletTx>::const_iterator mi = pwallet->mapWallet.find(hash);
+ if (mi != pwallet->mapWallet.end())
+ {
+ tx = (*mi).second;
+ BOOST_FOREACH(const CMerkleTx& txWalletPrev, (*mi).second.vtxPrev)
+ mapWalletPrev[txWalletPrev.GetHash()] = &txWalletPrev;
+ }
+ else if (mapWalletPrev.count(hash))
+ {
+ tx = *mapWalletPrev[hash];
+ }
+ else if (!fClient && txdb.ReadDiskTx(hash, tx))
+ {
+ ;
+ }
+ else
+ {
+ printf("ERROR: AddSupportingTransactions() : unsupported transaction\n");
+ continue;
+ }
+
+ int nDepth = tx.SetMerkleBranch();
+ vtxPrev.push_back(tx);
+
+ if (nDepth < COPY_DEPTH)
+ BOOST_FOREACH(const CTxIn& txin, tx.vin)
+ vWorkQueue.push_back(txin.prevout.hash);
+ }
+ }
+ }
+
+ reverse(vtxPrev.begin(), vtxPrev.end());
+}
+
+bool CWalletTx::WriteToDisk()
+{
+ return CWalletDB(pwallet->strWalletFile).WriteTx(GetHash(), *this);
+}
+
+// Scan the block chain (starting in pindexStart) for transactions
+// from or to us. If fUpdate is true, found transactions that already
+// exist in the wallet will be updated.
+int CWallet::ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate)
+{
+ int ret = 0;
+
+ CBlockIndex* pindex = pindexStart;
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ while (pindex)
+ {
+ CBlock block;
+ block.ReadFromDisk(pindex, true);
+ BOOST_FOREACH(CTransaction& tx, block.vtx)
+ {
+ if (AddToWalletIfInvolvingMe(tx, &block, fUpdate))
+ ret++;
+ }
+ pindex = pindex->pnext;
+ }
+ }
+ return ret;
+}
+
+void CWallet::ReacceptWalletTransactions()
+{
+ CTxDB txdb("r");
+ bool fRepeat = true;
+ while (fRepeat) CRITICAL_BLOCK(cs_wallet)
+ {
+ fRepeat = false;
+ vector<CDiskTxPos> vMissingTx;
+ BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
+ {
+ CWalletTx& wtx = item.second;
+ if (wtx.IsCoinBase() && wtx.IsSpent(0))
+ continue;
+
+ CTxIndex txindex;
+ bool fUpdated = false;
+ if (txdb.ReadTxIndex(wtx.GetHash(), txindex))
+ {
+ // Update fSpent if a tx got spent somewhere else by a copy of wallet.dat
+ if (txindex.vSpent.size() != wtx.vout.size())
+ {
+ printf("ERROR: ReacceptWalletTransactions() : txindex.vSpent.size() %d != wtx.vout.size() %d\n", txindex.vSpent.size(), wtx.vout.size());
+ continue;
+ }
+ for (int i = 0; i < txindex.vSpent.size(); i++)
+ {
+ if (wtx.IsSpent(i))
+ continue;
+ if (!txindex.vSpent[i].IsNull() && IsMine(wtx.vout[i]))
+ {
+ wtx.MarkSpent(i);
+ fUpdated = true;
+ vMissingTx.push_back(txindex.vSpent[i]);
+ }
+ }
+ if (fUpdated)
+ {
+ printf("ReacceptWalletTransactions found spent coin %sbc %s\n", FormatMoney(wtx.GetCredit()).c_str(), wtx.GetHash().ToString().c_str());
+ wtx.MarkDirty();
+ wtx.WriteToDisk();
+ }
+ }
+ else
+ {
+ // Reaccept any txes of ours that aren't already in a block
+ if (!wtx.IsCoinBase())
+ wtx.AcceptWalletTransaction(txdb, false);
+ }
+ }
+ if (!vMissingTx.empty())
+ {
+ // TODO: optimize this to scan just part of the block chain?
+ if (ScanForWalletTransactions(pindexGenesisBlock))
+ fRepeat = true; // Found missing transactions: re-do Reaccept.
+ }
+ }
+}
+
+void CWalletTx::RelayWalletTransaction(CTxDB& txdb)
+{
+ BOOST_FOREACH(const CMerkleTx& tx, vtxPrev)
+ {
+ if (!tx.IsCoinBase())
+ {
+ uint256 hash = tx.GetHash();
+ if (!txdb.ContainsTx(hash))
+ RelayMessage(CInv(MSG_TX, hash), (CTransaction)tx);
+ }
+ }
+ if (!IsCoinBase())
+ {
+ uint256 hash = GetHash();
+ if (!txdb.ContainsTx(hash))
+ {
+ printf("Relaying wtx %s\n", hash.ToString().substr(0,10).c_str());
+ RelayMessage(CInv(MSG_TX, hash), (CTransaction)*this);
+ }
+ }
+}
+
+void CWalletTx::RelayWalletTransaction()
+{
+ CTxDB txdb("r");
+ RelayWalletTransaction(txdb);
+}
+
+void CWallet::ResendWalletTransactions()
+{
+ // Do this infrequently and randomly to avoid giving away
+ // that these are our transactions.
+ static int64 nNextTime;
+ if (GetTime() < nNextTime)
+ return;
+ bool fFirst = (nNextTime == 0);
+ nNextTime = GetTime() + GetRand(30 * 60);
+ if (fFirst)
+ return;
+
+ // Only do it if there's been a new block since last time
+ static int64 nLastTime;
+ if (nTimeBestReceived < nLastTime)
+ return;
+ nLastTime = GetTime();
+
+ // Rebroadcast any of our txes that aren't in a block yet
+ printf("ResendWalletTransactions()\n");
+ CTxDB txdb("r");
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ // Sort them in chronological order
+ multimap<unsigned int, CWalletTx*> mapSorted;
+ BOOST_FOREACH(PAIRTYPE(const uint256, CWalletTx)& item, mapWallet)
+ {
+ CWalletTx& wtx = item.second;
+ // Don't rebroadcast until it's had plenty of time that
+ // it should have gotten in already by now.
+ if (nTimeBestReceived - (int64)wtx.nTimeReceived > 5 * 60)
+ mapSorted.insert(make_pair(wtx.nTimeReceived, &wtx));
+ }
+ BOOST_FOREACH(PAIRTYPE(const unsigned int, CWalletTx*)& item, mapSorted)
+ {
+ CWalletTx& wtx = *item.second;
+ wtx.RelayWalletTransaction(txdb);
+ }
+ }
+}
+
+
+
+
+
+
+//////////////////////////////////////////////////////////////////////////////
+//
+// Actions
+//
+
+
+int64 CWallet::GetBalance() const
+{
+ int64 nTotal = 0;
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
+ {
+ const CWalletTx* pcoin = &(*it).second;
+ if (!pcoin->IsFinal() || !pcoin->IsConfirmed())
+ continue;
+ nTotal += pcoin->GetAvailableCredit();
+ }
+ }
+
+ return nTotal;
+}
+
+int64 CWallet::GetUnconfirmedBalance() const
+{
+ int64 nTotal = 0;
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
+ {
+ const CWalletTx* pcoin = &(*it).second;
+ if (pcoin->IsFinal() && pcoin->IsConfirmed())
+ continue;
+ nTotal += pcoin->GetAvailableCredit();
+ }
+ }
+ return nTotal;
+}
+
+bool CWallet::SelectCoinsMinConf(int64 nTargetValue, int nConfMine, int nConfTheirs, set<pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64& nValueRet) const
+{
+ setCoinsRet.clear();
+ nValueRet = 0;
+
+ // List of values less than target
+ pair<int64, pair<const CWalletTx*,unsigned int> > coinLowestLarger;
+ coinLowestLarger.first = INT64_MAX;
+ coinLowestLarger.second.first = NULL;
+ vector<pair<int64, pair<const CWalletTx*,unsigned int> > > vValue;
+ int64 nTotalLower = 0;
+
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ vector<const CWalletTx*> vCoins;
+ vCoins.reserve(mapWallet.size());
+ for (map<uint256, CWalletTx>::const_iterator it = mapWallet.begin(); it != mapWallet.end(); ++it)
+ vCoins.push_back(&(*it).second);
+ random_shuffle(vCoins.begin(), vCoins.end(), GetRandInt);
+
+ BOOST_FOREACH(const CWalletTx* pcoin, vCoins)
+ {
+ if (!pcoin->IsFinal() || !pcoin->IsConfirmed())
+ continue;
+
+ if (pcoin->IsCoinBase() && pcoin->GetBlocksToMaturity() > 0)
+ continue;
+
+ int nDepth = pcoin->GetDepthInMainChain();
+ if (nDepth < (pcoin->IsFromMe() ? nConfMine : nConfTheirs))
+ continue;
+
+ for (int i = 0; i < pcoin->vout.size(); i++)
+ {
+ if (pcoin->IsSpent(i) || !IsMine(pcoin->vout[i]))
+ continue;
+
+ int64 n = pcoin->vout[i].nValue;
+
+ if (n <= 0)
+ continue;
+
+ pair<int64,pair<const CWalletTx*,unsigned int> > coin = make_pair(n,make_pair(pcoin,i));
+
+ if (n == nTargetValue)
+ {
+ setCoinsRet.insert(coin.second);
+ nValueRet += coin.first;
+ return true;
+ }
+ else if (n < nTargetValue + CENT)
+ {
+ vValue.push_back(coin);
+ nTotalLower += n;
+ }
+ else if (n < coinLowestLarger.first)
+ {
+ coinLowestLarger = coin;
+ }
+ }
+ }
+ }
+
+ if (nTotalLower == nTargetValue || nTotalLower == nTargetValue + CENT)
+ {
+ for (int i = 0; i < vValue.size(); ++i)
+ {
+ setCoinsRet.insert(vValue[i].second);
+ nValueRet += vValue[i].first;
+ }
+ return true;
+ }
+
+ if (nTotalLower < nTargetValue + (coinLowestLarger.second.first ? CENT : 0))
+ {
+ if (coinLowestLarger.second.first == NULL)
+ return false;
+ setCoinsRet.insert(coinLowestLarger.second);
+ nValueRet += coinLowestLarger.first;
+ return true;
+ }
+
+ if (nTotalLower >= nTargetValue + CENT)
+ nTargetValue += CENT;
+
+ // Solve subset sum by stochastic approximation
+ sort(vValue.rbegin(), vValue.rend());
+ vector<char> vfIncluded;
+ vector<char> vfBest(vValue.size(), true);
+ int64 nBest = nTotalLower;
+
+ for (int nRep = 0; nRep < 1000 && nBest != nTargetValue; nRep++)
+ {
+ vfIncluded.assign(vValue.size(), false);
+ int64 nTotal = 0;
+ bool fReachedTarget = false;
+ for (int nPass = 0; nPass < 2 && !fReachedTarget; nPass++)
+ {
+ for (int i = 0; i < vValue.size(); i++)
+ {
+ if (nPass == 0 ? rand() % 2 : !vfIncluded[i])
+ {
+ nTotal += vValue[i].first;
+ vfIncluded[i] = true;
+ if (nTotal >= nTargetValue)
+ {
+ fReachedTarget = true;
+ if (nTotal < nBest)
+ {
+ nBest = nTotal;
+ vfBest = vfIncluded;
+ }
+ nTotal -= vValue[i].first;
+ vfIncluded[i] = false;
+ }
+ }
+ }
+ }
+ }
+
+ // If the next larger is still closer, return it
+ if (coinLowestLarger.second.first && coinLowestLarger.first - nTargetValue <= nBest - nTargetValue)
+ {
+ setCoinsRet.insert(coinLowestLarger.second);
+ nValueRet += coinLowestLarger.first;
+ }
+ else {
+ for (int i = 0; i < vValue.size(); i++)
+ if (vfBest[i])
+ {
+ setCoinsRet.insert(vValue[i].second);
+ nValueRet += vValue[i].first;
+ }
+
+ //// debug print
+ printf("SelectCoins() best subset: ");
+ for (int i = 0; i < vValue.size(); i++)
+ if (vfBest[i])
+ printf("%s ", FormatMoney(vValue[i].first).c_str());
+ printf("total %s\n", FormatMoney(nBest).c_str());
+ }
+
+ return true;
+}
+
+bool CWallet::SelectCoins(int64 nTargetValue, set<pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64& nValueRet) const
+{
+ return (SelectCoinsMinConf(nTargetValue, 1, 6, setCoinsRet, nValueRet) ||
+ SelectCoinsMinConf(nTargetValue, 1, 1, setCoinsRet, nValueRet) ||
+ SelectCoinsMinConf(nTargetValue, 0, 1, setCoinsRet, nValueRet));
+}
+
+
+
+
+bool CWallet::CreateTransaction(const vector<pair<CScript, int64> >& vecSend, CWalletTx& wtxNew, CReserveKey& reservekey, int64& nFeeRet)
+{
+ int64 nValue = 0;
+ BOOST_FOREACH (const PAIRTYPE(CScript, int64)& s, vecSend)
+ {
+ if (nValue < 0)
+ return false;
+ nValue += s.second;
+ }
+ if (vecSend.empty() || nValue < 0)
+ return false;
+
+ wtxNew.pwallet = this;
+
+ CRITICAL_BLOCK(cs_main)
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ // txdb must be opened before the mapWallet lock
+ CTxDB txdb("r");
+ {
+ nFeeRet = nTransactionFee;
+ loop
+ {
+ wtxNew.vin.clear();
+ wtxNew.vout.clear();
+ wtxNew.fFromMe = true;
+
+ int64 nTotalValue = nValue + nFeeRet;
+ double dPriority = 0;
+ // vouts to the payees
+ BOOST_FOREACH (const PAIRTYPE(CScript, int64)& s, vecSend)
+ wtxNew.vout.push_back(CTxOut(s.second, s.first));
+
+ // Choose coins to use
+ set<pair<const CWalletTx*,unsigned int> > setCoins;
+ int64 nValueIn = 0;
+ if (!SelectCoins(nTotalValue, setCoins, nValueIn))
+ return false;
+ BOOST_FOREACH(PAIRTYPE(const CWalletTx*, unsigned int) pcoin, setCoins)
+ {
+ int64 nCredit = pcoin.first->vout[pcoin.second].nValue;
+ dPriority += (double)nCredit * pcoin.first->GetDepthInMainChain();
+ }
+
+ int64 nChange = nValueIn - nValue - nFeeRet;
+ // if sub-cent change is required, the fee must be raised to at least MIN_TX_FEE
+ // or until nChange becomes zero
+ if (nFeeRet < MIN_TX_FEE && nChange > 0 && nChange < CENT)
+ {
+ int64 nMoveToFee = min(nChange, MIN_TX_FEE - nFeeRet);
+ nChange -= nMoveToFee;
+ nFeeRet += nMoveToFee;
+ }
+
+ if (nChange > 0)
+ {
+ // Note: We use a new key here to keep it from being obvious which side is the change.
+ // The drawback is that by not reusing a previous key, the change may be lost if a
+ // backup is restored, if the backup doesn't have the new private key for the change.
+ // If we reused the old key, it would be possible to add code to look for and
+ // rediscover unknown transactions that were written with keys of ours to recover
+ // post-backup change.
+
+ // Reserve a new key pair from key pool
+ vector<unsigned char> vchPubKey = reservekey.GetReservedKey();
+ // assert(mapKeys.count(vchPubKey));
+
+ // Fill a vout to ourself, using same address type as the payment
+ CScript scriptChange;
+ if (vecSend[0].first.GetBitcoinAddress().IsValid())
+ scriptChange.SetBitcoinAddress(vchPubKey);
+ else
+ scriptChange << vchPubKey << OP_CHECKSIG;
+
+ // Insert change txn at random position:
+ vector<CTxOut>::iterator position = wtxNew.vout.begin()+GetRandInt(wtxNew.vout.size());
+ wtxNew.vout.insert(position, CTxOut(nChange, scriptChange));
+ }
+ else
+ reservekey.ReturnKey();
+
+ // Fill vin
+ BOOST_FOREACH(const PAIRTYPE(const CWalletTx*,unsigned int)& coin, setCoins)
+ wtxNew.vin.push_back(CTxIn(coin.first->GetHash(),coin.second));
+
+ // Sign
+ int nIn = 0;
+ BOOST_FOREACH(const PAIRTYPE(const CWalletTx*,unsigned int)& coin, setCoins)
+ if (!SignSignature(*this, *coin.first, wtxNew, nIn++))
+ return false;
+
+ // Limit size
+ unsigned int nBytes = ::GetSerializeSize(*(CTransaction*)&wtxNew, SER_NETWORK);
+ if (nBytes >= MAX_BLOCK_SIZE_GEN/5)
+ return false;
+ dPriority /= nBytes;
+
+ // Check that enough fee is included
+ int64 nPayFee = nTransactionFee * (1 + (int64)nBytes / 1000);
+ bool fAllowFree = CTransaction::AllowFree(dPriority);
+ int64 nMinFee = wtxNew.GetMinFee(1, fAllowFree);
+ if (nFeeRet < max(nPayFee, nMinFee))
+ {
+ nFeeRet = max(nPayFee, nMinFee);
+ continue;
+ }
+
+ // Fill vtxPrev by copying from previous transactions vtxPrev
+ wtxNew.AddSupportingTransactions(txdb);
+ wtxNew.fTimeReceivedIsTxTime = true;
+
+ break;
+ }
+ }
+ }
+ return true;
+}
+
+bool CWallet::CreateTransaction(CScript scriptPubKey, int64 nValue, CWalletTx& wtxNew, CReserveKey& reservekey, int64& nFeeRet)
+{
+ vector< pair<CScript, int64> > vecSend;
+ vecSend.push_back(make_pair(scriptPubKey, nValue));
+ return CreateTransaction(vecSend, wtxNew, reservekey, nFeeRet);
+}
+
+// Call after CreateTransaction unless you want to abort
+bool CWallet::CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey)
+{
+ CRITICAL_BLOCK(cs_main)
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ printf("CommitTransaction:\n%s", wtxNew.ToString().c_str());
+ {
+ // This is only to keep the database open to defeat the auto-flush for the
+ // duration of this scope. This is the only place where this optimization
+ // maybe makes sense; please don't do it anywhere else.
+ CWalletDB* pwalletdb = fFileBacked ? new CWalletDB(strWalletFile,"r") : NULL;
+
+ // Take key pair from key pool so it won't be used again
+ reservekey.KeepKey();
+
+ // Add tx to wallet, because if it has change it's also ours,
+ // otherwise just for transaction history.
+ AddToWallet(wtxNew);
+
+ // Mark old coins as spent
+ set<CWalletTx*> setCoins;
+ BOOST_FOREACH(const CTxIn& txin, wtxNew.vin)
+ {
+ CWalletTx &coin = mapWallet[txin.prevout.hash];
+ coin.pwallet = this;
+ coin.MarkSpent(txin.prevout.n);
+ coin.WriteToDisk();
+ vWalletUpdated.push_back(coin.GetHash());
+ }
+
+ if (fFileBacked)
+ delete pwalletdb;
+ }
+
+ // Track how many getdata requests our transaction gets
+ mapRequestCount[wtxNew.GetHash()] = 0;
+
+ // Broadcast
+ if (!wtxNew.AcceptToMemoryPool())
+ {
+ // This must not fail. The transaction has already been signed and recorded.
+ printf("CommitTransaction() : Error: Transaction not valid");
+ return false;
+ }
+ wtxNew.RelayWalletTransaction();
+ }
+ MainFrameRepaint();
+ return true;
+}
+
+
+
+
+string CWallet::SendMoney(CScript scriptPubKey, int64 nValue, CWalletTx& wtxNew, bool fAskFee)
+{
+ CReserveKey reservekey(this);
+ int64 nFeeRequired;
+
+ if (IsLocked())
+ {
+ string strError = _("Error: Wallet locked, unable to create transaction ");
+ printf("SendMoney() : %s", strError.c_str());
+ return strError;
+ }
+ if (!CreateTransaction(scriptPubKey, nValue, wtxNew, reservekey, nFeeRequired))
+ {
+ string strError;
+ if (nValue + nFeeRequired > GetBalance())
+ strError = strprintf(_("Error: This transaction requires a transaction fee of at least %s because of its amount, complexity, or use of recently received funds "), FormatMoney(nFeeRequired).c_str());
+ else
+ strError = _("Error: Transaction creation failed ");
+ printf("SendMoney() : %s", strError.c_str());
+ return strError;
+ }
+
+ if (fAskFee && !ThreadSafeAskFee(nFeeRequired, _("Sending..."), NULL))
+ return "ABORTED";
+
+ if (!CommitTransaction(wtxNew, reservekey))
+ return _("Error: The transaction was rejected. This might happen if some of the coins in your wallet were already spent, such as if you used a copy of wallet.dat and coins were spent in the copy but not marked as spent here.");
+
+ MainFrameRepaint();
+ return "";
+}
+
+
+
+string CWallet::SendMoneyToBitcoinAddress(const CBitcoinAddress& address, int64 nValue, CWalletTx& wtxNew, bool fAskFee)
+{
+ // Check amount
+ if (nValue <= 0)
+ return _("Invalid amount");
+ if (nValue + nTransactionFee > GetBalance())
+ return _("Insufficient funds");
+
+ // Parse bitcoin address
+ CScript scriptPubKey;
+ scriptPubKey.SetBitcoinAddress(address);
+
+ return SendMoney(scriptPubKey, nValue, wtxNew, fAskFee);
+}
+
+
+
+
+int CWallet::LoadWallet(bool& fFirstRunRet)
+{
+ if (!fFileBacked)
+ return false;
+ fFirstRunRet = false;
+ int nLoadWalletRet = CWalletDB(strWalletFile,"cr+").LoadWallet(this);
+ if (nLoadWalletRet == DB_NEED_REWRITE)
+ {
+ if (CDB::Rewrite(strWalletFile, "\x04pool"))
+ {
+ setKeyPool.clear();
+ // Note: can't top-up keypool here, because wallet is locked.
+ // User will be prompted to unlock wallet the next operation
+ // the requires a new key.
+ }
+ nLoadWalletRet = DB_NEED_REWRITE;
+ }
+
+ if (nLoadWalletRet != DB_LOAD_OK)
+ return nLoadWalletRet;
+ fFirstRunRet = vchDefaultKey.empty();
+
+ if (!HaveKey(Hash160(vchDefaultKey)))
+ {
+ // Create new keyUser and set as default key
+ RandAddSeedPerfmon();
+
+ std::vector<unsigned char> newDefaultKey;
+ if (!GetKeyFromPool(newDefaultKey, false))
+ return DB_LOAD_FAIL;
+ SetDefaultKey(newDefaultKey);
+ if (!SetAddressBookName(CBitcoinAddress(vchDefaultKey), ""))
+ return DB_LOAD_FAIL;
+ }
+
+ CreateThread(ThreadFlushWalletDB, &strWalletFile);
+ return DB_LOAD_OK;
+}
+
+
+bool CWallet::SetAddressBookName(const CBitcoinAddress& address, const string& strName)
+{
+ mapAddressBook[address] = strName;
+ if (!fFileBacked)
+ return false;
+ return CWalletDB(strWalletFile).WriteName(address.ToString(), strName);
+}
+
+bool CWallet::DelAddressBookName(const CBitcoinAddress& address)
+{
+ mapAddressBook.erase(address);
+ if (!fFileBacked)
+ return false;
+ return CWalletDB(strWalletFile).EraseName(address.ToString());
+}
+
+
+void CWallet::PrintWallet(const CBlock& block)
+{
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ if (mapWallet.count(block.vtx[0].GetHash()))
+ {
+ CWalletTx& wtx = mapWallet[block.vtx[0].GetHash()];
+ printf(" mine: %d %d %d", wtx.GetDepthInMainChain(), wtx.GetBlocksToMaturity(), wtx.GetCredit());
+ }
+ }
+ printf("\n");
+}
+
+bool CWallet::GetTransaction(const uint256 &hashTx, CWalletTx& wtx)
+{
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ map<uint256, CWalletTx>::iterator mi = mapWallet.find(hashTx);
+ if (mi != mapWallet.end())
+ {
+ wtx = (*mi).second;
+ return true;
+ }
+ }
+ return false;
+}
+
+bool CWallet::SetDefaultKey(const std::vector<unsigned char> &vchPubKey)
+{
+ if (fFileBacked)
+ {
+ if (!CWalletDB(strWalletFile).WriteDefaultKey(vchPubKey))
+ return false;
+ }
+ vchDefaultKey = vchPubKey;
+ return true;
+}
+
+bool GetWalletFile(CWallet* pwallet, string &strWalletFileOut)
+{
+ if (!pwallet->fFileBacked)
+ return false;
+ strWalletFileOut = pwallet->strWalletFile;
+ return true;
+}
+
+//
+// Mark old keypool keys as used,
+// and generate all new keys
+//
+bool CWallet::NewKeyPool()
+{
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ CWalletDB walletdb(strWalletFile);
+ BOOST_FOREACH(int64 nIndex, setKeyPool)
+ walletdb.ErasePool(nIndex);
+ setKeyPool.clear();
+
+ if (IsLocked())
+ return false;
+
+ int64 nKeys = max(GetArg("-keypool", 100), (int64)0);
+ for (int i = 0; i < nKeys; i++)
+ {
+ int64 nIndex = i+1;
+ walletdb.WritePool(nIndex, CKeyPool(GenerateNewKey()));
+ setKeyPool.insert(nIndex);
+ }
+ printf("CWallet::NewKeyPool wrote %"PRI64d" new keys\n", nKeys);
+ }
+ return true;
+}
+
+bool CWallet::TopUpKeyPool()
+{
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ if (IsLocked())
+ return false;
+
+ CWalletDB walletdb(strWalletFile);
+
+ // Top up key pool
+ int64 nTargetSize = max(GetArg("-keypool", 100), (int64)0);
+ while (setKeyPool.size() < nTargetSize+1)
+ {
+ int64 nEnd = 1;
+ if (!setKeyPool.empty())
+ nEnd = *(--setKeyPool.end()) + 1;
+ if (!walletdb.WritePool(nEnd, CKeyPool(GenerateNewKey())))
+ throw runtime_error("TopUpKeyPool() : writing generated key failed");
+ setKeyPool.insert(nEnd);
+ printf("keypool added key %"PRI64d", size=%d\n", nEnd, setKeyPool.size());
+ }
+ }
+ return true;
+}
+
+void CWallet::ReserveKeyFromKeyPool(int64& nIndex, CKeyPool& keypool)
+{
+ nIndex = -1;
+ keypool.vchPubKey.clear();
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ if (!IsLocked())
+ TopUpKeyPool();
+
+ // Get the oldest key
+ if(setKeyPool.empty())
+ return;
+
+ CWalletDB walletdb(strWalletFile);
+
+ nIndex = *(setKeyPool.begin());
+ setKeyPool.erase(setKeyPool.begin());
+ if (!walletdb.ReadPool(nIndex, keypool))
+ throw runtime_error("ReserveKeyFromKeyPool() : read failed");
+ if (!HaveKey(Hash160(keypool.vchPubKey)))
+ throw runtime_error("ReserveKeyFromKeyPool() : unknown key in key pool");
+ assert(!keypool.vchPubKey.empty());
+ printf("keypool reserve %"PRI64d"\n", nIndex);
+ }
+}
+
+void CWallet::KeepKey(int64 nIndex)
+{
+ // Remove from key pool
+ if (fFileBacked)
+ {
+ CWalletDB walletdb(strWalletFile);
+ walletdb.ErasePool(nIndex);
+ }
+ printf("keypool keep %"PRI64d"\n", nIndex);
+}
+
+void CWallet::ReturnKey(int64 nIndex)
+{
+ // Return to key pool
+ CRITICAL_BLOCK(cs_wallet)
+ setKeyPool.insert(nIndex);
+ printf("keypool return %"PRI64d"\n", nIndex);
+}
+
+bool CWallet::GetKeyFromPool(vector<unsigned char>& result, bool fAllowReuse)
+{
+ int64 nIndex = 0;
+ CKeyPool keypool;
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ ReserveKeyFromKeyPool(nIndex, keypool);
+ if (nIndex == -1)
+ {
+ if (fAllowReuse && !vchDefaultKey.empty())
+ {
+ result = vchDefaultKey;
+ return true;
+ }
+ if (IsLocked()) return false;
+ result = GenerateNewKey();
+ return true;
+ }
+ KeepKey(nIndex);
+ result = keypool.vchPubKey;
+ }
+ return true;
+}
+
+int64 CWallet::GetOldestKeyPoolTime()
+{
+ int64 nIndex = 0;
+ CKeyPool keypool;
+ ReserveKeyFromKeyPool(nIndex, keypool);
+ if (nIndex == -1)
+ return GetTime();
+ ReturnKey(nIndex);
+ return keypool.nTime;
+}
+
+vector<unsigned char> CReserveKey::GetReservedKey()
+{
+ if (nIndex == -1)
+ {
+ CKeyPool keypool;
+ pwallet->ReserveKeyFromKeyPool(nIndex, keypool);
+ if (nIndex != -1)
+ vchPubKey = keypool.vchPubKey;
+ else
+ {
+ printf("CReserveKey::GetReservedKey(): Warning: using default key instead of a new key, top up your keypool.");
+ vchPubKey = pwallet->vchDefaultKey;
+ }
+ }
+ assert(!vchPubKey.empty());
+ return vchPubKey;
+}
+
+void CReserveKey::KeepKey()
+{
+ if (nIndex != -1)
+ pwallet->KeepKey(nIndex);
+ nIndex = -1;
+ vchPubKey.clear();
+}
+
+void CReserveKey::ReturnKey()
+{
+ if (nIndex != -1)
+ pwallet->ReturnKey(nIndex);
+ nIndex = -1;
+ vchPubKey.clear();
+}
+
diff --git a/bitcoin/src/wallet.h b/bitcoin/src/wallet.h
@@ -0,0 +1,645 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2012 The Bitcoin developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file license.txt or http://www.opensource.org/licenses/mit-license.php.
+#ifndef BITCOIN_WALLET_H
+#define BITCOIN_WALLET_H
+
+#include "bignum.h"
+#include "key.h"
+#include "script.h"
+
+class CWalletTx;
+class CReserveKey;
+class CWalletDB;
+
+// A CWallet is an extension of a keystore, which also maintains a set of
+// transactions and balances, and provides the ability to create new
+// transactions
+class CWallet : public CCryptoKeyStore
+{
+private:
+ bool SelectCoinsMinConf(int64 nTargetValue, int nConfMine, int nConfTheirs, std::set<std::pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64& nValueRet) const;
+ bool SelectCoins(int64 nTargetValue, std::set<std::pair<const CWalletTx*,unsigned int> >& setCoinsRet, int64& nValueRet) const;
+
+ CWalletDB *pwalletdbEncryption;
+
+public:
+ mutable CCriticalSection cs_wallet;
+
+ bool fFileBacked;
+ std::string strWalletFile;
+
+ std::set<int64> setKeyPool;
+
+ typedef std::map<unsigned int, CMasterKey> MasterKeyMap;
+ MasterKeyMap mapMasterKeys;
+ unsigned int nMasterKeyMaxID;
+
+ CWallet()
+ {
+ fFileBacked = false;
+ nMasterKeyMaxID = 0;
+ pwalletdbEncryption = NULL;
+ }
+ CWallet(std::string strWalletFileIn)
+ {
+ strWalletFile = strWalletFileIn;
+ fFileBacked = true;
+ nMasterKeyMaxID = 0;
+ pwalletdbEncryption = NULL;
+ }
+
+ std::map<uint256, CWalletTx> mapWallet;
+ std::vector<uint256> vWalletUpdated;
+
+ std::map<uint256, int> mapRequestCount;
+
+ std::map<CBitcoinAddress, std::string> mapAddressBook;
+
+ std::vector<unsigned char> vchDefaultKey;
+
+ // keystore implementation
+ // Adds a key to the store, and saves it to disk.
+ bool AddKey(const CKey& key);
+ // Adds a key to the store, without saving it to disk (used by LoadWallet)
+ bool LoadKey(const CKey& key) { return CCryptoKeyStore::AddKey(key); }
+
+ // Adds an encrypted key to the store, and saves it to disk.
+ bool AddCryptedKey(const std::vector<unsigned char> &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret);
+ // Adds an encrypted key to the store, without saving it to disk (used by LoadWallet)
+ bool LoadCryptedKey(const std::vector<unsigned char> &vchPubKey, const std::vector<unsigned char> &vchCryptedSecret) { return CCryptoKeyStore::AddCryptedKey(vchPubKey, vchCryptedSecret); }
+
+ bool Unlock(const SecureString& strWalletPassphrase);
+ bool ChangeWalletPassphrase(const SecureString& strOldWalletPassphrase, const SecureString& strNewWalletPassphrase);
+ bool EncryptWallet(const SecureString& strWalletPassphrase);
+
+ bool AddToWallet(const CWalletTx& wtxIn);
+ bool AddToWalletIfInvolvingMe(const CTransaction& tx, const CBlock* pblock, bool fUpdate = false);
+ bool EraseFromWallet(uint256 hash);
+ void WalletUpdateSpent(const CTransaction& prevout);
+ int ScanForWalletTransactions(CBlockIndex* pindexStart, bool fUpdate = false);
+ void ReacceptWalletTransactions();
+ void ResendWalletTransactions();
+ int64 GetBalance() const;
+ int64 GetUnconfirmedBalance() const;
+ bool CreateTransaction(const std::vector<std::pair<CScript, int64> >& vecSend, CWalletTx& wtxNew, CReserveKey& reservekey, int64& nFeeRet);
+ bool CreateTransaction(CScript scriptPubKey, int64 nValue, CWalletTx& wtxNew, CReserveKey& reservekey, int64& nFeeRet);
+ bool CommitTransaction(CWalletTx& wtxNew, CReserveKey& reservekey);
+ std::string SendMoney(CScript scriptPubKey, int64 nValue, CWalletTx& wtxNew, bool fAskFee=false);
+ std::string SendMoneyToBitcoinAddress(const CBitcoinAddress& address, int64 nValue, CWalletTx& wtxNew, bool fAskFee=false);
+
+ bool NewKeyPool();
+ bool TopUpKeyPool();
+ void ReserveKeyFromKeyPool(int64& nIndex, CKeyPool& keypool);
+ void KeepKey(int64 nIndex);
+ void ReturnKey(int64 nIndex);
+ bool GetKeyFromPool(std::vector<unsigned char> &key, bool fAllowReuse=true);
+ int64 GetOldestKeyPoolTime();
+
+ bool IsMine(const CTxIn& txin) const;
+ int64 GetDebit(const CTxIn& txin) const;
+ bool IsMine(const CTxOut& txout) const
+ {
+ return ::IsMine(*this, txout.scriptPubKey);
+ }
+ int64 GetCredit(const CTxOut& txout) const
+ {
+ if (!MoneyRange(txout.nValue))
+ throw std::runtime_error("CWallet::GetCredit() : value out of range");
+ return (IsMine(txout) ? txout.nValue : 0);
+ }
+ bool IsChange(const CTxOut& txout) const
+ {
+ CBitcoinAddress address;
+ if (ExtractAddress(txout.scriptPubKey, this, address))
+ CRITICAL_BLOCK(cs_wallet)
+ if (!mapAddressBook.count(address))
+ return true;
+ return false;
+ }
+ int64 GetChange(const CTxOut& txout) const
+ {
+ if (!MoneyRange(txout.nValue))
+ throw std::runtime_error("CWallet::GetChange() : value out of range");
+ return (IsChange(txout) ? txout.nValue : 0);
+ }
+ bool IsMine(const CTransaction& tx) const
+ {
+ BOOST_FOREACH(const CTxOut& txout, tx.vout)
+ if (IsMine(txout))
+ return true;
+ return false;
+ }
+ bool IsFromMe(const CTransaction& tx) const
+ {
+ return (GetDebit(tx) > 0);
+ }
+ int64 GetDebit(const CTransaction& tx) const
+ {
+ int64 nDebit = 0;
+ BOOST_FOREACH(const CTxIn& txin, tx.vin)
+ {
+ nDebit += GetDebit(txin);
+ if (!MoneyRange(nDebit))
+ throw std::runtime_error("CWallet::GetDebit() : value out of range");
+ }
+ return nDebit;
+ }
+ int64 GetCredit(const CTransaction& tx) const
+ {
+ int64 nCredit = 0;
+ BOOST_FOREACH(const CTxOut& txout, tx.vout)
+ {
+ nCredit += GetCredit(txout);
+ if (!MoneyRange(nCredit))
+ throw std::runtime_error("CWallet::GetCredit() : value out of range");
+ }
+ return nCredit;
+ }
+ int64 GetChange(const CTransaction& tx) const
+ {
+ int64 nChange = 0;
+ BOOST_FOREACH(const CTxOut& txout, tx.vout)
+ {
+ nChange += GetChange(txout);
+ if (!MoneyRange(nChange))
+ throw std::runtime_error("CWallet::GetChange() : value out of range");
+ }
+ return nChange;
+ }
+ void SetBestChain(const CBlockLocator& loc)
+ {
+ CWalletDB walletdb(strWalletFile);
+ walletdb.WriteBestBlock(loc);
+ }
+
+ int LoadWallet(bool& fFirstRunRet);
+// bool BackupWallet(const std::string& strDest);
+
+ bool SetAddressBookName(const CBitcoinAddress& address, const std::string& strName);
+
+ bool DelAddressBookName(const CBitcoinAddress& address);
+
+ void UpdatedTransaction(const uint256 &hashTx)
+ {
+ CRITICAL_BLOCK(cs_wallet)
+ vWalletUpdated.push_back(hashTx);
+ }
+
+ void PrintWallet(const CBlock& block);
+
+ void Inventory(const uint256 &hash)
+ {
+ CRITICAL_BLOCK(cs_wallet)
+ {
+ std::map<uint256, int>::iterator mi = mapRequestCount.find(hash);
+ if (mi != mapRequestCount.end())
+ (*mi).second++;
+ }
+ }
+
+ int GetKeyPoolSize()
+ {
+ return setKeyPool.size();
+ }
+
+ bool GetTransaction(const uint256 &hashTx, CWalletTx& wtx);
+
+ bool SetDefaultKey(const std::vector<unsigned char> &vchPubKey);
+};
+
+
+class CReserveKey
+{
+protected:
+ CWallet* pwallet;
+ int64 nIndex;
+ std::vector<unsigned char> vchPubKey;
+public:
+ CReserveKey(CWallet* pwalletIn)
+ {
+ nIndex = -1;
+ pwallet = pwalletIn;
+ }
+
+ ~CReserveKey()
+ {
+ if (!fShutdown)
+ ReturnKey();
+ }
+
+ void ReturnKey();
+ std::vector<unsigned char> GetReservedKey();
+ void KeepKey();
+};
+
+
+//
+// A transaction with a bunch of additional info that only the owner cares
+// about. It includes any unrecorded transactions needed to link it back
+// to the block chain.
+//
+class CWalletTx : public CMerkleTx
+{
+public:
+ const CWallet* pwallet;
+
+ std::vector<CMerkleTx> vtxPrev;
+ std::map<std::string, std::string> mapValue;
+ std::vector<std::pair<std::string, std::string> > vOrderForm;
+ unsigned int fTimeReceivedIsTxTime;
+ unsigned int nTimeReceived; // time received by this node
+ char fFromMe;
+ std::string strFromAccount;
+ std::vector<char> vfSpent; // which outputs are already spent
+
+ // memory only
+ mutable char fDebitCached;
+ mutable char fCreditCached;
+ mutable char fAvailableCreditCached;
+ mutable char fChangeCached;
+ mutable int64 nDebitCached;
+ mutable int64 nCreditCached;
+ mutable int64 nAvailableCreditCached;
+ mutable int64 nChangeCached;
+
+ // memory only UI hints
+ mutable unsigned int nTimeDisplayed;
+ mutable int nLinesDisplayed;
+ mutable char fConfirmedDisplayed;
+
+ CWalletTx()
+ {
+ Init(NULL);
+ }
+
+ CWalletTx(const CWallet* pwalletIn)
+ {
+ Init(pwalletIn);
+ }
+
+ CWalletTx(const CWallet* pwalletIn, const CMerkleTx& txIn) : CMerkleTx(txIn)
+ {
+ Init(pwalletIn);
+ }
+
+ CWalletTx(const CWallet* pwalletIn, const CTransaction& txIn) : CMerkleTx(txIn)
+ {
+ Init(pwalletIn);
+ }
+
+ void Init(const CWallet* pwalletIn)
+ {
+ pwallet = pwalletIn;
+ vtxPrev.clear();
+ mapValue.clear();
+ vOrderForm.clear();
+ fTimeReceivedIsTxTime = false;
+ nTimeReceived = 0;
+ fFromMe = false;
+ strFromAccount.clear();
+ vfSpent.clear();
+ fDebitCached = false;
+ fCreditCached = false;
+ fAvailableCreditCached = false;
+ fChangeCached = false;
+ nDebitCached = 0;
+ nCreditCached = 0;
+ nAvailableCreditCached = 0;
+ nChangeCached = 0;
+ nTimeDisplayed = 0;
+ nLinesDisplayed = 0;
+ fConfirmedDisplayed = false;
+ }
+
+ IMPLEMENT_SERIALIZE
+ (
+ CWalletTx* pthis = const_cast<CWalletTx*>(this);
+ if (fRead)
+ pthis->Init(NULL);
+ char fSpent = false;
+
+ if (!fRead)
+ {
+ pthis->mapValue["fromaccount"] = pthis->strFromAccount;
+
+ std::string str;
+ BOOST_FOREACH(char f, vfSpent)
+ {
+ str += (f ? '1' : '0');
+ if (f)
+ fSpent = true;
+ }
+ pthis->mapValue["spent"] = str;
+ }
+
+ nSerSize += SerReadWrite(s, *(CMerkleTx*)this, nType, nVersion,ser_action);
+ READWRITE(vtxPrev);
+ READWRITE(mapValue);
+ READWRITE(vOrderForm);
+ READWRITE(fTimeReceivedIsTxTime);
+ READWRITE(nTimeReceived);
+ READWRITE(fFromMe);
+ READWRITE(fSpent);
+
+ if (fRead)
+ {
+ pthis->strFromAccount = pthis->mapValue["fromaccount"];
+
+ if (mapValue.count("spent"))
+ BOOST_FOREACH(char c, pthis->mapValue["spent"])
+ pthis->vfSpent.push_back(c != '0');
+ else
+ pthis->vfSpent.assign(vout.size(), fSpent);
+ }
+
+ pthis->mapValue.erase("fromaccount");
+ pthis->mapValue.erase("version");
+ pthis->mapValue.erase("spent");
+ )
+
+ // marks certain txout's as spent
+ // returns true if any update took place
+ bool UpdateSpent(const std::vector<char>& vfNewSpent)
+ {
+ bool fReturn = false;
+ for (int i=0; i < vfNewSpent.size(); i++)
+ {
+ if (i == vfSpent.size())
+ break;
+
+ if (vfNewSpent[i] && !vfSpent[i])
+ {
+ vfSpent[i] = true;
+ fReturn = true;
+ fAvailableCreditCached = false;
+ }
+ }
+ return fReturn;
+ }
+
+ // make sure balances are recalculated
+ void MarkDirty()
+ {
+ fCreditCached = false;
+ fAvailableCreditCached = false;
+ fDebitCached = false;
+ fChangeCached = false;
+ }
+
+ void MarkSpent(unsigned int nOut)
+ {
+ if (nOut >= vout.size())
+ throw std::runtime_error("CWalletTx::MarkSpent() : nOut out of range");
+ vfSpent.resize(vout.size());
+ if (!vfSpent[nOut])
+ {
+ vfSpent[nOut] = true;
+ fAvailableCreditCached = false;
+ }
+ }
+
+ bool IsSpent(unsigned int nOut) const
+ {
+ if (nOut >= vout.size())
+ throw std::runtime_error("CWalletTx::IsSpent() : nOut out of range");
+ if (nOut >= vfSpent.size())
+ return false;
+ return (!!vfSpent[nOut]);
+ }
+
+ int64 GetDebit() const
+ {
+ if (vin.empty())
+ return 0;
+ if (fDebitCached)
+ return nDebitCached;
+ nDebitCached = pwallet->GetDebit(*this);
+ fDebitCached = true;
+ return nDebitCached;
+ }
+
+ int64 GetCredit(bool fUseCache=true) const
+ {
+ // Must wait until coinbase is safely deep enough in the chain before valuing it
+ if (IsCoinBase() && GetBlocksToMaturity() > 0)
+ return 0;
+
+ // GetBalance can assume transactions in mapWallet won't change
+ if (fUseCache && fCreditCached)
+ return nCreditCached;
+ nCreditCached = pwallet->GetCredit(*this);
+ fCreditCached = true;
+ return nCreditCached;
+ }
+
+ int64 GetAvailableCredit(bool fUseCache=true) const
+ {
+ // Must wait until coinbase is safely deep enough in the chain before valuing it
+ if (IsCoinBase() && GetBlocksToMaturity() > 0)
+ return 0;
+
+ if (fUseCache && fAvailableCreditCached)
+ return nAvailableCreditCached;
+
+ int64 nCredit = 0;
+ for (int i = 0; i < vout.size(); i++)
+ {
+ if (!IsSpent(i))
+ {
+ const CTxOut &txout = vout[i];
+ nCredit += pwallet->GetCredit(txout);
+ if (!MoneyRange(nCredit))
+ throw std::runtime_error("CWalletTx::GetAvailableCredit() : value out of range");
+ }
+ }
+
+ nAvailableCreditCached = nCredit;
+ fAvailableCreditCached = true;
+ return nCredit;
+ }
+
+
+ int64 GetChange() const
+ {
+ if (fChangeCached)
+ return nChangeCached;
+ nChangeCached = pwallet->GetChange(*this);
+ fChangeCached = true;
+ return nChangeCached;
+ }
+
+ void GetAmounts(int64& nGeneratedImmature, int64& nGeneratedMature, std::list<std::pair<CBitcoinAddress, int64> >& listReceived,
+ std::list<std::pair<CBitcoinAddress, int64> >& listSent, int64& nFee, std::string& strSentAccount) const;
+
+ void GetAccountAmounts(const std::string& strAccount, int64& nGenerated, int64& nReceived,
+ int64& nSent, int64& nFee) const;
+
+ bool IsFromMe() const
+ {
+ return (GetDebit() > 0);
+ }
+
+ bool IsConfirmed() const
+ {
+ // Quick answer in most cases
+ if (!IsFinal())
+ return false;
+ if (GetDepthInMainChain() >= 1)
+ return true;
+ if (!IsFromMe()) // using wtx's cached debit
+ return false;
+
+ // If no confirmations but it's from us, we can still
+ // consider it confirmed if all dependencies are confirmed
+ std::map<uint256, const CMerkleTx*> mapPrev;
+ std::vector<const CMerkleTx*> vWorkQueue;
+ vWorkQueue.reserve(vtxPrev.size()+1);
+ vWorkQueue.push_back(this);
+ for (int i = 0; i < vWorkQueue.size(); i++)
+ {
+ const CMerkleTx* ptx = vWorkQueue[i];
+
+ if (!ptx->IsFinal())
+ return false;
+ if (ptx->GetDepthInMainChain() >= 1)
+ continue;
+ if (!pwallet->IsFromMe(*ptx))
+ return false;
+
+ if (mapPrev.empty())
+ BOOST_FOREACH(const CMerkleTx& tx, vtxPrev)
+ mapPrev[tx.GetHash()] = &tx;
+
+ BOOST_FOREACH(const CTxIn& txin, ptx->vin)
+ {
+ if (!mapPrev.count(txin.prevout.hash))
+ return false;
+ vWorkQueue.push_back(mapPrev[txin.prevout.hash]);
+ }
+ }
+ return true;
+ }
+
+ bool WriteToDisk();
+
+ int64 GetTxTime() const;
+ int GetRequestCount() const;
+
+ void AddSupportingTransactions(CTxDB& txdb);
+
+ bool AcceptWalletTransaction(CTxDB& txdb, bool fCheckInputs=true);
+ bool AcceptWalletTransaction();
+
+ void RelayWalletTransaction(CTxDB& txdb);
+ void RelayWalletTransaction();
+};
+
+
+//
+// Private key that includes an expiration date in case it never gets used.
+//
+class CWalletKey
+{
+public:
+ CPrivKey vchPrivKey;
+ int64 nTimeCreated;
+ int64 nTimeExpires;
+ std::string strComment;
+ //// todo: add something to note what created it (user, getnewaddress, change)
+ //// maybe should have a map<string, string> property map
+
+ CWalletKey(int64 nExpires=0)
+ {
+ nTimeCreated = (nExpires ? GetTime() : 0);
+ nTimeExpires = nExpires;
+ }
+
+ IMPLEMENT_SERIALIZE
+ (
+ if (!(nType & SER_GETHASH))
+ READWRITE(nVersion);
+ READWRITE(vchPrivKey);
+ READWRITE(nTimeCreated);
+ READWRITE(nTimeExpires);
+ READWRITE(strComment);
+ )
+};
+
+
+
+
+
+
+//
+// Account information.
+// Stored in wallet with key "acc"+string account name
+//
+class CAccount
+{
+public:
+ std::vector<unsigned char> vchPubKey;
+
+ CAccount()
+ {
+ SetNull();
+ }
+
+ void SetNull()
+ {
+ vchPubKey.clear();
+ }
+
+ IMPLEMENT_SERIALIZE
+ (
+ if (!(nType & SER_GETHASH))
+ READWRITE(nVersion);
+ READWRITE(vchPubKey);
+ )
+};
+
+
+
+//
+// Internal transfers.
+// Database key is acentry<account><counter>
+//
+class CAccountingEntry
+{
+public:
+ std::string strAccount;
+ int64 nCreditDebit;
+ int64 nTime;
+ std::string strOtherAccount;
+ std::string strComment;
+
+ CAccountingEntry()
+ {
+ SetNull();
+ }
+
+ void SetNull()
+ {
+ nCreditDebit = 0;
+ nTime = 0;
+ strAccount.clear();
+ strOtherAccount.clear();
+ strComment.clear();
+ }
+
+ IMPLEMENT_SERIALIZE
+ (
+ if (!(nType & SER_GETHASH))
+ READWRITE(nVersion);
+ // Note: strAccount is serialized as part of the key, not here.
+ READWRITE(nCreditDebit);
+ READWRITE(nTime);
+ READWRITE(strOtherAccount);
+ READWRITE(strComment);
+ )
+};
+
+bool GetWalletFile(CWallet* pwallet, std::string &strWalletFileOut);
+
+#endif
