mirror_frr/zebra/connected.c
Christian Franke f7f740fe58 zebra: add ZEBRA_IFC_QUEUED to keep track of kernel state
As there are timeframes when we don't get a notification from the kernel
about new addresses. (e.g. while Linux performs IPv6 DAD), we need to
have some information whether an address has been sent to the kernel or
not.

One case where this is relevant would be a user adding an IPv6 address,
but deleting it before DAD has been complete. With the next patch which
removes some (ill assuming) synchronous parts in address setup,
ipv6_address_uninstall would not know whether or not it has to actually
delete the prefix from the kernel. Resolving these windows where we lack
information is what the flag ZEBRA_IFC_QUEUED is intended for.

Signed-off-by: Christian Franke <chris@opensourcerouting.org>
Signed-off-by: David Lamparter <equinox@opensourcerouting.org>
2013-09-19 17:51:16 +02:00

454 lines
12 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* Address linked list routine.
* Copyright (C) 1997, 98 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.
*/
#include <zebra.h>
#include "prefix.h"
#include "linklist.h"
#include "if.h"
#include "table.h"
#include "rib.h"
#include "table.h"
#include "log.h"
#include "memory.h"
#include "zebra/zserv.h"
#include "zebra/redistribute.h"
#include "zebra/interface.h"
#include "zebra/connected.h"
extern struct zebra_t zebrad;
/* withdraw a connected address */
static void
connected_withdraw (struct connected *ifc)
{
if (! ifc)
return;
/* Update interface address information to protocol daemon. */
if (CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
{
zebra_interface_address_delete_update (ifc->ifp, ifc);
if (ifc->address->family == AF_INET)
if_subnet_delete (ifc->ifp, ifc);
if (ifc->address->family == AF_INET)
connected_down_ipv4 (ifc->ifp, ifc);
#ifdef HAVE_IPV6
else
connected_down_ipv6 (ifc->ifp, ifc);
#endif
UNSET_FLAG (ifc->conf, ZEBRA_IFC_REAL);
}
/* The address is not in the kernel anymore, so clear the flag */
UNSET_FLAG(ifc->conf, ZEBRA_IFC_QUEUED);
if (!CHECK_FLAG (ifc->conf, ZEBRA_IFC_CONFIGURED))
{
listnode_delete (ifc->ifp->connected, ifc);
connected_free (ifc);
}
}
static void
connected_announce (struct interface *ifp, struct connected *ifc)
{
if (!ifc)
return;
listnode_add (ifp->connected, ifc);
/* Update interface address information to protocol daemon. */
if (! CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
{
if (ifc->address->family == AF_INET)
if_subnet_add (ifp, ifc);
SET_FLAG (ifc->conf, ZEBRA_IFC_REAL);
zebra_interface_address_add_update (ifp, ifc);
if (if_is_operative(ifp))
{
if (ifc->address->family == AF_INET)
connected_up_ipv4 (ifp, ifc);
#ifdef HAVE_IPV6
else
connected_up_ipv6 (ifp, ifc);
#endif
}
}
}
/* If same interface address is already exist... */
struct connected *
connected_check (struct interface *ifp, struct prefix *p)
{
struct connected *ifc;
struct listnode *node;
for (ALL_LIST_ELEMENTS_RO (ifp->connected, node, ifc))
if (prefix_same (ifc->address, p))
return ifc;
return NULL;
}
/* Check if two ifc's describe the same address */
static int
connected_same (struct connected *ifc1, struct connected *ifc2)
{
if (ifc1->ifp != ifc2->ifp)
return 0;
if (ifc1->destination)
if (!ifc2->destination)
return 0;
if (ifc2->destination)
if (!ifc1->destination)
return 0;
if (ifc1->destination && ifc2->destination)
if (!prefix_same (ifc1->destination, ifc2->destination))
return 0;
if (ifc1->flags != ifc2->flags)
return 0;
return 1;
}
/* Handle changes to addresses and send the neccesary announcements
* to clients. */
static void
connected_update(struct interface *ifp, struct connected *ifc)
{
struct connected *current;
/* Check same connected route. */
if ((current = connected_check (ifp, (struct prefix *) ifc->address)))
{
if (CHECK_FLAG(current->conf, ZEBRA_IFC_CONFIGURED))
SET_FLAG(ifc->conf, ZEBRA_IFC_CONFIGURED);
/* Avoid spurious withdraws, this might be just the kernel 'reflecting'
* back an address we have already added.
*/
if (connected_same (current, ifc) && CHECK_FLAG(current->conf, ZEBRA_IFC_REAL))
{
/* nothing to do */
connected_free (ifc);
return;
}
/* Clear the configured flag on the old ifc, so it will be freed by
* connected withdraw. */
UNSET_FLAG(current->conf, ZEBRA_IFC_CONFIGURED);
connected_withdraw (current); /* implicit withdraw - freebsd does this */
}
/* If the connected is new or has changed, announce it */
connected_announce(ifp, ifc);
}
/* Called from if_up(). */
void
connected_up_ipv4 (struct interface *ifp, struct connected *ifc)
{
struct prefix_ipv4 p;
if (! CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
return;
PREFIX_COPY_IPV4(&p, CONNECTED_PREFIX(ifc));
/* Apply mask to the network. */
apply_mask_ipv4 (&p);
/* In case of connected address is 0.0.0.0/0 we treat it tunnel
address. */
if (prefix_ipv4_any (&p))
return;
rib_add_ipv4 (ZEBRA_ROUTE_CONNECT, 0, &p, NULL, NULL, ifp->ifindex,
RT_TABLE_MAIN, ifp->metric, 0, SAFI_UNICAST);
rib_add_ipv4 (ZEBRA_ROUTE_CONNECT, 0, &p, NULL, NULL, ifp->ifindex,
RT_TABLE_MAIN, ifp->metric, 0, SAFI_MULTICAST);
rib_update ();
}
/* Add connected IPv4 route to the interface. */
void
connected_add_ipv4 (struct interface *ifp, int flags, struct in_addr *addr,
u_char prefixlen, struct in_addr *broad,
const char *label)
{
struct prefix_ipv4 *p;
struct connected *ifc;
/* Make connected structure. */
ifc = connected_new ();
ifc->ifp = ifp;
ifc->flags = flags;
/* If we get a notification from the kernel,
* we can safely assume the address is known to the kernel */
SET_FLAG(ifc->conf, ZEBRA_IFC_QUEUED);
/* Allocate new connected address. */
p = prefix_ipv4_new ();
p->family = AF_INET;
p->prefix = *addr;
p->prefixlen = prefixlen;
ifc->address = (struct prefix *) p;
/* If there is broadcast or peer address. */
if (broad)
{
p = prefix_ipv4_new ();
p->family = AF_INET;
p->prefix = *broad;
p->prefixlen = prefixlen;
ifc->destination = (struct prefix *) p;
/* validate the destination address */
if (CONNECTED_PEER(ifc))
{
if (IPV4_ADDR_SAME(addr,broad))
zlog_warn("warning: interface %s has same local and peer "
"address %s, routing protocols may malfunction",
ifp->name,inet_ntoa(*addr));
}
else
{
if (broad->s_addr != ipv4_broadcast_addr(addr->s_addr,prefixlen))
{
char buf[2][INET_ADDRSTRLEN];
struct in_addr bcalc;
bcalc.s_addr = ipv4_broadcast_addr(addr->s_addr,prefixlen);
zlog_warn("warning: interface %s broadcast addr %s/%d != "
"calculated %s, routing protocols may malfunction",
ifp->name,
inet_ntop (AF_INET, broad, buf[0], sizeof(buf[0])),
prefixlen,
inet_ntop (AF_INET, &bcalc, buf[1], sizeof(buf[1])));
}
}
}
else
{
if (CHECK_FLAG(ifc->flags, ZEBRA_IFA_PEER))
{
zlog_warn("warning: %s called for interface %s "
"with peer flag set, but no peer address supplied",
__func__, ifp->name);
UNSET_FLAG(ifc->flags, ZEBRA_IFA_PEER);
}
/* no broadcast or destination address was supplied */
if ((prefixlen == IPV4_MAX_PREFIXLEN) && if_is_pointopoint(ifp))
zlog_warn("warning: PtP interface %s with addr %s/%d needs a "
"peer address",ifp->name,inet_ntoa(*addr),prefixlen);
}
/* Label of this address. */
if (label)
ifc->label = XSTRDUP (MTYPE_CONNECTED_LABEL, label);
connected_update(ifp, ifc);
}
void
connected_down_ipv4 (struct interface *ifp, struct connected *ifc)
{
struct prefix_ipv4 p;
if (! CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
return;
PREFIX_COPY_IPV4(&p, CONNECTED_PREFIX(ifc));
/* Apply mask to the network. */
apply_mask_ipv4 (&p);
/* In case of connected address is 0.0.0.0/0 we treat it tunnel
address. */
if (prefix_ipv4_any (&p))
return;
/* Same logic as for connected_up_ipv4(): push the changes into the head. */
rib_delete_ipv4 (ZEBRA_ROUTE_CONNECT, 0, &p, NULL, ifp->ifindex, 0, SAFI_UNICAST);
rib_delete_ipv4 (ZEBRA_ROUTE_CONNECT, 0, &p, NULL, ifp->ifindex, 0, SAFI_MULTICAST);
rib_update ();
}
/* Delete connected IPv4 route to the interface. */
void
connected_delete_ipv4 (struct interface *ifp, int flags, struct in_addr *addr,
u_char prefixlen, struct in_addr *broad)
{
struct prefix_ipv4 p;
struct connected *ifc;
memset (&p, 0, sizeof (struct prefix_ipv4));
p.family = AF_INET;
p.prefix = *addr;
p.prefixlen = prefixlen;
ifc = connected_check (ifp, (struct prefix *) &p);
if (! ifc)
return;
connected_withdraw (ifc);
rib_update();
}
#ifdef HAVE_IPV6
void
connected_up_ipv6 (struct interface *ifp, struct connected *ifc)
{
struct prefix_ipv6 p;
if (! CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
return;
PREFIX_COPY_IPV6(&p, CONNECTED_PREFIX(ifc));
/* Apply mask to the network. */
apply_mask_ipv6 (&p);
#if ! defined (MUSICA) && ! defined (LINUX)
/* XXX: It is already done by rib_bogus_ipv6 within rib_add_ipv6 */
if (IN6_IS_ADDR_UNSPECIFIED (&p.prefix))
return;
#endif
rib_add_ipv6 (ZEBRA_ROUTE_CONNECT, 0, &p, NULL, ifp->ifindex, RT_TABLE_MAIN,
ifp->metric, 0, SAFI_UNICAST);
rib_update ();
}
/* Add connected IPv6 route to the interface. */
void
connected_add_ipv6 (struct interface *ifp, int flags, struct in6_addr *addr,
u_char prefixlen, struct in6_addr *broad,
const char *label)
{
struct prefix_ipv6 *p;
struct connected *ifc;
/* Make connected structure. */
ifc = connected_new ();
ifc->ifp = ifp;
ifc->flags = flags;
/* If we get a notification from the kernel,
* we can safely assume the address is known to the kernel */
SET_FLAG(ifc->conf, ZEBRA_IFC_QUEUED);
/* Allocate new connected address. */
p = prefix_ipv6_new ();
p->family = AF_INET6;
IPV6_ADDR_COPY (&p->prefix, addr);
p->prefixlen = prefixlen;
ifc->address = (struct prefix *) p;
/* If there is broadcast or peer address. */
if (broad)
{
if (IN6_IS_ADDR_UNSPECIFIED(broad))
zlog_warn("warning: %s called for interface %s with unspecified "
"destination address; ignoring!", __func__, ifp->name);
else
{
p = prefix_ipv6_new ();
p->family = AF_INET6;
IPV6_ADDR_COPY (&p->prefix, broad);
p->prefixlen = prefixlen;
ifc->destination = (struct prefix *) p;
}
}
if (CHECK_FLAG(ifc->flags, ZEBRA_IFA_PEER) && !ifc->destination)
{
zlog_warn("warning: %s called for interface %s "
"with peer flag set, but no peer address supplied",
__func__, ifp->name);
UNSET_FLAG(ifc->flags, ZEBRA_IFA_PEER);
}
/* Label of this address. */
if (label)
ifc->label = XSTRDUP (MTYPE_CONNECTED_LABEL, label);
connected_update(ifp, ifc);
}
void
connected_down_ipv6 (struct interface *ifp, struct connected *ifc)
{
struct prefix_ipv6 p;
if (! CHECK_FLAG (ifc->conf, ZEBRA_IFC_REAL))
return;
PREFIX_COPY_IPV6(&p, CONNECTED_PREFIX(ifc));
apply_mask_ipv6 (&p);
if (IN6_IS_ADDR_UNSPECIFIED (&p.prefix))
return;
rib_delete_ipv6 (ZEBRA_ROUTE_CONNECT, 0, &p, NULL, ifp->ifindex, 0, SAFI_UNICAST);
rib_update ();
}
void
connected_delete_ipv6 (struct interface *ifp, struct in6_addr *address,
u_char prefixlen, struct in6_addr *broad)
{
struct prefix_ipv6 p;
struct connected *ifc;
memset (&p, 0, sizeof (struct prefix_ipv6));
p.family = AF_INET6;
memcpy (&p.prefix, address, sizeof (struct in6_addr));
p.prefixlen = prefixlen;
ifc = connected_check (ifp, (struct prefix *) &p);
if (! ifc)
return;
connected_withdraw (ifc);
rib_update();
}
#endif /* HAVE_IPV6 */