lib/ferr.c

   1 /*
   2  * Copyright (c) 2015-16  David Lamparter, for NetDEF, Inc.
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #ifdef HAVE_CONFIG_H
  18 #include "config.h"
  19 #endif
  20
  21 #include <stdlib.h>
  22 #include <stdarg.h>
  23 #include <string.h>
  24 #include <pthread.h>
  25 #include <signal.h>
  26 #include <inttypes.h>
  27
  28 #include "ferr.h"
  29 #include "vty.h"
  30 #include "jhash.h"
  31 #include "memory.h"
  32 #include "hash.h"
  33 #include "command.h"
  34 #include "json.h"
  35 #include "linklist.h"
  36 #include "frr_pthread.h"
  37
  38 DEFINE_MTYPE_STATIC(LIB, ERRINFO, "error information");
  39
  40 /*
  41  * Thread-specific key for temporary storage of allocated ferr.
  42  */
  43 static pthread_key_t errkey;
  44
  45 static void ferr_free(void *arg)
  46 {
  47         XFREE(MTYPE_ERRINFO, arg);
  48 }
  49
  50 static void err_key_init(void) __attribute__((_CONSTRUCTOR(500)));
  51 static void err_key_init(void)
  52 {
  53         pthread_key_create(&errkey, ferr_free);
  54 }
  55
  56 static void err_key_fini(void) __attribute__((_DESTRUCTOR(500)));
  57 static void err_key_fini(void)
  58 {
  59         pthread_key_delete(errkey);
  60 }
  61
  62 /*
  63  * Global shared hash table holding reference text for all defined errors.
  64  */
  65 static pthread_mutex_t refs_mtx = PTHREAD_MUTEX_INITIALIZER;
  66 struct hash *refs;
  67
  68 static bool ferr_hash_cmp(const void *a, const void *b)
  69 {
  70         const struct log_ref *f_a = a;
  71         const struct log_ref *f_b = b;
  72
  73         return f_a->code == f_b->code;
  74 }
  75
  76 static inline unsigned int ferr_hash_key(const void *a)
  77 {
  78         const struct log_ref *f = a;
  79
  80         return f->code;
  81 }
  82
  83 void log_ref_add(struct log_ref *ref)
  84 {
  85         uint32_t i = 0;
  86
  87         frr_with_mutex(&refs_mtx) {
  88                 while (ref[i].code != END_FERR) {
  89                         hash_get(refs, &ref[i], hash_alloc_intern);
  90                         i++;
  91                 }
  92         }
  93 }
  94
  95 struct log_ref *log_ref_get(uint32_t code)
  96 {
  97         struct log_ref holder;
  98         struct log_ref *ref;
  99
 100         holder.code = code;
 101         frr_with_mutex(&refs_mtx) {
 102                 ref = hash_lookup(refs, &holder);
 103         }
 104
 105         return ref;
 106 }
 107
 108 void log_ref_display(struct vty *vty, uint32_t code, bool json)
 109 {
 110         struct log_ref *ref;
 111         struct json_object *top = NULL, *obj = NULL;
 112         struct list *errlist;
 113         struct listnode *ln;
 114
 115         if (json)
 116                 top = json_object_new_object();
 117
 118         frr_with_mutex(&refs_mtx) {
 119                 errlist = code ? list_new() : hash_to_list(refs);
 120         }
 121
 122         if (code) {
 123                 ref = log_ref_get(code);
 124                 if (!ref) {
 125                         if (top)
 126                                 json_object_free(top);
 127                         list_delete(&errlist);
 128                         return;
 129                 }
 130                 listnode_add(errlist, ref);
 131         }
 132
 133         for (ALL_LIST_ELEMENTS_RO(errlist, ln, ref)) {
 134                 if (json) {
 135                         char key[11];
 136
 137                         snprintf(key, sizeof(key), "%u", ref->code);
 138                         obj = json_object_new_object();
 139                         json_object_string_add(obj, "title", ref->title);
 140                         json_object_string_add(obj, "description",
 141                                                ref->description);
 142                         json_object_string_add(obj, "suggestion",
 143                                                ref->suggestion);
 144                         json_object_object_add(top, key, obj);
 145                 } else {
 146                         char pbuf[256];
 147                         char ubuf[256];
 148
 149                         snprintf(pbuf, sizeof(pbuf), "\nError %u - %s",
 150                                  ref->code, ref->title);
 151                         memset(ubuf, '=', strlen(pbuf));
 152                         ubuf[strlen(pbuf)] = '\0';
 153
 154                         vty_out(vty, "%s\n%s\n", pbuf, ubuf);
 155                         vty_out(vty, "Description:\n%s\n\n", ref->description);
 156                         vty_out(vty, "Recommendation:\n%s\n", ref->suggestion);
 157                 }
 158         }
 159
 160         vty_json(vty, top);
 161         list_delete(&errlist);
 162 }
 163
 164 DEFUN_NOSH(show_error_code,
 165            show_error_code_cmd,
 166            "show error <(1-4294967295)|all> [json]",
 167            SHOW_STR
 168            "Information on errors\n"
 169            "Error code to get info about\n"
 170            "Information on all errors\n"
 171            JSON_STR)
 172 {
 173         bool json = strmatch(argv[argc-1]->text, "json");
 174         uint32_t arg = 0;
 175
 176         if (!strmatch(argv[2]->text, "all"))
 177                 arg = strtoul(argv[2]->arg, NULL, 10);
 178
 179         log_ref_display(vty, arg, json);
 180         return CMD_SUCCESS;
 181 }
 182
 183 void log_ref_init(void)
 184 {
 185         frr_with_mutex(&refs_mtx) {
 186                 refs = hash_create(ferr_hash_key, ferr_hash_cmp,
 187                                    "Error Reference Texts");
 188         }
 189 }
 190
 191 void log_ref_fini(void)
 192 {
 193         frr_with_mutex(&refs_mtx) {
 194                 hash_clean(refs, NULL);
 195                 hash_free(refs);
 196                 refs = NULL;
 197         }
 198 }
 199
 200 void log_ref_vty_init(void)
 201 {
 202         install_element(VIEW_NODE, &show_error_code_cmd);
 203 }
 204
 205
 206 const struct ferr *ferr_get_last(ferr_r errval)
 207 {
 208         struct ferr *last_error = pthread_getspecific(errkey);
 209         if (!last_error || last_error->kind == 0)
 210                 return NULL;
 211         return last_error;
 212 }
 213
 214 ferr_r ferr_clear(void)
 215 {
 216         struct ferr *last_error = pthread_getspecific(errkey);
 217         if (last_error)
 218                 last_error->kind = 0;
 219         return ferr_ok();
 220 }
 221
 222 static ferr_r ferr_set_va(const char *file, int line, const char *func,
 223                           enum ferr_kind kind, const char *pathname,
 224                           int errno_val, const char *text, va_list va)
 225 {
 226         struct ferr *error = pthread_getspecific(errkey);
 227
 228         if (!error) {
 229                 error = XCALLOC(MTYPE_ERRINFO, sizeof(*error));
 230
 231                 pthread_setspecific(errkey, error);
 232         }
 233
 234         error->file = file;
 235         error->line = line;
 236         error->func = func;
 237         error->kind = kind;
 238
 239         error->unique_id = jhash(text, strlen(text),
 240                                  jhash(file, strlen(file), 0xd4ed0298));
 241
 242         error->errno_val = errno_val;
 243         if (pathname)
 244                 snprintf(error->pathname, sizeof(error->pathname), "%s",
 245                          pathname);
 246         else
 247                 error->pathname[0] = '\0';
 248
 249         vsnprintf(error->message, sizeof(error->message), text, va);
 250         return -1;
 251 }
 252
 253 ferr_r ferr_set_internal(const char *file, int line, const char *func,
 254                          enum ferr_kind kind, const char *text, ...)
 255 {
 256         ferr_r rv;
 257         va_list va;
 258         va_start(va, text);
 259         rv = ferr_set_va(file, line, func, kind, NULL, 0, text, va);
 260         va_end(va);
 261         return rv;
 262 }
 263
 264 ferr_r ferr_set_internal_ext(const char *file, int line, const char *func,
 265                              enum ferr_kind kind, const char *pathname,
 266                              int errno_val, const char *text, ...)
 267 {
 268         ferr_r rv;
 269         va_list va;
 270         va_start(va, text);
 271         rv = ferr_set_va(file, line, func, kind, pathname, errno_val, text, va);
 272         va_end(va);
 273         return rv;
 274 }
 275
 276 #define REPLACE "$ERR"
 277 void vty_print_error(struct vty *vty, ferr_r err, const char *msg, ...)
 278 {
 279         char tmpmsg[512], *replacepos;
 280         const struct ferr *last_error = ferr_get_last(err);
 281
 282         va_list va;
 283         va_start(va, msg);
 284         vsnprintf(tmpmsg, sizeof(tmpmsg), msg, va);
 285         va_end(va);
 286
 287         replacepos = strstr(tmpmsg, REPLACE);
 288         if (!replacepos)
 289                 vty_out(vty, "%s\n", tmpmsg);
 290         else {
 291                 replacepos[0] = '\0';
 292                 replacepos += sizeof(REPLACE) - 1;
 293                 vty_out(vty, "%s%s%s\n", tmpmsg,
 294                         last_error ? last_error->message : "(no error?)",
 295                         replacepos);
 296         }
 297 }