[VerusCoin.git] / db.h

// 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.

class CTransaction;
class CTxIndex;
class CDiskBlockIndex;
class CDiskTxPos;
class COutPoint;
class CUser;
class CReview;
class CAddress;
class CWalletTx;

extern map<string, string> mapAddressBook;
extern CCriticalSection cs_mapAddressBook;
extern vector<unsigned char> vchDefaultKey;
extern bool fClient;
extern int nBestHeight;


extern unsigned int nWalletDBUpdated;
extern DbEnv dbenv;


extern void DBFlush(bool fShutdown);


class CDB
{
protected:
    Db* pdb;
    string strFile;
    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", false));

        // 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", false));

        // 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(string("version"), nVersion);
    }

    bool WriteVersion(int nVersion)
    {
        return Write(string("version"), nVersion);
    }
};


class CTxDB : public CDB
{
public:
    CTxDB(const char* pszMode="r+") : CDB(!fClient ? "blkindex.dat" : NULL, 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, 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 LoadAddresses();
};

bool LoadAddresses();


class CWalletDB : public CDB
{
public:
    CWalletDB(const char* pszMode="r+") : CDB("wallet.dat", pszMode) { }
private:
    CWalletDB(const CWalletDB&);
    void operator=(const CWalletDB&);
public:
    bool ReadName(const string& strAddress, string& strName)
    {
        strName = "";
        return Read(make_pair(string("name"), strAddress), strName);
    }

    bool WriteName(const string& strAddress, const string& strName)
    {
        CRITICAL_BLOCK(cs_mapAddressBook)
            mapAddressBook[strAddress] = strName;
        nWalletDBUpdated++;
        return Write(make_pair(string("name"), strAddress), strName);
    }

    bool 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.
        CRITICAL_BLOCK(cs_mapAddressBook)
            mapAddressBook.erase(strAddress);
        nWalletDBUpdated++;
        return Erase(make_pair(string("name"), strAddress));
    }

    bool ReadTx(uint256 hash, CWalletTx& wtx)
    {
        return Read(make_pair(string("tx"), hash), wtx);
    }

    bool WriteTx(uint256 hash, const CWalletTx& wtx)
    {
        nWalletDBUpdated++;
        return Write(make_pair(string("tx"), hash), wtx);
    }

    bool EraseTx(uint256 hash)
    {
        nWalletDBUpdated++;
        return Erase(make_pair(string("tx"), hash));
    }

    bool ReadKey(const vector<unsigned char>& vchPubKey, CPrivKey& vchPrivKey)
    {
        vchPrivKey.clear();
        return Read(make_pair(string("key"), vchPubKey), vchPrivKey);
    }

    bool WriteKey(const vector<unsigned char>& vchPubKey, const CPrivKey& vchPrivKey)
    {
        nWalletDBUpdated++;
        return Write(make_pair(string("key"), vchPubKey), vchPrivKey, false);
    }

    bool ReadDefaultKey(vector<unsigned char>& vchPubKey)
    {
        vchPubKey.clear();
        return Read(string("defaultkey"), vchPubKey);
    }

    bool WriteDefaultKey(const vector<unsigned char>& vchPubKey)
    {
        vchDefaultKey = vchPubKey;
        nWalletDBUpdated++;
        return Write(string("defaultkey"), vchPubKey);
    }

    template<typename T>
    bool ReadSetting(const string& strKey, T& value)
    {
        return Read(make_pair(string("setting"), strKey), value);
    }

    template<typename T>
    bool WriteSetting(const string& strKey, const T& value)
    {
        nWalletDBUpdated++;
        return Write(make_pair(string("setting"), strKey), value);
    }

    bool LoadWallet();
};

bool LoadWallet(bool& fFirstRunRet);
void BackupWallet(const string& strDest);

inline bool SetAddressBookName(const string& strAddress, const string& strName)
{
    return CWalletDB().WriteName(strAddress, strName);
}
Commit	Line	Data
0a61b0df	1	// Copyright (c) 2009-2010 Satoshi Nakamoto
	2	// Distributed under the MIT/X11 software license, see the accompanying
	3	// file license.txt or http://www.opensource.org/licenses/mit-license.php.
	4
	5	class CTransaction;
	6	class CTxIndex;
	7	class CDiskBlockIndex;
	8	class CDiskTxPos;
	9	class COutPoint;
	10	class CUser;
	11	class CReview;
	12	class CAddress;
	13	class CWalletTx;
	14
	15	extern map<string, string> mapAddressBook;
	16	extern CCriticalSection cs_mapAddressBook;
	17	extern vector<unsigned char> vchDefaultKey;
	18	extern bool fClient;
	19	extern int nBestHeight;
	20
	21
	22	extern unsigned int nWalletDBUpdated;
	23	extern DbEnv dbenv;
	24
	25
	26	extern void DBFlush(bool fShutdown);
	27
	28
	29
	30
	31	class CDB
	32	{
	33	protected:
	34	Db* pdb;
	35	string strFile;
	36	vector<DbTxn*> vTxn;
	37	bool fReadOnly;
	38
	39	explicit CDB(const char* pszFile, const char* pszMode="r+");
	40	~CDB() { Close(); }
	41	public:
	42	void Close();
	43	private:
	44	CDB(const CDB&);
	45	void operator=(const CDB&);
	46
	47	protected:
	48	template<typename K, typename T>
	49	bool Read(const K& key, T& value)
	50	{
	51	if (!pdb)
	52	return false;
	53
	54	// Key
	55	CDataStream ssKey(SER_DISK);
	56	ssKey.reserve(1000);
	57	ssKey << key;
	58	Dbt datKey(&ssKey[0], ssKey.size());
	59
	60	// Read
	61	Dbt datValue;
	62	datValue.set_flags(DB_DBT_MALLOC);
	63	int ret = pdb->get(GetTxn(), &datKey, &datValue, 0);
	64	memset(datKey.get_data(), 0, datKey.get_size());
65	if (datValue.get_data() == NULL)
66	return false;
67
68	// Unserialize value
69	CDataStream ssValue((char)datValue.get_data(), (char)datValue.get_data() + datValue.get_size(), SER_DISK);
70	ssValue >> value;
71
72	// Clear and free memory
73	memset(datValue.get_data(), 0, datValue.get_size());
74	free(datValue.get_data());
75	return (ret == 0);
76	}
77
78	template<typename K, typename T>
79	bool Write(const K& key, const T& value, bool fOverwrite=true)
80	{
81	if (!pdb)
82	return false;
83	if (fReadOnly)
84	assert(("Write called on database in read-only mode", false));
85
86	// Key
87	CDataStream ssKey(SER_DISK);
88	ssKey.reserve(1000);
89	ssKey << key;
90	Dbt datKey(&ssKey[0], ssKey.size());
91
92	// Value
93	CDataStream ssValue(SER_DISK);
94	ssValue.reserve(10000);
95	ssValue << value;
96	Dbt datValue(&ssValue[0], ssValue.size());
97
98	// Write
99	int ret = pdb->put(GetTxn(), &datKey, &datValue, (fOverwrite ? 0 : DB_NOOVERWRITE));
100
101	// Clear memory in case it was a private key
102	memset(datKey.get_data(), 0, datKey.get_size());
103	memset(datValue.get_data(), 0, datValue.get_size());
104	return (ret == 0);
105	}
106
107	template<typename K>
108	bool Erase(const K& key)
109	{
110	if (!pdb)
111	return false;
112	if (fReadOnly)
113	assert(("Erase called on database in read-only mode", false));
114
115	// Key
116	CDataStream ssKey(SER_DISK);
117	ssKey.reserve(1000);
118	ssKey << key;
119	Dbt datKey(&ssKey[0], ssKey.size());
120
121	// Erase
122	int ret = pdb->del(GetTxn(), &datKey, 0);
123
124	// Clear memory
125	memset(datKey.get_data(), 0, datKey.get_size());
126	return (ret == 0 \|\| ret == DB_NOTFOUND);
127	}
128
129	template<typename K>
130	bool Exists(const K& key)
131	{
132	if (!pdb)
133	return false;
134
135	// Key
136	CDataStream ssKey(SER_DISK);
137	ssKey.reserve(1000);
138	ssKey << key;
139	Dbt datKey(&ssKey[0], ssKey.size());
140
141	// Exists
142	int ret = pdb->exists(GetTxn(), &datKey, 0);
143
144	// Clear memory
145	memset(datKey.get_data(), 0, datKey.get_size());
146	return (ret == 0);
147	}
148
149	Dbc* GetCursor()
150	{
151	if (!pdb)
152	return NULL;
153	Dbc* pcursor = NULL;
154	int ret = pdb->cursor(NULL, &pcursor, 0);
155	if (ret != 0)
156	return NULL;
157	return pcursor;
158	}
159
160	int ReadAtCursor(Dbc* pcursor, CDataStream& ssKey, CDataStream& ssValue, unsigned int fFlags=DB_NEXT)
161	{
162	// Read at cursor
163	Dbt datKey;
164	if (fFlags == DB_SET \|\| fFlags == DB_SET_RANGE \|\| fFlags == DB_GET_BOTH \|\| fFlags == DB_GET_BOTH_RANGE)
165	{
166	datKey.set_data(&ssKey[0]);
167	datKey.set_size(ssKey.size());
168	}
169	Dbt datValue;
170	if (fFlags == DB_GET_BOTH \|\| fFlags == DB_GET_BOTH_RANGE)
171	{
172	datValue.set_data(&ssValue[0]);
173	datValue.set_size(ssValue.size());
174	}
175	datKey.set_flags(DB_DBT_MALLOC);
176	datValue.set_flags(DB_DBT_MALLOC);
177	int ret = pcursor->get(&datKey, &datValue, fFlags);
178	if (ret != 0)
179	return ret;
180	else if (datKey.get_data() == NULL \|\| datValue.get_data() == NULL)
181	return 99999;
182
183	// Convert to streams
184	ssKey.SetType(SER_DISK);
185	ssKey.clear();
186	ssKey.write((char*)datKey.get_data(), datKey.get_size());
187	ssValue.SetType(SER_DISK);
188	ssValue.clear();
189	ssValue.write((char*)datValue.get_data(), datValue.get_size());
190
191	// Clear and free memory
192	memset(datKey.get_data(), 0, datKey.get_size());
193	memset(datValue.get_data(), 0, datValue.get_size());
194	free(datKey.get_data());
195	free(datValue.get_data());
196	return 0;
197	}
198
199	DbTxn* GetTxn()
200	{
201	if (!vTxn.empty())
202	return vTxn.back();
203	else
204	return NULL;
205	}
206
207	public:
208	bool TxnBegin()
209	{
210	if (!pdb)
211	return false;
212	DbTxn* ptxn = NULL;
213	int ret = dbenv.txn_begin(GetTxn(), &ptxn, DB_TXN_NOSYNC);
214	if (!ptxn \|\| ret != 0)
215	return false;
216	vTxn.push_back(ptxn);
217	return true;
218	}
219
220	bool TxnCommit()
221	{
222	if (!pdb)
223	return false;
224	if (vTxn.empty())
225	return false;
226	int ret = vTxn.back()->commit(0);
227	vTxn.pop_back();
228	return (ret == 0);
229	}
230
231	bool TxnAbort()
232	{
233	if (!pdb)
234	return false;
235	if (vTxn.empty())
236	return false;
237	int ret = vTxn.back()->abort();
238	vTxn.pop_back();
239	return (ret == 0);
240	}
241
242	bool ReadVersion(int& nVersion)
243	{
244	nVersion = 0;
245	return Read(string("version"), nVersion);
246	}
247
248	bool WriteVersion(int nVersion)
249	{
250	return Write(string("version"), nVersion);
251	}
252	};
253
254
255
256
257
258
259
260
261	class CTxDB : public CDB
262	{
263	public:
264	CTxDB(const char* pszMode="r+") : CDB(!fClient ? "blkindex.dat" : NULL, pszMode) { }
265	private:
266	CTxDB(const CTxDB&);
267	void operator=(const CTxDB&);
268	public:
269	bool ReadTxIndex(uint256 hash, CTxIndex& txindex);
270	bool UpdateTxIndex(uint256 hash, const CTxIndex& txindex);
271	bool AddTxIndex(const CTransaction& tx, const CDiskTxPos& pos, int nHeight);
272	bool EraseTxIndex(const CTransaction& tx);
273	bool ContainsTx(uint256 hash);
274	bool ReadOwnerTxes(uint160 hash160, int nHeight, vector<CTransaction>& vtx);
275	bool ReadDiskTx(uint256 hash, CTransaction& tx, CTxIndex& txindex);
276	bool ReadDiskTx(uint256 hash, CTransaction& tx);
277	bool ReadDiskTx(COutPoint outpoint, CTransaction& tx, CTxIndex& txindex);
278	bool ReadDiskTx(COutPoint outpoint, CTransaction& tx);
279	bool WriteBlockIndex(const CDiskBlockIndex& blockindex);
280	bool EraseBlockIndex(uint256 hash);
281	bool ReadHashBestChain(uint256& hashBestChain);
282	bool WriteHashBestChain(uint256 hashBestChain);
283	bool ReadBestInvalidWork(CBigNum& bnBestInvalidWork);
284	bool WriteBestInvalidWork(CBigNum bnBestInvalidWork);
285	bool LoadBlockIndex();
286	};
287
288
289
290
291
292	class CAddrDB : public CDB
293	{
294	public:
295	CAddrDB(const char* pszMode="r+") : CDB("addr.dat", pszMode) { }
296	private:
297	CAddrDB(const CAddrDB&);
298	void operator=(const CAddrDB&);
299	public:
300	bool WriteAddress(const CAddress& addr);
301	bool LoadAddresses();
302	};
303
304	bool LoadAddresses();
305
306
307
308
309
310
311	class CWalletDB : public CDB
312	{
313	public:
314	CWalletDB(const char* pszMode="r+") : CDB("wallet.dat", pszMode) { }
315	private:
316	CWalletDB(const CWalletDB&);
317	void operator=(const CWalletDB&);
318	public:
319	bool ReadName(const string& strAddress, string& strName)
320	{
321	strName = "";
322	return Read(make_pair(string("name"), strAddress), strName);
323	}
324
325	bool WriteName(const string& strAddress, const string& strName)
326	{
327	CRITICAL_BLOCK(cs_mapAddressBook)
328	mapAddressBook[strAddress] = strName;
329	nWalletDBUpdated++;
330	return Write(make_pair(string("name"), strAddress), strName);
331	}
332
333	bool EraseName(const string& strAddress)
334	{
335	// This should only be used for sending addresses, never for receiving addresses,
336	// receiving addresses must always have an address book entry if they're not change return.
337	CRITICAL_BLOCK(cs_mapAddressBook)
338	mapAddressBook.erase(strAddress);
339	nWalletDBUpdated++;
340	return Erase(make_pair(string("name"), strAddress));
341	}
342
343	bool ReadTx(uint256 hash, CWalletTx& wtx)
344	{
345	return Read(make_pair(string("tx"), hash), wtx);
346	}
347
348	bool WriteTx(uint256 hash, const CWalletTx& wtx)
349	{
350	nWalletDBUpdated++;
351	return Write(make_pair(string("tx"), hash), wtx);
352	}
353
354	bool EraseTx(uint256 hash)
355	{
356	nWalletDBUpdated++;
357	return Erase(make_pair(string("tx"), hash));
358	}
359
360	bool ReadKey(const vector<unsigned char>& vchPubKey, CPrivKey& vchPrivKey)
361	{
362	vchPrivKey.clear();
363	return Read(make_pair(string("key"), vchPubKey), vchPrivKey);
364	}
365
366	bool WriteKey(const vector<unsigned char>& vchPubKey, const CPrivKey& vchPrivKey)
367	{
368	nWalletDBUpdated++;
369	return Write(make_pair(string("key"), vchPubKey), vchPrivKey, false);
370	}
371
372	bool ReadDefaultKey(vector<unsigned char>& vchPubKey)
373	{
374	vchPubKey.clear();
375	return Read(string("defaultkey"), vchPubKey);
376	}
377
378	bool WriteDefaultKey(const vector<unsigned char>& vchPubKey)
379	{
380	vchDefaultKey = vchPubKey;
381	nWalletDBUpdated++;
382	return Write(string("defaultkey"), vchPubKey);
383	}
384
385	template<typename T>
386	bool ReadSetting(const string& strKey, T& value)
387	{
388	return Read(make_pair(string("setting"), strKey), value);
389	}
390
391	template<typename T>
392	bool WriteSetting(const string& strKey, const T& value)
393	{
394	nWalletDBUpdated++;
395	return Write(make_pair(string("setting"), strKey), value);
396	}
397
398	bool LoadWallet();
399	};
400
401	bool LoadWallet(bool& fFirstRunRet);
d743f035	402	void BackupWallet(const string& strDest);
0a61b0df	403
	404	inline bool SetAddressBookName(const string& strAddress, const string& strName)
	405	{
	406	return CWalletDB().WriteName(strAddress, strName);
	407	}