/*
* @file certificate_dao.cpp
* @author Leerang Song (leerang.song@samsung.com)
+ * @author Wojciech Kosowicz (w.kosowicz@samsung.com
* @version 1.0
* @brief This file contains the definition of certificate dao class.
*/
#include <dpl/wrt-dao-ro/global_config.h>
#include <dpl/wrt-dao-ro/common_dao_types.h>
#include <sys/stat.h>
+#include <dpl/log/wrt_log.h>
+#include <db-util.h>
#include <fstream>
/* GCC versions 4.7 had changes to the C++ standard. It
* no longer includes <unistd.h> to remove namespace pollution.
#define SQL_CONNECTION_EXCEPTION_HANDLER_END(message) \
Catch(DPL::DB::SqlConnection::Exception::Base) { \
- LogError(message); \
+ WrtLogE(message); \
ReThrowMsg(CertificateDAO::Exception::DatabaseError, \
message); \
}
const char* const CERTIFICATE_DB_SQL_PATH =
"/usr/share/wrt-engine/certificate_db.sql";
const char* const CERTIFICATE_DATABASE_JOURNAL_FILENAME = "-journal";
+const char* const SELECT_CERTIFICATE_DATA_LIST =
+ "select certificate from CertificateInfo";
+const char* const SELECT_CERTIFICATE_GET_RESULT =
+ "select result from CertificateInfo"
+ " where certificate=?";
+const char* const INSERT_CERTIFICATE =
+ "insert into CertificateInfo (certificate, result)"
+ " values (?, ?)";
+const char* const UPDATE_CERTIFICATE =
+ "update CertificateInfo set result=?"
+ " where certificate=?";
+const char* const DELETE_CERTIFICATE =
+ "delete from CertificateInfo"
+ " where certificate=?";
+const char* const DELETE_CERTIFICATE_BY_RESULT =
+ "delete from CertificateInfo"
+ " where result=?";
const int WEB_APPLICATION_UID = 5000;
const int WEB_APPLICATION_GUID = 5000;
struct stat buffer;
if (stat(databasePath.c_str(), &buffer) != 0) {
//Create fresh database
- LogDebug("Creating database " << databasePath);
+ WrtLogD("Creating database %s", databasePath.c_str());
std::fstream file;
file.open(CERTIFICATE_DB_SQL_PATH, std::ios_base::in);
}
}
-CertificateDAO::CertificateDAO(const WrtDB::TizenPkgId &pkgName) :
- m_certificateDBPath(createDatabasePath(pkgName)),
- m_certificateDBInterface(m_certificateDBPath, CERTIFICATE_DB_TYPE)
+CertificateDAO::CertificateDAO(const WrtDB::TizenPkgId &pkgName)
{
- checkDatabase(m_certificateDBPath);
- m_certificateDBInterface.AttachToThread(CERTIFICATE_DB_OPTION);
+ std::string dbPath = createDatabasePath(pkgName);
+ checkDatabase(dbPath);
+ if (DB_UTIL_OK != db_util_open_with_options(
+ dbPath.c_str(),
+ &m_databaseInterface,
+ SQLITE_OPEN_READWRITE | SQLITE_OPEN_NOMUTEX,
+ NULL)) {
+ WrtLogE("Cannot open database. %s", sqlite3_errmsg(m_databaseInterface));
+ ThrowMsg(CertificateDAO::Exception::DatabaseError, "Cannot open database");
+ }
}
CertificateDAO::~CertificateDAO()
{
- m_certificateDBInterface.DetachFromThread();
}
CertificateDataList CertificateDAO::getCertificateDataList(void)
{
+ std::lock_guard<std::mutex> lock(m_dbLock);
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- CertificateDataList list;
- CERTIFICATE_DB_SELECT(select,
- CertificateInfo,
- &m_certificateDBInterface);
- typedef std::list<CertificateInfo::Row> RowList;
- RowList rowList = select->GetRowList();
+ sqlite3_stmt* stmt = sqlPrepare(SELECT_CERTIFICATE_DATA_LIST);
+ int rw = sqlite3_step(stmt);
- FOREACH(it, rowList) {
+ CertificateDataList list;
+ while (SQLITE_ROW == rw) {
+ //Read from row
list.push_back(
CertificateDataPtr(
- new CertificateData(it->Get_certificate())));
+ new CertificateData(sqlite3_column_string(stmt, 0))));
+ //Next row
+ rw = sqlite3_step(stmt);
+ }
+ releaseStatement(stmt);
+ if (SQLITE_DONE != rw) {
+ //Error occurede
+ WrtLogE("sqlite3_step error. %s", sqlite3_errmsg(m_databaseInterface));
+ ThrowMsg(CertificateDAO::Exception::DatabaseError, "getSecurityOriginDataList fail");
}
return list;
}
Result CertificateDAO::getResult(
const CertificateData &certificateData)
{
+ std::lock_guard<std::mutex> lock(m_dbLock);
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- CERTIFICATE_DB_SELECT(select,
- CertificateInfo,
- &m_certificateDBInterface);
- select->Where(
- Equals<CertificateInfo::certificate>(certificateData.certificate));
- CertificateInfo::Select::RowList rows = select->GetRowList();
-
- if (rows.empty()) {
- return RESULT_UNKNOWN;
+ Result retval = RESULT_UNKNOWN;
+ sqlite3_stmt* stmt = sqlPrepare(SELECT_CERTIFICATE_GET_RESULT);
+ sqlBind(stmt, 1, certificateData.certificate);
+ int rw = sqlite3_step(stmt);
+ if (SQLITE_ROW == rw) {
+ retval = static_cast<Result>(sqlite3_column_int(stmt, 0));
+ }
+ releaseStatement(stmt);
+ if (SQLITE_DONE != rw && SQLITE_ROW != rw) {
+ WrtLogE("sqlite3_step error. %s", sqlite3_errmsg(m_databaseInterface));
+ ThrowMsg(CertificateDAO::Exception::DatabaseError, "getResult fail");
}
- CertificateInfo::Row row = rows.front();
- return static_cast<Result>(row.Get_result());
+ return retval;
}
- SQL_CONNECTION_EXCEPTION_HANDLER_END(
- "Failed to get result for security certiInfo")
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("getResult error")
}
void CertificateDAO::setCertificateData(const CertificateData &certificateData,
{
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- ScopedTransaction transaction(&m_certificateDBInterface);
- CertificateInfo::Row row;
- row.Set_certificate(certificateData.certificate);
- row.Set_result(result);
-
if (true == hasResult(certificateData)) {
- CERTIFICATE_DB_UPDATE(update,
- CertificateInfo,
- &m_certificateDBInterface);
- update->Values(row);
- update->Execute();
+ std::lock_guard<std::mutex> lock(m_dbLock);
+ sqlite3_stmt* stmt = sqlPrepare(UPDATE_CERTIFICATE);
+ sqlBind(stmt, 1, static_cast<int>(result));
+ sqlBind(stmt, 2, certificateData.certificate);
+ int rw = sqlite3_step(stmt);
+ releaseStatement(stmt);
+ if (SQLITE_DONE != rw) {
+ WrtLogE("sqlite3_step error. %s", sqlite3_errmsg(m_databaseInterface));
+ ThrowMsg(CertificateDAO::Exception::DatabaseError, "updateData fail");
+ }
} else {
- CERTIFICATE_DB_INSERT(insert,
- CertificateInfo,
- &m_certificateDBInterface);
- insert->Values(row);
- insert->Execute();
+ std::lock_guard<std::mutex> lock(m_dbLock);
+ sqlite3_stmt* stmt = sqlPrepare(INSERT_CERTIFICATE);
+ sqlBind(stmt, 1, certificateData.certificate);
+ sqlBind(stmt, 2, static_cast<int>(result));
+ int rw = sqlite3_step(stmt);
+ releaseStatement(stmt);
+ if (SQLITE_DONE != rw)
+ {
+ WrtLogE("sqlite3_step error. %s", sqlite3_errmsg(m_databaseInterface));
+ ThrowMsg(CertificateDAO::Exception::DatabaseError, "insertData fail");
+ }
}
- transaction.Commit();
}
SQL_CONNECTION_EXCEPTION_HANDLER_END("Fail to set security certiInfo data")
}
{
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- ScopedTransaction transaction(&m_certificateDBInterface);
-
- if (true == hasResult(certificateData)) {
- CERTIFICATE_DB_DELETE(del,
- CertificateInfo,
- &m_certificateDBInterface)
- del->Where(
- Equals<CertificateInfo::certificate>(certificateData.certificate));
- del->Execute();
- transaction.Commit();
+ sqlite3_stmt* stmt = sqlPrepare(DELETE_CERTIFICATE);
+ sqlBind(stmt, 1, certificateData.certificate);
+ int rw = sqlite3_step(stmt);
+ releaseStatement(stmt);
+ if (SQLITE_DONE != rw) {
+ WrtLogE("sqlite3_step error. %s", sqlite3_errmsg(m_databaseInterface));
+ ThrowMsg(CertificateDAO::Exception::DatabaseError, "failed to delete certificate");
}
}
- SQL_CONNECTION_EXCEPTION_HANDLER_END("Fail to set certiInfo data")
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("failed to delete certificate")
}
void CertificateDAO::removeCertificateData(const Result result)
{
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- ScopedTransaction transaction(&m_certificateDBInterface);
- CERTIFICATE_DB_DELETE(del,
- CertificateInfo,
- &m_certificateDBInterface)
- del->Where(Equals<CertificateInfo::result>(result));
- del->Execute();
- transaction.Commit();
+ std::lock_guard<std::mutex> lock(m_dbLock);
+ sqlite3_stmt* stmt = sqlPrepare(DELETE_CERTIFICATE_BY_RESULT);
+ sqlBind(stmt, 1, static_cast<int>(result));
+ int rw = sqlite3_step(stmt);
+ releaseStatement(stmt);
+ if (SQLITE_DONE != rw) {
+ WrtLogE("sqlite3_step error. %s", sqlite3_errmsg(m_databaseInterface));
+ ThrowMsg(CertificateDAO::Exception::DatabaseError, "failed to delete certificate");
+ }
}
- SQL_CONNECTION_EXCEPTION_HANDLER_END("Fail to remove data by result")
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("failed to delete certificate")
}
bool CertificateDAO::hasResult(const CertificateData &certificateData)
return (res != RESULT_UNKNOWN);
}
-#undef SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
-#undef SQL_CONNECTION_EXCEPTION_HANDLER_END
} // namespace CertificateDB
projects / framework / web / wrt-commons.git / blobdiff