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: 2016-06-07 Functions: 2 2 100.0 %
Branches: 143 146 97.9 %

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

Generated by: LCOV version 1.10