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 <stdio.h>
39 #include <string.h>
41 #include <stdlib.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_error_vprintf(fmt, ap);
199 va_end(ap);
201 if (ret > 0)
202 sdb_do_log(prio);
203 return ret;
204 } /* sdb_log */
206 int
207 sdb_error_set(const char *fmt, ...)
208 {
209 va_list ap;
210 int ret;
212 va_start(ap, fmt);
213 ret = sdb_error_vprintf(fmt, ap);
214 va_end(ap);
216 return ret;
217 } /* sdb_error_set */
219 int
220 sdb_error_append(const char *fmt, ...)
221 {
222 va_list ap;
223 int ret;
225 va_start(ap, fmt);
226 ret = sdb_error_vappend(fmt, ap);
227 va_end(ap);
229 return ret;
230 } /* sdb_error_append */
232 int
233 sdb_error_chomp(void)
234 {
235 sdb_error_ctx_t *ctx;
237 ctx = sdb_error_get_ctx();
238 if (! ctx)
239 return -1;
241 sdb_strbuf_chomp(ctx->msg);
242 return 0;
243 } /* sdb_error_chomp */
245 int
246 sdb_error_log(int prio)
247 {
248 return sdb_do_log(prio);
249 } /* sdb_error_log */
251 const char *
252 sdb_error_get(void)
253 {
254 sdb_error_ctx_t *ctx;
256 ctx = sdb_error_get_ctx();
257 if (! ctx)
258 return "success";
259 return sdb_strbuf_string(ctx->msg);
260 } /* sdb_error_get */
262 int
263 sdb_error_get_prio(void)
264 {
265 sdb_error_ctx_t *ctx;
267 ctx = sdb_error_get_ctx();
268 if (! ctx)
269 return -1;
270 return ctx->prio;
271 } /* sdb_error_get_prio */
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
294 strerrbuf[buflen - 1] = '\0';
295 return strerrbuf;
296 } /* sdb_strerror */
298 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */