pal_plat_sst_impl.c

00001 // ----------------------------------------------------------------------------
00002 // Copyright 2018 ARM Ltd.
00003 //
00004 // Licensed under the Apache License, Version 2.0 (the "License");
00005 // you may not use this file except in compliance with the License.
00006 // You may obtain a copy of the License at
00007 //
00008 //     http://www.apache.org/licenses/LICENSE-2.0
00009 //
00010 // Unless required by applicable law or agreed to in writing, software
00011 // distributed under the License is distributed on an "AS IS" BASIS,
00012 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013 // See the License for the specific language governing permissions and
00014 // limitations under the License.
00015 // ----------------------------------------------------------------------------
00016 #ifdef MBED_CONF_MBED_CLOUD_CLIENT_EXTERNAL_SST_SUPPORT
00017 
00018 #include "pal.h"
00019 #include "pal_sst.h"
00020 #include "kvstore_global_api.h"
00021 #include "mbed_error.h"
00022 
00023 #define EXPANSION_STR(x) STR(x) //stringification of macro value
00024 #define STR(x) #x //stringification of the macro
00025 #define PAL_SST_KV_PREFIX "/"EXPANSION_STR(MBED_CONF_STORAGE_DEFAULT_KV)"/"
00026 
00027 #define TRACE_GROUP "PAL"
00028 
00029 static palStatus_t pal_sst_translate_error(int kv_status)
00030 {
00031     palStatus_t pal_status;
00032 
00033     switch (kv_status) {
00034         case MBED_SUCCESS:
00035             pal_status = PAL_SUCCESS;
00036             break;
00037         case MBED_ERROR_ITEM_NOT_FOUND:
00038             pal_status = PAL_ERR_SST_ITEM_NOT_FOUND;
00039             break;
00040         case  MBED_ERROR_INVALID_SIZE:
00041             pal_status = PAL_ERR_SST_INVALID_SIZE;
00042             break;
00043         case MBED_ERROR_NOT_READY:
00044             pal_status = PAL_ERR_SST_NOT_READY;
00045             break;
00046         case MBED_ERROR_WRITE_PROTECTED:
00047             pal_status = PAL_ERR_SST_WRITE_PROTECTED;
00048             break;
00049         case MBED_ERROR_WRITE_FAILED:
00050             pal_status = PAL_ERR_SST_WRITE_FAILED;
00051             break;
00052         case MBED_ERROR_READ_FAILED:
00053             pal_status = PAL_ERR_SST_READ_FAILED;
00054             break;
00055         case MBED_ERROR_INVALID_DATA_DETECTED:
00056             pal_status = PAL_ERR_SST_INVALID_DATA_DETECTED;
00057             break;
00058         case MBED_ERROR_FAILED_OPERATION:
00059             pal_status = PAL_ERR_SST_FAILED_OPERATION;
00060             break;
00061         case MBED_ERROR_INVALID_ARGUMENT:
00062             pal_status = PAL_ERR_INVALID_ARGUMENT ;
00063             break;
00064         case MBED_ERROR_MEDIA_FULL:
00065             pal_status = PAL_ERR_SST_MEDIA_FULL;
00066             break;
00067         case MBED_ERROR_RBP_AUTHENTICATION_FAILED:
00068             pal_status = PAL_ERR_SST_RBP_AUTHENTICATION_FAILED;
00069             break;
00070         case MBED_ERROR_AUTHENTICATION_FAILED:
00071             pal_status = PAL_ERR_SST_AUTHENTICATION_FAILED;
00072             break;
00073         default:
00074             pal_status = PAL_ERR_SST_GENERIC_FAILURE;
00075     }
00076 
00077     if (pal_status == PAL_ERR_SST_ITEM_NOT_FOUND) {
00078         PAL_LOG_DBG("kv_status: %" PRId16", pal_sst status: 0x%" PRIx32 "", MBED_GET_ERROR_CODE(kv_status), pal_status);
00079     }
00080     else if (pal_status != PAL_SUCCESS) {
00081         PAL_LOG_ERR("kv_status: %" PRId16", pal_sst status: 0x%" PRIx32 "", MBED_GET_ERROR_CODE(kv_status), pal_status);
00082     }
00083 
00084     return pal_status;
00085 }
00086 
00087 
00088 static palStatus_t pal_sst_build_complete_name(const char* item_name, char* complete_item_name)
00089 {
00090 
00091     PAL_VALIDATE_ARGUMENTS((NULL == item_name) || (NULL == complete_item_name));
00092 
00093     size_t item_name_length = strlen(item_name);
00094     size_t prefix_length = strlen(PAL_SST_KV_PREFIX);
00095     size_t total_length = prefix_length + item_name_length;
00096     if (total_length > KV_MAX_KEY_LENGTH) {
00097         return PAL_ERR_SST_INVALID_SIZE;
00098     }
00099 
00100     //copy prefix
00101     memcpy(complete_item_name, PAL_SST_KV_PREFIX, prefix_length);
00102 
00103     //copy item name to the new buffer
00104     memcpy(complete_item_name + prefix_length, item_name, item_name_length);
00105 
00106     //null terminate
00107     complete_item_name[total_length] = '\0';
00108 
00109     return PAL_SUCCESS;
00110 }
00111 
00112 palStatus_t pal_SSTSet (const char *itemName, const void *itemBuffer, size_t itemBufferSize, uint32_t SSTFlagsBitmap)
00113 {
00114     int kv_status = MBED_SUCCESS;
00115     palStatus_t pal_status = PAL_SUCCESS;
00116     uint32_t kv_flags = 0;
00117     char sst_complete_item_name[KV_MAX_KEY_LENGTH + 1]; //extra byte for null termination
00118 
00119     //these bitmask is for unused bits in SSTFlagsBitmap.
00120     //only PAL_SST_WRITE_ONCE_FLAG, PAL_SST_CONFIDENTIALITY_FLAG and PAL_SST_REPLAY_PROTECTION_FLAG used  
00121     uint32_t sst_flag_unused_bits_mask = ~(PAL_SST_WRITE_ONCE_FLAG | PAL_SST_CONFIDENTIALITY_FLAG | PAL_SST_REPLAY_PROTECTION_FLAG);
00122 
00123     //arguments validation
00124     PAL_VALIDATE_ARGUMENTS((NULL == itemName) || ((NULL == itemBuffer) && (itemBufferSize > 0)) || ((SSTFlagsBitmap & sst_flag_unused_bits_mask) != 0));
00125 
00126     //allocate buffer for itemName + prefix and copy prefix to the new buffer    
00127     pal_status = pal_sst_build_complete_name(itemName, sst_complete_item_name);
00128     if (pal_status != PAL_SUCCESS) {
00129         PAL_LOG_ERR("pal_SSTSet: 0x%" PRIx32 "", pal_status);
00130         return pal_status;
00131     }
00132 
00133     //translate palSSTFlags to kv flags
00134     if (SSTFlagsBitmap & PAL_SST_WRITE_ONCE_FLAG) {
00135         kv_flags |= KV_WRITE_ONCE_FLAG;
00136     }
00137     if (SSTFlagsBitmap & PAL_SST_CONFIDENTIALITY_FLAG) {
00138         kv_flags |= KV_REQUIRE_CONFIDENTIALITY_FLAG;
00139     }
00140     if (SSTFlagsBitmap & PAL_SST_REPLAY_PROTECTION_FLAG) {
00141         kv_flags |= KV_REQUIRE_REPLAY_PROTECTION_FLAG;
00142     }
00143 
00144     //call kv_set API
00145     kv_status = kv_set(sst_complete_item_name, itemBuffer, itemBufferSize, kv_flags);
00146 
00147     return pal_sst_translate_error(kv_status);
00148 }
00149 
00150 
00151 palStatus_t pal_SSTGet (const char *itemName, void *itemBuffer, size_t itemBufferSize, size_t *actualItemSize)
00152 {
00153     int kv_status = MBED_SUCCESS;
00154     palStatus_t pal_status = PAL_SUCCESS;
00155     char sst_complete_item_name[KV_MAX_KEY_LENGTH + 1]; //extra byte for null termination
00156 
00157     //arguments validation
00158     PAL_VALIDATE_ARGUMENTS((NULL == itemName) || ((NULL == itemBuffer) && (itemBufferSize > 0)) || (NULL == actualItemSize));
00159 
00160     //allocate buffer for itemName + prefix and copy prefix to the new buffer    
00161     pal_status = pal_sst_build_complete_name(itemName, sst_complete_item_name);
00162     if (pal_status != PAL_SUCCESS) {
00163         PAL_LOG_ERR("pal_SSTGet returned: 0x%" PRIx32 "", pal_status);
00164         return pal_status;
00165     }
00166 
00167     //call kv_get API
00168     kv_status = kv_get(sst_complete_item_name, itemBuffer, itemBufferSize, actualItemSize);
00169 
00170     return pal_sst_translate_error(kv_status);
00171 }
00172 
00173 
00174 palStatus_t pal_SSTGetInfo (const char *itemName, palSSTItemInfo_t *palItemInfo)
00175 {
00176 
00177     int kv_status = MBED_SUCCESS;
00178     palStatus_t pal_status = PAL_SUCCESS;
00179     kv_info_t kv_info = { 0 };
00180     char sst_complete_item_name[KV_MAX_KEY_LENGTH + 1]; //extra byte for null termination
00181 
00182     //arguments validation
00183     PAL_VALIDATE_ARGUMENTS((NULL == itemName) || (NULL == palItemInfo));
00184 
00185     //allocate buffer for itemName + prefix and copy prefix to the new buffer    
00186     pal_status = pal_sst_build_complete_name(itemName, sst_complete_item_name);
00187     if (pal_status != PAL_SUCCESS) {
00188         PAL_LOG_ERR("pal_SSTGetInfo returned: 0x%" PRIx32 "", pal_status);
00189         return pal_status;
00190     }
00191 
00192     //call kv_get_info API
00193     kv_status = kv_get_info(sst_complete_item_name, &kv_info);
00194 
00195     if (kv_status != MBED_SUCCESS) {
00196         return pal_sst_translate_error(kv_status);
00197     }
00198 
00199     // translate kv flags to palSSTFlags.
00200     if (kv_info.flags & KV_WRITE_ONCE_FLAG) {
00201         palItemInfo->SSTFlagsBitmap |= PAL_SST_WRITE_ONCE_FLAG;
00202     }
00203     if (kv_info.flags & KV_REQUIRE_CONFIDENTIALITY_FLAG) {
00204         palItemInfo->SSTFlagsBitmap |= PAL_SST_CONFIDENTIALITY_FLAG;
00205     }
00206     if (kv_info.flags & KV_REQUIRE_REPLAY_PROTECTION_FLAG) {
00207         palItemInfo->SSTFlagsBitmap |= PAL_SST_REPLAY_PROTECTION_FLAG;
00208     }
00209 
00210     palItemInfo->itemSize = kv_info.size;
00211 
00212     return PAL_SUCCESS;
00213 }
00214 
00215 
00216 palStatus_t pal_SSTRemove (const char *itemName)
00217 {
00218 
00219     int kv_status = MBED_SUCCESS;
00220     palStatus_t pal_status = PAL_SUCCESS;
00221     char sst_complete_item_name[KV_MAX_KEY_LENGTH + 1]; //extra byte for null termination
00222 
00223     //arguments validation
00224     PAL_VALIDATE_ARGUMENTS((NULL == itemName));
00225 
00226     //allocate buffer for itemName + prefix and copy prefix to the new buffer    
00227     pal_status = pal_sst_build_complete_name(itemName, sst_complete_item_name);
00228     if (pal_status != PAL_SUCCESS) {
00229         PAL_LOG_ERR("pal_SSTRemove returned: 0x%" PRIx32 "", pal_status);
00230         return pal_status;
00231     }
00232 
00233     //call kv_remove API
00234     kv_status = kv_remove(sst_complete_item_name);
00235 
00236     return pal_sst_translate_error(kv_status);
00237 }
00238 
00239 
00240 palStatus_t pal_SSTIteratorOpen (palSSTIterator_t *palSSTIterator, const char *itemPrefix)
00241 {
00242     int kv_status = MBED_SUCCESS;
00243     palStatus_t pal_status = PAL_SUCCESS;
00244     char sst_complete_item_prefix[KV_MAX_KEY_LENGTH + 1]; //extra byte for null termination
00245 
00246     //arguments validation
00247     PAL_VALIDATE_ARGUMENTS((NULL == palSSTIterator));
00248 
00249     //allocate buffer for itemName + prefix and copy prefix to the new buffer    
00250     pal_status = pal_sst_build_complete_name(itemPrefix, sst_complete_item_prefix);
00251     if (pal_status != PAL_SUCCESS) {
00252         PAL_LOG_ERR("pal_SSTIteratorOpen returned: 0x%" PRIx32 "", pal_status);
00253         return pal_status;
00254     }
00255 
00256     //call kv_iterator_open API
00257     kv_status = kv_iterator_open((kv_iterator_t*)palSSTIterator, sst_complete_item_prefix);
00258 
00259     return pal_sst_translate_error(kv_status);
00260 }
00261 
00262 
00263 palStatus_t pal_SSTIteratorNext (palSSTIterator_t palSSTIterator, char *itemName, size_t itemNameSize)
00264 {
00265     int kv_status = MBED_SUCCESS;
00266     char sst_complete_item_name[KV_MAX_KEY_LENGTH + 1]; //extra byte for null termination
00267 
00268     //arguments validation
00269     PAL_VALIDATE_ARGUMENTS(((uintptr_t)NULL == palSSTIterator) || (NULL == itemName) || (0 == itemNameSize));
00270 
00271     //call kv_iterator_next API
00272     kv_status = kv_iterator_next((kv_iterator_t)palSSTIterator, sst_complete_item_name, itemNameSize + strlen(PAL_SST_KV_PREFIX));
00273     if (kv_status != MBED_SUCCESS) {
00274         return pal_sst_translate_error(kv_status);
00275     }
00276 
00277     //copy the returned value to the input buffer
00278     memcpy(itemName, sst_complete_item_name + strlen(PAL_SST_KV_PREFIX), itemNameSize);
00279 
00280     return PAL_SUCCESS;
00281 }
00282 
00283 
00284 palStatus_t pal_SSTIteratorClose (palSSTIterator_t palSSTIterator)
00285 {
00286     //arguments validation
00287     PAL_VALIDATE_ARGUMENTS(((uintptr_t)NULL == palSSTIterator));
00288 
00289     int kv_status = MBED_SUCCESS;
00290 
00291     //call kv_iterator_close API
00292     kv_status = kv_iterator_close((kv_iterator_t)palSSTIterator);
00293 
00294     return pal_sst_translate_error(kv_status);
00295 }
00296 
00297 
00298 palStatus_t pal_SSTReset ()
00299 {
00300     int kv_status = MBED_SUCCESS;
00301 
00302     //call kv_reset API
00303     kv_status = kv_reset(PAL_SST_KV_PREFIX);
00304 
00305     return pal_sst_translate_error(kv_status);
00306 }
00307 
00308 #endif
00309