PPCoin: Define synchronized checkpoint message

diff --git a/src/checkpoints.cpp b/src/checkpoints.cpp
index 89e53ca..9c4ef34 100644 (file)
--- a/src/checkpoints.cpp
+++ b/src/checkpoints.cpp
@@ -58,11 +58,21 @@ namespace Checkpoints
 
     // ppcoin: synchronized checkpoint (centrally broadcasted)
     uint256 hashSyncCheckpoint;
+    CCriticalSection cs_hashSyncCheckpoint;
 
     bool AcceptNewSyncCheckpoint(uint256 hashCheckpoint)
     {
     }
 
+    bool CSyncCheckpoint::ProcessSyncCheckpoint()
+    {
+        if (!CheckSignature())
+            return false;
+
+        CRITICAL_BLOCK(cs_hashSyncCheckpoint)
+            hashSyncCheckpoint = this->hashCheckpoint;
+    }
+
     // ppcoin: automatic checkpoint (represented by height of checkpoint)
     int nAutoCheckpoint = 0;
     int nBranchPoint = 0;    // branch point to alternative branch

diff --git a/src/checkpoints.h b/src/checkpoints.h
index 033b228..f06f81c 100644 (file)
--- a/src/checkpoints.h
+++ b/src/checkpoints.h
@@ -34,6 +34,105 @@ namespace Checkpoints
     // ppcoin: synchronized checkpoint
     extern uint256 hashSyncCheckpoint;
 
+    class CUnsignedSyncCheckpoint
+    {
+    public:
+        int nVersion;
+        uint256 hashCheckpoint;      // checkpoint block
+
+        IMPLEMENT_SERIALIZE
+        (
+            READWRITE(this->nVersion);
+            nVersion = this->nVersion;
+            READWRITE(hashCheckpoint);
+        )
+
+        void SetNull()
+        {
+            nVersion = 1;
+            hashCheckpoint = 0;
+        }
+
+        std::string ToString() const
+        {
+            return strprintf(
+                    "CSyncCheckpoint(\n"
+                    "    nVersion       = %d\n"
+                    "    hashCheckpoint = %s\n"
+                    ")\n",
+                nVersion,
+                hashCheckpoint.ToString().c_str());
+        }
+
+        void print() const
+        {
+            printf("%s", ToString().c_str());
+        }
+    };
+
+    class CSyncCheckpoint : public CUnsignedSyncCheckpoint
+    {
+    public:
+        std::vector<unsigned char> vchMsg;
+        std::vector<unsigned char> vchSig;
+
+        CSyncCheckpoint()
+        {
+            SetNull();
+        }
+
+        IMPLEMENT_SERIALIZE
+        (
+            READWRITE(vchMsg);
+            READWRITE(vchSig);
+        )
+
+        void SetNull()
+        {
+            CUnsignedSyncCheckpoint::SetNull();
+            vchMsg.clear();
+            vchSig.clear();
+        }
+
+        bool IsNull() const
+        {
+            return (hashCheckpoint == 0);
+        }
+
+        uint256 GetHash() const
+        {
+            return SerializeHash(*this);
+        }
+
+        bool RelayTo(CNode* pnode) const
+        {
+            // returns true if wasn't already sent
+            if (pnode->hashCheckpointKnown != hashCheckpoint)
+            {
+                pnode->hashCheckpointKnown = hashCheckpoint;
+                pnode->PushMessage("checkpoint", *this);
+                return true;
+            }
+            return false;
+        }
+
+        bool CheckSignature()
+        {
+            CKey key;
+            if (!key.SetPubKey(ParseHex("0487ca85b6ae9d311f996c7616d20d0c88a5b4f07d25e78f419019f35cce6522acf978b2d99f0e7a58db1f120439e5c1889266927854aa57c93956c2569188a539")))
+                return error("CSyncCheckpoint::CheckSignature() : SetPubKey failed");
+            if (!key.Verify(Hash(vchMsg.begin(), vchMsg.end()), vchSig))
+                return error("CSyncCheckpoint::CheckSignature() : verify signature failed");
+
+            // Now unserialize the data
+            CDataStream sMsg(vchMsg);
+            sMsg >> *(CUnsignedSyncCheckpoint*)this;
+            return true;
+        }
+
+        bool ProcessSyncCheckpoint();
+    };
+
     // ppcoin: automatic checkpoint
     extern int nAutoCheckpoint;
     extern int nBranchPoint;

diff --git a/src/net.h b/src/net.h
index b120013..c2f0aad 100644 (file)
--- a/src/net.h
+++ b/src/net.h
@@ -146,6 +146,7 @@ public:
     std::set<CAddress> setAddrKnown;
     bool fGetAddr;
     std::set<uint256> setKnown;
+    uint256 hashCheckpointKnown; // ppcoin: known sent sync-checkpoint
 
     // inventory based relay
     std::set<CInv> setInventoryKnown;
@@ -193,6 +194,7 @@ public:
         fGetAddr = false;
         vfSubscribe.assign(256, false);
         nMisbehavior = 0;
+        hashCheckpointKnown = 0;
 
         // Be shy and don't send version until we hear
         if (!fInbound)