Toyomasa Watarai
Simple interface for Mbed Cloud Client
Embed:
(wiki syntax)
Show/hide line numbers
fcc_output_info_handler.c
00001 // ---------------------------------------------------------------------------- 00002 // Copyright 2016-2017 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 00017 #include <stdlib.h> 00018 #include "pv_error_handling.h" 00019 #include "fcc_status.h" 00020 #include "fcc_output_info_handler.h" 00021 #include "fcc_malloc.h" 00022 00023 00024 //General error string 00025 const char g_fcc_general_status_error_str[] = "General error:"; 00026 00027 //fcc error strings 00028 const char g_fcc_ca_error_str[] = "CA error:"; 00029 const char g_fcc_rot_error_str[] = "Root of trust error:"; 00030 const char g_fcc_entropy_error_str[] = "Entropy error:"; 00031 const char g_fcc_disabled_error_str[] = "Factory disabled error:"; 00032 const char g_fcc_invalid_certificate_error_str[] = "Certificate invalid:"; 00033 const char g_fcc_item_not_exists_error_str[] = "Item does not exist:"; 00034 const char g_fcc_meta_data_not_exists_error_str[] = "Meta data does not exist:"; 00035 const char g_fcc_meta_data_size_error_str[] = "Meta data does not exist:"; 00036 const char g_fcc_wrong_item_size_error_str[] = "Item size is wrong:"; 00037 const char g_fcc_empty_item_error_str[] = "Item empty:"; 00038 const char g_fcc_uri_wrong_format_error_str[] = "URI format incorrect:"; 00039 const char g_fcc_first_to_claim_not_allowed_error_str[] = "first to claim not allowed:"; 00040 const char g_fcc_wrong_utc_offset_value_error_str[] = "UTC offset incorrect:"; 00041 const char g_fcc_wrong_bootstrap_use_value_error_str[] = "Bootstrap mode value incorrect:"; 00042 const char g_fcc_not_permitted_error_str[] = "Operation not permitted:"; 00043 const char g_fcc_wrong_ca_certificate_error_str[] = "Validation of CA certificate failed:"; 00044 const char g_fcc_invalid_cn_certificate_error_str[] = "Certificate CN attribute invalid:"; 00045 const char g_fcc_crypto_public_key_correlation_error_str[] = "Certificate public key validation failed:"; 00046 const char g_fcc_internal_storage_error_str[] = "Internal storage error:"; 00047 00048 //kcm crypto error strings 00049 const char g_fcc_kcm_file_error_str[] = "File operation general error:"; 00050 const char g_fcc_kcm_invalid_file_version_str[] = "File version invalid:"; 00051 const char g_fcc_kcm_file_data_corrupted_str[] = "File data corrupted:"; 00052 const char g_fcc_kcm_file_name_corrupted_str[] = "File name corrupted:"; 00053 const char g_fcc_kcm_not_initialized_str[] = "KCM not initialized:"; 00054 const char g_fcc_kcm_close_incomplete_chain_str[] = "Closing incomplete KCM chain:"; 00055 const char g_fcc_kcm_invalid_chain_str[] = "Invalid certificate chain:"; 00056 const char g_fcc_kcm_invalid_num_of_cert_in_chain_str[] = "Invalid number of certificate in chain:"; 00057 const char g_fcc_kcm_file_exist_error_str[] = "Data already exists:"; 00058 const char g_fcc_kcm_file_name_too_long_error_str[] = "File name too long:"; 00059 const char g_fcc_crypto_kcm_error_str[] = "KCM crypto error:"; 00060 const char g_fcc_crypto_empty_item_error_str[] = "Item data empty:"; 00061 const char g_fcc_crypto_unsupported_hash_mode_error_str[] = "Hash mode unsupported:"; 00062 const char g_fcc_crypto_parsing_der_pivate_key_error_str[] = "Private key parse failed:"; 00063 const char g_fcc_crypto_parsing_der_public_key_error_str[] = "Public key parse failed:"; 00064 const char g_fcc_crypto_verify_private_key_error_str[] = "Private key verification failed:"; 00065 const char g_fcc_crypto_verify_public_key_error_str[] = "Public key verification failed:"; 00066 const char g_fcc_crypto_unsupported_curve_error_str[] = "Curve unsupported:"; 00067 const char g_fcc_crypto_parsing_der_cert_error_str[] = "Certificate parse failed:"; 00068 const char g_fcc_crypto_cert_expired_error_str[] = "Certificate expired:"; 00069 const char g_fcc_crypto_cert_future_error_str[] = "Certificate will be valid in the future:"; 00070 const char g_fcc_crypto_cert_md_alg_error_str[] = "Certificate MD algorithm error:"; 00071 const char g_fcc_crypto_cert_public_key_type_error_str[] = "Certificate public key type error:"; 00072 const char g_fcc_crypto_cert_public_key_error_str[] = "Certificate public key error:"; 00073 const char g_fcc_crypto_cert_not_trusted_error_str[] = "Certificate not trusted:"; 00074 const char g_fcc_crypto_invalid_x509_attr_error_str[] = "X509 attribute invalid:"; 00075 const char g_fcc_crypto_invalid_pk_key_format_error_str[] = "Public key format invalid:"; 00076 const char g_fcc_crypto_invalid_public_key_error_str[] = "Public key invalid:"; 00077 const char g_fcc_crypto_ecp_invalid_key_error_str[] = "EC key invalid:"; 00078 const char g_fcc_crypto_pk_key_invalid_version_error_str[] = "Public key version invalid:"; 00079 const char g_fcc_crypto_pk_password_requerd_error_str[] = "Public key password required:"; 00080 const char g_fcc_crypto_unknown_pk_algorithm_error_str[] = "Public key algorithm unknown:"; 00081 00082 //warning strings 00083 const char g_fcc_item_not_set_warning_str[] = "Item not set:"; 00084 00085 const char g_fcc_bootstrap_mode_false_warning_str[] = "Bootstrap mode not activated:"; 00086 const char g_fcc_self_signed_warning_str[] = "Certificate is self signed:"; 00087 const char g_fcc_item_is_empty_warning_str[] = "Item empty:"; 00088 const char g_fcc_redundant_item_warning_str[] = "Item redundant:"; 00089 const char g_fcc_cert_time_validity_warning_str[] = "Certificate validity cannot be checked:"; 00090 const char g_fcc_cert_validity_less_10_years_warning_str[] = "Certificate validity is less than 10 years:"; 00091 const char g_fcc_ca_identifier_warning_str[] = "CA identifier wasn't set properly:"; 00092 00093 fcc_output_info_s g_output_info; 00094 00095 00096 /** The function frees all allocated buffers 00097 * @param output_warning_info[in] The pointer to created fcc_warning_info_s structure 00098 */ 00099 static void fcc_free_list_of_warnings(fcc_warning_info_s *output_warning_info) 00100 { 00101 fcc_warning_info_s *current_node = output_warning_info; 00102 fcc_warning_info_s *next_node = output_warning_info->next; 00103 00104 while (current_node != NULL) { 00105 if (current_node->warning_info_string != NULL) { 00106 fcc_free(current_node->warning_info_string); 00107 } 00108 fcc_free(current_node); 00109 current_node = next_node; 00110 if (current_node != NULL) { 00111 next_node = current_node->next; 00112 } 00113 } 00114 } 00115 /** The function combines message string info and failed item, and sets it to passed pointer. 00116 * @param message_string[in] The message string - error or warning 00117 * @param failed_item_name[in] The name of item. 00118 * @param failed_item_name_size[in] The size of item's name. 00119 * @param out_string[in/out] The output string where the combined message should be copied. 00120 */ 00121 static fcc_status_e fcc_set_output_string_info(const char *message_string, const uint8_t *failed_item_name, size_t failed_item_name_size, char **out_string) 00122 { 00123 fcc_status_e fcc_status = FCC_STATUS_SUCCESS; 00124 00125 SA_PV_LOG_TRACE_FUNC_ENTER_NO_ARGS(); 00126 00127 //Allocate memory for error info 00128 *out_string = fcc_malloc(strlen(message_string) + failed_item_name_size + 1); // 1 char for '\0' 00129 SA_PV_ERR_RECOVERABLE_RETURN_IF((out_string == NULL), fcc_status = FCC_STATUS_MEMORY_OUT, "Failed to allocate buffer for output info"); 00130 00131 //Copy to the global structure error string info 00132 strcpy((*out_string), message_string); 00133 00134 //Copy to the global structure the name of failed item if it exists. 00135 if (failed_item_name != NULL) { 00136 memcpy((uint8_t*)(*out_string) + strlen(message_string), failed_item_name, failed_item_name_size); 00137 //Set '\0' in the end of error string info 00138 (*out_string)[strlen(message_string) + failed_item_name_size] = '\0'; 00139 } 00140 00141 00142 SA_PV_LOG_TRACE_FUNC_EXIT_NO_ARGS(); 00143 return fcc_status; 00144 } 00145 00146 static size_t fcc_get_size_of_all_warning_strings() 00147 { 00148 fcc_warning_info_s *current_node = g_output_info.head_of_warning_list; 00149 size_t size_of_all_warning_strings = 0; 00150 00151 SA_PV_LOG_INFO_FUNC_ENTER_NO_ARGS(); 00152 00153 while (current_node != NULL) { 00154 size_of_all_warning_strings += strlen(current_node->warning_info_string); 00155 current_node = current_node->next; 00156 } 00157 00158 SA_PV_LOG_INFO_FUNC_EXIT_NO_ARGS(); 00159 return size_of_all_warning_strings; 00160 } 00161 00162 static bool copy_all_warning_to_buffer(char *out_warning_string, size_t size_of_out_warning_string) 00163 { 00164 fcc_warning_info_s *current_node = g_output_info.head_of_warning_list; 00165 size_t length_of_iterated_strings = 0; 00166 00167 memset(out_warning_string, 0, size_of_out_warning_string); 00168 00169 while (current_node != NULL) { 00170 //Calculate size of current warning 00171 if (length_of_iterated_strings + strlen(current_node->warning_info_string) + 1 > size_of_out_warning_string) { 00172 return false; 00173 } 00174 strcpy(out_warning_string + length_of_iterated_strings, current_node->warning_info_string); 00175 //Set '\n' in the end of warning string info 00176 (out_warning_string)[length_of_iterated_strings + strlen(current_node->warning_info_string)] = '\n'; 00177 length_of_iterated_strings += strlen(current_node->warning_info_string) + 1; 00178 current_node = current_node->next; 00179 } 00180 //Increase the size for '\0' 00181 if (length_of_iterated_strings >= size_of_out_warning_string) { 00182 return false; 00183 } 00184 (out_warning_string)[length_of_iterated_strings] = '\0'; 00185 00186 return true; 00187 } 00188 /** The function returns error string according to passed fcc_status. 00189 * @param fcc_status[in] The fcc_status 00190 * 00191 */ 00192 char* fcc_get_fcc_error_string(fcc_status_e fcc_status) 00193 { 00194 SA_PV_LOG_TRACE_FUNC_ENTER("fcc_status is %d", fcc_status); 00195 char *fcc_error_string = NULL; 00196 00197 switch (fcc_status) { 00198 case FCC_STATUS_ERROR: 00199 case FCC_STATUS_MEMORY_OUT: 00200 case FCC_STATUS_INVALID_PARAMETER: 00201 case FCC_STATUS_KCM_ERROR: 00202 case FCC_STATUS_BUNDLE_ERROR: 00203 case FCC_STATUS_BUNDLE_RESPONSE_ERROR: 00204 case FCC_STATUS_BUNDLE_UNSUPPORTED_GROUP: 00205 case FCC_STATUS_BUNDLE_INVALID_SCHEME: 00206 case FCC_STATUS_BUNDLE_INVALID_GROUP: 00207 case FCC_STATUS_KCM_STORAGE_ERROR: 00208 case FCC_STATUS_KCM_FILE_EXIST_ERROR: 00209 case FCC_STATUS_NOT_INITIALIZED: 00210 case FCC_STATUS_OUTPUT_INFO_ERROR: 00211 case FCC_STATUS_WARNING_CREATE_ERROR: 00212 case FCC_STATUS_INVALID_CERT_ATTRIBUTE: 00213 case FCC_STATUS_INTERNAL_ITEM_ALREADY_EXIST: 00214 fcc_error_string = (char*)g_fcc_general_status_error_str; 00215 break; 00216 case FCC_STATUS_CA_ERROR: 00217 fcc_error_string = (char*)g_fcc_ca_error_str; 00218 break; 00219 case FCC_STATUS_ROT_ERROR: 00220 fcc_error_string = (char*)g_fcc_rot_error_str; 00221 break; 00222 case FCC_STATUS_STORE_ERROR: 00223 fcc_error_string = (char*)g_fcc_internal_storage_error_str; 00224 break; 00225 case FCC_STATUS_KCM_CRYPTO_ERROR: 00226 fcc_error_string = (char*)g_fcc_crypto_kcm_error_str; 00227 break; 00228 case FCC_STATUS_INVALID_CERTIFICATE: 00229 fcc_error_string = (char*)g_fcc_invalid_certificate_error_str; 00230 break; 00231 case FCC_STATUS_INVALID_LWM2M_CN_ATTR: 00232 fcc_error_string = (char*)g_fcc_invalid_cn_certificate_error_str; 00233 break; 00234 case FCC_STATUS_ENTROPY_ERROR: 00235 fcc_error_string = (char*)g_fcc_entropy_error_str; 00236 break; 00237 case FCC_STATUS_FACTORY_DISABLED_ERROR: 00238 fcc_error_string = (char*)g_fcc_disabled_error_str; 00239 break; 00240 case FCC_STATUS_ITEM_NOT_EXIST: 00241 fcc_error_string = (char*)g_fcc_item_not_exists_error_str; 00242 break; 00243 case FCC_STATUS_WRONG_ITEM_DATA_SIZE: 00244 fcc_error_string = (char*)g_fcc_wrong_item_size_error_str; 00245 break; 00246 case FCC_STATUS_EMPTY_ITEM: 00247 fcc_error_string = (char*)g_fcc_empty_item_error_str; 00248 break; 00249 case FCC_STATUS_URI_WRONG_FORMAT: 00250 fcc_error_string = (char*)g_fcc_uri_wrong_format_error_str; 00251 break; 00252 case FCC_STATUS_FIRST_TO_CLAIM_NOT_ALLOWED: 00253 fcc_error_string = (char*)g_fcc_first_to_claim_not_allowed_error_str; 00254 break; 00255 case FCC_STATUS_BOOTSTRAP_MODE_ERROR: 00256 fcc_error_string = (char*)g_fcc_wrong_bootstrap_use_value_error_str; 00257 break; 00258 case FCC_STATUS_UTC_OFFSET_WRONG_FORMAT: 00259 fcc_error_string = (char*)g_fcc_wrong_utc_offset_value_error_str; 00260 break; 00261 case FCC_STATUS_INVALID_CA_CERT_SIGNATURE: 00262 fcc_error_string = (char*)g_fcc_wrong_ca_certificate_error_str; 00263 break; 00264 case FCC_STATUS_EXPIRED_CERTIFICATE: 00265 fcc_error_string = (char*)g_fcc_crypto_cert_expired_error_str; 00266 break; 00267 case FCC_STATUS_CERTIFICATE_PUBLIC_KEY_CORRELATION_ERROR: 00268 fcc_error_string = (char*)g_fcc_crypto_public_key_correlation_error_str; 00269 break; 00270 default: 00271 fcc_error_string = (char*)NULL; 00272 break; 00273 } 00274 if (fcc_error_string != NULL) { 00275 SA_PV_LOG_TRACE_FUNC_EXIT("fcc_error_string is %s", fcc_error_string); 00276 } 00277 return fcc_error_string; 00278 } 00279 00280 /** The function returns error string according to passed kcm_status. 00281 * @param kcm_status[in] The kcm_status 00282 * 00283 */ 00284 00285 char* fcc_get_kcm_error_string(kcm_status_e kcm_status) 00286 { 00287 SA_PV_LOG_TRACE_FUNC_ENTER("kcm_status is %d", kcm_status); 00288 00289 char *kcm_error_string = NULL; 00290 00291 switch (kcm_status) { 00292 case KCM_STATUS_ERROR: 00293 case KCM_STATUS_INVALID_PARAMETER: 00294 case KCM_STATUS_INSUFFICIENT_BUFFER: 00295 case KCM_STATUS_OUT_OF_MEMORY: 00296 case KCM_STATUS_INVALID_FILE_ACCESS_MODE: 00297 case KCM_STATUS_UNKNOWN_STORAGE_ERROR: 00298 case KCM_CRYPTO_STATUS_INVALID_MD_TYPE: 00299 case KCM_CRYPTO_STATUS_FAILED_TO_WRITE_SIGNATURE: 00300 case KCM_CRYPTO_STATUS_VERIFY_SIGNATURE_FAILED: 00301 kcm_error_string = (char*)g_fcc_general_status_error_str; 00302 break; 00303 case KCM_STATUS_STORAGE_ERROR: 00304 kcm_error_string = (char*)g_fcc_kcm_file_error_str; 00305 break; 00306 case KCM_STATUS_INVALID_FILE_VERSION: 00307 kcm_error_string = (char*)g_fcc_kcm_invalid_file_version_str; 00308 break; 00309 case KCM_STATUS_FILE_CORRUPTED: 00310 kcm_error_string = (char*)g_fcc_kcm_file_data_corrupted_str; 00311 break; 00312 case KCM_STATUS_NOT_INITIALIZED: 00313 kcm_error_string = (char*)g_fcc_kcm_not_initialized_str; 00314 break; 00315 case KCM_STATUS_CLOSE_INCOMPLETE_CHAIN: 00316 kcm_error_string = (char*)g_fcc_kcm_close_incomplete_chain_str; 00317 break; 00318 case KCM_STATUS_INVALID_CHAIN: 00319 kcm_error_string = (char*)g_fcc_kcm_invalid_chain_str; 00320 break; 00321 case KCM_STATUS_INVALID_NUM_OF_CERT_IN_CHAIN: 00322 kcm_error_string = (char*)g_fcc_kcm_invalid_num_of_cert_in_chain_str; 00323 break; 00324 case KCM_STATUS_ITEM_NOT_FOUND: 00325 kcm_error_string = (char*)g_fcc_item_not_exists_error_str; 00326 break; 00327 case KCM_STATUS_META_DATA_NOT_FOUND: 00328 kcm_error_string = (char*)g_fcc_meta_data_not_exists_error_str; 00329 break; 00330 case KCM_STATUS_META_DATA_SIZE_ERROR: 00331 kcm_error_string = (char*)g_fcc_meta_data_size_error_str; 00332 break; 00333 case KCM_STATUS_NOT_PERMITTED: 00334 kcm_error_string = (char*)g_fcc_not_permitted_error_str; 00335 break; 00336 case KCM_STATUS_FILE_EXIST: 00337 kcm_error_string = (char*)g_fcc_kcm_file_exist_error_str; 00338 break; 00339 case KCM_STATUS_FILE_NAME_CORRUPTED: 00340 kcm_error_string = (char*)g_fcc_kcm_file_name_corrupted_str; 00341 break; 00342 case KCM_STATUS_ITEM_IS_EMPTY: 00343 kcm_error_string = (char*)g_fcc_crypto_empty_item_error_str; 00344 break; 00345 case KCM_STATUS_FILE_NAME_TOO_LONG: 00346 kcm_error_string = (char*)g_fcc_kcm_file_name_too_long_error_str; 00347 break; 00348 case KCM_CRYPTO_STATUS_UNSUPPORTED_HASH_MODE: 00349 kcm_error_string = (char*)g_fcc_crypto_unsupported_hash_mode_error_str; 00350 break; 00351 case KCM_CRYPTO_STATUS_PARSING_DER_PRIVATE_KEY: 00352 kcm_error_string = (char*)g_fcc_crypto_parsing_der_pivate_key_error_str; 00353 break; 00354 case KCM_CRYPTO_STATUS_PARSING_DER_PUBLIC_KEY: 00355 kcm_error_string = (char*)g_fcc_crypto_parsing_der_public_key_error_str; 00356 break; 00357 case KCM_CRYPTO_STATUS_PRIVATE_KEY_VERIFICATION_FAILED: 00358 kcm_error_string = (char*)g_fcc_crypto_verify_private_key_error_str; 00359 break; 00360 case KCM_CRYPTO_STATUS_PUBLIC_KEY_VERIFICATION_FAILED: 00361 kcm_error_string = (char*)g_fcc_crypto_verify_public_key_error_str; 00362 break; 00363 case KCM_CRYPTO_STATUS_UNSUPPORTED_CURVE: 00364 kcm_error_string = (char*)g_fcc_crypto_unsupported_curve_error_str; 00365 break; 00366 case KCM_CRYPTO_STATUS_PARSING_DER_CERT: 00367 kcm_error_string = (char*)g_fcc_crypto_parsing_der_cert_error_str; 00368 break; 00369 case KCM_CRYPTO_STATUS_CERT_EXPIRED: 00370 kcm_error_string = (char*)g_fcc_crypto_cert_expired_error_str; 00371 break; 00372 case KCM_CRYPTO_STATUS_CERT_FUTURE: 00373 kcm_error_string = (char*)g_fcc_crypto_cert_future_error_str; 00374 break; 00375 case KCM_CRYPTO_STATUS_CERT_MD_ALG: 00376 kcm_error_string = (char*)g_fcc_crypto_cert_md_alg_error_str; 00377 break; 00378 case KCM_CRYPTO_STATUS_CERT_PUB_KEY_TYPE: 00379 kcm_error_string = (char*)g_fcc_crypto_cert_public_key_type_error_str; 00380 break; 00381 case KCM_CRYPTO_STATUS_CERT_PUB_KEY: 00382 kcm_error_string = (char*)g_fcc_crypto_cert_public_key_error_str; 00383 break; 00384 case KCM_CRYPTO_STATUS_CERT_NOT_TRUSTED: 00385 kcm_error_string = (char*)g_fcc_crypto_cert_not_trusted_error_str; 00386 break; 00387 case KCM_CRYPTO_STATUS_INVALID_X509_ATTR: 00388 kcm_error_string = (char*)g_fcc_crypto_invalid_x509_attr_error_str; 00389 break; 00390 case KCM_CRYPTO_STATUS_PK_KEY_INVALID_FORMAT: 00391 kcm_error_string = (char*)g_fcc_crypto_invalid_pk_key_format_error_str; 00392 break; 00393 case KCM_CRYPTO_STATUS_INVALID_PK_PUBKEY: 00394 kcm_error_string = (char*)g_fcc_crypto_invalid_public_key_error_str; 00395 break; 00396 case KCM_CRYPTO_STATUS_ECP_INVALID_KEY: 00397 kcm_error_string = (char*)g_fcc_crypto_ecp_invalid_key_error_str; 00398 break; 00399 case KCM_CRYPTO_STATUS_PK_KEY_INVALID_VERSION: 00400 kcm_error_string = (char*)g_fcc_crypto_pk_key_invalid_version_error_str; 00401 break; 00402 case KCM_CRYPTO_STATUS_PK_PASSWORD_REQUIRED: 00403 kcm_error_string = (char*)g_fcc_crypto_pk_password_requerd_error_str; 00404 break; 00405 case KCM_CRYPTO_STATUS_PK_UNKNOWN_PK_ALG: 00406 kcm_error_string = (char*)g_fcc_crypto_unknown_pk_algorithm_error_str; 00407 break; 00408 default: 00409 kcm_error_string = (char*)NULL; 00410 break; 00411 } 00412 00413 if (kcm_error_string != NULL) { 00414 SA_PV_LOG_TRACE_FUNC_EXIT("kcm_error_string is %s", kcm_error_string); 00415 } 00416 return kcm_error_string; 00417 } 00418 00419 fcc_output_info_s* get_output_info(void) 00420 { 00421 return &g_output_info; 00422 } 00423 00424 void fcc_init_output_info_handler() 00425 { 00426 SA_PV_LOG_INFO_FUNC_ENTER_NO_ARGS(); 00427 00428 g_output_info.error_string_info = NULL; 00429 g_output_info.head_of_warning_list = NULL; 00430 g_output_info.tail_of_warning_list = NULL; 00431 g_output_info.size_of_warning_info_list = 0; 00432 00433 SA_PV_LOG_INFO_FUNC_EXIT_NO_ARGS(); 00434 } 00435 00436 void fcc_clean_output_info_handler() 00437 { 00438 SA_PV_LOG_INFO_FUNC_ENTER_NO_ARGS(); 00439 00440 fcc_free(g_output_info.error_string_info); 00441 g_output_info.error_string_info = NULL; 00442 00443 if (g_output_info.head_of_warning_list != NULL) { 00444 fcc_free_list_of_warnings(g_output_info.head_of_warning_list); 00445 } 00446 g_output_info.size_of_warning_info_list = 0; 00447 g_output_info.tail_of_warning_list = NULL; 00448 g_output_info.head_of_warning_list = NULL; 00449 00450 SA_PV_LOG_INFO_FUNC_EXIT_NO_ARGS(); 00451 } 00452 00453 fcc_status_e fcc_store_warning_info(const uint8_t *failed_item_name, size_t failed_item_name_size, const char *warning_string) 00454 { 00455 fcc_status_e fcc_status = FCC_STATUS_SUCCESS; 00456 fcc_warning_info_s *new_node = NULL; 00457 00458 SA_PV_ERR_RECOVERABLE_RETURN_IF((warning_string == NULL), fcc_status = FCC_STATUS_INVALID_PARAMETER, "Warning string is empty"); 00459 SA_PV_LOG_INFO_FUNC_ENTER("warning_string is %s", warning_string); 00460 //Check parameters (failed_item_name can be NULL) 00461 SA_PV_ERR_RECOVERABLE_RETURN_IF((failed_item_name != NULL && failed_item_name_size == 0), fcc_status = FCC_STATUS_INVALID_PARAMETER, "Wrong failed item name parameters"); 00462 00463 //Allocate new node 00464 new_node = (fcc_warning_info_s*)fcc_malloc(sizeof(fcc_warning_info_s)); 00465 SA_PV_ERR_RECOVERABLE_RETURN_IF((new_node == NULL), fcc_status = FCC_STATUS_MEMORY_OUT, "Failed to allocate memory for new warning list"); 00466 00467 //Set the new node with warning info (message and item name) 00468 fcc_status = fcc_set_output_string_info(warning_string, failed_item_name, failed_item_name_size, &(new_node->warning_info_string)); 00469 SA_PV_ERR_RECOVERABLE_GOTO_IF((fcc_status != FCC_STATUS_SUCCESS), fcc_status = FCC_STATUS_ERROR, exit_with_error, "Failed to set warning string info\n"); 00470 00471 //Update the list 00472 if (g_output_info.head_of_warning_list == NULL) { 00473 //In case this is the first node 00474 g_output_info.head_of_warning_list = g_output_info.tail_of_warning_list = new_node; 00475 } else { 00476 //In case this is an additional node 00477 g_output_info.tail_of_warning_list->next = new_node; 00478 g_output_info.tail_of_warning_list = new_node; 00479 } 00480 g_output_info.tail_of_warning_list->next = NULL; 00481 g_output_info.size_of_warning_info_list++; 00482 00483 SA_PV_LOG_INFO_FUNC_EXIT_NO_ARGS(); 00484 return fcc_status; 00485 00486 exit_with_error: 00487 fcc_free(new_node); 00488 return fcc_status; 00489 } 00490 00491 fcc_status_e fcc_bundle_store_error_info(const uint8_t *failed_item_name, size_t failed_item_name_size, kcm_status_e kcm_status) 00492 { 00493 fcc_status_e fcc_status = FCC_STATUS_SUCCESS; 00494 char *error_string_info = NULL; 00495 00496 SA_PV_LOG_INFO_FUNC_ENTER("kcm_status is %d", kcm_status); 00497 00498 //Check parameters (failed_item_name can be NULL) 00499 SA_PV_ERR_RECOVERABLE_RETURN_IF((kcm_status == KCM_STATUS_SUCCESS), fcc_status = FCC_STATUS_INVALID_PARAMETER, "The fcc_bundle_store_error_info should not be called with success status"); 00500 SA_PV_ERR_RECOVERABLE_RETURN_IF((failed_item_name != NULL && failed_item_name_size == 0), fcc_status = FCC_STATUS_INVALID_PARAMETER, "Wrong failed item name parameters"); 00501 00502 //Get kcm error string 00503 error_string_info = fcc_get_kcm_error_string(kcm_status); 00504 SA_PV_ERR_RECOVERABLE_RETURN_IF((error_string_info == NULL), fcc_status = FCC_STATUS_ERROR, "Failed to get kcm error string"); 00505 00506 //Store kcm error string with item name 00507 fcc_status = fcc_set_output_string_info(error_string_info, failed_item_name, failed_item_name_size, &(g_output_info.error_string_info)); 00508 SA_PV_ERR_RECOVERABLE_RETURN_IF((fcc_status != FCC_STATUS_SUCCESS), fcc_status = FCC_STATUS_ERROR, "Failed to set error string info "); 00509 00510 SA_PV_LOG_INFO_FUNC_EXIT_NO_ARGS(); 00511 return fcc_status; 00512 } 00513 00514 fcc_status_e fcc_store_error_info(const uint8_t *failed_item_name, size_t failed_item_name_size, fcc_status_e fcc_status) 00515 { 00516 fcc_status_e fcc_result = FCC_STATUS_SUCCESS; 00517 char *error_string_info = NULL; 00518 00519 SA_PV_LOG_INFO_FUNC_ENTER("fcc_status is %d", fcc_status); 00520 //Check parameters (failed_item_name can be NULL) 00521 SA_PV_ERR_RECOVERABLE_RETURN_IF((fcc_status == FCC_STATUS_SUCCESS), FCC_STATUS_INVALID_PARAMETER, "The fcc_store_error_info should not be called with success status"); 00522 SA_PV_ERR_RECOVERABLE_RETURN_IF((failed_item_name != NULL && failed_item_name_size == 0), FCC_STATUS_INVALID_PARAMETER, "Wrong failed item name parameters"); 00523 00524 //Get fcc error string 00525 error_string_info = fcc_get_fcc_error_string(fcc_status); 00526 SA_PV_ERR_RECOVERABLE_RETURN_IF((error_string_info == NULL), FCC_STATUS_ERROR, "Failed to get fcc error string"); 00527 00528 if (g_output_info.error_string_info == NULL) { 00529 //Store fcc error string with item name 00530 fcc_result = fcc_set_output_string_info(error_string_info, failed_item_name, failed_item_name_size, &(g_output_info.error_string_info)); 00531 SA_PV_ERR_RECOVERABLE_RETURN_IF((fcc_result != FCC_STATUS_SUCCESS), FCC_STATUS_ERROR, "Failed to set error string info "); 00532 } 00533 00534 SA_PV_LOG_INFO_FUNC_EXIT_NO_ARGS(); 00535 return fcc_result; 00536 } 00537 00538 char* fcc_get_output_error_info() 00539 { 00540 char *error_info = NULL; 00541 00542 SA_PV_LOG_INFO_FUNC_ENTER_NO_ARGS(); 00543 00544 if (g_output_info.error_string_info != NULL) { 00545 error_info = g_output_info.error_string_info; 00546 } 00547 00548 SA_PV_LOG_INFO_FUNC_EXIT_NO_ARGS(); 00549 return error_info; 00550 } 00551 00552 00553 char* fcc_get_output_warning_info() 00554 { 00555 char *warrning_string_collection = NULL; 00556 size_t size_of_warning_string_collection = 0; 00557 size_t total_size_of_strings_with_delimeters = 0; 00558 bool status = false; 00559 00560 SA_PV_LOG_INFO_FUNC_ENTER_NO_ARGS(); 00561 00562 if (g_output_info.head_of_warning_list == NULL || g_output_info.size_of_warning_info_list == 0) { 00563 return NULL; 00564 } else { 00565 //Get size of all warning 00566 size_of_warning_string_collection = fcc_get_size_of_all_warning_strings(); 00567 00568 //total_size_of_strings_with_delimeters -size_of_warning_string_collection +add '\n' - as delimiter between the warnings and '\0' in the end 00569 total_size_of_strings_with_delimeters = size_of_warning_string_collection + g_output_info.size_of_warning_info_list + 1; 00570 00571 //Allocate memory buffer for all warnings 00572 warrning_string_collection = fcc_malloc(total_size_of_strings_with_delimeters); 00573 if (warrning_string_collection == NULL) { 00574 SA_PV_LOG_INFO("Failed to allocate memory for warning strings"); 00575 return warrning_string_collection; 00576 } 00577 status = copy_all_warning_to_buffer(warrning_string_collection, total_size_of_strings_with_delimeters); 00578 if (status != true) { 00579 fcc_free(warrning_string_collection); 00580 return NULL; 00581 } 00582 } 00583 00584 SA_PV_LOG_INFO_FUNC_EXIT_NO_ARGS(); 00585 return warrning_string_collection; 00586 } 00587 00588 bool fcc_get_warning_status() 00589 { 00590 if (g_output_info.head_of_warning_list != NULL) { 00591 return true; 00592 } else { 00593 return false; 00594 } 00595 }
Generated on Tue Jul 12 2022 19:01:34 by
1.7.2