Claudio Jeker(cje...@diehard.n-r-g.com) on 2018.07.18 21:59:44 +0200:
> This is the next small bit of rde rebuilding.
>
> Move nexthop into struct filterstate (including nexthop flags) and use
> them whereever possible. In some places (path_update, softreconfig_out
> handler) the nexthop state are folded back into the rde_aspath.
> This also fixes a possible crash when it comes to nexthop filtering.
>
> --
> :wq Claudio
reads good, also tested.
ok benno@
>
>
> ? obj
> Index: rde.c
> ===================================================================
> RCS file: /cvs/src/usr.sbin/bgpd/rde.c,v
> retrieving revision 1.394
> diff -u -p -r1.394 rde.c
> --- rde.c 16 Jul 2018 09:09:20 -0000 1.394
> +++ rde.c 18 Jul 2018 19:52:26 -0000
> @@ -998,7 +998,7 @@ rde_update_dispatch(struct imsg *imsg)
> imsg->hdr.len - IMSG_HEADER_SIZE - 4 - withdrawn_len - attrpath_len;
> bzero(&mpa, sizeof(mpa));
>
> - rde_filterstate_prep(&state, NULL);
> + rde_filterstate_prep(&state, NULL, NULL);
> if (attrpath_len != 0) { /* 0 = no NLRI information in this message */
> /* parse path attributes */
> while (len > 0) {
> @@ -1221,14 +1221,9 @@ rde_update_dispatch(struct imsg *imsg)
> goto done;
> }
>
> - /*
> - * this works because asp is not linked.
> - * But first unlock the previously locked nexthop.
> - */
> - if (state.aspath.nexthop) {
> - (void)nexthop_put(state.aspath.nexthop);
> - state.aspath.nexthop = NULL;
> - }
> + /* unlock the previously locked nexthop, it is no longer used */
> + (void)nexthop_put(state.nexthop);
> + state.nexthop = NULL;
> if ((pos = rde_get_mp_nexthop(mpp, mplen, aid, &state)) == -1) {
> log_peer_warnx(&peer->conf, "bad nlri prefix");
> rde_update_err(peer, ERR_UPDATE, ERR_UPD_OPTATTR,
> @@ -1318,13 +1313,13 @@ rde_update_update(struct rde_peer *peer,
> for (i = RIB_LOC_START; i < rib_size; i++) {
> if (*ribs[i].name == '\0')
> break;
> - rde_filterstate_prep(&state, &in->aspath);
> + rde_filterstate_prep(&state, &in->aspath, in->nexthop);
> /* input filter */
> action = rde_filter(ribs[i].in_rules, peer, p, &state);
>
> if (action == ACTION_ALLOW) {
> rde_update_log("update", i, peer,
> - &state.aspath.nexthop->exit_nexthop, prefix,
> + &state.nexthop->exit_nexthop, prefix,
> prefixlen);
> path_update(&ribs[i].rib, peer, &state, prefix,
> prefixlen, 0);
> @@ -1499,7 +1494,8 @@ bad_flags:
> op, len);
> return (-1);
> }
> - a->nexthop = nexthop_get(&nexthop);
> + nexthop_put(state->nexthop); /* just to be sure */
> + state->nexthop = nexthop_get(&nexthop);
> break;
> case ATTR_MED:
> if (attr_len != 4)
> @@ -1832,7 +1828,8 @@ rde_get_mp_nexthop(u_char *data, u_int16
> return (-1);
> }
>
> - state->aspath.nexthop = nexthop_get(&nexthop);
> + nexthop_put(state->nexthop); /* just to be sure */
> + state->nexthop = nexthop_get(&nexthop);
>
> /* ignore reserved (old SNPA) field as per RFC4760 */
> totlen += nhlen + 1;
> @@ -2251,7 +2248,7 @@ rde_dump_filterout(struct rde_peer *peer
> if (up_test_update(peer, p) != 1)
> return;
>
> - rde_filterstate_prep(&state, prefix_aspath(p));
> + rde_filterstate_prep(&state, prefix_aspath(p), prefix_nexthop(p));
> a = rde_filter(out_rules, peer, p, &state);
>
> if (a == ACTION_ALLOW)
> @@ -3006,7 +3003,7 @@ rde_softreconfig_in(struct rib_entry *re
> asp = prefix_aspath(p);
> peer = asp->peer;
>
> - rde_filterstate_prep(&state, asp);
> + rde_filterstate_prep(&state, asp, prefix_nexthop(p));
> action = rde_filter(rib->in_rules, peer, p, &state);
>
> if (action == ACTION_ALLOW) {
> @@ -3044,8 +3041,8 @@ rde_softreconfig_out(struct rib_entry *r
> if (up_test_update(peer, p) != 1)
> return;
>
> - rde_filterstate_prep(&ostate, prefix_aspath(p));
> - rde_filterstate_prep(&nstate, prefix_aspath(p));
> + rde_filterstate_prep(&ostate, prefix_aspath(p), prefix_nexthop(p));
> + rde_filterstate_prep(&nstate, prefix_aspath(p), prefix_nexthop(p));
> oa = rde_filter(out_rules_tmp, peer, p, &ostate);
> na = rde_filter(out_rules, peer, p, &nstate);
>
> @@ -3054,14 +3051,23 @@ rde_softreconfig_out(struct rib_entry *r
> /* nothing todo */
> if (oa == ACTION_DENY && na == ACTION_ALLOW) {
> /* send update */
> - up_generate(peer, &nstate.aspath, &addr, pt->prefixlen);
> + up_generate(peer, &nstate, &addr, pt->prefixlen);
> } else if (oa == ACTION_ALLOW && na == ACTION_DENY) {
> /* send withdraw */
> up_generate(peer, NULL, &addr, pt->prefixlen);
> } else if (oa == ACTION_ALLOW && na == ACTION_ALLOW) {
> + /* XXX update nexthop for now, ugly but will go away */
> + nexthop_put(nstate.aspath.nexthop);
> + nstate.aspath.nexthop = nexthop_ref(nstate.nexthop);
> + nstate.aspath.flags = (nstate.aspath.flags & ~F_NEXTHOP_MASK) |
> + (nstate.nhflags & F_NEXTHOP_MASK);
> + nexthop_put(ostate.aspath.nexthop);
> + ostate.aspath.nexthop = nexthop_ref(ostate.nexthop);
> + ostate.aspath.flags = (ostate.aspath.flags & ~F_NEXTHOP_MASK) |
> + (ostate.nhflags & F_NEXTHOP_MASK);
> /* send update if path attributes changed */
> if (path_compare(&nstate.aspath, &ostate.aspath) != 0)
> - up_generate(peer, &nstate.aspath, &addr, pt->prefixlen);
> + up_generate(peer, &nstate, &addr, pt->prefixlen);
> }
>
> rde_filterstate_clean(&ostate);
> @@ -3084,7 +3090,7 @@ rde_softreconfig_unload_peer(struct rib_
> if (up_test_update(peer, p) != 1)
> return;
>
> - rde_filterstate_prep(&ostate, prefix_aspath(p));
> + rde_filterstate_prep(&ostate, prefix_aspath(p), prefix_nexthop(p));
> if (rde_filter(out_rules_tmp, peer, p, &ostate) != ACTION_DENY) {
> /* send withdraw */
> up_generate(peer, NULL, &addr, pt->prefixlen);
> @@ -3559,7 +3565,7 @@ network_add(struct network_config *nc, i
> }
> if (!flagstatic)
> asp->flags |= F_ANN_DYNAMIC;
> - rde_filterstate_prep(&state, asp);
> + rde_filterstate_prep(&state, asp, NULL); /* nexthop is not set */
> rde_apply_set(&nc->attrset, &state, nc->prefix.aid, peerself, peerself);
> if (vpnset)
> rde_apply_set(vpnset, &state, nc->prefix.aid, peerself,
> Index: rde.h
> ===================================================================
> RCS file: /cvs/src/usr.sbin/bgpd/rde.h,v
> retrieving revision 1.179
> diff -u -p -r1.179 rde.h
> --- rde.h 16 Jul 2018 09:09:20 -0000 1.179
> +++ rde.h 18 Jul 2018 19:52:26 -0000
> @@ -316,6 +316,8 @@ struct prefix {
>
> struct filterstate {
> struct rde_aspath aspath;
> + struct nexthop *nexthop;
> + unsigned int nhflags;
> };
>
> extern struct rde_memstats rdemem;
> @@ -405,7 +407,7 @@ u_char *community_ext_delete_non_trans(
> void prefix_evaluate(struct prefix *, struct rib_entry *);
>
> /* rde_filter.c */
> -void rde_filterstate_prep(struct filterstate *, struct rde_aspath
> *);
> +void rde_filterstate_prep(struct filterstate *, struct rde_aspath
> *, struct nexthop *);
> void rde_filterstate_clean(struct filterstate *);
> enum filter_actions rde_filter(struct filter_head *, struct rde_peer *,
> struct prefix *, struct filterstate *);
> @@ -506,6 +508,12 @@ prefix_aspath(struct prefix *p)
> return (p->aspath);
> }
>
> +static inline struct nexthop *
> +prefix_nexthop(struct prefix *p)
> +{
> + return (p->aspath->nexthop);
> +}
> +
> static inline struct rde_peer *
> prefix_peer(struct prefix *p)
> {
> @@ -528,7 +536,7 @@ int nexthop_compare(struct nexthop *,
> void up_init(struct rde_peer *);
> void up_down(struct rde_peer *);
> int up_test_update(struct rde_peer *, struct prefix *);
> -int up_generate(struct rde_peer *, struct rde_aspath *,
> +int up_generate(struct rde_peer *, struct filterstate *,
> struct bgpd_addr *, u_int8_t);
> void up_generate_updates(struct filter_head *, struct rde_peer *,
> struct prefix *, struct prefix *);
> Index: rde_filter.c
> ===================================================================
> RCS file: /cvs/src/usr.sbin/bgpd/rde_filter.c,v
> retrieving revision 1.96
> diff -u -p -r1.96 rde_filter.c
> --- rde_filter.c 16 Jul 2018 09:09:20 -0000 1.96
> +++ rde_filter.c 18 Jul 2018 19:52:26 -0000
> @@ -30,7 +30,7 @@
> #include "log.h"
>
> int rde_filter_match(struct filter_rule *, struct rde_peer *,
> - struct rde_aspath *, struct prefix *);
> + struct filterstate *, struct prefix *);
> int rde_prefix_match(struct filter_prefix *, struct prefix *);
> int filterset_equal(struct filter_set_head *, struct filter_set_head *);
>
> @@ -139,7 +139,7 @@ rde_apply_set(struct filter_set_head *sh
> case ACTION_SET_NEXTHOP_NOMODIFY:
> case ACTION_SET_NEXTHOP_SELF:
> nexthop_modify(set->action.nh, set->type, aid,
> - &state->aspath.nexthop, &state->aspath.flags);
> + &state->nexthop, &state->nhflags);
> break;
> case ACTION_SET_COMMUNITY:
> switch (set->action.community.as) {
> @@ -338,12 +338,16 @@ rde_apply_set(struct filter_set_head *sh
>
> int
> rde_filter_match(struct filter_rule *f, struct rde_peer *peer,
> - struct rde_aspath *asp, struct prefix *p)
> + struct filterstate *state, struct prefix *p)
> {
> u_int32_t pas;
> int cas, type;
> int64_t las, ld1, ld2;
> - struct prefixset_item *psi;
> + struct prefixset_item *psi;
> + struct rde_aspath *asp = NULL;
> +
> + if (state != NULL)
> + asp = &state->aspath;
>
> if (asp != NULL && f->match.as.type != AS_NONE) {
> if (f->match.as.flags & AS_FLAG_NEIGHBORAS)
> @@ -355,10 +359,10 @@ rde_filter_match(struct filter_rule *f,
> return (0);
> }
>
> - if (asp != NULL && f->peer.ebgp && !peer->conf.ebgp)
> - return (0);
> - if (asp != NULL && f->peer.ibgp && peer->conf.ebgp)
> - return (0);
> + if (f->peer.ebgp && !peer->conf.ebgp)
> + return (0);
> + if (f->peer.ibgp && peer->conf.ebgp)
> + return (0);
>
> if (asp != NULL && f->match.aslen.type != ASLEN_NONE)
> if (aspath_lenmatch(asp->aspath, f->match.aslen.type,
> @@ -450,12 +454,12 @@ rde_filter_match(struct filter_rule *f,
> return (0);
> }
>
> - if (f->match.nexthop.flags != 0) {
> + if (state != NULL && f->match.nexthop.flags != 0) {
> struct bgpd_addr *nexthop, *cmpaddr;
> - if (asp != NULL && asp->nexthop == NULL)
> + if (state->nexthop == NULL)
> /* no nexthop, skip */
> return (0);
> - nexthop = &asp->nexthop->exit_nexthop;
> + nexthop = &state->nexthop->exit_nexthop;
> if (f->match.nexthop.flags == FILTER_NEXTHOP_ADDR)
> cmpaddr = &f->match.nexthop.addr;
> else
> @@ -635,19 +639,26 @@ rde_filter_equal(struct filter_head *a,
> }
>
> void
> -rde_filterstate_prep(struct filterstate *state, struct rde_aspath *asp)
> +rde_filterstate_prep(struct filterstate *state, struct rde_aspath *asp,
> + struct nexthop *nh)
> {
> memset(state, 0, sizeof(*state));
>
> path_prep(&state->aspath);
> if (asp)
> path_copy(&state->aspath, asp);
> + state->nexthop = nexthop_ref(nh);
> + /* XXX the flag handling needs improvement */
> + if (asp)
> + state->nhflags |= asp->flags & F_NEXTHOP_MASK;
> }
>
> void
> rde_filterstate_clean(struct filterstate *state)
> {
> path_clean(&state->aspath);
> + nexthop_put(state->nexthop);
> + state->nexthop = NULL;
> }
>
> void
> @@ -1007,10 +1018,9 @@ rde_filter(struct filter_head *rules, st
> struct prefix *p, struct filterstate *state)
> {
> struct filter_rule *f;
> - struct rde_aspath *asp = prefix_aspath(p);
> enum filter_actions action = ACTION_DENY; /* default deny */
>
> - if (asp->flags & F_ATTR_PARSE_ERR)
> + if (state && state->aspath.flags & F_ATTR_PARSE_ERR)
> /*
> * don't try to filter bad updates just deny them
> * so they act as implicit withdraws
> @@ -1035,7 +1045,7 @@ rde_filter(struct filter_head *rules, st
> f->peer.peerid != peer->conf.id),
> f->skip[RDE_FILTER_SKIP_PEERID].ptr);
>
> - if (rde_filter_match(f, peer, asp, p)) {
> + if (rde_filter_match(f, peer, state, p)) {
> if (state != NULL) {
> rde_apply_set(&f->set, state,
> p->re->prefix->aid, prefix_peer(p), peer);
> Index: rde_rib.c
> ===================================================================
> RCS file: /cvs/src/usr.sbin/bgpd/rde_rib.c,v
> retrieving revision 1.171
> diff -u -p -r1.171 rde_rib.c
> --- rde_rib.c 16 Jul 2018 09:09:20 -0000 1.171
> +++ rde_rib.c 18 Jul 2018 19:52:27 -0000
> @@ -423,6 +423,11 @@ path_update(struct rib *rib, struct rde_
> struct prefix *p;
> int pflag = 0;
>
> + nexthop_put(nasp->nexthop);
> + nasp->nexthop = nexthop_ref(state->nexthop);
> + nasp->flags = (nasp->flags & ~F_NEXTHOP_MASK) |
> + (state->nhflags & F_NEXTHOP_MASK);
> +
> if (nasp->pftableid) {
> rde_send_pftable(nasp->pftableid, prefix, prefixlen, 0);
> rde_send_pftable_commit();
> @@ -1467,4 +1472,3 @@ nexthop_hash(struct bgpd_addr *nexthop)
> }
> return (&nexthoptable.nexthop_hashtbl[h &
> nexthoptable.nexthop_hashmask]);
> }
> -
> Index: rde_update.c
> ===================================================================
> RCS file: /cvs/src/usr.sbin/bgpd/rde_update.c,v
> retrieving revision 1.94
> diff -u -p -r1.94 rde_update.c
> --- rde_update.c 9 Jul 2018 14:08:48 -0000 1.94
> +++ rde_update.c 18 Jul 2018 19:52:27 -0000
> @@ -27,11 +27,11 @@
> #include "rde.h"
> #include "log.h"
>
> -in_addr_t up_get_nexthop(struct rde_peer *, struct rde_aspath *);
> +in_addr_t up_get_nexthop(struct rde_peer *, struct filterstate *);
> int up_generate_mp_reach(struct rde_peer *, struct update_attr *,
> - struct rde_aspath *, u_int8_t);
> + struct filterstate *, u_int8_t);
> int up_generate_attr(struct rde_peer *, struct update_attr *,
> - struct rde_aspath *, u_int8_t);
> + struct filterstate *, u_int8_t);
>
> /* update stuff. */
> struct update_prefix {
> @@ -354,19 +354,19 @@ up_test_update(struct rde_peer *peer, st
> }
>
> int
> -up_generate(struct rde_peer *peer, struct rde_aspath *asp,
> +up_generate(struct rde_peer *peer, struct filterstate *state,
> struct bgpd_addr *addr, u_int8_t prefixlen)
> {
> struct update_attr *ua = NULL;
> struct update_prefix *up;
> SIPHASH_CTX ctx;
>
> - if (asp) {
> + if (state) {
> ua = calloc(1, sizeof(struct update_attr));
> if (ua == NULL)
> fatal("up_generate");
>
> - if (up_generate_attr(peer, ua, asp, addr->aid) == -1) {
> + if (up_generate_attr(peer, ua, state, addr->aid) == -1) {
> log_warnx("generation of bgp path attributes failed");
> free(ua);
> return (-1);
> @@ -425,14 +425,15 @@ withdraw:
> return;
> }
>
> - rde_filterstate_prep(&state, prefix_aspath(new));
> + rde_filterstate_prep(&state, prefix_aspath(new),
> + prefix_nexthop(new));
> if (rde_filter(rules, peer, new, &state) == ACTION_DENY) {
> rde_filterstate_clean(&state);
> goto withdraw;
> }
>
> pt_getaddr(new->re->prefix, &addr);
> - up_generate(peer, &state.aspath, &addr,
> + up_generate(peer, &state, &addr,
> new->re->prefix->prefixlen);
>
> rde_filterstate_clean(&state);
> @@ -484,13 +485,13 @@ up_generate_default(struct filter_head *
> p.flags = 0;
>
> /* filter as usual */
> - rde_filterstate_prep(&state, asp);
> + rde_filterstate_prep(&state, asp, NULL);
> if (rde_filter(rules, peer, &p, &state) == ACTION_DENY) {
> rde_filterstate_clean(&state);
> return;
> }
>
> - up_generate(peer, &state.aspath, &addr, 0);
> + up_generate(peer, &state, &addr, 0);
>
> /* no longer needed */
> rde_filterstate_clean(&state);
> @@ -541,27 +542,27 @@ u_char up_attr_buf[4096];
>
> /* only for IPv4 */
> in_addr_t
> -up_get_nexthop(struct rde_peer *peer, struct rde_aspath *a)
> +up_get_nexthop(struct rde_peer *peer, struct filterstate *state)
> {
> in_addr_t mask;
>
> /* nexthop, already network byte order */
> - if (a->flags & F_NEXTHOP_NOMODIFY) {
> + if (state->nhflags & F_NEXTHOP_NOMODIFY) {
> /* no modify flag set */
> - if (a->nexthop == NULL)
> + if (state->nexthop == NULL)
> return (peer->local_v4_addr.v4.s_addr);
> else
> - return (a->nexthop->exit_nexthop.v4.s_addr);
> - } else if (a->flags & F_NEXTHOP_SELF)
> + return (state->nexthop->exit_nexthop.v4.s_addr);
> + } else if (state->nhflags & F_NEXTHOP_SELF)
> return (peer->local_v4_addr.v4.s_addr);
> else if (!peer->conf.ebgp) {
> /*
> * If directly connected use peer->local_v4_addr
> * this is only true for announced networks.
> */
> - if (a->nexthop == NULL)
> + if (state->nexthop == NULL)
> return (peer->local_v4_addr.v4.s_addr);
> - else if (a->nexthop->exit_nexthop.v4.s_addr ==
> + else if (state->nexthop->exit_nexthop.v4.s_addr ==
> peer->remote_addr.v4.s_addr)
> /*
> * per RFC: if remote peer address is equal to
> @@ -570,17 +571,17 @@ up_get_nexthop(struct rde_peer *peer, st
> */
> return (peer->local_v4_addr.v4.s_addr);
> else
> - return (a->nexthop->exit_nexthop.v4.s_addr);
> + return (state->nexthop->exit_nexthop.v4.s_addr);
> } else if (peer->conf.distance == 1) {
> /* ebgp directly connected */
> - if (a->nexthop != NULL &&
> - a->nexthop->flags & NEXTHOP_CONNECTED) {
> + if (state->nexthop != NULL &&
> + state->nexthop->flags & NEXTHOP_CONNECTED) {
> mask = htonl(
> - prefixlen2mask(a->nexthop->nexthop_netlen));
> + prefixlen2mask(state->nexthop->nexthop_netlen));
> if ((peer->remote_addr.v4.s_addr & mask) ==
> - (a->nexthop->nexthop_net.v4.s_addr & mask))
> + (state->nexthop->nexthop_net.v4.s_addr & mask))
> /* nexthop and peer are in the same net */
> - return (a->nexthop->exit_nexthop.v4.s_addr);
> + return (state->nexthop->exit_nexthop.v4.s_addr);
> else
> return (peer->local_v4_addr.v4.s_addr);
> } else
> @@ -597,7 +598,7 @@ up_get_nexthop(struct rde_peer *peer, st
>
> int
> up_generate_mp_reach(struct rde_peer *peer, struct update_attr *upa,
> - struct rde_aspath *a, u_int8_t aid)
> + struct filterstate *state, u_int8_t aid)
> {
> u_int16_t tmp;
>
> @@ -615,43 +616,43 @@ up_generate_mp_reach(struct rde_peer *pe
> upa->mpattr[20] = 0; /* Reserved must be 0 */
>
> /* nexthop dance see also up_get_nexthop() */
> - if (a->flags & F_NEXTHOP_NOMODIFY) {
> + if (state->nhflags & F_NEXTHOP_NOMODIFY) {
> /* no modify flag set */
> - if (a->nexthop == NULL)
> + if (state->nexthop == NULL)
> memcpy(&upa->mpattr[4], &peer->local_v6_addr.v6,
> sizeof(struct in6_addr));
> else
> memcpy(&upa->mpattr[4],
> - &a->nexthop->exit_nexthop.v6,
> + &state->nexthop->exit_nexthop.v6,
> sizeof(struct in6_addr));
> - } else if (a->flags & F_NEXTHOP_SELF)
> + } else if (state->nhflags & F_NEXTHOP_SELF)
> memcpy(&upa->mpattr[4], &peer->local_v6_addr.v6,
> sizeof(struct in6_addr));
> else if (!peer->conf.ebgp) {
> /* ibgp */
> - if (a->nexthop == NULL ||
> - (a->nexthop->exit_nexthop.aid == AID_INET6 &&
> - !memcmp(&a->nexthop->exit_nexthop.v6,
> + if (state->nexthop == NULL ||
> + (state->nexthop->exit_nexthop.aid == AID_INET6 &&
> + !memcmp(&state->nexthop->exit_nexthop.v6,
> &peer->remote_addr.v6, sizeof(struct in6_addr))))
> memcpy(&upa->mpattr[4], &peer->local_v6_addr.v6,
> sizeof(struct in6_addr));
> else
> memcpy(&upa->mpattr[4],
> - &a->nexthop->exit_nexthop.v6,
> + &state->nexthop->exit_nexthop.v6,
> sizeof(struct in6_addr));
> } else if (peer->conf.distance == 1) {
> /* ebgp directly connected */
> - if (a->nexthop != NULL &&
> - a->nexthop->flags & NEXTHOP_CONNECTED)
> + if (state->nexthop != NULL &&
> + state->nexthop->flags & NEXTHOP_CONNECTED)
> if (prefix_compare(&peer->remote_addr,
> - &a->nexthop->nexthop_net,
> - a->nexthop->nexthop_netlen) == 0) {
> + &state->nexthop->nexthop_net,
> + state->nexthop->nexthop_netlen) == 0) {
> /*
> * nexthop and peer are in the same
> * subnet
> */
> memcpy(&upa->mpattr[4],
> - &a->nexthop->exit_nexthop.v6,
> + &state->nexthop->exit_nexthop.v6,
> sizeof(struct in6_addr));
> return (0);
> }
> @@ -674,46 +675,46 @@ up_generate_mp_reach(struct rde_peer *pe
> upa->mpattr[3] = sizeof(u_int64_t) + sizeof(struct in_addr);
>
> /* nexthop dance see also up_get_nexthop() */
> - if (a->flags & F_NEXTHOP_NOMODIFY) {
> + if (state->nhflags & F_NEXTHOP_NOMODIFY) {
> /* no modify flag set */
> - if (a->nexthop == NULL)
> + if (state->nexthop == NULL)
> memcpy(&upa->mpattr[12],
> &peer->local_v4_addr.v4,
> sizeof(struct in_addr));
> else
> /* nexthops are stored as IPv4 addrs */
> memcpy(&upa->mpattr[12],
> - &a->nexthop->exit_nexthop.v4,
> + &state->nexthop->exit_nexthop.v4,
> sizeof(struct in_addr));
> - } else if (a->flags & F_NEXTHOP_SELF)
> + } else if (state->nhflags & F_NEXTHOP_SELF)
> memcpy(&upa->mpattr[12], &peer->local_v4_addr.v4,
> sizeof(struct in_addr));
> else if (!peer->conf.ebgp) {
> /* ibgp */
> - if (a->nexthop == NULL ||
> - (a->nexthop->exit_nexthop.aid == AID_INET &&
> - !memcmp(&a->nexthop->exit_nexthop.v4,
> + if (state->nexthop == NULL ||
> + (state->nexthop->exit_nexthop.aid == AID_INET &&
> + !memcmp(&state->nexthop->exit_nexthop.v4,
> &peer->remote_addr.v4, sizeof(struct in_addr))))
> memcpy(&upa->mpattr[12],
> &peer->local_v4_addr.v4,
> sizeof(struct in_addr));
> else
> memcpy(&upa->mpattr[12],
> - &a->nexthop->exit_nexthop.v4,
> + &state->nexthop->exit_nexthop.v4,
> sizeof(struct in_addr));
> } else if (peer->conf.distance == 1) {
> /* ebgp directly connected */
> - if (a->nexthop != NULL &&
> - a->nexthop->flags & NEXTHOP_CONNECTED)
> + if (state->nexthop != NULL &&
> + state->nexthop->flags & NEXTHOP_CONNECTED)
> if (prefix_compare(&peer->remote_addr,
> - &a->nexthop->nexthop_net,
> - a->nexthop->nexthop_netlen) == 0) {
> + &state->nexthop->nexthop_net,
> + state->nexthop->nexthop_netlen) == 0) {
> /*
> * nexthop and peer are in the same
> * subnet
> */
> memcpy(&upa->mpattr[12],
> - &a->nexthop->exit_nexthop.v4,
> + &state->nexthop->exit_nexthop.v4,
> sizeof(struct in_addr));
> return (0);
> }
> @@ -732,8 +733,9 @@ up_generate_mp_reach(struct rde_peer *pe
>
> int
> up_generate_attr(struct rde_peer *peer, struct update_attr *upa,
> - struct rde_aspath *a, u_int8_t aid)
> + struct filterstate *state, u_int8_t aid)
> {
> + struct rde_aspath *asp = &state->aspath;
> struct attr *oa, *newaggr = NULL;
> u_char *pdata;
> u_int32_t tmp32;
> @@ -746,17 +748,17 @@ up_generate_attr(struct rde_peer *peer,
>
> /* origin */
> if ((r = attr_write(up_attr_buf + wlen, len, ATTR_WELL_KNOWN,
> - ATTR_ORIGIN, &a->origin, 1)) == -1)
> + ATTR_ORIGIN, &asp->origin, 1)) == -1)
> return (-1);
> wlen += r; len -= r;
>
> /* aspath */
> if (!peer->conf.ebgp ||
> peer->conf.flags & PEERFLAG_TRANS_AS)
> - pdata = aspath_prepend(a->aspath, peer->conf.local_as, 0,
> + pdata = aspath_prepend(asp->aspath, peer->conf.local_as, 0,
> &plen);
> else
> - pdata = aspath_prepend(a->aspath, peer->conf.local_as, 1,
> + pdata = aspath_prepend(asp->aspath, peer->conf.local_as, 1,
> &plen);
>
> if (!rde_as4byte(peer))
> @@ -770,7 +772,7 @@ up_generate_attr(struct rde_peer *peer,
>
> switch (aid) {
> case AID_INET:
> - nexthop = up_get_nexthop(peer, a);
> + nexthop = up_get_nexthop(peer, state);
> if ((r = attr_write(up_attr_buf + wlen, len, ATTR_WELL_KNOWN,
> ATTR_NEXTHOP, &nexthop, 4)) == -1)
> return (-1);
> @@ -786,10 +788,10 @@ up_generate_attr(struct rde_peer *peer,
> * unless the MED is originating from us or the peer is an IBGP one.
> * Only exception are routers with "transparent-as yes" set.
> */
> - if (a->flags & F_ATTR_MED && (!peer->conf.ebgp ||
> - a->flags & F_ATTR_MED_ANNOUNCE ||
> + if (asp->flags & F_ATTR_MED && (!peer->conf.ebgp ||
> + asp->flags & F_ATTR_MED_ANNOUNCE ||
> peer->conf.flags & PEERFLAG_TRANS_AS)) {
> - tmp32 = htonl(a->med);
> + tmp32 = htonl(asp->med);
> if ((r = attr_write(up_attr_buf + wlen, len, ATTR_OPTIONAL,
> ATTR_MED, &tmp32, 4)) == -1)
> return (-1);
> @@ -798,7 +800,7 @@ up_generate_attr(struct rde_peer *peer,
>
> if (!peer->conf.ebgp) {
> /* local preference, only valid for ibgp */
> - tmp32 = htonl(a->lpref);
> + tmp32 = htonl(asp->lpref);
> if ((r = attr_write(up_attr_buf + wlen, len, ATTR_WELL_KNOWN,
> ATTR_LOCALPREF, &tmp32, 4)) == -1)
> return (-1);
> @@ -814,8 +816,8 @@ up_generate_attr(struct rde_peer *peer,
> * 3. transitive known attrs: announce unmodified
> * 4. transitive unknown attrs: set partial bit and re-announce
> */
> - for (l = 0; l < a->others_len; l++) {
> - if ((oa = a->others[l]) == NULL)
> + for (l = 0; l < asp->others_len; l++) {
> + if ((oa = asp->others[l]) == NULL)
> break;
> switch (oa->type) {
> case ATTR_ATOMIC_AGGREGATE:
> @@ -912,13 +914,13 @@ up_generate_attr(struct rde_peer *peer,
> if (neednewpath) {
> if (!peer->conf.ebgp ||
> peer->conf.flags & PEERFLAG_TRANS_AS)
> - pdata = aspath_prepend(a->aspath, peer->conf.local_as,
> + pdata = aspath_prepend(asp->aspath, peer->conf.local_as,
> 0, &plen);
> else
> - pdata = aspath_prepend(a->aspath, peer->conf.local_as,
> + pdata = aspath_prepend(asp->aspath, peer->conf.local_as,
> 1, &plen);
> flags = ATTR_OPTIONAL|ATTR_TRANSITIVE;
> - if (!(a->flags & F_PREFIX_ANNOUNCED))
> + if (!(asp->flags & F_PREFIX_ANNOUNCED))
> flags |= ATTR_PARTIAL;
> if (plen == 0)
> r = 0;
> @@ -930,7 +932,7 @@ up_generate_attr(struct rde_peer *peer,
> }
> if (newaggr) {
> flags = ATTR_OPTIONAL|ATTR_TRANSITIVE;
> - if (!(a->flags & F_PREFIX_ANNOUNCED))
> + if (!(asp->flags & F_PREFIX_ANNOUNCED))
> flags |= ATTR_PARTIAL;
> if ((r = attr_write(up_attr_buf + wlen, len, flags,
> ATTR_AS4_AGGREGATOR, newaggr->data, newaggr->len)) == -1)
> @@ -940,7 +942,7 @@ up_generate_attr(struct rde_peer *peer,
>
> /* write mp attribute to different buffer */
> if (ismp)
> - if (up_generate_mp_reach(peer, upa, a, aid) == -1)
> + if (up_generate_mp_reach(peer, upa, state, aid) == -1)
> return (-1);
>
> /* the bgp path attributes are now stored in the global buf */
>
