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