2. 程式人生 > >比特幣原始碼學習筆記（二）

比特幣原始碼學習筆記（二）

阿新 • • 發佈：2018-12-27

第二章

本章繼上一章交易建立之後介紹比特幣客戶端序列化資料的過程。

比特幣客戶端所有的序列化函式均在seriliaze.h中實現。其中，CDataStream類是資料序列化的核心結構。

CDataStream

CDataStream擁有一個字元類容器用來存放序列化之後的資料。它結合一個容器型別和一個流（stream）介面以處理資料。它使用6個成員函式實現這一功能：

class CDataStream
{
protected:
    typedef vector<char, secure_allocator<char> > vector_type;
    vector_type vch;
    unsigned int nReadPos;
    short state;
    short exceptmask;
public:
    int nType;
    int nVersion;
    //......
}
  • vch存有序列化後的資料。它是一個擁有自定義記憶體分配器的字元容器型別。該記憶體分配器將由該容器的實現在需要分配/釋放記憶體時呼叫。該記憶體分配器會在向作業系統釋放記憶體前清空記憶體中的資料以防止本機的其他程序訪問此資料，從而保證資料儲存的安全性。該記憶體分配器的實現在此不進行討論，讀者可於serialize.h自行查詢。
  • nReadPos是vch讀取資料的起始位置。
  • state是錯誤標識。該變數用於指示在序列化/反序列化當中可能出現的錯誤。
  • exceptmask是錯誤掩碼。它初始化為ios::badbit | ios::failbit。與state類似，它被用於指示錯誤種類。
  • nType的取值為SER_NETWORK，SER_DISK，SER_GETHASH，SER_SKIPSIG，SER_BLOCKHEADERONLY之一，其作用為通知CDataStream進行具體某種序列化操作。這5個符號被定義在一個列舉型別enum裡。每個符號均為一個int型別（4位元組），並且其值為2的次方。
enum
{
    // primary actions
    SER_NETWORK         = (1 << 0),
    SER_DISK            = (1 << 1),
    SER_GETHASH         = (1 << 2),

    // modifiers
    SER_SKIPSIG         = (1 << 16),
    SER_BLOCKHEADERONLY = (1 << 17),
};
  • nVersion是版本號。

CDataStream::read()與CDataStream::write()

成員函式CDataStream::read()和CDataStream::write()是用於執行序列化/反序列化CDataStream物件的低階函式。 
 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(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& 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);
    }
CDataStream::read()從CDataStream複製nSize個字元到一個由char* pch所指向的記憶體空間。以下是它的實現過程：
  • 計算將要從vch讀取的資料的結束位置，unsigned int nReadPosNext  = nReadPos + nSize。
  • 如果結束位置比vch的大小更大，則當前沒有足夠的資料供讀取。在這種情況下，通過呼叫函式setState()將state設為ios::failbit，並將所有的零複製到pch。
  • 否則，呼叫memcpy(pch, &vch[nReadPos], nSize)複製nSize個字元，從vch的nReadPos位置開始，到由pch指向的一段預先分配的記憶體。接著從nReadPos向前移至下一個起始位置nReadPosNext（第22行）。
該實現表明1）當一段資料被從流中讀取之後，該段資料無法被再次讀取；2）nReadPos是第一個有效資料的讀取位置。 CDataStream::write()非常簡單。它將由pch指向的nSize個字元附加到vch的結尾。

巨集READDATA()和WRITEDATA()

函式CDataStream::read()與CDataStream::write()的作用是序列化/反序列化原始型別（int，bool，unsigned long等）。為了序列化這些資料型別，這些型別的指標將被轉換為char*。由於這些型別的大小目前已知，它們可以從CDataStream中讀取或者寫入至字元緩衝。兩個用於引用這些函式的巨集被定義為助手。 
#define WRITEDATA(s, obj)   s.write((char*)&(obj), sizeof(obj))
#define READDATA(s, obj)    s.read((char*)&(obj), sizeof(obj))
這裡是如何使用這些巨集的例子。下面的函式將序列化一個unsigned long型別。 
template<typename Stream> inline void Serialize(Stream& s, unsigned long a,  int, int=0) { WRITEDATA(s, a); }
把WRITEDATA(s, a)用自身的定義取代，以下是展開以後的函式：
template<typename Stream> inline void Serialize(Stream& s, unsigned long a,  int, int=0) { s.write((char*)&(a), sizeof(a)); }
該函式接受一個unsigned long引數a，獲取它的記憶體地址，轉換指標為char*並呼叫函式s.write()。

CDataStream中的操作符 << 和 >>

CDataStream過載了操作符<< 和 >>用於序列化和反序列化。 
    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);
    }
標頭檔案serialize.h包含了14個過載後的這兩個全域性函式給14個原始型別（signed和unsigned版本char，short，int，long和long long，以及char，float，double和bool）以及6個過載版本的6個複合型別（string，vector，pair，map，set和CScript）。因此，對於這些型別，你可以簡單地使用以下程式碼來序列化/反序列化資料： 
CDataStream ss(SER_GETHASH);
ss<<obj1<<obj2; //序列化
ss>>obj3>>obj4; //反序列化

如果沒有任何實現的型別符合第二個引數obj，則以下泛型T全域性函式將會被呼叫。 
template<typename Stream, typename T>
inline void Serialize(Stream& os, const T& a, long nType, int nVersion=VERSION)
{
    a.Serialize(os, (int)nType, nVersion);
}

對於該泛型版本，型別T應該用於實現一個成員函式和簽名T::Serialize(Stream, int, int)。它將通過a.Serialize()被呼叫。

怎樣實現一個型別的序列化

在之前的介紹當中，泛型T需要實現以下三個成員函式進行序列化。 
    unsigned int GetSerializeSize(int nType=0, int nVersion=VERSION) const;
    void Serialize(Stream& s, int nType=0, int nVersion=VERSION) const;
    void Unserialize(Stream& s, int nType=0, int nVersion=VERSION);

這三個函式將由它們相對應的帶泛型T的全域性函式呼叫。這些全域性函式則由CDataStream中過載的操作符<<和>>呼叫。 一個巨集IMPLEMENT_SERIALIZE(statements)用於定義任意型別的這三個函式的實現。 
#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;                \
        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;              \
        {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;              \
        {statements}                            \
    }
以下例子示範怎樣使用該巨集。 
#include <iostream>
#include "serialize.h"
using namespace std;
class AClass {
public:
    AClass(int xin) : x(xin){};
    int x;
    IMPLEMENT_SERIALIZE(READWRITE(this->x);)
}
int main() {
    CDataStream astream2;
    AClass aObj(200); //一個x為200的AClass型別物件
    cout<<"aObj="<<aObj.x>>endl;
    asream2<<aObj;
    AClass a2(1); //另一個x為1的物件
    astream2>>a2
    cout<<"a2="<<a2.x<<endl;
    return 0;
}

這段程式序列化/反序列化AClass物件。它將在螢幕上輸出下面的結果。 
aObj=200
a2=200

AClass的這三個序列化/反序列化成員函式可以在一行程式碼中實現： IMPLEMENT_SERIALIZE(READWRITE(this->x);) 巨集READWRITE()的定義如下 
#define READWRITE(obj)      (nSerSize += ::SerReadWrite(s, (obj), nType, nVersion, ser_action))

該巨集的展開被放在巨集IMPLEMENT_SERIALIZE(statements)的全部三個函式裡。因此，它一次需要完成三件事情：1）返回序列化後資料的大小，2）序列化（寫入）資料至流；3）從流中反序列化（讀取）資料。參考巨集IMPLEMENT_SERIALIZE(statements)中對這三個函式的定義。 想要了解巨集READWRITE(obj)怎樣工作，你首先需要明白它的完整形式當中的nSerSize，s，nType，nVersion和ser_action是怎麼來的。它們全部來自巨集IMPLEMENT_SERIALIZE(statements)的三個函式主體部分：
  • nSerSize是一個unsigned int，在三個函式當中初始化為0；
  • ser_action是一個物件在三個函式當中均有宣告，但為三種不同型別。它在三個函式當中分別為CSerActionGetSerializeSize、CSerActionSerialize和CSerActionUnserialize；
  • s在第一個函式中定義為ser_streamplaceholder型別。它是第一個傳入至另外兩個函式的引數，擁有引數型別Stream；
  • nType和nVersion在三個函式中均為傳入引數。
因此，一旦巨集READWRITE()擴充套件至巨集IMPLEMENT_SERIALIZE()，所有它的符號都將被計算，因為它們已經存在於巨集IMPLEMENT_SERIALIZE()的主體中。READWRITE(obj)的擴充套件呼叫一個全域性函式::SerReadWrite(s, (obj), nType, nVersion, ser_action)。這裡是這個函式的全部三種版本。 
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;
}

如你所見，函式::SerReadWrite()被過載為三種版本。取決於最後一個引數，它將會調分別用全域性函式::GetSerialize()，::Serialize()和::Unserialize()；這三個函式在前面章節已經介紹。 如果你檢查三種不同版本的::SerReadWrite()的最後一個引數，你會發現它們全部為空型別。這三種類型的唯一用途是區別::SerReadWrite()的三個版本，繼而被巨集IMPLEMENT_SERIALIZE()定義的所有函式使用。

相關推薦

比特幣原始碼學習筆記（二）

第二章 本章繼上一章交易建立之後介紹比特幣客戶端序列化資料的過程。 比特幣客戶端所有的序列化函式均在seriliaze.h中實現。其中，CDataStream類是資料序列化的核心結構。 CDataStream CDataStream擁有一個字元類容器用來存放序列化之後的資料

比特幣原始碼學習筆記（一）

https://github.com/trottier/original-bitcoin 前言 從事區塊鏈的開發，不瞭解其底層核心技術是不夠的。許多人在看了比特幣白皮書之後仍然不清楚比特幣是怎樣實現的，因為比特幣的原始碼設計精巧，有許多設計白皮書未曾提及，加上本身

比特幣原始碼分析-網路（二）

比特幣原始碼分析-網路（二） https://www.jianshu.com/p/4b42d8698f35   眾所周知，比特幣網路是採用的P2P網路體系，所以，沒有明顯的客戶端與服務端的區別或者是概念，每一個節點既是自身的客戶端，又是其它節點的服務端。 在sync.h中，

比特幣原始碼學習筆記

比特幣原始碼學習筆記   FROM http://www.8btc.com/author/17786?order=hot 前言 從事區塊鏈的開發，不瞭解其底層核心技術是不夠的。許多人在看了比特幣白皮書之後仍然不清楚比特幣是怎樣實現的，因為比特幣的原始碼設計精巧，有

spring 原始碼學習筆記（二）事務管理

spring 事務管理會幫我們自動管理資料庫的事務，沒讀原始碼前覺得很神祕，讀了原始碼發現原理還是很簡單的。 本質上還是用的 jdbc 的事務管理。spring 在呼叫某個方法前，判斷是否需要事務，如果需要，則呼叫 con.setAutoCommit(false);//開

nginx 原始碼學習筆記（二十一）—— event 模組(二) ——事件驅動核心ngx_process_events_and_timers

首先繼續回憶下，之前子執行緒執行操作裡面有一個未涉及的內容ngx_process_events_and_timers，今天我們就來研究下這個函式。 本篇文章來自於：http://blog.csdn.net/lengzijian/article/details/7601730 先來看一下第十九

【區塊鏈】比特幣原始碼學習

比特幣原始碼學習 - 1 - 交易 參考部落格：here and here 一、交易概念 1、 交易形式 比特幣交易中的基礎構建單元是交易輸出。在比特幣的世界裡既沒有賬戶，也沒有餘額，只有分散到區塊鏈裡的UTXO[未花費的交易輸出]。 例如，你有20比特幣

STL原始碼剖析學習筆記（二）

iterator和traits程式設計技法（上） STL的中心思想在於，將資料容器和演算法分開，彼此獨立設計，然後再用一個粘合劑將其黏在一起。這個粘合劑，就是iterator。 由於容器和演算法都是適應於泛型程式設計的，所以iterator也必須適應這方面的

比特幣原始碼閱讀筆記【網路篇】

這篇文章總結下比特幣網路相關內容。 2008年中本聰創造比特幣時在白皮書中這樣定義比特幣：一個點對點的電子現金系統，那時還沒有“區塊鏈”這個說法。那段時間，點對點（P2P）網路已經有了廣泛的應用，例如Bittorrent和迅雷。P2P網路最大的特點就是網路中沒

區塊鏈(比特幣)的學習筆記

比特幣的基本概念及相關認識區塊鏈本質上是分散式的資料庫系統，是開放式的賬簿系統(ledger)。本質上，區塊鏈就是一個有著特定結構的資料庫，是一個有序，每一個塊都連線到前一個塊的連結串列。也就是說，區塊

比特幣原始碼閱讀筆記-創世塊的產生

const char*pszTimestamp = "2014/5/11 Write by Andy,Email:[email protected]";//我的創世區塊 CTransaction txNew; txNew.vin.resize(1);txNew.vout.resize(1); txN

php laravel框架學習筆記 （二） 數據庫操作

true 數據 mar sql show top 一行 ati del 原博客鏈接：http://www.cnblogs.com/bitch1319453/p/6810492.html mysql基本配置 你可用通過配置環境變量，使用cmd進入mysql，當然還有一種東

java學習筆記（二）圖形用戶接口

star strong per getwidth cep runnable graphics s2d gb2 這個學期主要放在ACM比賽上去了，比賽結束了。不知不覺就15周了，這周就要java考試了，復習一下java吧。java的學習的目的還是讓我們學以致用，讓我們可以

數據結構學習筆記（二） 線性表的順序存儲和鏈式存儲

出錯 初始化 node != test span 輸入 des val 線性表：由同類型數據元素構成有序序列的線性結構　　--》表中元素的個數稱為線性表的長度　　--》沒有元素時，成為空表　　--》表起始位置稱表頭，表結束位置稱表尾 順序存儲： 　　 1 package

Memcache 學習筆記（二）---- PHP 腳本操作 Memcache 服務器

ext status ram var_dump 介紹 修改 memcache local dbn 　　 PHP 腳本操作 Memcache 服務器 一、PHP腳本操作Memcache方法 　　　　使用 PHP 腳本操作 Memcache，在 PHP 手冊中有詳細的介紹，我們

javascript學習筆記（二）：定義函數、調用函數、參數、返回值、局部和全局變量

兩個 cnblogs bsp 結果 value ava ase com 調用 定義函數、調用函數、參數、返回值 關鍵字function定義函數，格式如下： function 函數名(){ 函數體 } 調用函數、參數、返回值的規則和c語言規則類似。 1 <!DOC

神箭手爬蟲學習筆記（二）

暫存 自動 表達 eve doc 常用 學習 數據 .sh 一，可以使用神劍手已經做好的爬蟲市場直接跑，不需要自己定義爬取規則 二，爬蟲市場裏沒有的網站，需要自己去定義規則來爬數據。 三，爬取的數據可以先存放在神劍手，也可以放到七牛暫存。（提醒下，網站需要數據備份如果數量不

thinkphp5.0學習筆記（二）API後臺處理與命名空間

mac code 輸入 -1 pub 基礎 select() color 第一個 命名空間 先來看命名空間吧； 命名空間是學習TP的基礎， <?php namespace app\lian\c1; class yi{ public $obj = "這是第一個

MongoDB學習筆記（二）

.get 條件過濾 條件 $set system.in ins version tle 不存在 一、Mongodb命令 說明：Mongodb命令是區分大小寫的，使用的命名規則是駝峰命名法。 對於database和collection無需主動創建，在插入數據時，如果dat

設計模式學習筆記（二） 設計基本原則之【單一職責原則】

code 分享 開發者 實際應用 需要 ret ext file類 tor 單一職責原則（SRP： Single Responsibility Principle） 名詞解釋： 1） 職責：是指類變化的原因。 2） 職責擴散：就是因為某種原因，職責P被分化為粒度更細的職責P