diff options
Diffstat (limited to 'include')
| -rw-r--r-- | include/odhtdb/Database.hpp | 56 | ||||
| -rw-r--r-- | include/odhtdb/DatabaseStorage.hpp | 134 | ||||
| -rw-r--r-- | include/odhtdb/Encryption.hpp | 3 | ||||
| -rw-r--r-- | include/odhtdb/Group.hpp | 15 | ||||
| -rw-r--r-- | include/odhtdb/LocalUser.hpp | 6 | ||||
| -rw-r--r-- | include/odhtdb/LocalUserEncrypted.hpp | 15 | ||||
| -rw-r--r-- | include/odhtdb/Permission.hpp | 2 | ||||
| -rw-r--r-- | include/odhtdb/RemoteUser.hpp | 6 | ||||
| -rw-r--r-- | include/odhtdb/Signature.hpp | 8 | ||||
| -rw-r--r-- | include/odhtdb/User.hpp | 15 | ||||
| -rw-r--r-- | include/odhtdb/sql/SqlQuery.hpp | 65 |
11 files changed, 181 insertions, 144 deletions
diff --git a/include/odhtdb/Database.hpp b/include/odhtdb/Database.hpp index 12c618b..1e4d470 100644 --- a/include/odhtdb/Database.hpp +++ b/include/odhtdb/Database.hpp @@ -55,14 +55,14 @@ namespace odhtdb const Hash *nodeHash; u64 timestamp; // In microseconds - const User *creatorUser; - std::string name; + const Signature::PublicKey *creatorPublicKey; + const DataView groupId; - DatabaseCreateNodeRequest(const Hash *_nodeHash, u64 _timestamp, const User *_creatorUser, std::string &&_name) : + DatabaseCreateNodeRequest(const Hash *_nodeHash, u64 _timestamp, const Signature::PublicKey *_creatorPublicKey, const DataView &_groupId) : nodeHash(_nodeHash), timestamp(_timestamp), - creatorUser(_creatorUser), - name(std::move(_name)) + creatorPublicKey(_creatorPublicKey), + groupId(_groupId) { } @@ -75,14 +75,14 @@ namespace odhtdb const Hash *nodeHash; const Hash *requestHash; u64 timestamp; // In microseconds - const User *creatorUser; + const Signature::PublicKey *creatorPublicKey; const DataView decryptedData; - DatabaseAddNodeRequest(const Hash *_nodeHash, const Hash *_requestHash, u64 _timestamp, const User *_creatorUser, const DataView &_decryptedData) : + DatabaseAddNodeRequest(const Hash *_nodeHash, const Hash *_requestHash, u64 _timestamp, const Signature::PublicKey *_creatorPublicKey, const DataView &_decryptedData) : nodeHash(_nodeHash), requestHash(_requestHash), timestamp(_timestamp), - creatorUser(_creatorUser), + creatorPublicKey(_creatorPublicKey), decryptedData(_decryptedData) { @@ -96,16 +96,16 @@ namespace odhtdb const Hash *nodeHash; const Hash *requestHash; u64 timestamp; // In microseconds - const User *creatorUser; - const User *userToAdd; - const Group *groupToAddUserTo; + const Signature::PublicKey *creatorPublicKey; + const Signature::PublicKey *userToAddPublicKey; + const DataView groupToAddUserTo; - DatabaseAddUserRequest(const Hash *_nodeHash, const Hash *_requestHash, u64 _timestamp, const User *_creatorUser, const User *_userToAdd, const Group *_groupToAddUserTo) : + DatabaseAddUserRequest(const Hash *_nodeHash, const Hash *_requestHash, u64 _timestamp, const Signature::PublicKey *_creatorPublicKey, const Signature::PublicKey *_userToAddPublicKey, const DataView &_groupToAddUserTo) : nodeHash(_nodeHash), requestHash(_requestHash), timestamp(_timestamp), - creatorUser(_creatorUser), - userToAdd(_userToAdd), + creatorPublicKey(_creatorPublicKey), + userToAddPublicKey(_userToAddPublicKey), groupToAddUserTo(_groupToAddUserTo) { @@ -115,7 +115,7 @@ namespace odhtdb class DatabaseCreateResponse { public: - DatabaseCreateResponse(LocalUser *nodeAdminUser, const std::shared_ptr<OwnedMemory> &key, const std::shared_ptr<Hash> &hash); + DatabaseCreateResponse(LocalUser *nodeAdminUser, std::shared_ptr<OwnedMemory> key, std::shared_ptr<Hash> hash); const LocalUser* getNodeAdminUser() const; // Size of encryption key is odhtdb::KEY_BYTE_SIZE (found in Encryption.hpp) @@ -144,32 +144,40 @@ namespace odhtdb reponseKeyInfoHash = other.reponseKeyInfoHash; } }; + + using CreateNodeCallbackFunc = std::function<void(const DatabaseCreateNodeRequest&)>; + using AddNodeCallbackFunc = std::function<void(const DatabaseAddNodeRequest&)>; + using AddUserCallbackFunc = std::function<void(const DatabaseAddUserRequest&)>; + + struct DatabaseCallbackFuncs + { + CreateNodeCallbackFunc createNodeCallbackFunc; + AddNodeCallbackFunc addNodeCallbackFunc; + AddUserCallbackFunc addUserCallbackFunc; + }; + class Database { DISABLE_COPY(Database) friend class DatabaseStorage; public: - Database(const char *bootstrapNodeAddr, u16 port, const boost::filesystem::path &storageDir); + Database(const char *bootstrapNodeAddr, u16 port, const boost::filesystem::path &storageDir, DatabaseCallbackFuncs callbackFuncs); ~Database(); // Safe to call multiple times with same node hash, will be ignored if the node is already beeing seeded void seed(const DatabaseNode &nodeToSeed); void stopSeeding(const Hash &nodeHash); + void loadNode(const Hash &nodeHash); // Throws DatabaseCreateException on failure. - std::unique_ptr<DatabaseCreateResponse> create(const std::string &ownerName, const std::string &nodeName); + std::unique_ptr<DatabaseCreateResponse> create(); // Throws DatabaseCreateException on failure. - std::unique_ptr<DatabaseCreateResponse> create(const std::string &ownerName, const Signature::KeyPair &keyPair, const std::string &nodeName); + std::unique_ptr<DatabaseCreateResponse> create(const Signature::KeyPair &creatorKeyPair); // Throws PermissionDeniedException if user @userToPerformActionWith is not allowed to add data to node void addData(const DatabaseNode &nodeInfo, const LocalUser *userToPerformActionWith, DataView dataToAdd); // Throws PermissionDeniedException if user @userToPerformActionWith is not allowed to add user @userToAdd to group @groupToAddUserTo - void addUser(const DatabaseNode &nodeInfo, const LocalUser *userToPerformActionWith, const std::string &userToAddName, const Signature::PublicKey &userToAddPublicKey, Group *groupToAddUserTo); - - void setOnCreateNodeCallback(std::function<void(const DatabaseCreateNodeRequest&)> callbackFunc); - void setOnAddNodeCallback(std::function<void(const DatabaseAddNodeRequest&)> callbackFunc); - void setOnAddUserCallback(std::function<void(const DatabaseAddUserRequest&)> callbackFunc); + void addUser(const DatabaseNode &nodeInfo, const LocalUser *userToPerformActionWith, const Signature::PublicKey &userToAddPublicKey, Group *groupToAddUserTo); - DatabaseStorage& getStorage(); ntp::NtpTimestamp getSyncedTimestampUtc() const; private: void deserializeCreateRequest(const std::shared_ptr<dht::Value> &value, const Hash &hash, const std::shared_ptr<OwnedMemory> encryptionKey); diff --git a/include/odhtdb/DatabaseStorage.hpp b/include/odhtdb/DatabaseStorage.hpp index 11e243a..3c4d9bc 100644 --- a/include/odhtdb/DatabaseStorage.hpp +++ b/include/odhtdb/DatabaseStorage.hpp @@ -15,6 +15,10 @@ #include <boost/filesystem/path.hpp> #include <sibs/SafeDeserializer.hpp> #include <opendht/crypto.h> +#include <functional> + +class sqlite3; +class sqlite3_stmt; namespace odhtdb { @@ -41,16 +45,12 @@ namespace odhtdb { Signature::PublicKey creatorPublicKey; DataView data; - u32 offsetToEncryptedData; u64 createdTimestamp; // In microseconds - std::string nodeName; - bool isDecrypted; std::vector<Group*> groups; std::vector<DatabaseStorageObject*> objects; DatabaseStorageObjectList(const Signature::PublicKey &_creatorPublicKey) : - creatorPublicKey(_creatorPublicKey), - isDecrypted(false) + creatorPublicKey(_creatorPublicKey) { } @@ -115,63 +115,46 @@ namespace odhtdb LocalUser *localUser; }; + using FetchNodeRawCallbackFunc = std::function<void(const DataView)>; + using FetchNodeAddDataRawCallbackFunc = std::function<void(const DataView)>; + class DatabaseStorage { public: - // Throws DatabaseStorageCorrupt if storage is corrupted + // Throws DatabaseStorageCorrupt if storage is corrupted. Throws DatabaseStorageException on other failures DatabaseStorage(Database *database, const boost::filesystem::path &storagePath); + ~DatabaseStorage(); + + void loadNode(const Hash &nodeHash); + + bool doesNodeExist(const Hash &nodeHash) const; + bool doesDataExist(const Hash &requestHash) const; // Throws DatabaseStorageAlreadyExists if data with hash already exists - void createStorage(const Hash &hash, Group *creatorGroup, u64 timestamp, const u8 *data, usize dataSize, u32 offsetToEncryptedData); + void createStorage(const Hash &hash, Group *creatorGroup, u64 timestamp, const void *data, usize size); // Throws DatabaseStorageNotFound if data with @nodeHash hash has not been created yet. // Throws DatabaseStorageAlreadyExists if same data has been added before (hash of @data, in @dataHash) - void appendStorage(const Hash &nodeHash, const Hash &dataHash, DatabaseOperation operation, const User *creatorUser, u64 timestamp, const u8 *data, usize dataSize, const DataView &encryptedDataView); - - // Throws DatabaseStorageAlreadyExists if same data has been added before (hash of @data, in @dataHash) - void addToQuarantine(const Hash &dataHash, const Signature::PublicKey &creatorPublicKey, u64 timestamp, const u8 *data, usize dataSize); - - // Return false if group with id already exists, otherwise return true - bool addGroup(const Hash &nodeHash, Group *group); + void appendStorage(const Hash &nodeHash, const Hash &dataHash, DatabaseOperation operation, const Signature::PublicKey &creatorPublicKey, u64 timestamp, const void *data, usize size, const DataView &additionalDataView); - // Return false if user public key already exists, otherwise return true - bool addUser(const Hash &nodeHash, User *user); + // Throws DatabaseStorageAlreadyExists if group already exists in node + void addGroup(const Hash &nodeHash, Group *group); - // Increase user action counter, returning the new value. If user has not performed any action yet, then 0 is returned. - // Returns DatabaseStorageException if no node with id @nodeHash exists or if user with public key @userPublicKey doesn't exist in node @nodeHash - //u64 increaseUserActionCounter(const Hash &nodeHash, const Signature::PublicKey &userPublicKey); + void addUserToGroup(const Hash &nodeHash, const Signature::PublicKey &userPublicKey, const DataView &groupId); - // Returns nullptr if no storage with provided hash exists - const DatabaseStorageObjectList* getStorage(const Hash &hash) const; + // Throws DatabaseStorageAlreadyExists is user already exists in node + void addUser(const Hash &nodeHash, const Signature::PublicKey &userPublicKey, const DataView &groupId); - // Returns nullptr if node @nodeHash doesn't exist - const DataViewMap<Group*>* getNodeGroups(const Hash &nodeHash); - - // Returns nullptr if a group with id @groupId doesn't exist in node @nodeHash or if no node with id @nodeHash exists - Group* getGroupById(const Hash &nodeHash, uint8_t groupId[GROUP_ID_LENGTH]) const; - - // Returns nullptr if node @nodeHash doesn't exist - const Signature::MapPublicKey<User*>* getNodeUsers(const Hash &nodeHash); - - // Returns nullptr if a user with public key @publicKey doesn't exist in node @nodeHash or if no node with id @nodeHash exists - User* getUserByPublicKey(const Hash &nodeHash, const Signature::PublicKey &userPublicKey) const; + void fetchNodeRaw(const Hash &nodeHash, FetchNodeRawCallbackFunc callbackFunc); + void fetchNodeAddDataRaw(const Hash &nodeHash, FetchNodeAddDataRawCallbackFunc callbackFunc); // Username and key pair has to be unique, returns true on success - bool storeLocalUser(const std::string &username, const Signature::KeyPair &keyPair, const std::string &password); + //bool storeLocalUser(const std::string &username, const Signature::KeyPair &keyPair, const std::string &password); // Returns public key and private key of encrypted local user. // Throws DatabaseStorageNoSuchLocalStorageUser if user does not exist in local storage. // Throws DatabaseStorageWrongPassword if password for the stored local user is wrong. - Signature::KeyPair decryptLocalEncryptedUser(const std::string &username, const std::string &password); - - // Get stored local user by public & private key in all nodes they exist. - // Creates a new user object and replaces user object in the nodes. - // Safe to call multiple times. - std::vector<NodeLocalUser> getLocalNodeUsers(const Signature::KeyPair &keyPair); - - // Returns data in node by its id. Doesn't include 'create' requests. - // Returns nullptr if not data with @dataHash exists. - DatabaseStorageObject* getDataById(const Hash &dataHash); + //Signature::KeyPair decryptLocalEncryptedUser(const std::string &username, const std::string &password); // Returns true and node decryption key if node exists and we have the decryption key, // otherwise return false and OwnedMemory with data set to nullptr @@ -183,37 +166,48 @@ namespace odhtdb // Update storage state (remove quarantine objects if they are too old, etc) void update(); private: - void loadGroupsFromFile(); - void loadUsersFromFile(); - void loadDataFromFile(); - void loadLocalUsersFromFile(); - void loadNodeDecryptionKeysFromFile(); - void loadDecryptedDataFromFile(); + void init(const boost::filesystem::path &storagePath); + void cleanup(); + + void bindCheckError(int sqliteBindResult); void loadMetadataFromFile(); - void loadStorageCreate(sibs::SafeDeserializer &deserializer); - void loadStorageAppend(sibs::SafeDeserializer &deserializer); - void loadDecryptedStorageCreate(sibs::SafeDeserializer &deserializer); - void loadDecryptedStorageAddData(sibs::SafeDeserializer &deserializer); - void loadDecryptedStorageAddUser(sibs::SafeDeserializer &deserializer); - - bool decryptNodeData(const Hash &nodeHash, DatabaseStorageObjectList *databaseCreateObject, const std::shared_ptr<OwnedMemory> decryptionKey); - bool decryptNodeAppendedData(const Hash &nodeHash, DatabaseStorageObject *databaseAppendObject, const std::shared_ptr<OwnedMemory> decryptionKey); + bool decryptNodeData(const Hash &nodeHash, const std::shared_ptr<OwnedMemory> decryptionKey); + bool decryptNodeData(const Hash &nodeHash, const std::shared_ptr<OwnedMemory> decryptionKey, const Signature::PublicKey *creatorPublicKey, const DataView &adminGroupId, u64 timestamp); + bool decryptNodeAddData(i64 rowId, const Hash &nodeHash, const Hash &dataHash, u64 timestamp, const Signature::PublicKey *creatorPublicKey, const DataView &encryptedData, const std::shared_ptr<OwnedMemory> decryptionKey); + bool decryptNodeAddUser(i64 rowId, const Hash &nodeHash, const Hash &dataHash, u64 timestamp, const Signature::PublicKey *creatorPublicKey, const Signature::PublicKey *userToAddPublicKey, const DataView &groupToAddUserTo, const std::shared_ptr<OwnedMemory> decryptionKey); + i64 getNodeRowId(const Hash &nodeHash); + i64 getNodeAddDataRowId(const Hash &requestHash); + + void setNodeAddDataDecrypted(i64 rowId); + void setNodeAddDataDecryptedData(i64 rowId, const DataView &decryptedData); private: Database *database; - DatabaseStorageMap storageMap; - DatabaseStorageQuarantineMap quarantineStorageMap; - MapHash<DatabaseStorageObject*> storedDataHash; // Prevent duplicate data from being added - MapHash<Signature::MapPublicKey<User*>*> nodePublicKeyUserDataMap; - MapHash<DataViewMap<Group*>*> nodeGroupByIdMap; - MapHash<std::shared_ptr<OwnedMemory>> nodeDecryptionKeyMap; - std::unordered_map<std::string, LocalUserEncrypted*> nameLocalUsersMap; - boost::filesystem::path groupsFilePath; - boost::filesystem::path usersFilePath; - boost::filesystem::path dataFilePath; + sqlite3 *sqliteDb; + sqlite3_stmt *insertNodeStmt; + sqlite3_stmt *insertUserStmt; + sqlite3_stmt *insertGroupStmt; + sqlite3_stmt *insertNodeAddDataStmt; + sqlite3_stmt *setNodeDecryptionKeyStmt; + sqlite3_stmt *getNodeDecryptionKeyStmt; + sqlite3_stmt *insertNodeUserGroupAssocStmt; + + sqlite3_stmt *selectNodeStmt; + sqlite3_stmt *selectNodeAddDataByNodeStmt; + sqlite3_stmt *selectNodeIdStatement; + sqlite3_stmt *selectNodeAddDataIdStatement; + sqlite3_stmt *insertNodeRawStmt; + sqlite3_stmt *insertNodeAddDataRawStmt; + + sqlite3_stmt *insertNodeAddDataAdditionalStmt; + sqlite3_stmt *insertNodeAddUserDataStmt; + + sqlite3_stmt *selectNodeAddDataAdditionalStmt; + sqlite3_stmt *selectNodeAddUserDataStmt; + + sqlite3_stmt *setNodeAddDataDecryptedStmt; + sqlite3_stmt *setNodeAddDataAdditionalDataStmt; + boost::filesystem::path metadataFilePath; - boost::filesystem::path localUsersFilePath; - boost::filesystem::path nodeDecryptionKeysFilePath; - boost::filesystem::path decryptedDataFilePath; u8 passwordSalt[PASSWORD_SALT_LEN]; std::pair<std::shared_ptr<dht::crypto::PrivateKey>, std::shared_ptr<dht::crypto::Certificate>> identity; }; diff --git a/include/odhtdb/Encryption.hpp b/include/odhtdb/Encryption.hpp index e710760..2457630 100644 --- a/include/odhtdb/Encryption.hpp +++ b/include/odhtdb/Encryption.hpp @@ -38,6 +38,9 @@ namespace odhtdb DataView getKey() const; DataView getNonce() const; DataView getCipherText() const; + + // Size of output should be at least @ENCRYPTION_KEY_BYTE_SIZE bytes + static void generateKey(unsigned char *output); private: unsigned char key[ENCRYPTION_KEY_BYTE_SIZE]; unsigned char nonce[ENCRYPTION_NONCE_BYTE_SIZE]; diff --git a/include/odhtdb/Group.hpp b/include/odhtdb/Group.hpp index 99307e1..f8de78e 100644 --- a/include/odhtdb/Group.hpp +++ b/include/odhtdb/Group.hpp @@ -4,7 +4,6 @@ #include "DataView.hpp" #include "Permission.hpp" #include "utils.hpp" -#include <string> #include <vector> #include <stdexcept> @@ -12,16 +11,6 @@ namespace odhtdb { class User; - class GroupNameTooLongException : public std::runtime_error - { - public: - GroupNameTooLongException(const std::string &groupName) : - std::runtime_error(std::string("The group name ") + groupName + " is longer than 255 bytes") - { - - } - }; - const int GROUP_ID_LENGTH = 16; class Group @@ -29,10 +18,9 @@ namespace odhtdb DISABLE_COPY(Group) friend class User; public: - Group(const std::string &name, uint8_t id[GROUP_ID_LENGTH], const Permission &permission); + Group(uint8_t id[GROUP_ID_LENGTH], const Permission &permission); ~Group(); - const std::string& getName() const; DataView getId() const; const Permission& getPermission() const; const std::vector<const User*>& getUsers() const; @@ -40,7 +28,6 @@ namespace odhtdb void addUser(const User *user); bool removeUser(const User *user); private: - std::string name; uint8_t id[GROUP_ID_LENGTH]; Permission permission; std::vector<const User*> users; diff --git a/include/odhtdb/LocalUser.hpp b/include/odhtdb/LocalUser.hpp index c87ba45..b60b516 100644 --- a/include/odhtdb/LocalUser.hpp +++ b/include/odhtdb/LocalUser.hpp @@ -8,9 +8,9 @@ namespace odhtdb class LocalUser : public User { public: - static LocalUser* create(const Signature::KeyPair &keyPair, const std::string &name, Group *group) + static LocalUser* create(const Signature::KeyPair &keyPair, Group *group) { - return new LocalUser(keyPair, name, group); + return new LocalUser(keyPair, group); } const Signature::PublicKey& getPublicKey() const override @@ -28,7 +28,7 @@ namespace odhtdb return keyPair; } private: - LocalUser(const Signature::KeyPair &_keyPair, const std::string &name, Group *group); + LocalUser(const Signature::KeyPair &_keyPair, Group *group); private: Signature::KeyPair keyPair; }; diff --git a/include/odhtdb/LocalUserEncrypted.hpp b/include/odhtdb/LocalUserEncrypted.hpp index 952892f..7919cb3 100644 --- a/include/odhtdb/LocalUserEncrypted.hpp +++ b/include/odhtdb/LocalUserEncrypted.hpp @@ -22,9 +22,9 @@ namespace odhtdb class LocalUserEncrypted { public: - static LocalUserEncrypted* create(const Signature::PublicKey &publicKey, const EncryptedPrivateKey &encryptedPrivateKey, const std::string &name) + static LocalUserEncrypted* create(const Signature::PublicKey &publicKey, const EncryptedPrivateKey &encryptedPrivateKey) { - return new LocalUserEncrypted(publicKey, encryptedPrivateKey, name); + return new LocalUserEncrypted(publicKey, encryptedPrivateKey); } const Signature::PublicKey& getPublicKey() const @@ -36,22 +36,15 @@ namespace odhtdb { return encryptedPrivateKey; } - - const std::string& getName() const - { - return name; - } private: - LocalUserEncrypted(const Signature::PublicKey &_publicKey, const EncryptedPrivateKey &_encryptedPrivateKey, const std::string &_name) : + LocalUserEncrypted(const Signature::PublicKey &_publicKey, const EncryptedPrivateKey &_encryptedPrivateKey) : publicKey(_publicKey), - encryptedPrivateKey(_encryptedPrivateKey), - name(_name) + encryptedPrivateKey(_encryptedPrivateKey) { } private: Signature::PublicKey publicKey; EncryptedPrivateKey encryptedPrivateKey; - std::string name; }; } diff --git a/include/odhtdb/Permission.hpp b/include/odhtdb/Permission.hpp index 1e7bb0c..0978c5e 100644 --- a/include/odhtdb/Permission.hpp +++ b/include/odhtdb/Permission.hpp @@ -16,7 +16,7 @@ namespace odhtdb { ADD_DATA = (1 << 0), ADD_USER_SAME_LEVEL = (1 << 1), - ADD_USER_LOWER_LEVEL = (1 << 2), + ADD_USER_HIGHER_LEVEL = (1 << 2), ADD_GROUP = (1 << 3), REMOVE_GROUP = (1 << 4) }; diff --git a/include/odhtdb/RemoteUser.hpp b/include/odhtdb/RemoteUser.hpp index 9dc8f96..2658132 100644 --- a/include/odhtdb/RemoteUser.hpp +++ b/include/odhtdb/RemoteUser.hpp @@ -7,9 +7,9 @@ namespace odhtdb class RemoteUser : public User { public: - static RemoteUser* create(const Signature::PublicKey &publicKey, const std::string &name, Group *group) + static RemoteUser* create(const Signature::PublicKey &publicKey, Group *group) { - return new RemoteUser(publicKey, name, group); + return new RemoteUser(publicKey, group); } const Signature::PublicKey& getPublicKey() const override @@ -17,7 +17,7 @@ namespace odhtdb return publicKey; } private: - RemoteUser(const Signature::PublicKey &_publicKey, const std::string &name, Group *group) : User(User::Type::REMOTE, name, group), publicKey(_publicKey){} + RemoteUser(const Signature::PublicKey &_publicKey, Group *group) : User(User::Type::REMOTE, group), publicKey(_publicKey) {} private: Signature::PublicKey publicKey; }; diff --git a/include/odhtdb/Signature.hpp b/include/odhtdb/Signature.hpp index 1f5158e..0fc9087 100644 --- a/include/odhtdb/Signature.hpp +++ b/include/odhtdb/Signature.hpp @@ -55,11 +55,13 @@ namespace odhtdb public: const static PublicKey ZERO; + PublicKey(); // Throws InvalidSignatureKeySize if size is not PUBLIC_KEY_NUM_BYTES PublicKey(const char *data, size_t size); PublicKey(const PublicKey &other); PublicKey& operator=(const PublicKey &other); + char* getData() { return data; } const char* getData() const { return data; } size_t getSize() const { return PUBLIC_KEY_NUM_BYTES; } @@ -74,8 +76,6 @@ namespace odhtdb std::string toString() const; private: - PublicKey(){} - private: char data[PUBLIC_KEY_NUM_BYTES]; }; @@ -96,11 +96,13 @@ namespace odhtdb public: const static PrivateKey ZERO; + PrivateKey(); // Throws InvalidSignatureKeySize if size is not PRIVATE_KEY_NUM_BYTES PrivateKey(const char *data, size_t size); PrivateKey(const PrivateKey &other); PrivateKey& operator=(const PrivateKey &other); + char* getData() { return data; } const char* getData() const { return data; } size_t getSize() const { return PRIVATE_KEY_NUM_BYTES; } @@ -108,8 +110,6 @@ namespace odhtdb std::string sign(const DataView &dataToSign) const; std::string toString() const; private: - PrivateKey(){} - private: char data[PRIVATE_KEY_NUM_BYTES]; }; diff --git a/include/odhtdb/User.hpp b/include/odhtdb/User.hpp index 4d6d9b3..15e6492 100644 --- a/include/odhtdb/User.hpp +++ b/include/odhtdb/User.hpp @@ -3,7 +3,6 @@ #include "Signature.hpp" #include "types.hpp" #include "Permission.hpp" -#include <string> #include <stdexcept> #include <vector> @@ -11,16 +10,6 @@ namespace odhtdb { class Group; class DatabaseStorage; - - class UserNameTooLongException : public std::runtime_error - { - public: - UserNameTooLongException(const std::string &userName) : - std::runtime_error(std::string("The username ") + userName + " is longer than 255 bytes") - { - - } - }; class User { @@ -37,16 +26,14 @@ namespace odhtdb virtual void addToGroup(Group *group); Type getType() const { return type; } - const std::string& getName() const { return name; } virtual const std::vector<Group*>& getGroups() const { return groups; } virtual const Signature::PublicKey& getPublicKey() const = 0; virtual bool isAllowedToPerformAction(PermissionType action) const; protected: - User(Type type, const std::string &name, Group *group); + User(Type type, Group *group); protected: Type type; - std::string name; std::vector<Group*> groups; }; } diff --git a/include/odhtdb/sql/SqlQuery.hpp b/include/odhtdb/sql/SqlQuery.hpp new file mode 100644 index 0000000..f26ee1a --- /dev/null +++ b/include/odhtdb/sql/SqlQuery.hpp @@ -0,0 +1,65 @@ +#pragma once + +#include "../DataView.hpp" +#include <utility> +#include <stdexcept> + +class sqlite3; +class sqlite3_stmt; + +namespace odhtdb +{ + class SqlQueryException : public std::runtime_error + { + public: + SqlQueryException(const std::string &errMsg) : std::runtime_error(errMsg) {} + }; + + class SqlArg + { + public: + enum class Type : u8 + { + DATA_VIEW, + INT, + INT64 + }; + + SqlArg(const DataView &data) : dataView(data), type(Type::DATA_VIEW) {} + SqlArg(int data) : integer(data), type(Type::INT) {} + SqlArg(i64 data) : integer64(data), type(Type::INT64) {} + + int bind(sqlite3_stmt *stmt, int paramIndex) const; + private: + union + { + const DataView dataView; + const int integer; + const i64 integer64; + }; + const Type type; + }; + + class SqlQuery + { + public: + // Throws SqlQueryException on failure + SqlQuery(sqlite3 *db, const char *sql, std::initializer_list<SqlArg> args); + ~SqlQuery(); + + // Return true if we got result, false if there are not rows left. + // Throws SqlQueryException on failure + bool next(); + + int getInt(int index); + i64 getInt64(int index); + // The returned blob is NOT a copy, it will be invalid after next call to @next or when SqlQuery is deallocated + const DataView getBlob(int index); + private: + void checkColumnIndex(int index); + private: + sqlite3 *db; + sqlite3_stmt *stmt; + int numColumns; + }; +} |