[mirror_frr.git] / bgpd / bgp_advertise.h

/* BGP advertisement and adjacency
   Copyright (C) 1996, 97, 98, 99, 2000 Kunihiro Ishiguro

This file is part of GNU Zebra.

GNU Zebra is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.

GNU Zebra is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Zebra; see the file COPYING.  If not, write to the Free
Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.  */

/* BGP advertise FIFO.  */
struct bgp_advertise_fifo
{
  struct bgp_advertise *next;
  struct bgp_advertise *prev;
};

/* BGP advertise attribute.  */
struct bgp_advertise_attr
{
  /* Head of advertisement pointer. */
  struct bgp_advertise *adv;

  /* Reference counter.  */
  unsigned long refcnt;

  /* Attribute pointer to be announced.  */
  struct attr *attr;
};

struct bgp_advertise
{
  /* FIFO for advertisement.  */
  struct bgp_advertise_fifo fifo;

  /* Link list for same attribute advertise.  */
  struct bgp_advertise *next;
  struct bgp_advertise *prev;

  /* Prefix information.  */
  struct bgp_node *rn;

  /* Reference pointer.  */
  struct bgp_adj_out *adj;

  /* Advertisement attribute.  */
  struct bgp_advertise_attr *baa;

  /* BGP info.  */
  struct bgp_info *binfo;
};

/* BGP adjacency out.  */
struct bgp_adj_out
{
  /* Lined list pointer.  */
  struct bgp_adj_out *next;
  struct bgp_adj_out *prev;

  /* Advertised peer.  */
  struct peer *peer;

  /* Advertised attribute.  */
  struct attr *attr;

  /* Advertisement information.  */
  struct bgp_advertise *adv;
};

/* BGP adjacency in. */
struct bgp_adj_in
{
  /* Linked list pointer.  */
  struct bgp_adj_in *next;
  struct bgp_adj_in *prev;

  /* Received peer.  */
  struct peer *peer;

  /* Received attribute.  */
  struct attr *attr;
};

/* BGP advertisement list.  */
struct bgp_synchronize
{
  struct bgp_advertise_fifo update;
  struct bgp_advertise_fifo withdraw;
  struct bgp_advertise_fifo withdraw_low;
};

/* FIFO -- first in first out structure and macros.  */
struct fifo
{
  struct fifo *next;
  struct fifo *prev;
};

#define FIFO_INIT(F)                                  \
  do {                                                \
    struct fifo *Xfifo = (struct fifo *)(F);          \
    Xfifo->next = Xfifo->prev = Xfifo;                \
  } while (0)

#define FIFO_ADD(F,N)                                 \
  do {                                                \
    struct fifo *Xfifo = (struct fifo *)(F);          \
    struct fifo *Xnode = (struct fifo *)(N);          \
    Xnode->next = Xfifo;                              \
    Xnode->prev = Xfifo->prev;                        \
    Xfifo->prev = Xfifo->prev->next = Xnode;          \
  } while (0)

#define FIFO_DEL(N)                                   \
  do {                                                \
    struct fifo *Xnode = (struct fifo *)(N);          \
    Xnode->prev->next = Xnode->next;                  \
    Xnode->next->prev = Xnode->prev;                  \
  } while (0)

#define FIFO_HEAD(F)                                  \
  ((((struct fifo *)(F))->next == (struct fifo *)(F)) \
  ? NULL : (F)->next)

/* BGP adjacency linked list.  */
#define BGP_INFO_ADD(N,A,TYPE)                        \
  do {                                                \
    (A)->prev = NULL;                                 \
    (A)->next = (N)->TYPE;                            \
    if ((N)->TYPE)                                    \
      (N)->TYPE->prev = (A);                          \
    (N)->TYPE = (A);                                  \
  } while (0)

#define BGP_INFO_DEL(N,A,TYPE)                        \
  do {                                                \
    if ((A)->next)                                    \
      (A)->next->prev = (A)->prev;                    \
    if ((A)->prev)                                    \
      (A)->prev->next = (A)->next;                    \
    else                                              \
      (N)->TYPE = (A)->next;                          \
  } while (0)

#define BGP_ADJ_IN_ADD(N,A)    BGP_INFO_ADD(N,A,adj_in)
#define BGP_ADJ_IN_DEL(N,A)    BGP_INFO_DEL(N,A,adj_in)
#define BGP_ADJ_OUT_ADD(N,A)   BGP_INFO_ADD(N,A,adj_out)
#define BGP_ADJ_OUT_DEL(N,A)   BGP_INFO_DEL(N,A,adj_out)

/* Prototypes.  */
void bgp_adj_out_set (struct bgp_node *, struct peer *, struct prefix *,
		      struct attr *, afi_t, safi_t, struct bgp_info *);
void bgp_adj_out_unset (struct bgp_node *, struct peer *, struct prefix *,
			afi_t, safi_t);
void bgp_adj_out_remove (struct bgp_node *, struct bgp_adj_out *, 
			 struct peer *, afi_t, safi_t);
int bgp_adj_out_lookup (struct peer *, struct prefix *, afi_t, safi_t,
			struct bgp_node *);

void bgp_adj_in_set (struct bgp_node *, struct peer *, struct attr *);
void bgp_adj_in_unset (struct bgp_node *, struct peer *);
void bgp_adj_in_remove (struct bgp_node *, struct bgp_adj_in *);

struct bgp_advertise *
bgp_advertise_clean (struct peer *, struct bgp_adj_out *, afi_t, safi_t);

void bgp_sync_init (struct peer *);
void bgp_sync_delete (struct peer *);
Commit	Line	Data
718e3744	1	/* BGP advertisement and adjacency
	2	Copyright (C) 1996, 97, 98, 99, 2000 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 the
	8	Free Software Foundation; either version 2, or (at your option) any
	9	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
	17	along with GNU Zebra; see the file COPYING. If not, write to the Free
	18	Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
	19	02111-1307, USA. */
	20
	21	/* BGP advertise FIFO. */
	22	struct bgp_advertise_fifo
	23	{
	24	struct bgp_advertise *next;
	25	struct bgp_advertise *prev;
	26	};
	27
	28	/* BGP advertise attribute. */
	29	struct bgp_advertise_attr
	30	{
	31	/* Head of advertisement pointer. */
	32	struct bgp_advertise *adv;
	33
	34	/* Reference counter. */
	35	unsigned long refcnt;
	36
	37	/* Attribute pointer to be announced. */
	38	struct attr *attr;
	39	};
	40
	41	struct bgp_advertise
	42	{
	43	/* FIFO for advertisement. */
	44	struct bgp_advertise_fifo fifo;
	45
	46	/* Link list for same attribute advertise. */
	47	struct bgp_advertise *next;
	48	struct bgp_advertise *prev;
	49
	50	/* Prefix information. */
	51	struct bgp_node *rn;
	52
	53	/* Reference pointer. */
	54	struct bgp_adj_out *adj;
	55
	56	/* Advertisement attribute. */
	57	struct bgp_advertise_attr *baa;
	58
	59	/* BGP info. */
	60	struct bgp_info *binfo;
	61	};
	62
	63	/* BGP adjacency out. */
	64	struct bgp_adj_out
65	{
66	/* Lined list pointer. */
67	struct bgp_adj_out *next;
68	struct bgp_adj_out *prev;
69
70	/* Advertised peer. */
71	struct peer *peer;
72
73	/* Advertised attribute. */
74	struct attr *attr;
75
76	/* Advertisement information. */
77	struct bgp_advertise *adv;
78	};
79
80	/* BGP adjacency in. */
81	struct bgp_adj_in
82	{
83	/* Linked list pointer. */
84	struct bgp_adj_in *next;
85	struct bgp_adj_in *prev;
86
87	/* Received peer. */
88	struct peer *peer;
89
90	/* Received attribute. */
91	struct attr *attr;
92	};
93
94	/* BGP advertisement list. */
95	struct bgp_synchronize
96	{
97	struct bgp_advertise_fifo update;
98	struct bgp_advertise_fifo withdraw;
99	struct bgp_advertise_fifo withdraw_low;
100	};
101
102	/* FIFO -- first in first out structure and macros. */
103	struct fifo
104	{
105	struct fifo *next;
106	struct fifo *prev;
107	};
108
109	#define FIFO_INIT(F) \
110	do { \
111	struct fifo Xfifo = (struct fifo )(F); \
112	Xfifo->next = Xfifo->prev = Xfifo; \
113	} while (0)
114
115	#define FIFO_ADD(F,N) \
116	do { \
117	struct fifo Xfifo = (struct fifo )(F); \
118	struct fifo Xnode = (struct fifo )(N); \
119	Xnode->next = Xfifo; \
120	Xnode->prev = Xfifo->prev; \
121	Xfifo->prev = Xfifo->prev->next = Xnode; \
122	} while (0)
123
124	#define FIFO_DEL(N) \
125	do { \
126	struct fifo Xnode = (struct fifo )(N); \
127	Xnode->prev->next = Xnode->next; \
128	Xnode->next->prev = Xnode->prev; \
129	} while (0)
130
131	#define FIFO_HEAD(F) \
132	((((struct fifo )(F))->next == (struct fifo )(F)) \
133	? NULL : (F)->next)
134
135	/* BGP adjacency linked list. */
136	#define BGP_INFO_ADD(N,A,TYPE) \
137	do { \
138	(A)->prev = NULL; \
139	(A)->next = (N)->TYPE; \
140	if ((N)->TYPE) \
141	(N)->TYPE->prev = (A); \
142	(N)->TYPE = (A); \
143	} while (0)
144
145	#define BGP_INFO_DEL(N,A,TYPE) \
146	do { \
147	if ((A)->next) \
148	(A)->next->prev = (A)->prev; \
149	if ((A)->prev) \
150	(A)->prev->next = (A)->next; \
151	else \
152	(N)->TYPE = (A)->next; \
153	} while (0)
154
155	#define BGP_ADJ_IN_ADD(N,A) BGP_INFO_ADD(N,A,adj_in)
156	#define BGP_ADJ_IN_DEL(N,A) BGP_INFO_DEL(N,A,adj_in)
157	#define BGP_ADJ_OUT_ADD(N,A) BGP_INFO_ADD(N,A,adj_out)
158	#define BGP_ADJ_OUT_DEL(N,A) BGP_INFO_DEL(N,A,adj_out)
159
160	/* Prototypes. */
161	void bgp_adj_out_set (struct bgp_node , struct peer , struct prefix *,
162	struct attr , afi_t, safi_t, struct bgp_info );
163	void bgp_adj_out_unset (struct bgp_node , struct peer , struct prefix *,
164	afi_t, safi_t);
165	void bgp_adj_out_remove (struct bgp_node , struct bgp_adj_out ,
166	struct peer *, afi_t, safi_t);
167	int bgp_adj_out_lookup (struct peer , struct prefix , afi_t, safi_t,
168	struct bgp_node *);
169
170	void bgp_adj_in_set (struct bgp_node , struct peer , struct attr *);
171	void bgp_adj_in_unset (struct bgp_node , struct peer );
172	void bgp_adj_in_remove (struct bgp_node , struct bgp_adj_in );
173
174	struct bgp_advertise *
175	bgp_advertise_clean (struct peer , struct bgp_adj_out , afi_t, safi_t);
176
177	void bgp_sync_init (struct peer *);
178	void bgp_sync_delete (struct peer *);