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

    ERR_ACCESS_READ,

    49

    50

    /** DNS resolver */

    51

    _ERR_RESOLVER   = 0x000200,

    52

    ERR_GETADDRINFO,

    53

    ERR_GETADDRINFO_EMPTY, 

    54

    55

    /** socket/IO errors */

    56

    _ERR_SOCK       = 0x000300,

    57

    ERR_SOCKET,         ///< socket(2) failed

    58

    ERR_CONNECT,        ///< connect(2) error - either direct or async

    59

    ERR_READ,           ///< read(2) error - will probably show up as an ERR_WRITE as well

    60

    ERR_WRITE,          ///< write(2) error - data was unsent, will probably show up as an ERR_READ as well

    61

    ERR_WRITE_EOF,      ///< write(2) gave EOF - zero bytes written

    62

    ERR_FCNTL,          ///< fcntl(2) failed

    63

    ERR_CLOSE,          ///< close(2) failed, some written data was probably not sent

    64

    ERR_GETSOCKOPT,     ///< getsockopt(2) failed

    65

    ERR_OPEN,           ///< open(2) failed

    66

    67

    /** @see sock_gnutls_error_code */

    68

    _ERR_GNUTLS     = 0x000400,

    69

    70

    /** Libevent errors */

    71

    _ERR_LIBEVENT   = 0x000500,

    72

    ERR_EVENT_NEW,

    73

    ERR_EVENT_ADD,

    74

    ERR_EVENT_DEL,

    75

    76

    /** Evsql errors */

    77

    _ERR_EVSQL      = 0x000600,

    78

    ERR_EVSQL_NEW_PQ,

    79

    ERR_EVSQL_QUERY_EXEC,

    80

    81

    /** irc_proto errors */

    82

    _ERR_IRC_LINE   = 0x000700,

    83

    ERR_LINE_TOO_LONG,

    84

    ERR_LINE_INVALID_TOKEN,

    85

    ERR_INVALID_NM,

    86

    ERR_INVALID_NICK_LENGTH,

    87

    88

    /** irc_conn errors */

    89

    _ERR_IRC_CONN   = 0x000800,

    90

    ERR_IRC_CONN_REGISTER_STATE,

    91

    ERR_IRC_CONN_QUIT_STATE,

    92

    93

    /** irc_net errors */

    94

    _ERR_IRC_NET    = 0x000900,

    95

    ERR_IRC_NET_INFO,

    96

    ERR_IRC_NET_STATE,

    97

    98

    /** @see module_error_code */

    99

    _ERR_MODULE     = 0x000a00,

   100

   101

    /** config errors */

   102

    _ERR_CONFIG     = 0x000b00,

   103

    ERR_CONFIG_NAME,        ///< unknown option name

   104

    ERR_CONFIG_TYPE,        ///< invalid value type for parameter

   105

    ERR_CONFIG_REQUIRED,    ///< missing value for required parameter

   106

    ERR_CONFIG_VALUE,       ///< invalid value

   107

    ERR_CONFIG_PARAMS,      ///< invalid number of parameters

   108

   109

    /** lua errors */

   110

    _ERR_LUA        = 0x000c00,

   111

    ERR_LUA_MEM,

   112

    ERR_LUA_SYNTAX,

   113

    ERR_LUA_RUN,

   114

    ERR_LUA_ERR,

   115

    ERR_LUA_FILE,

   116

   117

    /** irc_chan errors */

   118

    _ERR_IRC_CHAN   = 0x000d00,

   119

    ERR_IRC_CHAN_STATE,

   120

   121

    /** pcre errors */

   122

    _ERR_PCRE       = 0x000e00,

   123

    ERR_PCRE_COMPILE,       ///< pcre_compile: <error_msg>

   124

    ERR_PCRE_EXEC,          ///< pcre_exec: <error code>

   125

   126

    /** str errors */

   127

    _ERR_STR        = 0x000f00,

   128

   129

    /** Transport errors */

   130

    _ERR_TRANSPORT  = 0x001000,

   131

   132

    /** General errors */

   133

    _ERR_GENERAL    = 0xffff00,

   134

    ERR_MISC,               ///< general error

   135

    ERR_CMD_OPT,            ///< invalid commandline option

   136

    ERR_UNKNOWN,

   137

    ERR_DUP_NAME,           ///< duplicate name

   138

    ERR_EOF,                ///< end of file

   141

};

   142

   143

/**

   144

 * Table of error descriptions

   145

 */

   146

struct error_desc {

   147

    /** The flat error code */

   148

    err_t code;

   149

   150

    /** The short name */

   151

    const char *name;

   152

   153

    /** How to interpret .extra */

   154

    enum error_extra_types extra_type;

   155

};

   156

   157

/**

   158

 * An error code and associated extra infos

   159

 */

   160

struct error_info {

   161

    /** The base error code */

   162

    err_t code;

   163

   164

    union {

   165

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

   166

        int extra;

   167

   168

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

   169

        const char *extra_str;

   170

    };

   171

};

   172

   173

/**

   174

 * The public names

   175

 */

   176

typedef struct error_info error_t;

   177

   178

/**

   179

 * Translate an err_t into a function name.

   180

 */

   181

const char *error_name (err_t code);

   182

   183

/**

   184

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

   185

 */

   186

#define ERROR_MSG_MAXLEN 1024

   187

   188

/**

   189

 * Translate an error_info into a message.

   190

 *

   191

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

   192

 */

   193

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

   194

   195

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

   196

#define SUCCESS (0)

   197

   198

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

   199

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

   200

   201

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

   202

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

   203

   204

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

   205

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

   206

   207

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

   208

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

   209

   210

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

   211

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

   212

   213

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

   214

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

   215

   216

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

   217

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

   218

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

   219

   220

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

   221

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

   222

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

   223

   224

/** 

   225

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

   226

 * is being handled down-stack.

   227

 */

   228

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

   229

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

   230

   231

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

   232

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

   233

   234

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

   235

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

   236

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

   237

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

   238

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

   239

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

   240

   241

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

   242

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

   243

#define JUMP_SET_ERROR_EXTRA(err_info_ptr, err_code, err_extra) do { _SET_ERROR_EXTRA(err_info_ptr, err_code, err_extra); goto error; } while (0)

   244

#define JUMP_SET_ERROR_ERRNO(err_info_ptr, err_code) do { _SET_ERROR_ERRNO(err_info_ptr, err_code); goto error; } while (0)

   245

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

   246

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

   247

   248

/**

   249

 * Macro used to mark code segments that should never be executed (e.g. switch-default), kind of like assert

   250

 */

   251

#include <stdlib.h>

   252

#define NOT_REACHED() abort()

   253

   254

#endif