isisd/isis_nb_notifications.c

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