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 */
28 #if HAVE_CONFIG_H
29 # include "config.h"
30 #endif /* HAVE_CONFIG_H */
32 #include "utils/error.h"
33 #include "utils/strbuf.h"
35 #include <pthread.h>
37 #include <stdarg.h>
38 #include <stdbool.h>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <strings.h>
44 /*
45 * private data types
46 */
48 typedef struct {
49 int prio;
50 sdb_strbuf_t *msg;
51 bool logged;
52 } sdb_error_ctx_t;
53 #define SDB_ERROR_INIT { -1, NULL, 1 }
55 /*
56 * private variables
57 */
59 static sdb_error_ctx_t default_error_ctx = SDB_ERROR_INIT;
61 static pthread_key_t error_ctx_key;
62 static bool error_ctx_key_initialized = 0;
64 static int (*logger)(int prio, const char *msg) = NULL;
66 /*
67 * private helper functions
68 */
70 static void
71 sdb_error_ctx_destructor(void *p)
72 {
73 sdb_error_ctx_t *ctx = p;
75 if (! ctx)
76 return;
78 sdb_strbuf_destroy(ctx->msg);
79 free(ctx);
80 } /* sdb_error_ctx_destructor */
82 static void
83 sdb_error_ctx_init(void)
84 {
85 if (error_ctx_key_initialized)
86 return;
88 pthread_key_create(&error_ctx_key, sdb_error_ctx_destructor);
89 error_ctx_key_initialized = 1;
90 } /* sdb_error_init */
92 static sdb_error_ctx_t *
93 sdb_error_ctx_create(void)
94 {
95 sdb_error_ctx_t *ctx;
97 ctx = malloc(sizeof(*ctx));
98 if (! ctx)
99 return NULL;
101 *ctx = default_error_ctx;
102 ctx->msg = sdb_strbuf_create(64);
103 if (! ctx->msg) {
104 free(ctx);
105 return NULL;
106 }
108 if (! error_ctx_key_initialized)
109 sdb_error_ctx_init();
110 pthread_setspecific(error_ctx_key, ctx);
111 return ctx;
112 } /* sdb_error_ctx_create */
114 static sdb_error_ctx_t *
115 sdb_error_get_ctx(void)
116 {
117 sdb_error_ctx_t *ctx;
119 if (! error_ctx_key_initialized)
120 sdb_error_ctx_init();
121 ctx = pthread_getspecific(error_ctx_key);
123 if (! ctx)
124 ctx = sdb_error_ctx_create();
125 if (! ctx)
126 return NULL;
127 return ctx;
128 } /* sdb_error_get_ctx */
130 static int
131 sdb_error_vprintf(const char *fmt, va_list ap)
132 {
133 sdb_error_ctx_t *ctx;
135 ctx = sdb_error_get_ctx();
136 if (! ctx)
137 return -1;
139 ctx->logged = 0;
140 return (int)sdb_strbuf_vsprintf(ctx->msg, fmt, ap);
141 } /* sdb_error_vprintf */
143 static int
144 sdb_error_vappend(const char *fmt, va_list ap)
145 {
146 sdb_error_ctx_t *ctx;
148 ctx = sdb_error_get_ctx();
149 if (! ctx)
150 return -1;
152 ctx->logged = 0;
153 return (int)sdb_strbuf_vappend(ctx->msg, fmt, ap);
154 } /* sdb_error_vappend */
156 static int
157 sdb_do_log(int prio)
158 {
159 sdb_error_ctx_t *ctx;
160 int ret;
162 ctx = sdb_error_get_ctx();
163 if (! ctx)
164 return -1;
166 if (prio >= 0)
167 ctx->prio = prio;
169 if (ctx->logged)
170 return 0;
172 if (logger)
173 ret = logger(prio, sdb_strbuf_string(ctx->msg));
174 else
175 ret = fprintf(stderr, "[%s] %s\n", SDB_LOG_PRIO_TO_STRING(prio),
176 sdb_strbuf_string(ctx->msg));
178 ctx->logged = 1;
179 return ret;
180 } /* sdb_do_log */
182 /*
183 * public API
184 */
186 void
187 sdb_error_set_logger(int (*f)(int, const char *))
188 {
189 logger = f;
190 } /* sdb_error_set_logger */
192 int
193 sdb_log(int prio, const char *fmt, ...)
194 {
195 va_list ap;
196 int ret;
198 va_start(ap, fmt);
199 ret = sdb_vlog(prio, fmt, ap);
200 va_end(ap);
201 return ret;
202 } /* sdb_log */
204 int
205 sdb_vlog(int prio, const char *fmt, va_list ap)
206 {
207 int ret = sdb_error_vprintf(fmt, ap);
208 if (ret > 0)
209 sdb_do_log(prio);
210 return ret;
211 } /* sdb_vlog */
213 int
214 sdb_error_set(const char *fmt, ...)
215 {
216 va_list ap;
217 int ret;
219 va_start(ap, fmt);
220 ret = sdb_error_vprintf(fmt, ap);
221 va_end(ap);
223 return ret;
224 } /* sdb_error_set */
226 int
227 sdb_error_append(const char *fmt, ...)
228 {
229 va_list ap;
230 int ret;
232 va_start(ap, fmt);
233 ret = sdb_error_vappend(fmt, ap);
234 va_end(ap);
236 return ret;
237 } /* sdb_error_append */
239 int
240 sdb_error_chomp(void)
241 {
242 sdb_error_ctx_t *ctx;
244 ctx = sdb_error_get_ctx();
245 if (! ctx)
246 return -1;
248 sdb_strbuf_chomp(ctx->msg);
249 return 0;
250 } /* sdb_error_chomp */
252 int
253 sdb_error_log(int prio)
254 {
255 return sdb_do_log(prio);
256 } /* sdb_error_log */
258 const char *
259 sdb_error_get(void)
260 {
261 sdb_error_ctx_t *ctx;
263 ctx = sdb_error_get_ctx();
264 if (! ctx)
265 return "success";
266 return sdb_strbuf_string(ctx->msg);
267 } /* sdb_error_get */
269 int
270 sdb_error_get_prio(void)
271 {
272 sdb_error_ctx_t *ctx;
274 ctx = sdb_error_get_ctx();
275 if (! ctx)
276 return -1;
277 return ctx->prio;
278 } /* sdb_error_get_prio */
280 int
281 sdb_error_parse_priority(char *prio)
282 {
283 if (! strcasecmp(prio, "EMERG"))
284 return SDB_LOG_EMERG;
285 else if (! strcasecmp(prio, "ERROR"))
286 return SDB_LOG_ERR;
287 else if (! strcasecmp(prio, "WARNING"))
288 return SDB_LOG_WARNING;
289 else if (! strcasecmp(prio, "NOTICE"))
290 return SDB_LOG_NOTICE;
291 else if (! strcasecmp(prio, "INFO"))
292 return SDB_LOG_INFO;
293 else if (! strcasecmp(prio, "DEBUG"))
294 return SDB_LOG_DEBUG;
295 return -1;
296 } /* sdb_error_parse_priority */
298 char *
299 sdb_strerror(int errnum, char *strerrbuf, size_t buflen)
300 {
301 #if STRERROR_R_CHAR_P
302 {
303 char *tmp = strerror_r(errnum, strerrbuf, buflen);
304 if (*strerrbuf = '\0') {
305 if (tmp && (tmp != strerrbuf) && (*tmp != '\0'))
306 strncpy(strerrbuf, tmp, buflen);
307 else
308 snprintf(strerrbuf, buflen, "unknown error #%i "
309 "(strerror_r(3) did not return an error message)",
310 errnum);
311 }
312 }
313 #else
314 if (strerror_r(errnum, strerrbuf, buflen))
315 snprintf(strerrbuf, buflen, "unknown error #%i "
316 "(strerror_r(3) failed)", errnum);
317 #endif
319 strerrbuf[buflen - 1] = '\0';
320 return strerrbuf;
321 } /* sdb_strerror */
323 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */