lib/ferr.c

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