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 #include "utils/error.h"
  29 #include "utils/strbuf.h"
  30
  31 #include <pthread.h>
  32
  33 #include <stdarg.h>
  34 #include <stdio.h>
  35 #include <string.h>
  36
  37 #include <stdlib.h>
  38
  39 /*
  40  * private data types
  41  */
  42
  43 typedef struct {
  44         int   prio;
  45         sdb_strbuf_t *msg;
  46         _Bool logged;
  47 } sdb_error_ctx_t;
  48 #define SDB_ERROR_INIT { -1, NULL, 1 }
  49
  50 /*
  51  * private variables
  52  */
  53
  54 static sdb_error_ctx_t default_error_ctx = SDB_ERROR_INIT;
  55
  56 static pthread_key_t error_ctx_key;
  57 static _Bool         error_ctx_key_initialized = 0;
  58
  59 static int (*logger)(int prio, const char *msg) = NULL;
  60
  61 /*
  62  * private helper functions
  63  */
  64
  65 static void
  66 sdb_error_ctx_destructor(void *p)
  67 {
  68         sdb_error_ctx_t *ctx = p;
  69
  70         if (! ctx)
  71                 return;
  72
  73         sdb_strbuf_destroy(ctx->msg);
  74         free(ctx);
  75 } /* sdb_error_ctx_destructor */
  76
  77 static void
  78 sdb_error_ctx_init(void)
  79 {
  80         if (error_ctx_key_initialized)
  81                 return;
  82
  83         pthread_key_create(&error_ctx_key, sdb_error_ctx_destructor);
  84         error_ctx_key_initialized = 1;
  85 } /* sdb_error_init */
  86
  87 static sdb_error_ctx_t *
  88 sdb_error_ctx_create(void)
  89 {
  90         sdb_error_ctx_t *ctx;
  91
  92         ctx = malloc(sizeof(*ctx));
  93         if (! ctx)
  94                 return NULL;
  95
  96         *ctx = default_error_ctx;
  97         ctx->msg = sdb_strbuf_create(64);
  98         if (! ctx->msg) {
  99                 free(ctx);
 100                 return NULL;
 101         }
 102
 103         if (! error_ctx_key_initialized)
 104                 sdb_error_ctx_init();
 105         pthread_setspecific(error_ctx_key, ctx);
 106         return ctx;
 107 } /* sdb_error_ctx_create */
 108
 109 static sdb_error_ctx_t *
 110 sdb_error_get_ctx(void)
 111 {
 112         sdb_error_ctx_t *ctx;
 113
 114         if (! error_ctx_key_initialized)
 115                 sdb_error_ctx_init();
 116         ctx = pthread_getspecific(error_ctx_key);
 117
 118         if (! ctx)
 119                 ctx = sdb_error_ctx_create();
 120         if (! ctx)
 121                 return NULL;
 122         return ctx;
 123 } /* sdb_error_get_ctx */
 124
 125 static int
 126 sdb_error_vprintf(const char *fmt, va_list ap)
 127 {
 128         sdb_error_ctx_t *ctx;
 129
 130         ctx = sdb_error_get_ctx();
 131         if (! ctx)
 132                 return -1;
 133
 134         ctx->logged = 0;
 135         return (int)sdb_strbuf_vsprintf(ctx->msg, fmt, ap);
 136 } /* sdb_error_vprintf */
 137
 138 static int
 139 sdb_error_vappend(const char *fmt, va_list ap)
 140 {
 141         sdb_error_ctx_t *ctx;
 142
 143         ctx = sdb_error_get_ctx();
 144         if (! ctx)
 145                 return -1;
 146
 147         ctx->logged = 0;
 148         return (int)sdb_strbuf_vappend(ctx->msg, fmt, ap);
 149 } /* sdb_error_vappend */
 150
 151 static int
 152 sdb_do_log(int prio)
 153 {
 154         sdb_error_ctx_t *ctx;
 155         int ret;
 156
 157         ctx = sdb_error_get_ctx();
 158         if (! ctx)
 159                 return -1;
 160
 161         if (prio >= 0)
 162                 ctx->prio = prio;
 163
 164         if (ctx->logged)
 165                 return 0;
 166
 167         if (logger)
 168                 ret = logger(prio, sdb_strbuf_string(ctx->msg));
 169         else
 170                 ret = fprintf(stderr, "[%s] %s\n", SDB_LOG_PRIO_TO_STRING(prio),
 171                                 sdb_strbuf_string(ctx->msg));
 172
 173         ctx->logged = 1;
 174         return ret;
 175 } /* sdb_do_log */
 176
 177 /*
 178  * public API
 179  */
 180
 181 void
 182 sdb_error_set_logger(int (*f)(int, const char *))
 183 {
 184         logger = f;
 185 } /* sdb_error_set_logger */
 186
 187 int
 188 sdb_log(int prio, const char *fmt, ...)
 189 {
 190         va_list ap;
 191         int ret;
 192
 193         va_start(ap, fmt);
 194         ret = sdb_error_vprintf(fmt, ap);
 195         va_end(ap);
 196
 197         if (ret > 0)
 198                 sdb_do_log(prio);
 199         return ret;
 200 } /* sdb_log */
 201
 202 int
 203 sdb_error_set(const char *fmt, ...)
 204 {
 205         va_list ap;
 206         int ret;
 207
 208         va_start(ap, fmt);
 209         ret = sdb_error_vprintf(fmt, ap);
 210         va_end(ap);
 211
 212         return ret;
 213 } /* sdb_error_set */
 214
 215 int
 216 sdb_error_append(const char *fmt, ...)
 217 {
 218         va_list ap;
 219         int ret;
 220
 221         va_start(ap, fmt);
 222         ret = sdb_error_vappend(fmt, ap);
 223         va_end(ap);
 224
 225         return ret;
 226 } /* sdb_error_append */
 227
 228 int
 229 sdb_error_chomp(void)
 230 {
 231         sdb_error_ctx_t *ctx;
 232
 233         ctx = sdb_error_get_ctx();
 234         if (! ctx)
 235                 return -1;
 236
 237         sdb_strbuf_chomp(ctx->msg);
 238         return 0;
 239 } /* sdb_error_chomp */
 240
 241 int
 242 sdb_error_log(int prio)
 243 {
 244         return sdb_do_log(prio);
 245 } /* sdb_error_log */
 246
 247 const char *
 248 sdb_error_get(void)
 249 {
 250         sdb_error_ctx_t *ctx;
 251
 252         ctx = sdb_error_get_ctx();
 253         if (! ctx)
 254                 return "success";
 255         return sdb_strbuf_string(ctx->msg);
 256 } /* sdb_error_get */
 257
 258 int
 259 sdb_error_get_prio(void)
 260 {
 261         sdb_error_ctx_t *ctx;
 262
 263         ctx = sdb_error_get_ctx();
 264         if (! ctx)
 265                 return -1;
 266         return ctx->prio;
 267 } /* sdb_error_get_prio */
 268
 269 char *
 270 sdb_strerror(int errnum, char *strerrbuf, size_t buflen)
 271 {
 272 #if STRERROR_R_CHAR_P
 273         {
 274                 char *tmp = strerror_r(errnum, strerrbuf, buflen);
 275                 if (*strerrbuf = '\0') {
 276                         if (tmp && (tmp != strerrbuf) && (*tmp != '\0'))
 277                                 strncpy(strerrbuf, tmp, buflen);
 278                         else
 279                                 snprintf(strerrbuf, buflen, "unknown error #%i "
 280                                                 "(strerror_r(3) did not return an error message)",
 281                                                 errnum);
 282                 }
 283         }
 284 #else
 285         if (strerror_r(errnum, strerrbuf, buflen))
 286                 snprintf(strerrbuf, buflen, "unknown error #%i "
 287                                 "(strerror_r(3) failed)", errnum);
 288 #endif
 289
 290         strerrbuf[buflen - 1] = '\0';
 291         return strerrbuf;
 292 } /* sdb_strerror */
 293
 294 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 295