1

     2

#include "error.h"

     3

     4

// for the error_desc tables

     5

#include "sock.h"

     6

#include "sock_gnutls.h"

     7

#include "module.h"

     8

     9

#include <string.h>

    10

#include <stdio.h>

    11

    12

struct error_desc _core_error_desc[] = {

    13

    {   ERR_CALLOC,                         "calloc",                                   ERR_EXTRA_NONE      },

    14

    {   ERR_STRDUP,                         "strdup",                                   ERR_EXTRA_NONE      },

    15

    {   ERR_SIGACTION,                      "sigaction",                                ERR_EXTRA_ERRNO     },

    16

    {   ERR_ACCESS_READ,                    "access(R_OK)",                             ERR_EXTRA_ERRNO     },

    17

    {   ERR_GETADDRINFO,                    "getaddrinfo",                              ERR_EXTRA_GAI       },

    18

    {   ERR_GETADDRINFO_EMPTY,              "getaddrinfo: no results",                  ERR_EXTRA_NONE      },

    19

    {   ERR_EVENT_NEW,                      "event_new",                                ERR_EXTRA_NONE      },

    20

    {   ERR_EVENT_ADD,                      "event_add",                                ERR_EXTRA_NONE      },

    21

    {   ERR_EVSQL_NEW_PQ,                   "evsql_new_pq",                             ERR_EXTRA_NONE      },

    22

    {   ERR_EVSQL_QUERY_EXEC,               "evsql_query_exec",                         ERR_EXTRA_NONE      },

    23

    {   ERR_CMD_OPT,                        "argv",                                     ERR_EXTRA_STR       },

    24

    {   _ERR_INVALID,                       NULL,                                       0                   }

    25

    26

}, _sock_error_desc[] = {

    27

    {   ERR_SOCKET,                         "socket",                                   ERR_EXTRA_ERRNO     },

    28

    {   ERR_CONNECT,                        "connect",                                  ERR_EXTRA_ERRNO     },

    29

    {   ERR_READ,                           "read",                                     ERR_EXTRA_ERRNO     },

    30

    {   ERR_READ_EOF,                       "read: EOF",                                ERR_EXTRA_NONE      },

    31

    {   ERR_WRITE,                          "write",                                    ERR_EXTRA_ERRNO     },

    32

    {   ERR_WRITE_EOF,                      "write: EOF",                               ERR_EXTRA_NONE      },

    33

    {   ERR_FCNTL,                          "fcntl",                                    ERR_EXTRA_ERRNO     },

    34

    {   ERR_CLOSE,                          "close",                                    ERR_EXTRA_ERRNO     },

    35

    {   _ERR_INVALID,                       NULL,                                       0                   }

    36

    37

}, _sock_gnutls_error_desc[] = {

    38

    {   ERR_GNUTLS_CERT_ALLOC_CRED,         "gnutls_certificate_allocate_credentials",  ERR_EXTRA_GNUTLS    },

    39

    {   ERR_GNUTLS_GLOBAL_INIT,             "gnutls_global_init",                       ERR_EXTRA_GNUTLS    },

    40

    {   ERR_GNUTLS_SET_DEFAULT_PRIORITY,    "gnutls_set_default_priority",              ERR_EXTRA_GNUTLS    },

    41

    {   ERR_GNUTLS_CRED_SET,                "gnutls_credentials_set",                   ERR_EXTRA_GNUTLS    },

    42

    {   ERR_GNUTLS_HANDSHAKE,               "gnutls_handshake",                         ERR_EXTRA_GNUTLS    },

    43

    {   ERR_GNUTLS_RECORD_SEND,             "gnutls_record_send",                       ERR_EXTRA_GNUTLS    },

    44

    {   ERR_GNUTLS_RECORD_RECV,             "gnutls_record_recv",                       ERR_EXTRA_GNUTLS    },

    45

    {   ERR_GNUTLS_RECORD_GET_DIRECTION,    "gnutls_record_get_direction",              ERR_EXTRA_GNUTLS    },

    46

    {   _ERR_INVALID,                       NULL,                                       0                   }

    47

    48

}, _irc_error_desc[] = {

    49

    {   ERR_LINE_TOO_LONG,                  "IRC line is too long",                     ERR_EXTRA_NONE      },

    50

    {   ERR_LINE_INVALID_TOKEN,             "Illegal token value for IRC line",         ERR_EXTRA_NONE      },

    51

    {   ERR_INVALID_NM,                     "Invalid nickmask",                         ERR_EXTRA_NONE      },

    52

    {   ERR_INVALID_NICK_LENGTH,            "Nickname is too long",                     ERR_EXTRA_NONE      },

    53

    54

    // extra: the name of the invalid field

    55

    {   ERR_IRC_NET_INFO,                   "invalid irc_net_info",                     ERR_EXTRA_STR       },

    56

    {   ERR_IRC_NET_STATE,                  "invalid irc_net state for operation",      ERR_EXTRA_NONE      },

    57

    {   ERR_IRC_CHAN_STATE,                 "invalid irc_chan state for operation",     ERR_EXTRA_NONE      },

    58

    59

    {   _ERR_INVALID,                       NULL,                                       0                   }

    60

    61

}, _config_error_desc[] = {

    62

    // extra: the (unknown) config field name

    63

    {   ERR_CONFIG_NAME,                    "no matching config name",                  ERR_EXTRA_STR       },

    64

    65

    // XXX: extra: the mismatching types

    66

    {   ERR_CONFIG_TYPE,                    "wrong config type",                        ERR_EXTRA_NONE      },

    67

    68

    // extra: the name of the field with missing value

    69

    {   ERR_CONFIG_REQUIRED,                "missing required value",                   ERR_EXTRA_STR       },

    70

    71

    {   _ERR_INVALID,                       NULL,                                       0                   }

    72

    73

}, _module_error_desc[] = {

    74

    {   ERR_MODULE_NAME,                    "invalid module name",                      ERR_EXTRA_NONE      },

    75

    {   ERR_MODULE_DUP,                     "module already loaded",                    ERR_EXTRA_NONE      },

    76

    {   ERR_MODULE_PATH,                    "invalid module path",                      ERR_EXTRA_STR       },

    77

    {   ERR_MODULE_OPEN,                    "module dlopen() failed",                   ERR_EXTRA_STR       },

    78

    {   ERR_MODULE_SYM,                     "module dlsym() failed",                    ERR_EXTRA_STR       },

    79

    {   ERR_MODULE_INIT_FUNC,               "invalid module init func",                 ERR_EXTRA_STR       },

    80

    {   ERR_MODULE_CONF,                    "module_conf",                              ERR_EXTRA_STR       },

    81

    {   _ERR_INVALID,                       NULL,                                       0                   }

    82

    83

}, _lua_error_desc[] = {

    84

    {   ERR_LUA_MEM,                        "lua: out of memory",                       ERR_EXTRA_STR       },

    85

    {   ERR_LUA_SYNTAX,                     "lua: syntax error",                        ERR_EXTRA_STR       },

    86

    {   ERR_LUA_RUN,                        "lua: runtime error",                       ERR_EXTRA_STR       },

    87

    {   ERR_LUA_ERR,                        "lua: error handling error",                ERR_EXTRA_STR       },

    88

    {   ERR_LUA_FILE,                       "lua: error loading file",                  ERR_EXTRA_STR       },

    89

    {   _ERR_INVALID,                       NULL,                                       0                   }

    90

};

    91

    92

/**

    93

 * Array of error_desc tables

    94

 */

    95

static struct error_desc* _desc_tables[] = {

    96

    _core_error_desc,

    97

    _sock_error_desc,

    98

    _sock_gnutls_error_desc,

    99

    _irc_error_desc,

   100

    _module_error_desc,

   101

    _lua_error_desc,

   102

    NULL

   103

};

   104

   105

/**

   106

 * Look up the error_desc for the given error code

   107

 */

   108

static const struct error_desc* error_lookup_desc (err_t code)

   109

{

   110

    struct error_desc **desc_table, *desc = NULL;

   111

   112

    // iterate over each defined error_desc array

   113

    for (desc_table = _desc_tables; *desc_table; desc_table++) {

   114

        for (desc = *desc_table; desc->code && desc->name; desc++) {

   115

            // compare code

   116

            if (desc->code == code)

   117

                // found

   118

                return desc;

   119

        }

   120

    }

   121

   122

    // not found

   123

    return NULL;    

   124

}

   125

   126

const char *error_name (err_t code)

   127

{

   128

    const struct error_desc *desc;

   129

   130

    // do we have an error_desc for it?

   131

    if ((desc = error_lookup_desc(code)))

   132

        return desc->name;

   133

    else

   134

        // unknown

   135

        return "[unknown]";

   136

}

   137

   138

const char *error_msg (const struct error_info *err)

   139

{

   140

    static char msg[ERROR_MSG_MAXLEN];

   141

    const struct error_desc *desc;

   142

   143

    // do we have an error_desc for it?

   144

    if ((desc = error_lookup_desc(err->code)) == NULL)

   145

        // ???

   146

        snprintf(msg, ERROR_MSG_MAXLEN, "[%#.8x]: %#.8x", err->code, err->extra);

   147

   148

    else

   149

        // intrepret .extra

   150

        switch (desc->extra_type) {

   151

            case ERR_EXTRA_NONE:

   152

                // no additional info

   153

                snprintf(msg, ERROR_MSG_MAXLEN, "%s", desc->name);

   154

                break;

   155

   156

            case ERR_EXTRA_ERRNO:

   157

                // strerror

   158

                snprintf(msg, ERROR_MSG_MAXLEN, "%s: %s", desc->name, strerror(err->extra));

   159

                break;

   160

   161

            case ERR_EXTRA_GAI:

   162

                // gai_strerror

   163

                snprintf(msg, ERROR_MSG_MAXLEN, "%s: %s", desc->name, gai_strerror(err->extra));

   164

                break;

   165

   166

            case ERR_EXTRA_GNUTLS:

   167

                // gnutls_strerror

   168

                snprintf(msg, ERROR_MSG_MAXLEN, "%s: %s", desc->name, gnutls_strerror(err->extra));

   169

                break;

   170

   171

            case ERR_EXTRA_STR:

   172

                // static error message string

   173

                snprintf(msg, ERROR_MSG_MAXLEN, "%s: %s", desc->name, err->extra_str);

   174

                break;

   175

   176

            default:

   177

                // ???

   178

                snprintf(msg, ERROR_MSG_MAXLEN, "%s: %#.8x", desc->name, err->extra);

   179

                break;

   180

        }   

   181

   182

    // return static pointer

   183

    return msg;

   184

}

   185