isisd/isis_nb_notifications.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) 2018        Volta Networks
   4  *                           Emanuele Di Pascale
   5  */
   6
   7 #include <zebra.h>
   8
   9 #include "northbound.h"
  10 #include "log.h"
  11
  12 #include "isisd/isisd.h"
  13 #include "isisd/isis_nb.h"
  14 #include "isisd/isis_adjacency.h"
  15 #include "isisd/isis_dynhn.h"
  16 #include "isisd/isis_misc.h"
  17
  18 DEFINE_HOOK(isis_hook_lsp_too_large,
  19             (const struct isis_circuit *circuit, uint32_t pdu_size,
  20              const uint8_t *lsp_id),
  21             (circuit, pdu_size, lsp_id));
  22 DEFINE_HOOK(isis_hook_corrupted_lsp, (const struct isis_area *area), (area));
  23 DEFINE_HOOK(isis_hook_lsp_exceed_max,
  24             (const struct isis_area *area, const uint8_t *lsp_id),
  25             (area, lsp_id));
  26 DEFINE_HOOK(isis_hook_max_area_addr_mismatch,
  27             (const struct isis_circuit *circuit, uint8_t max_addrs,
  28              const char *raw_pdu, size_t raw_pdu_len),
  29             (circuit, max_addrs, raw_pdu, raw_pdu_len));
  30 DEFINE_HOOK(isis_hook_authentication_type_failure,
  31             (const struct isis_circuit *circuit, const char *raw_pdu,
  32              size_t raw_pdu_len),
  33             (circuit, raw_pdu, raw_pdu_len));
  34 DEFINE_HOOK(isis_hook_authentication_failure,
  35             (const struct isis_circuit *circuit, const char *raw_pdu,
  36              size_t raw_pdu_len),
  37             (circuit, raw_pdu, raw_pdu_len));
  38 DEFINE_HOOK(isis_hook_adj_state_change, (const struct isis_adjacency *adj),
  39             (adj));
  40 DEFINE_HOOK(isis_hook_reject_adjacency,
  41             (const struct isis_circuit *circuit, const char *raw_pdu,
  42              size_t raw_pdu_len),
  43             (circuit, raw_pdu, raw_pdu_len));
  44 DEFINE_HOOK(isis_hook_area_mismatch,
  45             (const struct isis_circuit *circuit, const char *raw_pdu,
  46              size_t raw_pdu_len),
  47             (circuit, raw_pdu, raw_pdu_len));
  48 DEFINE_HOOK(isis_hook_id_len_mismatch,
  49             (const struct isis_circuit *circuit, uint8_t rcv_id_len,
  50              const char *raw_pdu, size_t raw_pdu_len),
  51             (circuit, rcv_id_len, raw_pdu, raw_pdu_len));
  52 DEFINE_HOOK(isis_hook_version_skew,
  53             (const struct isis_circuit *circuit, uint8_t version,
  54              const char *raw_pdu, size_t raw_pdu_len),
  55             (circuit, version, raw_pdu, raw_pdu_len));
  56 DEFINE_HOOK(isis_hook_lsp_error,
  57             (const struct isis_circuit *circuit, const uint8_t *lsp_id,
  58              const char *raw_pdu, size_t raw_pdu_len),
  59             (circuit, lsp_id, raw_pdu, raw_pdu_len));
  60 DEFINE_HOOK(isis_hook_seqno_skipped,
  61             (const struct isis_circuit *circuit, const uint8_t *lsp_id),
  62             (circuit, lsp_id));
  63 DEFINE_HOOK(isis_hook_own_lsp_purge,
  64             (const struct isis_circuit *circuit, const uint8_t *lsp_id),
  65             (circuit, lsp_id));
  66
  67
  68 /*
  69  * Helper functions.
  70  */
  71 static void notif_prep_instance_hdr(const char *xpath,
  72                                     const struct isis_area *area,
  73                                     const char *routing_instance,
  74                                     struct list *args)
  75 {
  76         char xpath_arg[XPATH_MAXLEN];
  77         struct yang_data *data;
  78
  79         snprintf(xpath_arg, sizeof(xpath_arg), "%s/routing-instance", xpath);
  80         data = yang_data_new_string(xpath_arg, routing_instance);
  81         listnode_add(args, data);
  82         snprintf(xpath_arg, sizeof(xpath_arg), "%s/routing-protocol-name",
  83                  xpath);
  84         data = yang_data_new_string(xpath_arg, area->area_tag);
  85         listnode_add(args, data);
  86         snprintf(xpath_arg, sizeof(xpath_arg), "%s/isis-level", xpath);
  87         data = yang_data_new_enum(xpath_arg, area->is_type);
  88         listnode_add(args, data);
  89 }
  90
  91 static void notif_prepr_iface_hdr(const char *xpath,
  92                                   const struct isis_circuit *circuit,
  93                                   struct list *args)
  94 {
  95         char xpath_arg[XPATH_MAXLEN];
  96         struct yang_data *data;
  97
  98         snprintf(xpath_arg, sizeof(xpath_arg), "%s/interface-name", xpath);
  99         data = yang_data_new_string(xpath_arg, circuit->interface->name);
 100         listnode_add(args, data);
 101         snprintf(xpath_arg, sizeof(xpath_arg), "%s/interface-level", xpath);
 102         data = yang_data_new_enum(xpath_arg, circuit->is_type);
 103         listnode_add(args, data);
 104         snprintf(xpath_arg, sizeof(xpath_arg), "%s/extended-circuit-id", xpath);
 105         /* we do not seem to have the extended version of the circuit_id */
 106         data = yang_data_new_uint32(xpath_arg, (uint32_t)circuit->circuit_id);
 107         listnode_add(args, data);
 108 }
 109
 110 /*
 111  * XPath: /frr-isisd:database-overload
 112  */
 113 void isis_notif_db_overload(const struct isis_area *area, bool overload)
 114 {
 115         const char *xpath = "/frr-isisd:database-overload";
 116         struct list *arguments = yang_data_list_new();
 117         char xpath_arg[XPATH_MAXLEN];
 118         struct yang_data *data;
 119
 120         notif_prep_instance_hdr(xpath, area, "default", arguments);
 121         snprintf(xpath_arg, sizeof(xpath_arg), "%s/overload", xpath);
 122         data = yang_data_new_enum(xpath_arg, !!overload);
 123         listnode_add(arguments, data);
 124
 125         nb_notification_send(xpath, arguments);
 126 }
 127
 128 /*
 129  * XPath: /frr-isisd:lsp-too-large
 130  */
 131 void isis_notif_lsp_too_large(const struct isis_circuit *circuit,
 132                               uint32_t pdu_size, const uint8_t *lsp_id)
 133 {
 134         const char *xpath = "/frr-isisd:lsp-too-large";
 135         struct list *arguments = yang_data_list_new();
 136         char xpath_arg[XPATH_MAXLEN];
 137         char xpath_value[ISO_SYSID_STRLEN];
 138         struct yang_data *data;
 139         struct isis_area *area = circuit->area;
 140
 141         notif_prep_instance_hdr(xpath, area, "default", arguments);
 142         notif_prepr_iface_hdr(xpath, circuit, arguments);
 143         snprintf(xpath_arg, sizeof(xpath_arg), "%s/pdu-size", xpath);
 144         data = yang_data_new_uint32(xpath_arg, pdu_size);
 145         listnode_add(arguments, data);
 146         snprintf(xpath_arg, sizeof(xpath_arg), "%s/lsp-id", xpath);
 147         snprintfrr(xpath_value, ISO_SYSID_STRLEN, "%pLS", lsp_id);
 148         data = yang_data_new_string(xpath_arg, xpath_value);
 149         listnode_add(arguments, data);
 150
 151         hook_call(isis_hook_lsp_too_large, circuit, pdu_size, lsp_id);
 152
 153         nb_notification_send(xpath, arguments);
 154 }
 155
 156 /*
 157  * XPath: /frr-isisd:if-state-change
 158  */
 159 void isis_notif_if_state_change(const struct isis_circuit *circuit, bool down)
 160 {
 161         const char *xpath = "/frr-isisd:if-state-change";
 162         struct list *arguments = yang_data_list_new();
 163         char xpath_arg[XPATH_MAXLEN];
 164         struct yang_data *data;
 165         struct isis_area *area = circuit->area;
 166
 167         notif_prep_instance_hdr(xpath, area, "default", arguments);
 168         notif_prepr_iface_hdr(xpath, circuit, arguments);
 169         snprintf(xpath_arg, sizeof(xpath_arg), "%s/state", xpath);
 170         data = yang_data_new_enum(xpath_arg, !!down);
 171         listnode_add(arguments, data);
 172
 173         nb_notification_send(xpath, arguments);
 174 }
 175
 176 /*
 177  * XPath: /frr-isisd:corrupted-lsp-detected
 178  */
 179 void isis_notif_corrupted_lsp(const struct isis_area *area,
 180                               const uint8_t *lsp_id)
 181 {
 182         const char *xpath = "/frr-isisd:corrupted-lsp-detected";
 183         struct list *arguments = yang_data_list_new();
 184         char xpath_arg[XPATH_MAXLEN];
 185         char xpath_value[ISO_SYSID_STRLEN];
 186         struct yang_data *data;
 187
 188         notif_prep_instance_hdr(xpath, area, "default", arguments);
 189         snprintf(xpath_arg, sizeof(xpath_arg), "%s/lsp-id", xpath);
 190         snprintfrr(xpath_value, ISO_SYSID_STRLEN, "%pLS", lsp_id);
 191         data = yang_data_new_string(xpath_arg, xpath_value);
 192         listnode_add(arguments, data);
 193
 194         hook_call(isis_hook_corrupted_lsp, area);
 195
 196         nb_notification_send(xpath, arguments);
 197 }
 198
 199 /*
 200  * XPath: /frr-isisd:attempt-to-exceed-max-sequence
 201  */
 202 void isis_notif_lsp_exceed_max(const struct isis_area *area,
 203                                const uint8_t *lsp_id)
 204 {
 205         const char *xpath = "/frr-isisd:attempt-to-exceed-max-sequence";
 206         struct list *arguments = yang_data_list_new();
 207         char xpath_arg[XPATH_MAXLEN];
 208         char xpath_value[ISO_SYSID_STRLEN];
 209         struct yang_data *data;
 210
 211         notif_prep_instance_hdr(xpath, area, "default", arguments);
 212         snprintf(xpath_arg, sizeof(xpath_arg), "%s/lsp-id", xpath);
 213         snprintfrr(xpath_value, ISO_SYSID_STRLEN, "%pLS", lsp_id);
 214         data = yang_data_new_string(xpath_arg, xpath_value);
 215         listnode_add(arguments, data);
 216
 217         hook_call(isis_hook_lsp_exceed_max, area, lsp_id);
 218
 219         nb_notification_send(xpath, arguments);
 220 }
 221
 222 /*
 223  * XPath: /frr-isisd:max-area-addresses-mismatch
 224  */
 225 void isis_notif_max_area_addr_mismatch(const struct isis_circuit *circuit,
 226                                        uint8_t max_area_addrs,
 227                                        const char *raw_pdu, size_t raw_pdu_len)
 228 {
 229         const char *xpath = "/frr-isisd:max-area-addresses-mismatch";
 230         struct list *arguments = yang_data_list_new();
 231         char xpath_arg[XPATH_MAXLEN];
 232         struct yang_data *data;
 233         struct isis_area *area = circuit->area;
 234
 235         notif_prep_instance_hdr(xpath, area, "default", arguments);
 236         notif_prepr_iface_hdr(xpath, circuit, arguments);
 237         snprintf(xpath_arg, sizeof(xpath_arg), "%s/max-area-addresses", xpath);
 238         data = yang_data_new_uint8(xpath_arg, max_area_addrs);
 239         listnode_add(arguments, data);
 240         snprintf(xpath_arg, sizeof(xpath_arg), "%s/raw-pdu", xpath);
 241         data = yang_data_new_binary(xpath_arg, raw_pdu, raw_pdu_len);
 242         listnode_add(arguments, data);
 243
 244         hook_call(isis_hook_max_area_addr_mismatch, circuit, max_area_addrs,
 245                   raw_pdu, raw_pdu_len);
 246
 247         nb_notification_send(xpath, arguments);
 248 }
 249
 250 /*
 251  * XPath: /frr-isisd:authentication-type-failure
 252  */
 253 void isis_notif_authentication_type_failure(const struct isis_circuit *circuit,
 254                                             const char *raw_pdu,
 255                                             size_t raw_pdu_len)
 256 {
 257         const char *xpath = "/frr-isisd:authentication-type-failure";
 258         struct list *arguments = yang_data_list_new();
 259         char xpath_arg[XPATH_MAXLEN];
 260         struct yang_data *data;
 261         struct isis_area *area = circuit->area;
 262
 263         notif_prep_instance_hdr(xpath, area, "default", arguments);
 264         notif_prepr_iface_hdr(xpath, circuit, arguments);
 265         snprintf(xpath_arg, sizeof(xpath_arg), "%s/raw-pdu", xpath);
 266         data = yang_data_new_binary(xpath_arg, raw_pdu, raw_pdu_len);
 267         listnode_add(arguments, data);
 268
 269         hook_call(isis_hook_authentication_type_failure, circuit, raw_pdu,
 270                   raw_pdu_len);
 271
 272         nb_notification_send(xpath, arguments);
 273 }
 274
 275 /*
 276  * XPath: /frr-isisd:authentication-failure
 277  */
 278 void isis_notif_authentication_failure(const struct isis_circuit *circuit,
 279                                        const char *raw_pdu, size_t raw_pdu_len)
 280 {
 281         const char *xpath = "/frr-isisd:authentication-failure";
 282         struct list *arguments = yang_data_list_new();
 283         char xpath_arg[XPATH_MAXLEN];
 284         struct yang_data *data;
 285         struct isis_area *area = circuit->area;
 286
 287         notif_prep_instance_hdr(xpath, area, "default", arguments);
 288         notif_prepr_iface_hdr(xpath, circuit, arguments);
 289         snprintf(xpath_arg, sizeof(xpath_arg), "%s/raw-pdu", xpath);
 290         data = yang_data_new_binary(xpath_arg, raw_pdu, raw_pdu_len);
 291         listnode_add(arguments, data);
 292
 293         hook_call(isis_hook_authentication_failure, circuit, raw_pdu,
 294                   raw_pdu_len);
 295
 296         nb_notification_send(xpath, arguments);
 297 }
 298
 299 /*
 300  * XPath: /frr-isisd:adjacency-state-change
 301  */
 302 void isis_notif_adj_state_change(const struct isis_adjacency *adj,
 303                                  int new_state, const char *reason)
 304 {
 305         const char *xpath = "/frr-isisd:adjacency-state-change";
 306         struct list *arguments = yang_data_list_new();
 307         char xpath_arg[XPATH_MAXLEN];
 308         char xpath_value[ISO_SYSID_STRLEN];
 309         struct yang_data *data;
 310         struct isis_circuit *circuit = adj->circuit;
 311         struct isis_area *area = circuit->area;
 312         struct isis_dynhn *dyn = dynhn_find_by_id(circuit->isis, adj->sysid);
 313
 314         notif_prep_instance_hdr(xpath, area, "default", arguments);
 315         notif_prepr_iface_hdr(xpath, circuit, arguments);
 316         if (dyn) {
 317                 snprintf(xpath_arg, sizeof(xpath_arg), "%s/neighbor", xpath);
 318                 data = yang_data_new_string(xpath_arg, dyn->hostname);
 319                 listnode_add(arguments, data);
 320         }
 321         snprintf(xpath_arg, sizeof(xpath_arg), "%s/neighbor-system-id", xpath);
 322         snprintfrr(xpath_value, ISO_SYSID_STRLEN, "%pSY", adj->sysid);
 323         data = yang_data_new_string(xpath_arg, xpath_value);
 324         listnode_add(arguments, data);
 325
 326         snprintf(xpath_arg, sizeof(xpath_arg), "%s/state", xpath);
 327         data = yang_data_new_string(xpath_arg, isis_adj_yang_state(new_state));
 328         listnode_add(arguments, data);
 329         if (new_state == ISIS_ADJ_DOWN) {
 330                 snprintf(xpath_arg, sizeof(xpath_arg), "%s/reason", xpath);
 331                 data = yang_data_new_string(xpath_arg, reason);
 332                 listnode_add(arguments, data);
 333         }
 334
 335         hook_call(isis_hook_adj_state_change, adj);
 336
 337         nb_notification_send(xpath, arguments);
 338 }
 339
 340 /*
 341  * XPath: /frr-isisd:rejected-adjacency
 342  */
 343 void isis_notif_reject_adjacency(const struct isis_circuit *circuit,
 344                                  const char *reason, const char *raw_pdu,
 345                                  size_t raw_pdu_len)
 346 {
 347         const char *xpath = "/frr-isisd:rejected-adjacency";
 348         struct list *arguments = yang_data_list_new();
 349         char xpath_arg[XPATH_MAXLEN];
 350         struct yang_data *data;
 351         struct isis_area *area = circuit->area;
 352
 353         notif_prep_instance_hdr(xpath, area, "default", arguments);
 354         notif_prepr_iface_hdr(xpath, circuit, arguments);
 355         snprintf(xpath_arg, sizeof(xpath_arg), "%s/reason", xpath);
 356         data = yang_data_new_string(xpath_arg, reason);
 357         listnode_add(arguments, data);
 358         snprintf(xpath_arg, sizeof(xpath_arg), "%s/raw-pdu", xpath);
 359         data = yang_data_new_binary(xpath_arg, raw_pdu, raw_pdu_len);
 360         listnode_add(arguments, data);
 361
 362         hook_call(isis_hook_reject_adjacency, circuit, raw_pdu, raw_pdu_len);
 363
 364         nb_notification_send(xpath, arguments);
 365 }
 366
 367 /*
 368  * XPath: /frr-isisd:area-mismatch
 369  */
 370 void isis_notif_area_mismatch(const struct isis_circuit *circuit,
 371                               const char *raw_pdu, size_t raw_pdu_len)
 372 {
 373         const char *xpath = "/frr-isisd:area-mismatch";
 374         struct list *arguments = yang_data_list_new();
 375         char xpath_arg[XPATH_MAXLEN];
 376         struct yang_data *data;
 377         struct isis_area *area = circuit->area;
 378
 379         notif_prep_instance_hdr(xpath, area, "default", arguments);
 380         notif_prepr_iface_hdr(xpath, circuit, arguments);
 381         snprintf(xpath_arg, sizeof(xpath_arg), "%s/raw-pdu", xpath);
 382         data = yang_data_new_binary(xpath_arg, raw_pdu, raw_pdu_len);
 383         listnode_add(arguments, data);
 384
 385         hook_call(isis_hook_area_mismatch, circuit, raw_pdu, raw_pdu_len);
 386
 387         nb_notification_send(xpath, arguments);
 388 }
 389
 390 /*
 391  * XPath: /frr-isisd:lsp-received
 392  */
 393 void isis_notif_lsp_received(const struct isis_circuit *circuit,
 394                              const uint8_t *lsp_id, uint32_t seqno,
 395                              uint32_t timestamp, const char *sys_id)
 396 {
 397         const char *xpath = "/frr-isisd:lsp-received";
 398         struct list *arguments = yang_data_list_new();
 399         char xpath_arg[XPATH_MAXLEN];
 400         char xpath_value[ISO_SYSID_STRLEN];
 401         struct yang_data *data;
 402         struct isis_area *area = circuit->area;
 403
 404         notif_prep_instance_hdr(xpath, area, "default", arguments);
 405         notif_prepr_iface_hdr(xpath, circuit, arguments);
 406         snprintf(xpath_arg, sizeof(xpath_arg), "%s/lsp-id", xpath);
 407         snprintfrr(xpath_value, ISO_SYSID_STRLEN, "%pLS", lsp_id);
 408         data = yang_data_new_string(xpath_arg, xpath_value);
 409         listnode_add(arguments, data);
 410         snprintf(xpath_arg, sizeof(xpath_arg), "%s/sequence", xpath);
 411         data = yang_data_new_uint32(xpath_arg, seqno);
 412         listnode_add(arguments, data);
 413         snprintf(xpath_arg, sizeof(xpath_arg), "%s/received-timestamp", xpath);
 414         data = yang_data_new_uint32(xpath_arg, timestamp);
 415         listnode_add(arguments, data);
 416         snprintf(xpath_arg, sizeof(xpath_arg), "%s/neighbor-system-id", xpath);
 417         data = yang_data_new_string(xpath_arg, sys_id);
 418         listnode_add(arguments, data);
 419
 420         nb_notification_send(xpath, arguments);
 421 }
 422
 423 /*
 424  * XPath: /frr-isisd:lsp-generation
 425  */
 426 void isis_notif_lsp_gen(const struct isis_area *area, const uint8_t *lsp_id,
 427                         uint32_t seqno, uint32_t timestamp)
 428 {
 429         const char *xpath = "/frr-isisd:lsp-generation";
 430         struct list *arguments = yang_data_list_new();
 431         char xpath_arg[XPATH_MAXLEN];
 432         char xpath_value[ISO_SYSID_STRLEN];
 433         struct yang_data *data;
 434
 435         notif_prep_instance_hdr(xpath, area, "default", arguments);
 436         snprintf(xpath_arg, sizeof(xpath_arg), "%s/lsp-id", xpath);
 437         snprintfrr(xpath_value, ISO_SYSID_STRLEN, "%pLS", lsp_id);
 438         data = yang_data_new_string(xpath_arg, xpath_value);
 439         listnode_add(arguments, data);
 440         snprintf(xpath_arg, sizeof(xpath_arg), "%s/sequence", xpath);
 441         data = yang_data_new_uint32(xpath_arg, seqno);
 442         listnode_add(arguments, data);
 443         snprintf(xpath_arg, sizeof(xpath_arg), "%s/send-timestamp", xpath);
 444         data = yang_data_new_uint32(xpath_arg, timestamp);
 445         listnode_add(arguments, data);
 446
 447         nb_notification_send(xpath, arguments);
 448 }
 449
 450 /*
 451  * XPath: /frr-isisd:id-len-mismatch
 452  */
 453 void isis_notif_id_len_mismatch(const struct isis_circuit *circuit,
 454                                 uint8_t rcv_id_len, const char *raw_pdu,
 455                                 size_t raw_pdu_len)
 456 {
 457         const char *xpath = "/frr-isisd:id-len-mismatch";
 458         struct list *arguments = yang_data_list_new();
 459         char xpath_arg[XPATH_MAXLEN];
 460         struct yang_data *data;
 461         struct isis_area *area = circuit->area;
 462
 463         notif_prep_instance_hdr(xpath, area, "default", arguments);
 464         notif_prepr_iface_hdr(xpath, circuit, arguments);
 465         snprintf(xpath_arg, sizeof(xpath_arg), "%s/pdu-field-len", xpath);
 466         data = yang_data_new_uint8(xpath_arg, rcv_id_len);
 467         listnode_add(arguments, data);
 468         snprintf(xpath_arg, sizeof(xpath_arg), "%s/raw-pdu", xpath);
 469         data = yang_data_new_binary(xpath_arg, raw_pdu, raw_pdu_len);
 470         listnode_add(arguments, data);
 471
 472         hook_call(isis_hook_id_len_mismatch, circuit, rcv_id_len, raw_pdu,
 473                   raw_pdu_len);
 474
 475         nb_notification_send(xpath, arguments);
 476 }
 477
 478 /*
 479  * XPath: /frr-isisd:version-skew
 480  */
 481 void isis_notif_version_skew(const struct isis_circuit *circuit,
 482                              uint8_t version, const char *raw_pdu,
 483                              size_t raw_pdu_len)
 484 {
 485         const char *xpath = "/frr-isisd:version-skew";
 486         struct list *arguments = yang_data_list_new();
 487         char xpath_arg[XPATH_MAXLEN];
 488         struct yang_data *data;
 489         struct isis_area *area = circuit->area;
 490
 491         notif_prep_instance_hdr(xpath, area, "default", arguments);
 492         notif_prepr_iface_hdr(xpath, circuit, arguments);
 493         snprintf(xpath_arg, sizeof(xpath_arg), "%s/protocol-version", xpath);
 494         data = yang_data_new_uint8(xpath_arg, version);
 495         listnode_add(arguments, data);
 496         snprintf(xpath_arg, sizeof(xpath_arg), "%s/raw-pdu", xpath);
 497         data = yang_data_new_binary(xpath_arg, raw_pdu, raw_pdu_len);
 498         listnode_add(arguments, data);
 499
 500         hook_call(isis_hook_version_skew, circuit, version, raw_pdu,
 501                   raw_pdu_len);
 502
 503         nb_notification_send(xpath, arguments);
 504 }
 505
 506 /*
 507  * XPath: /frr-isisd:lsp-error-detected
 508  */
 509 void isis_notif_lsp_error(const struct isis_circuit *circuit,
 510                           const uint8_t *lsp_id, const char *raw_pdu,
 511                           size_t raw_pdu_len,
 512                           __attribute__((unused)) uint32_t offset,
 513                           __attribute__((unused)) uint8_t tlv_type)
 514 {
 515         const char *xpath = "/frr-isisd:lsp-error-detected";
 516         struct list *arguments = yang_data_list_new();
 517         char xpath_arg[XPATH_MAXLEN];
 518         char xpath_value[ISO_SYSID_STRLEN];
 519         struct yang_data *data;
 520         struct isis_area *area = circuit->area;
 521
 522         notif_prep_instance_hdr(xpath, area, "default", arguments);
 523         notif_prepr_iface_hdr(xpath, circuit, arguments);
 524         snprintf(xpath_arg, sizeof(xpath_arg), "%s/lsp-id", xpath);
 525         snprintfrr(xpath_value, ISO_SYSID_STRLEN, "%pLS", lsp_id);
 526         data = yang_data_new_string(xpath_arg, xpath_value);
 527         listnode_add(arguments, data);
 528         snprintf(xpath_arg, sizeof(xpath_arg), "%s/raw-pdu", xpath);
 529         data = yang_data_new_binary(xpath_arg, raw_pdu, raw_pdu_len);
 530         listnode_add(arguments, data);
 531         /* ignore offset and tlv_type which cannot be set properly */
 532
 533         hook_call(isis_hook_lsp_error, circuit, lsp_id, raw_pdu, raw_pdu_len);
 534
 535         nb_notification_send(xpath, arguments);
 536 }
 537
 538 /*
 539  * XPath: /frr-isisd:sequence-number-skipped
 540  */
 541 void isis_notif_seqno_skipped(const struct isis_circuit *circuit,
 542                               const uint8_t *lsp_id)
 543 {
 544         const char *xpath = "/frr-isisd:sequence-number-skipped";
 545         struct list *arguments = yang_data_list_new();
 546         char xpath_arg[XPATH_MAXLEN];
 547         char xpath_value[ISO_SYSID_STRLEN];
 548         struct yang_data *data;
 549         struct isis_area *area = circuit->area;
 550
 551         notif_prep_instance_hdr(xpath, area, "default", arguments);
 552         notif_prepr_iface_hdr(xpath, circuit, arguments);
 553         snprintf(xpath_arg, sizeof(xpath_arg), "%s/lsp-id", xpath);
 554         snprintfrr(xpath_value, ISO_SYSID_STRLEN, "%pLS", lsp_id);
 555         data = yang_data_new_string(xpath_arg, xpath_value);
 556         listnode_add(arguments, data);
 557
 558         hook_call(isis_hook_seqno_skipped, circuit, lsp_id);
 559
 560         nb_notification_send(xpath, arguments);
 561 }
 562
 563 /*
 564  * XPath: /frr-isisd:own-lsp-purge
 565  */
 566 void isis_notif_own_lsp_purge(const struct isis_circuit *circuit,
 567                               const uint8_t *lsp_id)
 568 {
 569         const char *xpath = "/frr-isisd:own-lsp-purge";
 570         struct list *arguments = yang_data_list_new();
 571         char xpath_arg[XPATH_MAXLEN];
 572         char xpath_value[ISO_SYSID_STRLEN];
 573         struct yang_data *data;
 574         struct isis_area *area = circuit->area;
 575
 576         notif_prep_instance_hdr(xpath, area, "default", arguments);
 577         notif_prepr_iface_hdr(xpath, circuit, arguments);
 578         snprintf(xpath_arg, sizeof(xpath_arg), "%s/lsp-id", xpath);
 579         snprintfrr(xpath_value, ISO_SYSID_STRLEN, "%pLS", lsp_id);
 580         data = yang_data_new_string(xpath_arg, xpath_value);
 581         listnode_add(arguments, data);
 582
 583         hook_call(isis_hook_own_lsp_purge, circuit, lsp_id);
 584
 585         nb_notification_send(xpath, arguments);
 586 }