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>
43 /*
44 * private data types
45 */
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 }
54 /*
55 * private variables
56 */
58 static sdb_error_ctx_t default_error_ctx = SDB_ERROR_INIT;
60 static pthread_key_t error_ctx_key;
61 static bool error_ctx_key_initialized = 0;
63 static int (*logger)(int prio, const char *msg) = NULL;
65 /*
66 * private helper functions
67 */
69 static void
70 sdb_error_ctx_destructor(void *p)
71 {
72 sdb_error_ctx_t *ctx = p;
74 if (! ctx)
75 return;
77 sdb_strbuf_destroy(ctx->msg);
78 free(ctx);
79 } /* sdb_error_ctx_destructor */
81 static void
82 sdb_error_ctx_init(void)
83 {
84 if (error_ctx_key_initialized)
85 return;
87 pthread_key_create(&error_ctx_key, sdb_error_ctx_destructor);
88 error_ctx_key_initialized = 1;
89 } /* sdb_error_init */
91 static sdb_error_ctx_t *
92 sdb_error_ctx_create(void)
93 {
94 sdb_error_ctx_t *ctx;
96 ctx = malloc(sizeof(*ctx));
97 if (! ctx)
98 return NULL;
100 *ctx = default_error_ctx;
101 ctx->msg = sdb_strbuf_create(64);
102 if (! ctx->msg) {
103 free(ctx);
104 return NULL;
105 }
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 */
113 static sdb_error_ctx_t *
114 sdb_error_get_ctx(void)
115 {
116 sdb_error_ctx_t *ctx;
118 if (! error_ctx_key_initialized)
119 sdb_error_ctx_init();
120 ctx = pthread_getspecific(error_ctx_key);
122 if (! ctx)
123 ctx = sdb_error_ctx_create();
124 if (! ctx)
125 return NULL;
126 return ctx;
127 } /* sdb_error_get_ctx */
129 static int
130 sdb_error_vprintf(const char *fmt, va_list ap)
131 {
132 sdb_error_ctx_t *ctx;
134 ctx = sdb_error_get_ctx();
135 if (! ctx)
136 return -1;
138 ctx->logged = 0;
139 return (int)sdb_strbuf_vsprintf(ctx->msg, fmt, ap);
140 } /* sdb_error_vprintf */
142 static int
143 sdb_error_vappend(const char *fmt, va_list ap)
144 {
145 sdb_error_ctx_t *ctx;
147 ctx = sdb_error_get_ctx();
148 if (! ctx)
149 return -1;
151 ctx->logged = 0;
152 return (int)sdb_strbuf_vappend(ctx->msg, fmt, ap);
153 } /* sdb_error_vappend */
155 static int
156 sdb_do_log(int prio)
157 {
158 sdb_error_ctx_t *ctx;
159 int ret;
161 ctx = sdb_error_get_ctx();
162 if (! ctx)
163 return -1;
165 if (prio >= 0)
166 ctx->prio = prio;
168 if (ctx->logged)
169 return 0;
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));
177 ctx->logged = 1;
178 return ret;
179 } /* sdb_do_log */
181 /*
182 * public API
183 */
185 void
186 sdb_error_set_logger(int (*f)(int, const char *))
187 {
188 logger = f;
189 } /* sdb_error_set_logger */
191 int
192 sdb_log(int prio, const char *fmt, ...)
193 {
194 va_list ap;
195 int ret;
197 va_start(ap, fmt);
198 ret = sdb_vlog(prio, fmt, ap);
199 va_end(ap);
200 return ret;
201 } /* sdb_log */
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 */
212 int
213 sdb_error_set(const char *fmt, ...)
214 {
215 va_list ap;
216 int ret;
218 va_start(ap, fmt);
219 ret = sdb_error_vprintf(fmt, ap);
220 va_end(ap);
222 return ret;
223 } /* sdb_error_set */
225 int
226 sdb_error_append(const char *fmt, ...)
227 {
228 va_list ap;
229 int ret;
231 va_start(ap, fmt);
232 ret = sdb_error_vappend(fmt, ap);
233 va_end(ap);
235 return ret;
236 } /* sdb_error_append */
238 int
239 sdb_error_chomp(void)
240 {
241 sdb_error_ctx_t *ctx;
243 ctx = sdb_error_get_ctx();
244 if (! ctx)
245 return -1;
247 sdb_strbuf_chomp(ctx->msg);
248 return 0;
249 } /* sdb_error_chomp */
251 int
252 sdb_error_log(int prio)
253 {
254 return sdb_do_log(prio);
255 } /* sdb_error_log */
257 const char *
258 sdb_error_get(void)
259 {
260 sdb_error_ctx_t *ctx;
262 ctx = sdb_error_get_ctx();
263 if (! ctx)
264 return "success";
265 return sdb_strbuf_string(ctx->msg);
266 } /* sdb_error_get */
268 int
269 sdb_error_get_prio(void)
270 {
271 sdb_error_ctx_t *ctx;
273 ctx = sdb_error_get_ctx();
274 if (! ctx)
275 return -1;
276 return ctx->prio;
277 } /* sdb_error_get_prio */
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 */
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
318 strerrbuf[buflen - 1] = '\0';
319 return strerrbuf;
320 } /* sdb_strerror */
322 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */