X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=resource%2Fcsdk%2Fsecurity%2Fprovisioning%2Fsrc%2Fprovisioningdatabasemanager.c;h=93ce7de0437adfae161aa971c7e94c25172c113d;hb=refs%2Fchanges%2F87%2F213987%2F1;hp=0d3182e63d2d4f792ace0ad283fc3c10d30c4461;hpb=66ea6de691f2f58652110c9c9cfc9f46e435f669;p=platform%2Fupstream%2Fiotivity.git diff --git a/resource/csdk/security/provisioning/src/provisioningdatabasemanager.c b/resource/csdk/security/provisioning/src/provisioningdatabasemanager.c old mode 100755 new mode 100644 index 0d3182e..93ce7de --- a/resource/csdk/security/provisioning/src/provisioningdatabasemanager.c +++ b/resource/csdk/security/provisioning/src/provisioningdatabasemanager.c @@ -30,14 +30,12 @@ #include "pmutility.h" #include "oic_string.h" #include "utlist.h" +#include "srmutility.h" #define DB_FILE "PDM.db" -#define TAG "PDM" - -#define PDM_STALE_STATE 1 -#define PDM_ACTIVE_STATE 0 +#define TAG "OIC_PDM" #define PDM_FIRST_INDEX 0 #define PDM_SECOND_INDEX 1 @@ -46,8 +44,10 @@ #define PDM_BIND_INDEX_SECOND 2 #define PDM_BIND_INDEX_THIRD 3 +#define HEX_UUID_STR_LENGTH (UUID_LENGTH*2 + 4) + #define PDM_CREATE_T_DEVICE_LIST "create table T_DEVICE_LIST(ID INTEGER PRIMARY KEY AUTOINCREMENT,\ - UUID BLOB NOT NULL UNIQUE);" + UUID BLOB NOT NULL UNIQUE, STATE INT NOT NULL);" #define PDM_CREATE_T_DEVICE_LINK "create table T_DEVICE_LINK_STATE(ID INT NOT NULL, ID2 INT NOT \ NULL,STATE INT NOT NULL, PRIMARY KEY (ID, ID2));" @@ -55,30 +55,52 @@ * Macro to verify sqlite success. * eg: VERIFY_NON_NULL(TAG, ptrData, ERROR,OC_STACK_ERROR); */ -#define PDM_VERIFY_SQLITE_OK(tag, arg, logLevel, retValue) do{ if (SQLITE_OK != (arg)) \ - { OC_LOG_V((logLevel), tag, "Error in " #arg ", Error Message: %s", \ - sqlite3_errmsg(g_db)); return retValue; }}while(0) +#define PDM_VERIFY_SQLITE_OK(tag, arg, stmt, logLevel, retValue) do{ if (SQLITE_OK != (arg)) \ + { OIC_LOG_V((logLevel), tag, "Error in " #arg ", Error Message: %s", \ + sqlite3_errmsg(g_db)); sqlite3_finalize(stmt); return retValue; }}while(0) + #define PDM_SQLITE_TRANSACTION_BEGIN "BEGIN TRANSACTION;" #define PDM_SQLITE_TRANSACTION_COMMIT "COMMIT;" #define PDM_SQLITE_TRANSACTION_ROLLBACK "ROLLBACK;" #define PDM_SQLITE_GET_STALE_INFO "SELECT ID,ID2 FROM T_DEVICE_LINK_STATE WHERE STATE = ?" -#define PDM_SQLITE_INSERT_T_DEVICE_LIST "INSERT INTO T_DEVICE_LIST VALUES(?,?)" -#define PDM_SQLITE_GET_ID "SELECT ID FROM T_DEVICE_LIST WHERE UUID like ?" +#define PDM_SQLITE_INSERT_T_DEVICE_LIST "INSERT INTO T_DEVICE_LIST VALUES(?,?,?)" +#define PDM_SQLITE_GET_ID "SELECT ID FROM T_DEVICE_LIST WHERE UUID = " +#define PDM_SQLITE_GET_ID_SIZE (int)sizeof(PDM_SQLITE_GET_ID) #define PDM_SQLITE_INSERT_LINK_DATA "INSERT INTO T_DEVICE_LINK_STATE VALUES(?,?,?)" #define PDM_SQLITE_DELETE_LINK "DELETE FROM T_DEVICE_LINK_STATE WHERE ID = ? and ID2 = ?" #define PDM_SQLITE_DELETE_DEVICE_LINK "DELETE FROM T_DEVICE_LINK_STATE WHERE ID = ? or ID2 = ?" #define PDM_SQLITE_DELETE_DEVICE "DELETE FROM T_DEVICE_LIST WHERE ID = ?" +#define PDM_SQLITE_DELETE_DEVICE_WITH_STATE "DELETE FROM T_DEVICE_LIST WHERE STATE= ?" #define PDM_SQLITE_UPDATE_LINK "UPDATE T_DEVICE_LINK_STATE SET STATE = ? WHERE ID = ? and ID2 = ?" -#define PDM_SQLITE_LIST_ALL_UUID "SELECT UUID FROM T_DEVICE_LIST" -#define PDM_SQLITE_GET_UUID "SELECT UUID FROM T_DEVICE_LIST WHERE ID = ?" -#define PDM_SQLITE_GET_LINKED_DEVICES "SELECT ID,ID2 FROM T_DEVICE_LINK_STATE WHERE ID = ? or ID2 = ?" +#define PDM_SQLITE_LIST_ALL_UUID "SELECT UUID FROM T_DEVICE_LIST WHERE STATE = 0" +#define PDM_SQLITE_GET_UUID "SELECT UUID,STATE FROM T_DEVICE_LIST WHERE ID = ?" +#define PDM_SQLITE_GET_LINKED_DEVICES "SELECT ID,ID2 FROM T_DEVICE_LINK_STATE WHERE \ + (ID = ? or ID2 = ?) and state = 0" +#define PDM_SQLITE_GET_DEVICE_LINKS "SELECT ID,ID2 FROM T_DEVICE_LINK_STATE WHERE \ + ID = ? and ID2 = ? and state = 0" +#define PDM_SQLITE_UPDATE_DEVICE "UPDATE T_DEVICE_LIST SET STATE = ? WHERE UUID = " +#define PDM_SQLITE_UPDATE_DEVICE_SIZE (int)sizeof(PDM_SQLITE_UPDATE_DEVICE) +#define PDM_SQLITE_GET_DEVICE_STATUS "SELECT STATE FROM T_DEVICE_LIST WHERE UUID = " +#define PDM_SQLITE_GET_DEVICE_STATUS_SIZE (int)sizeof(PDM_SQLITE_GET_DEVICE_STATUS) +#define PDM_SQLITE_UPDATE_LINK_STALE_FOR_STALE_DEVICE "UPDATE T_DEVICE_LINK_STATE SET STATE = 1\ + WHERE ID = ? or ID2 = ?" +#define OTM_CREATE_TABLE "CREATE TABLE IF NOT EXISTS otm(\ +id INTEGER PRIMARY KEY AUTOINCREMENT,\ +owner TEXT,\ +uuid TEXT NOT NULL UNIQUE,\ +state INT DEFAULT(1) NOT NULL,\ +time TIMESTAMP DEFAULT(datetime(\'now\',\'localtime\')) NOT NULL);" + +#define OTM_INSERT "INSERT INTO otm(owner,uuid) VALUES(?,?)" +#define OTM_UPDATE "UPDATE otm SET state=? WHERE uuid=?" +#define OTM_GET_STATE "SELECT state FROM otm WHERE uuid=?" #define ASCENDING_ORDER(id1, id2) do{if( (id1) > (id2) )\ { int temp; temp = id1; id1 = id2; id2 = temp; }}while(0) #define CHECK_PDM_INIT(tag) do{if(true != gInit)\ - { OC_LOG(ERROR, (tag), "PDB is not initialized"); \ + { OIC_LOG(ERROR, (tag), "PDB is not initialized"); \ return OC_STACK_PDM_IS_NOT_INITIALIZED; }}while(0) static sqlite3 *g_db = NULL; @@ -89,20 +111,28 @@ static bool gInit = false; /* Only if we can open sqlite db successfully, gInit */ static OCStackResult createDB(const char* path) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); int result = 0; result = sqlite3_open_v2(path, &g_db, SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE, NULL); - PDM_VERIFY_SQLITE_OK(TAG, result, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, result, NULL, ERROR, OC_STACK_ERROR); result = sqlite3_exec(g_db, PDM_CREATE_T_DEVICE_LIST, NULL, NULL, NULL); - PDM_VERIFY_SQLITE_OK(TAG, result, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, result, NULL, ERROR, OC_STACK_ERROR); - OC_LOG(INFO, TAG, "Created T_DEVICE_LIST"); + OIC_LOG(INFO, TAG, "Created T_DEVICE_LIST"); result = sqlite3_exec(g_db, PDM_CREATE_T_DEVICE_LINK, NULL, NULL, NULL); - PDM_VERIFY_SQLITE_OK(TAG, result, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, result, NULL, ERROR, OC_STACK_ERROR); + + OIC_LOG(INFO, TAG, "Created T_DEVICE_LINK_STATE"); + + result = sqlite3_exec(g_db, OTM_CREATE_TABLE, NULL, NULL, NULL); + PDM_VERIFY_SQLITE_OK(TAG, result, NULL, ERROR, OC_STACK_ERROR); - OC_LOG(INFO, TAG, "Created T_DEVICE_LINK_STATE"); gInit = true; + + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); + return OC_STACK_OK; } @@ -114,7 +144,7 @@ static OCStackResult begin() { int res = 0; res = sqlite3_exec(g_db, PDM_SQLITE_TRANSACTION_BEGIN, NULL, NULL, NULL); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, NULL, ERROR, OC_STACK_ERROR); return OC_STACK_OK; } @@ -125,7 +155,7 @@ static OCStackResult commit() { int res = 0; res = sqlite3_exec(g_db, PDM_SQLITE_TRANSACTION_COMMIT, NULL, NULL, NULL); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, NULL, ERROR, OC_STACK_ERROR); return OC_STACK_OK; } @@ -136,11 +166,47 @@ static OCStackResult rollback() { int res = 0; res = sqlite3_exec(g_db, PDM_SQLITE_TRANSACTION_ROLLBACK, NULL, NULL, NULL); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, NULL, ERROR, OC_STACK_ERROR); return OC_STACK_OK; } /** + * Function to convert UUID into hex representation + */ +static bool convertUuidToHexString(const OicUuid_t* uuidOfDevice, char* uuidHexString) +{ + if(NULL == uuidOfDevice || NULL == uuidHexString) + { + OIC_LOG(ERROR, TAG, "convertUuidToHexString : Invalid param"); + return false; + } + + char *strUUID = NULL; + OCStackResult ret = ConvertUuidToStr(uuidOfDevice, &strUUID); + if(OC_STACK_OK != ret) + { + OIC_LOG(ERROR, TAG, "SendDeleteCredentialRequest : Failed to canonical UUID encoding"); + return OC_STACK_ERROR; + + } + char* headPtr = strUUID; + strncat(uuidHexString, "x'",2); + while(('\0' != *headPtr)) + { + char tmp = *headPtr; + if('-' != tmp) + { + strncat(uuidHexString, &tmp,1); + } + headPtr++; + } + strncat(uuidHexString, "'",1); + + OICFree(strUUID); + return true; +} + +/** * Error log callback called by SQLite stack in case of error */ void errLogCallback(void *pArg, int iErrCode, const char *zMsg) @@ -148,16 +214,18 @@ void errLogCallback(void *pArg, int iErrCode, const char *zMsg) (void) pArg; (void) iErrCode; (void) zMsg; - OC_LOG_V(DEBUG,TAG, "(%d) %s", iErrCode, zMsg); + OIC_LOG_V(DEBUG,TAG, "%s : (%d) %s", __func__, iErrCode, zMsg); } OCStackResult PDMInit(const char *path) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + int rc; const char *dbPath = NULL; if (SQLITE_OK != sqlite3_config(SQLITE_CONFIG_LOG, errLogCallback, NULL)) { - OC_LOG(INFO, TAG, "Unable to enable debug log of sqlite"); + OIC_LOG(INFO, TAG, "Unable to enable debug log of sqlite"); } if (NULL == path || !*path) @@ -171,16 +239,177 @@ OCStackResult PDMInit(const char *path) rc = sqlite3_open_v2(dbPath, &g_db, SQLITE_OPEN_READWRITE, NULL); if (SQLITE_OK != rc) { - OC_LOG_V(INFO, TAG, "ERROR: Can't open database: %s", sqlite3_errmsg(g_db)); - return createDB(dbPath); + OIC_LOG_V(INFO, TAG, "ERROR: Can't open database: %s", sqlite3_errmsg(g_db)); + sqlite3_close(g_db); + OCStackResult ret = createDB(dbPath); + if (OC_STACK_OK != ret) + { + sqlite3_close(g_db); + } + return ret; } + + rc = sqlite3_exec(g_db, OTM_CREATE_TABLE, NULL, NULL, NULL); + PDM_VERIFY_SQLITE_OK(TAG, rc, NULL, ERROR, OC_STACK_ERROR); + gInit = true; + + /* + * Remove PDM_DEVICE_INIT status devices. + * PDM_DEVICE_INIT means that the OTM process is in progress. + * PDM_DEVICE_INIT state device can be existed when the program is terminated during the OTM process in progress. + * For this reason, PDM_DEVICE_INIT devices should be removed at PDM initialization time. + */ + if(OC_STACK_OK != PDMDeleteDeviceWithState(PDM_DEVICE_INIT)) + { + OIC_LOG_V(WARNING, TAG, "Failed to delete init state devices."); + } + + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); + return OC_STACK_OK; } +OCStackResult OTMStart(const OicUuid_t *uuid, const OicUuid_t *owner) +{ + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + + CHECK_PDM_INIT(TAG); + + if (NULL == uuid || NULL == owner) + { + return OC_STACK_INVALID_PARAM; + } + + sqlite3_stmt *stmt = 0; + int res =0; + char *uuidStr = NULL; + OCStackResult ret = OC_STACK_OK; + + res = sqlite3_prepare_v2(g_db, OTM_INSERT, strlen(OTM_INSERT) + 1, &stmt, NULL); + PDM_VERIFY_SQLITE_OK(TAG, res, NULL, ERROR, OC_STACK_ERROR); + + ConvertUuidToStr(owner, &uuidStr); + + res = sqlite3_bind_text(stmt, 1, uuidStr, strlen(uuidStr), SQLITE_TRANSIENT); + PDM_VERIFY_SQLITE_OK(TAG, res, NULL, ERROR, OC_STACK_ERROR); + + OICFree(uuidStr); + uuidStr = NULL; + ConvertUuidToStr(uuid, &uuidStr); + + res = sqlite3_bind_text(stmt, 2, uuidStr, strlen(uuidStr), SQLITE_TRANSIENT); + PDM_VERIFY_SQLITE_OK(TAG, res, NULL, ERROR, OC_STACK_ERROR); + + OICFree(uuidStr); + + res = sqlite3_step(stmt); + if (SQLITE_DONE != res) + { + if (SQLITE_CONSTRAINT == res) + { + int state; + if(OC_STACK_OK == OTMGetState(uuid, &state) && 1 == state) + { + OIC_LOG_V(WARNING, TAG, "%s OTM already started", __func__); + ret = OC_STACK_DUPLICATE_UUID; + } + } + else + { + ret = OC_STACK_ERROR; + } + } + sqlite3_finalize(stmt); + + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); + return ret; +} + +OCStackResult OTMSetState(const OicUuid_t *uuid, int state) +{ + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + + CHECK_PDM_INIT(TAG); + + if (NULL == uuid) + { + return OC_STACK_INVALID_PARAM; + } + + sqlite3_stmt *stmt = 0; + int res = 0 ; + char *uuidStr = NULL; + + res = sqlite3_prepare_v2(g_db, OTM_UPDATE, strlen(OTM_UPDATE) + 1, &stmt, NULL); + PDM_VERIFY_SQLITE_OK(TAG, res, NULL, ERROR, OC_STACK_ERROR); + + res = sqlite3_bind_int(stmt, 1, state); + PDM_VERIFY_SQLITE_OK(TAG, res, NULL, ERROR, OC_STACK_ERROR); + + ConvertUuidToStr(uuid, &uuidStr); + + res = sqlite3_bind_text(stmt, 2, uuidStr, strlen(uuidStr), SQLITE_TRANSIENT); + PDM_VERIFY_SQLITE_OK(TAG, res, NULL, ERROR, OC_STACK_ERROR); + + OICFree(uuidStr); + + if (SQLITE_DONE != sqlite3_step(stmt)) + { + OIC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db)); + sqlite3_finalize(stmt); + return OC_STACK_ERROR; + } + sqlite3_finalize(stmt); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); + return OC_STACK_OK; +} + +OCStackResult OTMStop(const OicUuid_t *uuid) +{ + return OTMSetState(uuid, 2); +} + +OCStackResult OTMGetState(const OicUuid_t *uuid, int *state) +{ + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + + CHECK_PDM_INIT(TAG); + + if (NULL == uuid) + { + return OC_STACK_INVALID_PARAM; + } + + sqlite3_stmt *stmt = 0; + int res = 0; + char *uuidStr = NULL; + OCStackResult ret = OC_STACK_ERROR; + + res = sqlite3_prepare_v2(g_db, OTM_GET_STATE, strlen(OTM_GET_STATE) + 1, &stmt, NULL); + PDM_VERIFY_SQLITE_OK(TAG, res, NULL, ERROR, OC_STACK_ERROR); + + ConvertUuidToStr(uuid, &uuidStr); + res = sqlite3_bind_text(stmt, 1, uuidStr, strlen(uuidStr), SQLITE_TRANSIENT); + PDM_VERIFY_SQLITE_OK(TAG, res, NULL, ERROR, OC_STACK_ERROR); + + if (SQLITE_ROW == sqlite3_step(stmt)) + { + *state = sqlite3_column_int(stmt, 1); + OIC_LOG_V(DEBUG, TAG, "%s state is %d", uuidStr, *state); + ret = OC_STACK_OK; + } + + OICFree(uuidStr); + sqlite3_finalize(stmt); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); + return ret; +} OCStackResult PDMAddDevice(const OicUuid_t *UUID) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + CHECK_PDM_INIT(TAG); if (NULL == UUID) { @@ -191,10 +420,13 @@ OCStackResult PDMAddDevice(const OicUuid_t *UUID) int res =0; res = sqlite3_prepare_v2(g_db, PDM_SQLITE_INSERT_T_DEVICE_LIST, strlen(PDM_SQLITE_INSERT_T_DEVICE_LIST) + 1, &stmt, NULL); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); res = sqlite3_bind_blob(stmt, PDM_BIND_INDEX_SECOND, UUID, UUID_LENGTH, SQLITE_STATIC); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); + + res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_THIRD, PDM_DEVICE_INIT); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); res = sqlite3_step(stmt); if (SQLITE_DONE != res) @@ -202,15 +434,17 @@ OCStackResult PDMAddDevice(const OicUuid_t *UUID) if (SQLITE_CONSTRAINT == res) { //new OCStack result code - OC_LOG_V(ERROR, TAG, "Error Occured: %s",sqlite3_errmsg(g_db)); + OIC_LOG_V(ERROR, TAG, "Error Occured: %s",sqlite3_errmsg(g_db)); sqlite3_finalize(stmt); return OC_STACK_DUPLICATE_UUID; } - OC_LOG_V(ERROR, TAG, "Error Occured: %s",sqlite3_errmsg(g_db)); + OIC_LOG_V(ERROR, TAG, "Error Occured: %s",sqlite3_errmsg(g_db)); sqlite3_finalize(stmt); return OC_STACK_ERROR; } sqlite3_finalize(stmt); + + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); return OC_STACK_OK; } @@ -219,24 +453,39 @@ OCStackResult PDMAddDevice(const OicUuid_t *UUID) */ static OCStackResult getIdForUUID(const OicUuid_t *UUID , int *id) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + sqlite3_stmt *stmt = 0; int res = 0; - res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_ID, strlen(PDM_SQLITE_GET_ID) + 1, &stmt, NULL); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + char sqlStat[PDM_SQLITE_GET_ID_SIZE - 1 + HEX_UUID_STR_LENGTH]; + char hexUUID[HEX_UUID_STR_LENGTH]; - res = sqlite3_bind_blob(stmt, PDM_BIND_INDEX_FIRST, UUID, UUID_LENGTH, SQLITE_STATIC); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + memset(sqlStat, 0, sizeof(sqlStat)); + strncpy(sqlStat, PDM_SQLITE_GET_ID, PDM_SQLITE_GET_ID_SIZE - 1); + memset(hexUUID, 0, sizeof(hexUUID)); - OC_LOG(DEBUG, TAG, "Binding Done"); - while (SQLITE_ROW == sqlite3_step(stmt)) + if (!convertUuidToHexString(UUID, hexUUID)) + { + return OC_STACK_ERROR; + } + + strncpy(sqlStat + PDM_SQLITE_GET_ID_SIZE - 1, hexUUID, HEX_UUID_STR_LENGTH); + res = sqlite3_prepare_v2(g_db, sqlStat, (int)sizeof(sqlStat), &stmt, 0); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); + + if (SQLITE_ROW == sqlite3_step(stmt)) { int tempId = sqlite3_column_int(stmt, PDM_FIRST_INDEX); - OC_LOG_V(DEBUG, TAG, "ID is %d", tempId); + OIC_LOG_V(DEBUG, TAG, "ID is %d", tempId); *id = tempId; sqlite3_finalize(stmt); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); return OC_STACK_OK; } + sqlite3_finalize(stmt); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); + return OC_STACK_INVALID_PARAM; } @@ -245,31 +494,43 @@ static OCStackResult getIdForUUID(const OicUuid_t *UUID , int *id) */ OCStackResult PDMIsDuplicateDevice(const OicUuid_t* UUID, bool *result) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); CHECK_PDM_INIT(TAG); if (NULL == UUID || NULL == result) { - OC_LOG(ERROR, TAG, "UUID or result is NULL"); + OIC_LOG(ERROR, TAG, "UUID or result is NULL"); return OC_STACK_INVALID_PARAM; } sqlite3_stmt *stmt = 0; int res = 0; - res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_ID, strlen(PDM_SQLITE_GET_ID) + 1, &stmt, NULL); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + char sqlStat[PDM_SQLITE_GET_ID_SIZE - 1 + HEX_UUID_STR_LENGTH]; + char hexUUID[HEX_UUID_STR_LENGTH]; + + memset(sqlStat, 0, sizeof(sqlStat)); + strncpy(sqlStat, PDM_SQLITE_GET_ID, PDM_SQLITE_GET_ID_SIZE - 1); + memset(hexUUID, 0, sizeof(hexUUID)); + + if (!convertUuidToHexString(UUID, hexUUID)) + { + return OC_STACK_ERROR; + } - res = sqlite3_bind_blob(stmt, PDM_BIND_INDEX_FIRST, UUID, UUID_LENGTH, SQLITE_STATIC); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + strncpy(sqlStat + PDM_SQLITE_GET_ID_SIZE - 1, hexUUID, HEX_UUID_STR_LENGTH); + res = sqlite3_prepare_v2(g_db, sqlStat, (int)sizeof(sqlStat), &stmt, 0); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); - OC_LOG(DEBUG, TAG, "Binding Done"); bool retValue = false; while(SQLITE_ROW == sqlite3_step(stmt)) { - OC_LOG(INFO, TAG, "Duplicated UUID"); + OIC_LOG(INFO, TAG, "Duplicated UUID"); retValue = true; } sqlite3_finalize(stmt); *result = retValue; + + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); return OC_STACK_OK; } @@ -278,52 +539,84 @@ OCStackResult PDMIsDuplicateDevice(const OicUuid_t* UUID, bool *result) */ static OCStackResult addlink(int id1, int id2) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + sqlite3_stmt *stmt = 0; int res = 0; res = sqlite3_prepare_v2(g_db, PDM_SQLITE_INSERT_LINK_DATA, strlen(PDM_SQLITE_INSERT_LINK_DATA) + 1, &stmt, NULL); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id1); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id2); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); - res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_THIRD, PDM_ACTIVE_STATE); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_THIRD, PDM_DEVICE_ACTIVE); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); if (sqlite3_step(stmt) != SQLITE_DONE) { - OC_LOG_V(ERROR, TAG, "Error Occured: %s",sqlite3_errmsg(g_db)); + OIC_LOG_V(ERROR, TAG, "Error Occured: %s",sqlite3_errmsg(g_db)); sqlite3_finalize(stmt); return OC_STACK_ERROR; } sqlite3_finalize(stmt); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); return OC_STACK_OK; } OCStackResult PDMLinkDevices(const OicUuid_t *UUID1, const OicUuid_t *UUID2) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + CHECK_PDM_INIT(TAG); if (NULL == UUID1 || NULL == UUID2) { - OC_LOG(ERROR, TAG, "Invalid PARAM"); + OIC_LOG(ERROR, TAG, "Invalid PARAM"); return OC_STACK_INVALID_PARAM; } + + PdmDeviceState_t state = PDM_DEVICE_UNKNOWN; + if (OC_STACK_OK != PDMGetDeviceState(UUID1, &state)) + { + OIC_LOG(ERROR, TAG, "Internal error occured"); + return OC_STACK_ERROR; + } + if (PDM_DEVICE_ACTIVE != state) + { + OIC_LOG_V(ERROR, TAG, "UUID1: Device state is not active : %d", state); + return OC_STACK_INVALID_PARAM; + } + + state = PDM_DEVICE_UNKNOWN; + if (OC_STACK_OK != PDMGetDeviceState(UUID2, &state)) + { + OIC_LOG(ERROR, TAG, "Internal error occured"); + return OC_STACK_ERROR; + } + if (PDM_DEVICE_ACTIVE != state) + { + OIC_LOG_V(ERROR, TAG, "UUID2: Device state is not active : %d", state); + return OC_STACK_INVALID_PARAM; + } + int id1 = 0; if (OC_STACK_OK != getIdForUUID(UUID1, &id1)) { - OC_LOG(ERROR, TAG, "Requested value not found"); + OIC_LOG(ERROR, TAG, "Requested value not found"); return OC_STACK_INVALID_PARAM; } int id2 = 0; if (OC_STACK_OK != getIdForUUID(UUID2, &id2)) { - OC_LOG(ERROR, TAG, "Requested value not found"); + OIC_LOG(ERROR, TAG, "Requested value not found"); return OC_STACK_INVALID_PARAM; } + ASCENDING_ORDER(id1, id2); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); return addlink(id1, id2); } @@ -332,76 +625,87 @@ OCStackResult PDMLinkDevices(const OicUuid_t *UUID1, const OicUuid_t *UUID2) */ static OCStackResult removeLink(int id1, int id2) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + int res = 0; sqlite3_stmt *stmt = 0; res = sqlite3_prepare_v2(g_db, PDM_SQLITE_DELETE_LINK, strlen(PDM_SQLITE_DELETE_LINK) + 1, &stmt, NULL); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id1); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id2); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); if (SQLITE_DONE != sqlite3_step(stmt)) { - OC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db)); + OIC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db)); sqlite3_finalize(stmt); return OC_STACK_ERROR; } sqlite3_finalize(stmt); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); return OC_STACK_OK; } OCStackResult PDMUnlinkDevices(const OicUuid_t *UUID1, const OicUuid_t *UUID2) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + CHECK_PDM_INIT(TAG); if (NULL == UUID1 || NULL == UUID2) { - OC_LOG(ERROR, TAG, "Invalid PARAM"); + OIC_LOG(ERROR, TAG, "Invalid PARAM"); return OC_STACK_INVALID_PARAM; } int id1 = 0; if (OC_STACK_OK != getIdForUUID(UUID1, &id1)) { - OC_LOG(ERROR, TAG, "Requested value not found"); + OIC_LOG(ERROR, TAG, "Requested value not found"); return OC_STACK_INVALID_PARAM; } int id2 = 0; if (OC_STACK_OK != getIdForUUID(UUID2, &id2)) { - OC_LOG(ERROR, TAG, "Requested value not found"); + OIC_LOG(ERROR, TAG, "Requested value not found"); return OC_STACK_INVALID_PARAM; } ASCENDING_ORDER(id1, id2); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); return removeLink(id1, id2); } static OCStackResult removeFromDeviceList(int id) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + sqlite3_stmt *stmt = 0; int res = 0; res = sqlite3_prepare_v2(g_db, PDM_SQLITE_DELETE_DEVICE, strlen(PDM_SQLITE_DELETE_DEVICE) + 1, &stmt, NULL); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); if (sqlite3_step(stmt) != SQLITE_DONE) { - OC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db)); + OIC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db)); sqlite3_finalize(stmt); return OC_STACK_ERROR; } sqlite3_finalize(stmt); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); return OC_STACK_OK; } OCStackResult PDMDeleteDevice(const OicUuid_t *UUID) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + CHECK_PDM_INIT(TAG); if (NULL == UUID) { @@ -410,99 +714,106 @@ OCStackResult PDMDeleteDevice(const OicUuid_t *UUID) int id = 0; if (OC_STACK_OK != getIdForUUID(UUID, &id)) { - OC_LOG(ERROR, TAG, "Requested value not found"); + OIC_LOG(ERROR, TAG, "Requested value not found"); return OC_STACK_INVALID_PARAM; } begin(); if(OC_STACK_OK != removeFromDeviceList(id)) { rollback(); - OC_LOG(ERROR, TAG, "Requested value not found"); + OIC_LOG(ERROR, TAG, "Requested value not found"); return OC_STACK_ERROR; } commit(); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); return OC_STACK_OK; } static OCStackResult updateLinkState(int id1, int id2, int state) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + sqlite3_stmt *stmt = 0; int res = 0 ; res = sqlite3_prepare_v2(g_db, PDM_SQLITE_UPDATE_LINK, strlen(PDM_SQLITE_UPDATE_LINK) + 1, &stmt, NULL); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, state); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id1); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_THIRD, id2); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); if (SQLITE_DONE != sqlite3_step(stmt)) { - OC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db)); + OIC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db)); sqlite3_finalize(stmt); return OC_STACK_ERROR; } sqlite3_finalize(stmt); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); return OC_STACK_OK; } OCStackResult PDMSetLinkStale(const OicUuid_t* uuidOfDevice1, const OicUuid_t* uuidOfDevice2) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + CHECK_PDM_INIT(TAG); if (NULL == uuidOfDevice1 || NULL == uuidOfDevice2) { - OC_LOG(ERROR, TAG, "Invalid PARAM"); + OIC_LOG(ERROR, TAG, "Invalid PARAM"); return OC_STACK_INVALID_PARAM; } int id1 = 0; if (OC_STACK_OK != getIdForUUID(uuidOfDevice1, &id1)) { - OC_LOG(ERROR, TAG, "Requested value not found"); + OIC_LOG(ERROR, TAG, "Requested value not found"); return OC_STACK_INVALID_PARAM; } int id2 = 0; if (OC_STACK_OK != getIdForUUID(uuidOfDevice2, &id2)) { - OC_LOG(ERROR, TAG, "Requested value not found"); + OIC_LOG(ERROR, TAG, "Requested value not found"); return OC_STACK_INVALID_PARAM; } ASCENDING_ORDER(id1, id2); - return updateLinkState(id1, id2, PDM_STALE_STATE); - + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); + return updateLinkState(id1, id2, PDM_DEVICE_STALE); } OCStackResult PDMGetOwnedDevices(OCUuidList_t **uuidList, size_t *numOfDevices) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + CHECK_PDM_INIT(TAG); if (NULL != *uuidList) { - OC_LOG(ERROR, TAG, "Not null list will cause memory leak"); + OIC_LOG(ERROR, TAG, "Not null list will cause memory leak"); return OC_STACK_INVALID_PARAM; } sqlite3_stmt *stmt = 0; int res = 0; res = sqlite3_prepare_v2(g_db, PDM_SQLITE_LIST_ALL_UUID, strlen(PDM_SQLITE_LIST_ALL_UUID) + 1, &stmt, NULL); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); - int counter = 0; + size_t counter = 0; while (SQLITE_ROW == sqlite3_step(stmt)) { - const void *ptr = sqlite3_column_blob(stmt, PDM_FIRST_INDEX); OicUuid_t *uid = (OicUuid_t *)ptr; OCUuidList_t *temp = (OCUuidList_t *) OICCalloc(1,sizeof(OCUuidList_t)); if (NULL == temp) { - OC_LOG_V(ERROR, TAG, "Memory allocation problem"); + OIC_LOG_V(ERROR, TAG, "Memory allocation problem"); sqlite3_finalize(stmt); return OC_STACK_NO_MEMORY; } @@ -512,61 +823,98 @@ OCStackResult PDMGetOwnedDevices(OCUuidList_t **uuidList, size_t *numOfDevices) } *numOfDevices = counter; sqlite3_finalize(stmt); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); return OC_STACK_OK; } -static OCStackResult getUUIDforId(int id, OicUuid_t *uid) +static OCStackResult getUUIDforId(int id, OicUuid_t *uid, bool *result) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + sqlite3_stmt *stmt = 0; int res = 0; res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_UUID, strlen(PDM_SQLITE_GET_UUID) + 1, &stmt, NULL); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); - while (SQLITE_ROW == sqlite3_step(stmt)) + if (SQLITE_ROW == sqlite3_step(stmt)) { const void *ptr = sqlite3_column_blob(stmt, PDM_FIRST_INDEX); memcpy(uid, ptr, sizeof(OicUuid_t)); + + int temp = sqlite3_column_int(stmt, PDM_SECOND_INDEX); + if(PDM_DEVICE_STALE == temp) + { + if(result) + { + *result = true; + } + } + else + { + if(result) + { + *result = false; + } + } + sqlite3_finalize(stmt); + return OC_STACK_OK; } sqlite3_finalize(stmt); - return OC_STACK_OK; + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); + return OC_STACK_INVALID_PARAM; } OCStackResult PDMGetLinkedDevices(const OicUuid_t *UUID, OCUuidList_t **UUIDLIST, size_t *numOfDevices) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + CHECK_PDM_INIT(TAG); - if (NULL != *UUIDLIST) + if (NULL == UUID || NULL == numOfDevices || !UUIDLIST) { - OC_LOG(ERROR, TAG, "Not null list will cause memory leak"); return OC_STACK_INVALID_PARAM; } - if (NULL == UUID) + if (NULL != *UUIDLIST ) + { + OIC_LOG(ERROR, TAG, "Not null list will cause memory leak"); + return OC_STACK_INVALID_PARAM; + } + PdmDeviceState_t state = PDM_DEVICE_UNKNOWN; + OCStackResult ret = PDMGetDeviceState(UUID, &state); + if (OC_STACK_OK != ret) { + OIC_LOG(ERROR, TAG, "Internal error occured"); + return OC_STACK_ERROR; + } + if (PDM_DEVICE_ACTIVE != state) + { + OIC_LOG_V(ERROR, TAG, "Device state is not active : %d", state); return OC_STACK_INVALID_PARAM; } int id = 0; if (OC_STACK_OK != getIdForUUID(UUID, &id)) { - OC_LOG(ERROR, TAG, "Requested value not found"); + OIC_LOG(ERROR, TAG, "Requested value not found"); return OC_STACK_INVALID_PARAM; } + sqlite3_stmt *stmt = 0; int res = 0; res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_LINKED_DEVICES, strlen(PDM_SQLITE_GET_LINKED_DEVICES) + 1, &stmt, NULL); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); - int counter = 0; + size_t counter = 0; while (SQLITE_ROW == sqlite3_step(stmt)) { int i1 = sqlite3_column_int(stmt, PDM_FIRST_INDEX); @@ -575,17 +923,17 @@ OCStackResult PDMGetLinkedDevices(const OicUuid_t *UUID, OCUuidList_t **UUIDLIST OicUuid_t temp = {{0,}}; if (i1 != id) { - getUUIDforId(i1, &temp); + getUUIDforId(i1, &temp, NULL); } if (i2 != id) { - getUUIDforId(i2, &temp); + getUUIDforId(i2, &temp, NULL); } OCUuidList_t *tempNode = (OCUuidList_t *) OICCalloc(1,sizeof(OCUuidList_t)); if (NULL == tempNode) { - OC_LOG(ERROR, TAG, "No Memory"); + OIC_LOG(ERROR, TAG, "No Memory"); sqlite3_finalize(stmt); return OC_STACK_NO_MEMORY; } @@ -595,15 +943,18 @@ OCStackResult PDMGetLinkedDevices(const OicUuid_t *UUID, OCUuidList_t **UUIDLIST } *numOfDevices = counter; sqlite3_finalize(stmt); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); return OC_STACK_OK; } OCStackResult PDMGetToBeUnlinkedDevices(OCPairList_t **staleDevList, size_t *numOfDevices) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + CHECK_PDM_INIT(TAG); if (NULL != *staleDevList) { - OC_LOG(ERROR, TAG, "Not null list will cause memory leak"); + OIC_LOG(ERROR, TAG, "Not null list will cause memory leak"); return OC_STACK_INVALID_PARAM; } @@ -611,25 +962,25 @@ OCStackResult PDMGetToBeUnlinkedDevices(OCPairList_t **staleDevList, size_t *num int res = 0; res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_STALE_INFO, strlen(PDM_SQLITE_GET_STALE_INFO) + 1, &stmt, NULL); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); - res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, PDM_STALE_STATE); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, PDM_DEVICE_STALE); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); - int counter = 0; + size_t counter = 0; while (SQLITE_ROW == sqlite3_step(stmt)) { int i1 = sqlite3_column_int(stmt, PDM_FIRST_INDEX); int i2 = sqlite3_column_int(stmt, PDM_SECOND_INDEX); OicUuid_t temp1 = {{0,}}; OicUuid_t temp2 = {{0,}};; - getUUIDforId(i1, &temp1); - getUUIDforId(i2, &temp2); + getUUIDforId(i1, &temp1, NULL); + getUUIDforId(i2, &temp2, NULL); OCPairList_t *tempNode = (OCPairList_t *) OICCalloc(1, sizeof(OCPairList_t)); if (NULL == tempNode) { - OC_LOG(ERROR, TAG, "No Memory"); + OIC_LOG(ERROR, TAG, "No Memory"); sqlite3_finalize(stmt); return OC_STACK_NO_MEMORY; } @@ -640,20 +991,26 @@ OCStackResult PDMGetToBeUnlinkedDevices(OCPairList_t **staleDevList, size_t *num } *numOfDevices = counter; sqlite3_finalize(stmt); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); return OC_STACK_OK; } OCStackResult PDMClose() { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + CHECK_PDM_INIT(TAG); int res = 0; res = sqlite3_close(g_db); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, NULL, ERROR, OC_STACK_ERROR); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); return OC_STACK_OK; } void PDMDestoryOicUuidLinkList(OCUuidList_t* ptr) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + if(ptr) { OCUuidList_t *tmp1 = NULL,*tmp2=NULL; @@ -663,10 +1020,14 @@ void PDMDestoryOicUuidLinkList(OCUuidList_t* ptr) OICFree(tmp1); } } + + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); } void PDMDestoryStaleLinkList(OCPairList_t* ptr) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + if(ptr) { OCPairList_t *tmp1 = NULL,*tmp2=NULL; @@ -676,11 +1037,15 @@ void PDMDestoryStaleLinkList(OCPairList_t* ptr) OICFree(tmp1); } } + + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); } OCStackResult PDMIsLinkExists(const OicUuid_t* uuidOfDevice1, const OicUuid_t* uuidOfDevice2, bool* result) { + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + CHECK_PDM_INIT(TAG); if (NULL == uuidOfDevice1 || NULL == uuidOfDevice2 || NULL == result) { @@ -690,13 +1055,37 @@ OCStackResult PDMIsLinkExists(const OicUuid_t* uuidOfDevice1, const OicUuid_t* u int id2 = 0; if (OC_STACK_OK != getIdForUUID(uuidOfDevice1, &id1)) { - OC_LOG(ERROR, TAG, "Requested value not found"); + OIC_LOG(ERROR, TAG, "Requested value not found"); return OC_STACK_INVALID_PARAM; } if (OC_STACK_OK != getIdForUUID(uuidOfDevice2, &id2)) { - OC_LOG(ERROR, TAG, "Requested value not found"); + OIC_LOG(ERROR, TAG, "Requested value not found"); + return OC_STACK_INVALID_PARAM; + } + + PdmDeviceState_t state = PDM_DEVICE_UNKNOWN; + if (OC_STACK_OK != PDMGetDeviceState(uuidOfDevice1, &state)) + { + OIC_LOG(ERROR, TAG, "uuidOfDevice1:Internal error occured"); + return OC_STACK_ERROR; + } + if (PDM_DEVICE_ACTIVE != state) + { + OIC_LOG_V(ERROR, TAG, "uuidOfDevice1:Device state is not active : %d", state); + return OC_STACK_INVALID_PARAM; + } + + state = PDM_DEVICE_UNKNOWN; + if (OC_STACK_OK != PDMGetDeviceState(uuidOfDevice2, &state)) + { + OIC_LOG(ERROR, TAG, "uuidOfDevice2:Internal error occured"); + return OC_STACK_ERROR; + } + if (PDM_DEVICE_ACTIVE != state) + { + OIC_LOG_V(ERROR, TAG, "uuidOfDevice2:Device state is not active : %d", state); return OC_STACK_INVALID_PARAM; } @@ -704,23 +1093,208 @@ OCStackResult PDMIsLinkExists(const OicUuid_t* uuidOfDevice1, const OicUuid_t* u sqlite3_stmt *stmt = 0; int res = 0; - res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_LINKED_DEVICES, - strlen(PDM_SQLITE_GET_LINKED_DEVICES) + 1, &stmt, NULL); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + res = sqlite3_prepare_v2(g_db, PDM_SQLITE_GET_DEVICE_LINKS, + strlen(PDM_SQLITE_GET_DEVICE_LINKS) + 1, &stmt, NULL); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id1); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id2); - PDM_VERIFY_SQLITE_OK(TAG, res, ERROR, OC_STACK_ERROR); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); bool ret = false; while(SQLITE_ROW == sqlite3_step(stmt)) { - OC_LOG(INFO, TAG, "Link already exists between devices"); + OIC_LOG(INFO, TAG, "Link already exists between devices"); ret = true; } sqlite3_finalize(stmt); *result = ret; + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); + return OC_STACK_OK; +} + +static OCStackResult updateDeviceState(const OicUuid_t *uuid, PdmDeviceState_t state) +{ + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + OIC_LOG_V(WARNING, TAG, "UUID is: %s", (char*) uuid); + + sqlite3_stmt *stmt = 0; + int res = 0 ; + char sqlStat[PDM_SQLITE_UPDATE_DEVICE_SIZE - 1 + HEX_UUID_STR_LENGTH]; + char hexUUID[HEX_UUID_STR_LENGTH]; + + memset(sqlStat, 0, sizeof(sqlStat)); + strncpy(sqlStat, PDM_SQLITE_UPDATE_DEVICE, PDM_SQLITE_UPDATE_DEVICE_SIZE - 1); + memset(hexUUID, 0, sizeof(hexUUID)); + + if (!convertUuidToHexString(uuid, hexUUID)) + { + return OC_STACK_ERROR; + } + + strncpy(sqlStat + PDM_SQLITE_UPDATE_DEVICE_SIZE - 1, hexUUID, HEX_UUID_STR_LENGTH); + res = sqlite3_prepare_v2(g_db, sqlStat, + (int)sizeof(sqlStat), &stmt, NULL); + + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); + res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, state); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); + + if (SQLITE_DONE != sqlite3_step(stmt)) + { + OIC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db)); + sqlite3_finalize(stmt); + return OC_STACK_ERROR; + } + sqlite3_finalize(stmt); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); + return OC_STACK_OK; +} + +static OCStackResult updateLinkForStaleDevice(const OicUuid_t *devUuid) +{ + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + + sqlite3_stmt *stmt = 0; + int res = 0 ; + + int id = 0; + if (OC_STACK_OK != getIdForUUID(devUuid, &id)) + { + OIC_LOG(ERROR, TAG, "Requested value not found"); + return OC_STACK_INVALID_PARAM; + } + + res = sqlite3_prepare_v2(g_db, PDM_SQLITE_UPDATE_LINK_STALE_FOR_STALE_DEVICE, + strlen(PDM_SQLITE_UPDATE_LINK_STALE_FOR_STALE_DEVICE) + 1, + &stmt, NULL); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); + + res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, id); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); + + res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_SECOND, id); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); + + if (SQLITE_DONE != sqlite3_step(stmt)) + { + OIC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db)); + sqlite3_finalize(stmt); + return OC_STACK_ERROR; + } + sqlite3_finalize(stmt); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); + return OC_STACK_OK; +} + +OCStackResult PDMSetDeviceState(const OicUuid_t* uuid, PdmDeviceState_t state) +{ + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + + OCStackResult res = OC_STACK_ERROR; + + CHECK_PDM_INIT(TAG); + if (NULL == uuid) + { + OIC_LOG(ERROR, TAG, "Invalid PARAM"); + return OC_STACK_INVALID_PARAM; + } + begin(); + + if(PDM_DEVICE_STALE == state) + { + res = updateLinkForStaleDevice(uuid); + if (OC_STACK_OK != res) + { + rollback(); + OIC_LOG(ERROR, TAG, "unable to update links"); + return res; + } + } + + res = updateDeviceState(uuid, state); + if (OC_STACK_OK != res) + { + rollback(); + OIC_LOG(ERROR, TAG, "unable to update device state"); + return res; + } + commit(); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); + return OC_STACK_OK; +} + +OCStackResult PDMGetDeviceState(const OicUuid_t *uuid, PdmDeviceState_t* result) +{ + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + + if (NULL == uuid || NULL == result) + { + OIC_LOG(ERROR, TAG, "UUID or result is NULL"); + return OC_STACK_INVALID_PARAM; + } + + sqlite3_stmt *stmt = 0; + int res = 0; + char sqlStat[PDM_SQLITE_GET_DEVICE_STATUS_SIZE - 1 + HEX_UUID_STR_LENGTH]; + char hexUUID[HEX_UUID_STR_LENGTH]; + + memset(sqlStat, 0, sizeof(sqlStat)); + strncpy(sqlStat, PDM_SQLITE_GET_DEVICE_STATUS, PDM_SQLITE_GET_DEVICE_STATUS_SIZE - 1); + memset(hexUUID, 0, sizeof(hexUUID)); + + if (!convertUuidToHexString(uuid, hexUUID)) + { + return OC_STACK_ERROR; + } + + strncpy(sqlStat + PDM_SQLITE_GET_DEVICE_STATUS_SIZE - 1, hexUUID, HEX_UUID_STR_LENGTH); + res = sqlite3_prepare_v2(g_db, sqlStat, (int)sizeof(sqlStat), &stmt, 0); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); + + *result = PDM_DEVICE_UNKNOWN; + while(SQLITE_ROW == sqlite3_step(stmt)) + { + int tempStaleStateFromDb = sqlite3_column_int(stmt, PDM_FIRST_INDEX); + OIC_LOG_V(DEBUG, TAG, "Device state is %d", tempStaleStateFromDb); + *result = (PdmDeviceState_t)tempStaleStateFromDb; + } + + sqlite3_finalize(stmt); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); + + return OC_STACK_OK; +} + +OCStackResult PDMDeleteDeviceWithState(const PdmDeviceState_t state) +{ + OIC_LOG_V(DEBUG, TAG, "IN %s", __func__); + + CHECK_PDM_INIT(TAG); + if (PDM_DEVICE_ACTIVE != state && PDM_DEVICE_STALE != state && + PDM_DEVICE_INIT != state && PDM_DEVICE_UNKNOWN != state) + { + return OC_STACK_INVALID_PARAM; + } + + sqlite3_stmt *stmt = 0; + int res =0; + res = sqlite3_prepare_v2(g_db, PDM_SQLITE_DELETE_DEVICE_WITH_STATE, + strlen(PDM_SQLITE_DELETE_DEVICE_WITH_STATE) + 1, &stmt, NULL); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); + + res = sqlite3_bind_int(stmt, PDM_BIND_INDEX_FIRST, state); + PDM_VERIFY_SQLITE_OK(TAG, res, stmt, ERROR, OC_STACK_ERROR); + + if (SQLITE_DONE != sqlite3_step(stmt)) + { + OIC_LOG_V(ERROR, TAG, "Error message: %s", sqlite3_errmsg(g_db)); + sqlite3_finalize(stmt); + return OC_STACK_ERROR; + } + sqlite3_finalize(stmt); + OIC_LOG_V(DEBUG, TAG, "OUT %s", __func__); return OC_STACK_OK; }