src/error.c
changeset 30 7f8dd120933f
parent 10 9fe218576d13
child 31 98ea2bd59195
equal deleted inserted replaced
29:3f0f2898fea3 30:7f8dd120933f
     1 
     1 
     2 #include "error.h"
     2 #include "error.h"
       
     3 
       
     4 // for the error_desc tables
       
     5 #include "sock.h"
       
     6 #include "sock_gnutls.h"
     3 
     7 
     4 #include <string.h>
     8 #include <string.h>
     5 #include <stdio.h>
     9 #include <stdio.h>
     6 
    10 
     7 #include <netdb.h>
    11 struct error_desc _core_error_desc[] = {
     8 #include <gnutls/gnutls.h>
    12     {   ERR_CALLOC,             "calloc",                       ERR_EXTRA_NONE  },
       
    13     {   ERR_GETADDRINFO,        "getaddrinfo",                  ERR_EXTRA_GAI   },
       
    14     {   ERR_GETADDRINFO_EMPTY,  "getaddrinfo: no results",      ERR_EXTRA_NONE  },
       
    15     {   ERR_EVENT_NEW,          "event_new",                    ERR_EXTRA_NONE  },
       
    16     {   ERR_EVENT_ADD,          "event_add",                    ERR_EXTRA_NONE  },
       
    17     {   ERR_EVSQL_NEW_PQ,       "evsql_new_pq",                 ERR_EXTRA_NONE  },
       
    18 };
     9 
    19 
    10 /*
    20 struct error_desc _sock_error_desc[] = {
    11  * Helper macros
    21     {   ERR_SOCKET,             "socket",           ERR_EXTRA_ERRNO },
       
    22     {   ERR_CONNECT,            "connect",          ERR_EXTRA_ERRNO },
       
    23     {   ERR_READ,               "read",             ERR_EXTRA_ERRNO },
       
    24     {   ERR_READ_EOF,           "read: EOF",        ERR_EXTRA_NONE  },
       
    25     {   ERR_WRITE,              "write",            ERR_EXTRA_ERRNO },
       
    26     {   ERR_WRITE_EOF,          "write: EOF",       ERR_EXTRA_NONE  },
       
    27     {   ERR_FCNTL,              "fcntl",            ERR_EXTRA_ERRNO },
       
    28     {   ERR_CLOSE,              "close",            ERR_EXTRA_ERRNO },
       
    29     {   _ERR_INVALID,           NULL,               0               }
       
    30 };
       
    31 
       
    32 struct error_desc _sock_gnutls_error_desc[] = {
       
    33     {   ERR_GNUTLS_CERT_ALLOC_CRED,     "gnutls_certificate_allocate_credentials",  ERR_EXTRA_GNUTLS    },
       
    34     {   ERR_GNUTLS_GLOBAL_INIT,         "gnutls_global_init",                       ERR_EXTRA_GNUTLS    },
       
    35     {   ERR_GNUTLS_SET_DEFAULT_PRIORITY,"gnutls_set_default_priority",              ERR_EXTRA_GNUTLS    },
       
    36     {   ERR_GNUTLS_CRED_SET,            "gnutls_credentials_set",                   ERR_EXTRA_GNUTLS    },
       
    37     {   ERR_GNUTLS_HANDSHAKE,           "gnutls_handshake",                         ERR_EXTRA_GNUTLS    },
       
    38     {   ERR_GNUTLS_RECORD_SEND,         "gnutls_record_send",                       ERR_EXTRA_GNUTLS    },
       
    39     {   ERR_GNUTLS_RECORD_RECV,         "gnutls_record_recv",                       ERR_EXTRA_GNUTLS    },
       
    40     {   ERR_GNUTLS_RECORD_GET_DIRECTION,"gnutls_record_get_direction",              ERR_EXTRA_GNUTLS    },
       
    41     {   _ERR_INVALID,                   NULL,                                       0                   }
       
    42 };
       
    43 
       
    44 /**
       
    45  * Array of error_desc tables
    12  */
    46  */
    13 #define ERROR_NAME(code, name) case code: return name
    47 static struct error_desc* _desc_tables[] = {
       
    48     _core_error_desc,
       
    49     _sock_error_desc,
       
    50     _sock_gnutls_error_desc,
       
    51     NULL
       
    52 };
       
    53 
       
    54 /**
       
    55  * Look up the error_desc for the given error code
       
    56  */
       
    57 static const struct error_desc* error_lookup_desc (err_t code)
       
    58 {
       
    59     struct error_desc **desc_table, *desc = NULL;
       
    60 
       
    61     // iterate over each defined error_desc array
       
    62     for (desc_table = _desc_tables; desc_table; desc_table++) {
       
    63         for (desc = *desc_table; desc->code && desc->name; desc++) {
       
    64             // compare code
       
    65             if (desc->code == code)
       
    66                 // found
       
    67                 return desc;
       
    68         }
       
    69     }
       
    70     
       
    71     // not found
       
    72     return NULL;    
       
    73 }
    14 
    74 
    15 const char *error_name (err_t code)
    75 const char *error_name (err_t code)
    16 {
    76 {
    17     switch (code) {
    77     const struct error_desc *desc;
    18         ERROR_NAME( ERR_CALLOC,                         "calloc"                                        );
    78     
    19         ERROR_NAME( ERR_GETADDRINFO,                    "getaddrinfo"                                   );
    79     // do we have an error_desc for it?
    20         ERROR_NAME( ERR_GETADDRINFO_EMPTY,              "getaddrinfo: no results"                       );
    80     if ((desc = error_lookup_desc(code)))
    21         ERROR_NAME( ERR_SOCKET,                         "socket"                                        );
    81         return desc->name;
    22         ERROR_NAME( ERR_CONNECT,                        "connect"                                       );
    82     else
    23         ERROR_NAME( ERR_READ,                           "read"                                          );
    83         // unknown
    24         ERROR_NAME( ERR_READ_EOF,                       "read: EOF"                                     );
    84         return "[unknown]";
    25         ERROR_NAME( ERR_WRITE,                          "write"                                         );
       
    26         ERROR_NAME( ERR_FCNTL,                          "fcntl"                                         );
       
    27         ERROR_NAME( ERR_GNUTLS_CERT_ALLOC_CRED,         "gnutls_certificate_allocate_credentials"       );
       
    28         ERROR_NAME( ERR_GNUTLS_GLOBAL_INIT,             "gnutls_global_init"                            );
       
    29         ERROR_NAME( ERR_GNUTLS_INIT,                    "gnutls_init"                                   );
       
    30         ERROR_NAME( ERR_GNUTLS_SET_DEFAULT_PRIORITY,    "gnutls_set_default_priority"                   );
       
    31         ERROR_NAME( ERR_GNUTLS_CRED_SET,                "gnutls_credentials_set"                        );
       
    32         ERROR_NAME( ERR_GNUTLS_HANDSHAKE,               "gnutls_handshake"                              );
       
    33         default: return "[unknown]";
       
    34     }
       
    35 }
    85 }
    36 
    86 
    37 const char *error_msg (const struct error_info *err)
    87 const char *error_msg (const struct error_info *err)
    38 {
    88 {
    39     static char msg[ERROR_MSG_MAXLEN];
    89     static char msg[ERROR_MSG_MAXLEN];
    40 
    90     const struct error_desc *desc;
    41     // intrepret .extra
    91     
    42     switch (err->code & _ERR_EXTRA_MASK) {
    92     // do we have an error_desc for it?
    43         case ERR_EXTRA_NONE:
    93     if ((desc = error_lookup_desc(err->code)) == NULL)
    44             // no additional info
    94         // ???
    45             snprintf(msg, ERROR_MSG_MAXLEN, "%s", error_name(err->code));
    95         snprintf(msg, ERROR_MSG_MAXLEN, "[%#.8x]: %#.8x", err->code, err->extra);
    46             break;
    96     
    47         
    97     else
    48         case ERR_EXTRA_ERRNO:
    98         // intrepret .extra
    49             // strerror
    99         switch (desc->extra_type) {
    50             snprintf(msg, ERROR_MSG_MAXLEN, "%s: %s", error_name(err->code), strerror(err->extra));
   100             case ERR_EXTRA_NONE:
    51             break;
   101                 // no additional info
    52         
   102                 snprintf(msg, ERROR_MSG_MAXLEN, "%s", desc->name);
    53         case ERR_EXTRA_GAI:
   103                 break;
    54             // gai_strerror
   104             
    55             snprintf(msg, ERROR_MSG_MAXLEN, "%s: %s", error_name(err->code), gai_strerror(err->extra));
   105             case ERR_EXTRA_ERRNO:
    56             break;
   106                 // strerror
    57         
   107                 snprintf(msg, ERROR_MSG_MAXLEN, "%s: %s", desc->name, strerror(err->extra));
    58         case ERR_EXTRA_GNUTLS:
   108                 break;
    59             // gnutls_strerror
   109             
    60             snprintf(msg, ERROR_MSG_MAXLEN, "%s: %s", error_name(err->code), gnutls_strerror(err->extra));
   110             case ERR_EXTRA_GAI:
    61             break;
   111                 // gai_strerror
    62         
   112                 snprintf(msg, ERROR_MSG_MAXLEN, "%s: %s", desc->name, gai_strerror(err->extra));
    63         default:
   113                 break;
    64             // ???
   114             
    65             snprintf(msg, ERROR_MSG_MAXLEN, "%s(%#.8x): %#.8x", error_name(err->code), err->code, err->extra);
   115             case ERR_EXTRA_GNUTLS:
    66             break;
   116                 // gnutls_strerror
    67     }   
   117                 snprintf(msg, ERROR_MSG_MAXLEN, "%s: %s", desc->name, gnutls_strerror(err->extra));
       
   118                 break;
       
   119             
       
   120             default:
       
   121                 // ???
       
   122                 snprintf(msg, ERROR_MSG_MAXLEN, "%s: %#.8x", desc->name, err->extra);
       
   123                 break;
       
   124         }   
    68 
   125 
    69     // return static pointer
   126     // return static pointer
    70     return msg;
   127     return msg;
    71 }
   128 }
    72 
   129