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 #include <zebra.h>
22
23 #include "command.h"
24 #include "memory.h"
25 #include "prefix.h"
26 #include "hash.h"
27 #include "thread.h"
28 #include "filter.h"
29
30 #include "bgpd/bgpd.h"
31 #include "bgpd/bgp_table.h"
32 #include "bgpd/bgp_route.h"
33 #include "bgpd/bgp_advertise.h"
34 #include "bgpd/bgp_attr.h"
35 #include "bgpd/bgp_aspath.h"
36 #include "bgpd/bgp_packet.h"
37 #include "bgpd/bgp_fsm.h"
38 #include "bgpd/bgp_mplsvpn.h"
39
40 /* BGP advertise attribute is used for pack same attribute update into
41 one packet. To do that we maintain attribute hash in struct
42 peer. */
43 static struct bgp_advertise_attr *
baa_new(void)44 baa_new (void)
45 {
46 return (struct bgp_advertise_attr *)
47 XCALLOC (MTYPE_BGP_ADVERTISE_ATTR, sizeof (struct bgp_advertise_attr));
48 }
49
50 static void
baa_free(struct bgp_advertise_attr * baa)51 baa_free (struct bgp_advertise_attr *baa)
52 {
53 XFREE (MTYPE_BGP_ADVERTISE_ATTR, baa);
54 }
55
56 static void *
baa_hash_alloc(void * p)57 baa_hash_alloc (void *p)
58 {
59 struct bgp_advertise_attr * ref = (struct bgp_advertise_attr *) p;
60 struct bgp_advertise_attr *baa;
61
62 baa = baa_new ();
63 baa->attr = ref->attr;
64 return baa;
65 }
66
67 static unsigned int
baa_hash_key(void * p)68 baa_hash_key (void *p)
69 {
70 struct bgp_advertise_attr * baa = (struct bgp_advertise_attr *) p;
71
72 return attrhash_key_make (baa->attr);
73 }
74
75 static int
baa_hash_cmp(const void * p1,const void * p2)76 baa_hash_cmp (const void *p1, const void *p2)
77 {
78 const struct bgp_advertise_attr * baa1 = p1;
79 const struct bgp_advertise_attr * baa2 = p2;
80
81 return attrhash_cmp (baa1->attr, baa2->attr);
82 }
83
84 /* BGP update and withdraw information is stored in BGP advertise
85 structure. This structure is referred from BGP adjacency
86 information. */
87 static struct bgp_advertise *
bgp_advertise_new(void)88 bgp_advertise_new (void)
89 {
90 return (struct bgp_advertise *)
91 XCALLOC (MTYPE_BGP_ADVERTISE, sizeof (struct bgp_advertise));
92 }
93
94 static void
bgp_advertise_free(struct bgp_advertise * adv)95 bgp_advertise_free (struct bgp_advertise *adv)
96 {
97 if (adv->binfo)
98 bgp_info_unlock (adv->binfo); /* bgp_advertise bgp_info reference */
99 XFREE (MTYPE_BGP_ADVERTISE, adv);
100 }
101
102 static void
bgp_advertise_add(struct bgp_advertise_attr * baa,struct bgp_advertise * adv)103 bgp_advertise_add (struct bgp_advertise_attr *baa,
104 struct bgp_advertise *adv)
105 {
106 adv->next = baa->adv;
107 if (baa->adv)
108 baa->adv->prev = adv;
109 baa->adv = adv;
110 }
111
112 static void
bgp_advertise_delete(struct bgp_advertise_attr * baa,struct bgp_advertise * adv)113 bgp_advertise_delete (struct bgp_advertise_attr *baa,
114 struct bgp_advertise *adv)
115 {
116 if (adv->next)
117 adv->next->prev = adv->prev;
118 if (adv->prev)
119 adv->prev->next = adv->next;
120 else
121 baa->adv = adv->next;
122 }
123
124 static struct bgp_advertise_attr *
bgp_advertise_intern(struct hash * hash,struct attr * attr)125 bgp_advertise_intern (struct hash *hash, struct attr *attr)
126 {
127 struct bgp_advertise_attr ref;
128 struct bgp_advertise_attr *baa;
129
130 ref.attr = bgp_attr_intern (attr);
131 baa = (struct bgp_advertise_attr *) hash_get (hash, &ref, baa_hash_alloc);
132 baa->refcnt++;
133
134 return baa;
135 }
136
137 static void
bgp_advertise_unintern(struct hash * hash,struct bgp_advertise_attr * baa)138 bgp_advertise_unintern (struct hash *hash, struct bgp_advertise_attr *baa)
139 {
140 if (baa->refcnt)
141 baa->refcnt--;
142
143 if (baa->refcnt && baa->attr)
144 bgp_attr_unintern (&baa->attr);
145 else
146 {
147 if (baa->attr)
148 {
149 hash_release (hash, baa);
150 bgp_attr_unintern (&baa->attr);
151 }
152 baa_free (baa);
153 }
154 }
155
156 /* BGP adjacency keeps minimal advertisement information. */
157 static void
bgp_adj_out_free(struct bgp_adj_out * adj)158 bgp_adj_out_free (struct bgp_adj_out *adj)
159 {
160 peer_unlock (adj->peer); /* adj_out peer reference */
161 XFREE (MTYPE_BGP_ADJ_OUT, adj);
162 }
163
164 int
bgp_adj_out_lookup(struct peer * peer,struct prefix * p,afi_t afi,safi_t safi,struct bgp_node * rn)165 bgp_adj_out_lookup (struct peer *peer, struct prefix *p,
166 afi_t afi, safi_t safi, struct bgp_node *rn)
167 {
168 struct bgp_adj_out *adj;
169
170 for (adj = rn->adj_out; adj; adj = adj->next)
171 if (adj->peer == peer)
172 break;
173
174 if (! adj)
175 return 0;
176
177 return (adj->adv
178 ? (adj->adv->baa ? 1 : 0)
179 : (adj->attr ? 1 : 0));
180 }
181
182 struct bgp_advertise *
bgp_advertise_clean(struct peer * peer,struct bgp_adj_out * adj,afi_t afi,safi_t safi)183 bgp_advertise_clean (struct peer *peer, struct bgp_adj_out *adj,
184 afi_t afi, safi_t safi)
185 {
186 struct bgp_advertise *adv;
187 struct bgp_advertise_attr *baa;
188 struct bgp_advertise *next;
189 struct bgp_advertise_fifo *fhead;
190
191 adv = adj->adv;
192 baa = adv->baa;
193 next = NULL;
194 fhead = (struct bgp_advertise_fifo *)&peer->sync[afi][safi]->withdraw;
195
196 if (baa)
197 {
198 /* Unlink myself from advertise attribute FIFO. */
199 bgp_advertise_delete (baa, adv);
200
201 /* Fetch next advertise candidate. */
202 next = baa->adv;
203
204 /* Unintern BGP advertise attribute. */
205 bgp_advertise_unintern (peer->hash[afi][safi], baa);
206
207 fhead = (struct bgp_advertise_fifo *)&peer->sync[afi][safi]->update;
208 }
209
210 /* Unlink myself from advertisement FIFO. */
211 BGP_ADV_FIFO_DEL (fhead, adv);
212
213 /* Free memory. */
214 bgp_advertise_free (adj->adv);
215 adj->adv = NULL;
216
217 return next;
218 }
219
220 void
bgp_adj_out_set(struct bgp_node * rn,struct peer * peer,struct prefix * p,struct attr * attr,afi_t afi,safi_t safi,struct bgp_info * binfo)221 bgp_adj_out_set (struct bgp_node *rn, struct peer *peer, struct prefix *p,
222 struct attr *attr, afi_t afi, safi_t safi,
223 struct bgp_info *binfo)
224 {
225 struct bgp_adj_out *adj = NULL;
226 struct bgp_advertise *adv;
227
228 if (DISABLE_BGP_ANNOUNCE)
229 return;
230
231 /* Look for adjacency information. */
232 if (rn)
233 {
234 for (adj = rn->adj_out; adj; adj = adj->next)
235 if (adj->peer == peer)
236 break;
237 }
238
239 if (! adj)
240 {
241 adj = XCALLOC (MTYPE_BGP_ADJ_OUT, sizeof (struct bgp_adj_out));
242 adj->peer = peer_lock (peer); /* adj_out peer reference */
243
244 if (rn)
245 {
246 BGP_ADJ_OUT_ADD (rn, adj);
247 bgp_lock_node (rn);
248 }
249 }
250
251 if (adj->adv)
252 bgp_advertise_clean (peer, adj, afi, safi);
253
254 adj->adv = bgp_advertise_new ();
255
256 adv = adj->adv;
257 adv->rn = rn;
258
259 assert (adv->binfo == NULL);
260 adv->binfo = bgp_info_lock (binfo); /* bgp_info adj_out reference */
261
262 if (attr)
263 adv->baa = bgp_advertise_intern (peer->hash[afi][safi], attr);
264 else
265 adv->baa = baa_new ();
266 adv->adj = adj;
267
268 /* Add new advertisement to advertisement attribute list. */
269 bgp_advertise_add (adv->baa, adv);
270
271 BGP_ADV_FIFO_ADD (&peer->sync[afi][safi]->update, &adv->fifo);
272 }
273
274 void
bgp_adj_out_unset(struct bgp_node * rn,struct peer * peer,struct prefix * p,afi_t afi,safi_t safi)275 bgp_adj_out_unset (struct bgp_node *rn, struct peer *peer, struct prefix *p,
276 afi_t afi, safi_t safi)
277 {
278 struct bgp_adj_out *adj;
279 struct bgp_advertise *adv;
280
281 if (DISABLE_BGP_ANNOUNCE)
282 return;
283
284 /* Lookup existing adjacency, if it is not there return immediately. */
285 for (adj = rn->adj_out; adj; adj = adj->next)
286 if (adj->peer == peer)
287 break;
288
289 if (! adj)
290 return;
291
292 /* Clearn up previous advertisement. */
293 if (adj->adv)
294 bgp_advertise_clean (peer, adj, afi, safi);
295
296 if (adj->attr)
297 {
298 /* We need advertisement structure. */
299 adj->adv = bgp_advertise_new ();
300 adv = adj->adv;
301 adv->rn = rn;
302 adv->adj = adj;
303
304 /* Add to synchronization entry for withdraw announcement. */
305 BGP_ADV_FIFO_ADD (&peer->sync[afi][safi]->withdraw, &adv->fifo);
306
307 /* Schedule packet write. */
308 BGP_WRITE_ON (peer->t_write, bgp_write, peer->fd);
309 }
310 else
311 {
312 /* Remove myself from adjacency. */
313 BGP_ADJ_OUT_DEL (rn, adj);
314
315 /* Free allocated information. */
316 bgp_adj_out_free (adj);
317
318 bgp_unlock_node (rn);
319 }
320 }
321
322 void
bgp_adj_out_remove(struct bgp_node * rn,struct bgp_adj_out * adj,struct peer * peer,afi_t afi,safi_t safi)323 bgp_adj_out_remove (struct bgp_node *rn, struct bgp_adj_out *adj,
324 struct peer *peer, afi_t afi, safi_t safi)
325 {
326 if (adj->attr)
327 bgp_attr_unintern (&adj->attr);
328
329 if (adj->adv)
330 bgp_advertise_clean (peer, adj, afi, safi);
331
332 BGP_ADJ_OUT_DEL (rn, adj);
333 bgp_adj_out_free (adj);
334 }
335
336 void
bgp_adj_in_set(struct bgp_node * rn,struct peer * peer,struct attr * attr)337 bgp_adj_in_set (struct bgp_node *rn, struct peer *peer, struct attr *attr)
338 {
339 struct bgp_adj_in *adj;
340
341 for (adj = rn->adj_in; adj; adj = adj->next)
342 {
343 if (adj->peer == peer)
344 {
345 if (adj->attr != attr)
346 {
347 bgp_attr_unintern (&adj->attr);
348 adj->attr = bgp_attr_intern (attr);
349 }
350 return;
351 }
352 }
353 adj = XCALLOC (MTYPE_BGP_ADJ_IN, sizeof (struct bgp_adj_in));
354 adj->peer = peer_lock (peer); /* adj_in peer reference */
355 adj->attr = bgp_attr_intern (attr);
356 BGP_ADJ_IN_ADD (rn, adj);
357 bgp_lock_node (rn);
358 }
359
360 void
bgp_adj_in_remove(struct bgp_node * rn,struct bgp_adj_in * bai)361 bgp_adj_in_remove (struct bgp_node *rn, struct bgp_adj_in *bai)
362 {
363 bgp_attr_unintern (&bai->attr);
364 BGP_ADJ_IN_DEL (rn, bai);
365 peer_unlock (bai->peer); /* adj_in peer reference */
366 XFREE (MTYPE_BGP_ADJ_IN, bai);
367 }
368
369 int
bgp_adj_in_unset(struct bgp_node * rn,struct peer * peer)370 bgp_adj_in_unset (struct bgp_node *rn, struct peer *peer)
371 {
372 struct bgp_adj_in *adj;
373
374 for (adj = rn->adj_in; adj; adj = adj->next)
375 if (adj->peer == peer)
376 break;
377
378 if (! adj)
379 return 0;
380
381 bgp_adj_in_remove (rn, adj);
382 bgp_unlock_node (rn);
383 return 1;
384 }
385
386 void
bgp_sync_init(struct peer * peer)387 bgp_sync_init (struct peer *peer)
388 {
389 afi_t afi;
390 safi_t safi;
391 struct bgp_synchronize *sync;
392
393 for (afi = AFI_IP; afi < AFI_MAX; afi++)
394 for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
395 {
396 sync = XCALLOC (MTYPE_BGP_SYNCHRONISE,
397 sizeof (struct bgp_synchronize));
398 BGP_ADV_FIFO_INIT (&sync->update);
399 BGP_ADV_FIFO_INIT (&sync->withdraw);
400 BGP_ADV_FIFO_INIT (&sync->withdraw_low);
401 peer->sync[afi][safi] = sync;
402 peer->hash[afi][safi] = hash_create (baa_hash_key, baa_hash_cmp);
403 }
404 }
405
406 void
bgp_sync_delete(struct peer * peer)407 bgp_sync_delete (struct peer *peer)
408 {
409 afi_t afi;
410 safi_t safi;
411
412 for (afi = AFI_IP; afi < AFI_MAX; afi++)
413 for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++)
414 {
415 if (peer->sync[afi][safi])
416 XFREE (MTYPE_BGP_SYNCHRONISE, peer->sync[afi][safi]);
417 peer->sync[afi][safi] = NULL;
418
419 if (peer->hash[afi][safi])
420 hash_free (peer->hash[afi][safi]);
421 peer->hash[afi][safi] = NULL;
422 }
423 }
424