/*
 * CryptError.h 
 * Copyright (c) 2011 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// SOL9
// 2009/03/05

#pragma once

#include <sol/Object.h>
#include <sol/Arg.h>
#include <wincrypt.h>


namespace SOL {

class CryptError :public Object {

public:
    static const TCHAR* getMessage(DWORD errId) {
        const TCHAR* message = _T("Unknown");

        static const Arg errors[] = {

        {_T("NTE_BAD_UID: Bad UID."),
            NTE_BAD_UID},
        {_T("NTE_BAD_HASH: Bad Hash."),    
            NTE_BAD_HASH},
        {_T("NTE_BAD_KEY: Bad Key."), 
            NTE_BAD_KEY},
        {_T("NTE_BAD_LEN: Bad Length."),    
            NTE_BAD_LEN},
        {_T("NTE_BAD_DATA: Bad Data."),    
            NTE_BAD_DATA},
        {_T("NTE_BAD_SIGNATURE: Invalid Signature."), 
            NTE_BAD_SIGNATURE},
        {_T("NTE_BAD_VER: Bad Version of provider."),
            NTE_BAD_VER},
        {_T("NTE_BAD_ALGID: Invalid algorithm specified."),
            NTE_BAD_ALGID},
        {_T("NTE_BAD_FLAGS: Invalid flags specified."),
            NTE_BAD_FLAGS},
        {_T("NTE_BAD_TYPE: Invalid type specified."),
            NTE_BAD_TYPE},
        {_T("NTE_BAD_KEY_STATE: Key not valid for use in specified state."),
            NTE_BAD_KEY_STATE},
        {_T("NTE_BAD_HASH_STATE: Hash not valid for use in specified state."),
            NTE_BAD_HASH_STATE},
        {_T("NTE_NO_KEY: Key does not exist."), 
            NTE_NO_KEY},
        {_T("NTE_NO_MEMORY: Insufficient memory available for the operation."),
            NTE_NO_MEMORY},
        {_T("NTE_EXISTS: Object already exists."),
            NTE_EXISTS},
        {_T("NTE_PERM: Access denied."),
            NTE_PERM},
        {_T("NTE_NOT_FOUND: Object was not found."),
            NTE_NOT_FOUND},
        {_T("NTE_DOUBLE_ENCRYPT: Data already encrypted."),
            NTE_DOUBLE_ENCRYPT},
        {_T("NTE_BAD_PROVIDER: Invalid provider specified."),
            NTE_BAD_PROVIDER},
        {_T("NTE_BAD_PROV_TYPE: Invalid provider type specified."),
            NTE_BAD_PROV_TYPE},
        {_T("NTE_BAD_PUBLIC_KEY: Provider's public key is invalid."),
            NTE_BAD_PUBLIC_KEY},
        {_T("NTE_BAD_KEYSET: Keyset does not exist."),
            NTE_BAD_KEYSET},
        {_T("NTE_PROV_TYPE_NOT_DEF: Provider type not defined."),
            NTE_PROV_TYPE_NOT_DEF},
        {_T("NTE_PROV_TYPE_ENTRY_BAD: Provider type as registered is invalid."),
            NTE_PROV_TYPE_ENTRY_BAD},
        {_T("NTE_KEYSET_NOT_DEF: The keyset is not defined."),
            NTE_KEYSET_NOT_DEF},
        {_T("NTE_KEYSET_ENTRY_BAD: Keyset as registered is invalid."),
            NTE_KEYSET_ENTRY_BAD},
        {_T("NTE_PROV_TYPE_NO_MATCH: Provider type does not match registered value."),
            NTE_PROV_TYPE_NO_MATCH},
        {_T("NTE_SIGNATURE_FILE_BAD: The digital signature file is corrupt."),
            NTE_SIGNATURE_FILE_BAD},
        {_T("NTE_PROVIDER_DLL_FAIL: Provider DLL failed to initialize correctly."),
            NTE_PROVIDER_DLL_FAIL},
        {_T("NTE_PROV_DLL_NOT_FOUND: Provider DLL could not be found."),
            NTE_PROV_DLL_NOT_FOUND},
        {_T("NTE_BAD_KEYSET_PARAM: The Keyset parameter is invalid."),
            NTE_BAD_KEYSET_PARAM},
        {_T("NTE_FAIL: An internal error occurred."),
            NTE_FAIL},
        {_T("NTE_SYS_ERR: A base error occurred."),
            NTE_SYS_ERR},
        {_T("NTE_SILENT_CONTEXT: Provider could not perform the action since the context was acquired as silent."),
            NTE_SILENT_CONTEXT},
        {_T("NTE_TOKEN_KEYSET_STORAGE_FULL: The security token does not have storage space available for an additional container."),
            NTE_TOKEN_KEYSET_STORAGE_FULL},
        {_T("NTE_TEMPORARY_PROFILE: The profile for the user is a temporary profile."),
            NTE_TEMPORARY_PROFILE},
        {_T("NTE_FIXEDPARAMETER: The key parameters could not be set because the CSP uses fixed parameters."),
             NTE_FIXEDPARAMETER},
        {_T("NTE_INVALID_HANDLE: The supplied handle is invalid."),
            NTE_INVALID_HANDLE},
        {_T("NTE_INVALID_PARAMETER: The parameter is incorrect."),
            NTE_INVALID_PARAMETER},
        {_T("NTE_BUFFER_TOO_SMALL: The buffer supplied to a function was too small."),
            NTE_BUFFER_TOO_SMALL},
        {_T("NTE_NOT_SUPPORTED: The requested operation is not supported."),
            NTE_NOT_SUPPORTED},
        {_T("NTE_NO_MORE_ITEMS: No more data is available."),
            NTE_NO_MORE_ITEMS},
        {_T("NTE_BUFFERS_OVERLAP: The supplied buffers overlap incorrectly."),
            NTE_BUFFERS_OVERLAP},
        {_T("NTE_DECRYPTION_FAILURE: The specified data could not be decrypted."),
            NTE_DECRYPTION_FAILURE},
        {_T("NTE_INTERNAL_ERROR: An internal consistency check failed."),
            NTE_INTERNAL_ERROR},
        {_T("NTE_UI_REQUIRED: This operation requires input from the user."),
            NTE_UI_REQUIRED},
        {_T("NTE_HMAC_NOT_SUPPORTED: The cryptographic provider does not support HMAC."),
            NTE_HMAC_NOT_SUPPORTED},
        };

        int num = XtNumber(errors);
        for (int i = 0; i<num; i++) {
            if (errors[i].value == errId) {
                message = errors[i].name;
                break;
            }

        }
        return message;
    }
};

}