Split alias at server side into pair name and label.

Change-Id: I5cbe62ee49042449127218a95f82db9b59105a73

3 files changed, 180 insertions, 166 deletions

diff --git a/tests/DBFixture.cpp b/tests/DBFixture.cpp
index f4636139..9581a534 100644
--- a/tests/DBFixture.cpp
+++ b/tests/DBFixture.cpp
@@ -37,21 +37,21 @@ void DBFixture::performance_stop(long num_operations_performed)
         BOOST_TEST_MESSAGE("\t<performance> average time per " << m_operation << ": " << time_elapsed_ms/num_operations_performed << "[ms]");
 }
 
-void DBFixture::generate_alias(unsigned int id, std::string & output)
+void DBFixture::generate_name(unsigned int id, Name & output)
 {
     std::stringstream ss;
-    ss << "alias_no_" << id;
+    ss << "name_no_" << id;
     output = ss.str();
 }
 
-void DBFixture::generate_label(unsigned int id, std::string & output)
+void DBFixture::generate_label(unsigned int id, Label & output)
 {
     std::stringstream ss;
     ss << "label_no_" << id;
     output = ss.str();
 }
 
-void DBFixture::generate_perf_DB(unsigned int num_alias, unsigned int num_label)
+void DBFixture::generate_perf_DB(unsigned int num_name, unsigned int num_label)
 {
     // to speed up data creation - cache the row
     DBRow rowPattern = create_default_row(DBDataType::BINARY_DATA);
@@ -59,33 +59,34 @@ void DBFixture::generate_perf_DB(unsigned int num_alias, unsigned int num_label)
     rowPattern.dataSize = rowPattern.data.size();
     rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1);
 
-    for(unsigned int i=0; i<num_alias; i++)
+    for(unsigned int i=0; i<num_name; i++)
     {
-        generate_alias(i, rowPattern.alias);
+        generate_name(i, rowPattern.name);
         generate_label(i/num_label, rowPattern.smackLabel);
 
         BOOST_REQUIRE_NO_THROW(m_db.saveDBRow(rowPattern));
     }
 }
 
-long DBFixture::add_full_access_rights(unsigned int num_alias, unsigned int num_alias_per_label)
+long DBFixture::add_full_access_rights(unsigned int num_name, unsigned int num_name_per_label)
 {
     long iterations = 0;
-    unsigned int num_labels = num_alias / num_alias_per_label;
-    std::string alias, owner_label, accessor_label;
-    for(unsigned int a=0; a<num_alias; a++)
+    unsigned int num_labels = num_name / num_name_per_label;
+    Name name;
+    Label owner_label, accessor_label;
+    for(unsigned int a=0; a<num_name; a++)
     {
-        generate_alias(a, alias);
-        generate_label(a/num_alias_per_label, owner_label);
+        generate_name(a, name);
+        generate_label(a/num_name_per_label, owner_label);
         for(unsigned int l=0; l<num_labels; l++)
         {
             // bypass the owner label
-            if(l == (a/num_alias_per_label))
+            if(l == (a/num_name_per_label))
                 continue;
 
             // add permission
             generate_label(l, accessor_label);
-            add_permission(alias, owner_label, accessor_label);
+            add_permission(name, owner_label, accessor_label);
             iterations ++;
         }
     }
@@ -95,15 +96,15 @@ long DBFixture::add_full_access_rights(unsigned int num_alias, unsigned int num_
 
 DBRow DBFixture::create_default_row(DBDataType type)
 {
-    return create_default_row(m_default_alias, m_default_label, type);
+    return create_default_row(m_default_name, m_default_label, type);
 }
 
-DBRow DBFixture::create_default_row(const std::string &alias,
-                                    const std::string &label,
+DBRow DBFixture::create_default_row(const Name &name,
+                                    const Label &label,
                                     DBDataType type)
 {
     DBRow row;
-    row.alias = alias;
+    row.name = name;
     row.smackLabel = label;
     row.exportable = 1;
     row.algorithmType = DBCMAlgType::AES_GCM_256;
@@ -117,9 +118,9 @@ DBRow DBFixture::create_default_row(const std::string &alias,
 
 void DBFixture::compare_row(const DBRow &lhs, const DBRow &rhs)
 {
-    BOOST_CHECK_MESSAGE(lhs.alias == rhs.alias,
-            "Aliases didn't match! Got: " << rhs.alias
-                << " , expected : " << lhs.alias);
+    BOOST_CHECK_MESSAGE(lhs.name == rhs.name,
+            "namees didn't match! Got: " << rhs.name
+                << " , expected : " << lhs.name);
 
     BOOST_CHECK_MESSAGE(lhs.smackLabel == rhs.smackLabel,
             "smackLabel didn't match! Got: " << rhs.smackLabel
@@ -144,65 +145,66 @@ void DBFixture::check_DB_integrity(const DBRow &rowPattern)
     DBRow selectRow = rowPattern;
 
     DBCrypto::DBRowOptional optional_row;
-    BOOST_REQUIRE_NO_THROW(optional_row = m_db.getDBRow("alias", "label", DBDataType::BINARY_DATA));
+    BOOST_REQUIRE_NO_THROW(optional_row = m_db.getDBRow("name", "label", "label", DBDataType::BINARY_DATA));
     BOOST_REQUIRE_MESSAGE(optional_row, "Select didn't return any row");
 
     compare_row(selectRow, rowPattern);
-    DBRow alias_duplicate = rowPattern;
-    alias_duplicate.data = createDefaultPass();
-    alias_duplicate.dataSize = alias_duplicate.data.size();
+    DBRow name_duplicate = rowPattern;
+    name_duplicate.data = createDefaultPass();
+    name_duplicate.dataSize = name_duplicate.data.size();
 
-    BOOST_REQUIRE_THROW(m_db.saveDBRow(alias_duplicate), DBCrypto::Exception::AliasExists);
+    BOOST_REQUIRE_THROW(m_db.saveDBRow(name_duplicate), DBCrypto::Exception::NameExists);
     unsigned int erased;
-    BOOST_REQUIRE_NO_THROW(erased = m_db.deleteDBRow("alias", "label"));
+    BOOST_REQUIRE_NO_THROW(erased = m_db.deleteDBRow("name", "label", "label"));
     BOOST_REQUIRE_MESSAGE(erased > 0, "Inserted row didn't exist in db");
 
     DBCrypto::DBRowOptional row_optional;
-    BOOST_REQUIRE_NO_THROW(row_optional = m_db.getDBRow("alias", "label", DBDataType::BINARY_DATA));
+    BOOST_REQUIRE_NO_THROW(row_optional = m_db.getDBRow("name", "label", "label", DBDataType::BINARY_DATA));
     BOOST_REQUIRE_MESSAGE(!row_optional, "Select should not return row after deletion");
 }
 
 void DBFixture::insert_row()
 {
-    insert_row(m_default_alias, m_default_label);
+    insert_row(m_default_name, m_default_label);
 }
 
-void DBFixture::insert_row(const std::string &alias, const std::string &accessor_label)
+void DBFixture::insert_row(const Name &name, const Label &owner_label)
 {
-    DBRow rowPattern = create_default_row(alias, accessor_label, DBDataType::BINARY_DATA);
+    DBRow rowPattern = create_default_row(name, owner_label, DBDataType::BINARY_DATA);
     rowPattern.data = RawBuffer(100, 20);
     rowPattern.dataSize = rowPattern.data.size();
     rowPattern.tag = RawBuffer(AES_GCM_TAG_SIZE, 1);
     BOOST_REQUIRE_NO_THROW(m_db.saveDBRow(rowPattern));
 }
 
-void DBFixture::delete_row(const std::string &alias, const std::string &accessor_label)
+void DBFixture::delete_row(const Name &name, const Label &owner_label, const Label &accessor_label)
 {
     bool exit_flag;
-    BOOST_REQUIRE_NO_THROW(exit_flag = m_db.deleteDBRow(alias, accessor_label));
-    BOOST_REQUIRE_MESSAGE(true == exit_flag, "remove alias failed: no rows removed");
+    BOOST_REQUIRE_NO_THROW(exit_flag = m_db.deleteDBRow(name, owner_label, accessor_label));
+    BOOST_REQUIRE_MESSAGE(true == exit_flag, "remove name failed: no rows removed");
 }
 
-void DBFixture::add_permission(const std::string &alias, const std::string &owner_label, const std::string &accessor_label)
+void DBFixture::add_permission(const Name &name, const Label &owner_label, const Label &accessor_label)
 {
     int ec;
-    BOOST_REQUIRE_NO_THROW(ec = m_db.setAccessRights(owner_label,
-                                                   alias,
-                                                   accessor_label,
-                                                   CKM::AccessRight::AR_READ_REMOVE));
+    BOOST_REQUIRE_NO_THROW(ec = m_db.setAccessRights(name,
+                                                     owner_label,
+                                                     accessor_label,
+                                                     CKM::AccessRight::AR_READ_REMOVE));
     BOOST_REQUIRE_MESSAGE(CKM_API_SUCCESS == ec, "add permission failed: " << ec);
 }
 
-void DBFixture::read_row_expect_fail(const std::string &alias, const std::string &accessor_label)
+void DBFixture::read_row_expect_fail(const Name &name, const Label &owner_label, const Label &accessor_label)
 {
     DBCrypto::DBRowOptional row;
-    BOOST_REQUIRE_THROW(row = m_db.getDBRow(alias, accessor_label, DBDataType::BINARY_DATA), DBCrypto::Exception::PermissionDenied);
+    BOOST_REQUIRE_NO_THROW(row = m_db.getDBRow(name, owner_label, accessor_label, DBDataType::BINARY_DATA));
+    BOOST_REQUIRE(!row);
 }
 
-void DBFixture::read_row_expect_success(const std::string &alias, const std::string &accessor_label)
+void DBFixture::read_row_expect_success(const Name &name, const Label &owner_label, const Label &accessor_label)
 {
     DBCrypto::DBRowOptional row;
-    BOOST_REQUIRE_NO_THROW(row = m_db.getDBRow(alias, accessor_label, DBDataType::BINARY_DATA));
+    BOOST_REQUIRE_NO_THROW(row = m_db.getDBRow(name, owner_label, accessor_label, DBDataType::BINARY_DATA));
     BOOST_REQUIRE_MESSAGE(row, "row is empty");
-    BOOST_REQUIRE_MESSAGE(row->alias == alias, "alias is not valid");
+    BOOST_REQUIRE_MESSAGE(row->name == name, "name is not valid");
 }
diff --git a/tests/DBFixture.h b/tests/DBFixture.h
index 883e9630..e4047c51 100644
--- a/tests/DBFixture.h
+++ b/tests/DBFixture.h
@@ -2,6 +2,7 @@
 
 #include <test_common.h>
 #include <ckm/ckm-type.h>
+#include <protocols.h>
 #include <chrono>
 
 class DBFixture
@@ -9,15 +10,15 @@ class DBFixture
     public:
         DBFixture();
 
-        constexpr static const char* m_default_alias = "alias";
+        constexpr static const char* m_default_name = "name";
         constexpr static const char* m_default_label = "label";
 
         // ::::::::::::::::::::::::: helper methods :::::::::::::::::::::::::
-        static void generate_alias(unsigned int id, std::string & output);
-        static void generate_label(unsigned int id, std::string & output);
+        static void generate_name(unsigned int id, CKM::Name & output);
+        static void generate_label(unsigned int id, CKM::Label & output);
         static CKM::DBRow create_default_row(CKM::DBDataType type = CKM::DBDataType::BINARY_DATA);
-        static CKM::DBRow create_default_row(const std::string &alias,
-                                             const std::string &label,
+        static CKM::DBRow create_default_row(const CKM::Name &name,
+                                             const CKM::Label &label,
                                              CKM::DBDataType type = CKM::DBDataType::BINARY_DATA);
         static void compare_row(const CKM::DBRow &lhs, const CKM::DBRow &rhs);
 
@@ -26,15 +27,15 @@ class DBFixture
         void performance_stop(long num_operations_performed);
 
         // ::::::::::::::::::::::::: DB :::::::::::::::::::::::::
-        void generate_perf_DB(unsigned int num_alias, unsigned int num_label);
-        long add_full_access_rights(unsigned int num_alias, unsigned int num_alias_per_label);
+        void generate_perf_DB(unsigned int num_name, unsigned int num_label);
+        long add_full_access_rights(unsigned int num_name, unsigned int num_names_per_label);
         void check_DB_integrity(const CKM::DBRow &rowPattern);
         void insert_row();
-        void insert_row(const std::string &alias, const std::string &accessor_label);
-        void delete_row(const std::string &alias, const std::string &accessor_label);
-        void add_permission(const std::string &alias, const std::string &owner_label, const std::string &accessor_label);
-        void read_row_expect_fail(const std::string &alias, const std::string &accessor_label);
-        void read_row_expect_success(const std::string &alias, const std::string &accessor_label);
+        void insert_row(const CKM::Name &name, const CKM::Label &owner_label);
+        void delete_row(const CKM::Name &name, const CKM::Label &owner_label, const CKM::Label &accessor_label);
+        void add_permission(const CKM::Name &name, const CKM::Label &owner_label, const CKM::Label &accessor_label);
+        void read_row_expect_fail(const CKM::Name &name, const CKM::Label &owner_label, const CKM::Label &accessor_label);
+        void read_row_expect_success(const CKM::Name &name, const CKM::Label &owner_label, const CKM::Label &accessor_label);
 
         CKM::DBCrypto    m_db;
     private:
diff --git a/tests/test_db_crypto.cpp b/tests/test_db_crypto.cpp
index 4344541b..db1db798 100644
--- a/tests/test_db_crypto.cpp
+++ b/tests/test_db_crypto.cpp
@@ -19,9 +19,9 @@ const int restricted_local = 1;
 const int restricted_global = 0;
 
 const unsigned int c_test_retries = 1000;
-const unsigned int c_num_aliases = 500;
-const unsigned int c_num_aliases_add_test = 5000;
-const unsigned int c_alias_per_label = 15;
+const unsigned int c_num_names = 500;
+const unsigned int c_num_names_add_test = 5000;
+const unsigned int c_names_per_label = 15;
 }
 
 
@@ -50,11 +50,11 @@ BOOST_AUTO_TEST_CASE(DBtestGlobal) {
 
     BOOST_REQUIRE_NO_THROW(m_db.saveDBRow(rowPattern));
 
-    DBRow alias_duplicate = rowPattern;
+    DBRow name_duplicate = rowPattern;
     rowPattern.smackLabel = rowPattern.smackLabel + "1";
 
-    BOOST_REQUIRE_THROW(m_db.saveDBRow(alias_duplicate),
-            DBCrypto::Exception::AliasExists);
+    BOOST_REQUIRE_THROW(m_db.saveDBRow(name_duplicate),
+            DBCrypto::Exception::NameExists);
 }
 BOOST_AUTO_TEST_CASE(DBtestTransaction) {
     DBRow rowPattern = create_default_row();
@@ -67,96 +67,96 @@ BOOST_AUTO_TEST_CASE(DBtestTransaction) {
     BOOST_REQUIRE_NO_THROW(transaction.rollback());
 
     DBCrypto::DBRowOptional row_optional;
-    BOOST_REQUIRE_NO_THROW(row_optional = m_db.getDBRow(m_default_alias, m_default_label,
-            DBDataType::BINARY_DATA));
+    BOOST_REQUIRE_NO_THROW(row_optional = m_db.getDBRow(m_default_name, m_default_label,
+                                                   m_default_label, DBDataType::BINARY_DATA));
     BOOST_CHECK_MESSAGE(!row_optional, "Row still present after rollback");
 
 }
 
 BOOST_AUTO_TEST_CASE(DBaddDataCheckIfPermissionIsAdded)
 {
-    std::string row_A_alias, row_B_alias;
-    std::string row_A_label, row_B_label;
-    generate_alias(0, row_A_alias); generate_label(0, row_A_label);
-    generate_alias(1, row_B_alias); generate_label(1, row_B_label);
+    Name row_A_name, row_B_name;
+    Label row_A_label, row_B_label;
+    generate_name(0, row_A_name); generate_label(0, row_A_label);
+    generate_name(1, row_B_name); generate_label(1, row_B_label);
 
     // insert initial data set
-    insert_row(row_A_alias, row_A_label);
-    insert_row(row_B_alias, row_B_label);
-    read_row_expect_success(row_A_alias, row_A_label);
-    read_row_expect_success(row_B_alias, row_B_label);
+    insert_row(row_A_name, row_A_label);
+    insert_row(row_B_name, row_B_label);
+    read_row_expect_success(row_A_name, row_A_label, row_A_label);
+    read_row_expect_success(row_B_name, row_B_label, row_B_label);
 
     // verify that no entries present in the permission table
     // read row A from label B and vice versa
-    read_row_expect_fail(row_A_alias, row_B_label);
-    read_row_expect_fail(row_B_alias, row_A_label);
+    read_row_expect_fail(row_A_name, row_A_label, row_B_label);
+    read_row_expect_fail(row_B_name, row_B_label, row_A_label);
 
     // add appropriate permissions for label B
-    add_permission(row_A_alias, row_A_label, row_B_label);
+    add_permission(row_A_name, row_A_label, row_B_label);
 
     // B should have access to A, while A should not to B
     // read row A from label B and vice versa
-    read_row_expect_success(row_A_alias, row_B_label);
-    read_row_expect_fail(row_B_alias, row_A_label);
+    read_row_expect_success(row_A_name, row_A_label, row_B_label);
+    read_row_expect_fail(row_B_name, row_B_label, row_A_label);
 
     // add appropriate permissions for label A
-    add_permission(row_B_alias, row_B_label, row_A_label);
+    add_permission(row_B_name, row_B_label, row_A_label);
 
     // B should have access to A, same as A have access to B
     // read row A from label B and vice versa
-    read_row_expect_success(row_A_alias, row_B_label);
-    read_row_expect_success(row_B_alias, row_A_label);
+    read_row_expect_success(row_A_name, row_A_label, row_B_label);
+    read_row_expect_success(row_B_name, row_B_label, row_A_label);
 }
 
 
 BOOST_AUTO_TEST_CASE(DBremoveDataCheckIfPermissionIsRemoved)
 {
-    std::string row_A_alias, row_B_alias, row_C_alias;
-    std::string row_A_label, row_B_label, row_C_label;
-    generate_alias(0, row_A_alias); generate_label(0, row_A_label);
-    generate_alias(1, row_B_alias); generate_label(1, row_B_label);
-    generate_alias(2, row_C_alias); generate_label(2, row_C_label);
+    Name row_A_name, row_B_name, row_C_name;
+    Label row_A_label, row_B_label, row_C_label;
+    generate_name(0, row_A_name); generate_label(0, row_A_label);
+    generate_name(1, row_B_name); generate_label(1, row_B_label);
+    generate_name(2, row_C_name); generate_label(2, row_C_label);
 
     // insert initial data set
-    insert_row(row_A_alias, row_A_label);
-    insert_row(row_B_alias, row_B_label);
-    insert_row(row_C_alias, row_C_label);
-    add_permission(row_A_alias, row_A_label, row_B_label);
-    add_permission(row_B_alias, row_B_label, row_A_label);
+    insert_row(row_A_name, row_A_label);
+    insert_row(row_B_name, row_B_label);
+    insert_row(row_C_name, row_C_label);
+    add_permission(row_A_name, row_A_label, row_B_label);
+    add_permission(row_B_name, row_B_label, row_A_label);
     // to test multiple permissions removal
-    // put intentionally after row_B_alias permission entry
-    add_permission(row_A_alias, row_A_label, row_C_label);
+    // put intentionally after row_B_name permission entry
+    add_permission(row_A_name, row_A_label, row_C_label);
 
     // B should have access to A, same as A have access to B
     // read row A from label B and vice versa
-    read_row_expect_success(row_A_alias, row_B_label);
-    read_row_expect_success(row_A_alias, row_C_label);
-    read_row_expect_success(row_B_alias, row_A_label);
-    read_row_expect_fail(row_B_alias, row_C_label);
+    read_row_expect_success(row_A_name, row_A_label, row_B_label);
+    read_row_expect_success(row_A_name, row_A_label, row_C_label);
+    read_row_expect_success(row_B_name, row_B_label, row_A_label);
+    read_row_expect_fail(row_B_name, row_B_label, row_C_label);
 
     // remove data A - expect permissions for B and C to be removed as well
-    delete_row(row_A_alias, row_A_label);
+    delete_row(row_A_name, row_A_label, row_A_label);
     // insert it again - expect permissions for label B and C not to be there anymore
-    insert_row(row_A_alias, row_A_label);
+    insert_row(row_A_name, row_A_label);
 
     // read row A from label B and vice versa
-    read_row_expect_fail(row_A_alias, row_B_label);
-    read_row_expect_fail(row_A_alias, row_C_label);
-    read_row_expect_success(row_B_alias, row_A_label);
+    read_row_expect_fail(row_A_name, row_A_label, row_B_label);
+    read_row_expect_fail(row_A_name, row_A_label, row_C_label);
+    read_row_expect_success(row_B_name, row_B_label, row_A_label);
 
     // remove data B - expect permission to be removed as well
-    delete_row(row_B_alias, row_B_label);
+    delete_row(row_B_name, row_B_label, row_B_label);
     // insert it again - expect permissions for label A not to be there anymore
-    insert_row(row_B_alias, row_B_label);
+    insert_row(row_B_name, row_B_label);
 
     // read row A from label B and vice versa
-    read_row_expect_fail(row_A_alias, row_B_label);
-    read_row_expect_fail(row_A_alias, row_C_label);
-    read_row_expect_fail(row_B_alias, row_A_label);
+    read_row_expect_fail(row_A_name, row_A_label, row_B_label);
+    read_row_expect_fail(row_A_name, row_A_label, row_C_label);
+    read_row_expect_fail(row_B_name, row_B_label, row_A_label);
 
     // sanity check: data exists
-    read_row_expect_success(row_A_alias, row_A_label);
-    read_row_expect_success(row_B_alias, row_B_label);
+    read_row_expect_success(row_A_name, row_A_label, row_A_label);
+    read_row_expect_success(row_B_name, row_B_label, row_B_label);
 }
 BOOST_AUTO_TEST_SUITE_END()
 
@@ -164,23 +164,24 @@ BOOST_AUTO_TEST_SUITE_END()
 
 BOOST_FIXTURE_TEST_SUITE(DBCRYPTO_PERF_TEST, DBFixture)
 
-BOOST_AUTO_TEST_CASE(DBperfAddAliases)
+BOOST_AUTO_TEST_CASE(DBperfAddNames)
 {
     // actual test
     performance_start("saveDBRow");
     {
-        generate_perf_DB(c_num_aliases_add_test, c_alias_per_label);
+        generate_perf_DB(c_num_names_add_test, c_names_per_label);
     }
-    performance_stop(c_num_aliases_add_test);
+    performance_stop(c_num_names_add_test);
 }
 
 BOOST_AUTO_TEST_CASE(DBperfLookupAliasByOwner)
 {
     // prepare data
-    generate_perf_DB(c_num_aliases, c_alias_per_label);
+    generate_perf_DB(c_num_names, c_names_per_label);
 
-    unsigned int num_labels = c_num_aliases/c_alias_per_label;
-    std::string alias, label;
+    unsigned int num_labels = c_num_names/c_names_per_label;
+    Name name;
+    Label label;
 
     // actual test - successful lookup
     performance_start("getDBRow");
@@ -189,117 +190,127 @@ BOOST_AUTO_TEST_CASE(DBperfLookupAliasByOwner)
         int label_num = rand() % num_labels;
         generate_label(label_num, label);
 
-        unsigned int start_alias = label_num*c_alias_per_label;
-        for(unsigned int alias_num=start_alias; alias_num<(start_alias+c_alias_per_label); alias_num++)
+        unsigned int start_name = label_num*c_names_per_label;
+        for(unsigned int name_num=start_name; name_num<(start_name+c_names_per_label); name_num++)
         {
-            generate_alias(alias_num, alias);
-            read_row_expect_success(alias, label);
+            generate_name(name_num, name);
+            read_row_expect_success(name, label, label);
         }
     }
-    performance_stop(c_test_retries * c_num_aliases);
+    performance_stop(c_test_retries * c_num_names);
 }
 
 BOOST_AUTO_TEST_CASE(DBperfLookupAliasByNotAllowed)
 {
     // prepare data
-    generate_perf_DB(c_num_aliases, c_alias_per_label);
+    generate_perf_DB(c_num_names, c_names_per_label);
 
-    std::string alias, label;
-    const unsigned int unavailable_label_idx = (c_num_aliases/c_alias_per_label) + 1;
-    generate_label(unavailable_label_idx, label);
+    Name name;
+    Label owner_label;
+    Label smack_label;
+    const unsigned int unavailable_label_idx = (c_num_names/c_names_per_label) + 1;
+    generate_label(unavailable_label_idx, smack_label);
 
     // actual test - failure lookup
     performance_start("getDBRow");
     for(unsigned int t=0; t<c_test_retries; t++)
     {
-        generate_alias(rand()%c_num_aliases, alias);
+        int name_idx = rand()%c_num_names;
+        generate_name(name_idx, name);
+        generate_label(name_idx/c_names_per_label, owner_label);
 
-        read_row_expect_fail(alias, label);
+        read_row_expect_fail(name, owner_label, smack_label);
     }
-    performance_stop(c_test_retries * c_num_aliases);
+    performance_stop(c_test_retries * c_num_names);
 }
 
 BOOST_AUTO_TEST_CASE(DBperfLookupAliasRandomOwnershipNoPermissions)
 {
     // prepare data
-    generate_perf_DB(c_num_aliases, c_alias_per_label);
+    generate_perf_DB(c_num_names, c_names_per_label);
 
-    std::string alias, label;
-    unsigned int num_labels = c_num_aliases / c_alias_per_label;
+    Name name;
+    Label owner_label;
+    Label smack_label;
+    unsigned int num_labels = c_num_names / c_names_per_label;
 
     // actual test - random lookup
     performance_start("getDBRow");
     for(unsigned int t=0; t<c_test_retries; t++)
     {
-        generate_alias(rand()%c_num_aliases, alias);
-        generate_label(rand()%num_labels, label);
+        int name_idx = rand()%c_num_names;
+        generate_name(name_idx, name);
+        generate_label(name_idx/c_names_per_label, owner_label);
+        generate_label(rand()%num_labels, smack_label);
 
-        try
-        {
-            m_db.getDBRow(alias, label, DBDataType::BINARY_DATA);
-        }
-        catch (const DBCrypto::Exception::PermissionDenied &e) {}
+        // do not care of result
+        m_db.getDBRow(name, owner_label, smack_label, DBDataType::BINARY_DATA);
     }
-    performance_stop(c_test_retries * c_num_aliases);
+    performance_stop(c_test_retries * c_num_names);
 }
 
 BOOST_AUTO_TEST_CASE(DBperfAddPermissions)
 {
     // prepare data
-    generate_perf_DB(c_num_aliases, c_alias_per_label);
+    generate_perf_DB(c_num_names, c_names_per_label);
 
     // actual test - add access rights
     performance_start("setAccessRights");
-    long iterations = add_full_access_rights(c_num_aliases, c_alias_per_label);
+    long iterations = add_full_access_rights(c_num_names, c_names_per_label);
     performance_stop(iterations);
 }
 
 BOOST_AUTO_TEST_CASE(DBperfLookupAliasRandomOwnershipWithPermissions)
 {
     // prepare data
-    generate_perf_DB(c_num_aliases, c_alias_per_label);
-    add_full_access_rights(c_num_aliases, c_alias_per_label);
+    generate_perf_DB(c_num_names, c_names_per_label);
+    add_full_access_rights(c_num_names, c_names_per_label);
 
-    std::string alias, label;
-    unsigned int num_labels = c_num_aliases / c_alias_per_label;
+    Name name;
+    Label owner_label;
+    Label smack_label;
+    unsigned int num_labels = c_num_names / c_names_per_label;
 
     // actual test - random lookup
     performance_start("getDBRow/perm");
     for(unsigned int t=0; t<c_test_retries; t++)
     {
-        generate_alias(rand()%c_num_aliases, alias);
-        generate_label(rand()%num_labels, label);
+        int name_idx = rand()%c_num_names;
+        generate_name(name_idx, name);
+        generate_label(name_idx/c_names_per_label, owner_label);
+        generate_label(rand()%num_labels, smack_label);
 
-        read_row_expect_success(alias, label);
+        read_row_expect_success(name, owner_label, smack_label);
     }
-    performance_stop(c_test_retries * c_num_aliases);
+    performance_stop(c_test_retries * c_num_names);
 }
 
 BOOST_AUTO_TEST_CASE(DBperfAliasRemoval)
 {
     // prepare data
-    generate_perf_DB(c_num_aliases, c_alias_per_label);
-    add_full_access_rights(c_num_aliases, c_alias_per_label);
+    generate_perf_DB(c_num_names, c_names_per_label);
+    add_full_access_rights(c_num_names, c_names_per_label);
 
     // actual test - random lookup
     performance_start("deleteDBRow");
-    std::string alias, label;
-    for(unsigned int t=0; t<c_num_aliases; t++)
+    Name name;
+    Label label;
+    for(unsigned int t=0; t<c_num_names; t++)
     {
-        generate_alias(t, alias);
-        generate_label(t/c_alias_per_label, label);
+        generate_name(t, name);
+        generate_label(t/c_names_per_label, label);
 
-        BOOST_REQUIRE_NO_THROW(m_db.deleteDBRow(alias, label));
+        BOOST_REQUIRE_NO_THROW(m_db.deleteDBRow(name, label, label));
     }
-    performance_stop(c_num_aliases);
+    performance_stop(c_num_names);
 
     // verify everything has been removed
-    unsigned int num_labels = c_num_aliases / c_alias_per_label;
+    unsigned int num_labels = c_num_names / c_names_per_label;
     for(unsigned int l=0; l<num_labels; l++)
     {
         generate_label(l, label);
-        AliasVector expect_no_data;
-        BOOST_REQUIRE_NO_THROW(m_db.getAliases(label, DBDataType::BINARY_DATA, expect_no_data));
+        LabelNameVector expect_no_data;
+        BOOST_REQUIRE_NO_THROW(m_db.getNames(label, DBDataType::BINARY_DATA, expect_no_data));
         BOOST_REQUIRE(0 == expect_no_data.size());
     }
 }
@@ -307,21 +318,21 @@ BOOST_AUTO_TEST_CASE(DBperfAliasRemoval)
 BOOST_AUTO_TEST_CASE(DBperfGetAliasList)
 {
     // prepare data
-    generate_perf_DB(c_num_aliases, c_alias_per_label);
-    add_full_access_rights(c_num_aliases, c_alias_per_label);
+    generate_perf_DB(c_num_names, c_names_per_label);
+    add_full_access_rights(c_num_names, c_names_per_label);
 
-    unsigned int num_labels = c_num_aliases / c_alias_per_label;
-    std::string label;
+    unsigned int num_labels = c_num_names / c_names_per_label;
+    Label label;
 
     // actual test - random lookup
-    performance_start("getAliases");
+    performance_start("getNames");
     for(unsigned int t=0; t<(c_test_retries/num_labels); t++)
     {
-        AliasVector ret_list;
+        LabelNameVector ret_list;
         generate_label(rand()%num_labels, label);
 
-        BOOST_REQUIRE_NO_THROW(m_db.getAliases(label, DBDataType::BINARY_DATA, ret_list));
-        BOOST_REQUIRE(c_num_aliases == ret_list.size());
+        BOOST_REQUIRE_NO_THROW(m_db.getNames(label, DBDataType::BINARY_DATA, ret_list));
+        BOOST_REQUIRE(c_num_names == ret_list.size());
         ret_list.clear();
     }
     performance_stop(c_test_retries/num_labels);