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 <stdio.h>
  39 #include <string.h>
  40
  41 #include <stdlib.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_error_vprintf(fmt, ap);
 199         va_end(ap);
 200
 201         if (ret > 0)
 202                 sdb_do_log(prio);
 203         return ret;
 204 } /* sdb_log */
 205
 206 int
 207 sdb_error_set(const char *fmt, ...)
 208 {
 209         va_list ap;
 210         int ret;
 211
 212         va_start(ap, fmt);
 213         ret = sdb_error_vprintf(fmt, ap);
 214         va_end(ap);
 215
 216         return ret;
 217 } /* sdb_error_set */
 218
 219 int
 220 sdb_error_append(const char *fmt, ...)
 221 {
 222         va_list ap;
 223         int ret;
 224
 225         va_start(ap, fmt);
 226         ret = sdb_error_vappend(fmt, ap);
 227         va_end(ap);
 228
 229         return ret;
 230 } /* sdb_error_append */
 231
 232 int
 233 sdb_error_chomp(void)
 234 {
 235         sdb_error_ctx_t *ctx;
 236
 237         ctx = sdb_error_get_ctx();
 238         if (! ctx)
 239                 return -1;
 240
 241         sdb_strbuf_chomp(ctx->msg);
 242         return 0;
 243 } /* sdb_error_chomp */
 244
 245 int
 246 sdb_error_log(int prio)
 247 {
 248         return sdb_do_log(prio);
 249 } /* sdb_error_log */
 250
 251 const char *
 252 sdb_error_get(void)
 253 {
 254         sdb_error_ctx_t *ctx;
 255
 256         ctx = sdb_error_get_ctx();
 257         if (! ctx)
 258                 return "success";
 259         return sdb_strbuf_string(ctx->msg);
 260 } /* sdb_error_get */
 261
 262 int
 263 sdb_error_get_prio(void)
 264 {
 265         sdb_error_ctx_t *ctx;
 266
 267         ctx = sdb_error_get_ctx();
 268         if (! ctx)
 269                 return -1;
 270         return ctx->prio;
 271 } /* sdb_error_get_prio */
 272
 273 char *
 274 sdb_strerror(int errnum, char *strerrbuf, size_t buflen)
 275 {
 276 #if STRERROR_R_CHAR_P
 277         {
 278                 char *tmp = strerror_r(errnum, strerrbuf, buflen);
 279                 if (*strerrbuf = '\0') {
 280                         if (tmp && (tmp != strerrbuf) && (*tmp != '\0'))
 281                                 strncpy(strerrbuf, tmp, buflen);
 282                         else
 283                                 snprintf(strerrbuf, buflen, "unknown error #%i "
 284                                                 "(strerror_r(3) did not return an error message)",
 285                                                 errnum);
 286                 }
 287         }
 288 #else
 289         if (strerror_r(errnum, strerrbuf, buflen))
 290                 snprintf(strerrbuf, buflen, "unknown error #%i "
 291                                 "(strerror_r(3) failed)", errnum);
 292 #endif
 293
 294         strerrbuf[buflen - 1] = '\0';
 295         return strerrbuf;
 296 } /* sdb_strerror */
 297
 298 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 299