std::pair<typename Hash<TK>::Node*, bool> Hash<TK>::Insert( TK const& k )
{
std::pair<typename Hash<TK>::Node*, bool> rtv;
uint hashCode = (uint)GetHashCode( k );
uint mod = hashCode % (uint)buckets.Size();
auto node = buckets[ mod ];
while( node )
{
if( node->hash == hashCode && EqualsTo( node->key, k ) )
{
rtv.first = node;
rtv.second = false;
return rtv;
}
node = node->next;
};
auto n = (Node*)pool.Alloc();
n->next = buckets[ mod ];
n->hash = hashCode;
n->index = nodes.Size();
new ( &n->key ) TK( k );
buckets[ mod ] = n;
nodes.Push( n );
if( nodes.Size() == buckets.Size() ) Resize();
rtv.first = n;
rtv.second = true;
return rtv;
}
void IntelligentDocInfo::AddDocument(const CStdString& sDocId, int iRevision)
{
if(iRevision == 0)
ThrowException(_T("Can't add a document with revision zero."), -1);
if(sDocId.IsEmpty())
ThrowException(_T("Can't add a document with no Doc Id."), -1);
CStdString sDocumentId = PrepareDocId(sDocId);
int iHash = GetHashCode(sDocumentId);
m_mHashDocId[iHash].SetDocumentId(sDocumentId);
m_mHashDocId[iHash].SetDocumentChecksum(m_DocumentStore.GetFileChecksum());
std::vector<HashRevPair>::iterator it;
for(it = m_vHashRevision.begin(); it != m_vHashRevision.end(); ++it)
{
if(it->first == iHash)
{
m_vHashRevision.erase(it);
break;
}
}
while(m_vHashRevision.size() > NUMBER_OF_HASH_ENTRIES_TO_STORE)
m_vHashRevision.erase(m_vHashRevision.begin());
HashRevPair hrPair;
hrPair.first = iHash;
hrPair.second = iRevision;
m_vHashRevision.push_back(hrPair);
}
typename Hash<TK>::Node* Hash<TK>::Find( TK const& k )
{
uint hashCode = (uint)GetHashCode( k );
uint mod = hashCode % (uint)buckets.Size();
auto node = buckets[ mod ];
while( node )
{
if( node->hash == hashCode && EqualsTo( node->key, k ) ) return node;
node = node->next;
}
return nullptr;
}
bool Matcher::Equals(const std::shared_ptr<void> &obj) {
if(obj == nullptr || obj->GetType() != GetType() || obj->GetHashCode() != GetHashCode())
return false;
auto matcher = std::static_pointer_cast<Matcher>(obj);
if(!equalIndices(matcher->GetallOfIndices(), _allOfIndices))
return false;
if(!equalIndices(matcher->GetanyOfIndices(), _anyOfIndices))
return false;
if(!equalIndices(matcher->GetnoneOfIndices(), _noneOfIndices))
return false;
return true;
}
inline uint32 KS_DLL GetHashCode(const std::wstring & str)
{
return GetHashCode((const unsigned char*)str.c_str(), str.size() * sizeof(wchar_t));
}
/* convert normal file path to secure storage file path */
int ConvertFileName(int sender_pid, char* dest, const char* src, ssm_flag flag, const char* group_id)
{
char* if_pointer = NULL;
unsigned short h_code = 0;
unsigned short h_code2 = 0;
unsigned char path_hash[SHA_DIGEST_LENGTH + 1];
char s[33+1];
const char* dir = NULL;
char tmp_cmd[32] = {0, };
char tmp_buf[10] = {0, };
const unsigned char exe_path[256] = {0, };
FILE* fp_proc = NULL;
char* preserved_dir = NULL;
int is_dir_exist = -1;
if(!dest || !src)
{
SLOGE( "[%s] Parameter error in ConvertFileName()...\n", __func__);
return SS_FILE_OPEN_ERROR; // file related error
}
memset(tmp_cmd, 0x00, 32);
snprintf(tmp_cmd, 32, "/proc/%d/cmdline", sender_pid);
if(!(fp_proc = fopen(tmp_cmd, "r")))
{
SLOGE("[%s] file open error: [%s]", __func__, tmp_cmd);
return SS_FILE_OPEN_ERROR;
}
fgets((char*)exe_path, 256, fp_proc);
fclose(fp_proc);
if(!strncmp(group_id, "NOTUSED", 7)) // don't share
{
h_code2 = GetHashCode(exe_path);
memset(tmp_buf, 0x00, 10);
snprintf(tmp_buf, 10, "%u", h_code2);
dir = tmp_buf;
}
else // share
dir = group_id;
if_pointer = strrchr(src, '/');
if(flag == SSM_FLAG_DATA) // /opt/share/secure-storage/*
{
// check whether directory is exist or not
is_dir_exist = IsDirExist(SS_STORAGE_DEFAULT_PATH);
if (is_dir_exist == 0) // SS_STORAGE_FILE_PATH is not exist
{
SLOGI("[%s] directory [%s] is making now.\n", __func__, SS_STORAGE_DEFAULT_PATH);
if(mkdir(SS_STORAGE_DEFAULT_PATH, 0700) < 0) // fail to make directory
{
SLOGE("[%s] [%s] cannot be made\n", __func__, SS_STORAGE_DEFAULT_PATH);
return SS_FILE_OPEN_ERROR;
}
}
else if (is_dir_exist == -1) // Unknown error
{
SLOGE("[%s] Unknown error in the function IsDirExist().\n", __func__);
return SS_PARAM_ERROR;
}
// TBD
strncpy(dest, SS_STORAGE_DEFAULT_PATH, MAX_FILENAME_LEN - 1);
strncat(dest, dir, (strlen(dest) - 1));
strncat(dest, "/", 1);
// make directory
dest[strlen(SS_STORAGE_DEFAULT_PATH) + strlen(dir) + 2] = '\0';
is_dir_exist = IsDirExist(dest);
if(is_dir_exist == 0) // not exist
{
SLOGI("[%s] %s is making now.\n", __func__, dest);
if(mkdir(dest, 0700) < 0) // fail to make directory
{
SLOGE("[%s] [%s] cannot be made\n", __func__, dest);
return SS_FILE_OPEN_ERROR;
}
}
strncat(dest, if_pointer + 1, strlen(if_pointer) + 1);
strncat(dest, "_", 1);
SHA1((unsigned char*)src, (size_t)strlen(src), path_hash);
h_code = GetHashCode(path_hash);
memset(s, 0x00, 34);
snprintf(s, 34, "%u", h_code);
strncat(dest, s, strlen(s));
strncat(dest, SS_FILE_POSTFIX, strlen(SS_FILE_POSTFIX));
dest[strlen(SS_STORAGE_DEFAULT_PATH) + strlen(dir) + strlen(if_pointer) + strlen(s) + strlen(SS_FILE_POSTFIX) + 4] = '\0';
}
else if(flag == SSM_FLAG_SECRET_PRESERVE) // /tmp/csa/
{
preserved_dir = get_preserved_dir();
if(preserved_dir == NULL) // fail to get preserved directory
{
SLOGE("[%s] fail to get preserved dir\n", __func__);
return SS_FILE_OPEN_ERROR;
}
if(strncmp(src, preserved_dir, strlen(preserved_dir)) == 0) //src[0] == '/')
{
strncpy(dest, src, MAX_FILENAME_LEN - 1);
strncat(dest, SS_FILE_POSTFIX, strlen(SS_FILE_POSTFIX));
dest[strlen(src) + strlen(SS_FILE_POSTFIX)] = '\0';
}
else if(if_pointer != NULL) // absolute path == file
{
strncpy(dest, preserved_dir, MAX_FILENAME_LEN - 1);
strncat(dest, if_pointer + 1, strlen(if_pointer) + 1);
strncat(dest, SS_FILE_POSTFIX, strlen(SS_FILE_POSTFIX));
dest[strlen(preserved_dir) + strlen(if_pointer) + strlen(SS_FILE_POSTFIX) + 1] = '\0';
}
else // relative path == buffer
{
strncpy(dest, preserved_dir, MAX_FILENAME_LEN - 1);
strncat(dest, src, strlen(src));
strncat(dest, SS_FILE_POSTFIX, strlen(SS_FILE_POSTFIX));
dest[strlen(preserved_dir) + strlen(src) + strlen(SS_FILE_POSTFIX)] = '\0';
}
free(preserved_dir);
}
else if(flag == SSM_FLAG_SECRET_OPERATION) // /opt/share/secure-storage/
{
if(if_pointer != NULL) // absolute path == input is a file
{
// check whether directory is exist or not
is_dir_exist = IsDirExist(SS_STORAGE_DEFAULT_PATH);
if (is_dir_exist == 0) // SS_STORAGE_FILE_PATH is not exist
{
SLOGI("[%s] %s is making now.\n", __func__, SS_STORAGE_DEFAULT_PATH);
if(mkdir(SS_STORAGE_DEFAULT_PATH, 0700) < 0) // fail to make directory
{
SLOGE("[%s] [%s] cannnot be made\n", __func__, SS_STORAGE_DEFAULT_PATH);
return SS_FILE_OPEN_ERROR;
}
}
else if (is_dir_exist == -1) // Unknown error
{
SLOGE("[%s] Unknown error in the function IsDirExist().\n", __func__);
return SS_PARAM_ERROR;
}
strncpy(dest, SS_STORAGE_DEFAULT_PATH, MAX_FILENAME_LEN - 1);
strncat(dest, dir, strlen(dir));
strncat(dest, "/", 1);
// make directory
dest[strlen(SS_STORAGE_DEFAULT_PATH) + strlen(dir) + 2] = '\0';
is_dir_exist = IsDirExist(dest);
if(is_dir_exist == 0) // not exist
{
SLOGI("[%s] %s is making now.\n", __func__, dest);
if(mkdir(dest, 0700) < 0)
{
SLOGE("[%s] [%s] cannot be made\n", __func__, dest);
return SS_FILE_OPEN_ERROR;
}
}
strncat(dest, if_pointer + 1, strlen(if_pointer) + 1);
strncat(dest, "_", 1);
SHA1((unsigned char*)src, (size_t)strlen(src), path_hash);
h_code = GetHashCode(path_hash);
memset(s, 0x00, 34);
snprintf(s, 34, "%u", h_code);
strncat(dest, s, strlen(s));
strncat(dest, SS_FILE_POSTFIX, strlen(SS_FILE_POSTFIX));
dest[strlen(SS_STORAGE_DEFAULT_PATH) + strlen(dir) + strlen(if_pointer) + strlen(s) + strlen(SS_FILE_POSTFIX) + 4] = '\0';
}
else // relative path == input is a buffer
{
// check whether directory is exist or not
is_dir_exist = IsDirExist(SS_STORAGE_DEFAULT_PATH);
if (is_dir_exist == 0) // SS_STORAGE_BUFFER_PATH is not exist
{
SLOGI("[%s] %s is making now.\n", __func__, SS_STORAGE_DEFAULT_PATH);
if(mkdir(SS_STORAGE_DEFAULT_PATH, 0700) < 0)
{
SLOGE("[%s] [%s] cannot be made\n", __func__, SS_STORAGE_DEFAULT_PATH);
return SS_FILE_OPEN_ERROR;
}
}
else if (is_dir_exist == -1) // Unknown error
{
SLOGE("[%s] Unknown error in the function IsDirExist().\n", __func__);
return SS_PARAM_ERROR;
}
strncpy(dest, SS_STORAGE_DEFAULT_PATH, MAX_FILENAME_LEN - 1);
strncat(dest, dir, strlen(dir));
strncat(dest, "/", 1);
// make directory
dest[strlen(SS_STORAGE_DEFAULT_PATH) + strlen(dir) + 2] = '\0';
is_dir_exist = IsDirExist(dest);
if(is_dir_exist == 0) // not exist
{
SLOGI("[%s] %s is making now.\n", __func__, dest);
if(mkdir(dest, 0700) < 0)
{
SLOGE("[%s] [%s] cannot be made\n", __func__, dest);
return SS_FILE_OPEN_ERROR;
}
}
strncat(dest, src, strlen(src));
strncat(dest, SS_FILE_POSTFIX, strlen(SS_FILE_POSTFIX));
dest[strlen(SS_STORAGE_DEFAULT_PATH) + strlen(dir) + strlen(src) + strlen(SS_FILE_POSTFIX) + 2] = '\0';
}
}
else
{
SLOGE("[%s] flag mispatch. cannot convert file name.\n", __func__);
return SS_PARAM_ERROR;
}
return 1;
}
