1

#ifndef ERROR_H

     2

#define ERROR_H

     3

     4

/**

     5

 * @file

     6

 *

     7

 * Error-handling functions

     8

 */

     9

#include <errno.h>

    10

    11

/**

    12

 * The type used for error codes is an explicitly *unsigned* int, meaning that error codes themselves are positive.

    13

 * Negative error codes (as signed ints) also exist in some places, and they are just a negative err_t.

    14

 */

    15

typedef unsigned int err_t;

    16

    17

/**

    18

 * Ways to interpret error_info.extra

    19

 */

    20

enum error_extra_types {

    21

    /** No extra info */

    22

    ERR_EXTRA_NONE      = 0,

    23

    24

    /** libc errno, using strerror() */

    25

    ERR_EXTRA_ERRNO,

    26

    27

    /** libc resolver, using gai_strerror() */

    28

    ERR_EXTRA_GAI,

    29

    30

    /** GnuTLS, using gnutls_strerror() */

    31

    ERR_EXTRA_GNUTLS,

    32

    33

    /** Static error message string */

    34

    ERR_EXTRA_STR,

    35

};

    36

    37

/**

    38

 * List of defined error codes, organized mostly by function name

    39

 */

    40

enum error_code {

    41

    _ERR_INVALID    = 0x000000,

    42

    43

    /** stdlib.h functions */

    44

    _ERR_STDLIB     = 0x000100,

    45

    ERR_CALLOC,

    46

    ERR_STRDUP,

    47

    ERR_SIGACTION,

    48

    49

    /** DNS resolver */

    50

    _ERR_RESOLVER   = 0x000200,

    51

    ERR_GETADDRINFO,

    52

    ERR_GETADDRINFO_EMPTY, 

    53

    54

    /** @see sock_error_code*/

    55

    _ERR_SOCK       = 0x000300,

    56

    57

    /** @see sock_gnutls_error_code */

    58

    _ERR_GNUTLS     = 0x000400,

    59

    60

    /** Libevent errors */

    61

    _ERR_LIBEVENT   = 0x000500,

    62

    ERR_EVENT_NEW,

    63

    ERR_EVENT_ADD,

    64

    65

    /** Evsql errors */

    66

    _ERR_EVSQL      = 0x000600,

    67

    ERR_EVSQL_NEW_PQ,

    68

    ERR_EVSQL_QUERY_EXEC,

    69

    70

    /** irc_proto errors */

    71

    _ERR_IRC_LINE   = 0x000700,

    72

    ERR_LINE_TOO_LONG,

    73

    ERR_LINE_INVALID_TOKEN,

    74

    ERR_INVALID_NM,

    75

    ERR_INVALID_NICK_LENGTH,

    76

    77

    /** irc_conn errors */

    78

    _ERR_IRC_CONN   = 0x000800,

    79

    ERR_IRC_CONN_REGISTER_STATE,

    80

    ERR_IRC_CONN_QUIT_STATE,

    81

    82

    /** irc_net errors */

    83

    _ERR_IRC_NET    = 0x000900,

    84

    ERR_IRC_NET_QUIT_STATE,

    85

    86

    /** @see module_error_code */

    87

    _ERR_MODULE     = 0x000a00,

    88

    89

    /** config errors */

    90

    _ERR_CONFIG     = 0x000b00,

    91

    ERR_CONFIG_NAME,

    92

    93

    /** General errors */

    94

    _ERR_GENERAL    = 0xffff00,

    95

    ERR_CMD_OPT,

    96

    97

};

    98

    99

/**

   100

 * Table of error descriptions

   101

 */

   102

struct error_desc {

   103

    /** The flat error code */

   104

    err_t code;

   105

   106

    /** The short name */

   107

    const char *name;

   108

   109

    /** How to interpret .extra */

   110

    enum error_extra_types extra_type;

   111

};

   112

   113

/**

   114

 * An error code and associated extra infos

   115

 */

   116

struct error_info {

   117

    /** The base error code */

   118

    err_t code;

   119

   120

    union {

   121

        /** Additional detail info, usually some third-party error code, as defined by the code's ERR_EXTRA_* */

   122

        int extra;

   123

   124

        /** Additional info, stored as a pointer to a static string (note how dangerous this is) */

   125

        const char *extra_str;

   126

    };

   127

};

   128

   129

/**

   130

 * Translate an err_t into a function name.

   131

 */

   132

const char *error_name (err_t code);

   133

   134

/**

   135

 * Maximum length of error messages returned by error_msg (including NUL byte)

   136

 */

   137

#define ERROR_MSG_MAXLEN 1024

   138

   139

/**

   140

 * Translate an error_info into a message.

   141

 *

   142

 * This is returned as a pointer into a statically allocated buffer. It is not re-entrant.

   143

 */

   144

const char *error_msg (const struct error_info *err);

   145

   146

/** No error, evaulates as logical false */

   147

#define SUCCESS (0)

   148

   149

/** Evaulates to error_info.code as lvalue */

   150

#define ERROR_CODE(err_info_ptr) ((err_info_ptr)->code)

   151

   152

/** Evaulates to error_info.extra as lvalue */

   153

#define ERROR_EXTRA(err_info_ptr) ((err_info_ptr)->extra)

   154

   155

/** Set error_info.code to SUCCESS, evaulates as zero */

   156

#define RESET_ERROR(err_info_ptr) ((err_info_ptr)->code = SUCCESS)

   157

   158

/** Compare error_info.code != 0 */

   159

#define IS_ERROR(err_info_ptr) (!!(err_info_ptr)->code)

   160

   161

/** Compare the err_code/err_extra for an err_info */

   162

#define MATCH_ERROR(err_info_ptr, err_code, err_extra) ((err_info_ptr)->code == (err_code) && (err_info_ptr)->extra == (err_extra))

   163

   164

/** Set error_info.code, but leave err_extra as-is. Evaluates to err_code */

   165

#define SET_ERROR(err_info_ptr, err_code) ((err_info_ptr)->code = (err_code))

   166

   167

/** Set error_info.code/extra. XXX: should evaluate to err_code */

   168

#define _SET_ERROR_EXTRA(err_info_ptr, err_code, err_extra) (err_info_ptr)->code = (err_code); (err_info_ptr)->extra = (err_extra)

   169

#define SET_ERROR_EXTRA(err_info_ptr, err_code, err_extra) do { _SET_ERROR_EXTRA(err_info_ptr, err_code, err_extra); } while (0)

   170

   171

/** Set error_info.code to err_code, and .extra to errno. XXX: should evaulate to err_code */

   172

#define _SET_ERROR_ERRNO(err_info_ptr, err_code) _SET_ERROR_EXTRA(err_info_ptr, err_code, errno);

   173

#define SET_ERROR_ERRNO(err_info_ptr, err_code) SET_ERROR_EXTRA(err_info_ptr, err_code, errno);

   174

   175

/** 

   176

 * Set error_info.code to err_code, and .extra_str to str. The given string pointer should remain valid while the error

   177

 * is being handled down-stack.

   178

 */

   179

#define _SET_ERROR_STR(err_info_ptr, err_code, err_str) (err_info_ptr)->code = (err_code); (err_info_ptr)->extra_str = (err_str)

   180

#define SET_ERROR_STR(err_info_ptr, err_code, err_str) do { _SET_ERROR_STR(err_info_ptr, err_code, err_str); } while(0)

   181

   182

/** Set error_info from another error_info. Evaluates to the new error_info */

   183

#define SET_ERROR_INFO(err_info_ptr, from_ptr) (*err_info_ptr = *from_ptr)

   184

   185

/** Same as above, but also return err_code from func. XXX: use 'return SET_ERROR...' instead */

   186

#define RETURN_SET_ERROR(err_info_ptr, err_code) do { SET_ERROR(err_info_ptr, err_code); return (err_code); } while (0)

   187

#define RETURN_SET_ERROR_EXTRA(err_info_ptr, err_code, err_extra) do { _SET_ERROR_EXTRA(err_info_ptr, err_code, err_extra); return (err_code); } while (0)

   188

#define RETURN_SET_ERROR_ERRNO(err_info_ptr, err_code) do { _SET_ERROR_ERRNO(err_info_ptr, err_code); return (err_code); } while (0)

   189

#define RETURN_SET_ERROR_INFO(err_info_ptr, from_ptr) do { SET_ERROR_INFO(err_info_ptr, from_ptr); return (from_ptr->code); } while (0)

   190

#define RETURN_SET_ERROR_STR(err_info_ptr, err_code, err_str) do { _SET_ERROR_STR(err_info_ptr, err_code, err_str); return (err_code); } while (0)

   191

   192

/** Same as above, but also do a 'goto error' */

   193

#define JUMP_SET_ERROR(err_info_ptr, err_code) do { SET_ERROR(err_info_ptr, err_code); goto error; } while (0)

   196

#define JUMP_SET_ERROR_INFO(err_info_ptr, from_ptr) do { SET_ERROR_INFO(err_info_ptr, from_ptr); goto error; } while (0)

   197

#define JUMP_SET_ERROR_STR(err_info_ptr, err_code, err_str) do { _SET_ERROR_STR(err_info_ptr, err_code, err_str); goto error; } while (0)

   198

   199

#endif