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 #include "utils/error.h"
29 #include "utils/strbuf.h"
31 #include <pthread.h>
33 #include <stdarg.h>
34 #include <stdio.h>
35 #include <string.h>
37 #include <stdlib.h>
39 /*
40 * private data types
41 */
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 }
50 /*
51 * private variables
52 */
54 static sdb_error_ctx_t default_error_ctx = SDB_ERROR_INIT;
56 static pthread_key_t error_ctx_key;
57 static _Bool error_ctx_key_initialized = 0;
59 static int (*logger)(int prio, const char *msg) = NULL;
61 /*
62 * private helper functions
63 */
65 static void
66 sdb_error_ctx_destructor(void *p)
67 {
68 sdb_error_ctx_t *ctx = p;
70 if (! ctx)
71 return;
73 sdb_strbuf_destroy(ctx->msg);
74 free(ctx);
75 } /* sdb_error_ctx_destructor */
77 static void
78 sdb_error_ctx_init(void)
79 {
80 if (error_ctx_key_initialized)
81 return;
83 pthread_key_create(&error_ctx_key, sdb_error_ctx_destructor);
84 error_ctx_key_initialized = 1;
85 } /* sdb_error_init */
87 static sdb_error_ctx_t *
88 sdb_error_ctx_create(void)
89 {
90 sdb_error_ctx_t *ctx;
92 ctx = malloc(sizeof(*ctx));
93 if (! ctx)
94 return NULL;
96 *ctx = default_error_ctx;
97 ctx->msg = sdb_strbuf_create(64);
98 if (! ctx->msg) {
99 free(ctx);
100 return NULL;
101 }
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 */
109 static sdb_error_ctx_t *
110 sdb_error_get_ctx(void)
111 {
112 sdb_error_ctx_t *ctx;
114 if (! error_ctx_key_initialized)
115 sdb_error_ctx_init();
116 ctx = pthread_getspecific(error_ctx_key);
118 if (! ctx)
119 ctx = sdb_error_ctx_create();
120 if (! ctx)
121 return NULL;
122 return ctx;
123 } /* sdb_error_get_ctx */
125 static int
126 sdb_error_vprintf(const char *fmt, va_list ap)
127 {
128 sdb_error_ctx_t *ctx;
130 ctx = sdb_error_get_ctx();
131 if (! ctx)
132 return -1;
134 ctx->logged = 0;
135 return (int)sdb_strbuf_vsprintf(ctx->msg, fmt, ap);
136 } /* sdb_error_vprintf */
138 static int
139 sdb_error_vappend(const char *fmt, va_list ap)
140 {
141 sdb_error_ctx_t *ctx;
143 ctx = sdb_error_get_ctx();
144 if (! ctx)
145 return -1;
147 ctx->logged = 0;
148 return (int)sdb_strbuf_vappend(ctx->msg, fmt, ap);
149 } /* sdb_error_vappend */
151 static int
152 sdb_do_log(int prio)
153 {
154 sdb_error_ctx_t *ctx;
155 int ret;
157 ctx = sdb_error_get_ctx();
158 if (! ctx)
159 return -1;
161 if (prio >= 0)
162 ctx->prio = prio;
164 if (ctx->logged)
165 return 0;
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));
173 ctx->logged = 1;
174 return ret;
175 } /* sdb_do_log */
177 /*
178 * public API
179 */
181 void
182 sdb_error_set_logger(int (*f)(int, const char *))
183 {
184 logger = f;
185 } /* sdb_error_set_logger */
187 int
188 sdb_log(int prio, const char *fmt, ...)
189 {
190 va_list ap;
191 int ret;
193 va_start(ap, fmt);
194 ret = sdb_error_vprintf(fmt, ap);
195 va_end(ap);
197 if (ret > 0)
198 sdb_do_log(prio);
199 return ret;
200 } /* sdb_log */
202 int
203 sdb_error_set(const char *fmt, ...)
204 {
205 va_list ap;
206 int ret;
208 va_start(ap, fmt);
209 ret = sdb_error_vprintf(fmt, ap);
210 va_end(ap);
212 return ret;
213 } /* sdb_error_set */
215 int
216 sdb_error_append(const char *fmt, ...)
217 {
218 va_list ap;
219 int ret;
221 va_start(ap, fmt);
222 ret = sdb_error_vappend(fmt, ap);
223 va_end(ap);
225 return ret;
226 } /* sdb_error_append */
228 int
229 sdb_error_chomp(void)
230 {
231 sdb_error_ctx_t *ctx;
233 ctx = sdb_error_get_ctx();
234 if (! ctx)
235 return -1;
237 sdb_strbuf_chomp(ctx->msg);
238 return 0;
239 } /* sdb_error_chomp */
241 int
242 sdb_error_log(int prio)
243 {
244 return sdb_do_log(prio);
245 } /* sdb_error_log */
247 const char *
248 sdb_error_get(void)
249 {
250 sdb_error_ctx_t *ctx;
252 ctx = sdb_error_get_ctx();
253 if (! ctx)
254 return "success";
255 return sdb_strbuf_string(ctx->msg);
256 } /* sdb_error_get */
258 int
259 sdb_error_get_prio(void)
260 {
261 sdb_error_ctx_t *ctx;
263 ctx = sdb_error_get_ctx();
264 if (! ctx)
265 return -1;
266 return ctx->prio;
267 } /* sdb_error_get_prio */
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
290 strerrbuf[buflen - 1] = '\0';
291 return strerrbuf;
292 } /* sdb_strerror */
294 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */