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

    48

    /** DNS resolver */

    49

    _ERR_RESOLVER   = 0x000200,

    50

    ERR_GETADDRINFO,

    51

    ERR_GETADDRINFO_EMPTY, 

    52

    53

    /** @see sock_error_code*/

    54

    _ERR_SOCK       = 0x000300,

    55

    56

    /** @see sock_gnutls_error_code */

    57

    _ERR_GNUTLS     = 0x000400,

    58

    59

    /** Libevent errors */

    60

    _ERR_LIBEVENT   = 0x000500,

    61

    ERR_EVENT_NEW,

    62

    ERR_EVENT_ADD,

    63

    64

    /** Evsql errors */

    65

    _ERR_EVSQL      = 0x000600,

    66

    ERR_EVSQL_NEW_PQ,

    67

    68

    /** irc_proto errors */

    69

    _ERR_IRC_LINE   = 0x000700,

    70

    ERR_LINE_TOO_LONG,

    71

    ERR_LINE_INVALID_TOKEN,

    72

    ERR_INVALID_NM,

    73

    ERR_INVALID_NICK_LENGTH,

    74

    75

    /** irc_conn errors */

    76

    _ERR_IRC_CONN   = 0x000800,

    77

    ERR_IRC_CONN_REGISTER_STATE,

    78

    ERR_IRC_CONN_QUIT_STATE,

    79

    80

    /** irc_net errors */

    81

    _ERR_IRC_NET    = 0x000900,

    82

    ERR_IRC_NET_QUIT_STATE,

    83

    84

    /** @see module_error_code */

    85

    _ERR_MODULE     = 0x000a00,

    86

};

    87

    88

/**

    89

 * Table of error descriptions

    90

 */

    91

struct error_desc {

    92

    /** The flat error code */

    93

    err_t code;

    94

    95

    /** The short name */

    96

    const char *name;

    97

    98

    /** How to interpret .extra */

    99

    enum error_extra_types extra_type;

   100

};

   101

   102

/**

   103

 * An error code and associated extra infos

   104

 */

   105

struct error_info {

   106

    /** The base error code */

   107

    err_t code;

   108

   109

    union {

   110

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

   111

        int extra;

   112

   113

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

   114

        const char *extra_str;

   115

    };

   116

};

   117

   118

/**

   119

 * Translate an err_t into a function name.

   120

 */

   121

const char *error_name (err_t code);

   122

   123

/**

   124

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

   125

 */

   126

#define ERROR_MSG_MAXLEN 1024

   127

   128

/**

   129

 * Translate an error_info into a message.

   130

 *

   131

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

   132

 */

   133

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

   134

   135

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

   136

#define SUCCESS (0)

   137

   138

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

   139

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

   140

   141

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

   142

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

   143

   144

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

   145

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

   146

   147

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

   148

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

   149

   150

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

   151

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

   152

   153

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

   154

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

   155

   156

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

   157

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

   158

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

   159

   160

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

   161

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

   162

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

   163

   164

/** 

   165

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

   166

 * is being handled down-stack.

   167

 */

   168

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

   169

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

   170

   171

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

   172

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

   173

   174

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

   175

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

   176

#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)

   177

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

   178

#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)

   179

#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)

   180

   181

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

   182

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

   183

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

   185

   186

#endif