lib/zclient.h

   1 /* Zebra's client header.
   2  * Copyright (C) 1999 Kunihiro Ishiguro
   3  *
   4  * This file is part of GNU Zebra.
   5  *
   6  * GNU Zebra is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2, or (at your option)
   9  * any later version.
  10  *
  11  * GNU Zebra is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; see the file COPYING; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #ifndef _ZEBRA_ZCLIENT_H
  22 #define _ZEBRA_ZCLIENT_H
  23
  24 /* For struct zapi_route. */
  25 #include "prefix.h"
  26
  27 /* For struct interface and struct connected. */
  28 #include "if.h"
  29
  30 /* For vrf_bitmap_t. */
  31 #include "vrf.h"
  32
  33 /* For union g_addr */
  34 #include "nexthop.h"
  35
  36 /* For union pw_protocol_fields */
  37 #include "pw.h"
  38
  39 #include "mlag.h"
  40
  41 /* Zebra types. Used in Zserv message header. */
  42 typedef uint16_t zebra_size_t;
  43
  44 /* Marker value used in new Zserv, in the byte location corresponding
  45  * the command value in the old zserv header. To allow old and new
  46  * Zserv headers to be distinguished from each other.
  47  */
  48 #define ZEBRA_HEADER_MARKER              254
  49
  50 /* For input/output buffer to zebra. */
  51 #define ZEBRA_MAX_PACKET_SIZ          16384U
  52
  53 /* Zebra header size. */
  54 #define ZEBRA_HEADER_SIZE             10
  55
  56 /* special socket path name to use TCP
  57  * @ is used as first character because that's abstract socket names on Linux
  58  */
  59 #define ZAPI_TCP_PATHNAME             "@tcp"
  60
  61 /* IPset size name stands for the name of the ipset entry
  62  * that can be created by using some zapi interfaces
  63  */
  64 #define ZEBRA_IPSET_NAME_SIZE   32
  65
  66 /* IPTable action is defined by two values: either
  67  * forward or drop
  68  */
  69 #define ZEBRA_IPTABLES_FORWARD 0
  70 #define ZEBRA_IPTABLES_DROP    1
  71
  72 /* Zebra FEC register command flags. */
  73 #define ZEBRA_FEC_REGISTER_LABEL          0x1
  74 #define ZEBRA_FEC_REGISTER_LABEL_INDEX    0x2
  75
  76 /* Client Graceful Restart */
  77 #define ZEBRA_CLIENT_GR_CAPABILITIES       0x1
  78 #define ZEBRA_CLIENT_ROUTE_UPDATE_COMPLETE 0x2
  79 #define ZEBRA_CLIENT_ROUTE_UPDATE_PENDING  0x3
  80 #define ZEBRA_CLIENT_GR_DISABLE            0x4
  81 #define ZEBRA_CLIENT_RIB_STALE_TIME        0x5
  82 #define ZEBRA_CLIENT_GR_ENABLED(X) (X & ZEBRA_CLIENT_GR_CAPABILITIES)
  83
  84 extern struct sockaddr_storage zclient_addr;
  85 extern socklen_t zclient_addr_len;
  86
  87 /* Zebra message types. */
  88 typedef enum {
  89         ZEBRA_INTERFACE_ADD,
  90         ZEBRA_INTERFACE_DELETE,
  91         ZEBRA_INTERFACE_ADDRESS_ADD,
  92         ZEBRA_INTERFACE_ADDRESS_DELETE,
  93         ZEBRA_INTERFACE_UP,
  94         ZEBRA_INTERFACE_DOWN,
  95         ZEBRA_INTERFACE_SET_MASTER,
  96         ZEBRA_INTERFACE_SET_PROTODOWN,
  97         ZEBRA_ROUTE_ADD,
  98         ZEBRA_ROUTE_DELETE,
  99         ZEBRA_ROUTE_NOTIFY_OWNER,
 100         ZEBRA_REDISTRIBUTE_ADD,
 101         ZEBRA_REDISTRIBUTE_DELETE,
 102         ZEBRA_REDISTRIBUTE_DEFAULT_ADD,
 103         ZEBRA_REDISTRIBUTE_DEFAULT_DELETE,
 104         ZEBRA_ROUTER_ID_ADD,
 105         ZEBRA_ROUTER_ID_DELETE,
 106         ZEBRA_ROUTER_ID_UPDATE,
 107         ZEBRA_HELLO,
 108         ZEBRA_CAPABILITIES,
 109         ZEBRA_NEXTHOP_REGISTER,
 110         ZEBRA_NEXTHOP_UNREGISTER,
 111         ZEBRA_NEXTHOP_UPDATE,
 112         ZEBRA_INTERFACE_NBR_ADDRESS_ADD,
 113         ZEBRA_INTERFACE_NBR_ADDRESS_DELETE,
 114         ZEBRA_INTERFACE_BFD_DEST_UPDATE,
 115         ZEBRA_IMPORT_ROUTE_REGISTER,
 116         ZEBRA_IMPORT_ROUTE_UNREGISTER,
 117         ZEBRA_IMPORT_CHECK_UPDATE,
 118         ZEBRA_BFD_DEST_REGISTER,
 119         ZEBRA_BFD_DEST_DEREGISTER,
 120         ZEBRA_BFD_DEST_UPDATE,
 121         ZEBRA_BFD_DEST_REPLAY,
 122         ZEBRA_REDISTRIBUTE_ROUTE_ADD,
 123         ZEBRA_REDISTRIBUTE_ROUTE_DEL,
 124         ZEBRA_VRF_UNREGISTER,
 125         ZEBRA_VRF_ADD,
 126         ZEBRA_VRF_DELETE,
 127         ZEBRA_VRF_LABEL,
 128         ZEBRA_INTERFACE_VRF_UPDATE,
 129         ZEBRA_BFD_CLIENT_REGISTER,
 130         ZEBRA_BFD_CLIENT_DEREGISTER,
 131         ZEBRA_INTERFACE_ENABLE_RADV,
 132         ZEBRA_INTERFACE_DISABLE_RADV,
 133         ZEBRA_IPV4_NEXTHOP_LOOKUP_MRIB,
 134         ZEBRA_INTERFACE_LINK_PARAMS,
 135         ZEBRA_MPLS_LABELS_ADD,
 136         ZEBRA_MPLS_LABELS_DELETE,
 137         ZEBRA_MPLS_LABELS_REPLACE,
 138         ZEBRA_IPMR_ROUTE_STATS,
 139         ZEBRA_LABEL_MANAGER_CONNECT,
 140         ZEBRA_LABEL_MANAGER_CONNECT_ASYNC,
 141         ZEBRA_GET_LABEL_CHUNK,
 142         ZEBRA_RELEASE_LABEL_CHUNK,
 143         ZEBRA_FEC_REGISTER,
 144         ZEBRA_FEC_UNREGISTER,
 145         ZEBRA_FEC_UPDATE,
 146         ZEBRA_ADVERTISE_DEFAULT_GW,
 147         ZEBRA_ADVERTISE_SVI_MACIP,
 148         ZEBRA_ADVERTISE_SUBNET,
 149         ZEBRA_ADVERTISE_ALL_VNI,
 150         ZEBRA_LOCAL_ES_ADD,
 151         ZEBRA_LOCAL_ES_DEL,
 152         ZEBRA_VNI_ADD,
 153         ZEBRA_VNI_DEL,
 154         ZEBRA_L3VNI_ADD,
 155         ZEBRA_L3VNI_DEL,
 156         ZEBRA_REMOTE_VTEP_ADD,
 157         ZEBRA_REMOTE_VTEP_DEL,
 158         ZEBRA_MACIP_ADD,
 159         ZEBRA_MACIP_DEL,
 160         ZEBRA_IP_PREFIX_ROUTE_ADD,
 161         ZEBRA_IP_PREFIX_ROUTE_DEL,
 162         ZEBRA_REMOTE_MACIP_ADD,
 163         ZEBRA_REMOTE_MACIP_DEL,
 164         ZEBRA_DUPLICATE_ADDR_DETECTION,
 165         ZEBRA_PW_ADD,
 166         ZEBRA_PW_DELETE,
 167         ZEBRA_PW_SET,
 168         ZEBRA_PW_UNSET,
 169         ZEBRA_PW_STATUS_UPDATE,
 170         ZEBRA_RULE_ADD,
 171         ZEBRA_RULE_DELETE,
 172         ZEBRA_RULE_NOTIFY_OWNER,
 173         ZEBRA_TABLE_MANAGER_CONNECT,
 174         ZEBRA_GET_TABLE_CHUNK,
 175         ZEBRA_RELEASE_TABLE_CHUNK,
 176         ZEBRA_IPSET_CREATE,
 177         ZEBRA_IPSET_DESTROY,
 178         ZEBRA_IPSET_ENTRY_ADD,
 179         ZEBRA_IPSET_ENTRY_DELETE,
 180         ZEBRA_IPSET_NOTIFY_OWNER,
 181         ZEBRA_IPSET_ENTRY_NOTIFY_OWNER,
 182         ZEBRA_IPTABLE_ADD,
 183         ZEBRA_IPTABLE_DELETE,
 184         ZEBRA_IPTABLE_NOTIFY_OWNER,
 185         ZEBRA_VXLAN_FLOOD_CONTROL,
 186         ZEBRA_VXLAN_SG_ADD,
 187         ZEBRA_VXLAN_SG_DEL,
 188         ZEBRA_VXLAN_SG_REPLAY,
 189         ZEBRA_MLAG_PROCESS_UP,
 190         ZEBRA_MLAG_PROCESS_DOWN,
 191         ZEBRA_MLAG_CLIENT_REGISTER,
 192         ZEBRA_MLAG_CLIENT_UNREGISTER,
 193         ZEBRA_MLAG_FORWARD_MSG,
 194         ZEBRA_ERROR,
 195         ZEBRA_CLIENT_CAPABILITIES
 196 } zebra_message_types_t;
 197
 198 enum zebra_error_types {
 199         ZEBRA_UNKNOWN_ERROR,    /* Error of unknown type */
 200         ZEBRA_NO_VRF,           /* Vrf in header was not found */
 201         ZEBRA_INVALID_MSG_TYPE, /* No handler found for msg type */
 202 };
 203
 204 static inline const char *zebra_error_type2str(enum zebra_error_types type)
 205 {
 206         const char *ret = "UNKNOWN";
 207
 208         switch (type) {
 209         case ZEBRA_UNKNOWN_ERROR:
 210                 ret = "ZEBRA_UNKNOWN_ERROR";
 211                 break;
 212         case ZEBRA_NO_VRF:
 213                 ret = "ZEBRA_NO_VRF";
 214                 break;
 215         case ZEBRA_INVALID_MSG_TYPE:
 216                 ret = "ZEBRA_INVALID_MSG_TYPE";
 217                 break;
 218         }
 219
 220         return ret;
 221 }
 222
 223 struct redist_proto {
 224         uint8_t enabled;
 225         struct list *instances;
 226 };
 227
 228 struct zclient_capabilities {
 229         uint32_t ecmp;
 230         bool mpls_enabled;
 231         enum mlag_role role;
 232 };
 233
 234 /* Graceful Restart Capabilities message */
 235 struct zapi_cap {
 236         uint32_t  cap;
 237         uint32_t  stale_removal_time;
 238         afi_t     afi;
 239         safi_t    safi;
 240         vrf_id_t  vrf_id;
 241 };
 242
 243 /* Structure for the zebra client. */
 244 struct zclient {
 245         /* The thread master we schedule ourselves on */
 246         struct thread_master *master;
 247
 248         /* Priviledges to change socket values */
 249         struct zebra_privs_t *privs;
 250
 251         /* Do we care about failure events for route install? */
 252         bool receive_notify;
 253
 254         /* Socket to zebra daemon. */
 255         int sock;
 256
 257         /* Connection failure count. */
 258         int fail;
 259
 260         /* Input buffer for zebra message. */
 261         struct stream *ibuf;
 262
 263         /* Output buffer for zebra message. */
 264         struct stream *obuf;
 265
 266         /* Buffer of data waiting to be written to zebra. */
 267         struct buffer *wb;
 268
 269         /* Read and connect thread. */
 270         struct thread *t_read;
 271         struct thread *t_connect;
 272
 273         /* Thread to write buffered data to zebra. */
 274         struct thread *t_write;
 275
 276         /* Redistribute information. */
 277         uint8_t redist_default; /* clients protocol */
 278         unsigned short instance;
 279         struct redist_proto mi_redist[AFI_MAX][ZEBRA_ROUTE_MAX];
 280         vrf_bitmap_t redist[AFI_MAX][ZEBRA_ROUTE_MAX];
 281
 282         /* Redistribute defauilt. */
 283         vrf_bitmap_t default_information[AFI_MAX];
 284
 285 #define ZAPI_CALLBACK_ARGS                                                     \
 286         int cmd, struct zclient *zclient, uint16_t length, vrf_id_t vrf_id
 287
 288         /* Pointer to the callback functions. */
 289         void (*zebra_connected)(struct zclient *);
 290         void (*zebra_capabilities)(struct zclient_capabilities *cap);
 291         int (*router_id_update)(ZAPI_CALLBACK_ARGS);
 292         int (*interface_address_add)(ZAPI_CALLBACK_ARGS);
 293         int (*interface_address_delete)(ZAPI_CALLBACK_ARGS);
 294         int (*interface_link_params)(ZAPI_CALLBACK_ARGS);
 295         int (*interface_bfd_dest_update)(ZAPI_CALLBACK_ARGS);
 296         int (*interface_nbr_address_add)(ZAPI_CALLBACK_ARGS);
 297         int (*interface_nbr_address_delete)(ZAPI_CALLBACK_ARGS);
 298         int (*interface_vrf_update)(ZAPI_CALLBACK_ARGS);
 299         int (*nexthop_update)(ZAPI_CALLBACK_ARGS);
 300         int (*import_check_update)(ZAPI_CALLBACK_ARGS);
 301         int (*bfd_dest_replay)(ZAPI_CALLBACK_ARGS);
 302         int (*redistribute_route_add)(ZAPI_CALLBACK_ARGS);
 303         int (*redistribute_route_del)(ZAPI_CALLBACK_ARGS);
 304         int (*fec_update)(int, struct zclient *, uint16_t);
 305         int (*local_es_add)(ZAPI_CALLBACK_ARGS);
 306         int (*local_es_del)(ZAPI_CALLBACK_ARGS);
 307         int (*local_vni_add)(ZAPI_CALLBACK_ARGS);
 308         int (*local_vni_del)(ZAPI_CALLBACK_ARGS);
 309         int (*local_l3vni_add)(ZAPI_CALLBACK_ARGS);
 310         int (*local_l3vni_del)(ZAPI_CALLBACK_ARGS);
 311         void (*local_ip_prefix_add)(ZAPI_CALLBACK_ARGS);
 312         void (*local_ip_prefix_del)(ZAPI_CALLBACK_ARGS);
 313         int (*local_macip_add)(ZAPI_CALLBACK_ARGS);
 314         int (*local_macip_del)(ZAPI_CALLBACK_ARGS);
 315         int (*pw_status_update)(ZAPI_CALLBACK_ARGS);
 316         int (*route_notify_owner)(ZAPI_CALLBACK_ARGS);
 317         int (*rule_notify_owner)(ZAPI_CALLBACK_ARGS);
 318         void (*label_chunk)(ZAPI_CALLBACK_ARGS);
 319         int (*ipset_notify_owner)(ZAPI_CALLBACK_ARGS);
 320         int (*ipset_entry_notify_owner)(ZAPI_CALLBACK_ARGS);
 321         int (*iptable_notify_owner)(ZAPI_CALLBACK_ARGS);
 322         int (*vxlan_sg_add)(ZAPI_CALLBACK_ARGS);
 323         int (*vxlan_sg_del)(ZAPI_CALLBACK_ARGS);
 324         int (*mlag_process_up)(void);
 325         int (*mlag_process_down)(void);
 326         int (*mlag_handle_msg)(struct stream *msg, int len);
 327         int (*handle_error)(enum zebra_error_types error);
 328 };
 329
 330 /* Zebra API message flag. */
 331 #define ZAPI_MESSAGE_NEXTHOP  0x01
 332 #define ZAPI_MESSAGE_DISTANCE 0x02
 333 #define ZAPI_MESSAGE_METRIC   0x04
 334 #define ZAPI_MESSAGE_TAG      0x08
 335 #define ZAPI_MESSAGE_MTU      0x10
 336 #define ZAPI_MESSAGE_SRCPFX   0x20
 337 /*
 338  * This should only be used by a DAEMON that needs to communicate
 339  * the table being used is not in the VRF.  You must pass the
 340  * default vrf, else this will be ignored.
 341  */
 342 #define ZAPI_MESSAGE_TABLEID  0x80
 343
 344 #define ZSERV_VERSION 6
 345 /* Zserv protocol message header */
 346 struct zmsghdr {
 347         uint16_t length;
 348         /* Always set to 255 in new zserv */
 349         uint8_t marker;
 350         uint8_t version;
 351         vrf_id_t vrf_id;
 352         uint16_t command;
 353 } __attribute__((packed));
 354 #define ZAPI_HEADER_CMD_LOCATION offsetof(struct zmsghdr, command)
 355
 356 struct zapi_nexthop {
 357         enum nexthop_types_t type;
 358         vrf_id_t vrf_id;
 359         ifindex_t ifindex;
 360         uint8_t flags;
 361         union {
 362                 union g_addr gate;
 363                 enum blackhole_type bh_type;
 364         };
 365
 366         /* MPLS labels for BGP-LU or Segment Routing */
 367         uint8_t label_num;
 368         mpls_label_t labels[MPLS_MAX_LABELS];
 369
 370         struct ethaddr rmac;
 371
 372         uint32_t weight;
 373 };
 374
 375 /*
 376  * ZAPI nexthop flags values
 377  */
 378 #define ZAPI_NEXTHOP_FLAG_ONLINK        0x01
 379 #define ZAPI_NEXTHOP_FLAG_LABEL         0x02
 380 #define ZAPI_NEXTHOP_FLAG_WEIGHT        0x04
 381
 382 /*
 383  * Some of these data structures do not map easily to
 384  * a actual data structure size giving different compilers
 385  * and systems.  For those data structures we need
 386  * to use the smallest available stream_getX/putX functions
 387  * to encode/decode.
 388  */
 389 struct zapi_route {
 390         uint8_t type;
 391         unsigned short instance;
 392
 393         uint32_t flags;
 394 /*
 395  * Cause Zebra to consider this routes nexthops recursively
 396  */
 397 #define ZEBRA_FLAG_ALLOW_RECURSION    0x01
 398 /*
 399  * This is a route that is read in on startup that was left around
 400  * from a previous run of FRR
 401  */
 402 #define ZEBRA_FLAG_SELFROUTE          0x02
 403 /*
 404  * This flag is used to tell Zebra that the BGP route being passed
 405  * down is a IBGP route
 406  */
 407 #define ZEBRA_FLAG_IBGP               0x04
 408 /*
 409  * This is a route that has been selected for FIB installation.
 410  * This flag is set in zebra and can be passed up to routing daemons
 411  */
 412 #define ZEBRA_FLAG_SELECTED           0x08
 413 /*
 414  * This is a route that we are telling Zebra that this route *must*
 415  * win and will be installed even over ZEBRA_FLAG_SELECTED
 416  */
 417 #define ZEBRA_FLAG_FIB_OVERRIDE       0x10
 418 /*
 419  * This flag tells Zebra that the route is a EVPN route and should
 420  * be treated specially
 421  */
 422 #define ZEBRA_FLAG_EVPN_ROUTE         0x20
 423 /*
 424  * This flag tells Zebra that it should treat the distance passed
 425  * down as an additional discriminator for route selection of the
 426  * route entry.  This mainly is used for backup static routes.
 427  */
 428 #define ZEBRA_FLAG_RR_USE_DISTANCE    0x40
 429
 430         uint8_t message;
 431
 432         /*
 433          * This is an enum but we are going to treat it as a uint8_t
 434          * for purpose of encoding/decoding
 435          */
 436         safi_t safi;
 437
 438         struct prefix prefix;
 439         struct prefix_ipv6 src_prefix;
 440
 441         uint16_t nexthop_num;
 442         struct zapi_nexthop nexthops[MULTIPATH_NUM];
 443
 444         uint8_t distance;
 445
 446         uint32_t metric;
 447
 448         route_tag_t tag;
 449
 450         uint32_t mtu;
 451
 452         vrf_id_t vrf_id;
 453
 454         uint32_t tableid;
 455 };
 456
 457 struct zapi_nexthop_label {
 458         enum nexthop_types_t type;
 459         int family;
 460         union g_addr address;
 461         ifindex_t ifindex;
 462         mpls_label_t label;
 463 };
 464
 465 struct zapi_labels {
 466         uint8_t message;
 467 #define ZAPI_LABELS_FTN      0x01
 468         enum lsp_types_t type;
 469         mpls_label_t local_label;
 470         struct {
 471                 struct prefix prefix;
 472                 uint8_t type;
 473                 unsigned short instance;
 474         } route;
 475         uint16_t nexthop_num;
 476         struct zapi_nexthop_label nexthops[MULTIPATH_NUM];
 477 };
 478
 479 struct zapi_pw {
 480         char ifname[IF_NAMESIZE];
 481         ifindex_t ifindex;
 482         int type;
 483         int af;
 484         union g_addr nexthop;
 485         uint32_t local_label;
 486         uint32_t remote_label;
 487         uint8_t flags;
 488         union pw_protocol_fields data;
 489         uint8_t protocol;
 490 };
 491
 492 struct zapi_pw_status {
 493         char ifname[IF_NAMESIZE];
 494         ifindex_t ifindex;
 495         uint32_t status;
 496 };
 497
 498 enum zapi_route_notify_owner {
 499         ZAPI_ROUTE_FAIL_INSTALL,
 500         ZAPI_ROUTE_BETTER_ADMIN_WON,
 501         ZAPI_ROUTE_INSTALLED,
 502         ZAPI_ROUTE_REMOVED,
 503         ZAPI_ROUTE_REMOVE_FAIL,
 504 };
 505
 506 enum zapi_rule_notify_owner {
 507         ZAPI_RULE_FAIL_INSTALL,
 508         ZAPI_RULE_INSTALLED,
 509         ZAPI_RULE_REMOVED,
 510         ZAPI_RULE_FAIL_REMOVE,
 511 };
 512
 513 enum ipset_type {
 514         IPSET_NET_NET = 1,
 515         IPSET_NET_PORT_NET,
 516         IPSET_NET_PORT,
 517         IPSET_NET
 518 };
 519
 520 enum zapi_ipset_notify_owner {
 521         ZAPI_IPSET_FAIL_INSTALL,
 522         ZAPI_IPSET_INSTALLED,
 523         ZAPI_IPSET_REMOVED,
 524         ZAPI_IPSET_FAIL_REMOVE,
 525 };
 526
 527 enum zapi_ipset_entry_notify_owner {
 528         ZAPI_IPSET_ENTRY_FAIL_INSTALL,
 529         ZAPI_IPSET_ENTRY_INSTALLED,
 530         ZAPI_IPSET_ENTRY_REMOVED,
 531         ZAPI_IPSET_ENTRY_FAIL_REMOVE,
 532 };
 533
 534 enum zapi_iptable_notify_owner {
 535         ZAPI_IPTABLE_FAIL_INSTALL,
 536         ZAPI_IPTABLE_INSTALLED,
 537         ZAPI_IPTABLE_REMOVED,
 538         ZAPI_IPTABLE_FAIL_REMOVE,
 539 };
 540
 541 static inline const char *
 542 zapi_rule_notify_owner2str(enum zapi_rule_notify_owner note)
 543 {
 544         const char *ret = "UNKNOWN";
 545
 546         switch (note) {
 547         case ZAPI_RULE_FAIL_INSTALL:
 548                 ret = "ZAPI_RULE_FAIL_INSTALL";
 549                 break;
 550         case ZAPI_RULE_INSTALLED:
 551                 ret = "ZAPI_RULE_INSTALLED";
 552                 break;
 553         case ZAPI_RULE_FAIL_REMOVE:
 554                 ret = "ZAPI_RULE_FAIL_REMOVE";
 555                 break;
 556         case ZAPI_RULE_REMOVED:
 557                 ret = "ZAPI_RULE_REMOVED";
 558                 break;
 559         }
 560
 561         return ret;
 562 }
 563
 564 /* Zebra MAC types */
 565 #define ZEBRA_MACIP_TYPE_STICKY                0x01 /* Sticky MAC*/
 566 #define ZEBRA_MACIP_TYPE_GW                    0x02 /* gateway (SVI) mac*/
 567 #define ZEBRA_MACIP_TYPE_ROUTER_FLAG           0x04 /* Router Flag - proxy NA */
 568 #define ZEBRA_MACIP_TYPE_OVERRIDE_FLAG         0x08 /* Override Flag */
 569 #define ZEBRA_MACIP_TYPE_SVI_IP                0x10 /* SVI MAC-IP */
 570
 571 enum zebra_neigh_state { ZEBRA_NEIGH_INACTIVE = 0, ZEBRA_NEIGH_ACTIVE = 1 };
 572
 573 struct zclient_options {
 574         bool receive_notify;
 575 };
 576
 577 extern struct zclient_options zclient_options_default;
 578
 579 extern struct zclient *zclient_new(struct thread_master *m,
 580                                    struct zclient_options *opt);
 581
 582 extern void zclient_init(struct zclient *, int, unsigned short,
 583                          struct zebra_privs_t *privs);
 584 extern int zclient_start(struct zclient *);
 585 extern void zclient_stop(struct zclient *);
 586 extern void zclient_reset(struct zclient *);
 587 extern void zclient_free(struct zclient *);
 588
 589 extern int zclient_socket_connect(struct zclient *);
 590
 591 extern unsigned short *redist_check_instance(struct redist_proto *,
 592                                              unsigned short);
 593 extern void redist_add_instance(struct redist_proto *, unsigned short);
 594 extern void redist_del_instance(struct redist_proto *, unsigned short);
 595 extern void redist_del_all_instances(struct redist_proto *red);
 596
 597 /*
 598  * Send to zebra that the specified vrf is using label to resolve
 599  * itself for L3VPN's.  Repeated calls of this function with
 600  * different labels will cause an effective update of the
 601  * label for lookup.  If you pass in MPLS_LABEL_NONE
 602  * we will cause a delete action and remove this label pop
 603  * operation.
 604  *
 605  * The underlying AF_MPLS doesn't care about afi's
 606  * but we can make the zebra_vrf keep track of what
 607  * we have installed and play some special games
 608  * to get them both installed.
 609  */
 610 extern void zclient_send_vrf_label(struct zclient *zclient, vrf_id_t vrf_id,
 611                                    afi_t afi, mpls_label_t label,
 612                                    enum lsp_types_t ltype);
 613
 614 extern void zclient_send_reg_requests(struct zclient *, vrf_id_t);
 615 extern void zclient_send_dereg_requests(struct zclient *, vrf_id_t);
 616
 617 extern void zclient_send_interface_radv_req(struct zclient *zclient,
 618                                             vrf_id_t vrf_id,
 619                                             struct interface *ifp, int enable,
 620                                             int ra_interval);
 621 extern int zclient_send_interface_protodown(struct zclient *zclient,
 622                                             vrf_id_t vrf_id,
 623                                             struct interface *ifp, bool down);
 624
 625 /* Send redistribute command to zebra daemon. Do not update zclient state. */
 626 extern int zebra_redistribute_send(int command, struct zclient *, afi_t,
 627                                    int type, unsigned short instance,
 628                                    vrf_id_t vrf_id);
 629
 630 extern int zebra_redistribute_default_send(int command, struct zclient *zclient,
 631                                            afi_t afi, vrf_id_t vrf_id);
 632
 633 /* If state has changed, update state and call zebra_redistribute_send. */
 634 extern void zclient_redistribute(int command, struct zclient *, afi_t, int type,
 635                                  unsigned short instance, vrf_id_t vrf_id);
 636
 637 /* If state has changed, update state and send the command to zebra. */
 638 extern void zclient_redistribute_default(int command, struct zclient *,
 639                                          afi_t, vrf_id_t vrf_id);
 640
 641 /* Send the message in zclient->obuf to the zebra daemon (or enqueue it).
 642    Returns 0 for success or -1 on an I/O error. */
 643 extern int zclient_send_message(struct zclient *);
 644
 645 /* create header for command, length to be filled in by user later */
 646 extern void zclient_create_header(struct stream *, uint16_t, vrf_id_t);
 647 /*
 648  * Read sizeof(struct zmsghdr) bytes from the provided socket and parse the
 649  * received data into the specified fields. If this is successful, read the
 650  * rest of the packet into the provided stream.
 651  *
 652  * s
 653  *    The stream to read into
 654  *
 655  * sock
 656  *    The socket to read from
 657  *
 658  * size
 659  *    Parsed message size will be placed in the pointed-at integer
 660  *
 661  * marker
 662  *    Parsed marker will be placed in the pointed-at byte
 663  *
 664  * version
 665  *    Parsed version will be placed in the pointed-at byte
 666  *
 667  * vrf_id
 668  *    Parsed VRF ID will be placed in the pointed-at vrf_id_t
 669  *
 670  * cmd
 671  *    Parsed command number will be placed in the pointed-at integer
 672  *
 673  * Returns:
 674  *    -1 if:
 675  *    - insufficient data for header was read
 676  *    - a version mismatch was detected
 677  *    - a marker mismatch was detected
 678  *    - header size field specified more data than could be read
 679  */
 680 extern int zclient_read_header(struct stream *s, int sock, uint16_t *size,
 681                                uint8_t *marker, uint8_t *version,
 682                                vrf_id_t *vrf_id, uint16_t *cmd);
 683 /*
 684  * Parse header from ZAPI message stream into struct zmsghdr.
 685  * This function assumes the stream getp points at the first byte of the header.
 686  * If the function is successful then the stream getp will point to the byte
 687  * immediately after the last byte of the header.
 688  *
 689  * zmsg
 690  *    The stream containing the header
 691  *
 692  * hdr
 693  *    The header struct to parse into.
 694  *
 695  * Returns:
 696  *    true if parsing succeeded, false otherwise
 697  */
 698 extern bool zapi_parse_header(struct stream *zmsg, struct zmsghdr *hdr);
 699
 700 extern void zclient_interface_set_master(struct zclient *client,
 701                                          struct interface *master,
 702                                          struct interface *slave);
 703 extern struct interface *zebra_interface_state_read(struct stream *s, vrf_id_t);
 704 extern struct connected *zebra_interface_address_read(int, struct stream *,
 705                                                       vrf_id_t);
 706 extern struct nbr_connected *
 707 zebra_interface_nbr_address_read(int, struct stream *, vrf_id_t);
 708 extern struct interface *zebra_interface_vrf_update_read(struct stream *s,
 709                                                          vrf_id_t vrf_id,
 710                                                          vrf_id_t *new_vrf_id);
 711 extern void zebra_router_id_update_read(struct stream *s, struct prefix *rid);
 712
 713 extern struct interface *zebra_interface_link_params_read(struct stream *s,
 714                                                           vrf_id_t vrf_id);
 715 extern size_t zebra_interface_link_params_write(struct stream *,
 716                                                 struct interface *);
 717 extern int zclient_send_get_label_chunk(struct zclient *zclient, uint8_t keep,
 718                                         uint32_t chunk_size, uint32_t base);
 719
 720 extern int lm_label_manager_connect(struct zclient *zclient, int async);
 721 extern int lm_get_label_chunk(struct zclient *zclient, uint8_t keep,
 722                               uint32_t base, uint32_t chunk_size,
 723                               uint32_t *start, uint32_t *end);
 724 extern int lm_release_label_chunk(struct zclient *zclient, uint32_t start,
 725                                   uint32_t end);
 726 extern int tm_table_manager_connect(struct zclient *zclient);
 727 extern int tm_get_table_chunk(struct zclient *zclient, uint32_t chunk_size,
 728                               uint32_t *start, uint32_t *end);
 729 extern int tm_release_table_chunk(struct zclient *zclient, uint32_t start,
 730                                   uint32_t end);
 731
 732 extern int zebra_send_mpls_labels(struct zclient *zclient, int cmd,
 733                                   struct zapi_labels *zl);
 734 extern int zapi_labels_encode(struct stream *s, int cmd,
 735                               struct zapi_labels *zl);
 736 extern int zapi_labels_decode(struct stream *s, struct zapi_labels *zl);
 737
 738 extern int zebra_send_pw(struct zclient *zclient, int command,
 739                          struct zapi_pw *pw);
 740 extern void zebra_read_pw_status_update(ZAPI_CALLBACK_ARGS, struct zapi_pw_status *pw);
 741
 742 extern int zclient_route_send(uint8_t, struct zclient *, struct zapi_route *);
 743 extern int zclient_send_rnh(struct zclient *zclient, int command,
 744                             struct prefix *p, bool exact_match,
 745                             vrf_id_t vrf_id);
 746 int zapi_nexthop_encode(struct stream *s, const struct zapi_nexthop *api_nh,
 747                         uint32_t api_flags);
 748 extern int zapi_route_encode(uint8_t, struct stream *, struct zapi_route *);
 749 extern int zapi_route_decode(struct stream *, struct zapi_route *);
 750 bool zapi_route_notify_decode(struct stream *s, struct prefix *p,
 751                               uint32_t *tableid,
 752                               enum zapi_route_notify_owner *note);
 753 bool zapi_rule_notify_decode(struct stream *s, uint32_t *seqno,
 754                              uint32_t *priority, uint32_t *unique,
 755                              ifindex_t *ifindex,
 756                              enum zapi_rule_notify_owner *note);
 757 bool zapi_ipset_notify_decode(struct stream *s,
 758                               uint32_t *unique,
 759                              enum zapi_ipset_notify_owner *note);
 760
 761 #define ZEBRA_IPSET_NAME_SIZE   32
 762
 763 bool zapi_ipset_entry_notify_decode(struct stream *s,
 764             uint32_t *unique,
 765             char *ipset_name,
 766             enum zapi_ipset_entry_notify_owner *note);
 767 bool zapi_iptable_notify_decode(struct stream *s,
 768                 uint32_t *unique,
 769                 enum zapi_iptable_notify_owner *note);
 770
 771 extern struct nexthop *nexthop_from_zapi_nexthop(struct zapi_nexthop *znh);
 772 int zapi_nexthop_from_nexthop(struct zapi_nexthop *znh,
 773                               const struct nexthop *nh);
 774 extern bool zapi_nexthop_update_decode(struct stream *s,
 775                                        struct zapi_route *nhr);
 776
 777 /* Decode the zebra error message */
 778 extern bool zapi_error_decode(struct stream *s, enum zebra_error_types *error);
 779
 780 static inline void zapi_route_set_blackhole(struct zapi_route *api,
 781                                             enum blackhole_type bh_type)
 782 {
 783         api->nexthop_num = 1;
 784         api->nexthops[0].type = NEXTHOP_TYPE_BLACKHOLE;
 785         api->nexthops[0].vrf_id = VRF_DEFAULT;
 786         api->nexthops[0].bh_type = bh_type;
 787         SET_FLAG(api->message, ZAPI_MESSAGE_NEXTHOP);
 788 };
 789
 790 extern void zclient_send_mlag_register(struct zclient *client,
 791                                        uint32_t bit_map);
 792 extern void zclient_send_mlag_deregister(struct zclient *client);
 793
 794 extern void zclient_send_mlag_data(struct zclient *client,
 795                                    struct stream *client_s);
 796
 797 extern int zclient_capabilities_send(uint32_t cmd, struct zclient *zclient,
 798                 struct zapi_cap *api);
 799 extern int zapi_capabilities_decode(struct stream *s, struct zapi_cap *api);
 800 #endif /* _ZEBRA_ZCLIENT_H */