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_GETADDRINFO,                    "getaddrinfo",                              ERR_EXTRA_GAI       },

    16

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

    17

    {   ERR_EVENT_NEW,                      "event_new",                                ERR_EXTRA_NONE      },

    18

    {   ERR_EVENT_ADD,                      "event_add",                                ERR_EXTRA_NONE      },

    19

    {   ERR_EVSQL_NEW_PQ,                   "evsql_new_pq",                             ERR_EXTRA_NONE      },

    20

    {   _ERR_INVALID,                       NULL,                                       0                   }

    21

    22

}, _sock_error_desc[] = {

    23

    {   ERR_SOCKET,                         "socket",                                   ERR_EXTRA_ERRNO     },

    24

    {   ERR_CONNECT,                        "connect",                                  ERR_EXTRA_ERRNO     },

    25

    {   ERR_READ,                           "read",                                     ERR_EXTRA_ERRNO     },

    26

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

    27

    {   ERR_WRITE,                          "write",                                    ERR_EXTRA_ERRNO     },

    28

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

    29

    {   ERR_FCNTL,                          "fcntl",                                    ERR_EXTRA_ERRNO     },

    30

    {   ERR_CLOSE,                          "close",                                    ERR_EXTRA_ERRNO     },

    31

    {   _ERR_INVALID,                       NULL,                                       0                   }

    32

    33

}, _sock_gnutls_error_desc[] = {

    34

    {   ERR_GNUTLS_CERT_ALLOC_CRED,         "gnutls_certificate_allocate_credentials",  ERR_EXTRA_GNUTLS    },

    35

    {   ERR_GNUTLS_GLOBAL_INIT,             "gnutls_global_init",                       ERR_EXTRA_GNUTLS    },

    36

    {   ERR_GNUTLS_SET_DEFAULT_PRIORITY,    "gnutls_set_default_priority",              ERR_EXTRA_GNUTLS    },

    37

    {   ERR_GNUTLS_CRED_SET,                "gnutls_credentials_set",                   ERR_EXTRA_GNUTLS    },

    38

    {   ERR_GNUTLS_HANDSHAKE,               "gnutls_handshake",                         ERR_EXTRA_GNUTLS    },

    39

    {   ERR_GNUTLS_RECORD_SEND,             "gnutls_record_send",                       ERR_EXTRA_GNUTLS    },

    40

    {   ERR_GNUTLS_RECORD_RECV,             "gnutls_record_recv",                       ERR_EXTRA_GNUTLS    },

    41

    {   ERR_GNUTLS_RECORD_GET_DIRECTION,    "gnutls_record_get_direction",              ERR_EXTRA_GNUTLS    },

    42

    {   _ERR_INVALID,                       NULL,                                       0                   }

    43

    44

}, _irc_proto_error_desc[] = {

    45

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

    46

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

    47

    {   ERR_INVALID_NM,                     "Invalid nickmask",                         ERR_EXTRA_NONE      },

    48

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

    49

    {   _ERR_INVALID,                       NULL,                                       0                   }

    50

}, _module_error_desc[] = {

    52

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

    54

    {   ERR_MODULE_CONF,                    "module_conf",                              ERR_EXTRA_STR       },

    55

    {   _ERR_INVALID,                       NULL,                                       0                   }

    56

};

    57

    58

/**

    59

 * Array of error_desc tables

    60

 */

    61

static struct error_desc* _desc_tables[] = {

    62

    _core_error_desc,

    63

    _sock_error_desc,

    64

    _sock_gnutls_error_desc,

    65

    _irc_proto_error_desc,

    66

    _module_error_desc,

    67

    NULL

    68

};

    69

    70

/**

    71

 * Look up the error_desc for the given error code

    72

 */

    73

static const struct error_desc* error_lookup_desc (err_t code)

    74

{

    75

    struct error_desc **desc_table, *desc = NULL;

    76

    77

    // iterate over each defined error_desc array

    78

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

    79

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

    80

            // compare code

    81

            if (desc->code == code)

    82

                // found

    83

                return desc;

    84

        }

    85

    }

    86

    87

    // not found

    88

    return NULL;    

    89

}

    90

    91

const char *error_name (err_t code)

    92

{

    93

    const struct error_desc *desc;

    94

    95

    // do we have an error_desc for it?

    96

    if ((desc = error_lookup_desc(code)))

    97

        return desc->name;

    98

    else

    99

        // unknown

   100

        return "[unknown]";

   101

}

   102

   103

const char *error_msg (const struct error_info *err)

   104

{

   105

    static char msg[ERROR_MSG_MAXLEN];

   106

    const struct error_desc *desc;

   107

   108

    // do we have an error_desc for it?

   109

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

   110

        // ???

   111

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

   112

   113

    else

   114

        // intrepret .extra

   115

        switch (desc->extra_type) {

   116

            case ERR_EXTRA_NONE:

   117

                // no additional info

   118

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

   119

                break;

   120

   121

            case ERR_EXTRA_ERRNO:

   122

                // strerror

   123

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

   124

                break;

   125

   126

            case ERR_EXTRA_GAI:

   127

                // gai_strerror

   128

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

   129

                break;

   130

   131

            case ERR_EXTRA_GNUTLS:

   132

                // gnutls_strerror

   133

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

   134

                break;

   135

   136

            case ERR_EXTRA_STR:

   137

                // static error message string

   138

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

   139

                break;

   140

   141

            default:

   142

                // ???

   143

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

   144

                break;

   145

        }   

   146

   147

    // return static pointer

   148

    return msg;

   149

}

   150