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