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