1

#ifndef ERROR_H

     2

#define ERROR_H

     3

     4

/*

     5

 * Error-handling functions

     6

 */

     7

#include <errno.h>

     8

     9

/*

    10

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

    11

 * Negative error codes also exist in some places, and they are just a negative err_t.

    12

 */

    13

typedef unsigned int err_t;

    14

    15

/*

    16

 * Bitmask of error_info.extra meanings

    17

 */

    18

enum error_extra_types {

    19

    // bit offset of ERR_EXTRA_* mask in error_code

    20

    _ERR_EXTRA_OFFSET   = 3 * 8,

    21

    22

    // mask of bits used for the error_extra_types value

    23

    _ERR_EXTRA_MASK     = 0xff << _ERR_EXTRA_OFFSET,

    24

    25

    ERR_EXTRA_NONE      = 0x00 << _ERR_EXTRA_OFFSET,

    26

    ERR_EXTRA_ERRNO     = 0x01 << _ERR_EXTRA_OFFSET,

    27

    ERR_EXTRA_GAI       = 0x02 << _ERR_EXTRA_OFFSET,

    28

    ERR_EXTRA_GNUTLS    = 0x03 << _ERR_EXTRA_OFFSET,

    29

    30

};

    31

    32

    33

#define _ERROR_CODE(name, code, extra) name = (code | ERR_EXTRA_ ## extra)

    34

/*

    35

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

    36

 */

    37

enum error_code {

    38

    /* Core functions */

    39

    _ERROR_CODE( ERR_CALLOC,                        0x000100,   NONE    ),

    40

    41

    /* Network resolver errors */

    42

    _ERROR_CODE( ERR_GETADDRINFO,                   0x000200,   GAI     ),

    43

    _ERROR_CODE( ERR_GETADDRINFO_EMPTY,             0x000201,   GAI     ),

    44

    45

    /* Low-level network errors */

    46

    _ERROR_CODE( ERR_SOCKET,                        0x000301,   ERRNO   ),

    47

    _ERROR_CODE( ERR_CONNECT,                       0x000302,   ERRNO   ),

    48

    49

    /* Low-level IO errors */

    50

    _ERROR_CODE( ERR_READ,                          0x000401,   ERRNO   ),

    51

    _ERROR_CODE( ERR_READ_EOF,                      0x000402,   NONE    ),

    52

    _ERROR_CODE( ERR_WRITE,                         0x000403,   ERRNO   ),

    53

    _ERROR_CODE( ERR_WRITE_EOF,                     0x000404,   NONE    ),

    54

    _ERROR_CODE( ERR_FCNTL,                         0x000405,   ERRNO   ),

    55

    56

    /* GnuTLS errors */

    57

    _ERROR_CODE( ERR_GNUTLS_CERT_ALLOC_CRED,        0x010101,   GNUTLS  ),

    58

    _ERROR_CODE( ERR_GNUTLS_GLOBAL_INIT,            0x010102,   GNUTLS  ),

    59

    _ERROR_CODE( ERR_GNUTLS_INIT,                   0x010103,   GNUTLS  ),

    60

    _ERROR_CODE( ERR_GNUTLS_SET_DEFAULT_PRIORITY,   0x010104,   GNUTLS  ),

    61

    _ERROR_CODE( ERR_GNUTLS_CRED_SET,               0x010105,   GNUTLS  ),

    62

    _ERROR_CODE( ERR_GNUTLS_HANDSHAKE,              0x010106,   GNUTLS  ),

    63

    _ERROR_CODE( ERR_GNUTLS_RECORD_SEND,            0x010107,   GNUTLS  ),

    64

    _ERROR_CODE( ERR_GNUTLS_RECORD_RECV,            0x010108,   GNUTLS  ),

    65

    _ERROR_CODE( ERR_GNUTLS_RECORD_GET_DIRECTION,   0x010109,   GNUTLS  ),

    66

    67

    /* Libevent errors */

    68

    _ERROR_CODE( ERR_EVENT_NEW,                     0x010201,   NONE    ),

    69

    _ERROR_CODE( ERR_EVENT_ADD,                     0x010202,   NONE    ),

    70

    74

    /* irc_line errors */

    75

    _ERROR_CODE( ERR_LINE_TOO_LONG,                 0x100101,   NONE    ),

    76

    _ERROR_CODE( ERR_LINE_INVALID_TOKEN,            0x100102,   NONE    ),

    77

    78

    // mask of bits used for the error_code value

    79

    _ERROR_CODE_MASK    = 0xffffff,

    80

};

    81

    82

/*

    83

 * An error code and associated extra infos

    84

 */

    85

struct error_info {

    86

    /* The base error code */

    87

    err_t code;

    88

    89

    /* Additional detail info, usually some third-part error code */

    90

    unsigned int extra;

    91

};

    92

    93

/*

    94

 * Translate an err_t into a function name.

    95

 */

    96

const char *error_name (err_t code);

    97

    98

/*

    99

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

   100

 */

   101

#define ERROR_MSG_MAXLEN 1024

   102

   103

/*

   104

 * Translate an error_info into a message.

   105

 *

   106

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

   107

 */

   108

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

   109

   110

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

   111

#define SUCCESS (0)

   112

   113

/* Evaulates to error_info.code as lvalue */

   114

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

   115

   116

/* Evaulates to error_info.extra as lvalue */

   117

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

   118

   119

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

   120

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

   121

   122

/* Compare error_info.code != 0 */

   123

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

   124

   125

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

   126

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

   127

   128

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

   129

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

   130

   131

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

   132

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

   133

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

   134

   135

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

   136

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

   137

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

   138

   139

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

   140

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

   141

   142

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

   143

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

   144

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

   145

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

   146

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

   147

   148

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

   149

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

   150

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

   151

   152

#endif