pimd/pim_msdp.h

   1 /*
   2  * IP MSDP for Quagga
   3  * Copyright (C) 2016 Cumulus Networks, Inc.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for 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 #ifndef PIM_MSDP_H
  20 #define PIM_MSDP_H
  21
  22 #include "lib/openbsd-queue.h"
  23
  24 enum pim_msdp_peer_state {
  25         PIM_MSDP_DISABLED,
  26         PIM_MSDP_INACTIVE,
  27         PIM_MSDP_LISTEN,
  28         PIM_MSDP_CONNECTING,
  29         PIM_MSDP_ESTABLISHED
  30 };
  31
  32 /* SA and KA TLVs are processed; rest ignored */
  33 enum pim_msdp_tlv {
  34         PIM_MSDP_V4_SOURCE_ACTIVE = 1,
  35         PIM_MSDP_V4_SOURCE_ACTIVE_REQUEST,
  36         PIM_MSDP_V4_SOURCE_ACTIVE_RESPONSE,
  37         PIM_MSDP_KEEPALIVE,
  38         PIM_MSDP_RESERVED,
  39         PIM_MSDP_TRACEROUTE_PROGRESS,
  40         PIM_MSDP_TRACEROUTE_REPLY,
  41 };
  42
  43 /* MSDP error codes */
  44 enum pim_msdp_err {
  45         PIM_MSDP_ERR_NONE = 0,
  46         PIM_MSDP_ERR_OOM = -1,
  47         PIM_MSDP_ERR_PEER_EXISTS = -2,
  48         PIM_MSDP_ERR_MAX_MESH_GROUPS = -3,
  49         PIM_MSDP_ERR_NO_PEER = -4,
  50         PIM_MSDP_ERR_MG_MBR_EXISTS = -5,
  51         PIM_MSDP_ERR_NO_MG = -6,
  52         PIM_MSDP_ERR_NO_MG_MBR = -7,
  53         PIM_MSDP_ERR_SIP_EQ_DIP = -8,
  54 };
  55
  56 #define PIM_MSDP_STATE_STRLEN 16
  57 #define PIM_MSDP_UPTIME_STRLEN 80
  58 #define PIM_MSDP_TIMER_STRLEN 12
  59 #define PIM_MSDP_TCP_PORT 639
  60 #define PIM_MSDP_SOCKET_SNDBUF_SIZE 65536
  61
  62 enum pim_msdp_sa_flags {
  63         PIM_MSDP_SAF_NONE = 0,
  64         /* There are two cases where we can pickup an active source locally -
  65          * 1. We are RP and got a source-register from the FHR
  66          * 2. We are RP and FHR and learnt a new directly connected source on a
  67          * DR interface */
  68         PIM_MSDP_SAF_LOCAL = (1 << 0),
  69         /* We got this in the MSDP SA TLV from a peer (and this passed peer-RPF
  70          * checks) */
  71         PIM_MSDP_SAF_PEER = (1 << 1),
  72         PIM_MSDP_SAF_REF = (PIM_MSDP_SAF_LOCAL | PIM_MSDP_SAF_PEER),
  73         PIM_MSDP_SAF_STALE = (1 << 2), /* local entries can get kicked out on
  74                                         * misc pim events such as RP change */
  75         PIM_MSDP_SAF_UP_DEL_IN_PROG = (1 << 3)
  76 };
  77
  78 struct pim_msdp_sa {
  79         struct pim_instance *pim;
  80
  81         pim_sgaddr sg;
  82         char sg_str[PIM_SG_LEN];
  83         struct in_addr rp;   /* Last RP address associated with this SA */
  84         struct in_addr peer; /* last peer from who we heard this SA */
  85         enum pim_msdp_sa_flags flags;
  86
  87 /* rfc-3618 is missing default value for SA-hold-down-Period. pulled
  88  * this number from industry-standards */
  89 #define PIM_MSDP_SA_HOLD_TIME ((3*60)+30)
  90         struct thread *sa_state_timer; // 5.6
  91         int64_t uptime;
  92
  93         struct pim_upstream *up;
  94 };
  95
  96 enum pim_msdp_peer_flags {
  97         PIM_MSDP_PEERF_NONE = 0,
  98         PIM_MSDP_PEERF_LISTENER = (1 << 0),
  99 #define PIM_MSDP_PEER_IS_LISTENER(mp) (mp->flags & PIM_MSDP_PEERF_LISTENER)
 100         PIM_MSDP_PEERF_SA_JUST_SENT = (1 << 1),
 101         /** Flag to signalize that peer belongs to a group. */
 102         PIM_MSDP_PEERF_IN_GROUP = (1 << 2),
 103 };
 104
 105 struct pim_msdp_peer {
 106         struct pim_instance *pim;
 107
 108         /* configuration */
 109         struct in_addr local;
 110         struct in_addr peer;
 111         char *mesh_group_name;
 112         char key_str[INET_ADDRSTRLEN];
 113
 114         /* state */
 115         enum pim_msdp_peer_state state;
 116         enum pim_msdp_peer_flags flags;
 117
 118         /* TCP socket info */
 119         union sockunion su_local;
 120         union sockunion su_peer;
 121         int fd;
 122
 123 /* protocol timers */
 124 #define PIM_MSDP_PEER_HOLD_TIME 75
 125         struct thread *hold_timer; // 5.4
 126 #define PIM_MSDP_PEER_KA_TIME 60
 127         struct thread *ka_timer; // 5.5
 128 #define PIM_MSDP_PEER_CONNECT_RETRY_TIME 30
 129         struct thread *cr_timer; // 5.6
 130
 131         /* packet thread and buffers */
 132         uint32_t packet_size;
 133         struct stream *ibuf;
 134         struct stream_fifo *obuf;
 135         struct thread *t_read;
 136         struct thread *t_write;
 137
 138         /* stats */
 139         uint32_t conn_attempts;
 140         uint32_t est_flaps;
 141         uint32_t sa_cnt; /* number of SAs attributed to this peer */
 142 #define PIM_MSDP_PEER_LAST_RESET_STR 20
 143         char last_reset[PIM_MSDP_PEER_LAST_RESET_STR];
 144
 145         /* packet stats */
 146         uint32_t ka_tx_cnt;
 147         uint32_t sa_tx_cnt;
 148         uint32_t ka_rx_cnt;
 149         uint32_t sa_rx_cnt;
 150         uint32_t unk_rx_cnt;
 151
 152         /* timestamps */
 153         int64_t uptime;
 154 };
 155
 156 struct pim_msdp_mg_mbr {
 157         struct in_addr mbr_ip;
 158         struct pim_msdp_peer *mp;
 159 };
 160
 161 /* PIM MSDP mesh-group */
 162 struct pim_msdp_mg {
 163         char *mesh_group_name;
 164         struct in_addr src_ip;
 165         uint32_t mbr_cnt;
 166         struct list *mbr_list;
 167
 168         /** Belongs to PIM instance list. */
 169         SLIST_ENTRY(pim_msdp_mg) mg_entry;
 170 };
 171
 172 SLIST_HEAD(pim_mesh_group_list, pim_msdp_mg);
 173
 174 enum pim_msdp_flags {
 175         PIM_MSDPF_NONE = 0,
 176         PIM_MSDPF_ENABLE = (1 << 0),
 177         PIM_MSDPF_LISTENER = (1 << 1)
 178 };
 179
 180 struct pim_msdp_listener {
 181         int fd;
 182         union sockunion su;
 183         struct thread *thread;
 184 };
 185
 186 struct pim_msdp {
 187         enum pim_msdp_flags flags;
 188         struct thread_master *master;
 189         struct pim_msdp_listener listener;
 190         uint32_t rejected_accepts;
 191
 192         /* MSDP peer info */
 193         struct hash *peer_hash;
 194         struct list *peer_list;
 195
 196 /* MSDP active-source info */
 197 #define PIM_MSDP_SA_ADVERTISMENT_TIME 60
 198         struct thread *sa_adv_timer; // 5.6
 199         struct hash *sa_hash;
 200         struct list *sa_list;
 201         uint32_t local_cnt;
 202
 203         /* keep a scratch pad for building SA TLVs */
 204         struct stream *work_obuf;
 205
 206         struct in_addr originator_id;
 207
 208         /** List of mesh groups. */
 209         struct pim_mesh_group_list mglist;
 210
 211         /** MSDP global hold time period. */
 212         uint32_t hold_time;
 213         /** MSDP global keep alive period. */
 214         uint32_t keep_alive;
 215         /** MSDP global connection retry period. */
 216         uint32_t connection_retry;
 217 };
 218
 219 #define PIM_MSDP_PEER_READ_ON(mp)                                              \
 220         thread_add_read(mp->pim->msdp.master, pim_msdp_read, mp, mp->fd,       \
 221                         &mp->t_read)
 222
 223 #define PIM_MSDP_PEER_WRITE_ON(mp)                                             \
 224         thread_add_write(mp->pim->msdp.master, pim_msdp_write, mp, mp->fd,     \
 225                          &mp->t_write)
 226
 227 #define PIM_MSDP_PEER_READ_OFF(mp) thread_cancel(&mp->t_read)
 228 #define PIM_MSDP_PEER_WRITE_OFF(mp) thread_cancel(&mp->t_write)
 229
 230 #if PIM_IPV != 6
 231 // struct pim_msdp *msdp;
 232 struct pim_instance;
 233 void pim_msdp_init(struct pim_instance *pim, struct thread_master *master);
 234 void pim_msdp_exit(struct pim_instance *pim);
 235 char *pim_msdp_state_dump(enum pim_msdp_peer_state state, char *buf,
 236                           int buf_size);
 237 struct pim_msdp_peer *pim_msdp_peer_find(struct pim_instance *pim,
 238                                          struct in_addr peer_addr);
 239 void pim_msdp_peer_established(struct pim_msdp_peer *mp);
 240 void pim_msdp_peer_pkt_rxed(struct pim_msdp_peer *mp);
 241 void pim_msdp_peer_stop_tcp_conn(struct pim_msdp_peer *mp, bool chg_state);
 242 void pim_msdp_peer_reset_tcp_conn(struct pim_msdp_peer *mp, const char *rc_str);
 243 void pim_msdp_write(struct thread *thread);
 244 int pim_msdp_config_write(struct pim_instance *pim, struct vty *vty,
 245                           const char *spaces);
 246 bool pim_msdp_peer_config_write(struct vty *vty, struct pim_instance *pim,
 247                                 const char *spaces);
 248 void pim_msdp_peer_pkt_txed(struct pim_msdp_peer *mp);
 249 void pim_msdp_sa_ref(struct pim_instance *pim, struct pim_msdp_peer *mp,
 250                      pim_sgaddr *sg, struct in_addr rp);
 251 void pim_msdp_sa_local_update(struct pim_upstream *up);
 252 void pim_msdp_sa_local_del(struct pim_instance *pim, pim_sgaddr *sg);
 253 void pim_msdp_i_am_rp_changed(struct pim_instance *pim);
 254 bool pim_msdp_peer_rpf_check(struct pim_msdp_peer *mp, struct in_addr rp);
 255 void pim_msdp_up_join_state_changed(struct pim_instance *pim,
 256                                     struct pim_upstream *xg_up);
 257 void pim_msdp_up_del(struct pim_instance *pim, pim_sgaddr *sg);
 258 enum pim_msdp_err pim_msdp_mg_del(struct pim_instance *pim,
 259                                   const char *mesh_group_name);
 260
 261 /**
 262  * Allocates a new mesh group data structure under PIM instance.
 263  */
 264 struct pim_msdp_mg *pim_msdp_mg_new(struct pim_instance *pim,
 265                                     const char *mesh_group_name);
 266 /**
 267  * Deallocates mesh group data structure under PIM instance.
 268  */
 269 void pim_msdp_mg_free(struct pim_instance *pim, struct pim_msdp_mg **mgp);
 270
 271 /**
 272  * Change the source address of a mesh group peers. It will do the following:
 273  * - Close all peers TCP connections
 274  * - Recreate peers data structure
 275  * - Start TCP connections with new local address.
 276  */
 277 void pim_msdp_mg_src_add(struct pim_instance *pim, struct pim_msdp_mg *mg,
 278                          struct in_addr *ai);
 279
 280 /**
 281  * Add new peer to mesh group and starts the connection if source address is
 282  * configured.
 283  */
 284 struct pim_msdp_mg_mbr *pim_msdp_mg_mbr_add(struct pim_instance *pim,
 285                                             struct pim_msdp_mg *mg,
 286                                             struct in_addr *ia);
 287
 288 /**
 289  * Stops the connection and removes the peer data structures.
 290  */
 291 void pim_msdp_mg_mbr_del(struct pim_msdp_mg *mg, struct pim_msdp_mg_mbr *mbr);
 292
 293 /**
 294  * Allocates MSDP peer data structure, adds peer to group name
 295  * `mesh_group_name` and starts state machine. If no group name is provided then
 296  * the peer will work standalone.
 297  *
 298  * \param pim PIM instance
 299  * \param peer_addr peer address
 300  * \param local_addr local listening address
 301  * \param mesh_group_name mesh group name (or `NULL` for peers without group).
 302  */
 303 struct pim_msdp_peer *pim_msdp_peer_add(struct pim_instance *pim,
 304                                         const struct in_addr *peer_addr,
 305                                         const struct in_addr *local_addr,
 306                                         const char *mesh_group_name);
 307
 308 /**
 309  * Stops peer state machine and free memory.
 310  */
 311 void pim_msdp_peer_del(struct pim_msdp_peer **mp);
 312
 313 /**
 314  * Changes peer source address.
 315  *
 316  * NOTE:
 317  * This will cause the connection to drop and start again.
 318  */
 319 void pim_msdp_peer_change_source(struct pim_msdp_peer *mp,
 320                                  const struct in_addr *addr);
 321
 322 #else /* PIM_IPV == 6 */
 323 static inline void pim_msdp_init(struct pim_instance *pim,
 324                                  struct thread_master *master)
 325 {
 326 }
 327
 328 static inline void pim_msdp_exit(struct pim_instance *pim)
 329 {
 330 }
 331
 332 static inline void pim_msdp_i_am_rp_changed(struct pim_instance *pim)
 333 {
 334 }
 335
 336 static inline void pim_msdp_up_join_state_changed(struct pim_instance *pim,
 337                                                   struct pim_upstream *xg_up)
 338 {
 339 }
 340
 341 static inline void pim_msdp_up_del(struct pim_instance *pim, pim_sgaddr *sg)
 342 {
 343 }
 344
 345 static inline void pim_msdp_sa_local_update(struct pim_upstream *up)
 346 {
 347 }
 348
 349 static inline void pim_msdp_sa_local_del(struct pim_instance *pim,
 350                                          pim_sgaddr *sg)
 351 {
 352 }
 353
 354 static inline int pim_msdp_config_write(struct pim_instance *pim,
 355                                         struct vty *vty, const char *spaces)
 356 {
 357         return 0;
 358 }
 359
 360 static inline bool pim_msdp_peer_config_write(struct vty *vty,
 361                                               struct pim_instance *pim,
 362                                               const char *spaces)
 363 {
 364         return false;
 365 }
 366 #endif /* PIM_IPV == 6 */
 367
 368 #endif