From e07ed779d61604ad43437a75cbb66692af7bc767 Mon Sep 17 00:00:00 2001 From: Jack Andersen Date: Sun, 17 May 2015 23:29:23 -1000 Subject: [PATCH] additional database implementation; integrated blowfish --- hecl/extern/blowfish/BLOWFISH.C | 228 +++++++++++ hecl/extern/blowfish/BLOWFISH.DAT | Bin 0 -> 5006 bytes hecl/extern/blowfish/BLOWFISH.DAT.c | 505 ++++++++++++++++++++++++ hecl/extern/blowfish/BLOWFISH.H | 8 + hecl/extern/blowfish/cme.py | 16 + hecl/include/HECLDatabase.hpp | 59 ++- hecl/lib/database/CLooseDatabase.hpp | 18 +- hecl/lib/database/CMemoryDatabase.hpp | 8 +- hecl/lib/database/CPackedDatabase.hpp | 8 +- hecl/lib/database/CSQLite.hpp | 92 ++++- hecl/lib/database/database.pri | 6 +- hecl/lib/database/sqlite_hecl_mem_vfs.c | 361 +++++++++++++++++ hecl/lib/database/sqlite_hecl_vfs.h | 17 + 13 files changed, 1291 insertions(+), 35 deletions(-) create mode 100644 hecl/extern/blowfish/BLOWFISH.C create mode 100644 hecl/extern/blowfish/BLOWFISH.DAT create mode 100644 hecl/extern/blowfish/BLOWFISH.DAT.c create mode 100644 hecl/extern/blowfish/BLOWFISH.H create mode 100644 hecl/extern/blowfish/cme.py create mode 100644 hecl/lib/database/sqlite_hecl_mem_vfs.c create mode 100644 hecl/lib/database/sqlite_hecl_vfs.h diff --git a/hecl/extern/blowfish/BLOWFISH.C b/hecl/extern/blowfish/BLOWFISH.C new file mode 100644 index 000000000..b1f7a286d --- /dev/null +++ b/hecl/extern/blowfish/BLOWFISH.C @@ -0,0 +1,228 @@ +#ifdef little_endian /* Eg: Intel */ + #include + #include + #include +#endif + +#include +#include +#include +#include + +#ifdef little_endian /* Eg: Intel */ + #include +#endif + +#include + +#ifdef little_endian /* Eg: Intel */ + #include + #include +#endif + +#ifdef big_endian + #include +#endif + +#include "Blowfish.h" + +#define N 16 +#define noErr 0 +#define DATAERROR -1 +#define KEYBYTES 8 +#define subkeyfilename "Blowfish.dat" + +unsigned long P[N + 2]; +unsigned long S[4][256]; +FILE* SubkeyFile; + +short opensubkeyfile(void) /* read only */ +{ + short error; + + error = noErr; + + if((SubkeyFile = fopen(subkeyfilename,"rb")) == NULL) { + error = DATAERROR; + } + + return error; +} + +unsigned long F(unsigned long x) +{ + unsigned short a; + unsigned short b; + unsigned short c; + unsigned short d; + unsigned long y; + + d = x & 0x00FF; + x >>= 8; + c = x & 0x00FF; + x >>= 8; + b = x & 0x00FF; + x >>= 8; + a = x & 0x00FF; + //y = ((S[0][a] + S[1][b]) ^ S[2][c]) + S[3][d]; + y = S[0][a] + S[1][b]; + y = y ^ S[2][c]; + y = y + S[3][d]; + + return y; +} + +void Blowfish_encipher(unsigned long *xl, unsigned long *xr) +{ + unsigned long Xl; + unsigned long Xr; + unsigned long temp; + short i; + + Xl = *xl; + Xr = *xr; + + for (i = 0; i < N; ++i) { + Xl = Xl ^ P[i]; + Xr = F(Xl) ^ Xr; + + temp = Xl; + Xl = Xr; + Xr = temp; + } + + temp = Xl; + Xl = Xr; + Xr = temp; + + Xr = Xr ^ P[N]; + Xl = Xl ^ P[N + 1]; + + *xl = Xl; + *xr = Xr; +} + +void Blowfish_decipher(unsigned long *xl, unsigned long *xr) +{ + unsigned long Xl; + unsigned long Xr; + unsigned long temp; + short i; + + Xl = *xl; + Xr = *xr; + + for (i = N + 1; i > 1; --i) { + Xl = Xl ^ P[i]; + Xr = F(Xl) ^ Xr; + + /* Exchange Xl and Xr */ + temp = Xl; + Xl = Xr; + Xr = temp; + } + + /* Exchange Xl and Xr */ + temp = Xl; + Xl = Xr; + Xr = temp; + + Xr = Xr ^ P[1]; + Xl = Xl ^ P[0]; + + *xl = Xl; + *xr = Xr; +} + +short InitializeBlowfish(char key[], short keybytes) +{ + short i; + short j; + short k; + short error; + short numread; + unsigned long data; + unsigned long datal; + unsigned long datar; + + /* First, open the file containing the array initialization data */ + error = opensubkeyfile(); + if (error == noErr) { + for (i = 0; i < N + 2; ++i) { + numread = fread(&data, 4, 1, SubkeyFile); + #ifdef little_endian /* Eg: Intel We want to process things in byte */ + /* order, not as rearranged in a longword */ + data = ((data & 0xFF000000) >> 24) | + ((data & 0x00FF0000) >> 8) | + ((data & 0x0000FF00) << 8) | + ((data & 0x000000FF) << 24); + #endif + + if (numread != 1) { + return DATAERROR; + } else { + P[i] = data; + } + } + + for (i = 0; i < 4; ++i) { + for (j = 0; j < 256; ++j) { + numread = fread(&data, 4, 1, SubkeyFile); + + #ifdef little_endian /* Eg: Intel We want to process things in byte */ + /* order, not as rearranged in a longword */ + data = ((data & 0xFF000000) >> 24) | + ((data & 0x00FF0000) >> 8) | + ((data & 0x0000FF00) << 8) | + ((data & 0x000000FF) << 24); + #endif + + if (numread != 1) { + return DATAERROR; + } else { + S[i][j] = data; + } + } + } + + fclose(SubkeyFile); + + j = 0; + for (i = 0; i < N + 2; ++i) { + data = 0x00000000; + for (k = 0; k < 4; ++k) { + data = (data << 8) | key[j]; + j = j + 1; + if (j >= keybytes) { + j = 0; + } + } + P[i] = P[i] ^ data; + } + + datal = 0x00000000; + datar = 0x00000000; + + for (i = 0; i < N + 2; i += 2) { + Blowfish_encipher(&datal, &datar); + + P[i] = datal; + P[i + 1] = datar; + } + + for (i = 0; i < 4; ++i) { + for (j = 0; j < 256; j += 2) { + + Blowfish_encipher(&datal, &datar); + + S[i][j] = datal; + S[i][j + 1] = datar; + } + } + } else { + printf("Unable to open subkey initialization file : %d\n", error); + } + + return error; +} + diff --git a/hecl/extern/blowfish/BLOWFISH.DAT b/hecl/extern/blowfish/BLOWFISH.DAT new file mode 100644 index 0000000000000000000000000000000000000000..de50afa7c6a684457ee6b161623dbfd70dda5b0b GIT binary patch literal 5006 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 +size_t BLOWFISH_DAT_SZ = 5006; +char BLOWFISH_DAT[] = { + 0x24,0x3F,0x6A,0x88,0x85,0xA3,0x08,0xD3,0x13,0x19, + 0x8A,0x2E,0x03,0x70,0x73,0x44,0xA4,0x09,0x38,0x22, + 0x29,0x9F,0x31,0xD0,0x08,0x2E,0xFA,0x98,0xEC,0x4E, + 0x6C,0x89,0x45,0x28,0x21,0xE6,0x38,0xD0,0x13,0x77, + 0xBE,0x54,0x66,0xCF,0x34,0xE9,0x0C,0x6C,0xC0,0xAC, + 0x29,0xB7,0xC9,0x7C,0x50,0xDD,0x3F,0x84,0xD5,0xB5, + 0xB5,0x47,0x09,0x17,0x92,0x16,0xD5,0xD9,0x89,0x79, + 0xFB,0x1B,0xD1,0x31,0x0B,0xA6,0x98,0xDF,0xB5,0xAC, + 0x2F,0xFD,0x72,0xDB,0xD0,0x1A,0xDF,0xB7,0xB8,0xE1, + 0xAF,0xED,0x6A,0x26,0x7E,0x96,0xBA,0x7C,0x90,0x45, + 0xF1,0x2C,0x7F,0x99,0x24,0xA1,0x99,0x47,0xB3,0x91, + 0x6C,0xF7,0x08,0x01,0xF2,0xE2,0x85,0x8E,0xFC,0x16, + 0x63,0x69,0x20,0xD8,0x71,0x57,0x4E,0x69,0xA4,0x58, + 0xFE,0xA3,0xF4,0x93,0x3D,0x7E,0x0D,0x95,0x74,0x8F, + 0x72,0x8E,0xB6,0x58,0x71,0x8B,0xCD,0x58,0x82,0x15, + 0x4A,0xEE,0x7B,0x54,0xA4,0x1D,0xC2,0x5A,0x59,0xB5, + 0x9C,0x30,0xD5,0x39,0x2A,0xF2,0x60,0x13,0xC5,0xD1, + 0xB0,0x23,0x28,0x60,0x85,0xF0,0xCA,0x41,0x79,0x18, + 0xB8,0xDB,0x38,0xEF,0x8E,0x79,0xDC,0xB0,0x60,0x3A, + 0x18,0x0E,0x6C,0x9E,0x0E,0x8B,0xB0,0x1E,0x8A,0x3E, + 0xD7,0x15,0x77,0xC1,0xBD,0x31,0x4B,0x27,0x78,0xAF, + 0x2F,0xDA,0x55,0x60,0x5C,0x60,0xE6,0x55,0x25,0xF3, + 0xAA,0x55,0xAB,0x94,0x57,0x48,0x98,0x62,0x63,0xE8, + 0x14,0x40,0x55,0xCA,0x39,0x6A,0x2A,0xAB,0x10,0xB6, + 0xB4,0xCC,0x5C,0x34,0x11,0x41,0xE8,0xCE,0xA1,0x54, + 0x86,0xAF,0x7C,0x72,0xE9,0x93,0xB3,0xEE,0x14,0x11, + 0x63,0x6F,0xBC,0x2A,0x2B,0xA9,0xC5,0x5D,0x74,0x18, + 0x31,0xF6,0xCE,0x5C,0x3E,0x16,0x9B,0x87,0x93,0x1E, + 0xAF,0xD6,0xBA,0x33,0x6C,0x24,0xCF,0x5C,0x7A,0x32, + 0x53,0x81,0x28,0x95,0x86,0x77,0x3B,0x8F,0x48,0x98, + 0x6B,0x4B,0xB9,0xAF,0xC4,0xBF,0xE8,0x1B,0x66,0x28, + 0x21,0x93,0x61,0xD8,0x09,0xCC,0xFB,0x21,0xA9,0x91, + 0x48,0x7C,0xAC,0x60,0x5D,0xEC,0x80,0x32,0xEF,0x84, + 0x5D,0x5D,0xE9,0x85,0x75,0xB1,0xDC,0x26,0x23,0x02, + 0xEB,0x65,0x1B,0x88,0x23,0x89,0x3E,0x81,0xD3,0x96, + 0xAC,0xC5,0x0F,0x6D,0x6F,0xF3,0x83,0xF4,0x42,0x39, + 0x2E,0x0B,0x44,0x82,0xA4,0x84,0x20,0x04,0x69,0xC8, + 0xF0,0x4A,0x9E,0x1F,0x9B,0x5E,0x21,0xC6,0x68,0x42, + 0xF6,0xE9,0x6C,0x9A,0x67,0x0C,0x9C,0x61,0xAB,0xD3, + 0x88,0xF0,0x6A,0x51,0xA0,0xD2,0xD8,0x54,0x2F,0x68, + 0x96,0x0F,0xA7,0x28,0xAB,0x51,0x33,0xA3,0x6E,0xEF, + 0x0B,0x6C,0x13,0x7A,0x3B,0xE4,0xBA,0x3B,0xF0,0x50, + 0x7E,0xFB,0x2A,0x98,0xA1,0xF1,0x65,0x1D,0x39,0xAF, + 0x01,0x76,0x66,0xCA,0x59,0x3E,0x82,0x43,0x0E,0x88, + 0x8C,0xEE,0x86,0x19,0x45,0x6F,0x9F,0xB4,0x7D,0x84, + 0xA5,0xC3,0x3B,0x8B,0x5E,0xBE,0xE0,0x6F,0x75,0xD8, + 0x85,0xC1,0x20,0x73,0x40,0x1A,0x44,0x9F,0x56,0xC1, + 0x6A,0xA6,0x4E,0xD3,0xAA,0x62,0x36,0x3F,0x77,0x06, + 0x1B,0xFE,0xDF,0x72,0x42,0x9B,0x02,0x3D,0x37,0xD0, + 0xD7,0x24,0xD0,0x0A,0x12,0x48,0xDB,0x0F,0xEA,0xD3, + 0x49,0xF1,0xC0,0x9B,0x07,0x53,0x72,0xC9,0x80,0x99, + 0x1B,0x7B,0x25,0xD4,0x79,0xD8,0xF6,0xE8,0xDE,0xF7, + 0xE3,0xFE,0x50,0x1A,0xB6,0x79,0x4C,0x3B,0x97,0x6C, + 0xE0,0xBD,0x04,0xC0,0x06,0xBA,0xC1,0xA9,0x4F,0xB6, + 0x40,0x9F,0x60,0xC4,0x5E,0x5C,0x9E,0xC2,0x19,0x6A, + 0x24,0x63,0x68,0xFB,0x6F,0xAF,0x3E,0x6C,0x53,0xB5, + 0x13,0x39,0xB2,0xEB,0x3B,0x52,0xEC,0x6F,0x6D,0xFC, + 0x51,0x1F,0x9B,0x30,0x95,0x2C,0xCC,0x81,0x45,0x44, + 0xAF,0x5E,0xBD,0x09,0xBE,0xE3,0xD0,0x04,0xDE,0x33, + 0x4A,0xFD,0x66,0x0F,0x28,0x07,0x19,0x2E,0x4B,0xB3, + 0xC0,0xCB,0xA8,0x57,0x45,0xC8,0x74,0x0F,0xD2,0x0B, + 0x5F,0x39,0xB9,0xD3,0xFB,0xDB,0x55,0x79,0xC0,0xBD, + 0x1A,0x60,0x32,0x0A,0xD6,0xA1,0x00,0xC6,0x40,0x2C, + 0x72,0x79,0x67,0x9F,0x25,0xFE,0xFB,0x1F,0xA3,0xCC, + 0x8E,0xA5,0xE9,0xF8,0xDB,0x32,0x22,0xF8,0x3C,0x75, + 0x16,0xDF,0xFD,0x61,0x6B,0x15,0x2F,0x50,0x1E,0xC8, + 0xAD,0x05,0x52,0xAB,0x32,0x3D,0xB5,0xFA,0xFD,0x23, + 0x87,0x60,0x53,0x31,0x7B,0x48,0x3E,0x00,0xDF,0x82, + 0x9E,0x5C,0x57,0xBB,0xCA,0x6F,0x8C,0xA0,0x1A,0x87, + 0x56,0x2E,0xDF,0x17,0x69,0xDB,0xD5,0x42,0xA8,0xF6, + 0x28,0x7E,0xFF,0xC3,0xAC,0x67,0x32,0xC6,0x8C,0x4F, + 0x55,0x73,0x69,0x5B,0x27,0xB0,0xBB,0xCA,0x58,0xC8, + 0xE1,0xFF,0xA3,0x5D,0xB8,0xF0,0x11,0xA0,0x10,0xFA, + 0x3D,0x98,0xFD,0x21,0x83,0xB8,0x4A,0xFC,0xB5,0x6C, + 0x2D,0xD1,0xD3,0x5B,0x9A,0x53,0xE4,0x79,0xB6,0xF8, + 0x45,0x65,0xD2,0x8E,0x49,0xBC,0x4B,0xFB,0x97,0x90, + 0xE1,0xDD,0xF2,0xDA,0xA4,0xCB,0x7E,0x33,0x62,0xFB, + 0x13,0x41,0xCE,0xE4,0xC6,0xE8,0xEF,0x20,0xCA,0xDA, + 0x36,0x77,0x4C,0x01,0xD0,0x7E,0x9E,0xFE,0x2B,0xF1, + 0x1F,0xB4,0x95,0xDB,0xDA,0x4D,0xAE,0x90,0x91,0x98, + 0xEA,0xAD,0x8E,0x71,0x6B,0x93,0xD5,0xA0,0xD0,0x8E, + 0xD1,0xD0,0xAF,0xC7,0x25,0xE0,0x8E,0x3C,0x5B,0x2F, + 0x8E,0x75,0x94,0xB7,0x8F,0xF6,0xE2,0xFB,0xF2,0x12, + 0x2B,0x64,0x88,0x88,0xB8,0x12,0x90,0x0D,0xF0,0x1C, + 0x4F,0xAD,0x5E,0xA0,0x68,0x8F,0xC3,0x1C,0xD1,0xCF, + 0xF1,0x91,0xB3,0xA8,0xC1,0xAD,0x2F,0x2F,0x22,0x18, + 0xBE,0x0E,0x17,0x77,0xEA,0x75,0x2D,0xFE,0x8B,0x02, + 0x1F,0xA1,0xE5,0xA0,0xCC,0x0F,0xB5,0x6F,0x74,0xE8, + 0x18,0xAC,0xF3,0xD6,0xCE,0x89,0xE2,0x99,0xB4,0xA8, + 0x4F,0xE0,0xFD,0x13,0xE0,0xB7,0x7C,0xC4,0x3B,0x81, + 0xD2,0xAD,0xA8,0xD9,0x16,0x5F,0xA2,0x66,0x80,0x95, + 0x77,0x05,0x93,0xCC,0x73,0x14,0x21,0x1A,0x14,0x77, + 0xE6,0xAD,0x20,0x65,0x77,0xB5,0xFA,0x86,0xC7,0x54, + 0x42,0xF5,0xFB,0x9D,0x35,0xCF,0xEB,0xCD,0xAF,0x0C, + 0x7B,0x3E,0x89,0xA0,0xD6,0x41,0x1B,0xD3,0xAE,0x1E, + 0x7E,0x49,0x00,0x25,0x0E,0x2D,0x20,0x71,0xB3,0x5E, + 0x22,0x68,0x00,0xBB,0x57,0xB8,0xE0,0xAF,0x24,0x64, + 0x36,0x9B,0xF0,0x09,0xB9,0x1E,0x55,0x63,0x91,0x1D, + 0x59,0xDF,0xA6,0xAA,0x78,0xC1,0x43,0x89,0xD9,0x5A, + 0x53,0x7F,0x20,0x7D,0x5B,0xA2,0x02,0xE5,0xB9,0xC5, + 0x83,0x26,0x03,0x76,0x62,0x95,0xCF,0xA9,0x11,0xC8, + 0x19,0x68,0x4E,0x73,0x4A,0x41,0xB3,0x47,0x2D,0xCA, + 0x7B,0x14,0xA9,0x4A,0x1B,0x51,0x00,0x52,0x9A,0x53, + 0x29,0x15,0xD6,0x0F,0x57,0x3F,0xBC,0x9B,0xC6,0xE4, + 0x2B,0x60,0xA4,0x76,0x81,0xE6,0x74,0x00,0x08,0xBA, + 0x6F,0xB5,0x57,0x1B,0xE9,0x1F,0xF2,0x96,0xEC,0x6B, + 0x2A,0x0D,0xD9,0x15,0xB6,0x63,0x65,0x21,0xE7,0xB9, + 0xF9,0xB6,0xFF,0x34,0x05,0x2E,0xC5,0x85,0x56,0x64, + 0x53,0xB0,0x2D,0x5D,0xA9,0x9F,0x8F,0xA1,0x08,0xBA, + 0x47,0x99,0x6E,0x85,0x07,0x6A,0x4B,0x7A,0x70,0xE9, + 0xB5,0xB3,0x29,0x44,0xDB,0x75,0x09,0x2E,0xC4,0x19, + 0x26,0x23,0xAD,0x6E,0xA6,0xB0,0x49,0xA7,0xDF,0x7D, + 0x9C,0xEE,0x60,0xB8,0x8F,0xED,0xB2,0x66,0xEC,0xAA, + 0x8C,0x71,0x69,0x9A,0x17,0xFF,0x56,0x64,0x52,0x6C, + 0xC2,0xB1,0x9E,0xE1,0x19,0x36,0x02,0xA5,0x75,0x09, + 0x4C,0x29,0xA0,0x59,0x13,0x40,0xE4,0x18,0x3A,0x3E, + 0x3F,0x54,0x98,0x9A,0x5B,0x42,0x9D,0x65,0x6B,0x8F, + 0xE4,0xD6,0x99,0xF7,0x3F,0xD6,0xA1,0xD2,0x9C,0x07, + 0xEF,0xE8,0x30,0xF5,0x4D,0x2D,0x38,0xE6,0xF0,0x25, + 0x5D,0xC1,0x4C,0xDD,0x20,0x86,0x84,0x70,0xEB,0x26, + 0x63,0x82,0xE9,0xC6,0x02,0x1E,0xCC,0x5E,0x09,0x68, + 0x6B,0x3F,0x3E,0xBA,0xEF,0xC9,0x3C,0x97,0x18,0x14, + 0x6B,0x6A,0x70,0xA1,0x68,0x7F,0x35,0x84,0x52,0xA0, + 0xE2,0x86,0xB7,0x9C,0x53,0x05,0xAA,0x50,0x07,0x37, + 0x3E,0x07,0x84,0x1C,0x7F,0xDE,0xAE,0x5C,0x8E,0x7D, + 0x44,0xEC,0x57,0x16,0xF2,0xB8,0xB0,0x3A,0xDA,0x37, + 0xF0,0x50,0x0C,0x0D,0xF0,0x1C,0x1F,0x04,0x02,0x00, + 0xB3,0xFF,0xAE,0x0C,0xF5,0x1A,0x3C,0xB5,0x74,0xB2, + 0x25,0x83,0x7A,0x58,0xDC,0x09,0x21,0xBD,0xD1,0x91, + 0x13,0xF9,0x7C,0xA9,0x2F,0xF6,0x94,0x32,0x47,0x73, + 0x22,0xF5,0x47,0x01,0x3A,0xE5,0xE5,0x81,0x37,0xC2, + 0xDA,0xDC,0xC8,0xB5,0x76,0x34,0x9A,0xF3,0xDD,0xA7, + 0xA9,0x44,0x61,0x46,0x0F,0xD0,0x03,0x0E,0xEC,0xC8, + 0xC7,0x3E,0xA4,0x75,0x1E,0x41,0xE2,0x38,0xCD,0x99, + 0x3B,0xEA,0x0E,0x2F,0x32,0x80,0xBB,0xA1,0x18,0x3E, + 0xB3,0x31,0x4E,0x54,0x8B,0x38,0x4F,0x6D,0xB9,0x08, + 0x6F,0x42,0x0D,0x03,0xF6,0x0A,0x04,0xBF,0x2C,0xB8, + 0x12,0x90,0x24,0x97,0x7C,0x79,0x56,0x79,0xB0,0x72, + 0xBC,0xAF,0x89,0xAF,0xDE,0x9A,0x77,0x1F,0xD9,0x93, + 0x08,0x10,0xB3,0x8B,0xAE,0x12,0xDC,0xCF,0x3F,0x2E, + 0x55,0x12,0x72,0x1F,0x2E,0x6B,0x71,0x24,0x50,0x1A, + 0xDD,0xE6,0x9F,0x84,0xCD,0x87,0x7A,0x58,0x47,0x18, + 0x74,0x08,0xDA,0x17,0xBC,0x9F,0x9A,0xBC,0xE9,0x4B, + 0x7D,0x8C,0xEC,0x7A,0xEC,0x3A,0xDB,0x85,0x1D,0xFA, + 0x63,0x09,0x43,0x66,0xC4,0x64,0xC3,0xD2,0xEF,0x1C, + 0x18,0x47,0x32,0x15,0xD9,0x08,0xDD,0x43,0x3B,0x37, + 0x24,0xC2,0xBA,0x16,0x12,0xA1,0x4D,0x43,0x2A,0x65, + 0xC4,0x51,0x50,0x94,0x00,0x02,0x13,0x3A,0xE4,0xDD, + 0x71,0xDF,0xF8,0x9E,0x10,0x31,0x4E,0x55,0x81,0xAC, + 0x77,0xD6,0x5F,0x11,0x19,0x9B,0x04,0x35,0x56,0xF1, + 0xD7,0xA3,0xC7,0x6B,0x3C,0x11,0x18,0x3B,0x59,0x24, + 0xA5,0x09,0xF2,0x8F,0xE6,0xED,0x97,0xF1,0xFB,0xFA, + 0x9E,0xBA,0xBF,0x2C,0x1E,0x15,0x3C,0x6E,0x86,0xE3, + 0x45,0x70,0xEA,0xE9,0x6F,0xB1,0x86,0x0E,0x5E,0x0A, + 0x5A,0x3E,0x2A,0xB3,0x77,0x1F,0xE7,0x1C,0x4E,0x3D, + 0x06,0xFA,0x29,0x65,0xDC,0xB9,0x99,0xE7,0x1D,0x0F, + 0x80,0x3E,0x89,0xD6,0x52,0x66,0xC8,0x25,0x2E,0x4C, + 0xC9,0x78,0x9C,0x10,0xB3,0x6A,0xC6,0x15,0x0E,0xBA, + 0x94,0xE2,0xEA,0x78,0xA5,0xFC,0x3C,0x53,0x1E,0x0A, + 0x2D,0xF4,0xF2,0xF7,0x4E,0xA7,0x36,0x1D,0x2B,0x3D, + 0x19,0x39,0x26,0x0F,0x19,0xC2,0x79,0x60,0x52,0x23, + 0xA7,0x08,0xF7,0x13,0x12,0xB6,0xEB,0xAD,0xFE,0x6E, + 0xEA,0xC3,0x1F,0x66,0xE3,0xBC,0x45,0x95,0xA6,0x7B, + 0xC8,0x83,0xB1,0x7F,0x37,0xD1,0x01,0x8C,0xFF,0x28, + 0xC3,0x32,0xDD,0xEF,0xBE,0x6C,0x5A,0xA5,0x65,0x58, + 0x21,0x85,0x68,0xAB,0x98,0x02,0xEE,0xCE,0xA5,0x0F, + 0xDB,0x2F,0x95,0x3B,0x2A,0xEF,0x7D,0xAD,0x5B,0x6E, + 0x2F,0x84,0x15,0x21,0xB6,0x28,0x29,0x07,0x61,0x70, + 0xEC,0xDD,0x47,0x75,0x61,0x9F,0x15,0x10,0x13,0xCC, + 0xA8,0x30,0xEB,0x61,0xBD,0x96,0x03,0x34,0xFE,0x1E, + 0xAA,0x03,0x63,0xCF,0xB5,0x73,0x5C,0x90,0x4C,0x70, + 0xA2,0x39,0xD5,0x9E,0x9E,0x0B,0xCB,0xAA,0xDE,0x14, + 0xEE,0xCC,0x86,0xBC,0x60,0x62,0x2C,0xA7,0x9C,0xAB, + 0x5C,0xAB,0xB2,0xF3,0x84,0x6E,0x64,0x8B,0x1E,0xAF, + 0x19,0xBD,0xF0,0xCA,0xA0,0x23,0x69,0xB9,0x65,0x5A, + 0xBB,0x50,0x40,0x68,0x5A,0x32,0x3C,0x2A,0xB4,0xB3, + 0x31,0x9E,0xE9,0xD5,0xC0,0x21,0xB8,0xF7,0x9B,0x54, + 0x0B,0x19,0x87,0x5F,0xA0,0x99,0x95,0xF7,0x99,0x7E, + 0x62,0x3D,0x7D,0xA8,0xF8,0x37,0x88,0x9A,0x97,0xE3, + 0x2D,0x77,0x11,0xED,0x93,0x5F,0x16,0x68,0x12,0x81, + 0x0E,0x35,0x88,0x29,0xC7,0xE6,0x1F,0xD6,0x96,0xDE, + 0xDF,0xA1,0x78,0x58,0xBA,0x99,0x57,0xF5,0x84,0xA5, + 0x1B,0x22,0x72,0x63,0x9B,0x83,0xC3,0xFF,0x1A,0xC2, + 0x46,0x96,0xCD,0xB3,0x0A,0xEB,0x53,0x2E,0x30,0x54, + 0x8F,0xD9,0x48,0xE4,0x6D,0xBC,0x31,0x28,0x58,0xEB, + 0xF2,0xEF,0x34,0xC6,0xFF,0xEA,0xFE,0x28,0xED,0x61, + 0xEE,0x7C,0x3C,0x73,0x5D,0x4A,0x14,0xD9,0xE8,0x64, + 0xB7,0xE3,0x42,0x10,0x5D,0x14,0x20,0x3E,0x13,0xE0, + 0x45,0xEE,0xE2,0xB6,0xA3,0xAA,0xAB,0xEA,0xDB,0x6C, + 0x4F,0x15,0xFA,0xCB,0x4F,0xD0,0xC7,0x42,0xF4,0x42, + 0xEF,0x6A,0xBB,0xB5,0x65,0x4F,0x3B,0x1D,0x41,0xCD, + 0x21,0x05,0xD8,0x1E,0x79,0x9E,0x86,0x85,0x4D,0xC7, + 0xE4,0x4B,0x47,0x6A,0x3D,0x81,0x62,0x50,0xCF,0x62, + 0xA1,0xF2,0x5B,0x8D,0x26,0x46,0xFC,0x88,0x83,0xA0, + 0xC1,0xC7,0xB6,0xA3,0x7F,0x15,0x24,0xC3,0x69,0xCB, + 0x74,0x92,0x47,0x84,0x8A,0x0B,0x56,0x92,0xB2,0x85, + 0x09,0x5B,0xBF,0x00,0xAD,0x19,0x48,0x9D,0x14,0x62, + 0xB1,0x74,0x23,0x82,0x0E,0x00,0x58,0x42,0x8D,0x2A, + 0x0C,0x55,0xF5,0xEA,0x1D,0xAD,0xF4,0x3E,0x23,0x3F, + 0x70,0x61,0x33,0x72,0xF0,0x92,0x8D,0x93,0x7E,0x41, + 0xD6,0x5F,0xEC,0xF1,0x6C,0x22,0x3B,0xDB,0x7C,0xDE, + 0x37,0x59,0xCB,0xEE,0x74,0x60,0x40,0x85,0xF2,0xA7, + 0xCE,0x77,0x32,0x6E,0xA6,0x07,0x80,0x84,0x19,0xF8, + 0x50,0x9E,0xE8,0xEF,0xD8,0x55,0x61,0xD9,0x97,0x35, + 0xA9,0x69,0xA7,0xAA,0xC5,0x0C,0x06,0xC2,0x5A,0x04, + 0xAB,0xFC,0x80,0x0B,0xCA,0xDC,0x9E,0x44,0x7A,0x2E, + 0xC3,0x45,0x34,0x84,0xFD,0xD5,0x67,0x05,0x0E,0x1E, + 0x9E,0xC9,0xDB,0x73,0xDB,0xD3,0x10,0x55,0x88,0xCD, + 0x67,0x5F,0xDA,0x79,0xE3,0x67,0x43,0x40,0xC5,0xC4, + 0x34,0x65,0x71,0x3E,0x38,0xD8,0x3D,0x28,0xF8,0x9E, + 0xF1,0x6D,0xFF,0x20,0x15,0x3E,0x21,0xE7,0x8F,0xB0, + 0x3D,0x4A,0xE6,0xE3,0x9F,0x2B,0xDB,0x83,0xAD,0xF7, + 0xE9,0x3D,0x5A,0x68,0x94,0x81,0x40,0xF7,0xF6,0x4C, + 0x26,0x1C,0x94,0x69,0x29,0x34,0x41,0x15,0x20,0xF7, + 0x76,0x02,0xD4,0xF7,0xBC,0xF4,0x6B,0x2E,0xD4,0xA2, + 0x00,0x68,0xD4,0x08,0x24,0x71,0x33,0x20,0xF4,0x6A, + 0x43,0xB7,0xD4,0xB7,0x50,0x00,0x61,0xAF,0x1E,0x39, + 0xF6,0x2E,0x97,0x24,0x45,0x46,0x14,0x21,0x4F,0x74, + 0xBF,0x8B,0x88,0x40,0x4D,0x95,0xFC,0x1D,0x96,0xB5, + 0x91,0xAF,0x70,0xF4,0xDD,0xD3,0x66,0xA0,0x2F,0x45, + 0xBF,0xBC,0x09,0xEC,0x03,0xBD,0x97,0x85,0x7F,0xAC, + 0x6D,0xD0,0x31,0xCB,0x85,0x04,0x96,0xEB,0x27,0xB3, + 0x55,0xFD,0x39,0x41,0xDA,0x25,0x47,0xE6,0xAB,0xCA, + 0x0A,0x9A,0x28,0x50,0x78,0x25,0x53,0x04,0x29,0xF4, + 0x0A,0x2C,0x86,0xDA,0xE9,0xB6,0x6D,0xFB,0x68,0xDC, + 0x14,0x62,0xD7,0x48,0x69,0x00,0x68,0x0E,0xC0,0xA4, + 0x27,0xA1,0x8D,0xEE,0x4F,0x3F,0xFE,0xA2,0xE8,0x87, + 0xAD,0x8C,0xB5,0x8C,0xE0,0x06,0x7A,0xF4,0xD6,0xB6, + 0xAA,0xCE,0x1E,0x7C,0xD3,0x37,0x5F,0xEC,0xCE,0x78, + 0xA3,0x99,0x40,0x6B,0x2A,0x42,0x20,0xFE,0x9E,0x35, + 0xD9,0xF3,0x85,0xB9,0xEE,0x39,0xD7,0xAB,0x3B,0x12, + 0x4E,0x8B,0x1D,0xC9,0xFA,0xF7,0x4B,0x6D,0x18,0x56, + 0x26,0xA3,0x66,0x31,0xEA,0xE3,0x97,0xB2,0x3A,0x6E, + 0xFA,0x74,0xDD,0x5B,0x43,0x32,0x68,0x41,0xE7,0xF7, + 0xCA,0x78,0x20,0xFB,0xFB,0x0A,0xF5,0x4E,0xD8,0xFE, + 0xB3,0x97,0x45,0x40,0x56,0xAC,0xBA,0x48,0x95,0x27, + 0x55,0x53,0x3A,0x3A,0x20,0x83,0x8D,0x87,0xFE,0x6B, + 0xA9,0xB7,0xD0,0x96,0x95,0x4B,0x55,0xA8,0x67,0xBC, + 0xA1,0x15,0x9A,0x58,0xCC,0xA9,0x29,0x63,0x99,0xE1, + 0xDB,0x33,0xA6,0x2A,0x4A,0x56,0x3F,0x31,0x25,0xF9, + 0x5E,0xF4,0x7E,0x1C,0x90,0x29,0x31,0x7C,0xFD,0xF8, + 0xE8,0x02,0x04,0x27,0x2F,0x70,0x80,0xBB,0x15,0x5C, + 0x05,0x28,0x2C,0xE3,0x95,0xC1,0x15,0x48,0xE4,0xC6, + 0x6D,0x22,0x48,0xC1,0x13,0x3F,0xC7,0x0F,0x86,0xDC, + 0x07,0xF9,0xC9,0xEE,0x41,0x04,0x1F,0x0F,0x40,0x47, + 0x79,0xA4,0x5D,0x88,0x6E,0x17,0x32,0x5F,0x51,0xEB, + 0xD5,0x9B,0xC0,0xD1,0xF2,0xBC,0xC1,0x8F,0x41,0x11, + 0x35,0x64,0x25,0x7B,0x78,0x34,0x60,0x2A,0x9C,0x60, + 0xDF,0xF8,0xE8,0xA3,0x1F,0x63,0x6C,0x1B,0x0E,0x12, + 0xB4,0xC2,0x02,0xE1,0x32,0x9E,0xAF,0x66,0x4F,0xD1, + 0xCA,0xD1,0x81,0x15,0x6B,0x23,0x95,0xE0,0x33,0x3E, + 0x92,0xE1,0x3B,0x24,0x0B,0x62,0xEE,0xBE,0xB9,0x22, + 0x85,0xB2,0xA2,0x0E,0xE6,0xBA,0x0D,0x99,0xDE,0x72, + 0x0C,0x8C,0x2D,0xA2,0xF7,0x28,0xD0,0x12,0x78,0x45, + 0x95,0xB7,0x94,0xFD,0x64,0x7D,0x08,0x62,0xE7,0xCC, + 0xF5,0xF0,0x54,0x49,0xA3,0x6F,0x87,0x7D,0x48,0xFA, + 0xC3,0x9D,0xFD,0x27,0xF3,0x3E,0x8D,0x1E,0x0A,0x47, + 0x63,0x41,0x99,0x2E,0xFF,0x74,0x3A,0x6F,0x6E,0xAB, + 0xF4,0xF8,0xFD,0x37,0xA8,0x12,0xDC,0x60,0xA1,0xEB, + 0xDD,0xF8,0x99,0x1B,0xE1,0x4C,0xDB,0x6E,0x6B,0x0D, + 0xC6,0x7B,0x55,0x10,0x6D,0x67,0x2C,0x37,0x27,0x65, + 0xD4,0x3B,0xDC,0xD0,0xE8,0x04,0xF1,0x29,0x0D,0xC7, + 0xCC,0x00,0xFF,0xA3,0xB5,0x39,0x0F,0x92,0x69,0x0F, + 0xED,0x0B,0x66,0x7B,0x9F,0xFB,0xCE,0xDB,0x7D,0x9C, + 0xA0,0x91,0xCF,0x0B,0xD9,0x15,0x5E,0xA3,0xBB,0x13, + 0x2F,0x88,0x51,0x5B,0xAD,0x24,0x7B,0x94,0x79,0xBF, + 0x76,0x3B,0xD6,0xEB,0x37,0x39,0x2E,0xB3,0xCC,0x11, + 0x59,0x79,0x80,0x26,0xE2,0x97,0xF4,0x2E,0x31,0x2D, + 0x68,0x42,0xAD,0xA7,0xC6,0x6A,0x2B,0x3B,0x12,0x75, + 0x4C,0xCC,0x78,0x2E,0xF1,0x1C,0x6A,0x12,0x42,0x37, + 0xB7,0x92,0x51,0xE7,0x06,0xA1,0xBB,0xE6,0x4B,0xFB, + 0x63,0x50,0x1A,0x6B,0x10,0x18,0x11,0xCA,0xED,0xFA, + 0x3D,0x25,0xBD,0xD8,0xE2,0xE1,0xC3,0xC9,0x44,0x42, + 0x16,0x59,0x0A,0x12,0x13,0x86,0xD9,0x0C,0xEC,0x6E, + 0xD5,0xAB,0xEA,0x2A,0x64,0xAF,0x67,0x4E,0xDA,0x86, + 0xA8,0x5F,0xBE,0xBF,0xE9,0x88,0x64,0xE4,0xC3,0xFE, + 0x9D,0xBC,0x80,0x57,0xF0,0xF7,0xC0,0x86,0x60,0x78, + 0x7B,0xF8,0x60,0x03,0x60,0x4D,0xD1,0xFD,0x83,0x46, + 0xF6,0x38,0x1F,0xB0,0x77,0x45,0xAE,0x04,0xD7,0x36, + 0xFC,0xCC,0x83,0x42,0x6B,0x33,0xF0,0x1E,0xAB,0x71, + 0xB0,0x80,0x41,0x87,0x3C,0x00,0x5E,0x5F,0x77,0xA0, + 0x57,0xBE,0xBD,0xE8,0xAE,0x24,0x55,0x46,0x42,0x99, + 0xBF,0x58,0x2E,0x61,0x4E,0x58,0xF4,0x8F,0xF2,0xDD, + 0xFD,0xA2,0xF4,0x74,0xEF,0x38,0x87,0x89,0xBD,0xC2, + 0x53,0x66,0xF9,0xC3,0xC8,0xB3,0x8E,0x74,0xB4,0x75, + 0xF2,0x55,0x46,0xFC,0xD9,0xB9,0x7A,0xEB,0x26,0x61, + 0x8B,0x1D,0xDF,0x84,0x84,0x6A,0x0E,0x79,0x91,0x5F, + 0x95,0xE2,0x46,0x6E,0x59,0x8E,0x20,0xB4,0x57,0x70, + 0x8C,0xD5,0x55,0x91,0xC9,0x02,0xDE,0x4C,0xB9,0x0B, + 0xAC,0xE1,0xBB,0x82,0x05,0xD0,0x11,0xA8,0x62,0x48, + 0x75,0x74,0xA9,0x9E,0xB7,0x7F,0x19,0xB6,0xE0,0xA9, + 0xDC,0x09,0x66,0x2D,0x09,0xA1,0xC4,0x32,0x46,0x33, + 0xE8,0x5A,0x1F,0x02,0x09,0xF0,0xBE,0x8C,0x4A,0x99, + 0xA0,0x25,0x1D,0x6E,0xFE,0x10,0x1A,0xB9,0x3D,0x1D, + 0x0B,0xA5,0xA4,0xDF,0xA1,0x86,0xF2,0x0F,0x28,0x68, + 0xF1,0x69,0xDC,0xB7,0xDA,0x83,0x57,0x39,0x06,0xFE, + 0xA1,0xE2,0xCE,0x9B,0x4F,0xCD,0x7F,0x52,0x50,0x11, + 0x5E,0x01,0xA7,0x06,0x83,0xFA,0xA0,0x02,0xB5,0xC4, + 0x0D,0xE6,0xD0,0x27,0x9A,0xF8,0x8C,0x27,0x77,0x3F, + 0x86,0x41,0xC3,0x60,0x4C,0x06,0x61,0xA8,0x06,0xB5, + 0xF0,0x17,0x7A,0x28,0xC0,0xF5,0x86,0xE0,0x00,0x60, + 0x58,0xAA,0x30,0xDC,0x7D,0x62,0x11,0xE6,0x9E,0xD7, + 0x23,0x38,0xEA,0x63,0x53,0xC2,0xDD,0x94,0xC2,0xC2, + 0x16,0x34,0xBB,0xCB,0xEE,0x56,0x90,0xBC,0xB6,0xDE, + 0xEB,0xFC,0x7D,0xA1,0xCE,0x59,0x1D,0x76,0x6F,0x05, + 0xE4,0x09,0x4B,0x7C,0x01,0x88,0x39,0x72,0x0A,0x3D, + 0x7C,0x92,0x7C,0x24,0x86,0xE3,0x72,0x5F,0x72,0x4D, + 0x9D,0xB9,0x1A,0xC1,0x5B,0xB4,0xD3,0x9E,0xB8,0xFC, + 0xED,0x54,0x55,0x78,0x08,0xFC,0xA5,0xB5,0xD8,0x3D, + 0x7C,0xD3,0x4D,0xAD,0x0F,0xC4,0x1E,0x50,0xEF,0x5E, + 0xB1,0x61,0xE6,0xF8,0xA2,0x85,0x14,0xD9,0x6C,0x51, + 0x13,0x3C,0x6F,0xD5,0xC7,0xE7,0x56,0xE1,0x4E,0xC4, + 0x36,0x2A,0xBF,0xCE,0xDD,0xC6,0xC8,0x37,0xD7,0x9A, + 0x32,0x34,0x92,0x63,0x82,0x12,0x67,0x0E,0xFA,0x8E, + 0x40,0x60,0x00,0xE0,0x3A,0x39,0xCE,0x37,0xD3,0xFA, + 0xF5,0xCF,0xAB,0xC2,0x77,0x37,0x5A,0xC5,0x2D,0x1B, + 0x5C,0xB0,0x67,0x9E,0x4F,0xA3,0x37,0x42,0xD3,0x82, + 0x27,0x40,0x99,0xBC,0x9B,0xBE,0xD5,0x11,0x8E,0x9D, + 0xBF,0x0F,0x73,0x15,0xD6,0x2D,0x1C,0x7E,0xC7,0x00, + 0xC4,0x7B,0xB7,0x8C,0x1B,0x6B,0x21,0xA1,0x90,0x45, + 0xB2,0x6E,0xB1,0xBE,0x6A,0x36,0x6E,0xB4,0x57,0x48, + 0xAB,0x2F,0xBC,0x94,0x6E,0x79,0xC6,0xA3,0x76,0xD2, + 0x65,0x49,0xC2,0xC8,0x53,0x0F,0xF8,0xEE,0x46,0x8D, + 0xDE,0x7D,0xD5,0x73,0x0A,0x1D,0x4C,0xD0,0x4D,0xC6, + 0x29,0x39,0xBB,0xDB,0xA9,0xBA,0x46,0x50,0xAC,0x95, + 0x26,0xE8,0xBE,0x5E,0xE3,0x04,0xA1,0xFA,0xD5,0xF0, + 0x6A,0x2D,0x51,0x9A,0x63,0xEF,0x8C,0xE2,0x9A,0x86, + 0xEE,0x22,0xC0,0x89,0xC2,0xB8,0x43,0x24,0x2E,0xF6, + 0xA5,0x1E,0x03,0xAA,0x9C,0xF2,0xD0,0xA4,0x83,0xC0, + 0x61,0xBA,0x9B,0xE9,0x6A,0x4D,0x8F,0xE5,0x15,0x50, + 0xBA,0x64,0x5B,0xD6,0x28,0x26,0xA2,0xF9,0xA7,0x3A, + 0x3A,0xE1,0x4B,0xA9,0x95,0x86,0xEF,0x55,0x62,0xE9, + 0xC7,0x2F,0xEF,0xD3,0xF7,0x52,0xF7,0xDA,0x3F,0x04, + 0x6F,0x69,0x77,0xFA,0x0A,0x59,0x80,0xE4,0xA9,0x15, + 0x87,0xB0,0x86,0x01,0x9B,0x09,0xE6,0xAD,0x3B,0x3E, + 0xE5,0x93,0xE9,0x90,0xFD,0x5A,0x9E,0x34,0xD7,0x97, + 0x2C,0xF0,0xB7,0xD9,0x02,0x2B,0x8B,0x51,0x96,0xD5, + 0xAC,0x3A,0x01,0x7D,0xA6,0x7D,0xD1,0xCF,0x3E,0xD6, + 0x7C,0x7D,0x2D,0x28,0x1F,0x9F,0x25,0xCF,0xAD,0xF2, + 0xB8,0x9B,0x5A,0xD6,0xB4,0x72,0x5A,0x88,0xF5,0x4C, + 0xE0,0x29,0xAC,0x71,0xE0,0x19,0xA5,0xE6,0x47,0xB0, + 0xAC,0xFD,0xED,0x93,0xFA,0x9B,0xE8,0xD3,0xC4,0x8D, + 0x28,0x3B,0x57,0xCC,0xF8,0xD5,0x66,0x29,0x79,0x13, + 0x2E,0x28,0x78,0x5F,0x01,0x91,0xED,0x75,0x60,0x55, + 0xF7,0x96,0x0E,0x44,0xE3,0xD3,0x5E,0x8C,0x15,0x05, + 0x6D,0xD4,0x88,0xF4,0x6D,0xBA,0x03,0xA1,0x61,0x25, + 0x05,0x64,0xF0,0xBD,0xC3,0xEB,0x9E,0x15,0x3C,0x90, + 0x57,0xA2,0x97,0x27,0x1A,0xEC,0xA9,0x3A,0x07,0x2A, + 0x1B,0x3F,0x6D,0x9B,0x1E,0x63,0x21,0xF5,0xF5,0x9C, + 0x66,0xFB,0x26,0xDC,0xF3,0x19,0x75,0x33,0xD9,0x28, + 0xB1,0x55,0xFD,0xF5,0x03,0x56,0x34,0x82,0x8A,0xBA, + 0x3C,0xBB,0x28,0x51,0x77,0x11,0xC2,0x0A,0xD9,0xF8, + 0xAB,0xCC,0x51,0x67,0xCC,0xAD,0x92,0x5F,0x4D,0xE8, + 0x17,0x51,0x38,0x30,0xDC,0x8E,0x37,0x9D,0x58,0x62, + 0x93,0x20,0xF9,0x91,0xEA,0x7A,0x90,0xC2,0xFB,0x3E, + 0x7B,0xCE,0x51,0x21,0xCE,0x64,0x77,0x4F,0xBE,0x32, + 0xA8,0xB6,0xE3,0x7E,0xC3,0x29,0x3D,0x46,0x48,0xDE, + 0x53,0x69,0x64,0x13,0xE6,0x80,0xA2,0xAE,0x08,0x10, + 0xDD,0x6D,0xB2,0x24,0x69,0x85,0x2D,0xFD,0x09,0x07, + 0x21,0x66,0xB3,0x9A,0x46,0x0A,0x64,0x45,0xC0,0xDD, + 0x58,0x6C,0xDE,0xCF,0x1C,0x20,0xC8,0xAE,0x5B,0xBE, + 0xF7,0xDD,0x1B,0x58,0x8D,0x40,0xCC,0xD2,0x01,0x7F, + 0x6B,0xB4,0xE3,0xBB,0xDD,0xA2,0x6A,0x7E,0x3A,0x59, + 0xFF,0x45,0x3E,0x35,0x0A,0x44,0xBC,0xB4,0xCD,0xD5, + 0x72,0xEA,0xCE,0xA8,0xFA,0x64,0x84,0xBB,0x8D,0x66, + 0x12,0xAE,0xBF,0x3C,0x6F,0x47,0xD2,0x9B,0xE4,0x63, + 0x54,0x2F,0x5D,0x9E,0xAE,0xC2,0x77,0x1B,0xF6,0x4E, + 0x63,0x70,0x74,0x0E,0x0D,0x8D,0xE7,0x5B,0x13,0x57, + 0xF8,0x72,0x16,0x71,0xAF,0x53,0x7D,0x5D,0x40,0x40, + 0xCB,0x08,0x4E,0xB4,0xE2,0xCC,0x34,0xD2,0x46,0x6A, + 0x01,0x15,0xAF,0x84,0xE1,0xB0,0x04,0x28,0x95,0x98, + 0x3A,0x1D,0x06,0xB8,0x9F,0xB4,0xCE,0x6E,0xA0,0x48, + 0x6F,0x3F,0x3B,0x82,0x35,0x20,0xAB,0x82,0x01,0x1A, + 0x1D,0x4B,0x27,0x72,0x27,0xF8,0x61,0x15,0x60,0xB1, + 0xE7,0x93,0x3F,0xDC,0xBB,0x3A,0x79,0x2B,0x34,0x45, + 0x25,0xBD,0xA0,0x88,0x39,0xE1,0x51,0xCE,0x79,0x4B, + 0x2F,0x32,0xC9,0xB7,0xA0,0x1F,0xBA,0xC9,0xE0,0x1C, + 0xC8,0x7E,0xBC,0xC7,0xD1,0xF6,0xCF,0x01,0x11,0xC3, + 0xA1,0xE8,0xAA,0xC7,0x1A,0x90,0x87,0x49,0xD4,0x4F, + 0xBD,0x9A,0xD0,0xDA,0xDE,0xCB,0xD5,0x0A,0xDA,0x38, + 0x03,0x39,0xC3,0x2A,0xC6,0x91,0x36,0x67,0x8D,0xF9, + 0x31,0x7C,0xE0,0xB1,0x2B,0x4F,0xF7,0x9E,0x59,0xB7, + 0x43,0xF5,0xBB,0x3A,0xF2,0xD5,0x19,0xFF,0x27,0xD9, + 0x45,0x9C,0xBF,0x97,0x22,0x2C,0x15,0xE6,0xFC,0x2A, + 0x0F,0x91,0xFC,0x71,0x9B,0x94,0x15,0x25,0xFA,0xE5, + 0x93,0x61,0xCE,0xB6,0x9C,0xEB,0xC2,0xA8,0x64,0x59, + 0x12,0xBA,0xA8,0xD1,0xB6,0xC1,0x07,0x5E,0xE3,0x05, + 0x6A,0x0C,0x10,0xD2,0x50,0x65,0xCB,0x03,0xA4,0x42, + 0xE0,0xEC,0x6E,0x0E,0x16,0x98,0xDB,0x3B,0x4C,0x98, + 0xA0,0xBE,0x32,0x78,0xE9,0x64,0x9F,0x1F,0x95,0x32, + 0xE0,0xD3,0x92,0xDF,0xD3,0xA0,0x34,0x2B,0x89,0x71, + 0xF2,0x1E,0x1B,0x0A,0x74,0x41,0x4B,0xA3,0x34,0x8C, + 0xC5,0xBE,0x71,0x20,0xC3,0x76,0x32,0xD8,0xDF,0x35, + 0x9F,0x8D,0x9B,0x99,0x2F,0x2E,0xE6,0x0B,0x6F,0x47, + 0x0F,0xE3,0xF1,0x1D,0xE5,0x4C,0xDA,0x54,0x1E,0xDA, + 0xD8,0x91,0xCE,0x62,0x79,0xCF,0xCD,0x3E,0x7E,0x6F, + 0x16,0x18,0xB1,0x66,0xFD,0x2C,0x1D,0x05,0x84,0x8F, + 0xD2,0xC5,0xF6,0xFB,0x22,0x99,0xF5,0x23,0xF3,0x57, + 0xA6,0x32,0x76,0x23,0x93,0xA8,0x35,0x31,0x56,0xCC, + 0xCD,0x02,0xAC,0xF0,0x81,0x62,0x5A,0x75,0xEB,0xB5, + 0x6E,0x16,0x36,0x97,0x88,0xD2,0x73,0xCC,0xDE,0x96, + 0x62,0x92,0x81,0xB9,0x49,0xD0,0x4C,0x50,0x90,0x1B, + 0x71,0xC6,0x56,0x14,0xE6,0xC6,0xC7,0xBD,0x32,0x7A, + 0x14,0x0A,0x45,0xE1,0xD0,0x06,0xC3,0xF2,0x7B,0x9A, + 0xC9,0xAA,0x53,0xFD,0x62,0xA8,0x0F,0x00,0xBB,0x25, + 0xBF,0xE2,0x35,0xBD,0xD2,0xF6,0x71,0x12,0x69,0x05, + 0xB2,0x04,0x02,0x22,0xB6,0xCB,0xCF,0x7C,0xCD,0x76, + 0x9C,0x2B,0x53,0x11,0x3E,0xC0,0x16,0x40,0xE3,0xD3, + 0x38,0xAB,0xBD,0x60,0x25,0x47,0xAD,0xF0,0xBA,0x38, + 0x20,0x9C,0xF7,0x46,0xCE,0x76,0x77,0xAF,0xA1,0xC5, + 0x20,0x75,0x60,0x60,0x85,0xCB,0xFE,0x4E,0x8A,0xE8, + 0x8D,0xD8,0x7A,0xAA,0xF9,0xB0,0x4C,0xF9,0xAA,0x7E, + 0x19,0x48,0xC2,0x5C,0x02,0xFB,0x8A,0x8C,0x01,0xC3, + 0x6A,0xE4,0xD6,0xEB,0xE1,0xF9,0x90,0xD4,0xF8,0x69, + 0xA6,0x5C,0xDE,0xA0,0x3F,0x09,0x25,0x2D,0xC2,0x08, + 0xE6,0x9F,0xB7,0x4E,0x61,0x32,0xCE,0x77,0xE2,0x5B, + 0x57,0x8F,0xDF,0xE3,0x3A,0xC3,0x72,0xE6,0xB8,0x3A, + 0xCB,0x02,0x20,0x02,0x39,0x7A,0x6E,0xC6,0xFB,0x5B, + 0xFF,0xCF,0xD4,0xDD,0x4C,0xBF,0x5E,0xD1,0xF4,0x3F, + 0xE5,0x82,0x3E,0xF4,0xE8,0x23,0x2D,0x15,0x2A,0xF0, + 0xE7,0x18,0xC9,0x70,0x59,0xBD,0x98,0x20,0x1F,0x4A, + 0x9D,0x62,0xE7,0xA5,0x29,0xBA,0x89,0xE1,0x24,0x8D, + 0x3B,0xF8,0x86,0x56,0xC5,0x11,0x4D,0x0E,0xBC,0x4C, + 0xEE,0x16,0x03,0x4D,0x8A,0x39,0x20,0xE4,0x78,0x82, + 0xE9,0xAE,0x8F,0xBD,0xE3,0xAB,0xDC,0x1F,0x6D,0xA5, + 0x1E,0x52,0x5D,0xB2,0xBA,0xE1,0x01,0xF8,0x6E,0x7A, + 0x6D,0x9C,0x68,0xA9,0x27,0x08,0xFC,0xD9,0x29,0x3C, + 0xBC,0x0C,0xB0,0x3C,0x86,0xF8,0xA8,0xAD,0x2C,0x2F, + 0x00,0x42,0x4E,0xEB,0xCA,0xCB,0x45,0x2D,0x89,0xCC, + 0x71,0xFC,0xD5,0x9C,0x7F,0x91,0x7F,0x06,0x22,0xBC, + 0x6D,0x8A,0x08,0xB1,0x83,0x4D,0x21,0x32,0x68,0x84, + 0xCA,0x82,0xE3,0xAA,0xCB,0xF3,0x77,0x86,0xF2,0xFA, + 0x2C,0xAB,0x6E,0x3D,0xCE,0x53,0x5A,0xD1,0xF2,0x0A, + 0xC6,0x07,0xC6,0xB8,0xE1,0x4F,0x5E,0xB4,0x38,0x8E, + 0x77,0x50,0x14,0xA6,0x65,0x66,0x65,0xF7,0xB6,0x4A, + 0x43,0xE4,0xBA,0x38,0x3D,0x01,0xB2,0xE4,0x10,0x79, + 0x8E,0xB2,0x98,0x6F,0x90,0x9E,0x0C,0xA4,0x1F,0x7B, + 0x37,0x77,0x2C,0x12,0x60,0x30,0x85,0x08,0x87,0x18, + 0xC4,0xE7,0xD1,0xBD,0x40,0x65,0xFF,0xCE,0x83,0x92, + 0xFD,0x8A,0xAA,0x36,0xD1,0x2B,0xB4,0xC8,0xC9,0xD0, + 0x99,0x4F,0xB0,0xB7,0x14,0xF9,0x68,0x18,0xF9,0xA5, + 0x39,0x98,0xA0,0xA1,0x78,0xC6,0x26,0x84,0xA8,0x1E, + 0x8A,0xE9,0x72,0xF6,0xB8,0x42,0x5E,0xB6,0x7A,0x29, + 0xD4,0x86,0x55,0x1B,0xD7,0x19,0xAF,0x32,0xC1,0x89, + 0xD5,0x14,0x55,0x05,0xDC,0x81,0xD5,0x3E,0x48,0x42, + 0x4E,0xDA,0xB7,0x96,0xEF,0x46,0xA0,0x49,0x8F,0x03, + 0x66,0x7D,0xEE,0xDE,0x03,0xAC,0x0A,0xB3,0xC4,0x97, + 0x73,0x3D,0x53,0x16,0xA8,0x91,0x30,0xA8,0x8F,0xCC, + 0x96,0x04,0x44,0x0A,0xCE,0xEB,0x89,0x3A,0x77,0x25, + 0xB8,0x2B,0x0E,0x1E,0xF6,0x9D,0x30,0x2A,0x5C,0x8E, + 0xE7,0xB8,0x4D,0xEF,0x5A,0x31,0xB0,0x96,0xC9,0xEB, + 0xF8,0x8D,0x51,0x2D,0x78,0x8E,0x7E,0x40,0x02,0xEE, + 0x87,0xE0,0x2A,0xF6,0xC3,0x58,0xA1,0xBB,0x02,0xE8, + 0xD7,0xAF,0xDF,0x9F,0xB0,0xE7,0x79,0x0E,0x94,0x2A, + 0x3B,0x3C,0x1A,0xBA,0xC6,0xFF,0xA7,0xAF,0x9D,0xF7, + 0x96,0xF9,0x32,0x1B,0xB9,0x94,0x01,0x74,0xA8,0xA8, + 0xED,0x22,0x16,0x2C,0xCF,0xF1,0xBB,0x99,0xDA,0xA8, + 0xD5,0x51,0xA4,0xD5,0xE4,0x4B,0xEC,0xDD,0xE3,0xEC, + 0xA8,0x0D,0xC5,0x09,0x03,0x93,0xEE,0xF2,0x72,0x52, + 0x3D,0x31,0xD4,0x8E,0x3A,0x1C,0x22,0x4E,0xB6,0x5E, + 0x60,0x52,0xC3,0xA4,0x21,0x09,0xC3,0x2F,0x05,0x2E, + 0xE3,0x88,0xED,0x9F,0x7E,0xA9,0x91,0xC6,0x2F,0x97, + 0x77,0xB5,0x5B,0xA0,0x15,0x0C,0xBC,0xA3,0x3A,0xEC, + 0x65,0x25,0xDF,0x31,0x83,0x83,0x43,0xA9,0xCE,0x26, + 0x93,0x62,0xAD,0x8B,0x01,0x34,0x14,0x0B,0x8D,0xF5, + 0xCF,0x81,0x1E,0x9F,0xF5,0x59,0x16,0x7F,0x05,0x64, + 0x38,0x12,0xF4,0xE0,0x58,0x8A,0x52,0xB0,0xCB,0xB8, + 0xE9,0x44,0xEF,0x5B,0x16,0xA3,0x73,0xC4,0xED,0xA1, + 0x7D,0xFC,0xFE,0xEA,0xF5,0x4B,0xCB,0xBE,0x87,0x73, + 0xE3,0xD2,0xC5,0x31,0xDC,0xD0,0x55,0xC4,0x67,0x29, + 0x52,0x77,0x4F,0x3A,0x57,0xCA,0x6B,0xC0,0x46,0x7D, + 0x3A,0x3B,0x24,0x77,0x84,0x25,0xB7,0x99,0x1E,0x9A, + 0xDD,0x82,0x5C,0x26,0xE4,0x52,0xC8,0xEE,0xFC,0xAC, + 0xDE,0x1E,0x84,0x83,0x3A,0xF3,0x61,0x21,0x1D,0x03, + 0x17,0x32,0xC1,0x31,0xCC,0xAD,0xB2,0x47,0xE6,0x06, + 0xBE,0x8C,0x71,0x2B,0x39,0xF1,0x88,0xB4,0xEF,0x39, + 0x3A,0x9F,0xCD,0xC5,0xC5,0x75,0x51,0x69,0x1F,0xF6, + 0x99,0x4F,0x39,0x82,0x9C,0xB0,0x11,0x01,0x65,0x73, + 0x33,0x43,0xCB,0xEB,0x61,0xD3,0xD0,0xB4,0x44,0xF3, + 0x0A,0xEF,0xA8,0xAE,0x73,0x75,0x2A,0x3A,0x1C,0x9D, + 0xB4,0xB7,0x09,0x14,0xD6,0xAB,0x25,0x0C,0x85,0x3B, + 0x73,0x28,0x49,0x5F,0x94,0x8F,0xD2,0xA4,0xED,0x8E, + 0x6C,0xF7,0x51,0xE4,0xC3,0x20,0xBB,0x75,0xD9,0xCA, + 0xA0,0xB3,0x8B,0xA5,0x62,0x62,0x4E,0x84,0xB0,0x3F, + 0xEE,0xA8,0x07,0x6E,0x74,0xA0,0x7F,0xE5,0x80,0x39, + 0xE0,0x0C,0x36,0xFF,0xDA,0xF8,0x03,0x73,0x13,0x58, + 0xB9,0xE6,0x71,0xB9,0xDA,0xC4,0xCE,0x1C,0xB2,0x5B, + 0x10,0xED,0x4D,0xD3,0xD5,0xB1,0xFC,0xF2,0xB4,0x80, + 0x46,0x34,0xF5,0x79,0x25,0xEA,0xC4,0x00,0xA9,0xAC, + 0x55,0xEA,0x72,0x89,0x32,0xDF,0x06,0x04,0x1D,0x05, + 0x5D,0x31,0xF5,0x02,0xC5,0x39,0xC2,0xE3,0x2B,0x89, + 0xD9,0xDB,0x5B,0xCC,0x0A,0x98,0xC0,0x5B,0xFD,0x6F, + 0x1B,0x25,0x06,0x22,0x2E,0x21,0xBE,0x0E,0x60,0x97, + 0x3B,0x04,0xEC,0xD5,0x4A,0x67,0xB5,0x4F,0xE6,0x38, + 0xA6,0xED,0x66,0x15,0x98,0x1A,0x91,0x0A,0x5D,0x92, + 0x92,0x8D,0xAC,0x6F,0xC6,0x97,0xE7,0x3C,0x63,0xAD, + 0x45,0x6E,0xDF,0x5F,0x45,0x7A,0x81,0x45,0x51,0x87, + 0x5A,0x64,0xCD,0x30,0x99,0xF1,0x69,0xB5,0xF1,0x8A, + 0x8C,0x73,0xEE,0x0B,0x5E,0x57,0x36,0x8F,0x6C,0x79, + 0xF4,0xBB,0x7A,0x59,0x59,0x26,0xAA,0xB4,0x9E,0xC6, + 0x8A,0xC8,0xFC,0xFB,0x80,0x00, +0x0}; diff --git a/hecl/extern/blowfish/BLOWFISH.H b/hecl/extern/blowfish/BLOWFISH.H new file mode 100644 index 000000000..f89d251b1 --- /dev/null +++ b/hecl/extern/blowfish/BLOWFISH.H @@ -0,0 +1,8 @@ +#define MAXKEYBYTES 56 /* 448 bits */ +// #define little_endian 1 /* Eg: Intel */ +#define big_endian 1 /* Eg: Motorola */ + +short opensubkeyfile(void); +unsigned long F(unsigned long x); +void Blowfish_encipher(unsigned long *xl, unsigned long *xr); +void Blowfish_decipher(unsigned long *xl, unsigned long *xr); diff --git a/hecl/extern/blowfish/cme.py b/hecl/extern/blowfish/cme.py new file mode 100644 index 000000000..09557f26b --- /dev/null +++ b/hecl/extern/blowfish/cme.py @@ -0,0 +1,16 @@ +import struct +with open('BLOWFISH.DAT', 'rb') as fin: + with open('BLOWFISH.DAT.c', 'w') as fout: + fout.write('#include \n') + fin.seek(0, 2) + sz = fin.tell() + fout.write('size_t BLOWFISH_DAT_SZ = %u;\n' % sz) + fout.write('char BLOWFISH_DAT[] = {') + fin.seek(0) + rb = fin.read(1) + for i in range(sz): + if not i%10: + fout.write('\n ') + fout.write('0x%02X,' % struct.unpack("B", rb)[0]) + rb = fin.read(1) + fout.write('\n0x0};\n') diff --git a/hecl/include/HECLDatabase.hpp b/hecl/include/HECLDatabase.hpp index 9ba1d5c72..2cada40f4 100644 --- a/hecl/include/HECLDatabase.hpp +++ b/hecl/include/HECLDatabase.hpp @@ -3,12 +3,47 @@ #include #include +#include +#include namespace HECLDatabase { class IDatabase; +/** + * @brief FourCC representation used within HECL's database + * + * FourCCs are efficient, mnemonic four-char-sequences used to represent types + * while fitting comfortably in a 32-bit word. HECL uses a four-char array + * to remain endian-independent + */ +struct FourCC +{ + union + { + char fcc[4]; + uint32_t num; + }; + FourCC(const char* name) + : num(*(uint32_t*)name) {} +}; + +/** + * @brief Hash representation used for all storable and comparable objects + * + * Hashes are used within HECL to avoid redundant storage of objects; + * providing a rapid mechanism to compare for equality. + */ +class ObjectHash +{ + uint64_t hash; + ObjectHash(const void* buf, size_t len) + { + std::hash hashfn; + } +}; + /** * @brief The IDataObject class * @@ -22,7 +57,7 @@ public: * @brief Data-key of object * @return Primary key */ - virtual std::size_t id() const=0; + virtual size_t id() const=0; /** * @brief Textual name of object @@ -34,7 +69,7 @@ public: * @brief Data-hash of object * @return Object hash truncated to system's size-type */ - virtual std::size_t hash() const=0; + virtual size_t hash() const=0; /** * @brief Retrieve the database this object is stored within @@ -53,21 +88,21 @@ public: * @brief Count of objects in the group * @return object count */ - virtual std::size_t length() const=0; + virtual size_t length() const=0; /** * @brief Alias of length() * @return object count */ - inline std::size_t size() const {return length();} + inline size_t size() const {return length();} /** * @brief Retrieve object at specified internal index within the group * @param idx internal index of object to fetch (range [0,length()-1]) * @return object or nullptr */ - virtual const IDataObject* at(std::size_t idx) const=0; - inline const IDataObject* operator[](std::size_t idx) {return at(idx);} + virtual const IDataObject* at(size_t idx) const=0; + inline const IDataObject* operator[](size_t idx) {return at(idx);} /** * @brief Simple IDataDependencyGroup iterator @@ -78,7 +113,7 @@ public: { friend class IDataDependencyGroup; const IDataDependencyGroup& m_grp; - std::size_t m_idx = 0; + size_t m_idx = 0; inline iterator(const IDataDependencyGroup& grp) : m_grp(grp) {} public: inline bool operator!=(const iterator& other) @@ -99,13 +134,13 @@ public: * @brief Accesses the length of the object (in bytes) * @return Data length */ - virtual std::size_t length() const=0; + virtual size_t length() const=0; /** * @brief Alias for the length() function * @return Data length */ - inline std::size_t size() const {return length();} + inline size_t size() const {return length();} /** * @brief Accesses the object's data @@ -155,7 +190,7 @@ public: * @param id Primary-key of object * @return Data object */ - virtual const IDataObject* lookupObject(std::size_t id) const=0; + virtual const IDataObject* lookupObject(size_t id) const=0; /** * @brief Lookup object by name @@ -171,7 +206,7 @@ public: * @param length Size of object data to copy * @return New data object */ - virtual const IDataObject* addDataBlob(const std::string& name, const void* data, std::size_t length)=0; + virtual const IDataObject* addDataBlob(const std::string& name, const void* data, size_t length)=0; /** * @brief Insert Data-blob object into a database with read/write access @@ -179,7 +214,7 @@ public: * @param length size of object data to copy * @return New data object */ - virtual const IDataObject* addDataBlob(const void* data, std::size_t length)=0; + virtual const IDataObject* addDataBlob(const void* data, size_t length)=0; /** * @brief Write a full copy of the database to another type/path diff --git a/hecl/lib/database/CLooseDatabase.hpp b/hecl/lib/database/CLooseDatabase.hpp index df18cda35..dfcb26f65 100644 --- a/hecl/lib/database/CLooseDatabase.hpp +++ b/hecl/lib/database/CLooseDatabase.hpp @@ -2,6 +2,8 @@ #error This file must only be included from HECLDatabase.cpp #endif +#include + #include "HECLDatabase.hpp" #include "CSQLite.hpp" @@ -34,7 +36,7 @@ public: return m_access; } - const IDataObject* lookupObject(std::size_t id) const + const IDataObject* lookupObject(size_t id) const { } @@ -42,16 +44,26 @@ public: { } - const IDataObject* addDataBlob(const std::string& name, const void* data, std::size_t length) + const IDataObject* addDataBlob(const std::string& name, const void* data, size_t length) { + } - const IDataObject* addDataBlob(const void* data, std::size_t length) + const IDataObject* addDataBlob(const void* data, size_t length) { } bool writeDatabase(IDatabase::Type type, const std::string& path) const { + if (type == PACKED) + { + size_t bufSz; + void* buf = m_sql.fillDBBuffer(bufSz); + FILE* fp = fopen(path.c_str(), "wb"); + fwrite(buf, 1, bufSz, fp); + return true; + } + return false; } }; diff --git a/hecl/lib/database/CMemoryDatabase.hpp b/hecl/lib/database/CMemoryDatabase.hpp index c3dd22113..c6780bfac 100644 --- a/hecl/lib/database/CMemoryDatabase.hpp +++ b/hecl/lib/database/CMemoryDatabase.hpp @@ -14,7 +14,7 @@ class CMemoryDatabase final : public IDatabase Access m_access; public: CMemoryDatabase(Access access) - : m_sql(":memory:"), m_access(access) + : m_sql(":memory:", (m_access == READONLY) ? true : false), m_access(access) { } @@ -34,7 +34,7 @@ public: return m_access; } - const IDataObject* lookupObject(std::size_t id) const + const IDataObject* lookupObject(size_t id) const { } @@ -42,11 +42,11 @@ public: { } - const IDataObject* addDataBlob(const std::string& name, const void* data, std::size_t length) + const IDataObject* addDataBlob(const std::string& name, const void* data, size_t length) { } - const IDataObject* addDataBlob(const void* data, std::size_t length) + const IDataObject* addDataBlob(const void* data, size_t length) { } diff --git a/hecl/lib/database/CPackedDatabase.hpp b/hecl/lib/database/CPackedDatabase.hpp index 49622c028..684cc755a 100644 --- a/hecl/lib/database/CPackedDatabase.hpp +++ b/hecl/lib/database/CPackedDatabase.hpp @@ -13,7 +13,7 @@ class CPackedDatabase final : public IDatabase CSQLite m_sql; public: CPackedDatabase(const std::string& path) - : m_sql(path.c_str(), (m_access == READONLY) ? true : false) + : m_sql(path.c_str(), true) { } @@ -33,7 +33,7 @@ public: return READONLY; } - const IDataObject* lookupObject(std::size_t id) const + const IDataObject* lookupObject(size_t id) const { } @@ -41,11 +41,11 @@ public: { } - const IDataObject* addDataBlob(const std::string& name, const void* data, std::size_t length) + const IDataObject* addDataBlob(const std::string& name, const void* data, size_t length) { } - const IDataObject* addDataBlob(const void* data, std::size_t length) + const IDataObject* addDataBlob(const void* data, size_t length) { } diff --git a/hecl/lib/database/CSQLite.hpp b/hecl/lib/database/CSQLite.hpp index 9df3ecf18..2a420b6c9 100644 --- a/hecl/lib/database/CSQLite.hpp +++ b/hecl/lib/database/CSQLite.hpp @@ -5,6 +5,9 @@ #include #include +#include "HECLDatabase.hpp" +#include "sqlite_hecl_vfs.h" + namespace HECLDatabase { @@ -36,21 +39,35 @@ if (sqlite3_prepare_v2(m_db, stmtSrc, 0, &outVar, NULL) != SQLITE_OK)\ class CSQLite { sqlite3* m_db; + sqlite3_stmt* m_selObjects; sqlite3_stmt* m_selObjectByName; sqlite3_stmt* m_selDistictDepGroups; sqlite3_stmt* m_selDepGroupObjects; + sqlite3_stmt* m_insObject; + + struct SCloseBuf + { + void* buf = NULL; + size_t sz = 0; + }; + static void _vfsClose(void* buf, size_t bufSz, SCloseBuf* ctx) + { + ctx->buf = buf; + ctx->sz = bufSz; + } public: CSQLite(const char* path, bool readonly) { /* Open database connection */ - if (sqlite3_open_v2(path, &m_db, readonly ? - SQLITE_OPEN_READONLY : - SQLITE_OPEN_READWRITE | - SQLITE_OPEN_CREATE, NULL) != SQLITE_OK) + int errCode = 0; + if ((errCode = sqlite3_open_v2(path, &m_db, readonly ? + SQLITE_OPEN_READONLY : + SQLITE_OPEN_READWRITE | + SQLITE_OPEN_CREATE, NULL)) != SQLITE_OK) { - throw std::runtime_error(sqlite3_errmsg(m_db)); + throw std::runtime_error(sqlite3_errstr(errCode)); sqlite3_close(m_db); return; } @@ -71,6 +88,7 @@ public: PREPSTMT("SELECT rowid FROM objects WHERE name=?1", m_selObjectByName); PREPSTMT("SELECT DISTINCT groupId FROM deplinks", m_selDistictDepGroups); PREPSTMT("SELECT DISTINCT objId FROM deplinks WHERE groupId=?1", m_selDepGroupObjects); + PREPSTMT("INSERT INTO objects(name,type4cc,hash64,compLen,decompLen) VALUES (?1,?2,?3,?4,?5)", m_insObject); } ~CSQLite() @@ -79,19 +97,21 @@ public: sqlite3_finalize(m_selObjectByName); sqlite3_finalize(m_selDistictDepGroups); sqlite3_finalize(m_selDepGroupObjects); + sqlite3_finalize(m_insObject); sqlite3_close(m_db); } - void buildMemoryIndex(const std::function& // decompLen + size_t&&, // compLen + size_t&&)>& // decompLen objectAdder) { while (sqlite3_step(m_selObjects) == SQLITE_ROW) { + /* <3 Move Lambdas!! */ objectAdder(sqlite3_column_int64(m_selObjects, 0), (const char*)sqlite3_column_text(m_selObjects, 1), sqlite3_column_int(m_selObjects, 2), @@ -102,16 +122,68 @@ public: sqlite3_reset(m_selObjects); } - std::size_t objectIdFromName(const std::string& name) + size_t objectIdFromName(const std::string& name) { sqlite3_bind_text(m_selObjectByName, 1, name.c_str(), name.length(), NULL); - std::size_t retval = 0; + size_t retval = 0; if (sqlite3_step(m_selObjectByName) == SQLITE_ROW) retval = sqlite3_column_int64(m_selObjectByName, 0); sqlite3_reset(m_selObjectByName); return retval; } + bool insertObject(const std::string& name, const FourCC& type, const ObjectHash& hash, size_t compLen, size_t decompLen) + { + } + + void* fillDBBuffer(size_t& bufSzOut) const + { + /* Instructs vfs that a close operation is premature and buffer should be freed */ + sqlite_hecl_mem_vfs_register(NULL, NULL); + + /* Open pure-memory DB */ + sqlite3* memDb; + int errCode; + if ((errCode = sqlite3_open_v2("", &memDb, SQLITE_OPEN_READWRITE, "hecl_mem")) != SQLITE_OK) + { + throw std::runtime_error(sqlite3_errstr(errCode)); + sqlite3_close(memDb); + return NULL; + } + + /* Perform backup (row copy) */ + sqlite3_backup* backup = sqlite3_backup_init(memDb, "main", m_db, "main"); + if (!backup) + { + throw std::runtime_error(sqlite3_errmsg(memDb)); + sqlite3_close(memDb); + return NULL; + } + sqlite3_backup_step(backup, -1); + sqlite3_backup_finish(backup); + + /* Now a close operation is useful; register close callback */ + SCloseBuf closeBuf; + sqlite_hecl_mem_vfs_register((TCloseCallback)_vfsClose, &closeBuf); + sqlite3_close(memDb); + + /* This should be set by close callback */ + if (!closeBuf.buf) + { + throw std::runtime_error("close operation did not write buffer"); + return NULL; + } + + /* All good! */ + bufSzOut = closeBuf.sz; + return closeBuf.buf; + } + + static void freeDBBuffer(void* buf) + { + sqlite3_free(buf); + } + }; } diff --git a/hecl/lib/database/database.pri b/hecl/lib/database/database.pri index 4c6befb29..857dc6e51 100644 --- a/hecl/lib/database/database.pri +++ b/hecl/lib/database/database.pri @@ -2,7 +2,9 @@ HEADERS += \ $$PWD/CPackedDatabase.hpp \ $$PWD/CMemoryDatabase.hpp \ $$PWD/CLooseDatabase.hpp \ - $$PWD/CSQLite.hpp + $$PWD/CSQLite.hpp \ + $$PWD/sqlite_hecl_vfs.h SOURCES += \ - $$PWD/HECLDatabase.cpp + $$PWD/HECLDatabase.cpp \ + $$PWD/sqlite_hecl_mem_vfs.c diff --git a/hecl/lib/database/sqlite_hecl_mem_vfs.c b/hecl/lib/database/sqlite_hecl_mem_vfs.c new file mode 100644 index 000000000..32cf0190f --- /dev/null +++ b/hecl/lib/database/sqlite_hecl_mem_vfs.c @@ -0,0 +1,361 @@ +#include "sqlite_hecl_vfs.h" + +#include "sqlite3.h" +#include +#include +#include +#include +#include + +/* + * Modified test_onefile.c VFS for sqlite3 + * + * This VFS gets registered with sqlite to access an in-memory, + * block-compressed LBA. It's designed for read-only access of + * a packed object-database. + * + * Journal and temp read/write is unsupported and will call abort + * if attempted. + */ + +/* + * App-supplied callback called when file is closed (ready to access) + */ +static TCloseCallback CLOSE_CALLBACK = NULL; +static void* CLOSE_CTX = NULL; + +typedef struct mem_file mem_file; +struct mem_file { + sqlite3_file base; + int nSize; + int nAlloc; + char *zAlloc; +}; + +/* +** Method declarations for mem_file. +*/ +static int memClose(sqlite3_file*); +static int memRead(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst); +static int memWrite(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst); +static int memTruncate(sqlite3_file*, sqlite3_int64 size); +static int memSync(sqlite3_file*, int flags); +static int memFileSize(sqlite3_file*, sqlite3_int64 *pSize); +static int memLock(sqlite3_file*, int); +static int memUnlock(sqlite3_file*, int); +static int memCheckReservedLock(sqlite3_file*, int *pResOut); +static int memFileControl(sqlite3_file*, int op, void *pArg); +static int memSectorSize(sqlite3_file*); +static int memDeviceCharacteristics(sqlite3_file*); + +/* +** Method declarations for fs_vfs. +*/ +static int memOpen(sqlite3_vfs*, const char *, sqlite3_file*, int , int *); +static int memDelete(sqlite3_vfs*, const char *zName, int syncDir); +static int memAccess(sqlite3_vfs*, const char *zName, int flags, int *); +static int memFullPathname(sqlite3_vfs*, const char *zName, int nOut,char *zOut); +static void *memDlOpen(sqlite3_vfs*, const char *zFilename); +static void memDlError(sqlite3_vfs*, int nByte, char *zErrMsg); +static void (*memDlSym(sqlite3_vfs*,void*, const char *zSymbol))(void); +static void memDlClose(sqlite3_vfs*, void*); +static int memRandomness(sqlite3_vfs*, int nByte, char *zOut); +static int memSleep(sqlite3_vfs*, int microseconds); +static int memCurrentTime(sqlite3_vfs*, double*); + +static sqlite3_vfs mem_vfs = { + 1, /* iVersion */ + 0, /* szOsFile */ + 0, /* mxPathname */ + 0, /* pNext */ + "hecl_mem", /* zName */ + 0, /* pAppData */ + memOpen, /* xOpen */ + memDelete, /* xDelete */ + memAccess, /* xAccess */ + memFullPathname, /* xFullPathname */ + memDlOpen, /* xDlOpen */ + memDlError, /* xDlError */ + memDlSym, /* xDlSym */ + memDlClose, /* xDlClose */ + memRandomness, /* xRandomness */ + memSleep, /* xSleep */ + memCurrentTime, /* xCurrentTime */ + 0 /* xCurrentTimeInt64 */ +}; + +static sqlite3_io_methods mem_io_methods = { + 1, /* iVersion */ + memClose, /* xClose */ + memRead, /* xRead */ + memWrite, /* xWrite */ + memTruncate, /* xTruncate */ + memSync, /* xSync */ + memFileSize, /* xFileSize */ + memLock, /* xLock */ + memUnlock, /* xUnlock */ + memCheckReservedLock, /* xCheckReservedLock */ + memFileControl, /* xFileControl */ + memSectorSize, /* xSectorSize */ + memDeviceCharacteristics, /* xDeviceCharacteristics */ + 0, /* xShmMap */ + 0, /* xShmLock */ + 0, /* xShmBarrier */ + 0, /* xShmUnmap */ + 0, + 0 +}; + +/* Useful macros used in several places */ +#define MIN(x,y) ((x)<(y)?(x):(y)) +#define MAX(x,y) ((x)>(y)?(x):(y)) + + +/* +** Close a mem-file. +*/ +static int memClose(sqlite3_file *pFile){ + mem_file *pTmp = (mem_file *)pFile; + if (CLOSE_CALLBACK) + CLOSE_CALLBACK(pTmp->zAlloc, pTmp->nSize, CLOSE_CTX); + else + sqlite3_free(pTmp->zAlloc); + return SQLITE_OK; +} + +/* +** Read data from a mem-file. +*/ +static int memRead( + sqlite3_file *pFile, + void *zBuf, + int iAmt, + sqlite_int64 iOfst + ){ + mem_file *pTmp = (mem_file *)pFile; + if( (iAmt+iOfst)>pTmp->nSize ){ + return SQLITE_IOERR_SHORT_READ; + } + memcpy(zBuf, &pTmp->zAlloc[iOfst], iAmt); + return SQLITE_OK; +} + +/* +** Write data to a mem-file. +*/ +static int memWrite( + sqlite3_file *pFile, + const void *zBuf, + int iAmt, + sqlite_int64 iOfst + ){ + mem_file *pTmp = (mem_file *)pFile; + if( (iAmt+iOfst)>pTmp->nAlloc ){ + int nNew = (int)(2*(iAmt+iOfst+pTmp->nAlloc)); + char *zNew = sqlite3_realloc(pTmp->zAlloc, nNew); + if( !zNew ){ + return SQLITE_NOMEM; + } + pTmp->zAlloc = zNew; + pTmp->nAlloc = nNew; + } + memcpy(&pTmp->zAlloc[iOfst], zBuf, iAmt); + pTmp->nSize = (int)MAX(pTmp->nSize, iOfst+iAmt); + return SQLITE_OK; +} + +/* +** Truncate a mem-file. +*/ +static int memTruncate(sqlite3_file *pFile, sqlite_int64 size){ + mem_file *pTmp = (mem_file *)pFile; + pTmp->nSize = (int)MIN(pTmp->nSize, size); + return SQLITE_OK; +} + +/* +** Sync a mem-file. +*/ +static int memSync(sqlite3_file *pFile, int flags){ + return SQLITE_OK; +} + +/* +** Return the current file-size of a mem-file. +*/ +static int memFileSize(sqlite3_file *pFile, sqlite_int64 *pSize){ + mem_file *pTmp = (mem_file *)pFile; + *pSize = pTmp->nSize; + return SQLITE_OK; +} + +/* +** Lock a mem-file. +*/ +static int memLock(sqlite3_file *pFile, int eLock){ + return SQLITE_OK; +} + +/* +** Unlock a mem-file. +*/ +static int memUnlock(sqlite3_file *pFile, int eLock){ + return SQLITE_OK; +} + +/* +** Check if another file-handle holds a RESERVED lock on a mem-file. +*/ +static int memCheckReservedLock(sqlite3_file *pFile, int *pResOut){ + *pResOut = 0; + return SQLITE_OK; +} + +/* +** File control method. For custom operations on a mem-file. +*/ +static int memFileControl(sqlite3_file *pFile, int op, void *pArg){ + return SQLITE_OK; +} + +/* +** Return the sector-size in bytes for a mem-file. +*/ +static int memSectorSize(sqlite3_file *pFile){ + return 0; +} + +/* +** Return the device characteristic flags supported by a mem-file. +*/ +static int memDeviceCharacteristics(sqlite3_file *pFile){ + return 0; +} + +/* +** Open an mem file handle. +*/ +static int memOpen( + sqlite3_vfs *pVfs, + const char *zName, + sqlite3_file *pFile, + int flags, + int *pOutFlags + ){ + if (flags != SQLITE_OPEN_MAIN_DB) + { + fprintf(stderr, "the sqlite hecl mem VFS only supports main-db writing\n"); + abort(); + } + mem_file *p2 = (mem_file *)pFile; + memset(p2, 0, sizeof(*p2)); + p2->base.pMethods = &mem_io_methods; + return SQLITE_OK; +} + +/* +** Delete the file located at zPath. If the dirSync argument is true, +** ensure the file-system modifications are synced to disk before +** returning. +*/ +static int memDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync){ + return SQLITE_OK; +} + +/* +** Test for access permissions. Return true if the requested permission +** is available, or false otherwise. +*/ +static int memAccess( + sqlite3_vfs *pVfs, + const char *zPath, + int flags, + int *pResOut + ){ + if (flags & SQLITE_ACCESS_READ | SQLITE_ACCESS_READWRITE) + return 1; + return 0; +} + +/* +** Populate buffer zOut with the full canonical pathname corresponding +** to the pathname in zPath. zOut is guaranteed to point to a buffer +** of at least (FS_MAX_PATHNAME+1) bytes. +*/ +static int memFullPathname( + sqlite3_vfs *pVfs, /* Pointer to vfs object */ + const char *zPath, /* Possibly relative input path */ + int nOut, /* Size of output buffer in bytes */ + char *zOut /* Output buffer */ + ){ + strncpy(zOut, zPath, nOut); + return SQLITE_OK; +} + +/* +** Open the dynamic library located at zPath and return a handle. +*/ +static void *memDlOpen(sqlite3_vfs *pVfs, const char *zPath){ + return NULL; +} + +/* +** Populate the buffer zErrMsg (size nByte bytes) with a human readable +** utf-8 string describing the most recent error encountered associated +** with dynamic libraries. +*/ +static void memDlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg){ +} + +/* +** Return a pointer to the symbol zSymbol in the dynamic library pHandle. +*/ +static void (*memDlSym(sqlite3_vfs *pVfs, void *pH, const char *zSym))(void){ +} + +/* +** Close the dynamic library handle pHandle. +*/ +static void memDlClose(sqlite3_vfs *pVfs, void *pHandle){ +} + +/* +** Populate the buffer pointed to by zBufOut with nByte bytes of +** random data. +*/ +static int memRandomness(sqlite3_vfs *pVfs, int nByte, char *zBufOut){ + for (int i=0 ; i +typedef void(*TCloseCallback)(void* buf, size_t bufLen, void* ctx); +int sqlite_hecl_mem_vfs_register(TCloseCallback closeCb, void* ctx); +int sqlite_hecl_memlba_vfs_register(TCloseCallback closeCb, void* ctx); + +#ifdef __cplusplus +} +#endif + +#endif // SQLITE_HECL_VFS