src/utils/error.c

   1 /*
   2  * SysDB - src/utils/error.c
   3  * Copyright (C) 2013 Sebastian 'tokkee' Harl <sh@tokkee.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  17  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  18  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
  19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #if HAVE_CONFIG_H
  29 #       include "config.h"
  30 #endif /* HAVE_CONFIG_H */
  31
  32 #include "utils/error.h"
  33 #include "utils/strbuf.h"
  34
  35 #include <pthread.h>
  36
  37 #include <stdarg.h>
  38 #include <stdbool.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42
  43 /*
  44  * private data types
  45  */
  46
  47 typedef struct {
  48         int   prio;
  49         sdb_strbuf_t *msg;
  50         bool logged;
  51 } sdb_error_ctx_t;
  52 #define SDB_ERROR_INIT { -1, NULL, 1 }
  53
  54 /*
  55  * private variables
  56  */
  57
  58 static sdb_error_ctx_t default_error_ctx = SDB_ERROR_INIT;
  59
  60 static pthread_key_t error_ctx_key;
  61 static bool          error_ctx_key_initialized = 0;
  62
  63 static int (*logger)(int prio, const char *msg) = NULL;
  64
  65 /*
  66  * private helper functions
  67  */
  68
  69 static void
  70 sdb_error_ctx_destructor(void *p)
  71 {
  72         sdb_error_ctx_t *ctx = p;
  73
  74         if (! ctx)
  75                 return;
  76
  77         sdb_strbuf_destroy(ctx->msg);
  78         free(ctx);
  79 } /* sdb_error_ctx_destructor */
  80
  81 static void
  82 sdb_error_ctx_init(void)
  83 {
  84         if (error_ctx_key_initialized)
  85                 return;
  86
  87         pthread_key_create(&error_ctx_key, sdb_error_ctx_destructor);
  88         error_ctx_key_initialized = 1;
  89 } /* sdb_error_init */
  90
  91 static sdb_error_ctx_t *
  92 sdb_error_ctx_create(void)
  93 {
  94         sdb_error_ctx_t *ctx;
  95
  96         ctx = malloc(sizeof(*ctx));
  97         if (! ctx)
  98                 return NULL;
  99
 100         *ctx = default_error_ctx;
 101         ctx->msg = sdb_strbuf_create(64);
 102         if (! ctx->msg) {
 103                 free(ctx);
 104                 return NULL;
 105         }
 106
 107         if (! error_ctx_key_initialized)
 108                 sdb_error_ctx_init();
 109         pthread_setspecific(error_ctx_key, ctx);
 110         return ctx;
 111 } /* sdb_error_ctx_create */
 112
 113 static sdb_error_ctx_t *
 114 sdb_error_get_ctx(void)
 115 {
 116         sdb_error_ctx_t *ctx;
 117
 118         if (! error_ctx_key_initialized)
 119                 sdb_error_ctx_init();
 120         ctx = pthread_getspecific(error_ctx_key);
 121
 122         if (! ctx)
 123                 ctx = sdb_error_ctx_create();
 124         if (! ctx)
 125                 return NULL;
 126         return ctx;
 127 } /* sdb_error_get_ctx */
 128
 129 static int
 130 sdb_error_vprintf(const char *fmt, va_list ap)
 131 {
 132         sdb_error_ctx_t *ctx;
 133
 134         ctx = sdb_error_get_ctx();
 135         if (! ctx)
 136                 return -1;
 137
 138         ctx->logged = 0;
 139         return (int)sdb_strbuf_vsprintf(ctx->msg, fmt, ap);
 140 } /* sdb_error_vprintf */
 141
 142 static int
 143 sdb_error_vappend(const char *fmt, va_list ap)
 144 {
 145         sdb_error_ctx_t *ctx;
 146
 147         ctx = sdb_error_get_ctx();
 148         if (! ctx)
 149                 return -1;
 150
 151         ctx->logged = 0;
 152         return (int)sdb_strbuf_vappend(ctx->msg, fmt, ap);
 153 } /* sdb_error_vappend */
 154
 155 static int
 156 sdb_do_log(int prio)
 157 {
 158         sdb_error_ctx_t *ctx;
 159         int ret;
 160
 161         ctx = sdb_error_get_ctx();
 162         if (! ctx)
 163                 return -1;
 164
 165         if (prio >= 0)
 166                 ctx->prio = prio;
 167
 168         if (ctx->logged)
 169                 return 0;
 170
 171         if (logger)
 172                 ret = logger(prio, sdb_strbuf_string(ctx->msg));
 173         else
 174                 ret = fprintf(stderr, "[%s] %s\n", SDB_LOG_PRIO_TO_STRING(prio),
 175                                 sdb_strbuf_string(ctx->msg));
 176
 177         ctx->logged = 1;
 178         return ret;
 179 } /* sdb_do_log */
 180
 181 /*
 182  * public API
 183  */
 184
 185 void
 186 sdb_error_set_logger(int (*f)(int, const char *))
 187 {
 188         logger = f;
 189 } /* sdb_error_set_logger */
 190
 191 int
 192 sdb_log(int prio, const char *fmt, ...)
 193 {
 194         va_list ap;
 195         int ret;
 196
 197         va_start(ap, fmt);
 198         ret = sdb_vlog(prio, fmt, ap);
 199         va_end(ap);
 200         return ret;
 201 } /* sdb_log */
 202
 203 int
 204 sdb_vlog(int prio, const char *fmt, va_list ap)
 205 {
 206         int ret = sdb_error_vprintf(fmt, ap);
 207         if (ret > 0)
 208                 sdb_do_log(prio);
 209         return ret;
 210 } /* sdb_vlog */
 211
 212 int
 213 sdb_error_set(const char *fmt, ...)
 214 {
 215         va_list ap;
 216         int ret;
 217
 218         va_start(ap, fmt);
 219         ret = sdb_error_vprintf(fmt, ap);
 220         va_end(ap);
 221
 222         return ret;
 223 } /* sdb_error_set */
 224
 225 int
 226 sdb_error_append(const char *fmt, ...)
 227 {
 228         va_list ap;
 229         int ret;
 230
 231         va_start(ap, fmt);
 232         ret = sdb_error_vappend(fmt, ap);
 233         va_end(ap);
 234
 235         return ret;
 236 } /* sdb_error_append */
 237
 238 int
 239 sdb_error_chomp(void)
 240 {
 241         sdb_error_ctx_t *ctx;
 242
 243         ctx = sdb_error_get_ctx();
 244         if (! ctx)
 245                 return -1;
 246
 247         sdb_strbuf_chomp(ctx->msg);
 248         return 0;
 249 } /* sdb_error_chomp */
 250
 251 int
 252 sdb_error_log(int prio)
 253 {
 254         return sdb_do_log(prio);
 255 } /* sdb_error_log */
 256
 257 const char *
 258 sdb_error_get(void)
 259 {
 260         sdb_error_ctx_t *ctx;
 261
 262         ctx = sdb_error_get_ctx();
 263         if (! ctx)
 264                 return "success";
 265         return sdb_strbuf_string(ctx->msg);
 266 } /* sdb_error_get */
 267
 268 int
 269 sdb_error_get_prio(void)
 270 {
 271         sdb_error_ctx_t *ctx;
 272
 273         ctx = sdb_error_get_ctx();
 274         if (! ctx)
 275                 return -1;
 276         return ctx->prio;
 277 } /* sdb_error_get_prio */
 278
 279 int
 280 sdb_error_parse_priority(char *prio)
 281 {
 282         if (! strcasecmp(prio, "EMERG"))
 283                 return SDB_LOG_EMERG;
 284         else if (! strcasecmp(prio, "ERROR"))
 285                 return SDB_LOG_ERR;
 286         else if (! strcasecmp(prio, "WARNING"))
 287                 return SDB_LOG_WARNING;
 288         else if (! strcasecmp(prio, "NOTICE"))
 289                 return SDB_LOG_NOTICE;
 290         else if (! strcasecmp(prio, "INFO"))
 291                 return SDB_LOG_INFO;
 292         else if (! strcasecmp(prio, "DEBUG"))
 293                 return SDB_LOG_DEBUG;
 294         return -1;
 295 } /* sdb_error_parse_priority */
 296
 297 char *
 298 sdb_strerror(int errnum, char *strerrbuf, size_t buflen)
 299 {
 300 #if STRERROR_R_CHAR_P
 301         {
 302                 char *tmp = strerror_r(errnum, strerrbuf, buflen);
 303                 if (*strerrbuf = '\0') {
 304                         if (tmp && (tmp != strerrbuf) && (*tmp != '\0'))
 305                                 strncpy(strerrbuf, tmp, buflen);
 306                         else
 307                                 snprintf(strerrbuf, buflen, "unknown error #%i "
 308                                                 "(strerror_r(3) did not return an error message)",
 309                                                 errnum);
 310                 }
 311         }
 312 #else
 313         if (strerror_r(errnum, strerrbuf, buflen))
 314                 snprintf(strerrbuf, buflen, "unknown error #%i "
 315                                 "(strerror_r(3) failed)", errnum);
 316 #endif
 317
 318         strerrbuf[buflen - 1] = '\0';
 319         return strerrbuf;
 320 } /* sdb_strerror */
 321
 322 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 323