/* 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);
/* For all that I know an IPv4 address is always ready when we receive
* the notification. So it should be safe to set the REAL flag here. */
SET_FLAG(ifc->conf, ZEBRA_IFC_REAL);
connected_update(ifp, ifc);
}
/* XXX I don`t know if I need to check does interface exist? */
void *
route_match_interface_compile (char *arg)
{
return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
}
static void *
route_match_ip_next_hop_prefix_list_compile (const char *arg)
{
return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
}
/* Route map `ip address' match statement. `arg' should be
access-list name. */
static void *
route_match_ip_address_compile (const char *arg)
{
return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
}
void
config_add_line (struct list *config, char *line)
{
listnode_add (config, XSTRDUP (MTYPE_VTYSH_CONFIG_LINE, line));
}
static void *route_match_ipv6_address_prefix_list_compile(const s8 *arg)
{
return XSTRDUP(MTYPE_ROUTE_MAP_COMPILED, arg);
}
static void
break_depends(Plisthead *impacthead)
{
Pkglist *rmimpact, *pimpact;
Plisthead *rdphead, *fdphead;
Pkglist *rdp, *fdp;
char *pkgname, *rpkg;
int dep_break, exists;
SLIST_FOREACH(pimpact, impacthead, next) {
if (pimpact->old == NULL) /* DONOTHING or TOINSTALL */
continue;
rdphead = init_head();
XSTRDUP(pkgname, pimpact->old);
trunc_str(pkgname, '-', STR_BACKWARD);
/* fetch old package reverse dependencies */
full_dep_tree(pkgname, LOCAL_REVERSE_DEPS, rdphead);
XFREE(pkgname);
/* browse reverse dependencies */
SLIST_FOREACH(rdp, rdphead, next) {
exists = 0;
/* check if rdp was already on impact list */
SLIST_FOREACH(rmimpact, impacthead, next)
if (strcmp(rmimpact->depend, rdp->depend) == 0) {
exists = 1;
break;
}
if (exists)
continue;
fdphead = init_head();
/*
* reverse dependency is a full package name,
* use it and strip it
*/
XSTRDUP(rpkg, rdp->depend);
trunc_str(rpkg, '-', STR_BACKWARD);
/* fetch dependencies for rdp */
full_dep_tree(rpkg, DIRECT_DEPS, fdphead);
/* initialize to broken dependency */
dep_break = 1;
/* empty full dep tree, this can't happen in normal situation.
* If it does, that means that the reverse dependency we're
* analyzing has no direct dependency.
* Such a situation could occur if the reverse dependency is not on
* the repository anymore, leading to no information regarding this
* package.
* So we will check if local package dependencies are satisfied by
* our newly upgraded packages.
*/
if (SLIST_EMPTY(fdphead)) {
free_pkglist(&fdphead, DEPTREE);
fdphead = init_head();
full_dep_tree(rpkg, LOCAL_DIRECT_DEPS, fdphead);
}
XFREE(rpkg);
/*
* browse dependencies for rdp and see if
* new package to be installed matches
*/
SLIST_FOREACH(fdp, fdphead, next) {
if (pkg_match(fdp->depend, pimpact->full)) {
dep_break = 0;
break;
}
}
free_pkglist(&fdphead, DEPTREE);
if (!dep_break)
continue;
/* dependency break, insert rdp in remove-list */
rmimpact = malloc_pkglist(IMPACT);
XSTRDUP(rmimpact->depend, rdp->depend);
XSTRDUP(rmimpact->full, rdp->depend);
XSTRDUP(rmimpact->old, rdp->depend);
rmimpact->action = TOREMOVE;
rmimpact->level = 0;
SLIST_INSERT_HEAD(impacthead, rmimpact, next);
}
free_pkglist(&rdphead, DEPTREE);
}
/*
* Called from interface_lookup_netlink(). This function is only used
* during bootstrap.
*/
static int netlink_interface(struct nlmsghdr *h, ns_id_t ns_id, int startup)
{
int len;
struct ifinfomsg *ifi;
struct rtattr *tb[IFLA_MAX + 1];
struct rtattr *linkinfo[IFLA_MAX + 1];
struct interface *ifp;
char *name = NULL;
char *kind = NULL;
char *desc = NULL;
char *slave_kind = NULL;
struct zebra_ns *zns;
vrf_id_t vrf_id = VRF_DEFAULT;
zebra_iftype_t zif_type = ZEBRA_IF_OTHER;
zebra_slave_iftype_t zif_slave_type = ZEBRA_IF_SLAVE_NONE;
ifindex_t bridge_ifindex = IFINDEX_INTERNAL;
ifindex_t link_ifindex = IFINDEX_INTERNAL;
zns = zebra_ns_lookup(ns_id);
ifi = NLMSG_DATA(h);
if (h->nlmsg_type != RTM_NEWLINK)
return 0;
len = h->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifinfomsg));
if (len < 0) {
zlog_err("%s: Message received from netlink is of a broken size: %d %zu",
__PRETTY_FUNCTION__,
h->nlmsg_len,
(size_t)NLMSG_LENGTH(sizeof(struct ifinfomsg)));
return -1;
}
/* We are interested in some AF_BRIDGE notifications. */
if (ifi->ifi_family == AF_BRIDGE)
return netlink_bridge_interface(h, len, ns_id, startup);
/* Looking up interface name. */
memset(tb, 0, sizeof tb);
memset(linkinfo, 0, sizeof linkinfo);
netlink_parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), len);
/* check for wireless messages to ignore */
if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0)) {
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug("%s: ignoring IFLA_WIRELESS message",
__func__);
return 0;
}
if (tb[IFLA_IFNAME] == NULL)
return -1;
name = (char *)RTA_DATA(tb[IFLA_IFNAME]);
if (tb[IFLA_IFALIAS])
desc = (char *)RTA_DATA(tb[IFLA_IFALIAS]);
if (tb[IFLA_LINKINFO]) {
parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb[IFLA_LINKINFO]);
if (linkinfo[IFLA_INFO_KIND])
kind = RTA_DATA(linkinfo[IFLA_INFO_KIND]);
if (linkinfo[IFLA_INFO_SLAVE_KIND])
slave_kind = RTA_DATA(linkinfo[IFLA_INFO_SLAVE_KIND]);
netlink_determine_zebra_iftype(kind, &zif_type);
}
/* If VRF, create the VRF structure itself. */
if (zif_type == ZEBRA_IF_VRF && !vrf_is_backend_netns()) {
netlink_vrf_change(h, tb[IFLA_LINKINFO], name);
vrf_id = (vrf_id_t)ifi->ifi_index;
}
if (tb[IFLA_MASTER]) {
if (slave_kind && (strcmp(slave_kind, "vrf") == 0)
&& !vrf_is_backend_netns()) {
zif_slave_type = ZEBRA_IF_SLAVE_VRF;
vrf_id = *(uint32_t *)RTA_DATA(tb[IFLA_MASTER]);
} else if (slave_kind && (strcmp(slave_kind, "bridge") == 0)) {
zif_slave_type = ZEBRA_IF_SLAVE_BRIDGE;
bridge_ifindex =
*(ifindex_t *)RTA_DATA(tb[IFLA_MASTER]);
} else
zif_slave_type = ZEBRA_IF_SLAVE_OTHER;
}
if (vrf_is_backend_netns())
vrf_id = (vrf_id_t)ns_id;
/* If linking to another interface, note it. */
if (tb[IFLA_LINK])
link_ifindex = *(ifindex_t *)RTA_DATA(tb[IFLA_LINK]);
/* Add interface. */
ifp = if_get_by_name(name, vrf_id, 0);
set_ifindex(ifp, ifi->ifi_index, zns);
ifp->flags = ifi->ifi_flags & 0x0000fffff;
ifp->mtu6 = ifp->mtu = *(uint32_t *)RTA_DATA(tb[IFLA_MTU]);
ifp->metric = 0;
ifp->speed = get_iflink_speed(ifp);
ifp->ptm_status = ZEBRA_PTM_STATUS_UNKNOWN;
if (desc)
ifp->desc = XSTRDUP(MTYPE_TMP, desc);
/* Set zebra interface type */
zebra_if_set_ziftype(ifp, zif_type, zif_slave_type);
if (IS_ZEBRA_IF_VRF(ifp))
SET_FLAG(ifp->status, ZEBRA_INTERFACE_VRF_LOOPBACK);
/* Update link. */
zebra_if_update_link(ifp, link_ifindex);
/* Hardware type and address. */
ifp->ll_type = netlink_to_zebra_link_type(ifi->ifi_type);
netlink_interface_update_hw_addr(tb, ifp);
if_add_update(ifp);
/* Extract and save L2 interface information, take additional actions.
*/
netlink_interface_update_l2info(ifp, linkinfo[IFLA_INFO_DATA], 1);
if (IS_ZEBRA_IF_BRIDGE_SLAVE(ifp))
zebra_l2if_update_bridge_slave(ifp, bridge_ifindex);
return 0;
}
static int
_pam_get_password(pam_handle_t *pamh, char **password, const char *prompt)
{
char *item, *token;
int retval;
struct pam_message msg[3], *pmsg[3];
struct pam_response *resp;
int i, replies;
DEBUG(90,("enter _pam_get_password"));
if (cntl_flags & CNTL_AUTHTOK) {
/*
* get the password from the PAM item
*/
retval = pam_get_item(pamh, PAM_AUTHTOK,
(const void **) &item);
if (retval != PAM_SUCCESS) {
/* very strange. */
_pam_log(LOG_ALERT,
"can't retrieve password item: %s",
pam_strerror(pamh, retval));
return retval;
} else if (item != NULL) {
*password = item;
item = NULL;
return PAM_SUCCESS;
} else
return PAM_AUTHTOK_RECOVER_ERR;
}
/*
* ask user for the password
*/
/* prepare to converse */
i = 0;
pmsg[i] = &msg[i];
msg[i].msg_style = PAM_PROMPT_ECHO_OFF;
msg[i++].msg = (const void*)prompt;
replies = 1;
/* run conversation */
resp = NULL;
token = NULL;
retval = gray_converse(pamh, i, pmsg, &resp);
if (resp != NULL && resp[i - replies].resp) {
if (retval == PAM_SUCCESS) { /* a good conversation */
token = XSTRDUP(resp[i - replies].resp);
DEBUG(100,("app returned [%s]", token));
pam_set_item(pamh, PAM_AUTHTOK, token);
PAM_DROP_REPLY(resp, 1);
} else {
_pam_log(LOG_ERR, "conversation error: %s",
pam_strerror(pamh, retval));
}
} else {
retval = (retval == PAM_SUCCESS)
? PAM_AUTHTOK_RECOVER_ERR : retval;
}
if (retval == PAM_SUCCESS) {
/*
* keep password as data specific to this module. pam_end()
* will arrange to clean it up.
*/
retval = pam_set_data(pamh, "password",
(void *)token,
gray_cleanup_string);
if (retval != PAM_SUCCESS) {
_pam_log(LOG_CRIT,
"can't keep password: %s",
pam_strerror(pamh, retval));
gray_pam_delete(token);
} else {
*password = token;
token = NULL; /* break link to password */
}
} else {
_pam_log(LOG_ERR,
"unable to obtain a password: %s",
pam_strerror(pamh, retval));
}
DEBUG(90,("exit _pam_get_password: %d", retval));
return retval;
}
/* Accept bgp connection. */
static int
bgp_accept (struct thread *thread)
{
int bgp_sock;
int accept_sock;
union sockunion su;
struct bgp_listener *listener = THREAD_ARG(thread);
struct peer *peer;
struct peer *peer1;
char buf[SU_ADDRSTRLEN];
/* Register accept thread. */
accept_sock = THREAD_FD (thread);
if (accept_sock < 0)
{
zlog_err ("accept_sock is nevative value %d", accept_sock);
return -1;
}
listener->thread = thread_add_read (master, bgp_accept, listener, accept_sock);
/* Accept client connection. */
bgp_sock = sockunion_accept (accept_sock, &su);
if (bgp_sock < 0)
{
zlog_err ("[Error] BGP socket accept failed (%s)", safe_strerror (errno));
return -1;
}
set_nonblocking (bgp_sock);
if (BGP_DEBUG (events, EVENTS))
zlog_debug ("[Event] BGP connection from host %s", inet_sutop (&su, buf));
/* Check remote IP address */
peer1 = peer_lookup (NULL, &su);
if (! peer1 || peer1->status == Idle)
{
if (BGP_DEBUG (events, EVENTS))
{
if (! peer1)
zlog_debug ("[Event] BGP connection IP address %s is not configured",
inet_sutop (&su, buf));
else
zlog_debug ("[Event] BGP connection IP address %s is Idle state",
inet_sutop (&su, buf));
}
close (bgp_sock);
return -1;
}
/* In case of peer is EBGP, we should set TTL for this connection. */
if (peer1->sort == BGP_PEER_EBGP) {
sockopt_ttl (peer1->su.sa.sa_family, bgp_sock, peer1->ttl);
if (peer1->gtsm_hops)
sockopt_minttl (peer1->su.sa.sa_family, bgp_sock, MAXTTL + 1 - peer1->gtsm_hops);
}
/* Make dummy peer until read Open packet. */
if (BGP_DEBUG (events, EVENTS))
zlog_debug ("[Event] Make dummy peer structure until read Open packet");
{
char buf[SU_ADDRSTRLEN];
peer = peer_create_accept (peer1->bgp);
SET_FLAG (peer->sflags, PEER_STATUS_ACCEPT_PEER);
peer->su = su;
peer->fd = bgp_sock;
peer->status = Active;
peer->local_id = peer1->local_id;
peer->v_holdtime = peer1->v_holdtime;
peer->v_keepalive = peer1->v_keepalive;
/* Make peer's address string. */
sockunion2str (&su, buf, SU_ADDRSTRLEN);
peer->host = XSTRDUP (MTYPE_BGP_PEER_HOST, buf);
}
BGP_EVENT_ADD (peer, TCP_connection_open);
return 0;
}
/* 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;
/* 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 pointopoint address. */
if (broad)
{
p = prefix_ipv4_new ();
p->family = AF_INET;
p->prefix = *broad;
ifc->destination = (struct prefix *) p;
/* validate the destination address */
if (ifp->flags & IFF_POINTOPOINT)
{
if (IPV4_ADDR_SAME(addr,broad))
zlog_warn("warning: PtP interface %s has same local and peer "
"address %s, routing protocols may malfunction",
ifp->name,inet_ntoa(*addr));
else if ((prefixlen != IPV4_MAX_PREFIXLEN) &&
(ipv4_network_addr(addr->s_addr,prefixlen) !=
ipv4_network_addr(broad->s_addr,prefixlen)))
{
char buf[2][INET_ADDRSTRLEN];
zlog_warn("warning: PtP interface %s network mismatch: local "
"%s/%d vs. peer %s, routing protocols may malfunction",
ifp->name,
inet_ntop (AF_INET, addr, buf[0], sizeof(buf[0])),
prefixlen,
inet_ntop (AF_INET, broad, buf[1], sizeof(buf[1])));
}
}
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])));
}
/*gjd : for Rtsuit restart , ip address write show running.*/
if(!CHECK_FLAG(ifc->ip_config,RTMD_RESTART_IP_CONFIG)&&(keep_kernel_mode == 1))
{
SET_FLAG(ifc->ip_config,RTMD_RESTART_IP_CONFIG);
/*zlog_err("%s : line %d ifc->conf(%u), ifc->ipconfig(%u).\n",
__func__,__LINE__,ifc->conf,ifc->ip_config);*/
}
}
}
else
/* 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);
/* nothing to do? */
if ((ifc = connected_implicit_withdraw (ifp, ifc)) == NULL)
return;
connected_announce (ifp, ifc);
}
zt_table *
zt_table_init(char *name, zt_table_hash_func_cb func,
zt_table_compare_cb cmp, size_t hint, int flags,
void *cdata)
{
zt_table * table;
size_t nbuckets = 0;
char tname[1024];
zt_mem_pool * table_mem_pool;
if ( (func == NULL) ||
(cmp == NULL)) {
return NULL;
}
table_mem_pool = zt_mem_pool_get(ZT_DEFAULT_TABLE_POOL);
if (table_mem_pool == NULL) {
table_mem_pool = table_pool_init(2);
}
if ( (table = (zt_table *)zt_mem_pool_alloc(table_mem_pool)) == NULL) {
return NULL;
}
table->flags = flags;
table->cdata = cdata;
if (flags & ZT_TABLE_SIZE_USE_HINT) {
nbuckets = hint;
} else {
int i = 0;
int len = sizeof_array(powers_of_2);
for (i = 0; i < len; i++) {
if (powers_of_2[i] > hint) {
nbuckets = powers_of_2[i];
break;
}
}
}
table->nbits = nbits(nbuckets - 1);
table->table_heap = zt_mem_heap_init(0, nbuckets * sizeof(struct table_node *));
table->buckets = zt_mem_heap_get_data(table->table_heap);
memset(table->buckets, 0, nbuckets * sizeof(struct table_node *));
if (name) {
table->name = XSTRDUP(name);
} else {
table->name = XSTRDUP("anonymous");
}
snprintf(tname, sizeof_array(tname), "%s (table node pool)", name);
table->node_pool = zt_mem_pool_init(tname, nbuckets,
sizeof(struct table_node), NULL, NULL, 0);
table->num_buckets = nbuckets;
table->cmp = cmp;
table->func = func;
return table;
} /* zt_table_init */
void mod_db_sql_init() {
char *str;
mod_db_sql_config.host = XSTRDUP("127.0.0.1", "mod_db_sql_init");
mod_db_sql_config.db = XSTRDUP("netmush", "mod_db_sql_init");
mod_db_sql_config.username = XSTRDUP("netmush", "mod_db_sql_init");
mod_db_sql_config.password = XSTRDUP("netmush", "mod_db_sql_init");
mod_db_sql_config.reconnect = 1;
mod_db_sql_config.port = 3306;
str = XMALLOC(MBUF_SIZE, "mod_db_sql_init");
snprintf(str, MBUF_SIZE, "version %d.%d", mudstate.version.major, mudstate.version.minor);
switch(mudstate.version.status){
case 0:
snprintf(str, MBUF_SIZE, "%s, Alpha %d", str, mudstate.version.revision);
break;
case 1:
snprintf(str, MBUF_SIZE, "%s, Beta %d", str, mudstate.version.revision);
break;
case 2:
snprintf(str, MBUF_SIZE, "%s, Release Candidate %d", str, mudstate.version.revision);
break;
default:
if(mudstate.version.revision > 0) {
snprintf(str, MBUF_SIZE, "%s, Patch Level %d", str, mudstate.version.revision);
} else {
snprintf(str, MBUF_SIZE, "%s, Gold Release.", str);
}
}
#ifdef SQL_DRIVER
snprintf(str, MBUF_SIZE, "%s (%s) using %s driver", str , PACKAGE_RELEASE_DATE, SQL_DRIVER);
mod_db_sql_version.version=XSTRDUP( str , "mod_db_sql_init");
#else
snprintf(str, MBUF_SIZE, "%s (%s) using placeholder driver", str , PACKAGE_RELEASE_DATE);
mod_db_sql_version.version=XSTRDUP(str, "mod_db_sql_init");
#endif
mod_db_sql_version.author=XSTRDUP("TinyMUSH Development Team", "mod_db_sql_init");
mod_db_sql_version.email=XSTRDUP("*****@*****.**", "mod_db_sql_init");
mod_db_sql_version.url=XSTRDUP("http://sourceforge.net/projects/tinymush/", "mod_db_sql_init");
mod_db_sql_version.description=XSTRDUP("SQL Database interface for TinyMUSH", "mod_db_sql_init");
mod_db_sql_version.copyright=XSTRDUP("Copyright (C) 2012 TinyMUSH development team.", "mod_db_sql_init");
XFREE(str, "mod_db_sql_init");
register_commands(mod_db_sql_cmdtable);
register_functions(mod_db_sql_functable);
}
/* Route map `ip next-hop' match statement. `arg' should be
access-list name. */
void *
route_match_ip_next_hop_compile (char *arg)
{
return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
}
/* 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;
/* 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);
/* nothing to do? */
if ((ifc = connected_implicit_withdraw (ifp, ifc)) == NULL)
return;
connected_announce (ifp, ifc);
}
void *
route_match_ip_address_prefix_list_compile (char *arg)
{
return XSTRDUP (MTYPE_ROUTE_MAP_COMPILED, arg);
}
int netlink_link_change(struct nlmsghdr *h, ns_id_t ns_id, int startup)
{
int len;
struct ifinfomsg *ifi;
struct rtattr *tb[IFLA_MAX + 1];
struct rtattr *linkinfo[IFLA_MAX + 1];
struct interface *ifp;
char *name = NULL;
char *kind = NULL;
char *desc = NULL;
char *slave_kind = NULL;
struct zebra_ns *zns;
vrf_id_t vrf_id = VRF_DEFAULT;
zebra_iftype_t zif_type = ZEBRA_IF_OTHER;
zebra_slave_iftype_t zif_slave_type = ZEBRA_IF_SLAVE_NONE;
ifindex_t bridge_ifindex = IFINDEX_INTERNAL;
ifindex_t link_ifindex = IFINDEX_INTERNAL;
zns = zebra_ns_lookup(ns_id);
ifi = NLMSG_DATA(h);
/* assume if not default zns, then new VRF */
if (!(h->nlmsg_type == RTM_NEWLINK || h->nlmsg_type == RTM_DELLINK)) {
/* If this is not link add/delete message so print warning. */
zlog_warn("netlink_link_change: wrong kernel message %d",
h->nlmsg_type);
return 0;
}
if (!(ifi->ifi_family == AF_UNSPEC || ifi->ifi_family == AF_BRIDGE
|| ifi->ifi_family == AF_INET6)) {
zlog_warn(
"Invalid address family: %u received from kernel link change: %u",
ifi->ifi_family, h->nlmsg_type);
return 0;
}
len = h->nlmsg_len - NLMSG_LENGTH(sizeof(struct ifinfomsg));
if (len < 0) {
zlog_err("%s: Message received from netlink is of a broken size %d %zu",
__PRETTY_FUNCTION__, h->nlmsg_len,
(size_t)NLMSG_LENGTH(sizeof(struct ifinfomsg)));
return -1;
}
/* We are interested in some AF_BRIDGE notifications. */
if (ifi->ifi_family == AF_BRIDGE)
return netlink_bridge_interface(h, len, ns_id, startup);
/* Looking up interface name. */
memset(tb, 0, sizeof tb);
memset(linkinfo, 0, sizeof linkinfo);
netlink_parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), len);
/* check for wireless messages to ignore */
if ((tb[IFLA_WIRELESS] != NULL) && (ifi->ifi_change == 0)) {
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug("%s: ignoring IFLA_WIRELESS message",
__func__);
return 0;
}
if (tb[IFLA_IFNAME] == NULL)
return -1;
name = (char *)RTA_DATA(tb[IFLA_IFNAME]);
if (tb[IFLA_LINKINFO]) {
parse_rtattr_nested(linkinfo, IFLA_INFO_MAX, tb[IFLA_LINKINFO]);
if (linkinfo[IFLA_INFO_KIND])
kind = RTA_DATA(linkinfo[IFLA_INFO_KIND]);
if (linkinfo[IFLA_INFO_SLAVE_KIND])
slave_kind = RTA_DATA(linkinfo[IFLA_INFO_SLAVE_KIND]);
netlink_determine_zebra_iftype(kind, &zif_type);
}
/* If linking to another interface, note it. */
if (tb[IFLA_LINK])
link_ifindex = *(ifindex_t *)RTA_DATA(tb[IFLA_LINK]);
if (tb[IFLA_IFALIAS]) {
desc = (char *)RTA_DATA(tb[IFLA_IFALIAS]);
}
/* If VRF, create or update the VRF structure itself. */
if (zif_type == ZEBRA_IF_VRF && !vrf_is_backend_netns()) {
netlink_vrf_change(h, tb[IFLA_LINKINFO], name);
vrf_id = (vrf_id_t)ifi->ifi_index;
}
/* See if interface is present. */
ifp = if_lookup_by_name_per_ns(zns, name);
if (ifp) {
if (ifp->desc)
XFREE(MTYPE_TMP, ifp->desc);
if (desc)
ifp->desc = XSTRDUP(MTYPE_TMP, desc);
}
if (h->nlmsg_type == RTM_NEWLINK) {
if (tb[IFLA_MASTER]) {
if (slave_kind && (strcmp(slave_kind, "vrf") == 0)
&& !vrf_is_backend_netns()) {
zif_slave_type = ZEBRA_IF_SLAVE_VRF;
vrf_id = *(uint32_t *)RTA_DATA(tb[IFLA_MASTER]);
} else if (slave_kind
&& (strcmp(slave_kind, "bridge") == 0)) {
zif_slave_type = ZEBRA_IF_SLAVE_BRIDGE;
bridge_ifindex =
*(ifindex_t *)RTA_DATA(tb[IFLA_MASTER]);
} else
zif_slave_type = ZEBRA_IF_SLAVE_OTHER;
}
if (vrf_is_backend_netns())
vrf_id = (vrf_id_t)ns_id;
if (ifp == NULL
|| !CHECK_FLAG(ifp->status, ZEBRA_INTERFACE_ACTIVE)) {
/* Add interface notification from kernel */
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug(
"RTM_NEWLINK ADD for %s(%u) vrf_id %u type %d "
"sl_type %d master %u flags 0x%x",
name, ifi->ifi_index, vrf_id, zif_type,
zif_slave_type, bridge_ifindex,
ifi->ifi_flags);
if (ifp == NULL) {
/* unknown interface */
ifp = if_get_by_name(name, vrf_id, 0);
} else {
/* pre-configured interface, learnt now */
if (ifp->vrf_id != vrf_id)
if_update_to_new_vrf(ifp, vrf_id);
}
/* Update interface information. */
set_ifindex(ifp, ifi->ifi_index, zns);
ifp->flags = ifi->ifi_flags & 0x0000fffff;
if (!tb[IFLA_MTU]) {
zlog_warn(
"RTM_NEWLINK for interface %s(%u) without MTU set",
name, ifi->ifi_index);
return 0;
}
ifp->mtu6 = ifp->mtu = *(int *)RTA_DATA(tb[IFLA_MTU]);
ifp->metric = 0;
ifp->ptm_status = ZEBRA_PTM_STATUS_UNKNOWN;
/* Set interface type */
zebra_if_set_ziftype(ifp, zif_type, zif_slave_type);
if (IS_ZEBRA_IF_VRF(ifp))
SET_FLAG(ifp->status,
ZEBRA_INTERFACE_VRF_LOOPBACK);
/* Update link. */
zebra_if_update_link(ifp, link_ifindex);
netlink_interface_update_hw_addr(tb, ifp);
/* Inform clients, install any configured addresses. */
if_add_update(ifp);
/* Extract and save L2 interface information, take
* additional actions. */
netlink_interface_update_l2info(
ifp, linkinfo[IFLA_INFO_DATA], 1);
if (IS_ZEBRA_IF_BRIDGE_SLAVE(ifp))
zebra_l2if_update_bridge_slave(ifp,
bridge_ifindex);
if_netlink_check_ifp_instance_consistency(RTM_NEWLINK,
ifp, ns_id);
} else if (ifp->vrf_id != vrf_id) {
/* VRF change for an interface. */
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug(
"RTM_NEWLINK vrf-change for %s(%u) "
"vrf_id %u -> %u flags 0x%x",
name, ifp->ifindex, ifp->vrf_id, vrf_id,
ifi->ifi_flags);
if_handle_vrf_change(ifp, vrf_id);
} else {
int was_bridge_slave;
/* Interface update. */
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug(
"RTM_NEWLINK update for %s(%u) "
"sl_type %d master %u flags 0x%x",
name, ifp->ifindex, zif_slave_type,
bridge_ifindex, ifi->ifi_flags);
set_ifindex(ifp, ifi->ifi_index, zns);
if (!tb[IFLA_MTU]) {
zlog_warn(
"RTM_NEWLINK for interface %s(%u) without MTU set",
name, ifi->ifi_index);
return 0;
}
ifp->mtu6 = ifp->mtu = *(int *)RTA_DATA(tb[IFLA_MTU]);
ifp->metric = 0;
/* Update interface type - NOTE: Only slave_type can
* change. */
was_bridge_slave = IS_ZEBRA_IF_BRIDGE_SLAVE(ifp);
zebra_if_set_ziftype(ifp, zif_type, zif_slave_type);
netlink_interface_update_hw_addr(tb, ifp);
if (if_is_no_ptm_operative(ifp)) {
ifp->flags = ifi->ifi_flags & 0x0000fffff;
if (!if_is_no_ptm_operative(ifp)) {
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug(
"Intf %s(%u) has gone DOWN",
name, ifp->ifindex);
if_down(ifp);
} else if (if_is_operative(ifp)) {
/* Must notify client daemons of new
* interface status. */
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug(
"Intf %s(%u) PTM up, notifying clients",
name, ifp->ifindex);
zebra_interface_up_update(ifp);
}
} else {
ifp->flags = ifi->ifi_flags & 0x0000fffff;
if (if_is_operative(ifp)) {
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug(
"Intf %s(%u) has come UP",
name, ifp->ifindex);
if_up(ifp);
}
}
/* Extract and save L2 interface information, take
* additional actions. */
netlink_interface_update_l2info(
ifp, linkinfo[IFLA_INFO_DATA], 0);
if (IS_ZEBRA_IF_BRIDGE_SLAVE(ifp) || was_bridge_slave)
zebra_l2if_update_bridge_slave(ifp,
bridge_ifindex);
if_netlink_check_ifp_instance_consistency(RTM_NEWLINK,
ifp, ns_id);
}
} else {
/* Delete interface notification from kernel */
if (ifp == NULL) {
zlog_warn("RTM_DELLINK for unknown interface %s(%u)",
name, ifi->ifi_index);
return 0;
}
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug("RTM_DELLINK for %s(%u)", name,
ifp->ifindex);
UNSET_FLAG(ifp->status, ZEBRA_INTERFACE_VRF_LOOPBACK);
/* Special handling for bridge or VxLAN interfaces. */
if (IS_ZEBRA_IF_BRIDGE(ifp))
zebra_l2_bridge_del(ifp);
else if (IS_ZEBRA_IF_VXLAN(ifp))
zebra_l2_vxlanif_del(ifp);
if (!IS_ZEBRA_IF_VRF(ifp))
if_delete_update(ifp);
if_netlink_check_ifp_instance_consistency(RTM_DELLINK,
ifp, ns_id);
}
return 0;
}
