LCOV - code coverage report
Current view: top level - lib - fko_error.c (source / functions) Hit Total Coverage
Test: lcov_coverage_final.info Lines: 145 145 100.0 %
Date: 2015-08-23 Functions: 2 2 100.0 %
Branches: 143 146 97.9 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  *****************************************************************************
       3                 :            :  *
       4                 :            :  * File:    fko_error.c
       5                 :            :  *
       6                 :            :  * Purpose: Error handling functions for libfko
       7                 :            :  *
       8                 :            :  *  Fwknop is developed primarily by the people listed in the file 'AUTHORS'.
       9                 :            :  *  Copyright (C) 2009-2014 fwknop developers and contributors. For a full
      10                 :            :  *  list of contributors, see the file 'CREDITS'.
      11                 :            :  *
      12                 :            :  *  License (GNU General Public License):
      13                 :            :  *
      14                 :            :  *  This program is free software; you can redistribute it and/or
      15                 :            :  *  modify it under the terms of the GNU General Public License
      16                 :            :  *  as published by the Free Software Foundation; either version 2
      17                 :            :  *  of the License, or (at your option) any later version.
      18                 :            :  *
      19                 :            :  *  This program is distributed in the hope that it will be useful,
      20                 :            :  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
      21                 :            :  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      22                 :            :  *  GNU General Public License for more details.
      23                 :            :  *
      24                 :            :  *  You should have received a copy of the GNU General Public License
      25                 :            :  *  along with this program; if not, write to the Free Software
      26                 :            :  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
      27                 :            :  *  USA
      28                 :            :  *
      29                 :            :  *****************************************************************************
      30                 :            : */
      31                 :            : #include "fko_common.h"
      32                 :            : #include "fko.h"
      33                 :            : 
      34                 :            : #if HAVE_LIBGPGME
      35                 :            :   #include <gpgme.h>
      36                 :            : #endif
      37                 :            : 
      38                 :            : const char*
      39                 :    1037341 : fko_errstr(const int err_code)
      40                 :            : {
      41   [ +  +  +  +  :    1037341 :     switch (err_code)
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
                      + ]
      42                 :            :     {
      43                 :            :         /* Start base FKO errors
      44                 :            :         */
      45                 :            :         case FKO_SUCCESS:
      46                 :            :             return("Success");
      47                 :            : 
      48                 :            :         case FKO_ERROR_CTX_NOT_INITIALIZED:
      49                 :       9727 :             return("FKO Context is not initialized");
      50                 :            : 
      51                 :            :         case FKO_ERROR_MEMORY_ALLOCATION:
      52                 :        785 :             return("Unable to allocate memory");
      53                 :            : 
      54                 :            :         case FKO_ERROR_FILESYSTEM_OPERATION:
      55                 :         11 :             return("Read/write bytes mismatch");
      56                 :            : 
      57                 :            :         case FKO_ERROR_INVALID_DATA:
      58                 :         30 :             return("Args contain invalid data");
      59                 :            : 
      60                 :            :         case FKO_ERROR_INVALID_DATA_CLIENT_TIMEOUT_NEGATIVE:
      61                 :       1212 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_CLIENT_TIMEOUT_NEGATIVE");
      62                 :            : 
      63                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_MSGLEN_VALIDFAIL:
      64                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_MSGLEN_VALIDFAIL");
      65                 :            : 
      66                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_NON_ASCII:
      67                 :      96762 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_NON_ASCII");
      68                 :            : 
      69                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_LT_MIN_FIELDS:
      70                 :      13355 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_LT_MIN_FIELDS");
      71                 :            : 
      72                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_GT_MAX_FIELDS:
      73                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_GT_MAX_FIELDS");
      74                 :            : 
      75                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_WRONG_NUM_FIELDS:
      76                 :        570 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_WRONG_NUM_FIELDS");
      77                 :            : 
      78                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_ENC_MSG_LEN_MT_T_SIZE:
      79                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_ENC_MSG_LEN_MT_T_SIZE");
      80                 :            : 
      81                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_RAND_MISSING:
      82                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_RAND_MISSING");
      83                 :            : 
      84                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_USERNAME_MISSING:
      85                 :         63 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_USERNAME_MISSING");
      86                 :            : 
      87                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_USERNAME_TOOBIG:
      88                 :       5845 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_USERNAME_TOOBIG");
      89                 :            : 
      90                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_USERNAME_DECODEFAIL:
      91                 :        646 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_USERNAME_DECODEFAIL");
      92                 :            : 
      93                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_USERNAME_VALIDFAIL:
      94                 :      26712 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_USERNAME_VALIDFAIL");
      95                 :            : 
      96                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_TIMESTAMP_MISSING:
      97                 :         89 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_TIMESTAMP_MISSING");
      98                 :            : 
      99                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_TIMESTAMP_TOOBIG:
     100                 :      43890 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_TIMESTAMP_TOOBIG");
     101                 :            : 
     102                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_TIMESTAMP_DECODEFAIL:
     103                 :        326 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_TIMESTAMP_DECODEFAIL");
     104                 :            : 
     105                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_VERSION_MISSING:
     106                 :         83 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_VERSION_MISSING");
     107                 :            : 
     108                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_VERSION_TOOBIG:
     109                 :      29259 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_VERSION_TOOBIG");
     110                 :            : 
     111                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_MSGTYPE_MISSING:
     112                 :         69 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_MSGTYPE_MISSING");
     113                 :            : 
     114                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_MSGTYPE_TOOBIG:
     115                 :      22630 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_MSGTYPE_TOOBIG");
     116                 :            : 
     117                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_MSGTYPE_DECODEFAIL:
     118                 :         26 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_MSGTYPE_DECODEFAIL");
     119                 :            : 
     120                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_MISSING:
     121                 :         67 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_MISSING");
     122                 :            : 
     123                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_TOOBIG:
     124                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_TOOBIG");
     125                 :            : 
     126                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_DECODEFAIL:
     127                 :       1731 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_DECODEFAIL");
     128                 :            : 
     129                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_VALIDFAIL:
     130                 :       4509 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_MESSAGE_VALIDFAIL");
     131                 :            : 
     132                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_ACCESS_VALIDFAIL:
     133                 :      80635 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_ACCESS_VALIDFAIL");
     134                 :            : 
     135                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_MISSING:
     136                 :        171 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_MISSING");
     137                 :            : 
     138                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_TOOBIG:
     139                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_TOOBIG");
     140                 :            : 
     141                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_DECODEFAIL:
     142                 :        579 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_DECODEFAIL");
     143                 :            : 
     144                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_VALIDFAIL:
     145                 :      39974 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_NATACCESS_VALIDFAIL");
     146                 :            : 
     147                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_SRVAUTH_MISSING:
     148                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_SRVAUTH_MISSING");
     149                 :            : 
     150                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_SRVAUTH_DECODEFAIL:
     151                 :         58 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_SRVAUTH_DECODEFAIL");
     152                 :            : 
     153                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_SPA_EXTRA_TOOBIG:
     154                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_SPA_EXTRA_TOOBIG");
     155                 :            : 
     156                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_EXTRA_TOOBIG:
     157                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_EXTRA_TOOBIG");
     158                 :            : 
     159                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_EXTRA_DECODEFAIL:
     160                 :       1931 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_EXTRA_DECODEFAIL");
     161                 :            : 
     162                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_MISSING:
     163                 :       1340 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_MISSING");
     164                 :            : 
     165                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_TOOBIG:
     166                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_TOOBIG");
     167                 :            : 
     168                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_VALIDFAIL:
     169                 :      17330 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_VALIDFAIL");
     170                 :            : 
     171                 :            :         case FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_DECODEFAIL:
     172                 :        160 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_DECODE_TIMEOUT_DECODEFAIL");
     173                 :            : 
     174                 :            :         case FKO_ERROR_INVALID_DATA_ENCODE_MESSAGE_TOOBIG:
     175                 :          9 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCODE_MESSAGE_TOOBIG");
     176                 :            : 
     177                 :            :         case FKO_ERROR_INVALID_DATA_ENCODE_MSGLEN_VALIDFAIL:
     178                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCODE_MSGLEN_VALIDFAIL");
     179                 :            : 
     180                 :            :         case FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_VALIDFAIL:
     181                 :       4884 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_VALIDFAIL");
     182                 :            : 
     183                 :            :         case FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_TOOBIG:
     184                 :      45017 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCODE_DIGEST_TOOBIG");
     185                 :            : 
     186                 :            :         case FKO_ERROR_INVALID_DATA_ENCODE_NOTBASE64:
     187                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCODE_NOTBASE64");
     188                 :            : 
     189                 :            :         case FKO_ERROR_INVALID_DATA_ENCRYPT_MSGLEN_VALIDFAIL:
     190                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_MSGLEN_VALIDFAIL");
     191                 :            : 
     192                 :            :         case FKO_ERROR_INVALID_DATA_ENCRYPT_DIGESTLEN_VALIDFAIL:
     193                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_DIGESTLEN_VALIDFAIL");
     194                 :            : 
     195                 :            :         case FKO_ERROR_INVALID_DATA_ENCRYPT_PTLEN_VALIDFAIL:
     196                 :          9 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_PTLEN_VALIDFAIL");
     197                 :            : 
     198                 :            :         case FKO_ERROR_INVALID_DATA_ENCRYPT_RESULT_MSGLEN_VALIDFAIL:
     199                 :      43440 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_RESULT_MSGLEN_VALIDFAIL");
     200                 :            : 
     201                 :            :         case FKO_ERROR_INVALID_DATA_ENCRYPT_CIPHERLEN_DECODEFAIL:
     202                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_CIPHERLEN_DECODEFAIL");
     203                 :            : 
     204                 :            :         case FKO_ERROR_INVALID_DATA_ENCRYPT_CIPHERLEN_VALIDFAIL:
     205                 :         25 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_CIPHERLEN_VALIDFAIL");
     206                 :            : 
     207                 :            :         case FKO_ERROR_INVALID_DATA_ENCRYPT_DECRYPTED_MESSAGE_MISSING:
     208                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_DECRYPTED_MESSAGE_MISSING");
     209                 :            : 
     210                 :            :         case FKO_ERROR_INVALID_DATA_ENCRYPT_DECRYPTED_MSGLEN_VALIDFAIL:
     211                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_DECRYPTED_MSGLEN_VALIDFAIL");
     212                 :            : 
     213                 :            :         case FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_MESSAGE_VALIDFAIL:
     214                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_MESSAGE_VALIDFAIL");
     215                 :            : 
     216                 :            :         case FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_DIGEST_VALIDFAIL:
     217                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_DIGEST_VALIDFAIL");
     218                 :            : 
     219                 :            :         case FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_MSGLEN_VALIDFAIL:
     220                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_MSGLEN_VALIDFAIL");
     221                 :            : 
     222                 :            :         case FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_RESULT_MSGLEN_VALIDFAIL:
     223                 :          9 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_RESULT_MSGLEN_VALIDFAIL");
     224                 :            : 
     225                 :            :         case FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_CIPHER_DECODEFAIL:
     226                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_CIPHER_DECODEFAIL");
     227                 :            : 
     228                 :            :         case FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_ENCODEDMSG_NULL:
     229                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_ENCODEDMSG_NULL");
     230                 :            : 
     231                 :            :         case FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_ENCODEDMSGLEN_VALIDFAIL:
     232                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_GPG_ENCODEDMSGLEN_VALIDFAIL");
     233                 :            : 
     234                 :            :         case FKO_ERROR_INVALID_DATA_ENCRYPT_TYPE_VALIDFAIL:
     235                 :       2435 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_TYPE_VALIDFAIL");
     236                 :            : 
     237                 :            :         case FKO_ERROR_INVALID_DATA_ENCRYPT_MODE_VALIDFAIL:
     238                 :       2424 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_MODE_VALIDFAIL");
     239                 :            : 
     240                 :            :         case FKO_ERROR_INVALID_DATA_ENCRYPT_TYPE_UNKNOWN:
     241                 :     219956 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_ENCRYPT_TYPE_UNKNOWN");
     242                 :            : 
     243                 :            :         case FKO_ERROR_INVALID_DATA_FUNCS_NEW_ENCMSG_MISSING:
     244                 :         15 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_FUNCS_NEW_ENCMSG_MISSING");
     245                 :            : 
     246                 :            :         case FKO_ERROR_INVALID_DATA_FUNCS_NEW_MSGLEN_VALIDFAIL:
     247                 :         17 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_FUNCS_NEW_MSGLEN_VALIDFAIL");
     248                 :            : 
     249                 :            :         case FKO_ERROR_INVALID_DATA_FUNCS_GEN_KEYLEN_VALIDFAIL:
     250                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_FUNCS_GEN_KEYLEN_VALIDFAIL");
     251                 :            : 
     252                 :            :         case FKO_ERROR_INVALID_DATA_FUNCS_GEN_HMACLEN_VALIDFAIL:
     253                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_FUNCS_GEN_HMACLEN_VALIDFAIL");
     254                 :            : 
     255                 :            :         case FKO_ERROR_INVALID_DATA_FUNCS_GEN_KEY_ENCODEFAIL:
     256                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_FUNCS_GEN_KEY_ENCODEFAIL");
     257                 :            : 
     258                 :            :         case FKO_ERROR_INVALID_DATA_FUNCS_GEN_HMAC_ENCODEFAIL:
     259                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_FUNCS_GEN_HMAC_ENCODEFAIL");
     260                 :            : 
     261                 :            :         case FKO_ERROR_INVALID_DATA_FUNCS_SET_MSGLEN_VALIDFAIL:
     262                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_FUNCS_SET_MSGLEN_VALIDFAIL");
     263                 :            : 
     264                 :            :         case FKO_ERROR_INVALID_DATA_HMAC_MSGLEN_VALIDFAIL:
     265                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_HMAC_MSGLEN_VALIDFAIL");
     266                 :            : 
     267                 :            :         case FKO_ERROR_INVALID_DATA_HMAC_ENCMSGLEN_VALIDFAIL:
     268                 :         18 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_HMAC_ENCMSGLEN_VALIDFAIL");
     269                 :            : 
     270                 :            :         case FKO_ERROR_INVALID_DATA_HMAC_COMPAREFAIL:
     271                 :       2249 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_HMAC_COMPAREFAIL");
     272                 :            : 
     273                 :            :         case FKO_ERROR_INVALID_DATA_HMAC_TYPE_VALIDFAIL:
     274                 :       2433 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_HMAC_TYPE_VALIDFAIL");
     275                 :            : 
     276                 :            :         case FKO_ERROR_INVALID_DATA_HMAC_LEN_VALIDFAIL:
     277                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_HMAC_LEN_VALIDFAIL");
     278                 :            : 
     279                 :            :         case FKO_ERROR_INVALID_DATA_MESSAGE_PORT_MISSING:
     280                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_MESSAGE_PORT_MISSING");
     281                 :            : 
     282                 :            :         case FKO_ERROR_INVALID_DATA_MESSAGE_TYPE_VALIDFAIL:
     283                 :       2443 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_MESSAGE_TYPE_VALIDFAIL");
     284                 :            : 
     285                 :            :         case FKO_ERROR_INVALID_DATA_MESSAGE_EMPTY:
     286                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_MESSAGE_EMPTY");
     287                 :            : 
     288                 :            :         case FKO_ERROR_INVALID_DATA_MESSAGE_CMD_MISSING:
     289                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_MESSAGE_CMD_MISSING");
     290                 :            : 
     291                 :            :         case FKO_ERROR_INVALID_DATA_MESSAGE_ACCESS_MISSING:
     292                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_MESSAGE_ACCESS_MISSING");
     293                 :            : 
     294                 :            :         case FKO_ERROR_INVALID_DATA_MESSAGE_NAT_MISSING:
     295                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_MESSAGE_NAT_MISSING");
     296                 :            : 
     297                 :            :         case FKO_ERROR_INVALID_DATA_MESSAGE_PORTPROTO_MISSING:
     298                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_MESSAGE_PORTPROTO_MISSING");
     299                 :            : 
     300                 :            :         case FKO_ERROR_INVALID_DATA_NAT_EMPTY:
     301                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_NAT_EMPTY");
     302                 :            : 
     303                 :            :         case FKO_ERROR_INVALID_DATA_RAND_LEN_VALIDFAIL:
     304                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_RAND_LEN_VALIDFAIL");
     305                 :            : 
     306                 :            :         case FKO_ERROR_INVALID_DATA_SRVAUTH_MISSING:
     307                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_SRVAUTH_MISSING");
     308                 :            : 
     309                 :            :         case FKO_ERROR_INVALID_DATA_TIMESTAMP_VALIDFAIL:
     310                 :         11 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_TIMESTAMP_VALIDFAIL");
     311                 :            : 
     312                 :            :         case FKO_ERROR_INVALID_DATA_USER_MISSING:
     313                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_USER_MISSING");
     314                 :            : 
     315                 :            :         case FKO_ERROR_INVALID_DATA_USER_FIRSTCHAR_VALIDFAIL:
     316                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_USER_FIRSTCHAR_VALIDFAIL");
     317                 :            : 
     318                 :            :         case FKO_ERROR_INVALID_DATA_USER_REMCHAR_VALIDFAIL:
     319                 :          9 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_USER_REMCHAR_VALIDFAIL");
     320                 :            : 
     321                 :            :         case FKO_ERROR_INVALID_DATA_UTIL_STRTOL_LT_MIN:
     322                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_UTIL_STRTOL_LT_MIN");
     323                 :            : 
     324                 :            :         case FKO_ERROR_INVALID_DATA_UTIL_STRTOL_GT_MAX:
     325                 :          8 :             return("Args contain invalid data: FKO_ERROR_INVALID_DATA_UTIL_STRTOL_GT_MAX");
     326                 :            : 
     327                 :            :         case FKO_ERROR_DATA_TOO_LARGE:
     328                 :          8 :             return("Value or Size of the data exceeded the max allowed");
     329                 :            : 
     330                 :            :         case FKO_ERROR_INVALID_KEY_LEN:
     331                 :       1000 :             return("Invalid key length");
     332                 :            : 
     333                 :            :         case FKO_ERROR_USERNAME_UNKNOWN:
     334                 :          8 :             return("Unable to determine username");
     335                 :            : 
     336                 :            :         case FKO_ERROR_INCOMPLETE_SPA_DATA:
     337                 :      45037 :             return("Missing or incomplete SPA data");
     338                 :            : 
     339                 :            :         case FKO_ERROR_MISSING_ENCODED_DATA:
     340                 :       6701 :             return("There is no encoded data to process");
     341                 :            : 
     342                 :            :         case FKO_ERROR_INVALID_DIGEST_TYPE:
     343                 :         13 :             return("Invalid digest type");
     344                 :            : 
     345                 :            :         case FKO_ERROR_INVALID_ALLOW_IP:
     346                 :          8 :             return("Invalid allow IP address in the SPA message data");
     347                 :            : 
     348                 :            :         case FKO_ERROR_INVALID_SPA_COMMAND_MSG:
     349                 :          8 :             return("Invalid SPA command message format");
     350                 :            : 
     351                 :            :         case FKO_ERROR_INVALID_SPA_ACCESS_MSG:
     352                 :         12 :             return("Invalid SPA access message format");
     353                 :            : 
     354                 :            :         case FKO_ERROR_INVALID_SPA_NAT_ACCESS_MSG:
     355                 :          8 :             return("Invalid SPA nat_access message format");
     356                 :            : 
     357                 :            :         case FKO_ERROR_INVALID_ENCRYPTION_TYPE:
     358                 :          8 :             return("Invalid encryption type");
     359                 :            : 
     360                 :            :         case FKO_ERROR_WRONG_ENCRYPTION_TYPE:
     361                 :          8 :             return("Wrong or inappropriate encryption type for this operation");
     362                 :            : 
     363                 :            :         case FKO_ERROR_DECRYPTION_SIZE:
     364                 :          8 :             return("Unexpected or invalid size for decrypted data");
     365                 :            : 
     366                 :            :         case FKO_ERROR_DECRYPTION_FAILURE:
     367                 :     110302 :             return("Decryption failed or decrypted data is invalid");
     368                 :            : 
     369                 :            :         case FKO_ERROR_DIGEST_VERIFICATION_FAILED:
     370                 :       7201 :             return("The computed digest did not match the digest in the spa data");
     371                 :            : 
     372                 :            :         case FKO_ERROR_INVALID_HMAC_KEY_LEN:
     373                 :          9 :             return("Invalid HMAC key length");
     374                 :            : 
     375                 :            :         case FKO_ERROR_UNSUPPORTED_HMAC_MODE:
     376                 :          8 :             return("Unsupported HMAC mode (default: SHA256)");
     377                 :            : 
     378                 :            :         case FKO_ERROR_UNSUPPORTED_FEATURE:
     379                 :          8 :             return("Unsupported or unimplemented feature or function");
     380                 :            : 
     381                 :            :         case FKO_ERROR_ZERO_OUT_DATA:
     382                 :         12 :             return("Could not zero out sensitive data");
     383                 :            : 
     384                 :            :         case FKO_ERROR_UNKNOWN:
     385                 :          8 :             return("Unknown/Unclassified error");
     386                 :            : 
     387                 :            : #if HAVE_LIBGPGME
     388                 :            :         /* Start GPGME-related errors
     389                 :            :         */
     390                 :            :         case FKO_ERROR_MISSING_GPG_KEY_DATA:
     391                 :          8 :             return("Missing GPG key data (signer or recipient not set)");
     392                 :            : 
     393                 :            :         case FKO_ERROR_GPGME_NO_OPENPGP:
     394                 :          8 :             return("This GPGME implementation does not support OpenPGP");
     395                 :            : 
     396                 :            :         case FKO_ERROR_GPGME_CONTEXT:
     397                 :          8 :             return("Unable to create GPGME context");
     398                 :            : 
     399                 :            :         case FKO_ERROR_GPGME_PLAINTEXT_DATA_OBJ:
     400                 :          8 :             return("Error creating the plaintext data object");
     401                 :            : 
     402                 :            :         case FKO_ERROR_GPGME_SET_PROTOCOL:
     403                 :          8 :             return("Unable to set GPGME to use OpenPGP protocol");
     404                 :            : 
     405                 :            :         case FKO_ERROR_GPGME_CIPHER_DATA_OBJ:
     406                 :          8 :             return("Error creating the encrypted data data object");
     407                 :            : 
     408                 :            :         case FKO_ERROR_GPGME_BAD_PASSPHRASE:
     409                 :          8 :             return("The GPG passphrase was not valid");
     410                 :            : 
     411                 :            :         case FKO_ERROR_GPGME_ENCRYPT_SIGN:
     412                 :          8 :             return("Error during the encrypt and sign operation");
     413                 :            : 
     414                 :            :         case FKO_ERROR_GPGME_CONTEXT_SIGNER_KEY:
     415                 :          8 :             return("Unable to create GPGME context for the signer key");
     416                 :            : 
     417                 :            :         case FKO_ERROR_GPGME_SIGNER_KEYLIST_START:
     418                 :          8 :             return("Error from signer keylist start operation");
     419                 :            : 
     420                 :            :         case FKO_ERROR_GPGME_SIGNER_KEY_NOT_FOUND:
     421                 :          9 :             return("The key for the given signer was not found");
     422                 :            : 
     423                 :            :         case FKO_ERROR_GPGME_SIGNER_KEY_AMBIGUOUS:
     424                 :          8 :             return("Ambiguous name/id for the signer key (mulitple matches)");
     425                 :            : 
     426                 :            :         case FKO_ERROR_GPGME_ADD_SIGNER:
     427                 :          8 :             return("Error adding the signer key to the gpgme context");
     428                 :            : 
     429                 :            :         case FKO_ERROR_GPGME_CONTEXT_RECIPIENT_KEY:
     430                 :          8 :             return("Unable to create GPGME context for the recipient key");
     431                 :            : 
     432                 :            :         case FKO_ERROR_GPGME_RECIPIENT_KEYLIST_START:
     433                 :          8 :             return("Error from signer keylist start operation");
     434                 :            : 
     435                 :            :         case FKO_ERROR_GPGME_RECIPIENT_KEY_NOT_FOUND:
     436                 :          9 :             return("The key for the given recipient was not found");
     437                 :            : 
     438                 :            :         case FKO_ERROR_GPGME_RECIPIENT_KEY_AMBIGUOUS:
     439                 :          8 :             return("Ambiguous name/id for the recipient key (mulitple matches)");
     440                 :            : 
     441                 :            :         case FKO_ERROR_GPGME_DECRYPT_FAILED:
     442                 :         15 :             return("Decryption operation failed");
     443                 :            : 
     444                 :            :         case FKO_ERROR_GPGME_DECRYPT_UNSUPPORTED_ALGORITHM:
     445                 :          8 :             return("Decryption operation failed due to unsupported algorithm");
     446                 :            : 
     447                 :            :         case FKO_ERROR_GPGME_BAD_GPG_EXE:
     448                 :         12 :             return("Unable to stat the given GPG executable");
     449                 :            : 
     450                 :            :         case FKO_ERROR_GPGME_BAD_HOME_DIR:
     451                 :          9 :             return("Unable to stat the given GPG home directory");
     452                 :            : 
     453                 :            :         case FKO_ERROR_GPGME_SET_HOME_DIR:
     454                 :          8 :             return("Unable to set the given GPG home directory");
     455                 :            : 
     456                 :            :         case FKO_ERROR_GPGME_NO_SIGNATURE:
     457                 :          8 :             return("Missing GPG signature");
     458                 :            : 
     459                 :            :         case FKO_ERROR_GPGME_BAD_SIGNATURE:
     460                 :          8 :             return("Bad GPG signature");
     461                 :            : 
     462                 :            :         case FKO_ERROR_GPGME_SIGNATURE_VERIFY_DISABLED:
     463                 :          8 :             return("Trying to check signature with verification disabled");
     464                 :            : 
     465                 :            : #endif /* HAVE_LIBGPGME */
     466                 :            :     }
     467                 :            : 
     468                 :            : #if !HAVE_LIBGPGME
     469                 :            :     if(err_code > GPGME_ERR_START && err_code < FKO_LAST_ERROR)
     470                 :            :         return("GPG-related error code given, but GPG is not supported");
     471                 :            : #endif
     472                 :            : 
     473                 :         88 :     return("Undefined Error");
     474                 :            : }
     475                 :            : 
     476                 :            : const char*
     477                 :          9 : fko_gpg_errstr(fko_ctx_t ctx)
     478                 :            : {
     479                 :            : #if HAVE_LIBGPGME
     480                 :            : 
     481                 :            :     /* Must be initialized
     482                 :            :      */
     483 [ +  - ][ +  - ]:          9 :     if(!CTX_INITIALIZED(ctx))
     484                 :            :         return("");
     485                 :            : 
     486         [ +  - ]:          9 :     if(ctx->gpg_err)
     487                 :          9 :         return(gpgme_strerror(ctx->gpg_err));
     488                 :            : #endif /* HAVE_LIBGPGME */
     489                 :            : 
     490                 :            :     return("");
     491                 :            : }
     492                 :            : 
     493                 :            : /***EOF***/

Generated by: LCOV version 1.10