bfdd/bfdd_nb_state.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * BFD daemon northbound implementation.
   4  *
   5  * Copyright (C) 2019 Network Device Education Foundation, Inc. ("NetDEF")
   6  *                    Rafael Zalamena
   7  */
   8
   9 #include <zebra.h>
  10
  11 #include "lib/log.h"
  12 #include "lib/northbound.h"
  13
  14 #include "bfd.h"
  15 #include "bfdd_nb.h"
  16
  17 /*
  18  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop
  19  */
  20 const void *
  21 bfdd_bfd_sessions_single_hop_get_next(struct nb_cb_get_next_args *args)
  22 {
  23         return bfd_session_next(args->list_entry, false);
  24 }
  25
  26 int bfdd_bfd_sessions_single_hop_get_keys(struct nb_cb_get_keys_args *args)
  27 {
  28         const struct bfd_session *bs = args->list_entry;
  29         char dstbuf[INET6_ADDRSTRLEN];
  30
  31         inet_ntop(bs->key.family, &bs->key.peer, dstbuf, sizeof(dstbuf));
  32
  33         args->keys->num = 3;
  34         strlcpy(args->keys->key[0], dstbuf, sizeof(args->keys->key[0]));
  35         strlcpy(args->keys->key[1], bs->key.ifname, sizeof(args->keys->key[1]));
  36         strlcpy(args->keys->key[2], bs->key.vrfname,
  37                 sizeof(args->keys->key[2]));
  38
  39         return NB_OK;
  40 }
  41
  42 const void *
  43 bfdd_bfd_sessions_single_hop_lookup_entry(struct nb_cb_lookup_entry_args *args)
  44 {
  45         const char *dest_addr = args->keys->key[0];
  46         const char *ifname = args->keys->key[1];
  47         const char *vrf = args->keys->key[2];
  48         struct sockaddr_any psa, lsa;
  49         struct bfd_key bk;
  50
  51         strtosa(dest_addr, &psa);
  52         memset(&lsa, 0, sizeof(lsa));
  53         gen_bfd_key(&bk, &psa, &lsa, false, ifname, vrf);
  54
  55         return bfd_key_lookup(bk);
  56 }
  57
  58 /*
  59  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/local-discriminator
  60  */
  61 struct yang_data *
  62 bfdd_bfd_sessions_single_hop_stats_local_discriminator_get_elem(
  63         struct nb_cb_get_elem_args *args)
  64 {
  65         const struct bfd_session *bs = args->list_entry;
  66
  67         return yang_data_new_uint32(args->xpath, bs->discrs.my_discr);
  68 }
  69
  70 /*
  71  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/local-state
  72  */
  73 struct yang_data *bfdd_bfd_sessions_single_hop_stats_local_state_get_elem(
  74         struct nb_cb_get_elem_args *args)
  75 {
  76         const struct bfd_session *bs = args->list_entry;
  77
  78         return yang_data_new_enum(args->xpath, bs->ses_state);
  79 }
  80
  81 /*
  82  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/local-diagnostic
  83  */
  84 struct yang_data *bfdd_bfd_sessions_single_hop_stats_local_diagnostic_get_elem(
  85         struct nb_cb_get_elem_args *args)
  86 {
  87         const struct bfd_session *bs = args->list_entry;
  88
  89         return yang_data_new_enum(args->xpath, bs->local_diag);
  90 }
  91
  92 /*
  93  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/local-multiplier
  94  */
  95 struct yang_data *bfdd_bfd_sessions_single_hop_stats_local_multiplier_get_elem(
  96         struct nb_cb_get_elem_args *args)
  97 {
  98         const struct bfd_session *bs = args->list_entry;
  99
 100         return yang_data_new_int8(args->xpath, bs->detect_mult);
 101 }
 102
 103 /*
 104  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/remote-discriminator
 105  */
 106 struct yang_data *
 107 bfdd_bfd_sessions_single_hop_stats_remote_discriminator_get_elem(
 108         struct nb_cb_get_elem_args *args)
 109 {
 110         const struct bfd_session *bs = args->list_entry;
 111
 112         if (bs->discrs.remote_discr == 0)
 113                 return NULL;
 114
 115         return yang_data_new_uint32(args->xpath, bs->discrs.remote_discr);
 116 }
 117
 118 /*
 119  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/remote-state
 120  */
 121 struct yang_data *bfdd_bfd_sessions_single_hop_stats_remote_state_get_elem(
 122         struct nb_cb_get_elem_args *args)
 123 {
 124         const struct bfd_session *bs = args->list_entry;
 125
 126         return yang_data_new_enum(args->xpath, bs->ses_state);
 127 }
 128
 129 /*
 130  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/remote-diagnostic
 131  */
 132 struct yang_data *bfdd_bfd_sessions_single_hop_stats_remote_diagnostic_get_elem(
 133         struct nb_cb_get_elem_args *args)
 134 {
 135         const struct bfd_session *bs = args->list_entry;
 136
 137         return yang_data_new_enum(args->xpath, bs->remote_diag);
 138 }
 139
 140 /*
 141  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/remote-multiplier
 142  */
 143 struct yang_data *bfdd_bfd_sessions_single_hop_stats_remote_multiplier_get_elem(
 144         struct nb_cb_get_elem_args *args)
 145 {
 146         const struct bfd_session *bs = args->list_entry;
 147
 148         return yang_data_new_int8(args->xpath, bs->remote_detect_mult);
 149 }
 150
 151 /*
 152  * XPath:
 153  * /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/negotiated-transmission-interval
 154  */
 155 struct yang_data *
 156 bfdd_bfd_sessions_single_hop_stats_negotiated_transmission_interval_get_elem(
 157         struct nb_cb_get_elem_args *args)
 158 {
 159         const struct bfd_session *bs = args->list_entry;
 160
 161         return yang_data_new_uint32(args->xpath,
 162                                     bs->remote_timers.desired_min_tx);
 163 }
 164
 165 /*
 166  * XPath:
 167  * /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/negotiated-receive-interval
 168  */
 169 struct yang_data *
 170 bfdd_bfd_sessions_single_hop_stats_negotiated_receive_interval_get_elem(
 171         struct nb_cb_get_elem_args *args)
 172 {
 173         const struct bfd_session *bs = args->list_entry;
 174
 175         return yang_data_new_uint32(args->xpath,
 176                                     bs->remote_timers.required_min_rx);
 177 }
 178
 179 /*
 180  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/detection-mode
 181  */
 182 struct yang_data *bfdd_bfd_sessions_single_hop_stats_detection_mode_get_elem(
 183         struct nb_cb_get_elem_args *args)
 184 {
 185         const struct bfd_session *bs = args->list_entry;
 186         int detection_mode;
 187
 188         /*
 189          * Detection mode:
 190          *   1. Async with echo
 191          *   2. Async without echo
 192          *   3. Demand with echo
 193          *   4. Demand without echo
 194          *
 195          * TODO: support demand mode.
 196          */
 197         if (CHECK_FLAG(bs->flags, BFD_SESS_FLAG_ECHO))
 198                 detection_mode = 1;
 199         else
 200                 detection_mode = 2;
 201
 202         return yang_data_new_enum(args->xpath, detection_mode);
 203 }
 204
 205 /*
 206  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/last-down-time
 207  */
 208 struct yang_data *bfdd_bfd_sessions_single_hop_stats_last_down_time_get_elem(
 209         struct nb_cb_get_elem_args *args)
 210 {
 211         /*
 212          * TODO: implement me.
 213          *
 214          * No yang support for time elements yet.
 215          */
 216         return NULL;
 217 }
 218
 219 /*
 220  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/last-up-time
 221  */
 222 struct yang_data *bfdd_bfd_sessions_single_hop_stats_last_up_time_get_elem(
 223         struct nb_cb_get_elem_args *args)
 224 {
 225         /*
 226          * TODO: implement me.
 227          *
 228          * No yang support for time elements yet.
 229          */
 230         return NULL;
 231 }
 232
 233 /*
 234  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/session-down-count
 235  */
 236 struct yang_data *
 237 bfdd_bfd_sessions_single_hop_stats_session_down_count_get_elem(
 238         struct nb_cb_get_elem_args *args)
 239 {
 240         const struct bfd_session *bs = args->list_entry;
 241
 242         return yang_data_new_uint64(args->xpath, bs->stats.session_down);
 243 }
 244
 245 /*
 246  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/session-up-count
 247  */
 248 struct yang_data *bfdd_bfd_sessions_single_hop_stats_session_up_count_get_elem(
 249         struct nb_cb_get_elem_args *args)
 250 {
 251         const struct bfd_session *bs = args->list_entry;
 252
 253         return yang_data_new_uint64(args->xpath, bs->stats.session_up);
 254 }
 255
 256 /*
 257  * XPath:
 258  * /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/control-packet-input-count
 259  */
 260 struct yang_data *
 261 bfdd_bfd_sessions_single_hop_stats_control_packet_input_count_get_elem(
 262         struct nb_cb_get_elem_args *args)
 263 {
 264         const struct bfd_session *bs = args->list_entry;
 265
 266         return yang_data_new_uint64(args->xpath, bs->stats.rx_ctrl_pkt);
 267 }
 268
 269 /*
 270  * XPath:
 271  * /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/control-packet-output-count
 272  */
 273 struct yang_data *
 274 bfdd_bfd_sessions_single_hop_stats_control_packet_output_count_get_elem(
 275         struct nb_cb_get_elem_args *args)
 276 {
 277         const struct bfd_session *bs = args->list_entry;
 278
 279         return yang_data_new_uint64(args->xpath, bs->stats.tx_ctrl_pkt);
 280 }
 281
 282 /*
 283  * XPath:
 284  * /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/negotiated-echo-transmission-interval
 285  */
 286 struct yang_data *
 287 bfdd_bfd_sessions_single_hop_stats_negotiated_echo_transmission_interval_get_elem(
 288         struct nb_cb_get_elem_args *args)
 289 {
 290         const struct bfd_session *bs = args->list_entry;
 291
 292         return yang_data_new_uint32(args->xpath,
 293                                     bs->remote_timers.required_min_echo);
 294 }
 295
 296 /*
 297  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/echo-packet-input-count
 298  */
 299 struct yang_data *
 300 bfdd_bfd_sessions_single_hop_stats_echo_packet_input_count_get_elem(
 301         struct nb_cb_get_elem_args *args)
 302 {
 303         const struct bfd_session *bs = args->list_entry;
 304
 305         return yang_data_new_uint64(args->xpath, bs->stats.rx_echo_pkt);
 306 }
 307
 308 /*
 309  * XPath: /frr-bfdd:bfdd/bfd/sessions/single-hop/stats/echo-packet-output-count
 310  */
 311 struct yang_data *
 312 bfdd_bfd_sessions_single_hop_stats_echo_packet_output_count_get_elem(
 313         struct nb_cb_get_elem_args *args)
 314 {
 315         const struct bfd_session *bs = args->list_entry;
 316
 317         return yang_data_new_uint64(args->xpath, bs->stats.tx_echo_pkt);
 318 }
 319
 320 /*
 321  * XPath: /frr-bfdd:bfdd/bfd/sessions/multi-hop
 322  */
 323 const void *
 324 bfdd_bfd_sessions_multi_hop_get_next(struct nb_cb_get_next_args *args)
 325 {
 326         return bfd_session_next(args->list_entry, true);
 327 }
 328
 329 int bfdd_bfd_sessions_multi_hop_get_keys(struct nb_cb_get_keys_args *args)
 330 {
 331         const struct bfd_session *bs = args->list_entry;
 332         char dstbuf[INET6_ADDRSTRLEN], srcbuf[INET6_ADDRSTRLEN];
 333
 334         inet_ntop(bs->key.family, &bs->key.peer, dstbuf, sizeof(dstbuf));
 335         inet_ntop(bs->key.family, &bs->key.local, srcbuf, sizeof(srcbuf));
 336
 337         args->keys->num = 4;
 338         strlcpy(args->keys->key[0], srcbuf, sizeof(args->keys->key[0]));
 339         strlcpy(args->keys->key[1], dstbuf, sizeof(args->keys->key[1]));
 340         strlcpy(args->keys->key[2], bs->key.vrfname,
 341                 sizeof(args->keys->key[2]));
 342
 343         return NB_OK;
 344 }
 345
 346 const void *
 347 bfdd_bfd_sessions_multi_hop_lookup_entry(struct nb_cb_lookup_entry_args *args)
 348 {
 349         const char *source_addr = args->keys->key[0];
 350         const char *dest_addr = args->keys->key[1];
 351         const char *vrf = args->keys->key[2];
 352         struct sockaddr_any psa, lsa;
 353         struct bfd_key bk;
 354
 355         strtosa(dest_addr, &psa);
 356         strtosa(source_addr, &lsa);
 357         gen_bfd_key(&bk, &psa, &lsa, true, NULL, vrf);
 358
 359         return bfd_key_lookup(bk);
 360 }