PPCoin: Force reorganization for synchronized checkpoint

[novacoin.git] / src / checkpoints.cpp

diff --git a/src/checkpoints.cpp b/src/checkpoints.cpp
index d986b07..283bbdd 100644 (file)
--- a/src/checkpoints.cpp
+++ b/src/checkpoints.cpp
@@ -77,7 +77,8 @@ namespace Checkpoints
 
         CBlockIndex* pindex = pindexCheckpointRecv;
         while (pindex->nHeight > pindexSyncCheckpoint->nHeight)
-            pindex = pindex->pprev;
+            if (!(pindex = pindex->pprev))
+                return error("ValidateSyncCheckpoint: pprev null - block index structure failure");
         if (pindex->GetBlockHash() != hashSyncCheckpoint)
             return error("ValidateSyncCheckpoint: new sync-checkpoint %s is not a descendant of current sync-checkpoint %s", hashCheckpoint.ToString().c_str(), hashSyncCheckpoint.ToString().c_str());
         return true;
@@ -85,7 +86,12 @@ namespace Checkpoints
 
     bool AcceptPendingSyncCheckpoint()
     {
+        bool fAccepted = false;
+        uint256 hashCheckpoint = 0;
+        CTxDB txdb;
+
         CRITICAL_BLOCK(cs_hashSyncCheckpoint)
+        {
             if ((!checkpointMessagePending.IsNull()) && mapBlockIndex.count(checkpointMessagePending.hashCheckpoint))
             {
                 if (!ValidateSyncCheckpoint(checkpointMessagePending.hashCheckpoint))
@@ -94,22 +100,45 @@ namespace Checkpoints
                     return false;
                 }
 
-                CTxDB txdb;
+                txdb.TxnBegin();
                 if (!txdb.WriteSyncCheckpoint(checkpointMessagePending.hashCheckpoint))
+                {
+                    txdb.TxnAbort();
                     return error("AcceptPendingSyncCheckpoint() : failed to write to db sync checkpoint %s\n", checkpointMessagePending.hashCheckpoint.ToString().c_str());
-                txdb.Close();
+                }
+                if (!txdb.TxnCommit())
+                    return error("AcceptPendingSyncCheckpoint() : failed to commit to db sync checkpoint %s\n", checkpointMessagePending.hashCheckpoint.ToString().c_str());
 
                 hashSyncCheckpoint = checkpointMessagePending.hashCheckpoint;
                 checkpointMessage = checkpointMessagePending;
                 checkpointMessagePending.SetNull();
                 printf("AcceptPendingSyncCheckpoint : sync-checkpoint at %s\n", hashSyncCheckpoint.ToString().c_str());
-                // relay the checkpoint
-                BOOST_FOREACH(CNode* pnode, vNodes)
-                    checkpointMessage.RelayTo(pnode);
-                return true;
+                fAccepted = true;
+                hashCheckpoint = hashSyncCheckpoint;
             }
+        }
 
-        return false;
+        if (fAccepted)
+        {
+            CBlockIndex* pindexCheckpoint = mapBlockIndex[hashCheckpoint];
+            if (!pindexCheckpoint->IsInMainChain())
+            {
+                txdb.TxnBegin();
+                if (!Reorganize(txdb, pindexCheckpoint))
+                {
+                    txdb.TxnAbort();
+                    return error("ProcessSyncCheckpoint: Reorganize failed for sync checkpoint %s", hashCheckpoint.ToString().c_str());
+                }
+            }
+        }
+        txdb.Close();
+
+        // relay the checkpoint
+        CRITICAL_BLOCK(cs_hashSyncCheckpoint)
+            BOOST_FOREACH(CNode* pnode, vNodes)
+                checkpointMessage.RelayTo(pnode);
+
+        return fAccepted;
     }
 
     uint256 AutoSelectSyncCheckpoint()
@@ -122,13 +151,27 @@ namespace Checkpoints
     }
 
     // Check against synchronized checkpoint
-    bool CheckSync(int nHeight, const uint256& hashBlock)
+    bool CheckSync(const uint256& hashBlock, const CBlockIndex* pindexPrev)
     {
         if (fTestNet) return true; // Testnet has no checkpoints
+        int nHeight = pindexPrev->nHeight + 1;
 
         CRITICAL_BLOCK(cs_hashSyncCheckpoint)
         {
-            CBlockIndex* pindexSync = mapBlockIndex[hashSyncCheckpoint];
+            // sync-checkpoint should always be accepted block
+            assert(mapBlockIndex.count(hashSyncCheckpoint));
+            const CBlockIndex* pindexSync = mapBlockIndex[hashSyncCheckpoint];
+
+            if (nHeight > pindexSync->nHeight)
+            {
+                // trace back to same height as sync-checkpoint
+                const CBlockIndex* pindex = pindexPrev;
+                while (pindex->nHeight > pindexSync->nHeight)
+                    if (!(pindex = pindex->pprev))
+                        return error("CheckSync: pprev null - block index structure failure");
+                if (pindex->nHeight < pindexSync->nHeight || pindex->GetBlockHash() != hashSyncCheckpoint)
+                    return false; // only descendant of sync-checkpoint can pass check
+            }
             if (nHeight == pindexSync->nHeight && hashBlock != hashSyncCheckpoint)
                 return false; // same height with sync-checkpoint
             if (nHeight < pindexSync->nHeight && !mapBlockIndex.count(hashBlock))
@@ -261,13 +304,14 @@ bool CSyncCheckpoint::ProcessSyncCheckpoint(CNode* pfrom)
     if (!CheckSignature())
         return false;
 
+    CTxDB txdb;
     CRITICAL_BLOCK(Checkpoints::cs_hashSyncCheckpoint)
     {
         if (!mapBlockIndex.count(hashCheckpoint))
         {
             // We haven't accepted this block, keep the checkpoint as pending
             Checkpoints::checkpointMessagePending = *this;
-            printf("ProcessSyncCheckpoint : pending for sync-checkpoint %s\n", hashCheckpoint.ToString().c_str());
+            printf("ProcessSyncCheckpoint: pending for sync-checkpoint %s\n", hashCheckpoint.ToString().c_str());
             // Ask this guy to fill in what we're missing
             if (pfrom)
                 pfrom->PushGetBlocks(pindexBest, hashCheckpoint);
@@ -276,15 +320,31 @@ bool CSyncCheckpoint::ProcessSyncCheckpoint(CNode* pfrom)
         if (!Checkpoints::ValidateSyncCheckpoint(hashCheckpoint))
             return false;
 
-        CTxDB txdb;
-        if (!txdb.WriteSyncCheckpoint(this->hashCheckpoint))
-            return error("ProcessSyncCheckpoint() : failed to write to db sync checkpoint %s\n", this->hashCheckpoint.ToString().c_str());
-        txdb.Close();
+        txdb.TxnBegin();
+        if (!txdb.WriteSyncCheckpoint(hashCheckpoint))
+        {
+            txdb.TxnAbort();
+            return error("ProcessSyncCheckpoint(): failed to write to db sync checkpoint %s", hashCheckpoint.ToString().c_str());
+        }
+        if (!txdb.TxnCommit())
+            return error("ProcessSyncCheckpoint(): failed to commit to db sync checkpoint %s", hashCheckpoint.ToString().c_str());
 
-        Checkpoints::hashSyncCheckpoint = this->hashCheckpoint;
+        Checkpoints::hashSyncCheckpoint = hashCheckpoint;
         Checkpoints::checkpointMessage = *this;
         Checkpoints::checkpointMessagePending.SetNull();
-        printf("ProcessSyncCheckpoint : sync-checkpoint at %s\n", Checkpoints::hashSyncCheckpoint.ToString().c_str());
+        printf("ProcessSyncCheckpoint: sync-checkpoint at %s\n", hashCheckpoint.ToString().c_str());
+    }
+
+    CBlockIndex* pindexCheckpoint = mapBlockIndex[hashCheckpoint];
+    if (!pindexCheckpoint->IsInMainChain())
+    {
+        txdb.TxnBegin();
+        if (!Reorganize(txdb, pindexCheckpoint))
+        {
+            txdb.TxnAbort();
+            return error("ProcessSyncCheckpoint: Reorganize failed for sync checkpoint %s", hashCheckpoint.ToString().c_str());
+        }
     }
+    txdb.Close();
     return true;
 }