Add database API and logic.
This commit is contained in:
Marc Burns
parent
9d9525f957
commit
55a63f8cd9
|
|
@ -0,0 +1,158 @@
|
|||
#include "db.h"
|
||||
#include "log.h"
|
||||
#include "sha1.h"
|
||||
#include <cassert>
|
||||
#include <cstdlib>
|
||||
#include <cstdio>
|
||||
#include <ctime>
|
||||
|
||||
PosDb::PosDb(const char * fn)
|
||||
: log(fn)
|
||||
{
|
||||
// read in the log
|
||||
for(std::list<LogEntry>::const_iterator p = log.begin(); p != log.end(); ++p)
|
||||
acceptLogEntry(*p);
|
||||
}
|
||||
|
||||
void PosDb::acceptLogEntry(const LogEntry & l) {
|
||||
switch(l.type) {
|
||||
case ET_HASH: {
|
||||
SHA1Hash h;
|
||||
h.set((unsigned char *)l.HashChange.hash);
|
||||
|
||||
if(l.HashChange.add) {
|
||||
// verify hash not associated with anything
|
||||
if(hash_to_account.find(h) != hash_to_account.end()) {
|
||||
fprintf(stderr, "PosDb: Log associates a hash"
|
||||
" with more than one account! Aborting.");
|
||||
abort();
|
||||
} else {
|
||||
hash_to_account[h] = l.HashChange.uid;
|
||||
}
|
||||
} else {
|
||||
// verify hash associated with something
|
||||
std::map<SHA1Hash, uint32_t, SHA1Less>::iterator it
|
||||
= hash_to_account.find(h);
|
||||
if(it == hash_to_account.end()) {
|
||||
fprintf(stderr, "PosDb: Log deassociates an"
|
||||
"unassociated hash! Aborting.");
|
||||
abort();
|
||||
} else {
|
||||
hash_to_account.erase(it);
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case ET_TRANS: {
|
||||
SHA1Hash h;
|
||||
h.set((unsigned char *)l.Transaction.hash);
|
||||
|
||||
std::map<SHA1Hash, uint32_t, SHA1Less>::iterator it
|
||||
= hash_to_account.find(h);
|
||||
|
||||
if(it == hash_to_account.end()) {
|
||||
fprintf(stderr, "PosDb: Log transacts on"
|
||||
" unassociated hash! Aborting.");
|
||||
abort();
|
||||
} else {
|
||||
std::map<uint32_t, int32_t>::iterator q =
|
||||
account_to_balance.find(it->second);
|
||||
if(q == account_to_balance.end())
|
||||
account_to_balance[it->second] = l.Transaction.delta;
|
||||
else
|
||||
q->second += l.Transaction.delta;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t PosDb::getAccountFromHash(const SHA1Hash & hash) {
|
||||
std::map<SHA1Hash, uint32_t, SHA1Less>::iterator it
|
||||
= hash_to_account.find(hash);
|
||||
if(it == hash_to_account.end())
|
||||
return 0;
|
||||
return it->second;
|
||||
}
|
||||
|
||||
std::list<std::string> PosDb::getHashesFromAccount(uint32_t account) {
|
||||
std::list<std::string> result;
|
||||
char bfr[20];
|
||||
|
||||
for(std::map<SHA1Hash, uint32_t, SHA1Less>::iterator p
|
||||
= hash_to_account.begin();
|
||||
p != hash_to_account.end(); ++p)
|
||||
{
|
||||
if(p->second == account)
|
||||
{
|
||||
p->first.get((unsigned char *)bfr);
|
||||
result.push_back(bfr);
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
int32_t PosDb::getAccountBalance(const SHA1Hash & hash) {
|
||||
std::map<SHA1Hash, uint32_t, SHA1Less>::iterator it
|
||||
= hash_to_account.find(hash);
|
||||
|
||||
if(it == hash_to_account.end())
|
||||
return 0;
|
||||
else {
|
||||
std::map<uint32_t, int32_t>::iterator p
|
||||
= account_to_balance.find(it->second);
|
||||
if(p == account_to_balance.end())
|
||||
return 0;
|
||||
else
|
||||
return p->second;
|
||||
}
|
||||
}
|
||||
|
||||
int32_t PosDb::getAccountBalance(uint32_t account) {
|
||||
std::map<uint32_t, int32_t>::iterator p
|
||||
= account_to_balance.find(account);
|
||||
if(p == account_to_balance.end())
|
||||
return 0;
|
||||
else
|
||||
return p->second;
|
||||
}
|
||||
|
||||
uint64_t PosDb::associateHash(const SHA1Hash & hash, uint32_t account) {
|
||||
// verify hash not associated with anything
|
||||
if(hash_to_account.find(hash) != hash_to_account.end()) {
|
||||
return 0;
|
||||
} else {
|
||||
LogEntry l;
|
||||
l.ts = (uint64_t)time(NULL);
|
||||
l.type = ET_HASH;
|
||||
l.HashChange.uid = account;
|
||||
l.HashChange.add = true;
|
||||
hash.get((unsigned char *)l.HashChange.hash);
|
||||
|
||||
acceptLogEntry(l);
|
||||
return log.writeEntry(l);
|
||||
}
|
||||
}
|
||||
|
||||
uint64_t PosDb::deassociateHash(const SHA1Hash & hash) {
|
||||
// verify hash associated with something
|
||||
std::map<SHA1Hash, uint32_t, SHA1Less>::iterator p
|
||||
= hash_to_account.find(hash);
|
||||
if(p == hash_to_account.end()) {
|
||||
return 0;
|
||||
} else {
|
||||
LogEntry l;
|
||||
l.ts = (uint64_t)time(NULL);
|
||||
l.type = ET_HASH;
|
||||
l.HashChange.uid = p->second;
|
||||
l.HashChange.add = false;
|
||||
hash.get((unsigned char *)l.HashChange.hash);
|
||||
|
||||
acceptLogEntry(l);
|
||||
return log.writeEntry(l);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
#ifndef _POS_DB_H_
|
||||
#define _POS_DB_H_
|
||||
#include "sha1.h"
|
||||
#include "log.h"
|
||||
#include <stdint.h>
|
||||
#include <list>
|
||||
#include <map>
|
||||
#include <string>
|
||||
|
||||
class PosDb {
|
||||
public:
|
||||
PosDb(const char * fn);
|
||||
uint32_t getAccountFromHash(const SHA1Hash & hash);
|
||||
std::list<std::string> getHashesFromAccount(uint32_t account);
|
||||
|
||||
int32_t getAccountBalance(const SHA1Hash & hash);
|
||||
int32_t getAccountBalance(uint32_t account);
|
||||
|
||||
uint64_t associateHash(const SHA1Hash & hash, uint32_t account);
|
||||
uint64_t deassociateHash(const SHA1Hash & hash);
|
||||
|
||||
uint64_t doTransaction(const SHA1Hash & hash, int32_t delta);
|
||||
uint64_t revertTransaction(uint64_t serial);
|
||||
|
||||
int32_t getStock(UPC upc);
|
||||
uint64_t doStockChange(UPC upc, int32_t delta);
|
||||
|
||||
private:
|
||||
void acceptLogEntry(const LogEntry & l);
|
||||
|
||||
std::map<SHA1Hash, uint32_t, SHA1Less> hash_to_account;
|
||||
std::map<uint32_t, int32_t> account_to_balance;
|
||||
|
||||
std::map<UPC, int32_t, UPCLess> upc_to_stock;
|
||||
|
||||
std::map<uint64_t, std::list<LogEntry>::const_iterator> serial_to_object;
|
||||
|
||||
Log log;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,225 @@
|
|||
/* Original (C) 2009 Linus Torvalds
|
||||
* Used with permission under GNU GPL licence
|
||||
*
|
||||
* Based on the Mozilla SHA1 (see mozilla-sha1/sha1.c),
|
||||
* optimized to do word accesses rather than byte accesses,
|
||||
* and to avoid unnecessary copies into the context array.
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
#include <arpa/inet.h>
|
||||
|
||||
#include "linus_sha1.h"
|
||||
|
||||
/* Hash one 64-byte block of data */
|
||||
static void blk_SHA1Block(blk_SHA_CTX *ctx, const unsigned int *data);
|
||||
|
||||
void blk_SHA1_Init(blk_SHA_CTX *ctx)
|
||||
{
|
||||
ctx->size = 0;
|
||||
|
||||
/* Initialize H with the magic constants (see FIPS180 for constants)
|
||||
*/
|
||||
ctx->H[0] = 0x67452301;
|
||||
ctx->H[1] = 0xefcdab89;
|
||||
ctx->H[2] = 0x98badcfe;
|
||||
ctx->H[3] = 0x10325476;
|
||||
ctx->H[4] = 0xc3d2e1f0;
|
||||
}
|
||||
|
||||
|
||||
void blk_SHA1_Update(blk_SHA_CTX *ctx, const void *data, unsigned long len)
|
||||
{
|
||||
int lenW = ctx->size & 63;
|
||||
|
||||
ctx->size += len;
|
||||
|
||||
/* Read the data into W and process blocks as they get full
|
||||
*/
|
||||
if (lenW) {
|
||||
int left = 64 - lenW;
|
||||
if (len < left)
|
||||
left = len;
|
||||
memcpy(lenW + (char *)ctx->W, data, left);
|
||||
lenW = (lenW + left) & 63;
|
||||
len -= left;
|
||||
data += left;
|
||||
if (lenW)
|
||||
return;
|
||||
blk_SHA1Block(ctx, (const unsigned int*)ctx->W);
|
||||
}
|
||||
while (len >= 64) {
|
||||
blk_SHA1Block(ctx, (const unsigned int*)data);
|
||||
data += 64;
|
||||
len -= 64;
|
||||
}
|
||||
if (len)
|
||||
memcpy(ctx->W, data, len);
|
||||
}
|
||||
|
||||
|
||||
void blk_SHA1_Final(unsigned char hashout[20], blk_SHA_CTX *ctx)
|
||||
{
|
||||
static const unsigned char pad[64] = { 0x80 };
|
||||
unsigned int padlen[2];
|
||||
int i;
|
||||
|
||||
/* Pad with a binary 1 (ie 0x80), then zeroes, then length
|
||||
*/
|
||||
padlen[0] = htonl(ctx->size >> 29);
|
||||
padlen[1] = htonl(ctx->size << 3);
|
||||
|
||||
i = ctx->size & 63;
|
||||
blk_SHA1_Update(ctx, pad, 1+ (63 & (55 - i)));
|
||||
blk_SHA1_Update(ctx, padlen, 8);
|
||||
|
||||
/* Output hash
|
||||
*/
|
||||
for (i = 0; i < 5; i++)
|
||||
((unsigned int *)hashout)[i] = htonl(ctx->H[i]);
|
||||
}
|
||||
|
||||
#if defined(__i386__) || defined(__x86_64__)
|
||||
|
||||
#define SHA_ASM(op, x, n) ({ unsigned int __res; __asm__(op " %1,%0":"=r" (__res):"i" (n), "0" (x)); __res; })
|
||||
#define SHA_ROL(x,n) SHA_ASM("rol", x, n)
|
||||
#define SHA_ROR(x,n) SHA_ASM("ror", x, n)
|
||||
|
||||
#else
|
||||
|
||||
#define SHA_ROT(X,l,r) (((X) << (l)) | ((X) >> (r)))
|
||||
#define SHA_ROL(X,n) SHA_ROT(X,n,32-(n))
|
||||
#define SHA_ROR(X,n) SHA_ROT(X,32-(n),n)
|
||||
|
||||
#endif
|
||||
|
||||
/* This "rolls" over the 512-bit array */
|
||||
#define W(x) (array[(x)&15])
|
||||
#define setW(x, val) (*(volatile unsigned int *)&W(x) = (val))
|
||||
|
||||
/*
|
||||
* Where do we get the source from? The first 16 iterations get it from
|
||||
* the input data, the next mix it from the 512-bit array.
|
||||
*/
|
||||
#define SHA_SRC(t) htonl(data[t])
|
||||
#define SHA_MIX(t) SHA_ROL(W(t+13) ^ W(t+8) ^ W(t+2) ^ W(t), 1)
|
||||
|
||||
#define SHA_ROUND(t, input, fn, constant, A, B, C, D, E) do { \
|
||||
unsigned int TEMP = input(t); setW(t, TEMP); \
|
||||
E += TEMP + SHA_ROL(A,5) + (fn) + (constant); \
|
||||
B = SHA_ROR(B, 2); } while (0)
|
||||
|
||||
#define T_0_15(t, A, B, C, D, E) SHA_ROUND(t, SHA_SRC, (((C^D)&B)^D) , 0x5a827999, A, B, C, D, E )
|
||||
#define T_16_19(t, A, B, C, D, E) SHA_ROUND(t, SHA_MIX, (((C^D)&B)^D) , 0x5a827999, A, B, C, D, E )
|
||||
#define T_20_39(t, A, B, C, D, E) SHA_ROUND(t, SHA_MIX, (B^C^D) , 0x6ed9eba1, A, B, C, D, E )
|
||||
#define T_40_59(t, A, B, C, D, E) SHA_ROUND(t, SHA_MIX, ((B&C)+(D&(B^C))) , 0x8f1bbcdc, A, B, C, D, E )
|
||||
#define T_60_79(t, A, B, C, D, E) SHA_ROUND(t, SHA_MIX, (B^C^D) , 0xca62c1d6, A, B, C, D, E )
|
||||
|
||||
static void blk_SHA1Block(blk_SHA_CTX *ctx, const unsigned int *data)
|
||||
{
|
||||
unsigned int A,B,C,D,E;
|
||||
unsigned int array[16];
|
||||
|
||||
A = ctx->H[0];
|
||||
B = ctx->H[1];
|
||||
C = ctx->H[2];
|
||||
D = ctx->H[3];
|
||||
E = ctx->H[4];
|
||||
|
||||
/* Round 1 - iterations 0-16 take their input from 'data' */
|
||||
T_0_15( 0, A, B, C, D, E);
|
||||
T_0_15( 1, E, A, B, C, D);
|
||||
T_0_15( 2, D, E, A, B, C);
|
||||
T_0_15( 3, C, D, E, A, B);
|
||||
T_0_15( 4, B, C, D, E, A);
|
||||
T_0_15( 5, A, B, C, D, E);
|
||||
T_0_15( 6, E, A, B, C, D);
|
||||
T_0_15( 7, D, E, A, B, C);
|
||||
T_0_15( 8, C, D, E, A, B);
|
||||
T_0_15( 9, B, C, D, E, A);
|
||||
T_0_15(10, A, B, C, D, E);
|
||||
T_0_15(11, E, A, B, C, D);
|
||||
T_0_15(12, D, E, A, B, C);
|
||||
T_0_15(13, C, D, E, A, B);
|
||||
T_0_15(14, B, C, D, E, A);
|
||||
T_0_15(15, A, B, C, D, E);
|
||||
|
||||
/* Round 1 - tail. Input from 512-bit mixing array */
|
||||
T_16_19(16, E, A, B, C, D);
|
||||
T_16_19(17, D, E, A, B, C);
|
||||
T_16_19(18, C, D, E, A, B);
|
||||
T_16_19(19, B, C, D, E, A);
|
||||
|
||||
/* Round 2 */
|
||||
T_20_39(20, A, B, C, D, E);
|
||||
T_20_39(21, E, A, B, C, D);
|
||||
T_20_39(22, D, E, A, B, C);
|
||||
T_20_39(23, C, D, E, A, B);
|
||||
T_20_39(24, B, C, D, E, A);
|
||||
T_20_39(25, A, B, C, D, E);
|
||||
T_20_39(26, E, A, B, C, D);
|
||||
T_20_39(27, D, E, A, B, C);
|
||||
T_20_39(28, C, D, E, A, B);
|
||||
T_20_39(29, B, C, D, E, A);
|
||||
T_20_39(30, A, B, C, D, E);
|
||||
T_20_39(31, E, A, B, C, D);
|
||||
T_20_39(32, D, E, A, B, C);
|
||||
T_20_39(33, C, D, E, A, B);
|
||||
T_20_39(34, B, C, D, E, A);
|
||||
T_20_39(35, A, B, C, D, E);
|
||||
T_20_39(36, E, A, B, C, D);
|
||||
T_20_39(37, D, E, A, B, C);
|
||||
T_20_39(38, C, D, E, A, B);
|
||||
T_20_39(39, B, C, D, E, A);
|
||||
|
||||
/* Round 3 */
|
||||
T_40_59(40, A, B, C, D, E);
|
||||
T_40_59(41, E, A, B, C, D);
|
||||
T_40_59(42, D, E, A, B, C);
|
||||
T_40_59(43, C, D, E, A, B);
|
||||
T_40_59(44, B, C, D, E, A);
|
||||
T_40_59(45, A, B, C, D, E);
|
||||
T_40_59(46, E, A, B, C, D);
|
||||
T_40_59(47, D, E, A, B, C);
|
||||
T_40_59(48, C, D, E, A, B);
|
||||
T_40_59(49, B, C, D, E, A);
|
||||
T_40_59(50, A, B, C, D, E);
|
||||
T_40_59(51, E, A, B, C, D);
|
||||
T_40_59(52, D, E, A, B, C);
|
||||
T_40_59(53, C, D, E, A, B);
|
||||
T_40_59(54, B, C, D, E, A);
|
||||
T_40_59(55, A, B, C, D, E);
|
||||
T_40_59(56, E, A, B, C, D);
|
||||
T_40_59(57, D, E, A, B, C);
|
||||
T_40_59(58, C, D, E, A, B);
|
||||
T_40_59(59, B, C, D, E, A);
|
||||
|
||||
/* Round 4 */
|
||||
T_60_79(60, A, B, C, D, E);
|
||||
T_60_79(61, E, A, B, C, D);
|
||||
T_60_79(62, D, E, A, B, C);
|
||||
T_60_79(63, C, D, E, A, B);
|
||||
T_60_79(64, B, C, D, E, A);
|
||||
T_60_79(65, A, B, C, D, E);
|
||||
T_60_79(66, E, A, B, C, D);
|
||||
T_60_79(67, D, E, A, B, C);
|
||||
T_60_79(68, C, D, E, A, B);
|
||||
T_60_79(69, B, C, D, E, A);
|
||||
T_60_79(70, A, B, C, D, E);
|
||||
T_60_79(71, E, A, B, C, D);
|
||||
T_60_79(72, D, E, A, B, C);
|
||||
T_60_79(73, C, D, E, A, B);
|
||||
T_60_79(74, B, C, D, E, A);
|
||||
T_60_79(75, A, B, C, D, E);
|
||||
T_60_79(76, E, A, B, C, D);
|
||||
T_60_79(77, D, E, A, B, C);
|
||||
T_60_79(78, C, D, E, A, B);
|
||||
T_60_79(79, B, C, D, E, A);
|
||||
|
||||
ctx->H[0] += A;
|
||||
ctx->H[1] += B;
|
||||
ctx->H[2] += C;
|
||||
ctx->H[3] += D;
|
||||
ctx->H[4] += E;
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
/* Original (C) 2009 Linus Torvalds
|
||||
* Used with permission under GNU GPL licence
|
||||
*
|
||||
* Based on the Mozilla SHA1 (see mozilla-sha1/sha1.h),
|
||||
* optimized to do word accesses rather than byte accesses,
|
||||
* and to avoid unnecessary copies into the context array.
|
||||
*/
|
||||
|
||||
typedef struct {
|
||||
unsigned int H[5];
|
||||
unsigned int W[16];
|
||||
unsigned long long size;
|
||||
} blk_SHA_CTX;
|
||||
|
||||
void blk_SHA1_Init(blk_SHA_CTX *ctx);
|
||||
void blk_SHA1_Update(blk_SHA_CTX *ctx, const void *dataIn, unsigned long len);
|
||||
void blk_SHA1_Final(unsigned char hashout[20], blk_SHA_CTX *ctx);
|
||||
|
||||
|
|
@ -9,7 +9,7 @@ Log::Log(const char * fn)
|
|||
{
|
||||
FILE * fh = fopen(fn, "r");
|
||||
if(!fh) {
|
||||
fprintf(stderr, "Log: Could not open log file '%s' for reading!\n", fn);
|
||||
fprintf(stderr, "Log: Could not open log file '%s' for reading! Creating an empty log.\n", fn);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -22,22 +22,29 @@ Log::Log(const char * fn)
|
|||
fclose(fh);
|
||||
}
|
||||
|
||||
void Log::writeEntry(LogEntry ent)
|
||||
uint64_t Log::writeEntry(LogEntry ent)
|
||||
{
|
||||
FILE * fh = fopen(log_name.c_str(), "a");
|
||||
assert(fh);
|
||||
if(!fh) {
|
||||
fprintf(stderr, "Log: FATAL: Could not open log file '%s' for append. Aborting.\n", log_name.c_str());
|
||||
abort();
|
||||
}
|
||||
|
||||
flockfile(fh);
|
||||
|
||||
fseek(fh, 0, SEEK_END);
|
||||
ent.serial = ++serial;
|
||||
assert(1 == fwrite(&ent, sizeof(LogEntry), 1, fh));
|
||||
if(1 != fwrite(&ent, sizeof(LogEntry), 1, fh)) {
|
||||
fprintf(stderr, "Log: FATAL: Could not write entry to log file '%s'. Aborting.\n", log_name.c_str());
|
||||
abort();
|
||||
}
|
||||
fflush(fh);
|
||||
|
||||
funlockfile(fh);
|
||||
fclose(fh);
|
||||
|
||||
entries.push_back(ent);
|
||||
return ent.serial;
|
||||
}
|
||||
|
||||
std::list<LogEntry>::const_iterator Log::begin()
|
||||
|
|
|
|||
|
|
@ -1,11 +1,26 @@
|
|||
#ifndef _POS_LOG_H_
|
||||
#define _POS_LOG_H_
|
||||
#include "sha1.h"
|
||||
#include <list>
|
||||
#include <string>
|
||||
#include <stdint.h>
|
||||
|
||||
enum E_OBJ_TYPE { ET_TRANS, ET_HASH, ET_SALE, ET_REVERT };
|
||||
|
||||
struct __attribute__ ((packed)) UPC {
|
||||
uint64_t h, l;
|
||||
};
|
||||
|
||||
class UPCLess {
|
||||
public:
|
||||
bool operator()(const UPC & lhs, const UPC & rhs) const {
|
||||
if(lhs.h == rhs.h)
|
||||
return (lhs.l < rhs.l);
|
||||
else
|
||||
return (lhs.h < rhs.h);
|
||||
}
|
||||
};
|
||||
|
||||
struct __attribute__ ((aligned (64), packed)) LogEntry
|
||||
{
|
||||
uint64_t ts;
|
||||
|
|
@ -13,18 +28,18 @@ struct __attribute__ ((aligned (64), packed)) LogEntry
|
|||
E_OBJ_TYPE type;
|
||||
union {
|
||||
struct __attribute__ ((packed)) {
|
||||
char hash[16];
|
||||
char hash[20];
|
||||
int32_t delta;
|
||||
} Transaction;
|
||||
|
||||
struct __attribute__ ((packed)) {
|
||||
char hash[16];
|
||||
char hash[20];
|
||||
uint32_t uid;
|
||||
bool add;
|
||||
} HashChange;
|
||||
|
||||
struct __attribute__ ((packed)) {
|
||||
char hash[16];
|
||||
uint64_t upc[2];
|
||||
UPC upc;
|
||||
int32_t delta;
|
||||
} StockChange;
|
||||
|
||||
|
|
@ -37,7 +52,7 @@ struct __attribute__ ((aligned (64), packed)) LogEntry
|
|||
class Log {
|
||||
public:
|
||||
Log(const char * fn);
|
||||
void writeEntry(LogEntry ent);
|
||||
uint64_t writeEntry(LogEntry ent);
|
||||
std::list<LogEntry>::const_iterator begin();
|
||||
std::list<LogEntry>::const_iterator end();
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,48 @@
|
|||
#include "sha1.h"
|
||||
#include "linus_sha1.h"
|
||||
#include <cstring>
|
||||
|
||||
SHA1Hash::SHA1Hash() {}
|
||||
|
||||
SHA1Hash::SHA1Hash(const char * str) {
|
||||
blk_SHA_CTX ctx;
|
||||
blk_SHA1_Init(&ctx);
|
||||
blk_SHA1_Update(&ctx, (const unsigned char*)str, strlen(str));
|
||||
blk_SHA1_Final(data, &ctx);
|
||||
}
|
||||
|
||||
SHA1Hash::SHA1Hash(const std::string str) {
|
||||
SHA1Hash(str.c_str());
|
||||
}
|
||||
|
||||
SHA1Hash::SHA1Hash(const SHA1Hash & other) {
|
||||
memcpy(data, other.data, sizeof(unsigned char) * 20);
|
||||
}
|
||||
|
||||
void SHA1Hash::set(const unsigned char * from) {
|
||||
memcpy(data, from, sizeof(unsigned char) * 20);
|
||||
}
|
||||
|
||||
void SHA1Hash::get(unsigned char * to) const {
|
||||
memcpy(to, data, sizeof(unsigned char) * 20);
|
||||
}
|
||||
|
||||
bool SHA1Hash::operator==(const SHA1Hash & other) const {
|
||||
bool res = true;
|
||||
for(int i=0;i<20;++i)
|
||||
res &= (other.data[i] == data[i]);
|
||||
return res;
|
||||
}
|
||||
|
||||
bool SHA1Less::operator()(const SHA1Hash & lhs, const SHA1Hash & rhs) const {
|
||||
int i;
|
||||
for(i=0;i<20;++i) {
|
||||
if(lhs.data[i] < rhs.data[i])
|
||||
break;
|
||||
else if(lhs.data[i] > rhs.data[i])
|
||||
return false;
|
||||
}
|
||||
|
||||
return (i < 20);
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
#ifndef _POS_SHA1_H_
|
||||
#define _POS_SHA1_H_
|
||||
#include <cstdlib>
|
||||
#include <string>
|
||||
|
||||
struct __attribute__ ((packed)) SHA1Hash {
|
||||
SHA1Hash();
|
||||
SHA1Hash(const char * str);
|
||||
SHA1Hash(const std::string str);
|
||||
SHA1Hash(const SHA1Hash & other);
|
||||
bool operator==(const SHA1Hash & other) const;
|
||||
void set(const unsigned char * from);
|
||||
void get(unsigned char * to) const;
|
||||
|
||||
unsigned char data[20];
|
||||
};
|
||||
|
||||
class SHA1Less {
|
||||
public:
|
||||
bool operator()(const SHA1Hash & lhs, const SHA1Hash & rhs) const;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
#include "db.h"
|
||||
#include <cstdio>
|
||||
|
||||
int main() {
|
||||
PosDb db("db");
|
||||
printf("%lu\n", db.associateHash(SHA1Hash("dongs"), 1));
|
||||
printf("%lu\n", db.associateHash(SHA1Hash("cocks"), 1));
|
||||
printf("%lu\n", db.deassociateHash(SHA1Hash("dongs")));
|
||||
|
||||
printf("%d\n", db.getAccountBalance(SHA1Hash("cocks")));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue