if (!as->segments) {
if (make_json) {
json_object_string_add(as->json, "string", "Local");
- json_object_object_add(as->json, "segments", jaspath_segments);
+ json_object_object_add(as->json, "segments",
+ jaspath_segments);
json_object_int_add(as->json, "length", 0);
}
as->str = XMALLOC(MTYPE_AS_STR, 1);
/* write out the ASNs, with their seperators, bar the last one*/
for (i = 0; i < seg->length; i++) {
if (make_json)
- json_object_array_add(jseg_list,
- json_object_new_int(seg->as[i]));
+ json_object_array_add(
+ jseg_list,
+ json_object_new_int(seg->as[i]));
len += snprintf(str_buf + len, str_size - len, "%u",
seg->as[i]);
if (make_json) {
jseg = json_object_new_object();
- json_object_string_add(jseg, "type",
- aspath_segment_type_str[seg->type]);
+ json_object_string_add(
+ jseg, "type",
+ aspath_segment_type_str[seg->type]);
json_object_object_add(jseg, "list", jseg_list);
json_object_array_add(jaspath_segments, jseg);
}
assegment_data_put(s, seg->as, AS_SEGMENT_MAX,
use32bit);
written += AS_SEGMENT_MAX;
- bytes += ASSEGMENT_SIZE(AS_SEGMENT_MAX, use32bit);
+ bytes += ASSEGMENT_SIZE(AS_SEGMENT_MAX,
+ use32bit);
}
/* write the final segment, probably is also the first
/* AS path hash initialize. */
void aspath_init(void)
{
- ashash = hash_create_size(32768,
- aspath_key_make,
- aspath_cmp,
+ ashash = hash_create_size(32768, aspath_key_make, aspath_cmp,
"BGP AS Path");
}
{BGP_ATTR_PREFIX_SID, "PREFIX_SID"},
{0}};
-static const struct message attr_flag_str[] =
- {
- {BGP_ATTR_FLAG_OPTIONAL, "Optional"},
- {BGP_ATTR_FLAG_TRANS, "Transitive"},
- {BGP_ATTR_FLAG_PARTIAL, "Partial"},
- /* bgp_attr_flags_diagnose() relies on this bit being last in
- this list */
- {BGP_ATTR_FLAG_EXTLEN, "Extended Length"},
- {0}};
+static const struct message attr_flag_str[] = {
+ {BGP_ATTR_FLAG_OPTIONAL, "Optional"},
+ {BGP_ATTR_FLAG_TRANS, "Transitive"},
+ {BGP_ATTR_FLAG_PARTIAL, "Partial"},
+ /* bgp_attr_flags_diagnose() relies on this bit being last in
+ this list */
+ {BGP_ATTR_FLAG_EXTLEN, "Extended Length"},
+ {0}};
static struct hash *cluster_hash;
static void cluster_init(void)
{
- cluster_hash = hash_create(cluster_hash_key_make,
- cluster_hash_cmp,
+ cluster_hash = hash_create(cluster_hash_key_make, cluster_hash_cmp,
"BGP Cluster");
}
static void encap_init(void)
{
- encap_hash = hash_create(encap_hash_key_make,
- encap_hash_cmp,
+ encap_hash = hash_create(encap_hash_key_make, encap_hash_cmp,
"BGP Encap Hash");
#if ENABLE_BGP_VNC
- vnc_hash = hash_create(encap_hash_key_make,
- encap_hash_cmp,
+ vnc_hash = hash_create(encap_hash_key_make, encap_hash_cmp,
"BGP VNC Hash");
#endif
}
static void transit_init(void)
{
- transit_hash = hash_create(transit_hash_key_make,
- transit_hash_cmp,
+ transit_hash = hash_create(transit_hash_key_make, transit_hash_cmp,
"BGP Transit Hash");
}
#define MIX3(a, b, c) key = jhash_3words((a), (b), (c), key)
MIX3(attr->origin, attr->nexthop.s_addr, attr->med);
- MIX3(attr->local_pref, attr->aggregator_as, attr->aggregator_addr.s_addr);
+ MIX3(attr->local_pref, attr->aggregator_as,
+ attr->aggregator_addr.s_addr);
MIX3(attr->weight, attr->mp_nexthop_global_in.s_addr,
attr->originator_id.s_addr);
MIX3(attr->tag, attr->label, attr->label_index);
static void attrhash_init(void)
{
- attrhash = hash_create(attrhash_key_make,
- attrhash_cmp,
- "BGP Attributes");
+ attrhash =
+ hash_create(attrhash_key_make, attrhash_cmp, "BGP Attributes");
}
/*
/* If we are not shutting down ourselves and we are
* aggregating a route that contains the GSHUT community we
* need to remove that community when creating the aggregate */
- if (!bgp_flag_check(bgp, BGP_FLAG_GRACEFUL_SHUTDOWN) &&
- community_include(community, gshut)) {
+ if (!bgp_flag_check(bgp, BGP_FLAG_GRACEFUL_SHUTDOWN)
+ && community_include(community, gshut)) {
community_del_val(community, &gshut);
}
if (new->lcommunity != old->lcommunity)
lcommunity_free(&new->lcommunity);
-
}
/* Free bgp attribute and aspath. */
case BGP_ATTR_NHLEN_VPNV4:
stream_getl(s); /* RD high */
stream_getl(s); /* RD low */
- /*
- * NOTE: intentional fall through
- * - for consistency in rx processing
- *
- * The following comment is to signal GCC this intention
- * and supress the warning
- */
- /* FALLTHRU */
+ /*
+ * NOTE: intentional fall through
+ * - for consistency in rx processing
+ *
+ * The following comment is to signal GCC this intention
+ * and supress the warning
+ */
+ /* FALLTHRU */
case BGP_ATTR_NHLEN_IPV4:
stream_get(&attr->mp_nexthop_global_in, s, IPV4_MAX_BYTELEN);
/* Probably needed for RFC 2283 */
/* alloc and copy sub-tlv */
/* TBD make sure these are freed when attributes are released */
tlv = XCALLOC(MTYPE_ENCAP_TLV,
- sizeof(struct bgp_attr_encap_subtlv)
- + sublength);
+ sizeof(struct bgp_attr_encap_subtlv) + sublength);
tlv->type = subtype;
tlv->length = sublength;
stream_get(tlv->value, peer->curr, sublength);
stream_put(s, &p->u.prefix, PSIZE(p->prefixlen));
} else if (afi == AFI_L2VPN && safi == SAFI_EVPN) {
/* EVPN prefix - contents depend on type */
- bgp_evpn_encode_prefix(s, p, prd, label, num_labels,
- attr, addpath_encode, addpath_tx_id);
+ bgp_evpn_encode_prefix(s, p, prd, label, num_labels, attr,
+ addpath_encode, addpath_tx_id);
} else if (safi == SAFI_LABELED_UNICAST) {
/* Prefix write with label. */
stream_put_labeled_prefix(s, p, label);
if (attrlenfield > 0xff) {
/* 2-octet length field */
- stream_putc(s, BGP_ATTR_FLAG_TRANS | BGP_ATTR_FLAG_OPTIONAL
- | BGP_ATTR_FLAG_EXTLEN);
+ stream_putc(s,
+ BGP_ATTR_FLAG_TRANS | BGP_ATTR_FLAG_OPTIONAL
+ | BGP_ATTR_FLAG_EXTLEN);
stream_putc(s, attrtype);
stream_putw(s, attrlenfield & 0xffff);
} else {
mpattrlen_pos = bgp_packet_mpattr_start(s, peer, afi, safi,
vecarr, attr);
- bgp_packet_mpattr_prefix(s, afi, safi, p, prd,
- label, num_labels,
- addpath_encode, addpath_tx_id, attr);
+ bgp_packet_mpattr_prefix(s, afi, safi, p, prd, label,
+ num_labels, addpath_encode,
+ addpath_tx_id, attr);
bgp_packet_mpattr_end(s, mpattrlen_pos);
}
if (CHECK_FLAG(peer->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY)
&& (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES))) {
if (attr->community->size * 4 > 255) {
- stream_putc(s, BGP_ATTR_FLAG_OPTIONAL
- | BGP_ATTR_FLAG_TRANS
- | BGP_ATTR_FLAG_EXTLEN);
+ stream_putc(s,
+ BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS
+ | BGP_ATTR_FLAG_EXTLEN);
stream_putc(s, BGP_ATTR_COMMUNITIES);
stream_putw(s, attr->community->size * 4);
} else {
- stream_putc(s, BGP_ATTR_FLAG_OPTIONAL
- | BGP_ATTR_FLAG_TRANS);
+ stream_putc(s,
+ BGP_ATTR_FLAG_OPTIONAL
+ | BGP_ATTR_FLAG_TRANS);
stream_putc(s, BGP_ATTR_COMMUNITIES);
stream_putc(s, attr->community->size * 4);
}
PEER_FLAG_SEND_LARGE_COMMUNITY)
&& (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES))) {
if (lcom_length(attr->lcommunity) > 255) {
- stream_putc(s, BGP_ATTR_FLAG_OPTIONAL
- | BGP_ATTR_FLAG_TRANS
- | BGP_ATTR_FLAG_EXTLEN);
+ stream_putc(s,
+ BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS
+ | BGP_ATTR_FLAG_EXTLEN);
stream_putc(s, BGP_ATTR_LARGE_COMMUNITIES);
stream_putw(s, lcom_length(attr->lcommunity));
} else {
- stream_putc(s, BGP_ATTR_FLAG_OPTIONAL
- | BGP_ATTR_FLAG_TRANS);
+ stream_putc(s,
+ BGP_ATTR_FLAG_OPTIONAL
+ | BGP_ATTR_FLAG_TRANS);
stream_putc(s, BGP_ATTR_LARGE_COMMUNITIES);
stream_putc(s, lcom_length(attr->lcommunity));
}
if (peer->sort == BGP_PEER_IBGP
|| peer->sort == BGP_PEER_CONFED) {
if (attr->ecommunity->size * 8 > 255) {
- stream_putc(s, BGP_ATTR_FLAG_OPTIONAL
- | BGP_ATTR_FLAG_TRANS
- | BGP_ATTR_FLAG_EXTLEN);
+ stream_putc(s,
+ BGP_ATTR_FLAG_OPTIONAL
+ | BGP_ATTR_FLAG_TRANS
+ | BGP_ATTR_FLAG_EXTLEN);
stream_putc(s, BGP_ATTR_EXT_COMMUNITIES);
stream_putw(s, attr->ecommunity->size * 8);
} else {
- stream_putc(s, BGP_ATTR_FLAG_OPTIONAL
- | BGP_ATTR_FLAG_TRANS);
+ stream_putc(s,
+ BGP_ATTR_FLAG_OPTIONAL
+ | BGP_ATTR_FLAG_TRANS);
stream_putc(s, BGP_ATTR_EXT_COMMUNITIES);
stream_putc(s, attr->ecommunity->size * 8);
}
label_index = attr->label_index;
if (label_index != BGP_INVALID_LABEL_INDEX) {
- stream_putc(s, BGP_ATTR_FLAG_OPTIONAL
- | BGP_ATTR_FLAG_TRANS);
+ stream_putc(s,
+ BGP_ATTR_FLAG_OPTIONAL
+ | BGP_ATTR_FLAG_TRANS);
stream_putc(s, BGP_ATTR_PREFIX_SID);
stream_putc(s, 10);
stream_putc(s, BGP_PREFIX_SID_LABEL_INDEX);
*/
aspath = aspath_delete_confed_seq(aspath);
- stream_putc(s, BGP_ATTR_FLAG_TRANS | BGP_ATTR_FLAG_OPTIONAL
- | BGP_ATTR_FLAG_EXTLEN);
+ stream_putc(s,
+ BGP_ATTR_FLAG_TRANS | BGP_ATTR_FLAG_OPTIONAL
+ | BGP_ATTR_FLAG_EXTLEN);
stream_putc(s, BGP_ATTR_AS4_PATH);
aspath_sizep = stream_get_endp(s);
stream_putw(s, 0);
stream_putc(s, 9); // Length
stream_putc(s, 0); // Flags
stream_putc(s, 6); // Tunnel type: Ingress Replication (6)
- stream_put(s, &(attr->label), BGP_LABEL_BYTES); // MPLS Label / VXLAN VNI
- stream_put_ipv4(s, attr->nexthop.s_addr); // Unicast tunnel endpoint IP address
+ stream_put(s, &(attr->label),
+ BGP_LABEL_BYTES); // MPLS Label / VXLAN VNI
+ stream_put_ipv4(s, attr->nexthop.s_addr); // Unicast tunnel
+ // endpoint IP address
}
/* Unknown transit attribute. */
num_labels = 1;
}
- return bgp_packet_mpattr_prefix(s, afi, safi, p, prd,
- label, num_labels,
+ return bgp_packet_mpattr_prefix(s, afi, safi, p, prd, label, num_labels,
addpath_encode, addpath_tx_id, attr);
}
/* Community attribute. */
if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES)) {
if (attr->community->size * 4 > 255) {
- stream_putc(s, BGP_ATTR_FLAG_OPTIONAL
- | BGP_ATTR_FLAG_TRANS
- | BGP_ATTR_FLAG_EXTLEN);
+ stream_putc(s,
+ BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS
+ | BGP_ATTR_FLAG_EXTLEN);
stream_putc(s, BGP_ATTR_COMMUNITIES);
stream_putw(s, attr->community->size * 4);
} else {
- stream_putc(s, BGP_ATTR_FLAG_OPTIONAL
- | BGP_ATTR_FLAG_TRANS);
+ stream_putc(s,
+ BGP_ATTR_FLAG_OPTIONAL
+ | BGP_ATTR_FLAG_TRANS);
stream_putc(s, BGP_ATTR_COMMUNITIES);
stream_putc(s, attr->community->size * 4);
}
/* Large Community attribute. */
if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES)) {
if (lcom_length(attr->lcommunity) > 255) {
- stream_putc(s, BGP_ATTR_FLAG_OPTIONAL
- | BGP_ATTR_FLAG_TRANS
- | BGP_ATTR_FLAG_EXTLEN);
+ stream_putc(s,
+ BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS
+ | BGP_ATTR_FLAG_EXTLEN);
stream_putc(s, BGP_ATTR_LARGE_COMMUNITIES);
stream_putw(s, lcom_length(attr->lcommunity));
} else {
- stream_putc(s, BGP_ATTR_FLAG_OPTIONAL
- | BGP_ATTR_FLAG_TRANS);
+ stream_putc(s,
+ BGP_ATTR_FLAG_OPTIONAL
+ | BGP_ATTR_FLAG_TRANS);
stream_putc(s, BGP_ATTR_LARGE_COMMUNITIES);
stream_putc(s, lcom_length(attr->lcommunity));
}
- stream_put(s, attr->lcommunity->val, lcom_length(attr->lcommunity));
+ stream_put(s, attr->lcommunity->val,
+ lcom_length(attr->lcommunity));
}
/* Add a MP_NLRI attribute to dump the IPv6 next hop */
/* Prefix SID */
if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID)) {
if (attr->label_index != BGP_INVALID_LABEL_INDEX) {
- stream_putc(s, BGP_ATTR_FLAG_OPTIONAL
- | BGP_ATTR_FLAG_TRANS);
+ stream_putc(s,
+ BGP_ATTR_FLAG_OPTIONAL
+ | BGP_ATTR_FLAG_TRANS);
stream_putc(s, BGP_ATTR_PREFIX_SID);
stream_putc(s, 10);
stream_putc(s, BGP_PREFIX_SID_LABEL_INDEX);
/* "(void) 0" will generate a compiler error. this is a safety check to
* ensure we're not using a value that exceeds the bit size of attr->flag. */
-#define ATTR_FLAG_BIT(X) \
- __builtin_choose_expr((X) >= 1 && (X) <= 64, \
- 1ULL << ((X) - 1), \
- (void) 0)
+#define ATTR_FLAG_BIT(X) \
+ __builtin_choose_expr((X) >= 1 && (X) <= 64, 1ULL << ((X)-1), (void)0)
#define BGP_CLUSTER_LIST_LENGTH(attr) \
(((attr)->flag & ATTR_FLAG_BIT(BGP_ATTR_CLUSTER_LIST)) \
struct bpacket_attr_vec_arr *vecarr,
struct prefix *, afi_t, safi_t,
struct peer *, struct prefix_rd *,
- mpls_label_t *, u_int32_t,
- int, u_int32_t);
+ mpls_label_t *, u_int32_t, int,
+ u_int32_t);
extern void bgp_dump_routes_attr(struct stream *, struct attr *,
struct prefix *);
extern int attrhash_cmp(const void *, const void *);
safi_t safi);
extern void bgp_packet_mpunreach_prefix(struct stream *s, struct prefix *p,
afi_t afi, safi_t safi,
- struct prefix_rd *prd,
- mpls_label_t *, u_int32_t,
- int, u_int32_t, struct attr *);
+ struct prefix_rd *prd, mpls_label_t *,
+ u_int32_t, int, u_int32_t,
+ struct attr *);
extern void bgp_packet_mpunreach_end(struct stream *s, size_t attrlen_pnt);
static inline int bgp_rmap_nhop_changed(u_int32_t out_rmap_flags,
}
/* Fetch router-mac from extended community */
-void bgp_attr_rmac(struct attr *attr,
- struct ethaddr *rmac)
+void bgp_attr_rmac(struct attr *attr, struct ethaddr *rmac)
{
int i = 0;
struct ecommunity *ecom;
type = *pnt++;
sub_type = *pnt++;
- if (!(type == ECOMMUNITY_ENCODE_EVPN &&
- sub_type == ECOMMUNITY_EVPN_SUBTYPE_ROUTERMAC))
+ if (!(type == ECOMMUNITY_ENCODE_EVPN
+ && sub_type == ECOMMUNITY_EVPN_SUBTYPE_ROUTERMAC))
continue;
memcpy(rmac, pnt, ETH_ALEN);
*/
uint8_t bgp_attr_default_gw(struct attr *attr)
{
- struct ecommunity *ecom;
- int i;
+ struct ecommunity *ecom;
+ int i;
ecom = attr->ecommunity;
if (!ecom || !ecom->size)
/* If there is a default gw extendd community return true otherwise
* return 0 */
for (i = 0; i < ecom->size; i++) {
- u_char *pnt;
- u_char type, sub_type;
+ u_char *pnt;
+ u_char type, sub_type;
pnt = (ecom->val + (i * ECOMMUNITY_SIZE));
type = *pnt++;
sub_type = *pnt++;
if ((type == ECOMMUNITY_ENCODE_OPAQUE
- && sub_type == ECOMMUNITY_EVPN_SUBTYPE_DEF_GW))
+ && sub_type == ECOMMUNITY_EVPN_SUBTYPE_DEF_GW))
return 1;
}
if (make_json) {
json_object_string_add(com->json, "string", "");
- json_object_object_add(com->json, "list", json_community_list);
+ json_object_object_add(com->json, "list",
+ json_community_list);
}
com->str = str;
return;
strcpy(pnt, "internet");
pnt += strlen("internet");
if (make_json) {
- json_string = json_object_new_string("internet");
- json_object_array_add(json_community_list, json_string);
+ json_string =
+ json_object_new_string("internet");
+ json_object_array_add(json_community_list,
+ json_string);
}
break;
case COMMUNITY_NO_EXPORT:
strcpy(pnt, "no-export");
pnt += strlen("no-export");
if (make_json) {
- json_string = json_object_new_string("noExport");
- json_object_array_add(json_community_list, json_string);
+ json_string =
+ json_object_new_string("noExport");
+ json_object_array_add(json_community_list,
+ json_string);
}
break;
case COMMUNITY_NO_ADVERTISE:
strcpy(pnt, "no-advertise");
pnt += strlen("no-advertise");
if (make_json) {
- json_string = json_object_new_string("noAdvertise");
- json_object_array_add(json_community_list, json_string);
+ json_string =
+ json_object_new_string("noAdvertise");
+ json_object_array_add(json_community_list,
+ json_string);
}
break;
case COMMUNITY_LOCAL_AS:
pnt += strlen("local-AS");
if (make_json) {
json_string = json_object_new_string("localAs");
- json_object_array_add(json_community_list, json_string);
+ json_object_array_add(json_community_list,
+ json_string);
}
break;
case COMMUNITY_GSHUT:
strcpy(pnt, "graceful-shutdown");
pnt += strlen("graceful-shutdown");
if (make_json) {
- json_string = json_object_new_string("gracefulShutdown");
- json_object_array_add(json_community_list, json_string);
+ json_string = json_object_new_string(
+ "gracefulShutdown");
+ json_object_array_add(json_community_list,
+ json_string);
}
break;
default:
sprintf(pnt, "%u:%d", as, val);
if (make_json) {
json_string = json_object_new_string(pnt);
- json_object_array_add(json_community_list, json_string);
+ json_object_array_add(json_community_list,
+ json_string);
}
pnt += strlen(pnt);
break;
p += strlen("local-AS");
return p;
}
- if (strncmp(p, "graceful-shutdown", strlen("graceful-shutdown")) == 0) {
+ if (strncmp(p, "graceful-shutdown", strlen("graceful-shutdown"))
+ == 0) {
*val = COMMUNITY_GSHUT;
*token = community_token_gshut;
p += strlen("graceful-shutdown");
/* Initialize comminity related hash. */
void community_init(void)
{
- comhash = hash_create(
- (unsigned int (*)(void *))community_hash_make,
- (int (*)(const void *, const void *))community_cmp,
- "BGP Community Hash");
+ comhash =
+ hash_create((unsigned int (*)(void *))community_hash_make,
+ (int (*)(const void *, const void *))community_cmp,
+ "BGP Community Hash");
}
void community_finish(void)
} else
reuse_time = 0;
-/* Making formatted timer strings. */
+ /* Making formatted timer strings. */
if (reuse_time == 0) {
if (use_json)
json_object_int_add(json, "reuseTimerMsecs", 0);
/* Initialize Extended Comminities related hash. */
void ecommunity_init(void)
{
- ecomhash = hash_create(ecommunity_hash_make,
- ecommunity_cmp,
+ ecomhash = hash_create(ecommunity_hash_make, ecommunity_cmp,
"BGP ecommunity hash");
}
tunneltype = ntohs(tunneltype);
len = sprintf(str_buf + str_pnt, "ET:%d",
tunneltype);
- } else if (*pnt == ECOMMUNITY_EVPN_SUBTYPE_DEF_GW) {
+ } else if (*pnt == ECOMMUNITY_EVPN_SUBTYPE_DEF_GW) {
len = sprintf(str_buf + str_pnt,
"Default Gateway");
} else
/*
* Is specified VRF present on the RT's list of "importing" VRFs?
*/
-static int is_vrf_present_in_irt_vrfs(struct list *vrfs,
- struct bgp *bgp_vrf)
+static int is_vrf_present_in_irt_vrfs(struct list *vrfs, struct bgp *bgp_vrf)
{
struct listnode *node = NULL, *nnode = NULL;
struct bgp *tmp_bgp_vrf = NULL;
* Map one RT to specified VRF.
* bgp_vrf = BGP vrf instance
*/
-static void map_vrf_to_rt(struct bgp *bgp_vrf,
- struct ecommunity_val *eval)
+static void map_vrf_to_rt(struct bgp *bgp_vrf, struct ecommunity_val *eval)
{
struct vrf_irt_node *irt = NULL;
struct ecommunity_val eval_tmp;
* as the RT for EBGP peering too.
*/
memcpy(&eval_tmp, eval, ECOMMUNITY_SIZE);
- if (!CHECK_FLAG(bgp_vrf->vrf_flags,
- BGP_VRF_IMPORT_RT_CFGD))
+ if (!CHECK_FLAG(bgp_vrf->vrf_flags, BGP_VRF_IMPORT_RT_CFGD))
mask_ecom_global_admin(&eval_tmp, eval);
irt = lookup_vrf_import_rt(&eval_tmp);
* VRFs for this RT, then the RT hash is deleted.
* bgp_vrf: BGP VRF specific instance
*/
-static void unmap_vrf_from_rt(struct bgp *bgp_vrf,
- struct vrf_irt_node *irt)
+static void unmap_vrf_from_rt(struct bgp *bgp_vrf, struct vrf_irt_node *irt)
{
/* Delete VRF from list for this RT. */
listnode_delete(irt->vrfs, bgp_vrf);
s = zclient->obuf;
stream_reset(s);
- zclient_create_header(s, add ? ZEBRA_REMOTE_MACIP_ADD
- : ZEBRA_REMOTE_MACIP_DEL,
- bgp->vrf_id);
+ zclient_create_header(
+ s, add ? ZEBRA_REMOTE_MACIP_ADD : ZEBRA_REMOTE_MACIP_DEL,
+ bgp->vrf_id);
stream_putl(s, vpn->vni);
stream_put(s, &p->prefix.mac.octet, ETH_ALEN); /* Mac Addr */
/* IP address length and IP address, if any. */
stream_putw_at(s, 0, stream_get_endp(s));
if (bgp_debug_zebra(NULL))
- zlog_debug("Tx %s MACIP, VNI %u MAC %s IP %s (flags: 0x%x) remote VTEP %s",
- add ? "ADD" : "DEL", vpn->vni,
- prefix_mac2str(&p->prefix.mac, buf1, sizeof(buf1)),
- ipaddr2str(&p->prefix.ip, buf3, sizeof(buf3)),
- flags,
- inet_ntop(AF_INET, &remote_vtep_ip, buf2,
- sizeof(buf2)));
+ zlog_debug(
+ "Tx %s MACIP, VNI %u MAC %s IP %s (flags: 0x%x) remote VTEP %s",
+ add ? "ADD" : "DEL", vpn->vni,
+ prefix_mac2str(&p->prefix.mac, buf1, sizeof(buf1)),
+ ipaddr2str(&p->prefix.ip, buf3, sizeof(buf3)), flags,
+ inet_ntop(AF_INET, &remote_vtep_ip, buf2,
+ sizeof(buf2)));
return zclient_send_message(zclient);
}
s = zclient->obuf;
stream_reset(s);
- zclient_create_header(s, add ? ZEBRA_REMOTE_VTEP_ADD
- : ZEBRA_REMOTE_VTEP_DEL,
- bgp->vrf_id);
+ zclient_create_header(
+ s, add ? ZEBRA_REMOTE_VTEP_ADD : ZEBRA_REMOTE_VTEP_DEL,
+ bgp->vrf_id);
stream_putl(s, vpn->vni);
if (IS_EVPN_PREFIX_IPADDR_V4(p))
stream_put_in_addr(s, &p->prefix.ip.ipaddr_v4);
vrf_export_rtl = bgp_vrf->vrf_export_rtl;
if (vrf_export_rtl && !list_isempty(vrf_export_rtl)) {
for (ALL_LIST_ELEMENTS(vrf_export_rtl, node, nnode, ecom))
- attr->ecommunity = ecommunity_merge(attr->ecommunity,
- ecom);
+ attr->ecommunity =
+ ecommunity_merge(attr->ecommunity, ecom);
}
/* add the router mac extended community */
encode_rmac_extcomm(&eval_rmac, &attr->rmac);
ecom_rmac.size = 1;
ecom_rmac.val = (uint8_t *)eval_rmac.val;
- attr->ecommunity = ecommunity_merge(attr->ecommunity,
- &ecom_rmac);
+ attr->ecommunity =
+ ecommunity_merge(attr->ecommunity, &ecom_rmac);
}
attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES);
if (vrf_export_rtl && !list_isempty(vrf_export_rtl)) {
for (ALL_LIST_ELEMENTS(vrf_export_rtl, node, nnode,
ecom))
- attr->ecommunity =
- ecommunity_merge(attr->ecommunity,
- ecom);
+ attr->ecommunity = ecommunity_merge(
+ attr->ecommunity, ecom);
}
}
* only attach l3-vni rmac for ipv4 address family and if we are
* advertising both the labels in type-2 routes
*/
- if (afi == AFI_IP && !is_zero_mac(&attr->rmac) &&
- CHECK_FLAG(vpn->flags, VNI_FLAG_USE_TWO_LABELS)) {
+ if (afi == AFI_IP && !is_zero_mac(&attr->rmac)
+ && CHECK_FLAG(vpn->flags, VNI_FLAG_USE_TWO_LABELS)) {
memset(&ecom_rmac, 0, sizeof(ecom_rmac));
encode_rmac_extcomm(&eval_rmac, &attr->rmac);
ecom_rmac.size = 1;
ecom_rmac.val = (uint8_t *)eval_rmac.val;
- attr->ecommunity = ecommunity_merge(attr->ecommunity,
- &ecom_rmac);
+ attr->ecommunity =
+ ecommunity_merge(attr->ecommunity, &ecom_rmac);
}
if (attr->default_gw) {
encode_default_gw_extcomm(&eval_default_gw);
ecom_default_gw.size = 1;
ecom_default_gw.val = (uint8_t *)eval_default_gw.val;
- attr->ecommunity = ecommunity_merge(attr->ecommunity,
- &ecom_default_gw);
+ attr->ecommunity =
+ ecommunity_merge(attr->ecommunity, &ecom_default_gw);
}
attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES);
afi_t afi = AFI_L2VPN;
safi_t safi = SAFI_EVPN;
int ret = 0;
- u_char flags = 0;
+ u_char flags = 0;
/* Compute the best path. */
bgp_best_selection(bgp, rn, &bgp->maxpaths[afi][safi], &old_and_new,
SET_FLAG(flags, ZEBRA_MACIP_TYPE_STICKY);
if (old_select->attr->default_gw)
SET_FLAG(flags, ZEBRA_MACIP_TYPE_GW);
- ret = evpn_zebra_install(bgp, vpn,
- (struct prefix_evpn *)&rn->p,
- old_select->attr->nexthop,
- flags);
+ ret = evpn_zebra_install(
+ bgp, vpn, (struct prefix_evpn *)&rn->p,
+ old_select->attr->nexthop, flags);
}
UNSET_FLAG(old_select->flags, BGP_INFO_MULTIPATH_CHG);
bgp_zebra_clear_route_change_flags(rn);
if (new_select->attr->default_gw)
SET_FLAG(flags, ZEBRA_MACIP_TYPE_GW);
ret = evpn_zebra_install(bgp, vpn, (struct prefix_evpn *)&rn->p,
- new_select->attr->nexthop,
- flags);
+ new_select->attr->nexthop, flags);
/* If an old best existed and it was a "local" route, the only
* reason
* it would be supplanted is due to MAC mobility procedures. So,
*/
static int evpn_route_is_def_gw(struct bgp *bgp, struct bgp_node *rn)
{
- struct bgp_info *tmp_ri = NULL;
- struct bgp_info *local_ri = NULL;
+ struct bgp_info *tmp_ri = NULL;
+ struct bgp_info *local_ri = NULL;
local_ri = NULL;
for (tmp_ri = rn->info; tmp_ri; tmp_ri = tmp_ri->next) {
}
/* update evpn type-5 route entry */
-static int update_evpn_type5_route(struct bgp *bgp_vrf,
- struct prefix_evpn *evp,
- struct attr* src_attr)
+static int update_evpn_type5_route(struct bgp *bgp_vrf, struct prefix_evpn *evp,
+ struct attr *src_attr)
{
afi_t afi = AFI_L2VPN;
safi_t safi = SAFI_EVPN;
/* get the route node in global table */
rn = bgp_afi_node_get(bgp_def->rib[afi][safi], afi, safi,
- (struct prefix *)evp,
- &bgp_vrf->vrf_prd);
+ (struct prefix *)evp, &bgp_vrf->vrf_prd);
assert(rn);
/* create or update the route entry within the route node */
- update_evpn_type5_route_entry(bgp_def, bgp_vrf,
- afi, safi,
- rn, &attr, &route_changed);
+ update_evpn_type5_route_entry(bgp_def, bgp_vrf, afi, safi, rn, &attr,
+ &route_changed);
/* schedule for processing and unlock node */
if (route_changed) {
* Only attach second label if we are advertising two labels for
* type-2 routes.
*/
- if (evp->prefix.route_type == BGP_EVPN_MAC_IP_ROUTE &&
- CHECK_FLAG(vpn->flags, VNI_FLAG_USE_TWO_LABELS)) {
+ if (evp->prefix.route_type == BGP_EVPN_MAC_IP_ROUTE
+ && CHECK_FLAG(vpn->flags, VNI_FLAG_USE_TWO_LABELS)) {
vni_t l3vni;
l3vni = bgpevpn_get_l3vni(vpn);
* be advertised with right labels.
*/
vni2label(vpn->vni, &label[0]);
- if (evp->prefix.route_type == BGP_EVPN_MAC_IP_ROUTE &&
- CHECK_FLAG(vpn->flags, VNI_FLAG_USE_TWO_LABELS)) {
+ if (evp->prefix.route_type == BGP_EVPN_MAC_IP_ROUTE
+ && CHECK_FLAG(vpn->flags,
+ VNI_FLAG_USE_TWO_LABELS)) {
vni_t l3vni;
l3vni = bgpevpn_get_l3vni(vpn);
vni2label(vpn->vni, &(attr.label));
/* Set up RT and ENCAP extended community. */
- build_evpn_route_extcomm(vpn, &attr,
- IS_EVPN_PREFIX_IPADDR_V4(p) ?
- AFI_IP : AFI_IP6);
+ build_evpn_route_extcomm(
+ vpn, &attr, IS_EVPN_PREFIX_IPADDR_V4(p) ? AFI_IP : AFI_IP6);
/* First, create (or fetch) route node within the VNI. */
/* NOTE: There is no RD here. */
/* Delete EVPN type5 route entry from global table */
static void delete_evpn_type5_route_entry(struct bgp *bgp_def,
- struct bgp *bgp_vrf,
- afi_t afi, safi_t safi,
- struct bgp_node *rn,
+ struct bgp *bgp_vrf, afi_t afi,
+ safi_t safi, struct bgp_node *rn,
struct bgp_info **ri)
{
struct bgp_info *tmp_ri = NULL;
}
/* Delete EVPN type5 route */
-static int delete_evpn_type5_route(struct bgp *bgp_vrf,
- struct prefix_evpn *evp)
+static int delete_evpn_type5_route(struct bgp *bgp_vrf, struct prefix_evpn *evp)
{
afi_t afi = AFI_L2VPN;
safi_t safi = SAFI_EVPN;
if (IS_EVPN_PREFIX_IPADDR_V4(evp)) {
if (evpn_route_is_sticky(bgp, rn))
update_evpn_route_entry(bgp, vpn, afi, safi, rn,
- &attr_sticky, 0, 1,
- &ri, 0);
+ &attr_sticky, 0, 1, &ri,
+ 0);
else if (evpn_route_is_def_gw(bgp, rn))
update_evpn_route_entry(bgp, vpn, afi, safi, rn,
- &attr_def_gw, 0, 1,
- &ri, 0);
+ &attr_def_gw, 0, 1, &ri,
+ 0);
else
update_evpn_route_entry(bgp, vpn, afi, safi, rn,
&attr, 0, 1, &ri, 0);
&ri, 0);
else
update_evpn_route_entry(bgp, vpn, afi, safi, rn,
- &attr_ip6, 0, 1,
- &ri, 0);
+ &attr_ip6, 0, 1, &ri,
+ 0);
}
/* If a local route exists for this prefix, we need to update
ip_prefix_from_type5_prefix(evp, pp);
if (bgp_debug_zebra(NULL)) {
- zlog_debug("installing evpn prefix %s as ip prefix %s in vrf %s",
- prefix2str(evp, buf, sizeof(buf)),
- prefix2str(pp, buf1, sizeof(buf)),
- vrf_id_to_name(bgp_vrf->vrf_id));
+ zlog_debug(
+ "installing evpn prefix %s as ip prefix %s in vrf %s",
+ prefix2str(evp, buf, sizeof(buf)),
+ prefix2str(pp, buf1, sizeof(buf)),
+ vrf_id_to_name(bgp_vrf->vrf_id));
}
/* Create (or fetch) route within the VRF. */
ip_prefix_from_type5_prefix(evp, pp);
if (bgp_debug_zebra(NULL)) {
- zlog_debug("uninstalling evpn prefix %s as ip prefix %s in vrf %s",
- prefix2str(evp, buf, sizeof(buf)),
- prefix2str(pp, buf1, sizeof(buf)),
- vrf_id_to_name(bgp_vrf->vrf_id));
+ zlog_debug(
+ "uninstalling evpn prefix %s as ip prefix %s in vrf %s",
+ prefix2str(evp, buf, sizeof(buf)),
+ prefix2str(pp, buf1, sizeof(buf)),
+ vrf_id_to_name(bgp_vrf->vrf_id));
}
/* Locate route within the VRF. */
* Given a route entry and a VRF, see if this route entry should be
* imported into the VRF i.e., RTs match.
*/
-static int is_route_matching_for_vrf(struct bgp *bgp_vrf,
- struct bgp_info *ri)
+static int is_route_matching_for_vrf(struct bgp *bgp_vrf, struct bgp_info *ri)
{
struct attr *attr = ri->attr;
struct ecommunity *ecom;
* Install or uninstall mac-ip routes are appropriate for this
* particular VRF.
*/
-static int install_uninstall_routes_for_vrf(struct bgp *bgp_vrf,
- int install)
+static int install_uninstall_routes_for_vrf(struct bgp *bgp_vrf, int install)
{
afi_t afi;
safi_t safi;
struct prefix_evpn *evp = (struct prefix_evpn *)&rn->p;
/* if not mac-ip route skip this route */
- if (!(evp->prefix.route_type == BGP_EVPN_MAC_IP_ROUTE ||
- evp->prefix.route_type == BGP_EVPN_IP_PREFIX_ROUTE))
+ if (!(evp->prefix.route_type == BGP_EVPN_MAC_IP_ROUTE
+ || evp->prefix.route_type
+ == BGP_EVPN_IP_PREFIX_ROUTE))
continue;
/* if not a mac+ip route skip this route */
- if (!(IS_EVPN_PREFIX_IPADDR_V4(evp) ||
- IS_EVPN_PREFIX_IPADDR_V6(evp)))
+ if (!(IS_EVPN_PREFIX_IPADDR_V4(evp)
+ || IS_EVPN_PREFIX_IPADDR_V6(evp)))
continue;
for (ri = rn->info; ri; ri = ri->next) {
if (is_route_matching_for_vrf(bgp_vrf, ri)) {
if (install)
- ret =
- install_evpn_route_entry_in_vrf(
+ ret = install_evpn_route_entry_in_vrf(
bgp_vrf, evp, ri);
else
- ret =
- uninstall_evpn_route_entry_in_vrf(
+ ret = uninstall_evpn_route_entry_in_vrf(
bgp_vrf, evp, ri);
if (ret) {
: "uninstall",
prefix2str(evp, buf,
sizeof(buf)),
- vrf_id_to_name(bgp_vrf->vrf_id));
+ vrf_id_to_name(
+ bgp_vrf->vrf_id));
return ret;
}
}
struct listnode *node, *nnode;
/* Only type-2/type-5 routes go into a VRF */
- if (!(evp->prefix.route_type == BGP_EVPN_MAC_IP_ROUTE ||
- evp->prefix.route_type == BGP_EVPN_IP_PREFIX_ROUTE))
+ if (!(evp->prefix.route_type == BGP_EVPN_MAC_IP_ROUTE
+ || evp->prefix.route_type == BGP_EVPN_IP_PREFIX_ROUTE))
return 0;
/* if it is type-2 route and not a mac+ip route skip this route */
- if ((evp->prefix.route_type == BGP_EVPN_MAC_IP_ROUTE) &&
- !(IS_EVPN_PREFIX_IPADDR_V4(evp) || IS_EVPN_PREFIX_IPADDR_V6(evp)))
+ if ((evp->prefix.route_type == BGP_EVPN_MAC_IP_ROUTE)
+ && !(IS_EVPN_PREFIX_IPADDR_V4(evp)
+ || IS_EVPN_PREFIX_IPADDR_V6(evp)))
return 0;
for (ALL_LIST_ELEMENTS(vrfs, node, nnode, bgp_vrf)) {
int ret;
if (install)
- ret = install_evpn_route_entry_in_vrf(bgp_vrf,
- evp, ri);
+ ret = install_evpn_route_entry_in_vrf(bgp_vrf, evp, ri);
else
- ret = uninstall_evpn_route_entry_in_vrf(bgp_vrf,
- evp, ri);
+ ret = uninstall_evpn_route_entry_in_vrf(bgp_vrf, evp,
+ ri);
if (ret) {
zlog_err("%u: Failed to %s prefix %s in VRF %s",
u_char type, sub_type;
struct ecommunity_val *eval;
struct ecommunity_val eval_tmp;
- struct irt_node *irt; /* import rt for l2vni */
+ struct irt_node *irt; /* import rt for l2vni */
struct vrf_irt_node *vrf_irt; /* import rt for l3vni */
/* Only deal with RTs */
install_uninstall_route_in_vnis(bgp, afi, safi, evp, ri,
irt->vnis, import);
if (vrf_irt && vrf_irt->vrfs)
- install_uninstall_route_in_vrfs(bgp, afi, safi, evp,
- ri, vrf_irt->vrfs,
- import);
+ install_uninstall_route_in_vrfs(bgp, afi, safi, evp, ri,
+ vrf_irt->vrfs, import);
}
return 0;
memcpy(&label[1], pfx, BGP_LABEL_BYTES);
/*
* If in future, we are required to access additional fields,
- * we MUST increment pfx by BGP_LABEL_BYTES in before reading the next field
+ * we MUST increment pfx by BGP_LABEL_BYTES in before reading
+ * the next field
*/
}
/*
* If in future, we are required to access additional fields,
- * we MUST increment pfx by BGP_LABEL_BYTES in before reading the next field
+ * we MUST increment pfx by BGP_LABEL_BYTES in before reading the next
+ * field
*/
/* Process the route. */
}
static void evpn_mpattr_encode_type5(struct stream *s, struct prefix *p,
- struct prefix_rd *prd,
- mpls_label_t *label, u_int32_t num_labels,
- struct attr *attr)
+ struct prefix_rd *prd, mpls_label_t *label,
+ u_int32_t num_labels, struct attr *attr)
{
int len;
char temp[16];
ret = delete_evpn_type5_route(bgp_vrf, &evp);
if (ret) {
zlog_err(
- "%u failed to delete type-5 route for prefix %s in vrf %s",
- bgp_vrf->vrf_id,
- prefix2str(p, buf, sizeof(buf)),
- vrf_id_to_name(bgp_vrf->vrf_id));
+ "%u failed to delete type-5 route for prefix %s in vrf %s",
+ bgp_vrf->vrf_id, prefix2str(p, buf, sizeof(buf)),
+ vrf_id_to_name(bgp_vrf->vrf_id));
}
}
/* withdraw all type-5 routes for an address family */
-void bgp_evpn_withdraw_type5_routes(struct bgp *bgp_vrf,
- afi_t afi, safi_t safi)
+void bgp_evpn_withdraw_type5_routes(struct bgp *bgp_vrf, afi_t afi, safi_t safi)
{
struct bgp_table *table = NULL;
struct bgp_node *rn = NULL;
/* Only care about "selected" routes - non-imported. */
/* TODO: Support for AddPath for EVPN. */
for (ri = rn->info; ri; ri = ri->next) {
- if (CHECK_FLAG(ri->flags, BGP_INFO_SELECTED) &&
- (!ri->extra || !ri->extra->parent)) {
+ if (CHECK_FLAG(ri->flags, BGP_INFO_SELECTED)
+ && (!ri->extra || !ri->extra->parent)) {
bgp_evpn_withdraw_type5_route(bgp_vrf, &rn->p,
afi, safi);
break;
* are advertising local subnets), the src_attr will be NULL.
*/
void bgp_evpn_advertise_type5_route(struct bgp *bgp_vrf, struct prefix *p,
- struct attr *src_attr,
- afi_t afi, safi_t safi)
+ struct attr *src_attr, afi_t afi,
+ safi_t safi)
{
int ret = 0;
struct prefix_evpn evp;
build_type5_prefix_from_ip_prefix(&evp, p);
ret = update_evpn_type5_route(bgp_vrf, &evp, src_attr);
if (ret)
- zlog_err(
- "%u: Failed to create type-5 route for prefix %s",
- bgp_vrf->vrf_id,
- prefix2str(p, buf, sizeof(buf)));
+ zlog_err("%u: Failed to create type-5 route for prefix %s",
+ bgp_vrf->vrf_id, prefix2str(p, buf, sizeof(buf)));
}
/* Inject all prefixes of a particular address-family (currently, IPv4 or
* IPv6 unicast) into EVPN as type-5 routes. This is invoked when the
* advertisement is enabled.
*/
-void bgp_evpn_advertise_type5_routes(struct bgp *bgp_vrf,
- afi_t afi, safi_t safi)
+void bgp_evpn_advertise_type5_routes(struct bgp *bgp_vrf, afi_t afi,
+ safi_t safi)
{
struct bgp_table *table = NULL;
struct bgp_node *rn = NULL;
* TODO: Support for AddPath for EVPN.
*/
for (ri = rn->info; ri; ri = ri->next) {
- if (CHECK_FLAG(ri->flags, BGP_INFO_SELECTED) &&
- (!ri->extra || !ri->extra->parent)) {
+ if (CHECK_FLAG(ri->flags, BGP_INFO_SELECTED)
+ && (!ri->extra || !ri->extra->parent)) {
/* apply the route-map */
if (bgp_vrf->adv_cmd_rmap[afi][safi].map) {
int ret = 0;
- ret =
- route_map_apply(
- bgp_vrf->adv_cmd_rmap[afi][safi].map,
- &rn->p, RMAP_BGP, ri);
+ ret = route_map_apply(
+ bgp_vrf->adv_cmd_rmap[afi][safi]
+ .map,
+ &rn->p, RMAP_BGP, ri);
if (ret == RMAP_DENYMATCH)
continue;
}
- bgp_evpn_advertise_type5_route(bgp_vrf, &rn->p,
- ri->attr,
- afi, safi);
+ bgp_evpn_advertise_type5_route(
+ bgp_vrf, &rn->p, ri->attr, afi, safi);
break;
}
}
}
}
-void evpn_rt_delete_auto(struct bgp *bgp, vni_t vni,
- struct list *rtl)
+void evpn_rt_delete_auto(struct bgp *bgp, vni_t vni, struct list *rtl)
{
struct listnode *node, *nnode, *node_to_del;
struct ecommunity *ecom, *ecom_auto;
SET_FLAG(bgp_vrf->vrf_flags, BGP_VRF_EXPORT_RT_CFGD);
bgp_evpn_handle_export_rt_change_for_vrf(bgp_vrf);
-
}
void bgp_evpn_unconfigure_export_rt_for_vrf(struct bgp *bgp_vrf,
return update_routes_for_vni(bgp, vpn);
}
-void bgp_evpn_handle_vrf_rd_change(struct bgp *bgp_vrf,
- int withdraw)
+void bgp_evpn_handle_vrf_rd_change(struct bgp *bgp_vrf, int withdraw)
{
if (withdraw)
delete_withdraw_vrf_routes(bgp_vrf);
/*
* TODO: Hardcoded for a maximum of 2 VNIs right now
*/
-char *bgp_evpn_label2str(mpls_label_t *label, u_int32_t num_labels,
- char *buf, int len)
+char *bgp_evpn_label2str(mpls_label_t *label, u_int32_t num_labels, char *buf,
+ int len)
{
vni_t vni1, vni2;
vni1 = label2vni(label);
if (num_labels == 2) {
- vni2 = label2vni(label+1);
+ vni2 = label2vni(label + 1);
snprintf(buf, len, "%u/%u", vni1, vni2);
} else
snprintf(buf, len, "%u", vni1);
}
} else if (p->prefix.route_type == BGP_EVPN_IP_PREFIX_ROUTE) {
snprintf(buf, len, "[%d]:[0]:[0]:[%d]:[%s]",
- p->prefix.route_type,
- p->prefix.ip_prefix_length,
- IS_EVPN_PREFIX_IPADDR_V4(p) ?
- inet_ntoa(p->prefix.ip.ipaddr_v4) :
- inet6_ntoa(p->prefix.ip.ipaddr_v6));
+ p->prefix.route_type, p->prefix.ip_prefix_length,
+ IS_EVPN_PREFIX_IPADDR_V4(p)
+ ? inet_ntoa(p->prefix.ip.ipaddr_v4)
+ : inet6_ntoa(p->prefix.ip.ipaddr_v6));
} else {
/* For EVPN route types not supported yet. */
snprintf(buf, len, "(unsupported route type %d)",
* Encode EVPN prefix in Update (MP_REACH)
*/
void bgp_evpn_encode_prefix(struct stream *s, struct prefix *p,
- struct prefix_rd *prd,
- mpls_label_t *label, u_int32_t num_labels,
- struct attr *attr, int addpath_encode,
- u_int32_t addpath_tx_id)
+ struct prefix_rd *prd, mpls_label_t *label,
+ u_int32_t num_labels, struct attr *attr,
+ int addpath_encode, u_int32_t addpath_tx_id)
{
struct prefix_evpn *evp = (struct prefix_evpn *)p;
int len, ipa_len = 0;
if (ipa_len && num_labels > 1) /* There are 2 VNIs */
len += 3;
stream_putc(s, len);
- stream_put(s, prd->val, 8); /* RD */
- stream_put(s, 0, 10); /* ESI */
- stream_putl(s, 0); /* Ethernet Tag ID */
+ stream_put(s, prd->val, 8); /* RD */
+ stream_put(s, 0, 10); /* ESI */
+ stream_putl(s, 0); /* Ethernet Tag ID */
stream_putc(s, 8 * ETH_ALEN); /* Mac Addr Len - bits */
stream_put(s, evp->prefix.mac.octet, 6); /* Mac Addr */
stream_putc(s, 8 * ipa_len); /* IP address Length */
- if (ipa_len) /* IP */
+ if (ipa_len) /* IP */
stream_put(s, &evp->prefix.ip.ip.addr, ipa_len);
/* 1st label is the L2 VNI */
stream_put(s, label, BGP_LABEL_BYTES);
/* Include 2nd label (L3 VNI) if advertising MAC+IP */
if (ipa_len && num_labels > 1)
- stream_put(s, label+1, BGP_LABEL_BYTES);
+ stream_put(s, label + 1, BGP_LABEL_BYTES);
break;
case BGP_EVPN_IMET_ROUTE:
}
-
/*
* Map the RTs (configured or automatically derived) of a VNI to the VNI.
* The mapping will be used during route processing.
zlog_err(
"%u:Failed to create Type-2 route, VNI %u %s MAC %s IP %s (flags: 0x%x)",
bgp->vrf_id, vpn->vni,
- CHECK_FLAG(flags, ZEBRA_MACIP_TYPE_STICKY) ? "sticky gateway"
- : "",
+ CHECK_FLAG(flags, ZEBRA_MACIP_TYPE_STICKY)
+ ? "sticky gateway"
+ : "",
prefix_mac2str(mac, buf, sizeof(buf)),
- ipaddr2str(ip, buf2, sizeof(buf2)),
- flags);
+ ipaddr2str(ip, buf2, sizeof(buf2)), flags);
return -1;
}
bgpevpn_link_to_l3vni(vpn);
}
-int bgp_evpn_local_l3vni_add(vni_t l3vni,
- vrf_id_t vrf_id,
- struct ethaddr *rmac,
- struct in_addr originator_ip,
- int filter)
+int bgp_evpn_local_l3vni_add(vni_t l3vni, vrf_id_t vrf_id, struct ethaddr *rmac,
+ struct in_addr originator_ip, int filter)
{
struct bgp *bgp_vrf = NULL; /* bgp VRF instance */
struct bgp *bgp_def = NULL; /* default bgp instance */
*/
bgp_def = bgp_get_default();
if (!bgp_def) {
- zlog_err("Cannot process L3VNI %u ADD - default BGP instance not yet created",
- l3vni);
+ zlog_err(
+ "Cannot process L3VNI %u ADD - default BGP instance not yet created",
+ l3vni);
return -1;
}
as = bgp_def->as;
/* link all corresponding l2vnis */
hash_iterate(bgp_def->vnihash,
- (void (*)(struct hash_backet *, void *))
- link_l2vni_hash_to_l3vni,
+ (void (*)(struct hash_backet *,
+ void *))link_l2vni_hash_to_l3vni,
bgp_vrf);
/* Only update all corresponding type-2 routes if we are advertising two
return 0;
}
-int bgp_evpn_local_l3vni_del(vni_t l3vni,
- vrf_id_t vrf_id)
+int bgp_evpn_local_l3vni_del(vni_t l3vni, vrf_id_t vrf_id)
{
struct bgp *bgp_vrf = NULL; /* bgp vrf instance */
struct bgp *bgp_def = NULL; /* default bgp instance */
bgp_vrf = bgp_lookup_by_vrf_id(vrf_id);
if (!bgp_vrf) {
- zlog_err("Cannot process L3VNI %u Del - Could not find BGP instance",
- l3vni);
+ zlog_err(
+ "Cannot process L3VNI %u Del - Could not find BGP instance",
+ l3vni);
return -1;
}
bgp_def = bgp_get_default();
if (!bgp_def) {
- zlog_err("Cannot process L3VNI %u Del - Could not find default BGP instance",
- l3vni);
+ zlog_err(
+ "Cannot process L3VNI %u Del - Could not find default BGP instance",
+ l3vni);
return -1;
}
* about are for the local-tunnel-ip and the (tenant) VRF.
*/
int bgp_evpn_local_vni_add(struct bgp *bgp, vni_t vni,
- struct in_addr originator_ip,
- vrf_id_t tenant_vrf_id)
+ struct in_addr originator_ip, vrf_id_t tenant_vrf_id)
{
struct bgpevpn *vpn;
struct prefix_evpn p;
bgp->vrf_export_rtl->cmp =
(int (*)(void *, void *))evpn_route_target_cmp;
bgp->l2vnis = list_new();
- bgp->l2vnis->cmp =
- (int (*)(void *, void *))vni_hash_cmp;
+ bgp->l2vnis->cmp = (int (*)(void *, void *))vni_hash_cmp;
bf_assign_index(bm->rd_idspace, bgp->vrf_rd_id);
-
}
void bgp_evpn_vrf_delete(struct bgp *bgp_vrf)
extern void bgp_evpn_advertise_type5_route(struct bgp *bgp_vrf,
struct prefix *p,
- struct attr *src_attr,
- afi_t afi, safi_t safi);
-extern void bgp_evpn_withdraw_type5_route(struct bgp *bgp_vrf,
- struct prefix *p,
+ struct attr *src_attr, afi_t afi,
+ safi_t safi);
+extern void bgp_evpn_withdraw_type5_route(struct bgp *bgp_vrf, struct prefix *p,
afi_t afi, safi_t safi);
extern void bgp_evpn_withdraw_type5_routes(struct bgp *bgp_vrf, afi_t afi,
safi_t safi);
extern char *bgp_evpn_route2str(struct prefix_evpn *p, char *buf, int len);
extern void bgp_evpn_route2json(struct prefix_evpn *p, json_object *json);
extern void bgp_evpn_encode_prefix(struct stream *s, struct prefix *p,
- struct prefix_rd *prd,
- mpls_label_t *label, u_int32_t num_labels,
- struct attr *attr, int addpath_encode,
- u_int32_t addpath_tx_id);
+ struct prefix_rd *prd, mpls_label_t *label,
+ u_int32_t num_labels, struct attr *attr,
+ int addpath_encode, u_int32_t addpath_tx_id);
extern int bgp_nlri_parse_evpn(struct peer *peer, struct attr *attr,
struct bgp_nlri *packet, int withdraw);
extern int bgp_evpn_import_route(struct bgp *bgp, afi_t afi, safi_t safi,
u_char flags);
extern int bgp_evpn_local_l3vni_add(vni_t vni, vrf_id_t vrf_id,
struct ethaddr *rmac,
- struct in_addr originator_ip,
- int filter);
+ struct in_addr originator_ip, int filter);
extern int bgp_evpn_local_l3vni_del(vni_t vni, vrf_id_t vrf_id);
extern int bgp_evpn_local_vni_del(struct bgp *bgp, vni_t vni);
extern int bgp_evpn_local_vni_add(struct bgp *bgp, vni_t vni,
struct bgp *bgp_vrf; /* back pointer to the vrf instance */
- /* Flag to indicate if we are advertising the g/w mac ip for this VNI*/
- u_int8_t advertise_gw_macip;
+ /* Flag to indicate if we are
+ * advertising the g/w mac ip for
+ * this VNI*/
+ u_int8_t advertise_gw_macip;
- /* Flag to indicate if we are advertising subnet for this VNI */
- u_int8_t advertise_subnet;
+ /* Flag to indicate if we are
+ * advertising subnet for this VNI */
+ u_int8_t advertise_subnet;
- /* Id for deriving the RD automatically for this VNI */
- u_int16_t rd_id;
+ /* Id for deriving the RD
+ * automatically for this VNI */
+ u_int16_t rd_id;
- /* RD for this VNI. */
- struct prefix_rd prd;
+ /* RD for this VNI. */
+ struct prefix_rd prd;
- /* Route type 3 field */
- struct in_addr originator_ip;
+ /* Route type 3 field */
+ struct in_addr originator_ip;
- /* Import and Export RTs. */
- struct list *import_rtl;
- struct list *export_rtl;
+ /* Import and Export RTs. */
+ struct list *import_rtl;
+ struct list *export_rtl;
- /* Route table for EVPN routes for this VNI. */
- struct bgp_table *route_table;
+ /* Route table for EVPN routes for
+ * this VNI. */
+ struct bgp_table *route_table;
- QOBJ_FIELDS
+ QOBJ_FIELDS
};
DECLARE_QOBJ_TYPE(bgpevpn)
static inline int is_vrf_rd_configured(struct bgp *bgp_vrf)
{
- return (CHECK_FLAG(bgp_vrf->vrf_flags,
- BGP_VRF_RD_CFGD));
+ return (CHECK_FLAG(bgp_vrf->vrf_flags, BGP_VRF_RD_CFGD));
}
static inline int bgp_evpn_vrf_rd_matches_existing(struct bgp *bgp_vrf,
/* bail if vpn is not associated to bgp_vrf */
if (!vpn->bgp_vrf)
return;
-
+
UNSET_FLAG(vpn->flags, VNI_FLAG_USE_TWO_LABELS);
listnode_delete(vpn->bgp_vrf->l2vnis, vpn);
-
+
/* remove the backpointer to the vrf instance */
vpn->bgp_vrf = NULL;
}
listnode_add_sort(bgp_vrf->l2vnis, vpn);
/* check if we are advertising two labels for this vpn */
- if (!CHECK_FLAG(bgp_vrf->vrf_flags,
- BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY))
+ if (!CHECK_FLAG(bgp_vrf->vrf_flags, BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY))
SET_FLAG(vpn->flags, VNI_FLAG_USE_TWO_LABELS);
}
if (IS_EVPN_PREFIX_IPADDR_V4(evp)) {
ip->family = AF_INET;
ip->prefixlen = evp->prefix.ip_prefix_length;
- memcpy(&(ip->u.prefix4),
- &(evp->prefix.ip.ip),
+ memcpy(&(ip->u.prefix4), &(evp->prefix.ip.ip),
IPV4_MAX_BYTELEN);
} else if (IS_EVPN_PREFIX_IPADDR_V6(evp)) {
ip->family = AF_INET6;
ip->prefixlen = evp->prefix.ip_prefix_length;
- memcpy(&(ip->u.prefix6),
- &(evp->prefix.ip.ip),
+ memcpy(&(ip->u.prefix6), &(evp->prefix.ip.ip),
IPV6_MAX_BYTELEN);
}
}
if (IS_EVPN_PREFIX_IPADDR_V4(evp)) {
ip->family = AF_INET;
ip->prefixlen = IPV4_MAX_BITLEN;
- memcpy(&(ip->u.prefix4),
- &(evp->prefix.ip.ip),
+ memcpy(&(ip->u.prefix4), &(evp->prefix.ip.ip),
IPV4_MAX_BYTELEN);
} else if (IS_EVPN_PREFIX_IPADDR_V6(evp)) {
ip->family = AF_INET6;
ip->prefixlen = IPV6_MAX_BITLEN;
- memcpy(&(ip->u.prefix6),
- &(evp->prefix.ip.ip),
+ memcpy(&(ip->u.prefix6), &(evp->prefix.ip.ip),
IPV6_MAX_BYTELEN);
}
}
p->prefix.ip.ipaddr_v4 = originator_ip;
}
-static inline int advertise_type5_routes(struct bgp *bgp_vrf,
- afi_t afi)
+static inline int advertise_type5_routes(struct bgp *bgp_vrf, afi_t afi)
{
if (!bgp_vrf->l3vni)
return 0;
- if (afi == AFI_IP &&
- CHECK_FLAG(bgp_vrf->vrf_flags, BGP_VRF_ADVERTISE_IPV4_IN_EVPN))
+ if (afi == AFI_IP
+ && CHECK_FLAG(bgp_vrf->vrf_flags, BGP_VRF_ADVERTISE_IPV4_IN_EVPN))
return 1;
- if (afi == AFI_IP6 &&
- CHECK_FLAG(bgp_vrf->vrf_flags, BGP_VRF_ADVERTISE_IPV6_IN_EVPN))
+ if (afi == AFI_IP6
+ && CHECK_FLAG(bgp_vrf->vrf_flags, BGP_VRF_ADVERTISE_IPV6_IN_EVPN))
return 1;
return 0;
}
-extern void evpn_rt_delete_auto(struct bgp*, vni_t, struct list*);
+extern void evpn_rt_delete_auto(struct bgp *, vni_t, struct list *);
extern void bgp_evpn_configure_export_rt_for_vrf(struct bgp *bgp_vrf,
struct ecommunity *ecomadd);
extern void bgp_evpn_unconfigure_export_rt_for_vrf(struct bgp *bgp_vrf,
};
#if defined(HAVE_CUMULUS)
-static void display_vrf_import_rt(struct vty *vty,
- struct vrf_irt_node *irt,
+static void display_vrf_import_rt(struct vty *vty, struct vrf_irt_node *irt,
json_object *json)
{
u_char *pnt;
json_object_array_add(
json_vrfs,
json_object_new_string(
- vrf_id_to_name(
- tmp_bgp_vrf->vrf_id)));
+ vrf_id_to_name(tmp_bgp_vrf->vrf_id)));
else
vty_out(vty, " %s\n",
vrf_id_to_name(tmp_bgp_vrf->vrf_id));
}
}
-static void show_vrf_import_rt_entry(struct hash_backet *backet,
- void *args[])
+static void show_vrf_import_rt_entry(struct hash_backet *backet, void *args[])
{
json_object *json = NULL;
struct vty *vty = NULL;
}
static void show_l3vni_entry(struct vty *vty, struct bgp *bgp,
- json_object *json)
+ json_object *json)
{
json_object *json_vni;
json_object *json_import_rtl;
json_vni, "rd",
prefix_rd2str(&bgp->vrf_prd, buf2, RD_ADDRSTRLEN));
} else {
- vty_out(vty, "%-1s %-10u %-4s %-21s",
- buf1, bgp->l3vni, "L3",
+ vty_out(vty, "%-1s %-10u %-4s %-21s", buf1, bgp->l3vni, "L3",
prefix_rd2str(&bgp->vrf_prd, buf2, RD_ADDRSTRLEN));
}
json_vni, "rd",
prefix_rd2str(&vpn->prd, buf2, sizeof(buf2)));
} else {
- vty_out(vty, "%-1s %-10u %-4s %-21s",
- buf1, vpn->vni, "L2",
+ vty_out(vty, "%-1s %-10u %-4s %-21s", buf1, vpn->vni, "L2",
prefix_rd2str(&vpn->prd, buf2, RD_ADDRSTRLEN));
}
return bgp_static_set_safi(
AFI_L2VPN, SAFI_EVPN, vty, argv[idx_ipv4_prefixlen]->arg,
- argv[idx_route_distinguisher]->arg, argv[idx_label]->arg,
- NULL,
+ argv[idx_route_distinguisher]->arg, argv[idx_label]->arg, NULL,
BGP_EVPN_IP_PREFIX_ROUTE, argv[idx_esi]->arg,
argv[idx_gwip]->arg, argv[idx_ethtag]->arg,
argv[idx_routermac]->arg);
/*
* Configure RD for VRF
*/
-static void evpn_configure_vrf_rd(struct bgp *bgp_vrf,
- struct prefix_rd *rd)
+static void evpn_configure_vrf_rd(struct bgp *bgp_vrf, struct prefix_rd *rd)
{
/* If we have already advertise type-5 routes with a diffrent RD, we
* have to delete and withdraw them firs
* Display import RT mapping to VRFs (vty handler)
* bgp_def: default bgp instance
*/
-static void evpn_show_vrf_import_rts(struct vty *vty,
- struct bgp *bgp_def,
+static void evpn_show_vrf_import_rts(struct vty *vty, struct bgp *bgp_def,
json_object *json)
{
void *args[2];
args[1] = json;
hash_iterate(bgp_def->vrf_import_rt_hash,
- (void (*)(struct hash_backet *, void *))
- show_vrf_import_rt_entry,
+ (void (*)(struct hash_backet *,
+ void *))show_vrf_import_rt_entry,
args);
}
if (!json) {
vty_out(vty, "Flags: * - Kernel\n");
vty_out(vty, " %-10s %-4s %-21s %-25s %-25s %-37s\n", "VNI",
- "Type", "RD", "Import RT",
- "Export RT", "Tenant VRF");
+ "Type", "RD", "Import RT", "Export RT", "Tenant VRF");
}
/* print all L2 VNIS */
/* print all L3 VNIs */
for (ALL_LIST_ELEMENTS_RO(bm->bgp, node, bgp_temp))
show_l3vni_entry(vty, bgp_temp, json);
-
}
/*
/*
* evpn - enable advertisement of default g/w
*/
-static void evpn_set_advertise_subnet(struct bgp *bgp,
- struct bgpevpn *vpn)
+static void evpn_set_advertise_subnet(struct bgp *bgp, struct bgpevpn *vpn)
{
if (vpn->advertise_subnet)
return;
/*
* evpn - disable advertisement of default g/w
*/
-static void evpn_unset_advertise_subnet(struct bgp *bgp,
- struct bgpevpn *vpn)
+static void evpn_unset_advertise_subnet(struct bgp *bgp, struct bgpevpn *vpn)
{
if (!vpn->advertise_subnet)
return;
if (!bgp_vrf)
return CMD_WARNING;
- if (!(advertise_type5_routes(bgp_vrf, AFI_IP) ||
- advertise_type5_routes(bgp_vrf, AFI_IP6))) {
+ if (!(advertise_type5_routes(bgp_vrf, AFI_IP)
+ || advertise_type5_routes(bgp_vrf, AFI_IP6))) {
vty_out(vty,
"%%Please enable ip prefix advertisement under l2vpn evpn in %s",
vrf_id_to_name(bgp_vrf->vrf_id));
if (!bgp_vrf->adv_cmd_rmap[afi][safi].name)
rmap_changed = 1;
else if (strcmp(argv[idx_rmap + 1]->arg,
- bgp_vrf->adv_cmd_rmap[afi][safi].name) != 0)
+ bgp_vrf->adv_cmd_rmap[afi][safi].name)
+ != 0)
rmap_changed = 1;
} else if (bgp_vrf->adv_cmd_rmap[afi][safi].name) {
rmap_changed = 1;
if (!rmap_changed && CHECK_FLAG(bgp_vrf->vrf_flags,
BGP_VRF_ADVERTISE_IPV4_IN_EVPN))
return CMD_WARNING;
- SET_FLAG(bgp_vrf->vrf_flags,
- BGP_VRF_ADVERTISE_IPV4_IN_EVPN);
+ SET_FLAG(bgp_vrf->vrf_flags, BGP_VRF_ADVERTISE_IPV4_IN_EVPN);
} else {
/* if we are already advertising ipv6 prefix as type-5
if (!rmap_changed && CHECK_FLAG(bgp_vrf->vrf_flags,
BGP_VRF_ADVERTISE_IPV6_IN_EVPN))
return CMD_WARNING;
- SET_FLAG(bgp_vrf->vrf_flags,
- BGP_VRF_ADVERTISE_IPV6_IN_EVPN);
+ SET_FLAG(bgp_vrf->vrf_flags, BGP_VRF_ADVERTISE_IPV6_IN_EVPN);
}
if (rmap_changed) {
/* set the route-map for advertise command */
if (ret && argv[idx_rmap + 1]->arg) {
bgp_vrf->adv_cmd_rmap[afi][safi].name =
- XSTRDUP(MTYPE_ROUTE_MAP_NAME,
- argv[idx_rmap + 1]->arg);
+ XSTRDUP(MTYPE_ROUTE_MAP_NAME, argv[idx_rmap + 1]->arg);
bgp_vrf->adv_cmd_rmap[afi][safi].map =
route_map_lookup_by_name(argv[idx_rmap + 1]->arg);
}
? "Enabled"
: "Disabled");
json_object_string_add(json, "advertiseAllVnis",
- is_evpn_enabled()
- ? "Enabled"
- : "Disabled");
+ is_evpn_enabled() ? "Enabled"
+ : "Disabled");
json_object_int_add(json, "numVnis", num_vnis);
json_object_int_add(json, "numL2Vnis", num_l2vnis);
json_object_int_add(json, "numL3Vnis", num_l3vnis);
} else {
vty_out(vty, "Advertise Gateway Macip: %s\n",
bgp_def->advertise_gw_macip ? "Enabled"
- : "Disabled");
+ : "Disabled");
vty_out(vty, "Advertise All VNI flag: %s\n",
is_evpn_enabled() ? "Enabled" : "Disabled");
vty_out(vty, "Number of L2 VNIs: %u\n", num_l2vnis);
ALIAS_HIDDEN(show_bgp_l2vpn_evpn_summary, show_bgp_evpn_summary_cmd,
"show bgp evpn summary [json]", SHOW_STR BGP_STR EVPN_HELP_STR
- "Summary of BGP neighbor status\n"
- JSON_STR)
+ "Summary of BGP neighbor status\n" JSON_STR)
ALIAS_HIDDEN(show_bgp_l2vpn_evpn_route, show_bgp_evpn_route_cmd,
"show bgp evpn route [type <macip|multicast>]",
bgp = bgp_lookup_by_name(name);
if (!bgp) {
if (!uj)
- vty_out(vty, "BGP instance for VRF %s not found",
- name);
+ vty_out(vty, "BGP instance for VRF %s not found", name);
else {
json_object_string_add(json, "warning",
"BGP instance not found");
- vty_out(vty, "%s\n",
- json_object_to_json_string(json));
+ vty_out(vty, "%s\n", json_object_to_json_string(json));
json_object_free(json);
}
return CMD_WARNING;
if (!json) {
vty_out(vty, "BGP VRF: %s\n", name);
- vty_out(vty, " Local-Ip: %s\n",
- inet_ntoa(bgp->originator_ip));
+ vty_out(vty, " Local-Ip: %s\n", inet_ntoa(bgp->originator_ip));
vty_out(vty, " L3-VNI: %u\n", bgp->l3vni);
vty_out(vty, " Rmac: %s\n",
prefix_mac2str(&bgp->rmac, buf, sizeof(buf)));
vty_out(vty, " VNI Filter: %s\n",
CHECK_FLAG(bgp->vrf_flags,
- BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY) ?
- "prefix-routes-only" : "none");
+ BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY)
+ ? "prefix-routes-only"
+ : "none");
vty_out(vty, " L2-VNI List:\n");
vty_out(vty, " ");
for (ALL_LIST_ELEMENTS_RO(bgp->l2vnis, node, vpn))
json_object_string_add(json, "local-ip",
inet_ntoa(bgp->originator_ip));
json_object_int_add(json, "l3vni", bgp->l3vni);
- json_object_string_add(json, "rmac",
- prefix_mac2str(&bgp->rmac, buf,
- sizeof(buf)));
- json_object_string_add(json, "vniFilter",
- CHECK_FLAG(bgp->vrf_flags,
- BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY)
- ? "prefix-routes-only" : "none");
+ json_object_string_add(
+ json, "rmac",
+ prefix_mac2str(&bgp->rmac, buf, sizeof(buf)));
+ json_object_string_add(
+ json, "vniFilter",
+ CHECK_FLAG(bgp->vrf_flags,
+ BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY)
+ ? "prefix-routes-only"
+ : "none");
/* list of l2vnis */
for (ALL_LIST_ELEMENTS_RO(bgp->l2vnis, node, vpn))
json_object_array_add(json_vnis,
/* export rts */
for (ALL_LIST_ELEMENTS_RO(bgp->vrf_export_rtl, node, ecom))
- json_object_array_add(json_export_rts,
- json_object_new_string(
- ecommunity_str(ecom)));
+ json_object_array_add(
+ json_export_rts,
+ json_object_new_string(ecommunity_str(ecom)));
json_object_object_add(json, "export-rts", json_export_rts);
/* import rts */
for (ALL_LIST_ELEMENTS_RO(bgp->vrf_import_rtl, node, ecom))
- json_object_array_add(json_import_rts,
- json_object_new_string(
- ecommunity_str(ecom)));
+ json_object_array_add(
+ json_import_rts,
+ json_object_new_string(ecommunity_str(ecom)));
json_object_object_add(json, "import-rts", json_import_rts);
json_object_string_add(
json, "rd",
prefix_rd2str(&bgp->vrf_prd, buf1, RD_ADDRSTRLEN));
-
}
if (uj) {
ecommunity_str(ecomadd);
/* Do nothing if we already have this import route-target */
- if (!bgp_evpn_rt_matches_existing(bgp->vrf_import_rtl,
- ecomadd))
+ if (!bgp_evpn_rt_matches_existing(bgp->vrf_import_rtl, ecomadd))
bgp_evpn_configure_import_rt_for_vrf(bgp, ecomadd);
}
ecommunity_str(ecomadd);
/* Do nothing if we already have this export route-target */
- if (!bgp_evpn_rt_matches_existing(bgp->vrf_export_rtl,
- ecomadd))
+ if (!bgp_evpn_rt_matches_existing(bgp->vrf_export_rtl, ecomadd))
bgp_evpn_configure_export_rt_for_vrf(bgp, ecomadd);
}
ecom)) {
ecom_str = ecommunity_ecom2str(
ecom, ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
- vty_out(vty, " route-target import %s\n",
- ecom_str);
+ vty_out(vty, " route-target import %s\n", ecom_str);
XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
}
}
ecom)) {
ecom_str = ecommunity_ecom2str(
ecom, ECOMMUNITY_FORMAT_ROUTE_MAP, 0);
- vty_out(vty, " route-target export %s\n",
- ecom_str);
+ vty_out(vty, " route-target export %s\n", ecom_str);
XFREE(MTYPE_ECOMMUNITY_STR, ecom_str);
}
}
UNSET_FLAG(peer->sflags, PEER_STATUS_NSF_MODE);
for (afi = AFI_IP; afi < AFI_MAX; afi++)
- for (safi = SAFI_UNICAST;
- safi <= SAFI_MPLS_VPN; safi++)
+ for (safi = SAFI_UNICAST; safi <= SAFI_MPLS_VPN;
+ safi++)
peer->nsf[afi][safi] = 0;
}
return 0;
}
- if (peer->bgp &&
- peer->bgp->vrf_id == VRF_UNKNOWN) {
+ if (peer->bgp && peer->bgp->vrf_id == VRF_UNKNOWN) {
if (bgp_debug_neighbor_events(peer))
zlog_err(
- "%s [FSM] In a VRF that is not initialised yet",
- peer->host);
+ "%s [FSM] In a VRF that is not initialised yet",
+ peer->host);
return -1;
}
}
if (other == peer)
- ret =
- 1; /* bgp_establish specific code when xfer_conn
- happens. */
+ ret = 1; /* bgp_establish specific code when xfer_conn
+ happens. */
/* Reset capability open status flag. */
if (!CHECK_FLAG(peer->sflags, PEER_STATUS_CAPABILITY_OPEN))
uint16_t status = 0;
uint32_t wpkt_quanta_old;
- wpkt_quanta_old =
- atomic_load_explicit(&peer->bgp->wpkt_quanta, memory_order_relaxed);
+ wpkt_quanta_old = atomic_load_explicit(&peer->bgp->wpkt_quanta,
+ memory_order_relaxed);
while (count < wpkt_quanta_old && (s = stream_fifo_head(peer->obuf))) {
int writenum;
/* EAGAIN or EWOULDBLOCK; come back later */
if (nbytes < 0 && ERRNO_IO_RETRY(errno)) {
SET_FLAG(status, BGP_IO_TRANS_ERR);
- /* Fatal error; tear down session */
+ /* Fatal error; tear down session */
} else if (nbytes < 0) {
zlog_err("%s [Error] bgp_read_packet error: %s", peer->host,
safe_strerror(errno));
BGP_EVENT_ADD(peer, TCP_fatal_error);
SET_FLAG(status, BGP_IO_FATAL_ERR);
- /* Received EOF / TCP session closed */
+ /* Received EOF / TCP session closed */
} else if (nbytes == 0) {
if (bgp_debug_neighbor_events(peer))
zlog_debug("%s [Event] BGP connection closed fd %d",
type);
bgp_notify_send_with_data(peer, BGP_NOTIFY_HEADER_ERR,
- BGP_NOTIFY_HEADER_BAD_MESTYPE,
- &type, 1);
+ BGP_NOTIFY_HEADER_BAD_MESTYPE, &type,
+ 1);
return false;
}
zlog_debug("%s bad message length - %d for %s",
peer->host, size,
type == 128 ? "ROUTE-REFRESH"
- : bgp_type_str[(int) type]);
+ : bgp_type_str[(int)type]);
}
uint16_t nsize = htons(size);
bgp_notify_send_with_data(peer, BGP_NOTIFY_HEADER_ERR,
BGP_NOTIFY_HEADER_BAD_MESLEN,
- (unsigned char *) &nsize, 2);
+ (unsigned char *)&nsize, 2);
return false;
}
struct lcommunity *lcom2)
{
if (lcom1->val)
- lcom1->val =
- XREALLOC(MTYPE_LCOMMUNITY_VAL, lcom1->val,
- lcom_length(lcom1) + lcom_length(lcom2));
+ lcom1->val = XREALLOC(MTYPE_LCOMMUNITY_VAL, lcom1->val,
+ lcom_length(lcom1) + lcom_length(lcom2));
else
- lcom1->val =
- XMALLOC(MTYPE_LCOMMUNITY_VAL,
- lcom_length(lcom1) + lcom_length(lcom2));
+ lcom1->val = XMALLOC(MTYPE_LCOMMUNITY_VAL,
+ lcom_length(lcom1) + lcom_length(lcom2));
memcpy(lcom1->val + lcom_length(lcom1), lcom2->val, lcom_length(lcom2));
lcom1->size += lcom2->size;
const struct lcommunity *lcom2 = arg2;
return (lcom1->size == lcom2->size
- && memcmp(lcom1->val, lcom2->val, lcom_length(lcom1))
- == 0);
+ && memcmp(lcom1->val, lcom2->val, lcom_length(lcom1)) == 0);
}
/* Return communities hash. */
/* Initialize Large Comminities related hash. */
void lcommunity_init(void)
{
- lcomhash = hash_create(lcommunity_hash_make,
- lcommunity_cmp,
+ lcomhash = hash_create(lcommunity_hash_make, lcommunity_cmp,
"BGP lcommunity hash");
}
/* Every community on com2 needs to be on com1 for this to match */
while (i < lcom1->size && j < lcom2->size) {
- if (memcmp(lcom1->val + (i * LCOMMUNITY_SIZE), lcom2->val + (j * LCOMMUNITY_SIZE),
- LCOMMUNITY_SIZE)
+ if (memcmp(lcom1->val + (i * LCOMMUNITY_SIZE),
+ lcom2->val + (j * LCOMMUNITY_SIZE), LCOMMUNITY_SIZE)
== 0)
j++;
i++;
if (lcom->size > 0)
lcom->val =
- XREALLOC(MTYPE_LCOMMUNITY_VAL, lcom->val,
- lcom_length(lcom));
+ XREALLOC(MTYPE_LCOMMUNITY_VAL,
+ lcom->val, lcom_length(lcom));
else {
XFREE(MTYPE_LCOMMUNITY_VAL, lcom->val);
lcom->val = NULL;
static int retain_mode = 0;
/* privileges */
-static zebra_capabilities_t _caps_p[] = {
- ZCAP_BIND, ZCAP_NET_RAW, ZCAP_NET_ADMIN, ZCAP_SYS_ADMIN
-};
+static zebra_capabilities_t _caps_p[] = {ZCAP_BIND, ZCAP_NET_RAW,
+ ZCAP_NET_ADMIN, ZCAP_SYS_ADMIN};
struct zebra_privs_t bgpd_privs = {
#if defined(FRR_USER) && defined(FRR_GROUP)
&bi2->attr->mp_nexthop_global);
break;
case BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL:
- addr1 = (bi1->attr->mp_nexthop_prefer_global) ?
- bi1->attr->mp_nexthop_global
- : bi1->attr->mp_nexthop_local;
- addr2 = (bi2->attr->mp_nexthop_prefer_global) ?
- bi2->attr->mp_nexthop_global
- : bi2->attr->mp_nexthop_local;
-
- if (!bi1->attr->mp_nexthop_prefer_global &&
- !bi2->attr->mp_nexthop_prefer_global)
- compare = !bgp_interface_same(bi1->peer->ifp, bi2->peer->ifp);
+ addr1 = (bi1->attr->mp_nexthop_prefer_global)
+ ? bi1->attr->mp_nexthop_global
+ : bi1->attr->mp_nexthop_local;
+ addr2 = (bi2->attr->mp_nexthop_prefer_global)
+ ? bi2->attr->mp_nexthop_global
+ : bi2->attr->mp_nexthop_local;
+
+ if (!bi1->attr->mp_nexthop_prefer_global
+ && !bi2->attr->mp_nexthop_prefer_global)
+ compare = !bgp_interface_same(
+ bi1->peer->ifp, bi2->peer->ifp);
if (!compare)
compare = IPV6_ADDR_CMP(&addr1, &addr2);
{
char *name = NULL;
- if ((peer->bgp->vrf_id == VRF_DEFAULT) &&
- !peer->ifname && !peer->conf_if)
+ if ((peer->bgp->vrf_id == VRF_DEFAULT) && !peer->ifname
+ && !peer->conf_if)
return NULL;
if (peer->su.sa.sa_family != AF_INET
listener->fd = sock;
/* this socket needs a change of ns. record bgp back pointer */
- if (bgp->vrf_id != VRF_DEFAULT &&
- vrf_is_mapped_on_netns(bgp->vrf_id))
+ if (bgp->vrf_id != VRF_DEFAULT && vrf_is_mapped_on_netns(bgp->vrf_id))
listener->bgp = bgp;
memcpy(&listener->su, sa, salen);
if (bgpd_privs.change(ZPRIVS_RAISE))
zlog_err("Can't raise privileges");
- ret = vrf_getaddrinfo(address, port_str, &req,
- &ainfo_save, bgp->vrf_id);
+ ret = vrf_getaddrinfo(address, port_str, &req, &ainfo_save,
+ bgp->vrf_id);
if (bgpd_privs.change(ZPRIVS_LOWER))
zlog_err("Can't lower privileges");
if (ret != 0) {
if (bgpd_privs.change(ZPRIVS_RAISE))
zlog_err("Can't raise privileges");
sock = vrf_socket(ainfo->ai_family, ainfo->ai_socktype,
- ainfo->ai_protocol, bgp->vrf_id,
- NULL);
+ ainfo->ai_protocol, bgp->vrf_id, NULL);
if (bgpd_privs.change(ZPRIVS_LOWER))
zlog_err("Can't lower privileges");
if (sock < 0) {
* ttl=255 */
sockopt_ttl(ainfo->ai_family, sock, MAXTTL);
- ret = bgp_listener(sock, ainfo->ai_addr,
- ainfo->ai_addrlen, bgp);
+ ret = bgp_listener(sock, ainfo->ai_addr, ainfo->ai_addrlen,
+ bgp);
if (ret == 0)
++count;
else
}
freeaddrinfo(ainfo_save);
if (count == 0) {
- zlog_err("%s: no usable addresses please check other programs usage of specified port %d",
- __func__, port);
+ zlog_err(
+ "%s: no usable addresses please check other programs usage of specified port %d",
+ __func__, port);
zlog_err("%s: Program cannot continue", __func__);
exit(-1);
}
void bgp_tip_hash_init(struct bgp *bgp)
{
- bgp->tip_hash = hash_create(bgp_tip_hash_key_make,
- bgp_tip_hash_cmp,
+ bgp->tip_hash = hash_create(bgp_tip_hash_key_make, bgp_tip_hash_cmp,
"BGP TIP hash");
}
void bgp_address_init(struct bgp *bgp)
{
- bgp->address_hash = hash_create(bgp_address_hash_key_make,
- bgp_address_hash_cmp,
- "BGP Address Hash");
+ bgp->address_hash =
+ hash_create(bgp_address_hash_key_make, bgp_address_hash_cmp,
+ "BGP Address Hash");
}
void bgp_address_destroy(struct bgp *bgp)
rn1 = rn2 = NULL;
bgp = SUBGRP_INST(subgrp);
- rn1 = bgp_node_match(bgp->connected_table[AFI_IP],
- &np);
+ rn1 = bgp_node_match(bgp->connected_table[AFI_IP], &np);
if (!rn1)
return 0;
- SUBGRP_FOREACH_PEER(subgrp, paf) {
+ SUBGRP_FOREACH_PEER (subgrp, paf) {
p.u.prefix4 = paf->peer->su.sin.sin_addr;
- rn2 = bgp_node_match(bgp->connected_table[AFI_IP],
- &p);
+ rn2 = bgp_node_match(bgp->connected_table[AFI_IP], &p);
if (rn1 == rn2) {
bgp_unlock_node(rn1);
bgp_unlock_node(rn2);
return 0;
}
-static void bgp_show_nexthops_detail(struct vty *vty,
- struct bgp *bgp,
+static void bgp_show_nexthops_detail(struct vty *vty, struct bgp *bgp,
struct bgp_nexthop_cache *bnc)
{
char buf[PREFIX2STR_BUFFER];
switch (nexthop->type) {
case NEXTHOP_TYPE_IPV6:
vty_out(vty, " gate %s\n",
- inet_ntop(AF_INET6, &nexthop->gate.ipv6,
- buf, sizeof(buf)));
+ inet_ntop(AF_INET6, &nexthop->gate.ipv6, buf,
+ sizeof(buf)));
break;
case NEXTHOP_TYPE_IPV6_IFINDEX:
vty_out(vty, " gate %s, if %s\n",
- inet_ntop(AF_INET6, &nexthop->gate.ipv6,
- buf, sizeof(buf)),
- ifindex2ifname(nexthop->ifindex,
- bgp->vrf_id));
+ inet_ntop(AF_INET6, &nexthop->gate.ipv6, buf,
+ sizeof(buf)),
+ ifindex2ifname(nexthop->ifindex, bgp->vrf_id));
break;
case NEXTHOP_TYPE_IPV4:
vty_out(vty, " gate %s\n",
- inet_ntop(AF_INET, &nexthop->gate.ipv4,
- buf, sizeof(buf)));
+ inet_ntop(AF_INET, &nexthop->gate.ipv4, buf,
+ sizeof(buf)));
break;
case NEXTHOP_TYPE_IFINDEX:
vty_out(vty, " if %s\n",
- ifindex2ifname(nexthop->ifindex,
- bgp->vrf_id));
+ ifindex2ifname(nexthop->ifindex, bgp->vrf_id));
break;
case NEXTHOP_TYPE_IPV4_IFINDEX:
vty_out(vty, " gate %s, if %s\n",
- inet_ntop(AF_INET, &nexthop->gate.ipv4,
- buf, sizeof(buf)),
- ifindex2ifname(nexthop->ifindex,
- bgp->vrf_id));
+ inet_ntop(AF_INET, &nexthop->gate.ipv4, buf,
+ sizeof(buf)),
+ ifindex2ifname(nexthop->ifindex, bgp->vrf_id));
break;
case NEXTHOP_TYPE_BLACKHOLE:
vty_out(vty, " blackhole\n");
break;
default:
- vty_out(vty,
- " invalid nexthop type %u\n",
+ vty_out(vty, " invalid nexthop type %u\n",
nexthop->type);
}
}
bgp_show_nexthops_detail(vty, bgp, bnc);
- } else{
+ } else {
vty_out(vty, " %s invalid\n",
inet_ntop(rn->p.family,
&rn->p.u.prefix, buf,
return;
p = &(bnc->node->p);
- if ((command == ZEBRA_NEXTHOP_REGISTER ||
- command == ZEBRA_IMPORT_ROUTE_REGISTER) &&
- (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_CONNECTED)
- || CHECK_FLAG(bnc->flags, BGP_STATIC_ROUTE_EXACT_MATCH)))
+ if ((command == ZEBRA_NEXTHOP_REGISTER
+ || command == ZEBRA_IMPORT_ROUTE_REGISTER)
+ && (CHECK_FLAG(bnc->flags, BGP_NEXTHOP_CONNECTED)
+ || CHECK_FLAG(bnc->flags, BGP_STATIC_ROUTE_EXACT_MATCH)))
exact_match = true;
- ret = zclient_send_rnh(zclient, command, p,
- exact_match, bnc->bgp->vrf_id);
+ ret = zclient_send_rnh(zclient, command, p, exact_match,
+ bnc->bgp->vrf_id);
/* TBD: handle the failure */
if (ret < 0)
zlog_warn("sendmsg_nexthop: zclient_send_message() failed");
* Non-MP IPv4/Unicast EoR is a completely empty UPDATE
* and MP EoR should have only an empty MP_UNREACH
*/
- if ((!update_len && !withdraw_len &&
- nlris[NLRI_MP_UPDATE].length == 0) ||
- (attr_parse_ret == BGP_ATTR_PARSE_EOR)) {
+ if ((!update_len && !withdraw_len && nlris[NLRI_MP_UPDATE].length == 0)
+ || (attr_parse_ret == BGP_ATTR_PARSE_EOR)) {
afi_t afi = 0;
safi_t safi;
: NULL);
/* First update is deferred until ORF or ROUTE-REFRESH is received */
- if (onlypeer
- && CHECK_FLAG(onlypeer->af_sflags[afi][safi],
- PEER_STATUS_ORF_WAIT_REFRESH))
+ if (onlypeer && CHECK_FLAG(onlypeer->af_sflags[afi][safi],
+ PEER_STATUS_ORF_WAIT_REFRESH))
return 0;
memset(&attr, 0, sizeof(struct attr));
/* advertise/withdraw type-5 routes */
if ((afi == AFI_IP || afi == AFI_IP6) && (safi == SAFI_UNICAST)) {
- if (new_select &&
- (!new_select->extra || !new_select->extra->parent))
- bgp_evpn_advertise_type5_route(bgp, &rn->p,
- new_select->attr,
- afi, safi);
- else if (old_select &&
- (!old_select->extra || !old_select->extra->parent))
+ if (new_select
+ && (!new_select->extra || !new_select->extra->parent))
+ bgp_evpn_advertise_type5_route(
+ bgp, &rn->p, new_select->attr, afi, safi);
+ else if (old_select
+ && (!old_select->extra || !old_select->extra->parent))
bgp_evpn_withdraw_type5_route(bgp, &rn->p, afi, safi);
}
bgp_damp_reuse_time_vty(vty, binfo, timebuf, BGP_UPTIME_LEN,
use_json, json);
else
- vty_out(vty, "%s ",
- bgp_damp_reuse_time_vty(vty, binfo, timebuf,
- BGP_UPTIME_LEN, use_json,
- json));
+ vty_out(vty, "%s ", bgp_damp_reuse_time_vty(vty, binfo, timebuf,
+ BGP_UPTIME_LEN,
+ use_json, json));
/* Print attribute */
attr = binfo->attr;
peer_uptime(bdi->start_time, timebuf, BGP_UPTIME_LEN, use_json,
json);
else
- vty_out(vty, "%s ",
- peer_uptime(bdi->start_time, timebuf, BGP_UPTIME_LEN, 0,
- NULL));
+ vty_out(vty, "%s ", peer_uptime(bdi->start_time, timebuf,
+ BGP_UPTIME_LEN, 0, NULL));
if (CHECK_FLAG(binfo->flags, BGP_INFO_DAMPED)
&& !CHECK_FLAG(binfo->flags, BGP_INFO_HISTORY)) {
}
if (!use_json && header) {
- vty_out(vty,
- "BGP table version is %" PRIu64
- ", local router ID is %s\n",
+ vty_out(vty, "BGP table version is %" PRIu64
+ ", local router ID is %s\n",
table->version,
inet_ntoa(bgp->router_id));
vty_out(vty, BGP_SHOW_SCODE_HEADER);
if (display)
json_object_object_add(json, "paths", json_paths);
- vty_out(vty, "%s\n",
- json_object_to_json_string_ext(
- json, JSON_C_TO_STRING_PRETTY));
+ vty_out(vty, "%s\n", json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
} else {
if (!display) {
json, "recommended",
"Please report this bug, with the above command output");
}
- vty_out(vty, "%s\n",
- json_object_to_json_string_ext(
- json, JSON_C_TO_STRING_PRETTY));
+ vty_out(vty, "%s\n", json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
} else {
"bgpOriginatingDefaultNetwork",
"0.0.0.0");
} else {
- vty_out(vty,
- "BGP table version is %" PRIu64
- ", local router ID is %s\n",
+ vty_out(vty, "BGP table version is %" PRIu64
+ ", local router ID is %s\n",
table->version, inet_ntoa(bgp->router_id));
vty_out(vty, BGP_SHOW_SCODE_HEADER);
vty_out(vty, BGP_SHOW_OCODE_HEADER);
output_count);
}
if (use_json) {
- vty_out(vty, "%s\n",
- json_object_to_json_string_ext(
- json, JSON_C_TO_STRING_PRETTY));
+ vty_out(vty, "%s\n", json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
}
}
struct in6_addr addr6;
} un; /* cached un address */
time_t create_time;
- struct
- prefix
- aux_prefix; /* AFI_L2VPN: the IP addr,
- if family set */
+ struct prefix aux_prefix; /* AFI_L2VPN: the IP addr,
+ if family set */
} import;
} vnc;
/* Route map commands for evpn route-type matching. */
struct route_map_rule_cmd route_match_evpn_route_type_cmd = {
"evpn route-type", route_match_evpn_route_type,
- route_match_evpn_route_type_compile,
- route_match_evpn_route_type_free};
+ route_match_evpn_route_type_compile, route_match_evpn_route_type_free};
/* `match local-preference LOCAL-PREF' */
/* for type5 command route-maps */
FOREACH_AFI_SAFI (afi, safi) {
- if (bgp->adv_cmd_rmap[afi][safi].name &&
- strcmp(rmap_name, bgp->adv_cmd_rmap[afi][safi].name) == 0) {
+ if (bgp->adv_cmd_rmap[afi][safi].name
+ && strcmp(rmap_name, bgp->adv_cmd_rmap[afi][safi].name)
+ == 0) {
if (BGP_DEBUG(zebra, ZEBRA))
zlog_debug(
- "Processing route_map %s update on advertise type5 route command",
- rmap_name);
+ "Processing route_map %s update on advertise type5 route command",
+ rmap_name);
bgp_evpn_withdraw_type5_routes(bgp, afi, safi);
bgp_evpn_advertise_type5_routes(bgp, afi, safi);
}
/*
* BGP RPKI
* Copyright (C) 2013 Michael Mester (m.mester@fu-berlin.de), for FU Berlin
- * Copyright (C) 2014-2017 Andreas Reuter (andreas.reuter@fu-berlin.de), for FU Berlin
- * Copyright (C) 2016-2017 Colin Sames (colin.sames@haw-hamburg.de), for HAW Hamburg
- * Copyright (C) 2017 Marcel Röthke (marcel.roethke@haw-hamburg.de), for HAW Hamburg
+ * Copyright (C) 2014-2017 Andreas Reuter (andreas.reuter@fu-berlin.de), for FU
+ * Berlin
+ * Copyright (C) 2016-2017 Colin Sames (colin.sames@haw-hamburg.de), for HAW
+ * Hamburg
+ * Copyright (C) 2017 Marcel Röthke (marcel.roethke@haw-hamburg.de), for HAW
+ * Hamburg
*
* This file is part of FRRouting.
*
#define RPKI_OUTPUT_STRING "Control rpki specific settings\n"
struct cache {
- enum { TCP, SSH } type;
- struct tr_socket *tr_socket;
- union {
+ enum { TCP, SSH } type;
+ struct tr_socket *tr_socket;
+ union {
struct tr_tcp_config *tcp_config;
struct tr_ssh_config *ssh_config;
- } tr_config;
- struct rtr_socket *rtr_socket;
- uint8_t preference;
+ } tr_config;
+ struct rtr_socket *rtr_socket;
+ uint8_t preference;
};
enum return_values { SUCCESS = 0, ERROR = -1 };
static void free_cache(struct cache *cache);
static struct rtr_mgr_group *get_groups(void);
#if defined(FOUND_SSH)
-static int add_ssh_cache(const char *host,
- const unsigned int port,
- const char *username,
- const char *client_privkey_path,
+static int add_ssh_cache(const char *host, const unsigned int port,
+ const char *username, const char *client_privkey_path,
const char *client_pubkey_path,
const char *server_pubkey_path,
const uint8_t preference);
#endif
static struct rtr_socket *create_rtr_socket(struct tr_socket *tr_socket);
static struct cache *find_cache(const uint8_t preference);
-static int add_tcp_cache(const char *host,
- const char *port,
+static int add_tcp_cache(const char *host, const char *port,
const uint8_t preference);
static void print_record(const struct pfx_record *record, void *data);
static int is_synchronized(void);
static int is_running(void);
static void route_match_free(void *rule);
-static route_map_result_t route_match(void *rule,
- struct prefix *prefix,
- route_map_object_t type,
- void *object);
+static route_map_result_t route_match(void *rule, struct prefix *prefix,
+ route_map_object_t type, void *object);
static void *route_match_compile(const char *arg);
static struct rtr_mgr_config *rtr_config;
static unsigned int initial_synchronisation_timeout;
static struct cmd_node rpki_node = {RPKI_NODE, "%s(config-rpki)# ", 1};
-static struct route_map_rule_cmd route_match_rpki_cmd = {"rpki", route_match,
- route_match_compile,
- route_match_free};
+static struct route_map_rule_cmd route_match_rpki_cmd = {
+ "rpki", route_match, route_match_compile, route_match_free};
static void *malloc_wrapper(size_t size)
{
struct prefix *prefix);
static route_map_result_t route_match(void *rule, struct prefix *prefix,
- route_map_object_t type,
- void *object)
+ route_map_object_t type, void *object)
{
int *rpki_status = rule;
struct bgp_info *bgp_info;
rtr_is_running = 0;
cache_list = list_new();
- cache_list->del = (void (*)(void *)) &free_cache;
+ cache_list->del = (void (*)(void *)) & free_cache;
polling_period = POLLING_PERIOD_DEFAULT;
expire_interval = EXPIRE_INTERVAL_DEFAULT;
static int bgp_rpki_module_init(void)
{
- lrtr_set_alloc_functions(malloc_wrapper,
- realloc_wrapper,
- free_wrapper);
+ lrtr_set_alloc_functions(malloc_wrapper, realloc_wrapper, free_wrapper);
hook_register(frr_late_init, bgp_rpki_init);
hook_register(frr_early_fini, &bgp_rpki_fini);
struct rtr_mgr_group *groups = get_groups();
ret = rtr_mgr_init(&rtr_config, groups, groups_len, polling_period,
- expire_interval, retry_interval,
- NULL, NULL, NULL, NULL);
+ expire_interval, retry_interval, NULL, NULL, NULL,
+ NULL);
if (ret == RTR_ERROR) {
RPKI_DEBUG("Init rtr_mgr failed.");
return ERROR;
if (as_segment->type == AS_SEQUENCE) {
// Get rightmost asn
as_number = as_segment->as[as_segment->length - 1];
- } else if (as_segment->type == AS_CONFED_SEQUENCE ||
- as_segment->type == AS_CONFED_SET) {
+ } else if (as_segment->type == AS_CONFED_SEQUENCE
+ || as_segment->type == AS_CONFED_SET) {
// Set own as number
as_number = peer->bgp->as;
} else {
listnode_add(cache_list, cache);
- if (rtr_is_running &&
- rtr_mgr_add_group(rtr_config, &group) != RTR_SUCCESS) {
+ if (rtr_is_running
+ && rtr_mgr_add_group(rtr_config, &group) != RTR_SUCCESS) {
return ERROR;
}
return SUCCESS;
}
-static int add_tcp_cache(const char *host,
- const char *port,
+static int add_tcp_cache(const char *host, const char *port,
const uint8_t preference)
{
struct rtr_socket *rtr_socket;
}
#if defined(FOUND_SSH)
-static int add_ssh_cache(const char *host,
- const unsigned int port,
- const char *username,
- const char *client_privkey_path,
+static int add_ssh_cache(const char *host, const unsigned int port,
+ const char *username, const char *client_privkey_path,
const char *client_pubkey_path,
const char *server_pubkey_path,
const uint8_t preference)
ssh_config->bindaddr = NULL;
ssh_config->username = XSTRDUP(MTYPE_BGP_RPKI_CACHE, username);
- ssh_config->client_privkey_path = XSTRDUP(
- MTYPE_BGP_RPKI_CACHE, client_privkey_path);
+ ssh_config->client_privkey_path =
+ XSTRDUP(MTYPE_BGP_RPKI_CACHE, client_privkey_path);
ssh_config->server_hostkey_path =
XSTRDUP(MTYPE_BGP_RPKI_CACHE, server_pubkey_path);
static void free_cache(struct cache *cache)
{
if (cache->type == TCP) {
- XFREE(MTYPE_BGP_RPKI_CACHE,
- cache->tr_config.tcp_config->host);
- XFREE(MTYPE_BGP_RPKI_CACHE,
- cache->tr_config.tcp_config->port);
+ XFREE(MTYPE_BGP_RPKI_CACHE, cache->tr_config.tcp_config->host);
+ XFREE(MTYPE_BGP_RPKI_CACHE, cache->tr_config.tcp_config->port);
XFREE(MTYPE_BGP_RPKI_CACHE, cache->tr_config.tcp_config);
}
#if defined(FOUND_SSH)
else {
- XFREE(MTYPE_BGP_RPKI_CACHE,
- cache->tr_config.ssh_config->host);
+ XFREE(MTYPE_BGP_RPKI_CACHE, cache->tr_config.ssh_config->host);
XFREE(MTYPE_BGP_RPKI_CACHE,
cache->tr_config.ssh_config->username);
XFREE(MTYPE_BGP_RPKI_CACHE,
#endif
case TCP:
tcp_config = cache->tr_config.tcp_config;
- vty_out(vty,
- " rpki cache %s %s ",
- tcp_config->host,
- tcp_config->port);
+ vty_out(vty, " rpki cache %s %s ",
+ tcp_config->host, tcp_config->port);
break;
#if defined(FOUND_SSH)
case SSH:
ssh_config = cache->tr_config.ssh_config;
- vty_out(vty,
- " rpki cache %s %u %s %s %s ",
- ssh_config->host,
- ssh_config->port,
+ vty_out(vty, " rpki cache %s %u %s %s %s ",
+ ssh_config->host, ssh_config->port,
ssh_config->username,
ssh_config->client_privkey_path,
- ssh_config->server_hostkey_path
- != NULL
+ ssh_config->server_hostkey_path != NULL
? ssh_config
->server_hostkey_path
: " ");
"start rpki support\n")
{
if (listcount(cache_list) == 0)
- vty_out(vty, "Could not start rpki because no caches are configured\n");
+ vty_out(vty,
+ "Could not start rpki because no caches are configured\n");
if (!is_running()) {
if (start() == ERROR) {
// use ssh connection
if (ssh_uname) {
#if defined(FOUND_SSH)
- return_value = add_ssh_cache(
- cache, sshport, ssh_uname, ssh_privkey, ssh_pubkey,
- server_pubkey, preference);
+ return_value =
+ add_ssh_cache(cache, sshport, ssh_uname, ssh_privkey,
+ ssh_pubkey, server_pubkey, preference);
#else
vty_out(vty,
"ssh sockets are not supported. "
struct cache *cache;
for (ALL_LIST_ELEMENTS_RO(cache_list, cache_node, cache)) {
- vty_out(vty,
- "host: %s port: %s\n",
+ vty_out(vty, "host: %s port: %s\n",
cache->tr_config.tcp_config->host,
cache->tr_config.tcp_config->port);
}
struct cache *cache;
for (ALL_LIST_ELEMENTS_RO(cache_list, cache_node, cache)) {
- vty_out(vty,
- "host: %s port: %s\n",
+ vty_out(vty, "host: %s port: %s\n",
cache->tr_config.tcp_config->host,
cache->tr_config.tcp_config->port);
}
return CMD_SUCCESS;
}
vty_out(vty, "Connected to group %d\n", group->preference);
- for (ALL_LIST_ELEMENTS_RO(cache_list, cache_node,
- cache)) {
+ for (ALL_LIST_ELEMENTS_RO(cache_list, cache_node, cache)) {
if (cache->preference == group->preference) {
struct tr_tcp_config *tcp_config;
#if defined(FOUND_SSH)
switch (cache->type) {
case TCP:
tcp_config =
- cache->tr_config
- .tcp_config;
+ cache->tr_config.tcp_config;
vty_out(vty,
"rpki tcp cache %s %s pref %hhu\n",
tcp_config->host,
#if defined(FOUND_SSH)
case SSH:
ssh_config =
- cache->tr_config
- .ssh_config;
+ cache->tr_config.ssh_config;
vty_out(vty,
"rpki ssh cache %s %u pref %hhu\n",
ssh_config->host,
for (i = 0; i < cmd_vector->active; ++i) {
struct cmd_element *cmd = vector_lookup(cmd_vector, i);
- if (strcmp(cmd->string, "exit") == 0 ||
- strcmp(cmd->string, "quit") == 0 ||
- strcmp(cmd->string, "end") == 0) {
+ if (strcmp(cmd->string, "exit") == 0
+ || strcmp(cmd->string, "quit") == 0
+ || strcmp(cmd->string, "end") == 0) {
uninstall_element(RPKI_NODE, cmd);
}
}
static void install_cli_commands(void)
{
- //TODO: make config write work
+ // TODO: make config write work
install_node(&rpki_node, &config_write);
install_default(RPKI_NODE);
overwrite_exit_commands();
FRR_MODULE_SETUP(.name = "bgpd_rpki", .version = "0.3.6",
.description = "Enable RPKI support for FRR.",
- .init = bgp_rpki_module_init)
+ .init = bgp_rpki_module_init)
return SNMP_INTEGER(-1);
break;
case BGP4PATHATTRBEST: /* 13 */
- /* $FRR indent$ */
- /* clang-format off */
#define BGP4_PathAttrBest_false 1
#define BGP4_PathAttrBest_true 2
if (CHECK_FLAG(binfo->flags, BGP_INFO_SELECTED))
BGP_ADV_FIFO_INIT(&subgrp->sync->update);
BGP_ADV_FIFO_INIT(&subgrp->sync->withdraw);
BGP_ADV_FIFO_INIT(&subgrp->sync->withdraw_low);
- subgrp->hash = hash_create(baa_hash_key,
- baa_hash_cmp,
- "BGP SubGroup Hash");
+ subgrp->hash =
+ hash_create(baa_hash_key, baa_hash_cmp, "BGP SubGroup Hash");
/* We use a larger buffer for subgrp->work in the event that:
* - We RX a BGP_UPDATE where the attributes alone are just
AF_FOREACH (afid)
bgp->update_groups[afid] =
- hash_create(updgrp_hash_key_make,
- updgrp_hash_cmp,
+ hash_create(updgrp_hash_key_make, updgrp_hash_cmp,
"BGP Update Group Hash");
}
* the subgroup output queue into their own output queue. This action
* will trigger a write job on the I/O thread.
*/
- SUBGRP_FOREACH_PEER(subgrp, paf)
- if (paf->peer->status == Established)
- thread_add_timer_msec(bm->master, bgp_generate_updgrp_packets,
- paf->peer, 0,
- &paf->peer->t_generate_updgrp_packets);
+ SUBGRP_FOREACH_PEER (subgrp, paf)
+ if (paf->peer->status == Established)
+ thread_add_timer_msec(
+ bm->master, bgp_generate_updgrp_packets,
+ paf->peer, 0,
+ &paf->peer->t_generate_updgrp_packets);
}
int update_group_clear_update_dbg(struct update_group *updgrp, void *arg)
*/
#define SUBGRP_DECR_STAT(subgrp, stat) SUBGRP_INCR_STAT_BY(subgrp, stat, -1)
-
typedef int (*updgrp_walkcb)(struct update_group *updgrp, void *ctx);
/* really a private structure */
* Walk all subgroups in an update group.
*/
#define UPDGRP_FOREACH_SUBGRP(updgrp, subgrp) \
- LIST_FOREACH(subgrp, &((updgrp)->subgrps), updgrp_train)
+ LIST_FOREACH (subgrp, &((updgrp)->subgrps), updgrp_train)
#define UPDGRP_FOREACH_SUBGRP_SAFE(updgrp, subgrp, tmp_subgrp) \
- LIST_FOREACH_SAFE(subgrp, &((updgrp)->subgrps), updgrp_train, \
- tmp_subgrp)
+ LIST_FOREACH_SAFE (subgrp, &((updgrp)->subgrps), updgrp_train, \
+ tmp_subgrp)
#define SUBGRP_FOREACH_PEER(subgrp, paf) \
- LIST_FOREACH(paf, &(subgrp->peers), subgrp_train)
+ LIST_FOREACH (paf, &(subgrp->peers), subgrp_train)
#define SUBGRP_FOREACH_PEER_SAFE(subgrp, paf, temp_paf) \
- LIST_FOREACH_SAFE(paf, &(subgrp->peers), subgrp_train, temp_paf)
+ LIST_FOREACH_SAFE (paf, &(subgrp->peers), subgrp_train, temp_paf)
#define SUBGRP_FOREACH_ADJ(subgrp, adj) \
- TAILQ_FOREACH(adj, &(subgrp->adjq), subgrp_adj_train)
+ TAILQ_FOREACH (adj, &(subgrp->adjq), subgrp_adj_train)
#define SUBGRP_FOREACH_ADJ_SAFE(subgrp, adj, adj_temp) \
- TAILQ_FOREACH_SAFE(adj, &(subgrp->adjq), subgrp_adj_train, adj_temp)
+ TAILQ_FOREACH_SAFE (adj, &(subgrp->adjq), subgrp_adj_train, adj_temp)
/* Prototypes. */
/* bgp_updgrp.c */
space_remaining = STREAM_CONCAT_REMAIN(s, snlri, STREAM_SIZE(s))
- BGP_MAX_PACKET_SIZE_OVERFLOW;
- space_needed = BGP_NLRI_LENGTH + addpath_overhead +
- bgp_packet_mpattr_prefix_size(afi, safi, &rn->p);
+ space_needed =
+ BGP_NLRI_LENGTH + addpath_overhead
+ + bgp_packet_mpattr_prefix_size(afi, safi, &rn->p);
/* When remaining space can't include NLRI and it's length. */
if (space_remaining < space_needed)
space_remaining =
STREAM_CONCAT_REMAIN(s, snlri, STREAM_SIZE(s))
- BGP_MAX_PACKET_SIZE_OVERFLOW;
- space_needed = BGP_NLRI_LENGTH + addpath_overhead +
- bgp_packet_mpattr_prefix_size(afi, safi,
- &rn->p);
+ space_needed = BGP_NLRI_LENGTH + addpath_overhead
+ + bgp_packet_mpattr_prefix_size(
+ afi, safi, &rn->p);
/* If the attributes alone do not leave any room for
* NLRI then
}
if (listcount(bm->bgp) > 1) {
- vty_out(vty,
- "%% Please specify ASN and VRF\n");
+ vty_out(vty, "%% Please specify ASN and VRF\n");
return CMD_WARNING_CONFIG_FAILED;
}
}
}
if (listcount(bm->bgp) > 1) {
- vty_out(vty,
- "%% Please specify ASN and VRF\n");
+ vty_out(vty, "%% Please specify ASN and VRF\n");
return CMD_WARNING_CONFIG_FAILED;
}
}
ALIAS_HIDDEN(no_bgp_maxpaths, no_bgp_maxpaths_hidden_cmd,
- "no maximum-paths [" CMD_RANGE_STR(1, MULTIPATH_NUM) "]",
- NO_STR
+ "no maximum-paths [" CMD_RANGE_STR(1, MULTIPATH_NUM) "]", NO_STR
"Forward packets over multiple paths\n"
"Number of paths\n")
json_object_int_add(json, "totalVrfs", count);
- vty_out(vty, "%s\n",
- json_object_to_json_string_ext(
- json, JSON_C_TO_STRING_PRETTY));
+ vty_out(vty, "%s\n", json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
} else {
if (count)
/* Other attributes */
if ((count = community_count()))
vty_out(vty, "%ld BGP community entries, using %s of memory\n",
- count,
- mtype_memstr(memstrbuf, sizeof(memstrbuf),
- count * sizeof(struct community)));
+ count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
+ count * sizeof(struct community)));
if ((count = mtype_stats_alloc(MTYPE_ECOMMUNITY)))
vty_out(vty, "%ld BGP community entries, using %s of memory\n",
- count,
- mtype_memstr(memstrbuf, sizeof(memstrbuf),
- count * sizeof(struct ecommunity)));
+ count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
+ count * sizeof(struct ecommunity)));
if ((count = mtype_stats_alloc(MTYPE_LCOMMUNITY)))
vty_out(vty,
"%ld BGP large-community entries, using %s of memory\n",
- count,
- mtype_memstr(memstrbuf, sizeof(memstrbuf),
- count * sizeof(struct lcommunity)));
+ count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
+ count * sizeof(struct lcommunity)));
if ((count = mtype_stats_alloc(MTYPE_CLUSTER)))
vty_out(vty, "%ld Cluster lists, using %s of memory\n", count,
count * sizeof(struct hash_backet)));
if ((count = mtype_stats_alloc(MTYPE_BGP_REGEXP)))
vty_out(vty, "%ld compiled regexes, using %s of memory\n",
- count,
- mtype_memstr(memstrbuf, sizeof(memstrbuf),
- count * sizeof(regex_t)));
+ count, mtype_memstr(memstrbuf, sizeof(memstrbuf),
+ count * sizeof(regex_t)));
return CMD_SUCCESS;
}
json, "peerGroupCount", ents);
json_object_int_add(
json, "peerGroupMemory",
- ents
- * sizeof(struct
- peer_group));
+ ents * sizeof(struct
+ peer_group));
}
if (CHECK_FLAG(bgp->af_flags[afi][safi],
vty_out(vty,
"RIB entries %ld, using %s of memory\n",
ents,
- mtype_memstr(
- memstrbuf, sizeof(memstrbuf),
- ents
- * sizeof(struct
- bgp_node)));
+ mtype_memstr(memstrbuf,
+ sizeof(memstrbuf),
+ ents * sizeof(struct
+ bgp_node)));
/* Peer related usage */
ents = listcount(bgp->peer);
mtype_memstr(
memstrbuf,
sizeof(memstrbuf),
- ents
- * sizeof(struct
- peer_group)));
+ ents * sizeof(struct
+ peer_group)));
if (CHECK_FLAG(bgp->af_flags[afi][safi],
BGP_CONFIG_DAMPENING))
bgp_show_bestpath_json(bgp, json);
- vty_out(vty, "%s\n",
- json_object_to_json_string_ext(
- json, JSON_C_TO_STRING_PRETTY));
+ vty_out(vty, "%s\n", json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
} else {
if (count)
paf = peer_af_find(p, afi, safi);
if (paf && PAF_SUBGRP(paf)) {
- vty_out(vty,
- " Update group %" PRIu64 ", subgroup %" PRIu64
- "\n",
+ vty_out(vty, " Update group %" PRIu64
+ ", subgroup %" PRIu64 "\n",
PAF_UPDGRP(paf)->id, PAF_SUBGRP(paf)->id);
vty_out(vty, " Packet Queue length %d\n",
bpacket_queue_virtual_length(paf));
} else
vty_out(vty,
" Reduce the no. of prefix from %s, will restart in %ld seconds\n",
- p->host,
- thread_timer_remain_second(
- p->t_pmax_restart));
+ p->host, thread_timer_remain_second(
+ p->t_pmax_restart));
} else {
if (use_json)
json_object_boolean_true_add(
}
if (use_json) {
- vty_out(vty, "%s\n",
- json_object_to_json_string_ext(
- json, JSON_C_TO_STRING_PRETTY));
+ vty_out(vty, "%s\n", json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
} else {
vty_out(vty, "\n");
if (BGP_DEBUG(zebra, ZEBRA))
zlog_debug("Rx L3-VNI %s VRF %s VNI %u RMAC %s filter %s",
(cmd == ZEBRA_L3VNI_ADD) ? "add" : "del",
- vrf_id_to_name(vrf_id),
- l3vni,
+ vrf_id_to_name(vrf_id), l3vni,
prefix_mac2str(&rmac, buf, sizeof(buf)),
filter ? "prefix-routes-only" : "none");
/* handle socket creation or deletion, if necessary
* this is called for all new BGP instances
*/
-int bgp_handle_socket(struct bgp *bgp, struct vrf *vrf,
- vrf_id_t old_vrf_id, bool create)
+int bgp_handle_socket(struct bgp *bgp, struct vrf *vrf, vrf_id_t old_vrf_id,
+ bool create)
{
int ret = 0;
/* Create BGP server socket, if listen mode not disabled */
if (!bgp || bgp_option_check(BGP_OPT_NO_LISTEN))
return 0;
- if (bgp->name
- && bgp->inst_type == BGP_INSTANCE_TYPE_VRF
- && vrf) {
+ if (bgp->name && bgp->inst_type == BGP_INSTANCE_TYPE_VRF && vrf) {
/*
* suppress vrf socket
*/
* invoked without an instance
* when examining VRFs.
*/
- if ((bgp->inst_type == BGP_INSTANCE_TYPE_VRF) &&
- !vrf_is_mapped_on_netns(bgp->vrf_id))
+ if ((bgp->inst_type == BGP_INSTANCE_TYPE_VRF)
+ && !vrf_is_mapped_on_netns(bgp->vrf_id))
continue;
peer = hash_lookup(bgp->peerhash, &tmp_peer);
}
/* Track if addpath TX is in use */
- if (flag
- & (PEER_FLAG_ADDPATH_TX_ALL_PATHS
- | PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS)) {
+ if (flag & (PEER_FLAG_ADDPATH_TX_ALL_PATHS
+ | PEER_FLAG_ADDPATH_TX_BESTPATH_PER_AS)) {
bgp = peer->bgp;
addpath_tx_used = 0;
} else {
if (!peer_af_flag_check(peer, afi, safi,
PEER_FLAG_SEND_COMMUNITY)
- && (!g_peer
- || peer_af_flag_check(g_peer, afi, safi,
- PEER_FLAG_SEND_COMMUNITY))
+ && (!g_peer || peer_af_flag_check(g_peer, afi, safi,
+ PEER_FLAG_SEND_COMMUNITY))
&& !peer_af_flag_check(peer, afi, safi,
PEER_FLAG_SEND_EXT_COMMUNITY)
&& (!g_peer
PEER_FLAG_SEND_EXT_COMMUNITY))
&& !peer_af_flag_check(peer, afi, safi,
PEER_FLAG_SEND_LARGE_COMMUNITY)
- && (!g_peer
- || peer_af_flag_check(
- g_peer, afi, safi,
- PEER_FLAG_SEND_LARGE_COMMUNITY))) {
+ && (!g_peer || peer_af_flag_check(
+ g_peer, afi, safi,
+ PEER_FLAG_SEND_LARGE_COMMUNITY))) {
vty_out(vty, " no neighbor %s send-community all\n",
addr);
} else {
if (!peer_af_flag_check(peer, afi, safi,
PEER_FLAG_SEND_COMMUNITY)
- && (!g_peer
- || peer_af_flag_check(
- g_peer, afi, safi,
- PEER_FLAG_SEND_COMMUNITY))) {
+ && (!g_peer || peer_af_flag_check(
+ g_peer, afi, safi,
+ PEER_FLAG_SEND_COMMUNITY))) {
vty_out(vty,
" no neighbor %s send-community\n",
addr);
/* timer to dampen route map changes */
struct thread *t_rmap_update; /* Handle route map updates */
u_int32_t rmap_update_timer; /* Route map update timer */
- /* $FRR indent$ */
- /* clang-format off */
#define RMAP_DEFAULT_UPDATE_TIMER 5 /* disabled by default */
/* Id space for automatic RD derivation for an EVI/VRF */
*t_startup; /* start-up timer on only once at the beginning */
u_int32_t v_maxmed_onstartup; /* Duration of max-med on start-up */
- /* $FRR indent$ */
- /* clang-format off */
#define BGP_MAXMED_ONSTARTUP_UNCONFIGURED 0 /* 0 means off, its the default */
u_int32_t maxmed_onstartup_value; /* Max-med value when active on
start-up */
u_char maxmed_onstartup_over; /* Flag to make it effective only once */
u_char v_maxmed_admin; /* 1/0 if max-med administrative is on/off */
- /* $FRR indent$ */
- /* clang-format off */
#define BGP_MAXMED_ADMIN_UNCONFIGURED 0 /* Off by default */
u_int32_t maxmed_admin_value; /* Max-med value when administrative in on
*/
- /* $FRR indent$ */
- /* clang-format off */
#define BGP_MAXMED_VALUE_DEFAULT 4294967294 /* Maximum by default */
- u_char maxmed_active; /* 1/0 if max-med is active or not */
- u_int32_t maxmed_value; /* Max-med value when its active */
+ u_char maxmed_active; /* 1/0 if max-med is active or not */
+ u_int32_t maxmed_value; /* Max-med value when its active */
/* BGP update delay on startup */
struct thread *t_update_delay;
unsigned short port; /* Destination port for peer */
char *host; /* Printable address of the peer. */
union sockunion su; /* Sockunion address of the peer. */
- /* $FRR indent$ */
- /* clang-format off */
#define BGP_PEER_SU_UNSPEC(peer) (peer->su.sa.sa_family == AF_UNSPEC)
time_t uptime; /* Last Up/Down time */
time_t readtime; /* Last read time */
memory_order_relaxed)
/* Statistics field */
- _Atomic uint32_t open_in; /* Open message input count */
- _Atomic uint32_t open_out; /* Open message output count */
+ _Atomic uint32_t open_in; /* Open message input count */
+ _Atomic uint32_t open_out; /* Open message output count */
_Atomic uint32_t update_in; /* Update message input count */
_Atomic uint32_t update_out; /* Update message ouput count */
_Atomic time_t update_time; /* Update message received time. */
idx += 2; /* skip afi and keyword */
if (is_bgp) {
- if (idx == argc
- || strmatch(argv[idx]->arg,
- rfg->plist_export_bgp_name[afi])) {
+ if (idx == argc || strmatch(argv[idx]->arg,
+ rfg->plist_export_bgp_name[afi])) {
if (rfg->plist_export_bgp_name[afi])
free(rfg->plist_export_bgp_name[afi]);
rfg->plist_export_bgp_name[afi] = NULL;
}
if (is_bgp) {
- if (idx == argc
- || strmatch(argv[idx]->arg,
- rfg->routemap_export_bgp_name)) {
+ if (idx == argc || strmatch(argv[idx]->arg,
+ rfg->routemap_export_bgp_name)) {
if (rfg->routemap_export_bgp_name)
free(rfg->routemap_export_bgp_name);
rfg->routemap_export_bgp_name = NULL;
vnc_direct_bgp_reexport_group_afi(bgp, rfg, AFI_IP6);
}
} else {
- if (idx == argc
- || strmatch(argv[idx]->arg,
- rfg->routemap_export_zebra_name)) {
+ if (idx == argc || strmatch(argv[idx]->arg,
+ rfg->routemap_export_zebra_name)) {
if (rfg->routemap_export_zebra_name)
free(rfg->routemap_export_zebra_name);
rfg->routemap_export_zebra_name = NULL;
VTY_DECLVAR_CONTEXT(bgp, bgp);
if (bgp->inst_type == BGP_INSTANCE_TYPE_VRF) {
- vty_out(vty, "Can't configure vrf-policy within a BGP VRF instance\n");
+ vty_out(vty,
+ "Can't configure vrf-policy within a BGP VRF instance\n");
return CMD_WARNING_CONFIG_FAILED;
}
vnc_zlog_debug_verbose(
"%s: peer=%p, prefix=%s, prd=%s afi=%d, safi=%d bn=%p, bn->info=%p",
- __func__, peer, buf,
- prefix_rd2str(prd, buf2, sizeof(buf2)), afi, safi, bn,
- (bn ? bn->info : NULL));
+ __func__, peer, buf, prefix_rd2str(prd, buf2, sizeof(buf2)),
+ afi, safi, bn, (bn ? bn->info : NULL));
for (bi = (bn ? bn->info : NULL); bi; bi = bi->next) {
if (lifetime && *lifetime != RFAPI_INFINITE_LIFETIME) {
uint32_t lt;
- encaptlv =
- XCALLOC(MTYPE_ENCAP_TLV,
- sizeof(struct bgp_attr_encap_subtlv) + 4);
+ encaptlv = XCALLOC(MTYPE_ENCAP_TLV,
+ sizeof(struct bgp_attr_encap_subtlv) + 4);
assert(encaptlv);
encaptlv->type =
BGP_VNC_SUBTLV_TYPE_LIFETIME; /* prefix lifetime */
*/
encaptlv = XCALLOC(
MTYPE_ENCAP_TLV,
- sizeof(struct bgp_attr_encap_subtlv)
- + 2 + hop->length);
+ sizeof(struct bgp_attr_encap_subtlv) + 2
+ + hop->length);
assert(encaptlv);
encaptlv->type =
BGP_VNC_SUBTLV_TYPE_RFPOPTION; /* RFP
} else if (encode == ECOMMUNITY_ENCODE_AS) {
as = (*p++ << 8);
as |= (*p++);
- p +=
- 2; /* skip next two, tag/vid
- always in lowest bytes */
+ p += 2; /* skip next two, tag/vid
+ always in lowest bytes */
}
if (as == bgp->as) {
*tag_id = *p++ << 8;
switch (pfx_un1.family) {
case AF_INET:
- if (!IPV4_ADDR_SAME(&pfx_un1.u.prefix4,
- &pfx_un2.u.prefix4))
+ if (!IPV4_ADDR_SAME(&pfx_un1.u.prefix4, &pfx_un2.u.prefix4))
return 0;
break;
case AF_INET6:
vnc_zlog_debug_verbose(
"%s: bi has prd=%s, peer=%p", __func__,
- prefix_rd2str(&bi_result->extra->vnc.import.rd,
- buf,
- sizeof(buf)),
+ prefix_rd2str(&bi_result->extra->vnc
+ .import.rd,
+ buf, sizeof(buf)),
bi_result->peer);
}
#endif
char buf_attach_pfx[PREFIX_STRLEN];
char buf_target_pfx[PREFIX_STRLEN];
- prefix2str(&m->node->p,
- buf_attach_pfx,
+ prefix2str(&m->node->p, buf_attach_pfx,
sizeof(buf_attach_pfx));
- prefix2str(&m->p,
- buf_target_pfx,
+ prefix2str(&m->p, buf_target_pfx,
sizeof(buf_target_pfx));
vnc_zlog_debug_verbose(
"%s: update rfd %p attached to pfx %s (targ=%s)",
__func__, m->rfd,
- buf_attach_pfx,
- buf_target_pfx);
+ buf_attach_pfx, buf_target_pfx);
/*
* update its RIB
extern void rfapi_vn_options_free(struct rfapi_vn_option *goner);
-extern void vnc_add_vrf_opener(struct bgp *bgp, struct rfapi_nve_group_cfg *rfg);
+extern void vnc_add_vrf_opener(struct bgp *bgp,
+ struct rfapi_nve_group_cfg *rfg);
extern void clear_vnc_vrf_closer(struct rfapi_nve_group_cfg *rfg);
/*------------------------------------------
* rfapi_extract_l2o
if (pn->info) {
if (pn->info != (void *)1) {
list_delete_and_null(
- (struct list **)(&pn->info));
+ (struct list *
+ *)(&pn->info));
}
pn->info = NULL;
/* linklist or 1 deleted */
vnc_zlog_debug_verbose(
"%s: move route to recently deleted list, rd=%s",
__func__,
- prefix_rd2str(&ri->rk.rd,
- buf_rd,
- sizeof(buf_rd)));
+ prefix_rd2str(
+ &ri->rk.rd,
+ buf_rd,
+ sizeof(buf_rd)));
}
#endif
* print that on the next line
*/
- if (bi->extra
- && bi->extra->vnc.import.aux_prefix.family) {
+ if (bi->extra && bi->extra->vnc.import.aux_prefix.family) {
const char *sp;
sp = rfapi_ntop(
************************************************************************/
void vnc_add_vrf_opener(struct bgp *bgp, struct rfapi_nve_group_cfg *rfg)
{
- if (rfg->rfd == NULL) { /* need new rfapi_handle */
+ if (rfg->rfd == NULL) { /* need new rfapi_handle */
/* based on rfapi_open */
struct rfapi_descriptor *rfd;
static void vnc_direct_add_rn_group_rd(struct bgp *bgp,
struct rfapi_nve_group_cfg *rfg,
- struct route_node *rn,
- struct attr *attr,
+ struct route_node *rn, struct attr *attr,
afi_t afi,
struct rfapi_descriptor *irfd);
NULL, /* attr, ignored */
afi, SAFI_UNICAST, ZEBRA_ROUTE_VNC_DIRECT,
BGP_ROUTE_REDISTRIBUTE,
- NULL, /* RD not used for unicast */
- NULL, 0, NULL); /* tag not used for unicast */
+ NULL, /* RD not used for unicast */
+ NULL, 0,
+ NULL); /* tag not used for unicast */
/*
* yuck!
* - but consistent with rest of function
NULL, /* attr, ignored */
afi, SAFI_UNICAST, ZEBRA_ROUTE_VNC_DIRECT,
BGP_ROUTE_REDISTRIBUTE,
- NULL, /* RD not used for unicast */
- NULL, 0, NULL); /* tag not used for unicast */
+ NULL, /* RD not used for unicast */
+ NULL, 0,
+ NULL); /* tag not used for unicast */
}
}
}
static void vnc_direct_add_rn_group_rd(struct bgp *bgp,
struct rfapi_nve_group_cfg *rfg,
- struct route_node *rn,
- struct attr *attr,
- afi_t afi,
- struct rfapi_descriptor *irfd)
+ struct route_node *rn, struct attr *attr,
+ afi_t afi, struct rfapi_descriptor *irfd)
{
struct prefix nhp;
struct bgp_info info;
assert(rfg->rfd == NULL);
if (!rfg->rt_export_list || !rfg->rfapi_import_table) {
- vnc_zlog_debug_verbose("%s: VRF \"%s\" is missing RT import/export configuration.\n",
- __func__, rfg->name);
+ vnc_zlog_debug_verbose(
+ "%s: VRF \"%s\" is missing RT import/export configuration.\n",
+ __func__, rfg->name);
return;
}
if (!rfg->rd.prefixlen) {
- vnc_zlog_debug_verbose("%s: VRF \"%s\" is missing RD configuration.\n",
- __func__, rfg->name);
+ vnc_zlog_debug_verbose(
+ "%s: VRF \"%s\" is missing RD configuration.\n",
+ __func__, rfg->name);
return;
}
if (rfg->label > MPLS_LABEL_MAX) {
- vnc_zlog_debug_verbose("%s: VRF \"%s\" is missing defaul label configuration.\n",
- __func__, rfg->name);
+ vnc_zlog_debug_verbose(
+ "%s: VRF \"%s\" is missing defaul label configuration.\n",
+ __func__, rfg->name);
return;
}
irfd = XCALLOC(MTYPE_RFAPI_DESC,
- sizeof(struct rfapi_descriptor));
+ sizeof(struct rfapi_descriptor));
irfd->bgp = bgp;
rfg->rfd = irfd;
/*
return;
if (VNC_DEBUG(EXPORT_BGP_DIRECT_ADD)) {
- vnc_zlog_debug_any("%s: attr follows",
- __func__);
+ vnc_zlog_debug_any("%s: attr follows", __func__);
rfapiPrintAttrPtrs(NULL, attr);
- vnc_zlog_debug_any("%s: hattr follows",
- __func__);
+ vnc_zlog_debug_any("%s: hattr follows", __func__);
rfapiPrintAttrPtrs(NULL, &hattr);
}
info.peer = irfd->peer;
info.attr = &hattr;
- ret = route_map_apply(rfg->routemap_export_bgp,
- &rn->p, RMAP_BGP, &info);
+ ret = route_map_apply(rfg->routemap_export_bgp, &rn->p,
+ RMAP_BGP, &info);
if (ret == RMAP_DENYMATCH) {
bgp_attr_flush(&hattr);
- vnc_zlog_debug_verbose("%s: route map says DENY, so not calling bgp_update",
- __func__);
+ vnc_zlog_debug_verbose(
+ "%s: route map says DENY, so not calling bgp_update",
+ __func__);
return;
}
}
bgp_update(irfd->peer, &rn->p, /* prefix */
0, /* addpath_id */
- iattr, /* bgp_update copies it */
- afi, SAFI_UNICAST,
- ZEBRA_ROUTE_VNC_DIRECT,
- BGP_ROUTE_REDISTRIBUTE,
- NULL, /* RD not used for unicast */
- NULL, /* tag not used for unicast */
- 0, 0, NULL); /* EVPN not used */
+ iattr, /* bgp_update copies it */
+ afi, SAFI_UNICAST, ZEBRA_ROUTE_VNC_DIRECT,
+ BGP_ROUTE_REDISTRIBUTE, NULL, /* RD not used for unicast */
+ NULL, /* tag not used for unicast */
+ 0, 0, NULL); /* EVPN not used */
bgp_attr_unintern(&iattr);
for (ln = listhead(rfg->nves); ln;
ln = listnextnode(ln)) {
vnc_direct_add_rn_group_rd(bgp, rfg, rn, &attr,
- afi, listgetdata(ln));
+ afi,
+ listgetdata(ln));
}
}
}
static void vnc_direct_del_rn_group_rd(struct bgp *bgp,
struct rfapi_nve_group_cfg *rfg,
- struct route_node *rn,
- afi_t afi,
+ struct route_node *rn, afi_t afi,
struct rfapi_descriptor *irfd)
{
if (irfd == NULL)
return;
bgp_withdraw(irfd->peer, &rn->p, /* prefix */
- 0, /* addpath_id */
- NULL, /* attr, ignored */
- afi, SAFI_UNICAST,
- ZEBRA_ROUTE_VNC_DIRECT,
- BGP_ROUTE_REDISTRIBUTE,
- NULL, /* RD not used for unicast */
- NULL, 0,
- NULL); /* tag not used for unicast */
+ 0, /* addpath_id */
+ NULL, /* attr, ignored */
+ afi, SAFI_UNICAST, ZEBRA_ROUTE_VNC_DIRECT,
+ BGP_ROUTE_REDISTRIBUTE, NULL, /* RD not used for unicast */
+ NULL, 0, NULL); /* tag not used for unicast */
return;
}
for (rn = route_top(rt); rn; rn = route_next(rn))
if (rn->info) {
if (rfg->type == RFAPI_GROUP_CFG_VRF)
- vnc_direct_del_rn_group_rd(bgp, rfg, rn,
- afi, rfg->rfd);
+ vnc_direct_del_rn_group_rd(bgp, rfg, rn, afi,
+ rfg->rfd);
else {
struct listnode *ln;
/*
- * For each NVE that is assigned to the export nve
+ * For each NVE that is assigned to the export
+ * nve
* group, generate
* a route with that NVE as its next hop
*/
for (ln = listhead(rfg->nves); ln;
ln = listnextnode(ln))
- vnc_direct_del_rn_group_rd(bgp, rfg, rn,
- afi, listgetdata(ln));
+ vnc_direct_del_rn_group_rd(
+ bgp, rfg, rn, afi,
+ listgetdata(ln));
}
}
}
if (rfgn->rfg && rfgn->rfg->rfapi_import_table == it) {
if (rfgn->rfg->nves)
nve_group_to_nve_list(rfgn->rfg, nves, family);
- else if (rfgn->rfg->rfd &&
- rfgn->rfg->type == RFAPI_GROUP_CFG_VRF) {
+ else if (rfgn->rfg->rfd
+ && rfgn->rfg->type == RFAPI_GROUP_CFG_VRF) {
if (!*nves)
*nves = list_new();
listnode_add(*nves, rfgn->rfg->rfd);
iattr, /* bgp_update copies this attr */
afi, SAFI_UNICAST, ZEBRA_ROUTE_VNC_DIRECT_RH,
BGP_ROUTE_REDISTRIBUTE, NULL, /* RD not used for unicast */
- NULL, /* tag not used for unicast, EVPN neither */
+ NULL, /* tag not used for unicast, EVPN neither */
0, 0, NULL); /* EVPN not used */
bgp_attr_unintern(&iattr);
}
NULL, /* attr, ignored */
family2afi(eti->node->p.family), SAFI_UNICAST, eti->type,
eti->subtype, NULL, /* RD not used for unicast */
- NULL, 0, NULL); /* tag not used for unicast, EVPN neither */
+ NULL, 0,
+ NULL); /* tag not used for unicast, EVPN neither */
/*
* Free the eti
prefix2str(&rn->p, prefixstr,
sizeof(prefixstr));
- vnc_zlog_debug_verbose(
- "%s: checking prefix %s", __func__,
- prefixstr);
+ vnc_zlog_debug_verbose("%s: checking prefix %s",
+ __func__, prefixstr);
}
/*
if (bi->extra) {
prd = &bi->extra->vnc.import.rd;
label = decode_label(
- &bi->extra->label[0]);
+ &bi->extra->label[0]);
} else
prd = NULL;
#define EIGRP_MULTICAST_ADDRESS 0xe000000A /*224.0.0.10*/
#define EIGRP_MAX_METRIC 0xffffffffU /*4294967295*/
-enum metric_change {
- METRIC_DECREASE,
- METRIC_SAME,
- METRIC_INCREASE
-};
+enum metric_change { METRIC_DECREASE, METRIC_SAME, METRIC_INCREASE };
#define DEFAULT_ROUTE ZEBRA_ROUTE_MAX
#define DEFAULT_ROUTE_TYPE(T) ((T) == DEFAULT_ROUTE)
* state not changed
* usually by receiving not last reply
*/
- EIGRP_FSM_KEEP_STATE,
+ EIGRP_FSM_KEEP_STATE,
};
/**
vty_out(vty, "%u %c %-10u", 0, '/',
eigrp_neighbor_packet_queue_sum(ei));
vty_out(vty, "%-7u %-14u %-12u %-8u", 0, 0, 0, 0);
- vty_out(vty, "%-8u %-8u \n", ei->params.v_hello,
- ei->params.v_wait);
+ vty_out(vty, "%-8u %-8u \n", ei->params.v_hello, ei->params.v_wait);
}
void show_ip_eigrp_interface_detail(struct vty *vty, struct eigrp *eigrp,
vty_out(vty, "%-3u %-17s %-21s", 0, eigrp_neigh_ip_string(nbr),
eigrp_if_name_string(nbr->ei));
if (nbr->t_holddown)
- vty_out(vty, "%-7lu", thread_timer_remain_second(nbr->t_holddown));
+ vty_out(vty, "%-7lu",
+ thread_timer_remain_second(nbr->t_holddown));
else
vty_out(vty, "- ");
vty_out(vty, "%-8u %-6u %-5u", 0, 0, EIGRP_PACKET_RETRANS_TIME);
vty_out(vty, "%s, ",
prefix2str(tn->destination, buffer, PREFIX_STRLEN));
- vty_out(vty, "%u successors, ",
- (successors) ? successors->count : 0);
+ vty_out(vty, "%u successors, ", (successors) ? successors->count : 0);
vty_out(vty, "FD is %u, serno: %" PRIu64 " \n", tn->fdistance,
tn->serno);
}
void show_ip_eigrp_nexthop_entry(struct vty *vty, struct eigrp *eigrp,
- struct eigrp_nexthop_entry *te, int *first)
+ struct eigrp_nexthop_entry *te, int *first)
{
if (te->reported_distance == EIGRP_MAX_METRIC)
return;
extern void show_ip_eigrp_prefix_entry(struct vty *,
struct eigrp_prefix_entry *);
extern void show_ip_eigrp_nexthop_entry(struct vty *, struct eigrp *,
- struct eigrp_nexthop_entry *, int *);
+ struct eigrp_nexthop_entry *, int *);
extern void eigrp_debug_init(void);
* Return number of occurred event (arrow in diagram).
*
*/
-static enum eigrp_fsm_events eigrp_get_fsm_event(
- struct eigrp_fsm_action_message *msg)
+static enum eigrp_fsm_events
+eigrp_get_fsm_event(struct eigrp_fsm_action_message *msg)
{
// Loading base information from message
// struct eigrp *eigrp = msg->eigrp;
return EIGRP_FSM_KEEP_STATE;
zlog_info("All reply received\n");
- if (head->reported_distance
- < prefix->fdistance) {
+ if (head->reported_distance < prefix->fdistance) {
return EIGRP_FSM_EVENT_LR_FCS;
}
{
enum eigrp_fsm_events event = eigrp_get_fsm_event(msg);
- zlog_info("EIGRP AS: %d State: %s Event: %s Network: %s Packet Type: %s Reply RIJ Count: %d change: %s",
- msg->eigrp->AS, prefix_state2str(msg->prefix->state),
- fsm_state2str(event),
- eigrp_topology_ip_string(msg->prefix),
- packet_type2str(msg->packet_type),
- msg->prefix->rij->count,
- change2str(msg->change));
+ zlog_info(
+ "EIGRP AS: %d State: %s Event: %s Network: %s Packet Type: %s Reply RIJ Count: %d change: %s",
+ msg->eigrp->AS, prefix_state2str(msg->prefix->state),
+ fsm_state2str(event), eigrp_topology_ip_string(msg->prefix),
+ packet_type2str(msg->packet_type), msg->prefix->rij->count,
+ change2str(msg->change));
(*(NSM[msg->prefix->state][event].func))(msg);
return 1;
ne = listnode_head(successors);
prefix->state = EIGRP_FSM_STATE_ACTIVE_1;
- prefix->rdistance = prefix->distance = prefix->fdistance =
- ne->distance;
+ prefix->rdistance = prefix->distance = prefix->fdistance = ne->distance;
prefix->reported_metric = ne->total_metric;
if (eigrp_nbr_count_get()) {
ne = listnode_head(successors);
prefix->state = EIGRP_FSM_STATE_ACTIVE_3;
- prefix->rdistance = prefix->distance = prefix->fdistance =
- ne->distance;
+ prefix->rdistance = prefix->distance = prefix->fdistance = ne->distance;
prefix->reported_metric = ne->total_metric;
if (eigrp_nbr_count_get()) {
prefix->req_action |= EIGRP_FSM_NEED_QUERY;
ne->total_metric)) {
prefix->rdistance = prefix->fdistance =
prefix->distance = ne->distance;
- prefix->reported_metric =
- ne->total_metric;
+ prefix->reported_metric = ne->total_metric;
if (msg->packet_type == EIGRP_OPC_QUERY)
eigrp_send_reply(msg->adv_router, prefix);
prefix->req_action |= EIGRP_FSM_NEED_UPDATE;
struct eigrp_prefix_entry *prefix = msg->prefix;
struct eigrp_nexthop_entry *ne = listnode_head(prefix->entries);
- prefix->fdistance = prefix->distance = prefix->rdistance =
- ne->distance;
+ prefix->fdistance = prefix->distance = prefix->rdistance = ne->distance;
prefix->reported_metric = ne->total_metric;
if (prefix->state == EIGRP_FSM_STATE_ACTIVE_3) {
assert(successors); // It's like Napolean and Waterloo
ne = listnode_head(successors);
- eigrp_send_reply(ne->adv_router,
- prefix);
+ eigrp_send_reply(ne->adv_router, prefix);
list_delete_and_null(&successors);
}
assert(successors); // Having a spoon and all you need is a
// knife
ne = listnode_head(successors);
- eigrp_send_reply(ne->adv_router,
- prefix);
+ eigrp_send_reply(ne->adv_router, prefix);
list_delete_and_null(&successors);
}
/* Hello timer set. */
ei->t_hello = NULL;
- thread_add_timer(master, eigrp_hello_timer, ei,
- ei->params.v_hello, &ei->t_hello);
+ thread_add_timer(master, eigrp_hello_timer, ei, ei->params.v_hello,
+ &ei->t_hello);
return 0;
}
stream_putw(s, EIGRP_TLV_SW_VERSION);
stream_putw(s, length);
- stream_putc(s, FRR_MAJOR); //!< major os version
+ stream_putc(s, FRR_MAJOR); //!< major os version
stream_putc(s, FRR_MINOR); //!< minor os version
/* and the core eigrp version */
if (ep) {
// encode common header feilds
- eigrp_packet_header_init(EIGRP_OPC_HELLO, ei->eigrp, ep->s, 0, 0, ack);
+ eigrp_packet_header_init(EIGRP_OPC_HELLO, ei->eigrp, ep->s, 0,
+ 0, ack);
// encode Authentication TLV
if ((ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
&& (ei->params.auth_keychain != NULL)) {
length += eigrp_add_authTLV_MD5_to_stream(ep->s, ei);
- } else if ((ei->params.auth_type
- == EIGRP_AUTH_TYPE_SHA256)
+ } else if ((ei->params.auth_type == EIGRP_AUTH_TYPE_SHA256)
&& (ei->params.auth_keychain != NULL)) {
length += eigrp_add_authTLV_SHA256_to_stream(ep->s, ei);
}
&& (ei->params.auth_keychain != NULL)) {
eigrp_make_md5_digest(ei, ep->s,
EIGRP_AUTH_BASIC_HELLO_FLAG);
- } else if ((ei->params.auth_type
- == EIGRP_AUTH_TYPE_SHA256)
+ } else if ((ei->params.auth_type == EIGRP_AUTH_TYPE_SHA256)
&& (ei->params.auth_keychain != NULL)) {
eigrp_make_sha256_digest(ei, ep->s,
EIGRP_AUTH_BASIC_HELLO_FLAG);
void eigrp_if_init()
{
/* Initialize Zebra interface data structure. */
- //hook_register_prio(if_add, 0, eigrp_if_new);
+ // hook_register_prio(if_add, 0, eigrp_if_new);
hook_register_prio(if_del, 0, eigrp_if_delete_hook);
}
-
void eigrp_del_if_params(struct eigrp_if_params *eip)
{
if (eip->auth_keychain)
thread_add_event(master, eigrp_hello_timer, ei, (1), NULL);
/*Prepare metrics*/
- metric.bandwidth =
- eigrp_bandwidth_to_scaled(ei->params.bandwidth);
+ metric.bandwidth = eigrp_bandwidth_to_scaled(ei->params.bandwidth);
metric.delay = eigrp_delay_to_scaled(ei->params.delay);
metric.load = ei->params.load;
metric.reliability = ei->params.reliability;
* group. */
if (ei->member_allrouters) {
/* Only actually drop if this is the last reference */
- eigrp_if_drop_allspfrouters(ei->eigrp,
- ei->address,
+ eigrp_if_drop_allspfrouters(ei->eigrp, ei->address,
ei->ifp->ifindex);
/* Unset the flag regardless of whether the system call
to leave
return EIGRP_IFTYPE_BROADCAST;
}
-void eigrp_if_free(struct eigrp_interface *ei,
- int source)
+void eigrp_if_free(struct eigrp_interface *ei, int source)
{
struct prefix dest_addr;
struct eigrp_prefix_entry *pe;
#ifndef _ZEBRA_EIGRP_MACROS_H_
#define _ZEBRA_EIGRP_MACROS_H_
-
//--------------------------------------------------------------------------
#define EIGRP_IF_STRING_MAXLEN 40
eigrp_nbr_delete(nbr);
}
-int eigrp_nbr_split_horizon_check(struct eigrp_nexthop_entry *ne, struct eigrp_interface *ei)
+int eigrp_nbr_split_horizon_check(struct eigrp_nexthop_entry *ne,
+ struct eigrp_interface *ei)
{
if (ne->distance == EIGRP_MAX_METRIC)
return 0;
if (CHECK_FLAG(co->flags, ZEBRA_IFA_SECONDARY))
continue;
- if (p->family == co->address->family
- && !ifp->info
+ if (p->family == co->address->family && !ifp->info
&& eigrp_network_match_iface(co, p)) {
ei = eigrp_if_new(eigrp, ifp, co->address);
struct eigrp_interface *ei = entry->ei;
entry->total_metric = entry->reported_metric;
- uint64_t temp_delay = (uint64_t)entry->total_metric.delay
- + (uint64_t)eigrp_delay_to_scaled(ei->params.delay);
+ uint64_t temp_delay =
+ (uint64_t)entry->total_metric.delay
+ + (uint64_t)eigrp_delay_to_scaled(ei->params.delay);
entry->total_metric.delay = temp_delay > EIGRP_MAX_METRIC
? EIGRP_MAX_METRIC
: (u_int32_t)temp_delay;
- u_int32_t bw =
- eigrp_bandwidth_to_scaled(ei->params.bandwidth);
+ u_int32_t bw = eigrp_bandwidth_to_scaled(ei->params.bandwidth);
entry->total_metric.bandwidth = entry->total_metric.bandwidth > bw
- ? bw
- : entry->total_metric.bandwidth;
+ ? bw
+ : entry->total_metric.bandwidth;
return eigrp_calculate_metrics(eigrp, entry->total_metric);
}
key = key_lookup_for_send(keychain);
if (!key) {
- zlog_warn("Interface %s: Expected key value not found in config",
- nbr->ei->ifp->name);
+ zlog_warn(
+ "Interface %s: Expected key value not found in config",
+ nbr->ei->ifp->name);
return 0;
}
key = key_lookup_for_send(keychain);
if (!key) {
- zlog_warn("Interface %s: Expected key value not found in config",
- ei->ifp->name);
+ zlog_warn(
+ "Interface %s: Expected key value not found in config",
+ ei->ifp->name);
eigrp_authTLV_SHA256_free(auth_TLV);
return 0;
}
#ifdef WANT_EIGRP_WRITE_FRAGMENT
static u_int16_t ipid = 0;
#endif /* WANT_EIGRP_WRITE_FRAGMENT */
- /* $FRR indent$ */
-/* clang-format off */
#define EIGRP_WRITE_IPHL_SHIFT 2
eigrp->t_write = NULL;
goto out;
}
if (ep->length < EIGRP_HEADER_LEN) {
- zlog_err("%s: Packet just has a header?",
- __PRETTY_FUNCTION__);
+ zlog_err("%s: Packet just has a header?", __PRETTY_FUNCTION__);
eigrp_header_dump((struct eigrp_header *)ep->s->data);
eigrp_packet_delete(ei);
goto out;
if (IS_DEBUG_EIGRP_TRANSMIT(0, SEND)) {
eigrph = (struct eigrp_header *)STREAM_DATA(ep->s);
- zlog_debug("Sending [%s][%d/%d] to [%s] via [%s] ret [%d].",
- lookup_msg(eigrp_packet_type_str, eigrph->opcode, NULL),
- seqno, ack,
- inet_ntoa(ep->dst), IF_NAME(ei), ret);
+ zlog_debug(
+ "Sending [%s][%d/%d] to [%s] via [%s] ret [%d].",
+ lookup_msg(eigrp_packet_type_str, eigrph->opcode, NULL),
+ seqno, ack, inet_ntoa(ep->dst), IF_NAME(ei), ret);
}
if (ret < 0)
strlcpy(src, inet_ntoa(iph->ip_src), sizeof(src));
strlcpy(dst, inet_ntoa(iph->ip_dst), sizeof(dst));
- zlog_debug("Received [%s][%d/%d] length [%u] via [%s] src [%s] dst [%s]",
- lookup_msg(eigrp_packet_type_str, opcode, NULL),
- ntohl(eigrph->sequence), ntohl(eigrph->ack), length,
- IF_NAME(ei), src, dst);
+ zlog_debug(
+ "Received [%s][%d/%d] length [%u] via [%s] src [%s] dst [%s]",
+ lookup_msg(eigrp_packet_type_str, opcode, NULL),
+ ntohl(eigrph->sequence), ntohl(eigrph->ack), length,
+ IF_NAME(ei), src, dst);
}
/* Read rest of the packet and call each sort of packet routine. */
eigrp_packet_free(ep);
if ((nbr->state == EIGRP_NEIGHBOR_PENDING)
- && (ntohl(eigrph->ack) == nbr->init_sequence_number)) {
+ && (ntohl(eigrph->ack)
+ == nbr->init_sequence_number)) {
eigrp_nbr_state_set(nbr, EIGRP_NEIGHBOR_UP);
zlog_info("Neighbor(%s) adjacency became full",
inet_ntoa(nbr->src));
nbr->recv_sequence_number =
ntohl(eigrph->sequence);
eigrp_update_send_EOT(nbr);
- }
- else
+ } else
eigrp_send_packet_reliably(nbr);
}
ep = eigrp_fifo_next(nbr->multicast_queue);
}
/* Make EIGRP header. */
-void eigrp_packet_header_init(int type, struct eigrp *eigrp,
- struct stream *s, u_int32_t flags,
- u_int32_t sequence, u_int32_t ack)
+void eigrp_packet_header_init(int type, struct eigrp *eigrp, struct stream *s,
+ u_int32_t flags, u_int32_t sequence,
+ u_int32_t ack)
{
struct eigrp_header *eigrph;
stream_putc(s, pe->destination->u.prefix4.s_addr & 0xFF);
if (pe->destination->prefixlen > 8)
- stream_putc(s,
- (pe->destination->u.prefix4.s_addr >> 8) & 0xFF);
+ stream_putc(s, (pe->destination->u.prefix4.s_addr >> 8) & 0xFF);
if (pe->destination->prefixlen > 16)
stream_putc(s,
(pe->destination->u.prefix4.s_addr >> 16) & 0xFF);
struct eigrp_neighbor *);
extern void eigrp_packet_free(struct eigrp_packet *);
extern void eigrp_packet_delete(struct eigrp_interface *);
-extern void eigrp_packet_header_init(int, struct eigrp *,
- struct stream *, u_int32_t, u_int32_t,
- u_int32_t);
+extern void eigrp_packet_header_init(int, struct eigrp *, struct stream *,
+ u_int32_t, u_int32_t, u_int32_t);
extern void eigrp_packet_checksum(struct eigrp_interface *, struct stream *,
u_int16_t);
* These externs are found in eigrp_update.c
*/
extern bool eigrp_update_prefix_apply(struct eigrp *eigrp,
- struct eigrp_interface *ei,
- int in,
+ struct eigrp_interface *ei, int in,
struct prefix *prefix);
extern void eigrp_update_send(struct eigrp_interface *);
extern void eigrp_update_receive(struct eigrp *, struct ip *,
break;
case EIGRP_TLV_IPv4_EXT:
- /* DVS: processing of external routes needs packet and fsm work.
- * for now, lets just not creash the box
- */
+ /* DVS: processing of external routes needs packet and fsm work.
+ * for now, lets just not creash the box
+ */
default:
length = stream_getw(s);
// -2 for type, -2 for len
- for (length-=4; length ; length--) {
+ for (length -= 4; length; length--) {
(void)stream_getc(s);
}
}
ep = eigrp_packet_new(ei->ifp->mtu, NULL);
/* Prepare EIGRP INIT UPDATE header */
- eigrp_packet_header_init(EIGRP_OPC_QUERY,
- ei->eigrp, ep->s, 0,
+ eigrp_packet_header_init(EIGRP_OPC_QUERY, ei->eigrp,
+ ep->s, 0,
ei->eigrp->sequence_number, 0);
// encode Authentication TLV, if needed
if ((ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
&& (ei->params.auth_keychain != NULL)) {
- length +=
- eigrp_add_authTLV_MD5_to_stream(ep->s,
- ei);
+ length += eigrp_add_authTLV_MD5_to_stream(ep->s,
+ ei);
}
new_packet = false;
}
sizeof(struct eigrp_prefix_entry));
memcpy(pe2, pe, sizeof(struct eigrp_prefix_entry));
- if (eigrp_update_prefix_apply(eigrp, ei,
- EIGRP_FILTER_OUT,
+ if (eigrp_update_prefix_apply(eigrp, ei, EIGRP_FILTER_OUT,
pe2->destination)) {
zlog_info("REPLY SEND: Setting Metric to max");
pe2->reported_metric.delay = EIGRP_MAX_METRIC;
-
}
/*
dest_addr.u.prefix4 = tlv->destination;
dest_addr.prefixlen = tlv->prefix_length;
struct eigrp_prefix_entry *dest =
- eigrp_topology_table_lookup_ipv4(
- eigrp->topology_table, &dest_addr);
+ eigrp_topology_table_lookup_ipv4(eigrp->topology_table,
+ &dest_addr);
/*
* Destination must exists
*/
if (!dest) {
char buf[PREFIX_STRLEN];
- zlog_err("%s: Received prefix %s which we do not know about",
- __PRETTY_FUNCTION__,
- prefix2str(&dest_addr, buf, sizeof(buf)));
+ zlog_err(
+ "%s: Received prefix %s which we do not know about",
+ __PRETTY_FUNCTION__,
+ prefix2str(&dest_addr, buf, sizeof(buf)));
eigrp_IPv4_InternalTLV_free(tlv);
continue;
}
struct eigrp_nexthop_entry *entry =
eigrp_prefix_entry_lookup(dest->entries, nbr);
- if (eigrp_update_prefix_apply(eigrp, ei,
- EIGRP_FILTER_IN,
+ if (eigrp_update_prefix_apply(eigrp, ei, EIGRP_FILTER_IN,
&dest_addr)) {
tlv->metric.delay = EIGRP_MAX_METRIC;
}
#include "if_rmap.h"
extern bool eigrp_routemap_prefix_apply(struct eigrp *eigrp,
- struct eigrp_interface *ei,
- int in,
+ struct eigrp_interface *ei, int in,
struct prefix *prefix);
extern void eigrp_route_map_update(const char *);
extern void eigrp_route_map_init();
uint64_t serno; /* Global serial number counter for topology entry
changes*/
- uint64_t
- serno_last_update; /* Highest serial number of information send
- by last update*/
+ uint64_t serno_last_update; /* Highest serial number of information send
+ by last update*/
struct list *topology_changes_internalIPV4;
struct list *topology_changes_externalIPV4;
u_char passive_interface;
u_int32_t v_hello;
u_int16_t v_wait;
- u_char type; /* type of interface */
+ u_char type; /* type of interface */
u_int32_t bandwidth;
u_int32_t delay;
u_char reliability;
u_char load;
char *auth_keychain; /* Associated keychain with interface*/
- int auth_type; /* EIGRP authentication type */
+ int auth_type; /* EIGRP authentication type */
};
enum { MEMBER_ALLROUTERS = 0,
/*multicast group refcnts */
bool member_allrouters;
-
+
/* This interface's parent eigrp instance. */
struct eigrp *eigrp;
#include "eigrpd/eigrp_memory.h"
static int eigrp_nexthop_entry_cmp(struct eigrp_nexthop_entry *,
- struct eigrp_nexthop_entry *);
+ struct eigrp_nexthop_entry *);
/*
* Returns linkedlist used as topology table
* Topology entry comparison
*/
static int eigrp_nexthop_entry_cmp(struct eigrp_nexthop_entry *entry1,
- struct eigrp_nexthop_entry *entry2)
+ struct eigrp_nexthop_entry *entry2)
{
if (entry1->distance < entry2->distance)
return -1;
if (IS_DEBUG_EIGRP_EVENT) {
char buf[PREFIX_STRLEN];
- zlog_debug("%s: %s Should we have found this entry in the topo table?",
- __PRETTY_FUNCTION__,
- prefix2str(pe->destination, buf,
- sizeof(buf)));
+ zlog_debug(
+ "%s: %s Should we have found this entry in the topo table?",
+ __PRETTY_FUNCTION__,
+ prefix2str(pe->destination, buf, sizeof(buf)));
}
}
* Adding topology entry to topology node
*/
void eigrp_nexthop_entry_add(struct eigrp_prefix_entry *node,
- struct eigrp_nexthop_entry *entry)
+ struct eigrp_nexthop_entry *entry)
{
struct list *l = list_new();
eigrp_zebra_route_delete(pe->destination);
rn->info = NULL;
- route_unlock_node(rn); //Lookup above
- route_unlock_node(rn); //Initial creation
+ route_unlock_node(rn); // Lookup above
+ route_unlock_node(rn); // Initial creation
XFREE(MTYPE_EIGRP_PREFIX_ENTRY, pe);
}
* Deleting topology entry from topology node
*/
void eigrp_nexthop_entry_delete(struct eigrp_prefix_entry *node,
- struct eigrp_nexthop_entry *entry)
+ struct eigrp_nexthop_entry *entry)
{
if (listnode_lookup(node->entries, entry) != NULL) {
listnode_delete(node->entries, entry);
return prefixes;
}
-enum metric_change eigrp_topology_update_distance(struct eigrp_fsm_action_message *msg)
+enum metric_change
+eigrp_topology_update_distance(struct eigrp_fsm_action_message *msg)
{
struct eigrp *eigrp = msg->eigrp;
struct eigrp_prefix_entry *prefix = msg->prefix;
assert(entry);
- switch(msg->data_type) {
+ switch (msg->data_type) {
case EIGRP_CONNECTED:
if (prefix->nt == EIGRP_TOPOLOGY_TYPE_CONNECTED)
return change;
return change; // No change
}
- new_reported_distance = eigrp_calculate_metrics(eigrp,
- msg->metrics);
+ new_reported_distance =
+ eigrp_calculate_metrics(eigrp, msg->metrics);
if (entry->reported_distance < new_reported_distance) {
change = METRIC_INCREASE;
zlog_err("%s: Please implement handler", __PRETTY_FUNCTION__);
break;
}
- distance_done:
+distance_done:
/*
* Move to correct position in list according to new distance
*/
struct eigrp_nexthop_entry *entry;
if (successors) {
- eigrp_zebra_route_add(prefix->destination,
- successors);
+ eigrp_zebra_route_add(prefix->destination, successors);
for (ALL_LIST_ELEMENTS_RO(successors, node, entry))
entry->flags |= EIGRP_NEXTHOP_ENTRY_INTABLE_FLAG;
extern void eigrp_prefix_entry_add(struct route_table *table,
struct eigrp_prefix_entry *pe);
extern void eigrp_nexthop_entry_add(struct eigrp_prefix_entry *,
- struct eigrp_nexthop_entry *);
+ struct eigrp_nexthop_entry *);
extern void eigrp_prefix_entry_delete(struct route_table *table,
struct eigrp_prefix_entry *pe);
extern void eigrp_nexthop_entry_delete(struct eigrp_prefix_entry *,
- struct eigrp_nexthop_entry *);
+ struct eigrp_nexthop_entry *);
extern void eigrp_topology_delete_all(struct route_table *table);
extern unsigned int eigrp_topology_table_isempty(struct list *);
extern struct eigrp_prefix_entry *
-eigrp_topology_table_lookup_ipv4(struct route_table *table,
- struct prefix *p);
+eigrp_topology_table_lookup_ipv4(struct route_table *table, struct prefix *p);
extern struct list *eigrp_topology_get_successor(struct eigrp_prefix_entry *);
extern struct list *
eigrp_topology_get_successor_max(struct eigrp_prefix_entry *pe,
struct eigrp_neighbor *);
extern void eigrp_topology_update_all_node_flags(struct eigrp *);
extern void eigrp_topology_update_node_flags(struct eigrp_prefix_entry *);
-extern enum metric_change eigrp_topology_update_distance(struct eigrp_fsm_action_message *);
+extern enum metric_change
+eigrp_topology_update_distance(struct eigrp_fsm_action_message *);
extern void eigrp_update_routing_table(struct eigrp_prefix_entry *);
extern void eigrp_topology_neighbor_down(struct eigrp *,
struct eigrp_neighbor *);
#include "eigrpd/eigrp_network.h"
#include "eigrpd/eigrp_memory.h"
-bool eigrp_update_prefix_apply(struct eigrp *eigrp,
- struct eigrp_interface *ei,
+bool eigrp_update_prefix_apply(struct eigrp *eigrp, struct eigrp_interface *ei,
int in, struct prefix *prefix)
{
struct access_list *alist;
/* iterate over all prefixes which weren't advertised by neighbor */
for (ALL_LIST_ELEMENTS_RO(nbr_prefixes, node1, prefix)) {
char buffer[PREFIX_STRLEN];
- zlog_debug("GR receive: Neighbor not advertised %s",
- prefix2str(prefix->destination,
- buffer, PREFIX_STRLEN));
+ zlog_debug(
+ "GR receive: Neighbor not advertised %s",
+ prefix2str(prefix->destination, buffer, PREFIX_STRLEN));
fsm_msg.metrics = prefix->reported_metric;
/* set delay to MAX */
/*Here comes topology information save*/
pe = eigrp_prefix_entry_new();
pe->serno = eigrp->serno;
- pe->destination = (struct prefix *)prefix_ipv4_new();
- prefix_copy(pe->destination,
- &dest_addr);
+ pe->destination =
+ (struct prefix *)prefix_ipv4_new();
+ prefix_copy(pe->destination, &dest_addr);
pe->af = AF_INET;
pe->state = EIGRP_FSM_STATE_PASSIVE;
pe->nt = EIGRP_TOPOLOGY_TYPE_REMOTE;
if (eigrp_update_prefix_apply(eigrp, ei,
EIGRP_FILTER_IN,
&dest_addr))
- ne->reported_metric.delay = EIGRP_MAX_METRIC;
+ ne->reported_metric.delay =
+ EIGRP_MAX_METRIC;
ne->distance = eigrp_calculate_total_metrics(
eigrp, ne);
break;
case EIGRP_TLV_IPv4_EXT:
- /* DVS: processing of external routes needs packet and fsm work.
- * for now, lets just not creash the box
- */
+ /* DVS: processing of external routes needs packet and fsm work.
+ * for now, lets just not creash the box
+ */
default:
length = stream_getw(s);
// -2 for type, -2 for len
- for (length-=4; length ; length--) {
+ for (length -= 4; length; length--) {
(void)stream_getc(s);
}
}
nbr->ei->eigrp->sequence_number,
nbr->recv_sequence_number);
- eigrp_packet_header_init(EIGRP_OPC_UPDATE, nbr->ei->eigrp,
- ep->s, EIGRP_INIT_FLAG,
- nbr->ei->eigrp->sequence_number,
- nbr->recv_sequence_number);
+ eigrp_packet_header_init(
+ EIGRP_OPC_UPDATE, nbr->ei->eigrp, ep->s, EIGRP_INIT_FLAG,
+ nbr->ei->eigrp->sequence_number, nbr->recv_sequence_number);
// encode Authentication TLV, if needed
if ((nbr->ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
static void eigrp_update_place_on_nbr_queue(struct eigrp_neighbor *nbr,
struct eigrp_packet *ep,
- u_int32_t seq_no,
- int length)
+ u_int32_t seq_no, int length)
{
- if((nbr->ei->params.auth_type == EIGRP_AUTH_TYPE_MD5) &&
- (nbr->ei->params.auth_keychain != NULL)) {
- eigrp_make_md5_digest(nbr->ei,ep->s, EIGRP_AUTH_UPDATE_FLAG);
+ if ((nbr->ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
+ && (nbr->ei->params.auth_keychain != NULL)) {
+ eigrp_make_md5_digest(nbr->ei, ep->s, EIGRP_AUTH_UPDATE_FLAG);
}
/* EIGRP Checksum */
ep = eigrp_packet_new(mtu, nbr);
/* Prepare EIGRP EOT UPDATE header */
- eigrp_packet_header_init(EIGRP_OPC_UPDATE, eigrp,
- ep->s, EIGRP_EOT_FLAG,
+ eigrp_packet_header_init(EIGRP_OPC_UPDATE, eigrp, ep->s, EIGRP_EOT_FLAG,
seq_no, nbr->recv_sequence_number);
// encode Authentication TLV, if needed
- if((ei->params.auth_type == EIGRP_AUTH_TYPE_MD5) &&
- (ei->params.auth_keychain != NULL)) {
- length += eigrp_add_authTLV_MD5_to_stream(ep->s,ei);
+ if ((ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
+ && (ei->params.auth_keychain != NULL)) {
+ length += eigrp_add_authTLV_MD5_to_stream(ep->s, ei);
}
for (rn = route_top(eigrp->topology_table); rn; rn = route_next(rn)) {
continue;
if ((length + EIGRP_TLV_MAX_IPV4_BYTE) > mtu) {
- eigrp_update_place_on_nbr_queue (nbr, ep, seq_no, length);
+ eigrp_update_place_on_nbr_queue(nbr, ep, seq_no,
+ length);
seq_no++;
length = EIGRP_HEADER_LEN;
ep = eigrp_packet_new(mtu, nbr);
- eigrp_packet_header_init(EIGRP_OPC_UPDATE,
- nbr->ei->eigrp,
- ep->s, EIGRP_EOT_FLAG,
- seq_no,
- nbr->recv_sequence_number);
-
- if((ei->params.auth_type == EIGRP_AUTH_TYPE_MD5) &&
- (ei->params.auth_keychain != NULL))
- {
- length += eigrp_add_authTLV_MD5_to_stream(ep->s,ei);
+ eigrp_packet_header_init(
+ EIGRP_OPC_UPDATE, nbr->ei->eigrp, ep->s,
+ EIGRP_EOT_FLAG, seq_no,
+ nbr->recv_sequence_number);
+
+ if ((ei->params.auth_type
+ == EIGRP_AUTH_TYPE_MD5)
+ && (ei->params.auth_keychain != NULL)) {
+ length +=
+ eigrp_add_authTLV_MD5_to_stream(
+ ep->s, ei);
}
}
/* Get destination address from prefix */
dest_addr = pe->destination;
/* Check if any list fits */
- if (eigrp_update_prefix_apply(eigrp, ei,
- EIGRP_FILTER_OUT,
- dest_addr))
+ if (eigrp_update_prefix_apply(
+ eigrp, ei, EIGRP_FILTER_OUT, dest_addr))
continue;
else {
- length += eigrp_add_internalTLV_to_stream(ep->s, pe);
+ length += eigrp_add_internalTLV_to_stream(ep->s,
+ pe);
}
}
}
- eigrp_update_place_on_nbr_queue (nbr, ep, seq_no, length);
+ eigrp_update_place_on_nbr_queue(nbr, ep, seq_no, length);
eigrp->sequence_number = seq_no++;
}
ep = eigrp_packet_new(ei->ifp->mtu, NULL);
/* Prepare EIGRP INIT UPDATE header */
- eigrp_packet_header_init(EIGRP_OPC_UPDATE, eigrp,
- ep->s, 0, seq_no, 0);
+ eigrp_packet_header_init(EIGRP_OPC_UPDATE, eigrp, ep->s, 0, seq_no, 0);
// encode Authentication TLV, if needed
if ((ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
if (eigrp_nbr_split_horizon_check(ne, ei))
continue;
- if ((length + EIGRP_TLV_MAX_IPV4_BYTE) >
- (u_int16_t)ei->ifp->mtu) {
+ if ((length + EIGRP_TLV_MAX_IPV4_BYTE)
+ > (u_int16_t)ei->ifp->mtu) {
if ((ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
&& (ei->params.auth_keychain != NULL)) {
- eigrp_make_md5_digest(ei, ep->s, EIGRP_AUTH_UPDATE_FLAG);
+ eigrp_make_md5_digest(ei, ep->s,
+ EIGRP_AUTH_UPDATE_FLAG);
}
eigrp_packet_checksum(ei, ep->s, length);
length = EIGRP_HEADER_LEN;
ep = eigrp_packet_new(ei->ifp->mtu, NULL);
- eigrp_packet_header_init(EIGRP_OPC_UPDATE, eigrp,
- ep->s, 0, seq_no, 0);
+ eigrp_packet_header_init(EIGRP_OPC_UPDATE, eigrp, ep->s,
+ 0, seq_no, 0);
if ((ei->params.auth_type == EIGRP_AUTH_TYPE_MD5)
&& (ei->params.auth_keychain != NULL)) {
- length += eigrp_add_authTLV_MD5_to_stream(ep->s, ei);
+ length += eigrp_add_authTLV_MD5_to_stream(ep->s,
+ ei);
}
has_tlv = 0;
}
/* Get destination address from prefix */
dest_addr = pe->destination;
- if (eigrp_update_prefix_apply(eigrp, ei,
- EIGRP_FILTER_OUT,
+ if (eigrp_update_prefix_apply(eigrp, ei, EIGRP_FILTER_OUT,
dest_addr)) {
// pe->reported_metric.delay = EIGRP_MAX_METRIC;
continue;
} else {
- length += eigrp_add_internalTLV_to_stream(ep->s,
- pe);
+ length += eigrp_add_internalTLV_to_stream(ep->s, pe);
has_tlv = 1;
}
}
/**
* @fn eigrp_update_send_GR_part
*
- * @param[in] nbr contains neighbor who would receive Graceful
+ * @param[in] nbr contains neighbor who would receive
+ * Graceful
* restart
*
* @return void
*/
dest_addr = pe->destination;
- if (eigrp_update_prefix_apply(eigrp, ei,
- EIGRP_FILTER_OUT,
+ if (eigrp_update_prefix_apply(eigrp, ei, EIGRP_FILTER_OUT,
dest_addr)) {
/* do not send filtered route */
zlog_info("Filtered prefix %s won't be sent out.",
* This makes no sense, Filter out then filter in???
* Look into this more - DBS
*/
- if (eigrp_update_prefix_apply(eigrp, ei,
- EIGRP_FILTER_IN,
+ if (eigrp_update_prefix_apply(eigrp, ei, EIGRP_FILTER_IN,
dest_addr)) {
/* do not send filtered route */
zlog_info("Filtered prefix %s will be removed.",
/**
* @fn eigrp_update_send_GR
*
- * @param[in] nbr Neighbor who would receive Graceful
+ * @param[in] nbr Neighbor who would receive
+ * Graceful
* restart
* @param[in] gr_type Who executed Graceful restart
* @param[in] vty Virtual terminal for log output
vty_out(vty,
"Neighbor %s (%s) is resync: manually cleared\n",
inet_ntoa(nbr->src),
- ifindex2ifname(ei->ifp->ifindex,
- VRF_DEFAULT));
+ ifindex2ifname(ei->ifp->ifindex, VRF_DEFAULT));
}
}
/**
* @fn eigrp_update_send_interface_GR
*
- * @param[in] ei Interface to neighbors of which the GR
+ * @param[in] ei Interface to neighbors of which
+ * the
+ * GR
* is sent
* @param[in] gr_type Who executed Graceful restart
* @param[in] vty Virtual terminal for log output
if (ei->params.auth_keychain) {
vty_out(vty,
" ip authentication key-chain eigrp %d %s\n",
- eigrp->AS,
- ei->params.auth_keychain);
+ eigrp->AS, ei->params.auth_keychain);
}
if (ei->params.v_hello != EIGRP_HELLO_INTERVAL_DEFAULT) {
vty_out(vty, " description %s\n", ifp->desc);
if (ei->params.bandwidth != EIGRP_BANDWIDTH_DEFAULT)
- vty_out(vty, " bandwidth %u\n",
- ei->params.bandwidth);
+ vty_out(vty, " bandwidth %u\n", ei->params.bandwidth);
if (ei->params.delay != EIGRP_DELAY_DEFAULT)
vty_out(vty, " delay %u\n", ei->params.delay);
if (ei->params.v_hello != EIGRP_HELLO_INTERVAL_DEFAULT)
& EIGRP_NEXTHOP_ENTRY_FSUCCESSOR_FLAG)
== EIGRP_NEXTHOP_ENTRY_FSUCCESSOR_FLAG))) {
show_ip_eigrp_nexthop_entry(vty, eigrp, te,
- &first);
+ &first);
first = 0;
}
}
ei->params.v_hello = EIGRP_HELLO_INTERVAL_DEFAULT;
THREAD_TIMER_OFF(ei->t_hello);
- thread_add_timer(master, eigrp_hello_timer, ei, 1,
- &ei->t_hello);
+ thread_add_timer(master, eigrp_hello_timer, ei, 1, &ei->t_hello);
return CMD_SUCCESS;
}
if (keychain != NULL) {
if (ei->params.auth_keychain) {
free(ei->params.auth_keychain);
- ei->params.auth_keychain =
- strdup(keychain->name);
+ ei->params.auth_keychain = strdup(keychain->name);
} else
- ei->params.auth_keychain =
- strdup(keychain->name);
+ ei->params.auth_keychain = strdup(keychain->name);
} else
vty_out(vty, "Key chain with specified name not found\n");
struct in_addr nbr_addr;
if (!inet_aton(argv[4]->arg, &nbr_addr)) {
- vty_out(vty, "Unable to parse %s",
- argv[4]->arg);
+ vty_out(vty, "Unable to parse %s", argv[4]->arg);
return CMD_WARNING;
}
struct in_addr nbr_addr;
if (!inet_aton(argv[4]->arg, &nbr_addr)) {
- vty_out(vty, "Unable to parse: %s",
- argv[4]->arg);
+ vty_out(vty, "Unable to parse: %s", argv[4]->arg);
return CMD_WARNING;
}
void eigrp_zebra_init(void)
{
- struct zclient_options opt = { .receive_notify = false };
+ struct zclient_options opt = {.receive_notify = false};
zclient = zclient_new_notify(master, &opt);
ifp->metric, ifp->mtu);
if (ifp->info)
- eigrp_if_free(ifp->info,
- INTERFACE_DOWN_BY_ZEBRA);
+ eigrp_if_free(ifp->info, INTERFACE_DOWN_BY_ZEBRA);
if_set_index(ifp, IFINDEX_INTERNAL);
return 0;
for (unsigned int i = 0; i < adj->area_address_count;
i++) {
vty_out(vty, " %s\n",
- isonet_print(adj->area_addresses[i]
- .area_addr,
- adj->area_addresses[i]
- .addr_len));
+ isonet_print(adj->area_addresses[i]
+ .area_addr,
+ adj->area_addresses[i]
+ .addr_len));
}
}
if (adj->ipv4_address_count) {
for (unsigned int i = 0; i < adj->ipv4_address_count;
i++)
vty_out(vty, " %s\n",
- inet_ntoa(adj->ipv4_addresses[i]));
+ inet_ntoa(adj->ipv4_addresses[i]));
}
if (adj->ipv6_address_count) {
vty_out(vty, " IPv6 Address(es):\n");
bpf_hdr->bh_caplen - LLC_LEN - ETHER_HDR_LEN);
stream_set_getp(circuit->rcv_stream, 0);
- memcpy(ssnpa, readbuff + bpf_hdr->bh_hdrlen + ETH_ALEN,
- ETH_ALEN);
+ memcpy(ssnpa, readbuff + bpf_hdr->bh_hdrlen + ETH_ALEN, ETH_ALEN);
if (ioctl(circuit->fd, BIOCFLUSH, &one) < 0)
zlog_warn("Flushing failed: %s", safe_strerror(errno));
/* Circuit ids MUST be unique for any broadcast circuits. Otherwise,
* Pseudo-Node LSPs cannot be generated correctly.
*
- * Currently, allocate one circuit ID for any circuit, limiting the total
+ * Currently, allocate one circuit ID for any circuit, limiting the
+ * total
* numer of circuits IS-IS can run on to 255.
*
- * We should revisit this when implementing 3-way adjacencies for p2p, since
+ * We should revisit this when implementing 3-way adjacencies for p2p,
+ * since
* we then have extended interface IDs available.
*/
uint8_t id = ifp->ifindex;
}
if (i == 256) {
- zlog_warn("Could not allocate a circuit id for '%s'", ifp->name);
+ zlog_warn("Could not allocate a circuit id for '%s'",
+ ifp->name);
return 0;
}
{
if (circuit->t_send_lsp)
return;
- circuit->t_send_lsp = thread_add_event(master, send_lsp, circuit, 0, NULL);
+ circuit->t_send_lsp =
+ thread_add_event(master, send_lsp, circuit, 0, NULL);
}
void isis_circuit_queue_lsp(struct isis_circuit *circuit, struct isis_lsp *lsp)
struct thread *t_send_csnp[2];
struct thread *t_send_psnp[2];
struct thread *t_send_lsp;
- struct list *lsp_queue; /* LSPs to be txed (both levels) */
- struct isis_lsp_hash *lsp_hash; /* Hashtable synchronized with lsp_queue */
+ struct list *lsp_queue; /* LSPs to be txed (both levels) */
+ struct isis_lsp_hash
+ *lsp_hash; /* Hashtable synchronized with lsp_queue */
time_t lsp_queue_last_push[2]; /* timestamp used to enforce transmit
* interval;
* for scalability, use one timestamp per
int (*tx)(struct isis_circuit *circuit, int level);
struct stream *snd_stream; /* Stream for sending */
int idx; /* idx in S[RM|SN] flags */
- /* $FRR indent$ */
- /* clang-format off */
#define CIRCUIT_T_UNKNOWN 0
#define CIRCUIT_T_BROADCAST 1
#define CIRCUIT_T_P2P 2
bool ipv6_router);
ferr_r isis_circuit_passive_set(struct isis_circuit *circuit, bool passive);
void isis_circuit_is_type_set(struct isis_circuit *circuit, int is_type);
-ferr_r isis_circuit_circ_type_set (struct isis_circuit *circuit, int circ_type);
+ferr_r isis_circuit_circ_type_set(struct isis_circuit *circuit, int circ_type);
ferr_r isis_circuit_metric_set(struct isis_circuit *circuit, int level,
int metric);
void flags_free_index(struct flags *flags, long int index);
int flags_any_set(u_int32_t *flags);
-#define _ISIS_SET_FLAG(F, C) \
- { \
- F[(C) >> 5] |= (1 << ((C) & 0x1F)); \
+#define _ISIS_SET_FLAG(F, C) \
+ { \
+ F[(C) >> 5] |= (1 << ((C)&0x1F)); \
}
#define ISIS_SET_FLAG(F, C) _ISIS_SET_FLAG(F, C->idx)
-
-#define _ISIS_CLEAR_FLAG(F, C) \
- { \
- F[(C) >> 5] &= ~(1 << ((C) & 0x1F)); \
+#define _ISIS_CLEAR_FLAG(F, C) \
+ { \
+ F[(C) >> 5] &= ~(1 << ((C)&0x1F)); \
}
#define ISIS_CLEAR_FLAG(F, C) _ISIS_CLEAR_FLAG(F, C->idx)
-
#define _ISIS_CHECK_FLAG(F, C) (F[(C)>>5] & (1<<((C) & 0x1F)))
#define ISIS_CHECK_FLAG(F, C) _ISIS_CHECK_FLAG(F, C->idx)
struct list *fragments = isis_fragment_tlvs(tlvs, tlv_space);
if (!fragments) {
zlog_warn("BUG: could not fragment own LSP:");
- log_multiline(LOG_WARNING, " ", "%s", isis_format_tlvs(tlvs));
+ log_multiline(LOG_WARNING, " ", "%s",
+ isis_format_tlvs(tlvs));
isis_free_tlvs(tlvs);
return;
}
if (LSP_FRAGMENT(frag->hdr.lsp_id) == 255) {
if (!fragment_overflow) {
fragment_overflow = true;
- zlog_warn("ISIS (%s): Too much information for 256 fragments",
- area->area_tag);
+ zlog_warn(
+ "ISIS (%s): Too much information for 256 fragments",
+ area->area_tag);
}
isis_free_tlvs(tlvs);
continue;
dnode_t *dnode, *dnode_next;
int level;
u_int16_t rem_lifetime;
- time_t now = monotime(NULL);
+ time_t now = monotime(NULL);
lsp_list = list_new();
if (!circuit->lsp_queue)
continue;
- if (now - circuit->lsp_queue_last_push[level]
+ if (now
+ - circuit->lsp_queue_last_push
+ [level]
< MIN_LSP_RETRANS_INTERVAL) {
continue;
}
- circuit->lsp_queue_last_push[level] = now;
+ circuit->lsp_queue_last_push[level] =
+ now;
for (ALL_LIST_ELEMENTS_RO(
lsp_list, lspnode, lsp)) {
&& ISIS_CHECK_FLAG(
lsp->SRMflags,
circuit)) {
- isis_circuit_queue_lsp(circuit, lsp);
+ isis_circuit_queue_lsp(
+ circuit, lsp);
}
}
}
}
struct isis_lsp *isis_lsp_hash_lookup(struct isis_lsp_hash *ih,
- struct isis_lsp *lsp)
+ struct isis_lsp *lsp)
{
return hash_lookup(ih->h, lsp);
}
lsp_set_all_srmflags(lsp);
/* v */
ISIS_FLAGS_CLEAR_ALL(
- lsp
- ->SSNflags); /* FIXME:
- OTHER
- than c
- */
+ lsp->SSNflags); /* FIXME:
+ OTHER
+ than c
+ */
/* For the case of lsp confusion, flood
* the purge back to its
entry = entry->next) {
zlog_debug(
"ISIS-Snp (%s): %cSNP entry %s, seq 0x%08" PRIx32
- ", cksum 0x%04" PRIx16 ", lifetime %" PRIu16 "s",
+ ", cksum 0x%04" PRIx16 ", lifetime %" PRIu16
+ "s",
circuit->area->area_tag, typechar,
rawlspid_print(entry->id), entry->seqno,
entry->checksum, entry->rem_lifetime);
ISIS_SYS_ID_LEN + 1);
LSP_FRAGMENT(lspid) = 0;
lsp0 = lsp_search(
- lspid,
- circuit->area->lspdb[level - 1]);
+ lspid,
+ circuit->area
+ ->lspdb[level - 1]);
if (!lsp0) {
- zlog_debug("Got lsp frag in snp, while zero not in database");
+ zlog_debug(
+ "Got lsp frag in snp, while zero not in database");
continue;
}
}
#include "privs.h"
/* tcpdump -i eth0 'isis' -dd */
-static struct sock_filter isisfilter[] =
- {
- /* NB: we're in SOCK_DGRAM, so src/dst mac + length are stripped
- * off!
- * (OTOH it's a bit more lower-layer agnostic and might work
- * over GRE?) */
- /* { 0x28, 0, 0, 0x0000000c - 14 }, */
- /* { 0x25, 5, 0, 0x000005dc }, */
- {0x28, 0, 0, 0x0000000e - 14}, {0x15, 0, 3, 0x0000fefe},
- {0x30, 0, 0, 0x00000011 - 14}, {0x15, 0, 1, 0x00000083},
- {0x6, 0, 0, 0x00040000}, {0x6, 0, 0, 0x00000000},
+static struct sock_filter isisfilter[] = {
+ /* NB: we're in SOCK_DGRAM, so src/dst mac + length are stripped
+ * off!
+ * (OTOH it's a bit more lower-layer agnostic and might work
+ * over GRE?) */
+ /* { 0x28, 0, 0, 0x0000000c - 14 }, */
+ /* { 0x25, 5, 0, 0x000005dc }, */
+ {0x28, 0, 0, 0x0000000e - 14}, {0x15, 0, 3, 0x0000fefe},
+ {0x30, 0, 0, 0x00000011 - 14}, {0x15, 0, 1, 0x00000083},
+ {0x6, 0, 0, 0x00040000}, {0x6, 0, 0, 0x00000000},
};
static struct sock_fprog bpf = {
struct prefix prefix;
} N;
- u_int32_t d_N; /* d(N) Distance from this IS */
- u_int16_t depth; /* The depth in the imaginary tree */
- struct list *Adj_N; /* {Adj(N)} next hop or neighbor list */
- struct list *parents; /* list of parents for ECMP */
+ u_int32_t d_N; /* d(N) Distance from this IS */
+ u_int16_t depth; /* The depth in the imaginary tree */
+ struct list *Adj_N; /* {Adj(N)} next hop or neighbor list */
+ struct list *parents; /* list of parents for ECMP */
uint64_t insert_counter;
};
return skiplist_new(0, isis_vertex_queue_tent_cmp, NULL);
}
-static void isis_vertex_queue_init(struct isis_vertex_queue *queue, const char *name, bool ordered)
+static void isis_vertex_queue_init(struct isis_vertex_queue *queue,
+ const char *name, bool ordered)
{
if (ordered) {
queue->insert_counter = 1;
queue->l.list = list_new();
}
queue->hash = hash_create(isis_vertex_queue_hash_key,
- isis_vertex_queue_hash_cmp,
- name);
+ isis_vertex_queue_hash_cmp, name);
}
static void isis_vertex_del(struct isis_vertex *vertex);
if (queue->insert_counter) {
struct isis_vertex *vertex;
- while (0 == skiplist_first(queue->l.slist, NULL, (void**)&vertex)) {
+ while (0 == skiplist_first(queue->l.slist, NULL,
+ (void **)&vertex)) {
isis_vertex_del(vertex);
skiplist_delete_first(queue->l.slist);
}
assert(inserted == vertex);
}
-static struct isis_vertex *isis_vertex_queue_pop(struct isis_vertex_queue *queue)
+static struct isis_vertex *
+isis_vertex_queue_pop(struct isis_vertex_queue *queue)
{
assert(queue->insert_counter);
struct isis_vertex *rv;
- if (skiplist_first(queue->l.slist, NULL, (void**)&rv))
+ if (skiplist_first(queue->l.slist, NULL, (void **)&rv))
return NULL;
skiplist_delete_first(queue->l.slist);
hash_release(queue->hash, vertex);
}
-#define ALL_QUEUE_ELEMENTS_RO(queue, node, data) \
- ALL_LIST_ELEMENTS_RO((queue)->l.list, node, data)
+#define ALL_QUEUE_ELEMENTS_RO(queue, node, data) \
+ ALL_LIST_ELEMENTS_RO((queue)->l.list, node, data)
/* End of vertex queue definitions */
struct isis_spftree {
struct isis_vertex_queue paths; /* the SPT */
struct isis_vertex_queue tents; /* TENT */
- struct isis_area *area; /* back pointer to area */
- unsigned int runcount; /* number of runs since uptime */
- time_t last_run_timestamp; /* last run timestamp as wall time for display */
- time_t last_run_monotime; /* last run as monotime for scheduling */
- time_t last_run_duration; /* last run duration in msec */
+ struct isis_area *area; /* back pointer to area */
+ unsigned int runcount; /* number of runs since uptime */
+ time_t last_run_timestamp; /* last run timestamp as wall time for
+ display */
+ time_t last_run_monotime; /* last run as monotime for scheduling */
+ time_t last_run_duration; /* last run duration in msec */
uint16_t mtid;
int family;
return "UNKNOWN";
}
-static void isis_vertex_id_init(struct isis_vertex *vertex, void *id, enum vertextype vtype)
+static void isis_vertex_id_init(struct isis_vertex *vertex, void *id,
+ enum vertextype vtype)
{
vertex->type = vtype;
return vertex;
}
-static struct isis_vertex *isis_find_vertex(struct isis_vertex_queue *queue, void *id,
- enum vertextype vtype)
+static struct isis_vertex *isis_find_vertex(struct isis_vertex_queue *queue,
+ void *id, enum vertextype vtype)
{
struct isis_vertex querier;
return ISIS_OK;
/* RFC3787 section 4 SHOULD ignore overload bit in pseudo LSPs */
- bool no_overload = (pseudo_lsp
- || (spftree->mtid == ISIS_MT_IPV4_UNICAST
+ bool no_overload =
+ (pseudo_lsp || (spftree->mtid == ISIS_MT_IPV4_UNICAST
&& !ISIS_MASK_LSP_OL_BIT(lsp->hdr.lsp_bits))
- || (mt_router_info && !mt_router_info->overload));
+ || (mt_router_info && !mt_router_info->overload));
lspfragloop:
if (lsp->hdr.seqno == 0) {
if (area->ip_circuits)
retval = isis_run_spf(area, level, AF_INET, isis->sysid,
- &thread->real);
+ &thread->real);
if (area->ipv6_circuits)
retval = isis_run_spf(area, level, AF_INET6, isis->sysid,
- &thread->real);
+ &thread->real);
return retval;
}
/* wait configured min_spf_interval before doing the SPF */
long timer;
if (diff >= area->min_spf_interval[level - 1]) {
- /* Last run is more than min interval ago, schedule immediate run */
+ /* Last run is more than min interval ago, schedule immediate
+ * run */
timer = 0;
} else {
timer = area->min_spf_interval[level - 1] - diff;
vty_out(vty, "%-20s %-12s %-6u ",
vid2string(vertex, buff, sizeof(buff)),
vtype2string(vertex->type), vertex->d_N);
- for (unsigned int i = 0;
- i < MAX(listcount(vertex->Adj_N),
- listcount(vertex->parents)); i++) {
+ for (unsigned int i = 0; i < MAX(listcount(vertex->Adj_N),
+ listcount(vertex->parents));
+ i++) {
if (anode) {
adj = listgetdata(anode);
anode = anode->next;
vty_out(vty, "%-20s %-9s ", "", "");
vty_out(vty, "%s(%d)",
- vid2string(pvertex, buff,
- sizeof(buff)),
+ vid2string(pvertex, buff, sizeof(buff)),
pvertex->type);
}
continue;
if (area->ip_circuits > 0 && area->spftree[level - 1]
- && isis_vertex_queue_count(&area->spftree[level - 1]->paths) > 0) {
+ && isis_vertex_queue_count(
+ &area->spftree[level - 1]->paths)
+ > 0) {
vty_out(vty,
"IS-IS paths to level-%d routers that speak IP\n",
level);
vty_out(vty, "\n");
}
if (area->ipv6_circuits > 0 && area->spftree6[level - 1]
- && isis_vertex_queue_count(&area->spftree6[level - 1]->paths) > 0) {
+ && isis_vertex_queue_count(
+ &area->spftree6[level - 1]->paths)
+ > 0) {
vty_out(vty,
"IS-IS paths to level-%d routers that speak IPv6\n",
level);
vty_out(vty, " last run duration : %u usec\n",
(u_int32_t)spftree->last_run_duration);
- vty_out(vty, " run count : %u\n",
- spftree->runcount);
+ vty_out(vty, " run count : %u\n", spftree->runcount);
}
fval = ntohf(tlv->value);
- sbuf_push(buf, indent, "Maximum Reservable Bandwidth: %g (Bytes/sec)\n", fval);
+ sbuf_push(buf, indent, "Maximum Reservable Bandwidth: %g (Bytes/sec)\n",
+ fval);
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
for (i = 0; i < MAX_CLASS_TYPE; i += 2) {
fval1 = ntohf(tlv->value[i]);
fval2 = ntohf(tlv->value[i + 1]);
- sbuf_push(buf, indent + 2, "[%d]: %g (Bytes/sec),\t[%d]: %g (Bytes/sec)\n",
- i, fval1, i + 1, fval2);
+ sbuf_push(buf, indent + 2,
+ "[%d]: %g (Bytes/sec),\t[%d]: %g (Bytes/sec)\n", i,
+ fval1, i + 1, fval2);
}
return (SUBTLV_HDR_SIZE + TE_SUBTLV_UNRSV_SIZE);
delay = (u_int32_t)ntohl(tlv->value) & TE_EXT_MASK;
A = (u_int32_t)ntohl(tlv->value) & TE_EXT_ANORMAL;
- sbuf_push(buf, indent, "%s Average Link Delay: %" PRIu32 " (micro-sec)\n",
+ sbuf_push(buf, indent,
+ "%s Average Link Delay: %" PRIu32 " (micro-sec)\n",
A ? "Anomalous" : "Normal", delay);
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
A = (u_int32_t)ntohl(tlv->low) & TE_EXT_ANORMAL;
high = (u_int32_t)ntohl(tlv->high) & TE_EXT_MASK;
- sbuf_push(buf, indent, "%s Min/Max Link Delay: %" PRIu32 " / %" PRIu32 " (micro-sec)\n",
+ sbuf_push(buf, indent, "%s Min/Max Link Delay: %" PRIu32 " / %" PRIu32
+ " (micro-sec)\n",
A ? "Anomalous" : "Normal", low, high);
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
jitter = (u_int32_t)ntohl(tlv->value) & TE_EXT_MASK;
- sbuf_push(buf, indent, "Delay Variation: %" PRIu32 " (micro-sec)\n", jitter);
+ sbuf_push(buf, indent, "Delay Variation: %" PRIu32 " (micro-sec)\n",
+ jitter);
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
fval = ntohf(tlv->value);
- sbuf_push(buf, indent, "Unidirectional Residual Bandwidth: %g (Bytes/sec)\n",
- fval);
+ sbuf_push(buf, indent,
+ "Unidirectional Residual Bandwidth: %g (Bytes/sec)\n", fval);
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
fval = ntohf(tlv->value);
- sbuf_push(buf, indent, "Unidirectional Available Bandwidth: %g (Bytes/sec)\n",
- fval);
+ sbuf_push(buf, indent,
+ "Unidirectional Available Bandwidth: %g (Bytes/sec)\n", fval);
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
fval = ntohf(tlv->value);
- sbuf_push(buf, indent, "Unidirectional Utilized Bandwidth: %g (Bytes/sec)\n",
- fval);
+ sbuf_push(buf, indent,
+ "Unidirectional Utilized Bandwidth: %g (Bytes/sec)\n", fval);
return (SUBTLV_HDR_SIZE + SUBTLV_DEF_SIZE);
}
sbuf_push(buf, 0, " %#.2x", v[i]);
if (rtn == 8) {
sbuf_push(buf, 0, "\n");
- sbuf_push(buf, indent + 8,
- "[%.2x]", i + 1);
+ sbuf_push(buf, indent + 8, "[%.2x]", i + 1);
rtn = 1;
} else
rtn++;
}
/* Main Show function */
-void mpls_te_print_detail(struct sbuf *buf, int indent,
- uint8_t *subtlvs, uint8_t subtlv_len)
+void mpls_te_print_detail(struct sbuf *buf, int indent, uint8_t *subtlvs,
+ uint8_t subtlv_len)
{
struct subtlv_header *tlvh = (struct subtlv_header *)subtlvs;
uint16_t sum = 0;
for (; sum < subtlv_len; tlvh = SUBTLV_HDR_NEXT(tlvh)) {
switch (tlvh->type) {
case TE_SUBTLV_ADMIN_GRP:
- sum += print_subtlv_admin_grp(buf, indent,
+ sum += print_subtlv_admin_grp(
+ buf, indent,
(struct te_subtlv_admin_grp *)tlvh);
break;
case TE_SUBTLV_LLRI:
sum += print_subtlv_llri(buf, indent,
- (struct te_subtlv_llri *)tlvh);
+ (struct te_subtlv_llri *)tlvh);
break;
case TE_SUBTLV_LOCAL_IPADDR:
- sum += print_subtlv_local_ipaddr(buf, indent,
+ sum += print_subtlv_local_ipaddr(
+ buf, indent,
(struct te_subtlv_local_ipaddr *)tlvh);
break;
case TE_SUBTLV_RMT_IPADDR:
- sum += print_subtlv_rmt_ipaddr(buf, indent,
+ sum += print_subtlv_rmt_ipaddr(
+ buf, indent,
(struct te_subtlv_rmt_ipaddr *)tlvh);
break;
case TE_SUBTLV_MAX_BW:
- sum += print_subtlv_max_bw(buf, indent,
- (struct te_subtlv_max_bw *)tlvh);
+ sum += print_subtlv_max_bw(
+ buf, indent, (struct te_subtlv_max_bw *)tlvh);
break;
case TE_SUBTLV_MAX_RSV_BW:
- sum += print_subtlv_max_rsv_bw(buf, indent,
+ sum += print_subtlv_max_rsv_bw(
+ buf, indent,
(struct te_subtlv_max_rsv_bw *)tlvh);
break;
case TE_SUBTLV_UNRSV_BW:
- sum += print_subtlv_unrsv_bw(buf, indent,
- (struct te_subtlv_unrsv_bw *)tlvh);
+ sum += print_subtlv_unrsv_bw(
+ buf, indent, (struct te_subtlv_unrsv_bw *)tlvh);
break;
case TE_SUBTLV_TE_METRIC:
- sum += print_subtlv_te_metric(buf, indent,
+ sum += print_subtlv_te_metric(
+ buf, indent,
(struct te_subtlv_te_metric *)tlvh);
break;
case TE_SUBTLV_RAS:
sum += print_subtlv_ras(buf, indent,
- (struct te_subtlv_ras *)tlvh);
+ (struct te_subtlv_ras *)tlvh);
break;
case TE_SUBTLV_RIP:
sum += print_subtlv_rip(buf, indent,
- (struct te_subtlv_rip *)tlvh);
+ (struct te_subtlv_rip *)tlvh);
break;
case TE_SUBTLV_AV_DELAY:
- sum += print_subtlv_av_delay(buf, indent,
- (struct te_subtlv_av_delay *)tlvh);
+ sum += print_subtlv_av_delay(
+ buf, indent, (struct te_subtlv_av_delay *)tlvh);
break;
case TE_SUBTLV_MM_DELAY:
- sum += print_subtlv_mm_delay(buf, indent,
- (struct te_subtlv_mm_delay *)tlvh);
+ sum += print_subtlv_mm_delay(
+ buf, indent, (struct te_subtlv_mm_delay *)tlvh);
break;
case TE_SUBTLV_DELAY_VAR:
- sum += print_subtlv_delay_var(buf, indent,
+ sum += print_subtlv_delay_var(
+ buf, indent,
(struct te_subtlv_delay_var *)tlvh);
break;
case TE_SUBTLV_PKT_LOSS:
- sum += print_subtlv_pkt_loss(buf, indent,
- (struct te_subtlv_pkt_loss *)tlvh);
+ sum += print_subtlv_pkt_loss(
+ buf, indent, (struct te_subtlv_pkt_loss *)tlvh);
break;
case TE_SUBTLV_RES_BW:
- sum += print_subtlv_res_bw(buf, indent,
- (struct te_subtlv_res_bw *)tlvh);
+ sum += print_subtlv_res_bw(
+ buf, indent, (struct te_subtlv_res_bw *)tlvh);
break;
case TE_SUBTLV_AVA_BW:
- sum += print_subtlv_ava_bw(buf, indent,
- (struct te_subtlv_ava_bw *)tlvh);
+ sum += print_subtlv_ava_bw(
+ buf, indent, (struct te_subtlv_ava_bw *)tlvh);
break;
case TE_SUBTLV_USE_BW:
- sum += print_subtlv_use_bw(buf, indent,
- (struct te_subtlv_use_bw *)tlvh);
+ sum += print_subtlv_use_bw(
+ buf, indent, (struct te_subtlv_use_bw *)tlvh);
break;
default:
sum += print_unknown_tlv(buf, indent, tlvh);
void isis_mpls_te_init(void);
struct mpls_te_circuit *mpls_te_circuit_new(void);
struct sbuf;
-void mpls_te_print_detail(struct sbuf *buf, int indent, uint8_t *subtlvs, uint8_t subtlv_len);
+void mpls_te_print_detail(struct sbuf *buf, int indent, uint8_t *subtlvs,
+ uint8_t subtlv_len);
void set_circuitparams_local_ipaddr(struct mpls_te_circuit *, struct in_addr);
void set_circuitparams_rmt_ipaddr(struct mpls_te_circuit *, struct in_addr);
uint8_t subtlvs_len(struct mpls_te_circuit *);
sbuf_push(log, indent, "Unpacking IPv6 Source Prefix Sub-TLV...\n");
if (tlv_len < 1) {
- sbuf_push(log, indent,
- "Not enough data left. (expected 1 or more bytes, got %" PRIu8 ")\n",
- tlv_len);
+ sbuf_push(
+ log, indent,
+ "Not enough data left. (expected 1 or more bytes, got %" PRIu8
+ ")\n",
+ tlv_len);
return 1;
}
{
struct isis_lsp_entry *e = (struct isis_lsp_entry *)i;
- sbuf_push(buf, indent, "LSP Entry: %s, seq 0x%08" PRIx32
- ", cksum 0x%04" PRIx16 ", lifetime %" PRIu16 "s\n",
+ sbuf_push(buf, indent,
+ "LSP Entry: %s, seq 0x%08" PRIx32 ", cksum 0x%04" PRIx16
+ ", lifetime %" PRIu16 "s\n",
isis_format_id(e->id, 8), e->seqno, e->checksum,
e->rem_lifetime);
}
sbuf_push(buf, 0, "\n");
if (r->subtlv_len && r->subtlvs)
- mpls_te_print_detail(buf, indent + 2, r->subtlvs, r->subtlv_len);
+ mpls_te_print_detail(buf, indent + 2, r->subtlvs,
+ r->subtlv_len);
}
static void free_item_extended_reach(struct isis_item *i)
(mtid == ISIS_MT_IPV4_UNICAST) ? "extended" : "mt");
if (len < 11) {
- sbuf_push(log, indent,
- "Not enough data left. (expected 11 or more bytes, got %"
- PRIu8 ")\n",
- len);
+ sbuf_push(
+ log, indent,
+ "Not enough data left. (expected 11 or more bytes, got %" PRIu8
+ ")\n",
+ len);
goto out;
}
char prefixbuf[PREFIX2STR_BUFFER];
sbuf_push(buf, indent, "IP Reachability: %s (Metric: %" PRIu8 ")\n",
- prefix2str(&r->prefix, prefixbuf, sizeof(prefixbuf)), r->metric);
+ prefix2str(&r->prefix, prefixbuf, sizeof(prefixbuf)),
+ r->metric);
}
static void free_item_oldstyle_ip_reach(struct isis_item *i)
struct isis_mt_router_info *info = (struct isis_mt_router_info *)i;
sbuf_push(buf, indent, "MT Router Info: %s%s%s\n",
- isis_mtid2str(info->mtid),
- info->overload ? " Overload" : "",
+ isis_mtid2str(info->mtid), info->overload ? " Overload" : "",
info->attached ? " Attached" : "");
}
sbuf_push(buf, indent, "%s IP Reachability: %s (Metric: %u)%s",
(mtid == ISIS_MT_IPV4_UNICAST) ? "Extended" : "MT",
- prefix2str(&r->prefix, prefixbuf, sizeof(prefixbuf)), r->metric,
- r->down ? " Down" : "");
+ prefix2str(&r->prefix, prefixbuf, sizeof(prefixbuf)),
+ r->metric, r->down ? " Down" : "");
if (mtid != ISIS_MT_IPV4_UNICAST)
sbuf_push(buf, 0, " %s", isis_mtid2str(mtid));
sbuf_push(buf, 0, "\n");
consume = 5;
if (len < consume) {
- sbuf_push(log, indent,
- "Not enough data left. (expected 5 or more bytes, got %" PRIu8 ")\n",
- len);
+ sbuf_push(
+ log, indent,
+ "Not enough data left. (expected 5 or more bytes, got %" PRIu8
+ ")\n",
+ len);
goto out;
}
consume += PSIZE(rv->prefix.prefixlen);
if (len < consume) {
- sbuf_push(log, indent,
- "Expected %u bytes of prefix, but only %u bytes available.\n",
- PSIZE(rv->prefix.prefixlen), len - 5);
+ sbuf_push(
+ log, indent,
+ "Expected %u bytes of prefix, but only %u bytes available.\n",
+ PSIZE(rv->prefix.prefixlen), len - 5);
goto out;
}
stream_get(&rv->prefix.prefix.s_addr, s, PSIZE(rv->prefix.prefixlen));
if (control & ISIS_EXTENDED_IP_REACH_SUBTLV) {
consume += 1;
if (len < consume) {
- sbuf_push(log, indent,
- "Expected 1 byte of subtlv len, but no more data present.\n");
+ sbuf_push(
+ log, indent,
+ "Expected 1 byte of subtlv len, but no more data present.\n");
goto out;
}
subtlv_len = stream_getc(s);
if (!subtlv_len) {
- sbuf_push(log, indent + 2,
- " WARNING: subtlv bit is set, but there are no subtlvs.\n");
+ sbuf_push(
+ log, indent + 2,
+ " WARNING: subtlv bit is set, but there are no subtlvs.\n");
}
consume += subtlv_len;
if (len < consume) {
- sbuf_push(log, indent,
- "Expected %" PRIu8
- " bytes of subtlvs, but only %u bytes available.\n",
- subtlv_len,
- len - 6 - PSIZE(rv->prefix.prefixlen));
+ sbuf_push(
+ log, indent,
+ "Expected %" PRIu8
+ " bytes of subtlvs, but only %u bytes available.\n",
+ subtlv_len,
+ len - 6 - PSIZE(rv->prefix.prefixlen));
goto out;
}
sbuf_push(log, indent, "Skipping %" PRIu8 " bytes of subvls",
sbuf_push(buf, indent, "%sIPv6 Reachability: %s (Metric: %u)%s%s",
(mtid == ISIS_MT_IPV4_UNICAST) ? "" : "MT ",
prefix2str(&r->prefix, prefixbuf, sizeof(prefixbuf)),
- r->metric,
- r->down ? " Down" : "",
+ r->metric, r->down ? " Down" : "",
r->external ? " External" : "");
if (mtid != ISIS_MT_IPV4_UNICAST)
sbuf_push(buf, 0, " %s", isis_mtid2str(mtid));
(mtid == ISIS_MT_IPV4_UNICAST) ? "" : "mt ");
consume = 6;
if (len < consume) {
- sbuf_push(log, indent,
- "Not enough data left. (expected 6 or more bytes, got %"
- PRIu8 ")\n",
- len);
+ sbuf_push(
+ log, indent,
+ "Not enough data left. (expected 6 or more bytes, got %" PRIu8
+ ")\n",
+ len);
goto out;
}
consume += PSIZE(rv->prefix.prefixlen);
if (len < consume) {
- sbuf_push(log, indent,
- "Expected %u bytes of prefix, but only %u bytes available.\n",
- PSIZE(rv->prefix.prefixlen), len - 6);
+ sbuf_push(
+ log, indent,
+ "Expected %u bytes of prefix, but only %u bytes available.\n",
+ PSIZE(rv->prefix.prefixlen), len - 6);
goto out;
}
stream_get(&rv->prefix.prefix.s6_addr, s, PSIZE(rv->prefix.prefixlen));
if (control & ISIS_IPV6_REACH_SUBTLV) {
consume += 1;
if (len < consume) {
- sbuf_push(log, indent,
- "Expected 1 byte of subtlv len, but no more data persent.\n");
+ sbuf_push(
+ log, indent,
+ "Expected 1 byte of subtlv len, but no more data persent.\n");
goto out;
}
subtlv_len = stream_getc(s);
if (!subtlv_len) {
- sbuf_push(log, indent + 2,
- " WARNING: subtlv bit set, but there are no subtlvs.\n");
+ sbuf_push(
+ log, indent + 2,
+ " WARNING: subtlv bit set, but there are no subtlvs.\n");
}
consume += subtlv_len;
if (len < consume) {
- sbuf_push(log, indent,
- "Expected %" PRIu8
- " bytes of subtlvs, but only %u bytes available.\n",
- subtlv_len,
- len - 6 - PSIZE(rv->prefix.prefixlen));
+ sbuf_push(
+ log, indent,
+ "Expected %" PRIu8
+ " bytes of subtlvs, but only %u bytes available.\n",
+ subtlv_len,
+ len - 6 - PSIZE(rv->prefix.prefixlen));
goto out;
}
return 1;
}
-static void add_item_to_fragment(struct isis_item *i, struct pack_order_entry *pe,
+static void add_item_to_fragment(struct isis_item *i,
+ struct pack_order_entry *pe,
struct isis_tlvs *fragment_tlvs, uint16_t mtid)
{
struct isis_item_list *l;
if (pe->how_to_pack == ISIS_ITEMS) {
- l = (struct isis_item_list *)(((char *)fragment_tlvs) + pe->what_to_pack);
+ l = (struct isis_item_list *)(((char *)fragment_tlvs)
+ + pe->what_to_pack);
} else {
struct isis_mt_item_list *m;
- m = (struct isis_mt_item_list *)(((char *)fragment_tlvs) + pe->what_to_pack);
+ m = (struct isis_mt_item_list *)(((char *)fragment_tlvs)
+ + pe->what_to_pack);
l = isis_get_mt_items(m, mtid);
}
/* When fragmenting, don't add auth as it's already accounted for in the
* size we are given. */
if (!fragment_tlvs) {
- rv = pack_items(ISIS_CONTEXT_LSP, ISIS_TLV_AUTH, &tlvs->isis_auth,
- stream, NULL, NULL, NULL, NULL);
+ rv = pack_items(ISIS_CONTEXT_LSP, ISIS_TLV_AUTH,
+ &tlvs->isis_auth, stream, NULL, NULL, NULL,
+ NULL);
if (rv)
return rv;
}
tlv_type, tlv_len);
if (avail_len < ((size_t)tlv_len) + 2) {
- sbuf_push(log, indent + 2,
- "Available data %zu too short for claimed TLV len %" PRIu8 ".\n",
- avail_len - 2, tlv_len);
+ sbuf_push(
+ log, indent + 2,
+ "Available data %zu too short for claimed TLV len %" PRIu8
+ ".\n",
+ avail_len - 2, tlv_len);
return 1;
}
static const struct tlv_ops tlv_##_name_##_ops = { \
.name = _desc_, \
.unpack = unpack_tlv_with_items, \
- \
+ \
.pack_item = pack_item_##_name_, \
.free_item = free_item_##_name_, \
.unpack_item = unpack_item_##_name_, \
SUBTLV_OPS(ipv6_source_prefix, "Sub-TLV 22 IPv6 Source Prefix");
-static const struct tlv_ops *tlv_table[ISIS_CONTEXT_MAX][ISIS_TLV_MAX] = {
- [ISIS_CONTEXT_LSP] = {
- [ISIS_TLV_AREA_ADDRESSES] = &tlv_area_address_ops,
- [ISIS_TLV_OLDSTYLE_REACH] = &tlv_oldstyle_reach_ops,
- [ISIS_TLV_LAN_NEIGHBORS] = &tlv_lan_neighbor_ops,
- [ISIS_TLV_LSP_ENTRY] = &tlv_lsp_entry_ops,
- [ISIS_TLV_AUTH] = &tlv_auth_ops,
- [ISIS_TLV_EXTENDED_REACH] = &tlv_extended_reach_ops,
- [ISIS_TLV_MT_REACH] = &tlv_extended_reach_ops,
- [ISIS_TLV_OLDSTYLE_IP_REACH] = &tlv_oldstyle_ip_reach_ops,
- [ISIS_TLV_PROTOCOLS_SUPPORTED] = &tlv_protocols_supported_ops,
- [ISIS_TLV_OLDSTYLE_IP_REACH_EXT] = &tlv_oldstyle_ip_reach_ops,
- [ISIS_TLV_IPV4_ADDRESS] = &tlv_ipv4_address_ops,
- [ISIS_TLV_TE_ROUTER_ID] = &tlv_te_router_id_ops,
- [ISIS_TLV_EXTENDED_IP_REACH] = &tlv_extended_ip_reach_ops,
- [ISIS_TLV_MT_IP_REACH] = &tlv_extended_ip_reach_ops,
- [ISIS_TLV_DYNAMIC_HOSTNAME] = &tlv_dynamic_hostname_ops,
- [ISIS_TLV_MT_ROUTER_INFO] = &tlv_mt_router_info_ops,
- [ISIS_TLV_IPV6_ADDRESS] = &tlv_ipv6_address_ops,
- [ISIS_TLV_IPV6_REACH] = &tlv_ipv6_reach_ops,
- [ISIS_TLV_MT_IPV6_REACH] = &tlv_ipv6_reach_ops,
- },
- [ISIS_CONTEXT_SUBTLV_NE_REACH] = {},
- [ISIS_CONTEXT_SUBTLV_IP_REACH] = {},
- [ISIS_CONTEXT_SUBTLV_IPV6_REACH] = {
- [ISIS_SUBTLV_IPV6_SOURCE_PREFIX] = &subtlv_ipv6_source_prefix_ops,
- }
-};
+static const struct tlv_ops *tlv_table[ISIS_CONTEXT_MAX][ISIS_TLV_MAX] =
+ {[ISIS_CONTEXT_LSP] =
+ {
+ [ISIS_TLV_AREA_ADDRESSES] =
+ &tlv_area_address_ops,
+ [ISIS_TLV_OLDSTYLE_REACH] =
+ &tlv_oldstyle_reach_ops,
+ [ISIS_TLV_LAN_NEIGHBORS] =
+ &tlv_lan_neighbor_ops,
+ [ISIS_TLV_LSP_ENTRY] = &tlv_lsp_entry_ops,
+ [ISIS_TLV_AUTH] = &tlv_auth_ops,
+ [ISIS_TLV_EXTENDED_REACH] =
+ &tlv_extended_reach_ops,
+ [ISIS_TLV_MT_REACH] = &tlv_extended_reach_ops,
+ [ISIS_TLV_OLDSTYLE_IP_REACH] =
+ &tlv_oldstyle_ip_reach_ops,
+ [ISIS_TLV_PROTOCOLS_SUPPORTED] =
+ &tlv_protocols_supported_ops,
+ [ISIS_TLV_OLDSTYLE_IP_REACH_EXT] =
+ &tlv_oldstyle_ip_reach_ops,
+ [ISIS_TLV_IPV4_ADDRESS] =
+ &tlv_ipv4_address_ops,
+ [ISIS_TLV_TE_ROUTER_ID] =
+ &tlv_te_router_id_ops,
+ [ISIS_TLV_EXTENDED_IP_REACH] =
+ &tlv_extended_ip_reach_ops,
+ [ISIS_TLV_MT_IP_REACH] =
+ &tlv_extended_ip_reach_ops,
+ [ISIS_TLV_DYNAMIC_HOSTNAME] =
+ &tlv_dynamic_hostname_ops,
+ [ISIS_TLV_MT_ROUTER_INFO] =
+ &tlv_mt_router_info_ops,
+ [ISIS_TLV_IPV6_ADDRESS] =
+ &tlv_ipv6_address_ops,
+ [ISIS_TLV_IPV6_REACH] = &tlv_ipv6_reach_ops,
+ [ISIS_TLV_MT_IPV6_REACH] = &tlv_ipv6_reach_ops,
+ },
+ [ISIS_CONTEXT_SUBTLV_NE_REACH] = {},
+ [ISIS_CONTEXT_SUBTLV_IP_REACH] = {},
+ [ISIS_CONTEXT_SUBTLV_IPV6_REACH] = {
+ [ISIS_SUBTLV_IPV6_SOURCE_PREFIX] =
+ &subtlv_ipv6_source_prefix_ops,
+ }};
/* Accessor functions */
"State of each debugging option\n"
ISIS_STR)
{
- vty_out (vty, "IS-IS debugging status:\n");
+ vty_out(vty, "IS-IS debugging status:\n");
if (isis->debugs)
print_debug(vty, isis->debugs, 1);
struct area_addr *man_area_addrs; /* manualAreaAddresses */
u_int32_t debugs; /* bitmap for debug */
time_t uptime; /* when did we start */
- struct thread *t_dync_clean; /* dynamic hostname cache cleanup thread */
- uint32_t circuit_ids_used[8]; /* 256 bits to track circuit ids 0 through 255 */
+ struct thread *t_dync_clean; /* dynamic hostname cache cleanup thread */
+ uint32_t circuit_ids_used
+ [8]; /* 256 bits to track circuit ids 0 through 255 */
struct route_table *ext_info[REDIST_PROTOCOL_COUNT];
struct route_table *route_table[ISIS_LEVELS]; /* IPv4 routes */
struct isis_spftree *spftree6[ISIS_LEVELS]; /* The v6 SPTs */
struct route_table *route_table6[ISIS_LEVELS]; /* IPv6 routes */
- /* $FRR indent$ */
-/* clang-format off */
#define DEFAULT_LSP_MTU 1497
unsigned int lsp_mtu; /* Size of LSPs to generate */
struct list *circuit_list; /* IS-IS circuits */
"aaa", // AAA_NODE,
"keychain", // KEYCHAIN_NODE,
"keychain key", // KEYCHAIN_KEY_NODE,
- "logical-router", // LOGICALROUTER_NODE,
+ "logical-router", // LOGICALROUTER_NODE,
"vrf", // VRF_NODE,
"interface", // INTERFACE_NODE,
"zebra", // ZEBRA_NODE,
"bgp", // BGP_NODE,
"bgp vpnv4", // BGP_VPNV4_NODE,
"bgp vpnv6", // BGP_VPNV6_NODE,
- "bgp ipv4 unicast", // BGP_IPV4_NODE,
+ "bgp ipv4 unicast", // BGP_IPV4_NODE,
"bgp ipv4 multicast", // BGP_IPV4M_NODE,
"bgp ipv4 labeled unicast", // BGP_IPV4L_NODE,
"bgp ipv6", // BGP_IPV6_NODE,
"bgp ipv6 multicast", // BGP_IPV6M_NODE,
"bgp ipv6 labeled unicast", // BGP_IPV6L_NODE,
- "bgp vrf policy", // BGP_VRF_POLICY_NODE,
- "bgp vnc defaults", // BGP_VNC_DEFAULTS_NODE,
+ "bgp vrf policy", // BGP_VRF_POLICY_NODE,
+ "bgp vnc defaults", // BGP_VNC_DEFAULTS_NODE,
"bgp vnc nve", // BGP_VNC_NVE_GROUP_NODE,
"bgp vnc l2", // BGP_VNC_L2_GROUP_NODE,
"rfp defaults", // RFP_DEFAULTS_NODE,
"masc", // MASC_NODE,
"irdp", // IRDP_NODE,
"static ip", // IP_NODE,
- "ipv4 access list", // ACCESS_NODE,
- "ipv4 prefix list", // PREFIX_NODE,
- "ipv6 access list", // ACCESS_IPV6_NODE,
- "MAC access list", // ACCESS_MAC_NODE,
- "ipv6 prefix list", // PREFIX_IPV6_NODE,
+ "ipv4 access list", // ACCESS_NODE,
+ "ipv4 prefix list", // PREFIX_NODE,
+ "ipv6 access list", // ACCESS_IPV6_NODE,
+ "MAC access list", // ACCESS_MAC_NODE,
+ "ipv6 prefix list", // PREFIX_IPV6_NODE,
"as list", // AS_LIST_NODE,
- "community list", // COMMUNITY_LIST_NODE,
+ "community list", // COMMUNITY_LIST_NODE,
"routemap", // RMAP_NODE,
"smux", // SMUX_NODE,
"dump", // DUMP_NODE,
cmd_token_new(START_TKN, CMD_ATTR_NORMAL, NULL, NULL);
graph_new_node(node->cmdgraph, token,
(void (*)(void *)) & cmd_token_del);
- node->cmd_hash = hash_create_size(16, cmd_hash_key,
- cmd_hash_cmp,
+ node->cmd_hash = hash_create_size(16, cmd_hash_key, cmd_hash_cmp,
"Command Hash");
}
if (!(use_daemon && ret == CMD_SUCCESS_DAEMON)
&& !(!use_daemon && ret == CMD_ERR_NOTHING_TODO)
&& ret != CMD_SUCCESS && ret != CMD_WARNING
- && ret != CMD_NOT_MY_INSTANCE
- && ret != CMD_WARNING_CONFIG_FAILED
+ && ret != CMD_NOT_MY_INSTANCE && ret != CMD_WARNING_CONFIG_FAILED
&& vty->node != CONFIG_NODE) {
saved_node = vty->node;
AAA_NODE, /* AAA node. */
KEYCHAIN_NODE, /* Key-chain node. */
KEYCHAIN_KEY_NODE, /* Key-chain key node. */
- LOGICALROUTER_NODE, /* Logical-Router node. */
+ LOGICALROUTER_NODE, /* Logical-Router node. */
VRF_NODE, /* VRF mode node. */
INTERFACE_NODE, /* Interface mode node. */
ZEBRA_NODE, /* zebra connection node. */
VTY_NODE, /* Vty node. */
LINK_PARAMS_NODE, /* Link-parameters node */
BGP_EVPN_VNI_NODE, /* BGP EVPN VNI */
- RPKI_NODE, /* RPKI node for configuration of RPKI cache server connections.*/
- NODE_TYPE_MAX, /* maximum */
+ RPKI_NODE, /* RPKI node for configuration of RPKI cache server
+ connections.*/
+ NODE_TYPE_MAX, /* maximum */
};
extern vector cmdvec;
* void prototype(void) __attribute__((_CONSTRUCTOR(100)));
*/
#if defined(__clang__)
-# if __clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >= 5)
+#if __clang_major__ > 3 || (__clang_major__ == 3 && __clang_minor__ >= 5)
# define _RET_NONNULL , returns_nonnull
-# endif
+#endif
# define _CONSTRUCTOR(x) constructor(x)
#elif defined(__GNUC__)
-# if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9)
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9)
# define _RET_NONNULL , returns_nonnull
-# endif
-# if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
+#endif
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
# define _CONSTRUCTOR(x) constructor(x)
# define _DESTRUCTOR(x) destructor(x)
# define _ALLOC_SIZE(x) alloc_size(x)
-# endif
+#endif
#endif
#ifdef __sun
/* Solaris doesn't do constructor priorities due to linker restrictions */
-# undef _CONSTRUCTOR
-# undef _DESTRUCTOR
+#undef _CONSTRUCTOR
+#undef _DESTRUCTOR
#endif
/* fallback versions */
}
static ferr_r ferr_set_va(const char *file, int line, const char *func,
- enum ferr_kind kind, const char *pathname, int errno_val,
- const char *text, va_list va)
+ enum ferr_kind kind, const char *pathname,
+ int errno_val, const char *text, va_list va)
{
struct ferr *error = pthread_getspecific(errkey);
/* we're screwed */
zlog_err("out of memory while allocating error info");
raise(SIGSEGV);
- abort(); /* raise() can return, but raise(SIGSEGV) shall not */
+ abort(); /* raise() can return, but raise(SIGSEGV) shall
+ not */
}
pthread_setspecific(errkey, error);
error->kind = kind;
error->unique_id = jhash(text, strlen(text),
- jhash(file, strlen(file), 0xd4ed0298));
+ jhash(file, strlen(file), 0xd4ed0298));
error->errno_val = errno_val;
if (pathname)
- snprintf(error->pathname, sizeof(error->pathname),
- "%s", pathname);
+ snprintf(error->pathname, sizeof(error->pathname), "%s",
+ pathname);
else
error->pathname[0] = '\0';
}
ferr_r ferr_set_internal(const char *file, int line, const char *func,
- enum ferr_kind kind, const char *text, ...)
+ enum ferr_kind kind, const char *text, ...)
{
ferr_r rv;
va_list va;
}
ferr_r ferr_set_internal_ext(const char *file, int line, const char *func,
- enum ferr_kind kind, const char *pathname, int errno_val,
- const char *text, ...)
+ enum ferr_kind kind, const char *pathname,
+ int errno_val, const char *text, ...)
{
ferr_r rv;
va_list va;
else {
replacepos[0] = '\0';
replacepos += sizeof(REPLACE) - 1;
- vty_out(vty, "%s%s%s\n",
- tmpmsg,
+ vty_out(vty, "%s%s%s\n", tmpmsg,
last_error ? last_error->message : "(no error?)",
replacepos);
}
}
-
/* do NOT call these functions directly. only for macro use! */
ferr_r ferr_set_internal(const char *file, int line, const char *func,
- enum ferr_kind kind, const char *text, ...);
+ enum ferr_kind kind, const char *text, ...);
ferr_r ferr_set_internal_ext(const char *file, int line, const char *func,
- enum ferr_kind kind, const char *pathname, int errno_val,
- const char *text, ...);
+ enum ferr_kind kind, const char *pathname,
+ int errno_val, const char *text, ...);
-#define ferr_ok() \
- 0
+#define ferr_ok() 0
/* Report an error.
*
*
* Don't put a \n at the end of the error message.
*/
-#define ferr_code_bug(...) \
- ferr_set_internal(__FILE__, __LINE__, __func__, FERR_CODE_BUG, \
- __VA_ARGS__)
-#define ferr_cfg_invalid(...) \
- ferr_set_internal(__FILE__, __LINE__, __func__, FERR_CONFIG_INVALID, \
- __VA_ARGS__)
-#define ferr_cfg_reality(...) \
- ferr_set_internal(__FILE__, __LINE__, __func__, FERR_CONFIG_REALITY, \
- __VA_ARGS__)
-#define ferr_cfg_resource(...) \
- ferr_set_internal(__FILE__, __LINE__, __func__, FERR_RESOURCE, \
- __VA_ARGS__)
-#define ferr_system(...) \
- ferr_set_internal(__FILE__, __LINE__, __func__, FERR_SYSTEM, \
- __VA_ARGS__)
-#define ferr_library(...) \
- ferr_set_internal(__FILE__, __LINE__, __func__, FERR_LIBRARY, \
- __VA_ARGS__)
+#define ferr_code_bug(...) \
+ ferr_set_internal(__FILE__, __LINE__, __func__, FERR_CODE_BUG, \
+ __VA_ARGS__)
+#define ferr_cfg_invalid(...) \
+ ferr_set_internal(__FILE__, __LINE__, __func__, FERR_CONFIG_INVALID, \
+ __VA_ARGS__)
+#define ferr_cfg_reality(...) \
+ ferr_set_internal(__FILE__, __LINE__, __func__, FERR_CONFIG_REALITY, \
+ __VA_ARGS__)
+#define ferr_cfg_resource(...) \
+ ferr_set_internal(__FILE__, __LINE__, __func__, FERR_RESOURCE, \
+ __VA_ARGS__)
+#define ferr_system(...) \
+ ferr_set_internal(__FILE__, __LINE__, __func__, FERR_SYSTEM, \
+ __VA_ARGS__)
+#define ferr_library(...) \
+ ferr_set_internal(__FILE__, __LINE__, __func__, FERR_LIBRARY, \
+ __VA_ARGS__)
/* extended information variants */
-#define ferr_system_errno(...) \
- ferr_set_internal_ext(__FILE__, __LINE__, __func__, FERR_SYSTEM, \
- NULL, errno, __VA_ARGS__)
-#define ferr_system_path_errno(path, ...) \
- ferr_set_internal_ext(__FILE__, __LINE__, __func__, FERR_SYSTEM, \
- path, errno, __VA_ARGS__)
+#define ferr_system_errno(...) \
+ ferr_set_internal_ext(__FILE__, __LINE__, __func__, FERR_SYSTEM, NULL, \
+ errno, __VA_ARGS__)
+#define ferr_system_path_errno(path, ...) \
+ ferr_set_internal_ext(__FILE__, __LINE__, __func__, FERR_SYSTEM, path, \
+ errno, __VA_ARGS__)
#include "vty.h"
/* print error message to vty; $ERR is replaced by the error's message */
void vty_print_error(struct vty *vty, ferr_r err, const char *msg, ...);
-#define CMD_FERR_DO(func, action, ...) \
- do { ferr_r cmd_retval = func; \
- if (cmd_retval) { \
- vty_print_error(vty, cmd_retval, __VA_ARGS__); \
- action; \
- } \
+#define CMD_FERR_DO(func, action, ...) \
+ do { \
+ ferr_r cmd_retval = func; \
+ if (cmd_retval) { \
+ vty_print_error(vty, cmd_retval, __VA_ARGS__); \
+ action; \
+ } \
} while (0)
-#define CMD_FERR_RETURN(func, ...) \
+#define CMD_FERR_RETURN(func, ...) \
CMD_FERR_DO(func, return CMD_WARNING_CONFIG_FAILED, __VA_ARGS__)
-#define CMD_FERR_GOTO(func, label, ...) \
+#define CMD_FERR_GOTO(func, label, ...) \
CMD_FERR_DO(func, goto label, __VA_ARGS__)
/* example: uses bogus #define to keep indent.py happy */
DEFUN("bla")
{
CMD_FERR_RETURN(foo_bar_set(obj, atoi(argv[1])),
- "command failed: $ERR\n");
+ "command failed: $ERR\n");
return CMD_SUCCESS;
}
(STAILQ_EMPTY((head)) \
? NULL \
: ((struct type *)(void *)((char *)((head)->stqh_last) \
- - offsetof(struct type, \
- field))))
+ - offsetof(struct type, field))))
#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)
nodegraph = cnode->cmdgraph;
if (!nodegraph)
continue;
- vty_out(vty, "scanning node %d (%s)\n",
- scannode - 1, node_names[scannode - 1]);
+ vty_out(vty, "scanning node %d (%s)\n", scannode - 1,
+ node_names[scannode - 1]);
}
commands = cmd_graph_permutations(nodegraph);
he->priority = priority;
for (pos = &hook->entries; *pos; pos = &(*pos)->next)
- if (hook->reverse
- ? (*pos)->priority < priority
- : (*pos)->priority >= priority)
+ if (hook->reverse ? (*pos)->priority < priority
+ : (*pos)->priority >= priority)
break;
he->next = *pos;
NULL, false, THIS_MODULE, #func, prio)
#define hook_register_arg_prio(hookname, prio, func, arg) \
_hook_register(&_hook_##hookname, \
- _hook_typecheck_arg_##hookname(func), \
- arg, true, THIS_MODULE, #func, prio)
+ _hook_typecheck_arg_##hookname(func), arg, true, \
+ THIS_MODULE, #func, prio)
extern void _hook_unregister(struct hook *hook, void *funcptr, void *arg,
bool has_arg);
{ \
return (void *)funcptr; \
}
-#define DECLARE_KOOH(hookname, arglist, passlist) \
+#define DECLARE_KOOH(hookname, arglist, passlist) \
DECLARE_HOOK(hookname, arglist, passlist)
/* use in source file - contains hook-related definitions.
return hooksum; \
}
-#define DEFINE_HOOK(hookname, arglist, passlist) \
+#define DEFINE_HOOK(hookname, arglist, passlist) \
DEFINE_HOOK_INT(hookname, arglist, passlist, false)
-#define DEFINE_KOOH(hookname, arglist, passlist) \
+#define DEFINE_KOOH(hookname, arglist, passlist) \
DEFINE_HOOK_INT(hookname, arglist, passlist, true)
#endif /* _FRR_HOOK_H */
DEFINE_QOBJ_TYPE(interface)
-DEFINE_HOOK(if_add, (struct interface *ifp), (ifp))
-DEFINE_KOOH(if_del, (struct interface *ifp), (ifp))
+DEFINE_HOOK(if_add, (struct interface * ifp), (ifp))
+DEFINE_KOOH(if_del, (struct interface * ifp), (ifp))
/* List of interfaces in only the default VRF */
int ptm_enable = 0;
SET_FLAG(ifp->status, ZEBRA_INTERFACE_LINKDETECTION);
QOBJ_REG(ifp, interface);
- hook_call(if_add, ifp);
+ hook_call(if_add, ifp);
return ifp;
}
/* Delete interface structure. */
void if_delete_retain(struct interface *ifp)
{
- hook_call(if_del, ifp);
+ hook_call(if_del, ifp);
QOBJ_UNREG(ifp);
/* Free connected address list */
if (vrf_id == VRF_UNKNOWN) {
struct interface *ifp;
- RB_FOREACH(vrf, vrf_id_head, &vrfs_by_id) {
+ RB_FOREACH (vrf, vrf_id_head, &vrfs_by_id) {
ifp = if_lookup_by_index(ifindex, vrf->vrf_id);
if (ifp)
return ifp;
* this should not be considered as an update
* then create the new interface
*/
- if (ifp->vrf_id != vrf_id &&
- vrf_is_mapped_on_netns(vrf_id))
+ if (ifp->vrf_id != vrf_id && vrf_is_mapped_on_netns(vrf_id))
return if_create(name, vrf_id);
/* If it came from the kernel
* or by way of zclient, believe it and update
* can use 1000+ so they run after the daemon has initialised daemon-specific
* interface data
*/
-DECLARE_HOOK(if_add, (struct interface *ifp), (ifp))
-DECLARE_KOOH(if_del, (struct interface *ifp), (ifp))
+DECLARE_HOOK(if_add, (struct interface * ifp), (ifp))
+DECLARE_KOOH(if_del, (struct interface * ifp), (ifp))
/* Connected address structure. */
struct connected {
* else think before you use VRF_UNKNOWN
*/
extern void if_update_to_new_vrf(struct interface *, vrf_id_t vrf_id);
-extern struct interface *if_create(const char *name, vrf_id_t vrf_id);
+extern struct interface *if_create(const char *name, vrf_id_t vrf_id);
extern struct interface *if_lookup_by_index(ifindex_t, vrf_id_t vrf_id);
extern struct interface *if_lookup_exact_address(void *matchaddr, int family,
vrf_id_t vrf_id);
void if_rmap_init(int node)
{
- ifrmaphash = hash_create_size(4,
- if_rmap_hash_make,
- if_rmap_hash_cmp,
+ ifrmaphash = hash_create_size(4, if_rmap_hash_make, if_rmap_hash_cmp,
"Interface Route-Map Hash");
if (node == RIPNG_NODE) {
} else if (node == RIP_NODE) {
#include "queue.h"
#include "imsg.h"
-int ibuf_realloc(struct ibuf *, size_t);
-void ibuf_enqueue(struct msgbuf *, struct ibuf *);
-void ibuf_dequeue(struct msgbuf *, struct ibuf *);
+int ibuf_realloc(struct ibuf *, size_t);
+void ibuf_enqueue(struct msgbuf *, struct ibuf *);
+void ibuf_dequeue(struct msgbuf *, struct ibuf *);
-struct ibuf *
-ibuf_open(size_t len)
+struct ibuf *ibuf_open(size_t len)
{
- struct ibuf *buf;
+ struct ibuf *buf;
if ((buf = calloc(1, sizeof(struct ibuf))) == NULL)
return (NULL);
return (buf);
}
-struct ibuf *
-ibuf_dynamic(size_t len, size_t max)
+struct ibuf *ibuf_dynamic(size_t len, size_t max)
{
- struct ibuf *buf;
+ struct ibuf *buf;
if (max < len)
return (NULL);
return (buf);
}
-int
-ibuf_realloc(struct ibuf *buf, size_t len)
+int ibuf_realloc(struct ibuf *buf, size_t len)
{
- u_char *b;
+ u_char *b;
/* on static buffers max is eq size and so the following fails */
if (buf->wpos + len > buf->max) {
return (0);
}
-int
-ibuf_add(struct ibuf *buf, const void *data, size_t len)
+int ibuf_add(struct ibuf *buf, const void *data, size_t len)
{
if (buf->wpos + len > buf->size)
if (ibuf_realloc(buf, len) == -1)
return (0);
}
-void *
-ibuf_reserve(struct ibuf *buf, size_t len)
+void *ibuf_reserve(struct ibuf *buf, size_t len)
{
- void *b;
+ void *b;
if (buf->wpos + len > buf->size)
if (ibuf_realloc(buf, len) == -1)
return (b);
}
-void *
-ibuf_seek(struct ibuf *buf, size_t pos, size_t len)
+void *ibuf_seek(struct ibuf *buf, size_t pos, size_t len)
{
/* only allowed to seek in already written parts */
if (pos + len > buf->wpos)
return (buf->buf + pos);
}
-size_t
-ibuf_size(struct ibuf *buf)
+size_t ibuf_size(struct ibuf *buf)
{
return (buf->wpos);
}
-size_t
-ibuf_left(struct ibuf *buf)
+size_t ibuf_left(struct ibuf *buf)
{
return (buf->max - buf->wpos);
}
-void
-ibuf_close(struct msgbuf *msgbuf, struct ibuf *buf)
+void ibuf_close(struct msgbuf *msgbuf, struct ibuf *buf)
{
ibuf_enqueue(msgbuf, buf);
}
-int
-ibuf_write(struct msgbuf *msgbuf)
+int ibuf_write(struct msgbuf *msgbuf)
{
- struct iovec iov[IOV_MAX];
- struct ibuf *buf;
- unsigned int i = 0;
- ssize_t n;
+ struct iovec iov[IOV_MAX];
+ struct ibuf *buf;
+ unsigned int i = 0;
+ ssize_t n;
memset(&iov, 0, sizeof(iov));
- TAILQ_FOREACH(buf, &msgbuf->bufs, entry) {
+ TAILQ_FOREACH (buf, &msgbuf->bufs, entry) {
if (i >= IOV_MAX)
break;
iov[i].iov_base = buf->buf + buf->rpos;
return (-1);
}
- if (n == 0) { /* connection closed */
+ if (n == 0) { /* connection closed */
errno = 0;
return (0);
}
return (1);
}
-void
-ibuf_free(struct ibuf *buf)
+void ibuf_free(struct ibuf *buf)
{
if (buf == NULL)
return;
free(buf);
}
-void
-msgbuf_init(struct msgbuf *msgbuf)
+void msgbuf_init(struct msgbuf *msgbuf)
{
msgbuf->queued = 0;
msgbuf->fd = -1;
TAILQ_INIT(&msgbuf->bufs);
}
-void
-msgbuf_drain(struct msgbuf *msgbuf, size_t n)
+void msgbuf_drain(struct msgbuf *msgbuf, size_t n)
{
- struct ibuf *buf, *next;
+ struct ibuf *buf, *next;
for (buf = TAILQ_FIRST(&msgbuf->bufs); buf != NULL && n > 0;
- buf = next) {
+ buf = next) {
next = TAILQ_NEXT(buf, entry);
if (buf->rpos + n >= buf->wpos) {
n -= buf->wpos - buf->rpos;
}
}
-void
-msgbuf_clear(struct msgbuf *msgbuf)
+void msgbuf_clear(struct msgbuf *msgbuf)
{
- struct ibuf *buf;
+ struct ibuf *buf;
while ((buf = TAILQ_FIRST(&msgbuf->bufs)) != NULL)
ibuf_dequeue(msgbuf, buf);
}
-int
-msgbuf_write(struct msgbuf *msgbuf)
+int msgbuf_write(struct msgbuf *msgbuf)
{
- struct iovec iov[IOV_MAX];
- struct ibuf *buf;
- unsigned int i = 0;
- ssize_t n;
- struct msghdr msg;
- struct cmsghdr *cmsg;
+ struct iovec iov[IOV_MAX];
+ struct ibuf *buf;
+ unsigned int i = 0;
+ ssize_t n;
+ struct msghdr msg;
+ struct cmsghdr *cmsg;
union {
- struct cmsghdr hdr;
- char buf[CMSG_SPACE(sizeof(int))];
+ struct cmsghdr hdr;
+ char buf[CMSG_SPACE(sizeof(int))];
} cmsgbuf;
memset(&iov, 0, sizeof(iov));
memset(&msg, 0, sizeof(msg));
memset(&cmsgbuf, 0, sizeof(cmsgbuf));
- TAILQ_FOREACH(buf, &msgbuf->bufs, entry) {
+ TAILQ_FOREACH (buf, &msgbuf->bufs, entry) {
if (i >= IOV_MAX)
break;
iov[i].iov_base = buf->buf + buf->rpos;
return (-1);
}
- if (n == 0) { /* connection closed */
+ if (n == 0) { /* connection closed */
errno = 0;
return (0);
}
return (1);
}
-void
-ibuf_enqueue(struct msgbuf *msgbuf, struct ibuf *buf)
+void ibuf_enqueue(struct msgbuf *msgbuf, struct ibuf *buf)
{
TAILQ_INSERT_TAIL(&msgbuf->bufs, buf, entry);
msgbuf->queued++;
}
-void
-ibuf_dequeue(struct msgbuf *msgbuf, struct ibuf *buf)
+void ibuf_dequeue(struct msgbuf *msgbuf, struct ibuf *buf)
{
TAILQ_REMOVE(&msgbuf->bufs, buf, entry);
#include "queue.h"
#include "imsg.h"
-int imsg_fd_overhead = 0;
+int imsg_fd_overhead = 0;
-int imsg_get_fd(struct imsgbuf *);
+int imsg_get_fd(struct imsgbuf *);
#ifndef __OpenBSD__
/*
* The original code calls getdtablecount() which is OpenBSD specific. Use
* available_fds() from OpenSMTPD instead.
*/
-static int
-available_fds(unsigned int n)
+static int available_fds(unsigned int n)
{
- unsigned int i;
- int ret, fds[256];
+ unsigned int i;
+ int ret, fds[256];
- if (n > (sizeof(fds)/sizeof(fds[0])))
+ if (n > (sizeof(fds) / sizeof(fds[0])))
return (1);
ret = 0;
}
#endif
-void
-imsg_init(struct imsgbuf *ibuf, int fd)
+void imsg_init(struct imsgbuf *ibuf, int fd)
{
msgbuf_init(&ibuf->w);
memset(&ibuf->r, 0, sizeof(ibuf->r));
TAILQ_INIT(&ibuf->fds);
}
-ssize_t
-imsg_read(struct imsgbuf *ibuf)
+ssize_t imsg_read(struct imsgbuf *ibuf)
{
- struct msghdr msg;
- struct cmsghdr *cmsg;
+ struct msghdr msg;
+ struct cmsghdr *cmsg;
union {
struct cmsghdr hdr;
- char buf[CMSG_SPACE(sizeof(int) * 1)];
+ char buf[CMSG_SPACE(sizeof(int) * 1)];
} cmsgbuf;
- struct iovec iov;
- ssize_t n = -1;
- int fd;
- struct imsg_fd *ifd;
+ struct iovec iov;
+ ssize_t n = -1;
+ int fd;
+ struct imsg_fd *ifd;
memset(&msg, 0, sizeof(msg));
memset(&cmsgbuf, 0, sizeof(cmsgbuf));
again:
#ifdef __OpenBSD__
- if (getdtablecount() + imsg_fd_overhead +
- (int)((CMSG_SPACE(sizeof(int))-CMSG_SPACE(0))/sizeof(int))
+ if (getdtablecount() + imsg_fd_overhead
+ + (int)((CMSG_SPACE(sizeof(int)) - CMSG_SPACE(0))
+ / sizeof(int))
>= getdtablesize()) {
#else
- if (available_fds(imsg_fd_overhead +
- (CMSG_SPACE(sizeof(int))-CMSG_SPACE(0))/sizeof(int))) {
+ if (available_fds(imsg_fd_overhead
+ + (CMSG_SPACE(sizeof(int)) - CMSG_SPACE(0))
+ / sizeof(int))) {
#endif
errno = EAGAIN;
free(ifd);
ibuf->r.wpos += n;
for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL;
- cmsg = CMSG_NXTHDR(&msg, cmsg)) {
- if (cmsg->cmsg_level == SOL_SOCKET &&
- cmsg->cmsg_type == SCM_RIGHTS) {
+ cmsg = CMSG_NXTHDR(&msg, cmsg)) {
+ if (cmsg->cmsg_level == SOL_SOCKET
+ && cmsg->cmsg_type == SCM_RIGHTS) {
int i;
int j;
* padding rules, our control buffer might contain
* more than one fd, and we must close them.
*/
- j = ((char *)cmsg + cmsg->cmsg_len -
- (char *)CMSG_DATA(cmsg)) / sizeof(int);
+ j = ((char *)cmsg + cmsg->cmsg_len
+ - (char *)CMSG_DATA(cmsg))
+ / sizeof(int);
for (i = 0; i < j; i++) {
fd = ((int *)CMSG_DATA(cmsg))[i];
if (ifd != NULL) {
ifd->fd = fd;
TAILQ_INSERT_TAIL(&ibuf->fds, ifd,
- entry);
+ entry);
ifd = NULL;
} else
close(fd);
return (n);
}
-ssize_t
-imsg_get(struct imsgbuf *ibuf, struct imsg *imsg)
+ssize_t imsg_get(struct imsgbuf *ibuf, struct imsg *imsg)
{
- size_t av, left, datalen;
+ size_t av, left, datalen;
av = ibuf->r.wpos;
return (0);
memcpy(&imsg->hdr, ibuf->r.buf, sizeof(imsg->hdr));
- if (imsg->hdr.len < IMSG_HEADER_SIZE ||
- imsg->hdr.len > MAX_IMSGSIZE) {
+ if (imsg->hdr.len < IMSG_HEADER_SIZE || imsg->hdr.len > MAX_IMSGSIZE) {
errno = ERANGE;
return (-1);
}
imsg->fd = -1;
if (imsg->data)
- memcpy(imsg->data, ibuf->r.rptr, datalen);
+ memcpy(imsg->data, ibuf->r.rptr, datalen);
if (imsg->hdr.len < av) {
left = av - imsg->hdr.len;
return (datalen + IMSG_HEADER_SIZE);
}
-int
-imsg_compose(struct imsgbuf *ibuf, u_int32_t type, u_int32_t peerid,
- pid_t pid, int fd, const void *data, u_int16_t datalen)
+int imsg_compose(struct imsgbuf *ibuf, u_int32_t type, u_int32_t peerid,
+ pid_t pid, int fd, const void *data, u_int16_t datalen)
{
- struct ibuf *wbuf;
+ struct ibuf *wbuf;
if ((wbuf = imsg_create(ibuf, type, peerid, pid, datalen)) == NULL)
return (-1);
return (1);
}
-int
-imsg_composev(struct imsgbuf *ibuf, u_int32_t type, u_int32_t peerid,
- pid_t pid, int fd, const struct iovec *iov, int iovcnt)
+int imsg_composev(struct imsgbuf *ibuf, u_int32_t type, u_int32_t peerid,
+ pid_t pid, int fd, const struct iovec *iov, int iovcnt)
{
- struct ibuf *wbuf;
- int i, datalen = 0;
+ struct ibuf *wbuf;
+ int i, datalen = 0;
for (i = 0; i < iovcnt; i++)
datalen += iov[i].iov_len;
}
/* ARGSUSED */
-struct ibuf *
-imsg_create(struct imsgbuf *ibuf, u_int32_t type, u_int32_t peerid,
- pid_t pid, u_int16_t datalen)
+struct ibuf *imsg_create(struct imsgbuf *ibuf, u_int32_t type, u_int32_t peerid,
+ pid_t pid, u_int16_t datalen)
{
- struct ibuf *wbuf;
- struct imsg_hdr hdr;
+ struct ibuf *wbuf;
+ struct imsg_hdr hdr;
datalen += IMSG_HEADER_SIZE;
if (datalen > MAX_IMSGSIZE) {
return (wbuf);
}
-int
-imsg_add(struct ibuf *msg, const void *data, u_int16_t datalen)
+int imsg_add(struct ibuf *msg, const void *data, u_int16_t datalen)
{
if (datalen)
if (ibuf_add(msg, data, datalen) == -1) {
return (datalen);
}
-void
-imsg_close(struct imsgbuf *ibuf, struct ibuf *msg)
+void imsg_close(struct imsgbuf *ibuf, struct ibuf *msg)
{
- struct imsg_hdr *hdr;
+ struct imsg_hdr *hdr;
hdr = (struct imsg_hdr *)msg->buf;
ibuf_close(&ibuf->w, msg);
}
-void
-imsg_free(struct imsg *imsg)
+void imsg_free(struct imsg *imsg)
{
free(imsg->data);
}
-int
-imsg_get_fd(struct imsgbuf *ibuf)
+int imsg_get_fd(struct imsgbuf *ibuf)
{
- int fd;
- struct imsg_fd *ifd;
+ int fd;
+ struct imsg_fd *ifd;
if ((ifd = TAILQ_FIRST(&ibuf->fds)) == NULL)
return (-1);
return (fd);
}
-int
-imsg_flush(struct imsgbuf *ibuf)
+int imsg_flush(struct imsgbuf *ibuf)
{
while (ibuf->w.queued)
if (msgbuf_write(&ibuf->w) <= 0)
return (0);
}
-void
-imsg_clear(struct imsgbuf *ibuf)
+void imsg_clear(struct imsgbuf *ibuf)
{
- int fd;
+ int fd;
msgbuf_clear(&ibuf->w);
while ((fd = imsg_get_fd(ibuf)) != -1)
#define MAX_IMSGSIZE 16384
struct ibuf {
- TAILQ_ENTRY(ibuf) entry;
- u_char *buf;
- size_t size;
- size_t max;
- size_t wpos;
- size_t rpos;
- int fd;
+ TAILQ_ENTRY(ibuf) entry;
+ u_char *buf;
+ size_t size;
+ size_t max;
+ size_t wpos;
+ size_t rpos;
+ int fd;
};
struct msgbuf {
- TAILQ_HEAD(, ibuf) bufs;
- u_int32_t queued;
- int fd;
+ TAILQ_HEAD(, ibuf) bufs;
+ u_int32_t queued;
+ int fd;
};
struct ibuf_read {
- u_char buf[IBUF_READ_SIZE];
- u_char *rptr;
- size_t wpos;
+ u_char buf[IBUF_READ_SIZE];
+ u_char *rptr;
+ size_t wpos;
};
struct imsg_fd {
- TAILQ_ENTRY(imsg_fd) entry;
- int fd;
+ TAILQ_ENTRY(imsg_fd) entry;
+ int fd;
};
struct imsgbuf {
- TAILQ_HEAD(, imsg_fd) fds;
- struct ibuf_read r;
- struct msgbuf w;
- int fd;
- pid_t pid;
+ TAILQ_HEAD(, imsg_fd) fds;
+ struct ibuf_read r;
+ struct msgbuf w;
+ int fd;
+ pid_t pid;
};
#define IMSGF_HASFD 1
struct imsg_hdr {
- u_int32_t type;
- u_int16_t len;
- u_int16_t flags;
- u_int32_t peerid;
- u_int32_t pid;
+ u_int32_t type;
+ u_int16_t len;
+ u_int16_t flags;
+ u_int32_t peerid;
+ u_int32_t pid;
};
struct imsg {
- struct imsg_hdr hdr;
- int fd;
- void *data;
+ struct imsg_hdr hdr;
+ int fd;
+ void *data;
};
/* buffer.c */
-struct ibuf *ibuf_open(size_t);
-struct ibuf *ibuf_dynamic(size_t, size_t);
-int ibuf_add(struct ibuf *, const void *, size_t);
-void *ibuf_reserve(struct ibuf *, size_t);
-void *ibuf_seek(struct ibuf *, size_t, size_t);
-size_t ibuf_size(struct ibuf *);
-size_t ibuf_left(struct ibuf *);
-void ibuf_close(struct msgbuf *, struct ibuf *);
-int ibuf_write(struct msgbuf *);
-void ibuf_free(struct ibuf *);
-void msgbuf_init(struct msgbuf *);
-void msgbuf_clear(struct msgbuf *);
-int msgbuf_write(struct msgbuf *);
-void msgbuf_drain(struct msgbuf *, size_t);
+struct ibuf *ibuf_open(size_t);
+struct ibuf *ibuf_dynamic(size_t, size_t);
+int ibuf_add(struct ibuf *, const void *, size_t);
+void *ibuf_reserve(struct ibuf *, size_t);
+void *ibuf_seek(struct ibuf *, size_t, size_t);
+size_t ibuf_size(struct ibuf *);
+size_t ibuf_left(struct ibuf *);
+void ibuf_close(struct msgbuf *, struct ibuf *);
+int ibuf_write(struct msgbuf *);
+void ibuf_free(struct ibuf *);
+void msgbuf_init(struct msgbuf *);
+void msgbuf_clear(struct msgbuf *);
+int msgbuf_write(struct msgbuf *);
+void msgbuf_drain(struct msgbuf *, size_t);
/* imsg.c */
-void imsg_init(struct imsgbuf *, int);
-ssize_t imsg_read(struct imsgbuf *);
-ssize_t imsg_get(struct imsgbuf *, struct imsg *);
-int imsg_compose(struct imsgbuf *, u_int32_t, u_int32_t, pid_t,
- int, const void *, u_int16_t);
-int imsg_composev(struct imsgbuf *, u_int32_t, u_int32_t, pid_t,
- int, const struct iovec *, int);
+void imsg_init(struct imsgbuf *, int);
+ssize_t imsg_read(struct imsgbuf *);
+ssize_t imsg_get(struct imsgbuf *, struct imsg *);
+int imsg_compose(struct imsgbuf *, u_int32_t, u_int32_t, pid_t, int,
+ const void *, u_int16_t);
+int imsg_composev(struct imsgbuf *, u_int32_t, u_int32_t, pid_t, int,
+ const struct iovec *, int);
struct ibuf *imsg_create(struct imsgbuf *, u_int32_t, u_int32_t, pid_t,
- u_int16_t);
-int imsg_add(struct ibuf *, const void *, u_int16_t);
-void imsg_close(struct imsgbuf *, struct ibuf *);
-void imsg_free(struct imsg *);
-int imsg_flush(struct imsgbuf *);
-void imsg_clear(struct imsgbuf *);
+ u_int16_t);
+int imsg_add(struct ibuf *, const void *, u_int16_t);
+void imsg_close(struct imsgbuf *, struct ibuf *);
+void imsg_free(struct imsg *);
+int imsg_flush(struct imsgbuf *);
+void imsg_clear(struct imsgbuf *);
#endif
&accept_lifetime_duration_day_month_cmd);
install_element(KEYCHAIN_KEY_NODE,
&accept_lifetime_duration_month_day_cmd);
- install_element(KEYCHAIN_KEY_NODE,
- &no_accept_lifetime_cmd);
+ install_element(KEYCHAIN_KEY_NODE, &no_accept_lifetime_cmd);
install_element(KEYCHAIN_KEY_NODE,
&send_lifetime_day_month_day_month_cmd);
&send_lifetime_duration_day_month_cmd);
install_element(KEYCHAIN_KEY_NODE,
&send_lifetime_duration_month_day_cmd);
- install_element(KEYCHAIN_KEY_NODE,
- &no_send_lifetime_cmd);
+ install_element(KEYCHAIN_KEY_NODE, &no_send_lifetime_cmd);
}
break;
case '6':
path++;
- /* fallthrough */
+ /* fallthrough */
default:
af = AF_INET6;
break;
rcvd_signal = 0;
-#if defined(HAVE_PPOLL)
+#if defined(HAVE_PPOLL)
ret = ppoll(pfd, 1, NULL, &prevsigs);
#elif defined(HAVE_POLLTS)
ret = pollts(pfd, 1, NULL, &prevsigs);
return 0;
switch (buf[0]) {
- case 'S': /* SIGTSTP */
+ case 'S': /* SIGTSTP */
vty_stdio_suspend();
send(daemon_ctl_sock, "s", 1, 0);
break;
- case 'R': /* SIGTCNT [implicit] */
+ case 'R': /* SIGTCNT [implicit] */
vty_stdio_resume();
break;
- case 'I': /* SIGINT */
+ case 'I': /* SIGINT */
di->daemon_mode = false;
raise(SIGINT);
break;
- case 'Q': /* SIGQUIT */
+ case 'Q': /* SIGQUIT */
di->daemon_mode = true;
vty_stdio_close();
break;
if (!have_leftovers)
return;
- snprintf(filename, sizeof(filename),
- "/tmp/frr-memstats-%s-%llu-%llu",
- di->name,
- (unsigned long long)getpid(),
+ snprintf(filename, sizeof(filename), "/tmp/frr-memstats-%s-%llu-%llu",
+ di->name, (unsigned long long)getpid(),
(unsigned long long)time(NULL));
fp = fopen(filename, "w");
#endif
extern void list_delete_and_null(struct list **);
extern void list_delete_original(struct list *);
-#define list_delete(X) list_delete_original((X)) \
- CPP_WARN("Please transition to using list_delete_and_null")
-#define list_free(X) list_delete_original((X)) \
- CPP_WARN("Please transition tousing list_delete_and_null")
+#define list_delete(X) \
+ list_delete_original((X)) \
+ CPP_WARN("Please transition to using list_delete_and_null")
+#define list_free(X) \
+ list_delete_original((X)) \
+ CPP_WARN("Please transition tousing list_delete_and_null")
extern void list_delete_all_node(struct list *);
static void vzlog_file(struct zlog *zl, struct timestamp_control *tsctl,
- const char *proto_str, int record_priority,
- int priority, FILE *fp, const char *format,
- va_list args)
+ const char *proto_str, int record_priority, int priority,
+ FILE *fp, const char *format, va_list args)
{
va_list ac;
/* File output. */
if ((priority <= zl->maxlvl[ZLOG_DEST_FILE]) && zl->fp)
- vzlog_file(zl, &tsctl, proto_str, zl->record_priority,
- priority, zl->fp, format, args);
+ vzlog_file(zl, &tsctl, proto_str, zl->record_priority, priority,
+ zl->fp, format, args);
/* fixed-config logging to stderr while we're stating up & haven't
* daemonized / reached mainloop yet
* note the "else" on stdout output -- we don't want to print the same
* message to both stderr and stdout. */
if (zlog_startup_stderr && priority <= LOG_WARNING)
- vzlog_file(zl, &tsctl, proto_str, 1,
- priority, stderr, format, args);
+ vzlog_file(zl, &tsctl, proto_str, 1, priority, stderr, format,
+ args);
else if (priority <= zl->maxlvl[ZLOG_DEST_STDOUT])
- vzlog_file(zl, &tsctl, proto_str, zl->record_priority,
- priority, stdout, format, args);
+ vzlog_file(zl, &tsctl, proto_str, zl->record_priority, priority,
+ stdout, format, args);
/* Terminal monitor. */
if (priority <= zl->maxlvl[ZLOG_DEST_MONITOR])
printing */
s += sprintf(s, " ");
- else if (
- isprint((int)((const char *)mem)
- [j])) /* printable char
- */
+ else if (isprint((int)((const char *)mem)
+ [j])) /* printable char
+ */
s += sprintf(
s, "%c",
0xFF & ((const char *)mem)[j]);
DEFINE_MTYPE_STATIC(LIB, LOGICALROUTER_NAME, "Logical Router Name")
/* Logical Router node has no interface. */
-static struct cmd_node logicalrouter_node = {LOGICALROUTER_NODE, "",
- 1};
+static struct cmd_node logicalrouter_node = {LOGICALROUTER_NODE, "", 1};
static int logicalrouter_backend;
int log_memstats(FILE *fp, const char *prefix)
{
- struct exit_dump_args eda = { .fp = fp, .prefix = prefix, .error = 0 };
+ struct exit_dump_args eda = {.fp = fp, .prefix = prefix, .error = 0};
qmem_walk(qmem_exit_walker, &eda);
return eda.error;
}
.description = "libfrr core module",
};
union _frrmod_runtime_u frrmod_default = {
- .r = {
- .info = &frrmod_default_info,
- .finished_loading = 1,
- },
+ .r =
+ {
+ .info = &frrmod_default_info,
+ .finished_loading = 1,
+ },
};
// if defined(HAVE_SYS_WEAK_ALIAS_ATTRIBUTE)
zlog_info("NS %s is created.", ns->name);
}
if (ns_master.ns_new_hook)
- (*ns_master.ns_new_hook) (ns);
+ (*ns_master.ns_new_hook)(ns);
return ns;
}
{
if (ns_is_enabled(ns)) {
if (ns_debug)
- zlog_info("NS %u is to be disabled.",
- ns->ns_id);
+ zlog_info("NS %u is to be disabled.", ns->ns_id);
if (ns_master.ns_disable_hook)
(*ns_master.ns_disable_hook)(ns);
}
/* Look up the data pointer of the specified VRF. */
-void *
-ns_info_lookup(ns_id_t ns_id)
+void *ns_info_lookup(ns_id_t ns_id)
{
struct ns *ns = ns_lookup_internal(ns_id);
vty_out(vty, "Invalid pathname: %s\n",
safe_strerror(errno));
else
- zlog_warn("Invalid pathname: %s",
- safe_strerror(errno));
+ zlog_warn("Invalid pathname: %s", safe_strerror(errno));
return NULL;
}
check_base = basename(pathname);
if (check_base != NULL && strlen(check_base) + 1 > NS_NAMSIZ) {
if (vty)
vty_out(vty, "NS name (%s) invalid: too long (>%d)\n",
- check_base, NS_NAMSIZ-1);
+ check_base, NS_NAMSIZ - 1);
else
zlog_warn("NS name (%s) invalid: too long (>%d)",
- check_base, NS_NAMSIZ-1);
+ check_base, NS_NAMSIZ - 1);
return NULL;
}
return pathname;
ns_init();
default_ns = ns_get_created_internal(NULL, NULL, default_ns_id);
if (!default_ns) {
- zlog_err("%s: failed to create the default NS!",
- __func__);
+ zlog_err("%s: failed to create the default NS!", __func__);
exit(1);
}
if (have_netns()) {
/* Set the default NS name. */
default_ns->name = XSTRDUP(MTYPE_NS_NAME, NS_DEFAULT_NAME);
if (ns_debug)
- zlog_info("%s: default NSID is %u",
- __func__, default_ns->ns_id);
+ zlog_info("%s: default NSID is %u", __func__,
+ default_ns->ns_id);
/* Enable the default NS. */
if (!ns_enable(default_ns, NULL)) {
- zlog_err("%s: failed to enable the default NS!",
- __func__);
+ zlog_err("%s: failed to enable the default NS!", __func__);
exit(1);
}
}
return default_ns->ns_id;
return NS_UNKNOWN;
}
-
return 1;
}
-int
-nexthop_same_firsthop (struct nexthop *next1, struct nexthop *next2)
+int nexthop_same_firsthop(struct nexthop *next1, struct nexthop *next2)
{
int type1 = NEXTHOP_FIRSTHOPTYPE(next1->type);
int type2 = NEXTHOP_FIRSTHOPTYPE(next2->type);
if (type1 != type2)
return 0;
- switch (type1)
- {
+ switch (type1) {
case NEXTHOP_TYPE_IPV4_IFINDEX:
- if (! IPV4_ADDR_SAME (&next1->gate.ipv4, &next2->gate.ipv4))
+ if (!IPV4_ADDR_SAME(&next1->gate.ipv4, &next2->gate.ipv4))
return 0;
if (next1->ifindex != next2->ifindex)
return 0;
return 0;
break;
case NEXTHOP_TYPE_IPV6_IFINDEX:
- if (! IPV6_ADDR_SAME (&next1->gate.ipv6, &next2->gate.ipv6))
+ if (!IPV6_ADDR_SAME(&next1->gate.ipv6, &next2->gate.ipv6))
return 0;
if (next1->ifindex != next2->ifindex)
return 0;
nexthop->flags = nh1->flags;
memcpy(&nexthop->gate, &nh1->gate, sizeof(nh1->gate));
memcpy(&nexthop->src, &nh1->src, sizeof(nh1->src));
- memcpy(&nexthop->rmap_src, &nh1->rmap_src, sizeof(nh1->rmap_src));
+ memcpy(&nexthop->rmap_src, &nh1->rmap_src,
+ sizeof(nh1->rmap_src));
nexthop->rparent = rparent;
if (nh1->nh_label)
nexthop_add_labels(nexthop, nh1->nh_label_type,
};
/* IPV[46] -> IPV[46]_IFINDEX */
-#define NEXTHOP_FIRSTHOPTYPE(type) \
- ((type) == NEXTHOP_TYPE_IFINDEX || (type) == NEXTHOP_TYPE_BLACKHOLE) \
- ? (type) : ((type) | 1)
+#define NEXTHOP_FIRSTHOPTYPE(type) \
+ ((type) == NEXTHOP_TYPE_IFINDEX || (type) == NEXTHOP_TYPE_BLACKHOLE) \
+ ? (type) \
+ : ((type) | 1)
/* Nexthop structure. */
struct nexthop {
#define NEXTHOP_FLAG_FILTERED (1 << 5) /* rmap filtered, used by static only */
#define NEXTHOP_FLAG_DUPLICATE (1 << 6) /* nexthop duplicates another active one */
#define NEXTHOP_FLAG_EVPN_RVTEP (1 << 7) /* EVPN remote vtep nexthop */
-#define NEXTHOP_IS_ACTIVE(flags) \
- (CHECK_FLAG(flags, NEXTHOP_FLAG_ACTIVE) \
- && !CHECK_FLAG(flags, NEXTHOP_FLAG_DUPLICATE))
+#define NEXTHOP_IS_ACTIVE(flags) \
+ (CHECK_FLAG(flags, NEXTHOP_FLAG_ACTIVE) \
+ && !CHECK_FLAG(flags, NEXTHOP_FLAG_DUPLICATE))
/* Nexthop address */
union {
extern int nexthop_same_no_recurse(const struct nexthop *next1,
const struct nexthop *next2);
extern int nexthop_labels_match(struct nexthop *nh1, struct nexthop *nh2);
-extern int nexthop_same_firsthop (struct nexthop *next1, struct nexthop *next2);
+extern int nexthop_same_firsthop(struct nexthop *next1, struct nexthop *next2);
extern const char *nexthop2str(struct nexthop *nexthop, char *str, int size);
extern struct nexthop *nexthop_next(struct nexthop *nexthop);
#include <lib/openbsd-tree.h>
-static inline struct rb_entry *
-rb_n2e(const struct rb_type *t, void *node)
+static inline struct rb_entry *rb_n2e(const struct rb_type *t, void *node)
{
unsigned long addr = (unsigned long)node;
return ((struct rb_entry *)(addr + t->t_offset));
}
-static inline void *
-rb_e2n(const struct rb_type *t, struct rb_entry *rbe)
+static inline void *rb_e2n(const struct rb_type *t, struct rb_entry *rbe)
{
unsigned long addr = (unsigned long)rbe;
#define RBH_ROOT(_rbt) (_rbt)->rbt_root
-static inline void
-rbe_set(struct rb_entry *rbe, struct rb_entry *parent)
+static inline void rbe_set(struct rb_entry *rbe, struct rb_entry *parent)
{
RBE_PARENT(rbe) = parent;
RBE_LEFT(rbe) = RBE_RIGHT(rbe) = NULL;
RBE_COLOR(rbe) = RB_RED;
}
-static inline void
-rbe_set_blackred(struct rb_entry *black, struct rb_entry *red)
+static inline void rbe_set_blackred(struct rb_entry *black,
+ struct rb_entry *red)
{
RBE_COLOR(black) = RB_BLACK;
RBE_COLOR(red) = RB_RED;
}
-static inline void
-rbe_augment(const struct rb_type *t, struct rb_entry *rbe)
+static inline void rbe_augment(const struct rb_type *t, struct rb_entry *rbe)
{
(*t->t_augment)(rb_e2n(t, rbe));
}
-static inline void
-rbe_if_augment(const struct rb_type *t, struct rb_entry *rbe)
+static inline void rbe_if_augment(const struct rb_type *t, struct rb_entry *rbe)
{
if (t->t_augment != NULL)
rbe_augment(t, rbe);
}
-static inline void
-rbe_rotate_left(const struct rb_type *t, struct rbt_tree *rbt,
- struct rb_entry *rbe)
+static inline void rbe_rotate_left(const struct rb_type *t,
+ struct rbt_tree *rbt, struct rb_entry *rbe)
{
struct rb_entry *parent;
struct rb_entry *tmp;
}
}
-static inline void
-rbe_rotate_right(const struct rb_type *t, struct rbt_tree *rbt,
- struct rb_entry *rbe)
+static inline void rbe_rotate_right(const struct rb_type *t,
+ struct rbt_tree *rbt, struct rb_entry *rbe)
{
struct rb_entry *parent;
struct rb_entry *tmp;
}
}
-static inline void
-rbe_insert_color(const struct rb_type *t, struct rbt_tree *rbt,
- struct rb_entry *rbe)
+static inline void rbe_insert_color(const struct rb_type *t,
+ struct rbt_tree *rbt, struct rb_entry *rbe)
{
struct rb_entry *parent, *gparent, *tmp;
- while ((parent = RBE_PARENT(rbe)) != NULL &&
- RBE_COLOR(parent) == RB_RED) {
+ while ((parent = RBE_PARENT(rbe)) != NULL
+ && RBE_COLOR(parent) == RB_RED) {
gparent = RBE_PARENT(parent);
if (parent == RBE_LEFT(gparent)) {
RBE_COLOR(RBH_ROOT(rbt)) = RB_BLACK;
}
-static inline void
-rbe_remove_color(const struct rb_type *t, struct rbt_tree *rbt,
- struct rb_entry *parent, struct rb_entry *rbe)
+static inline void rbe_remove_color(const struct rb_type *t,
+ struct rbt_tree *rbt,
+ struct rb_entry *parent,
+ struct rb_entry *rbe)
{
struct rb_entry *tmp;
- while ((rbe == NULL || RBE_COLOR(rbe) == RB_BLACK) &&
- rbe != RBH_ROOT(rbt) && parent) {
+ while ((rbe == NULL || RBE_COLOR(rbe) == RB_BLACK)
+ && rbe != RBH_ROOT(rbt) && parent) {
if (RBE_LEFT(parent) == rbe) {
tmp = RBE_RIGHT(parent);
if (RBE_COLOR(tmp) == RB_RED) {
rbe_rotate_left(t, rbt, parent);
tmp = RBE_RIGHT(parent);
}
- if ((RBE_LEFT(tmp) == NULL ||
- RBE_COLOR(RBE_LEFT(tmp)) == RB_BLACK) &&
- (RBE_RIGHT(tmp) == NULL ||
- RBE_COLOR(RBE_RIGHT(tmp)) == RB_BLACK)) {
+ if ((RBE_LEFT(tmp) == NULL
+ || RBE_COLOR(RBE_LEFT(tmp)) == RB_BLACK)
+ && (RBE_RIGHT(tmp) == NULL
+ || RBE_COLOR(RBE_RIGHT(tmp)) == RB_BLACK)) {
RBE_COLOR(tmp) = RB_RED;
rbe = parent;
parent = RBE_PARENT(rbe);
} else {
- if (RBE_RIGHT(tmp) == NULL ||
- RBE_COLOR(RBE_RIGHT(tmp)) == RB_BLACK) {
+ if (RBE_RIGHT(tmp) == NULL
+ || RBE_COLOR(RBE_RIGHT(tmp)) == RB_BLACK) {
struct rb_entry *oleft;
oleft = RBE_LEFT(tmp);
tmp = RBE_LEFT(parent);
}
- if ((RBE_LEFT(tmp) == NULL ||
- RBE_COLOR(RBE_LEFT(tmp)) == RB_BLACK) &&
- (RBE_RIGHT(tmp) == NULL ||
- RBE_COLOR(RBE_RIGHT(tmp)) == RB_BLACK)) {
+ if ((RBE_LEFT(tmp) == NULL
+ || RBE_COLOR(RBE_LEFT(tmp)) == RB_BLACK)
+ && (RBE_RIGHT(tmp) == NULL
+ || RBE_COLOR(RBE_RIGHT(tmp)) == RB_BLACK)) {
RBE_COLOR(tmp) = RB_RED;
rbe = parent;
parent = RBE_PARENT(rbe);
} else {
- if (RBE_LEFT(tmp) == NULL ||
- RBE_COLOR(RBE_LEFT(tmp)) == RB_BLACK) {
+ if (RBE_LEFT(tmp) == NULL
+ || RBE_COLOR(RBE_LEFT(tmp)) == RB_BLACK) {
struct rb_entry *oright;
oright = RBE_RIGHT(tmp);
return (old);
}
-void *
-_rb_remove(const struct rb_type *t, struct rbt_tree *rbt, void *elm)
+void *_rb_remove(const struct rb_type *t, struct rbt_tree *rbt, void *elm)
{
struct rb_entry *rbe = rb_n2e(t, elm);
struct rb_entry *old;
return (old == NULL ? NULL : rb_e2n(t, old));
}
-void *
-_rb_insert(const struct rb_type *t, struct rbt_tree *rbt, void *elm)
+void *_rb_insert(const struct rb_type *t, struct rbt_tree *rbt, void *elm)
{
struct rb_entry *rbe = rb_n2e(t, elm);
struct rb_entry *tmp;
}
/* Finds the node with the same key as elm */
-void *
-_rb_find(const struct rb_type *t, struct rbt_tree *rbt, const void *key)
+void *_rb_find(const struct rb_type *t, struct rbt_tree *rbt, const void *key)
{
struct rb_entry *tmp = RBH_ROOT(rbt);
void *node;
}
/* Finds the first node greater than or equal to the search key */
-void *
-_rb_nfind(const struct rb_type *t, struct rbt_tree *rbt, const void *key)
+void *_rb_nfind(const struct rb_type *t, struct rbt_tree *rbt, const void *key)
{
struct rb_entry *tmp = RBH_ROOT(rbt);
void *node;
return (res);
}
-void *
-_rb_next(const struct rb_type *t, void *elm)
+void *_rb_next(const struct rb_type *t, void *elm)
{
struct rb_entry *rbe = rb_n2e(t, elm);
while (RBE_LEFT(rbe) != NULL)
rbe = RBE_LEFT(rbe);
} else {
- if (RBE_PARENT(rbe) &&
- (rbe == RBE_LEFT(RBE_PARENT(rbe))))
+ if (RBE_PARENT(rbe) && (rbe == RBE_LEFT(RBE_PARENT(rbe))))
rbe = RBE_PARENT(rbe);
else {
- while (RBE_PARENT(rbe) &&
- (rbe == RBE_RIGHT(RBE_PARENT(rbe))))
+ while (RBE_PARENT(rbe)
+ && (rbe == RBE_RIGHT(RBE_PARENT(rbe))))
rbe = RBE_PARENT(rbe);
rbe = RBE_PARENT(rbe);
}
return (rbe == NULL ? NULL : rb_e2n(t, rbe));
}
-void *
-_rb_prev(const struct rb_type *t, void *elm)
+void *_rb_prev(const struct rb_type *t, void *elm)
{
struct rb_entry *rbe = rb_n2e(t, elm);
while (RBE_RIGHT(rbe))
rbe = RBE_RIGHT(rbe);
} else {
- if (RBE_PARENT(rbe) &&
- (rbe == RBE_RIGHT(RBE_PARENT(rbe))))
+ if (RBE_PARENT(rbe) && (rbe == RBE_RIGHT(RBE_PARENT(rbe))))
rbe = RBE_PARENT(rbe);
else {
- while (RBE_PARENT(rbe) &&
- (rbe == RBE_LEFT(RBE_PARENT(rbe))))
+ while (RBE_PARENT(rbe)
+ && (rbe == RBE_LEFT(RBE_PARENT(rbe))))
rbe = RBE_PARENT(rbe);
rbe = RBE_PARENT(rbe);
}
return (rbe == NULL ? NULL : rb_e2n(t, rbe));
}
-void *
-_rb_root(const struct rb_type *t, struct rbt_tree *rbt)
+void *_rb_root(const struct rb_type *t, struct rbt_tree *rbt)
{
struct rb_entry *rbe = RBH_ROOT(rbt);
return (rbe == NULL ? rbe : rb_e2n(t, rbe));
}
-void *
-_rb_min(const struct rb_type *t, struct rbt_tree *rbt)
+void *_rb_min(const struct rb_type *t, struct rbt_tree *rbt)
{
struct rb_entry *rbe = RBH_ROOT(rbt);
struct rb_entry *parent = NULL;
return (parent == NULL ? NULL : rb_e2n(t, parent));
}
-void *
-_rb_max(const struct rb_type *t, struct rbt_tree *rbt)
+void *_rb_max(const struct rb_type *t, struct rbt_tree *rbt)
{
struct rb_entry *rbe = RBH_ROOT(rbt);
struct rb_entry *parent = NULL;
return (parent == NULL ? NULL : rb_e2n(t, parent));
}
-void *
-_rb_left(const struct rb_type *t, void *node)
+void *_rb_left(const struct rb_type *t, void *node)
{
struct rb_entry *rbe = rb_n2e(t, node);
rbe = RBE_LEFT(rbe);
return (rbe == NULL ? NULL : rb_e2n(t, rbe));
}
-void *
-_rb_right(const struct rb_type *t, void *node)
+void *_rb_right(const struct rb_type *t, void *node)
{
struct rb_entry *rbe = rb_n2e(t, node);
rbe = RBE_RIGHT(rbe);
return (rbe == NULL ? NULL : rb_e2n(t, rbe));
}
-void *
-_rb_parent(const struct rb_type *t, void *node)
+void *_rb_parent(const struct rb_type *t, void *node)
{
struct rb_entry *rbe = rb_n2e(t, node);
rbe = RBE_PARENT(rbe);
return (rbe == NULL ? NULL : rb_e2n(t, rbe));
}
-void
-_rb_set_left(const struct rb_type *t, void *node, void *left)
+void _rb_set_left(const struct rb_type *t, void *node, void *left)
{
struct rb_entry *rbe = rb_n2e(t, node);
struct rb_entry *rbl = (left == NULL) ? NULL : rb_n2e(t, left);
RBE_LEFT(rbe) = rbl;
}
-void
-_rb_set_right(const struct rb_type *t, void *node, void *right)
+void _rb_set_right(const struct rb_type *t, void *node, void *right)
{
struct rb_entry *rbe = rb_n2e(t, node);
struct rb_entry *rbr = (right == NULL) ? NULL : rb_n2e(t, right);
RBE_RIGHT(rbe) = rbr;
}
-void
-_rb_set_parent(const struct rb_type *t, void *node, void *parent)
+void _rb_set_parent(const struct rb_type *t, void *node, void *parent)
{
struct rb_entry *rbe = rb_n2e(t, node);
struct rb_entry *rbp = (parent == NULL) ? NULL : rb_n2e(t, parent);
RBE_PARENT(rbe) = rbp;
}
-void
-_rb_poison(const struct rb_type *t, void *node, unsigned long poison)
+void _rb_poison(const struct rb_type *t, void *node, unsigned long poison)
{
struct rb_entry *rbe = rb_n2e(t, node);
RBE_PARENT(rbe) = RBE_LEFT(rbe) = RBE_RIGHT(rbe) =
- (struct rb_entry *)poison;
+ (struct rb_entry *)poison;
}
-int
-_rb_check(const struct rb_type *t, void *node, unsigned long poison)
+int _rb_check(const struct rb_type *t, void *node, unsigned long poison)
{
struct rb_entry *rbe = rb_n2e(t, node);
- return ((unsigned long)RBE_PARENT(rbe) == poison &&
- (unsigned long)RBE_LEFT(rbe) == poison &&
- (unsigned long)RBE_RIGHT(rbe) == poison);
+ return ((unsigned long)RBE_PARENT(rbe) == poison
+ && (unsigned long)RBE_LEFT(rbe) == poison
+ && (unsigned long)RBE_RIGHT(rbe) == poison);
}
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef _SYS_TREE_H_
+#ifndef _SYS_TREE_H_
#define _SYS_TREE_H_
/*
* The maximum height of a red-black tree is 2lg (n+1).
*/
-#define SPLAY_HEAD(name, type) \
-struct name { \
- struct type *sph_root; /* root of the tree */ \
-}
+#define SPLAY_HEAD(name, type) \
+ struct name { \
+ struct type *sph_root; /* root of the tree */ \
+ }
-#define SPLAY_INITIALIZER(root) \
- { NULL }
+#define SPLAY_INITIALIZER(root) \
+ { \
+ NULL \
+ }
-#define SPLAY_INIT(root) do { \
- (root)->sph_root = NULL; \
-} while (0)
+#define SPLAY_INIT(root) \
+ do { \
+ (root)->sph_root = NULL; \
+ } while (0)
-#define SPLAY_ENTRY(type) \
-struct { \
- struct type *spe_left; /* left element */ \
- struct type *spe_right; /* right element */ \
-}
+#define SPLAY_ENTRY(type) \
+ struct { \
+ struct type *spe_left; /* left element */ \
+ struct type *spe_right; /* right element */ \
+ }
#define SPLAY_LEFT(elm, field) (elm)->field.spe_left
#define SPLAY_RIGHT(elm, field) (elm)->field.spe_right
#define SPLAY_EMPTY(head) (SPLAY_ROOT(head) == NULL)
/* SPLAY_ROTATE_{LEFT,RIGHT} expect that tmp hold SPLAY_{RIGHT,LEFT} */
-#define SPLAY_ROTATE_RIGHT(head, tmp, field) do { \
- SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(tmp, field); \
- SPLAY_RIGHT(tmp, field) = (head)->sph_root; \
- (head)->sph_root = tmp; \
-} while (0)
-
-#define SPLAY_ROTATE_LEFT(head, tmp, field) do { \
- SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(tmp, field); \
- SPLAY_LEFT(tmp, field) = (head)->sph_root; \
- (head)->sph_root = tmp; \
-} while (0)
-
-#define SPLAY_LINKLEFT(head, tmp, field) do { \
- SPLAY_LEFT(tmp, field) = (head)->sph_root; \
- tmp = (head)->sph_root; \
- (head)->sph_root = SPLAY_LEFT((head)->sph_root, field); \
-} while (0)
-
-#define SPLAY_LINKRIGHT(head, tmp, field) do { \
- SPLAY_RIGHT(tmp, field) = (head)->sph_root; \
- tmp = (head)->sph_root; \
- (head)->sph_root = SPLAY_RIGHT((head)->sph_root, field); \
-} while (0)
-
-#define SPLAY_ASSEMBLE(head, node, left, right, field) do { \
- SPLAY_RIGHT(left, field) = SPLAY_LEFT((head)->sph_root, field); \
- SPLAY_LEFT(right, field) = SPLAY_RIGHT((head)->sph_root, field);\
- SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(node, field); \
- SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(node, field); \
-} while (0)
+#define SPLAY_ROTATE_RIGHT(head, tmp, field) \
+ do { \
+ SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(tmp, field); \
+ SPLAY_RIGHT(tmp, field) = (head)->sph_root; \
+ (head)->sph_root = tmp; \
+ } while (0)
+
+#define SPLAY_ROTATE_LEFT(head, tmp, field) \
+ do { \
+ SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(tmp, field); \
+ SPLAY_LEFT(tmp, field) = (head)->sph_root; \
+ (head)->sph_root = tmp; \
+ } while (0)
+
+#define SPLAY_LINKLEFT(head, tmp, field) \
+ do { \
+ SPLAY_LEFT(tmp, field) = (head)->sph_root; \
+ tmp = (head)->sph_root; \
+ (head)->sph_root = SPLAY_LEFT((head)->sph_root, field); \
+ } while (0)
+
+#define SPLAY_LINKRIGHT(head, tmp, field) \
+ do { \
+ SPLAY_RIGHT(tmp, field) = (head)->sph_root; \
+ tmp = (head)->sph_root; \
+ (head)->sph_root = SPLAY_RIGHT((head)->sph_root, field); \
+ } while (0)
+
+#define SPLAY_ASSEMBLE(head, node, left, right, field) \
+ do { \
+ SPLAY_RIGHT(left, field) = \
+ SPLAY_LEFT((head)->sph_root, field); \
+ SPLAY_LEFT(right, field) = \
+ SPLAY_RIGHT((head)->sph_root, field); \
+ SPLAY_LEFT((head)->sph_root, field) = \
+ SPLAY_RIGHT(node, field); \
+ SPLAY_RIGHT((head)->sph_root, field) = \
+ SPLAY_LEFT(node, field); \
+ } while (0)
/* Generates prototypes and inline functions */
-#define SPLAY_PROTOTYPE(name, type, field, cmp) \
-void name##_SPLAY(struct name *, struct type *); \
-void name##_SPLAY_MINMAX(struct name *, int); \
-struct type *name##_SPLAY_INSERT(struct name *, struct type *); \
-struct type *name##_SPLAY_REMOVE(struct name *, struct type *); \
- \
-/* Finds the node with the same key as elm */ \
-static __inline struct type * \
-name##_SPLAY_FIND(struct name *head, struct type *elm) \
-{ \
- if (SPLAY_EMPTY(head)) \
- return(NULL); \
- name##_SPLAY(head, elm); \
- if ((cmp)(elm, (head)->sph_root) == 0) \
- return (head->sph_root); \
- return (NULL); \
-} \
- \
-static __inline struct type * \
-name##_SPLAY_NEXT(struct name *head, struct type *elm) \
-{ \
- name##_SPLAY(head, elm); \
- if (SPLAY_RIGHT(elm, field) != NULL) { \
- elm = SPLAY_RIGHT(elm, field); \
- while (SPLAY_LEFT(elm, field) != NULL) { \
- elm = SPLAY_LEFT(elm, field); \
- } \
- } else \
- elm = NULL; \
- return (elm); \
-} \
- \
-static __inline struct type * \
-name##_SPLAY_MIN_MAX(struct name *head, int val) \
-{ \
- name##_SPLAY_MINMAX(head, val); \
- return (SPLAY_ROOT(head)); \
-}
+#define SPLAY_PROTOTYPE(name, type, field, cmp) \
+ void name##_SPLAY(struct name *, struct type *); \
+ void name##_SPLAY_MINMAX(struct name *, int); \
+ struct type *name##_SPLAY_INSERT(struct name *, struct type *); \
+ struct type *name##_SPLAY_REMOVE(struct name *, struct type *); \
+ \
+ /* Finds the node with the same key as elm */ \
+ static __inline struct type *name##_SPLAY_FIND(struct name *head, \
+ struct type *elm) \
+ { \
+ if (SPLAY_EMPTY(head)) \
+ return (NULL); \
+ name##_SPLAY(head, elm); \
+ if ((cmp)(elm, (head)->sph_root) == 0) \
+ return (head->sph_root); \
+ return (NULL); \
+ } \
+ \
+ static __inline struct type *name##_SPLAY_NEXT(struct name *head, \
+ struct type *elm) \
+ { \
+ name##_SPLAY(head, elm); \
+ if (SPLAY_RIGHT(elm, field) != NULL) { \
+ elm = SPLAY_RIGHT(elm, field); \
+ while (SPLAY_LEFT(elm, field) != NULL) { \
+ elm = SPLAY_LEFT(elm, field); \
+ } \
+ } else \
+ elm = NULL; \
+ return (elm); \
+ } \
+ \
+ static __inline struct type *name##_SPLAY_MIN_MAX(struct name *head, \
+ int val) \
+ { \
+ name##_SPLAY_MINMAX(head, val); \
+ return (SPLAY_ROOT(head)); \
+ }
/* Main splay operation.
* Moves node close to the key of elm to top
*/
-#define SPLAY_GENERATE(name, type, field, cmp) \
-struct type * \
-name##_SPLAY_INSERT(struct name *head, struct type *elm) \
-{ \
- if (SPLAY_EMPTY(head)) { \
- SPLAY_LEFT(elm, field) = SPLAY_RIGHT(elm, field) = NULL; \
- } else { \
- int __comp; \
- name##_SPLAY(head, elm); \
- __comp = (cmp)(elm, (head)->sph_root); \
- if(__comp < 0) { \
- SPLAY_LEFT(elm, field) = SPLAY_LEFT((head)->sph_root, field);\
- SPLAY_RIGHT(elm, field) = (head)->sph_root; \
- SPLAY_LEFT((head)->sph_root, field) = NULL; \
- } else if (__comp > 0) { \
- SPLAY_RIGHT(elm, field) = SPLAY_RIGHT((head)->sph_root, field);\
- SPLAY_LEFT(elm, field) = (head)->sph_root; \
- SPLAY_RIGHT((head)->sph_root, field) = NULL; \
- } else \
- return ((head)->sph_root); \
- } \
- (head)->sph_root = (elm); \
- return (NULL); \
-} \
- \
-struct type * \
-name##_SPLAY_REMOVE(struct name *head, struct type *elm) \
-{ \
- struct type *__tmp; \
- if (SPLAY_EMPTY(head)) \
- return (NULL); \
- name##_SPLAY(head, elm); \
- if ((cmp)(elm, (head)->sph_root) == 0) { \
- if (SPLAY_LEFT((head)->sph_root, field) == NULL) { \
- (head)->sph_root = SPLAY_RIGHT((head)->sph_root, field);\
- } else { \
- __tmp = SPLAY_RIGHT((head)->sph_root, field); \
- (head)->sph_root = SPLAY_LEFT((head)->sph_root, field);\
- name##_SPLAY(head, elm); \
- SPLAY_RIGHT((head)->sph_root, field) = __tmp; \
- } \
- return (elm); \
- } \
- return (NULL); \
-} \
- \
-void \
-name##_SPLAY(struct name *head, struct type *elm) \
-{ \
- struct type __node, *__left, *__right, *__tmp; \
- int __comp; \
-\
- SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = NULL;\
- __left = __right = &__node; \
-\
- while ((__comp = (cmp)(elm, (head)->sph_root))) { \
- if (__comp < 0) { \
- __tmp = SPLAY_LEFT((head)->sph_root, field); \
- if (__tmp == NULL) \
- break; \
- if ((cmp)(elm, __tmp) < 0){ \
- SPLAY_ROTATE_RIGHT(head, __tmp, field); \
- if (SPLAY_LEFT((head)->sph_root, field) == NULL)\
- break; \
- } \
- SPLAY_LINKLEFT(head, __right, field); \
- } else if (__comp > 0) { \
- __tmp = SPLAY_RIGHT((head)->sph_root, field); \
- if (__tmp == NULL) \
- break; \
- if ((cmp)(elm, __tmp) > 0){ \
- SPLAY_ROTATE_LEFT(head, __tmp, field); \
- if (SPLAY_RIGHT((head)->sph_root, field) == NULL)\
- break; \
- } \
- SPLAY_LINKRIGHT(head, __left, field); \
- } \
- } \
- SPLAY_ASSEMBLE(head, &__node, __left, __right, field); \
-} \
- \
-/* Splay with either the minimum or the maximum element \
- * Used to find minimum or maximum element in tree. \
- */ \
-void name##_SPLAY_MINMAX(struct name *head, int __comp) \
-{ \
- struct type __node, *__left, *__right, *__tmp; \
-\
- SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = NULL;\
- __left = __right = &__node; \
-\
- while (1) { \
- if (__comp < 0) { \
- __tmp = SPLAY_LEFT((head)->sph_root, field); \
- if (__tmp == NULL) \
- break; \
- if (__comp < 0){ \
- SPLAY_ROTATE_RIGHT(head, __tmp, field); \
- if (SPLAY_LEFT((head)->sph_root, field) == NULL)\
- break; \
- } \
- SPLAY_LINKLEFT(head, __right, field); \
- } else if (__comp > 0) { \
- __tmp = SPLAY_RIGHT((head)->sph_root, field); \
- if (__tmp == NULL) \
- break; \
- if (__comp > 0) { \
- SPLAY_ROTATE_LEFT(head, __tmp, field); \
- if (SPLAY_RIGHT((head)->sph_root, field) == NULL)\
- break; \
- } \
- SPLAY_LINKRIGHT(head, __left, field); \
- } \
- } \
- SPLAY_ASSEMBLE(head, &__node, __left, __right, field); \
-}
+#define SPLAY_GENERATE(name, type, field, cmp) \
+ struct type *name##_SPLAY_INSERT(struct name *head, struct type *elm) \
+ { \
+ if (SPLAY_EMPTY(head)) { \
+ SPLAY_LEFT(elm, field) = SPLAY_RIGHT(elm, field) = \
+ NULL; \
+ } else { \
+ int __comp; \
+ name##_SPLAY(head, elm); \
+ __comp = (cmp)(elm, (head)->sph_root); \
+ if (__comp < 0) { \
+ SPLAY_LEFT(elm, field) = \
+ SPLAY_LEFT((head)->sph_root, field); \
+ SPLAY_RIGHT(elm, field) = (head)->sph_root; \
+ SPLAY_LEFT((head)->sph_root, field) = NULL; \
+ } else if (__comp > 0) { \
+ SPLAY_RIGHT(elm, field) = \
+ SPLAY_RIGHT((head)->sph_root, field); \
+ SPLAY_LEFT(elm, field) = (head)->sph_root; \
+ SPLAY_RIGHT((head)->sph_root, field) = NULL; \
+ } else \
+ return ((head)->sph_root); \
+ } \
+ (head)->sph_root = (elm); \
+ return (NULL); \
+ } \
+ \
+ struct type *name##_SPLAY_REMOVE(struct name *head, struct type *elm) \
+ { \
+ struct type *__tmp; \
+ if (SPLAY_EMPTY(head)) \
+ return (NULL); \
+ name##_SPLAY(head, elm); \
+ if ((cmp)(elm, (head)->sph_root) == 0) { \
+ if (SPLAY_LEFT((head)->sph_root, field) == NULL) { \
+ (head)->sph_root = \
+ SPLAY_RIGHT((head)->sph_root, field); \
+ } else { \
+ __tmp = SPLAY_RIGHT((head)->sph_root, field); \
+ (head)->sph_root = \
+ SPLAY_LEFT((head)->sph_root, field); \
+ name##_SPLAY(head, elm); \
+ SPLAY_RIGHT((head)->sph_root, field) = __tmp; \
+ } \
+ return (elm); \
+ } \
+ return (NULL); \
+ } \
+ \
+ void name##_SPLAY(struct name *head, struct type *elm) \
+ { \
+ struct type __node, *__left, *__right, *__tmp; \
+ int __comp; \
+ \
+ SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = \
+ NULL; \
+ __left = __right = &__node; \
+ \
+ while ((__comp = (cmp)(elm, (head)->sph_root))) { \
+ if (__comp < 0) { \
+ __tmp = SPLAY_LEFT((head)->sph_root, field); \
+ if (__tmp == NULL) \
+ break; \
+ if ((cmp)(elm, __tmp) < 0) { \
+ SPLAY_ROTATE_RIGHT(head, __tmp, \
+ field); \
+ if (SPLAY_LEFT((head)->sph_root, \
+ field) \
+ == NULL) \
+ break; \
+ } \
+ SPLAY_LINKLEFT(head, __right, field); \
+ } else if (__comp > 0) { \
+ __tmp = SPLAY_RIGHT((head)->sph_root, field); \
+ if (__tmp == NULL) \
+ break; \
+ if ((cmp)(elm, __tmp) > 0) { \
+ SPLAY_ROTATE_LEFT(head, __tmp, field); \
+ if (SPLAY_RIGHT((head)->sph_root, \
+ field) \
+ == NULL) \
+ break; \
+ } \
+ SPLAY_LINKRIGHT(head, __left, field); \
+ } \
+ } \
+ SPLAY_ASSEMBLE(head, &__node, __left, __right, field); \
+ } \
+ \
+ /* Splay with either the minimum or the maximum element \
+ * Used to find minimum or maximum element in tree. \
+ */ \
+ void name##_SPLAY_MINMAX(struct name *head, int __comp) \
+ { \
+ struct type __node, *__left, *__right, *__tmp; \
+ \
+ SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = \
+ NULL; \
+ __left = __right = &__node; \
+ \
+ while (1) { \
+ if (__comp < 0) { \
+ __tmp = SPLAY_LEFT((head)->sph_root, field); \
+ if (__tmp == NULL) \
+ break; \
+ if (__comp < 0) { \
+ SPLAY_ROTATE_RIGHT(head, __tmp, \
+ field); \
+ if (SPLAY_LEFT((head)->sph_root, \
+ field) \
+ == NULL) \
+ break; \
+ } \
+ SPLAY_LINKLEFT(head, __right, field); \
+ } else if (__comp > 0) { \
+ __tmp = SPLAY_RIGHT((head)->sph_root, field); \
+ if (__tmp == NULL) \
+ break; \
+ if (__comp > 0) { \
+ SPLAY_ROTATE_LEFT(head, __tmp, field); \
+ if (SPLAY_RIGHT((head)->sph_root, \
+ field) \
+ == NULL) \
+ break; \
+ } \
+ SPLAY_LINKRIGHT(head, __left, field); \
+ } \
+ } \
+ SPLAY_ASSEMBLE(head, &__node, __left, __right, field); \
+ }
#define SPLAY_NEGINF -1
#define SPLAY_INF 1
#define SPLAY_REMOVE(name, x, y) name##_SPLAY_REMOVE(x, y)
#define SPLAY_FIND(name, x, y) name##_SPLAY_FIND(x, y)
#define SPLAY_NEXT(name, x, y) name##_SPLAY_NEXT(x, y)
-#define SPLAY_MIN(name, x) (SPLAY_EMPTY(x) ? NULL \
- : name##_SPLAY_MIN_MAX(x, SPLAY_NEGINF))
-#define SPLAY_MAX(name, x) (SPLAY_EMPTY(x) ? NULL \
- : name##_SPLAY_MIN_MAX(x, SPLAY_INF))
-
-#define SPLAY_FOREACH(x, name, head) \
- for ((x) = SPLAY_MIN(name, head); \
- (x) != NULL; \
+#define SPLAY_MIN(name, x) \
+ (SPLAY_EMPTY(x) ? NULL : name##_SPLAY_MIN_MAX(x, SPLAY_NEGINF))
+#define SPLAY_MAX(name, x) \
+ (SPLAY_EMPTY(x) ? NULL : name##_SPLAY_MIN_MAX(x, SPLAY_INF))
+
+#define SPLAY_FOREACH(x, name, head) \
+ for ((x) = SPLAY_MIN(name, head); (x) != NULL; \
(x) = SPLAY_NEXT(name, head, x))
/*
#define RB_RED 1
struct rb_type {
- int (*t_compare)(const void *, const void *);
- void (*t_augment)(void *);
- unsigned int t_offset; /* offset of rb_entry in type */
+ int (*t_compare)(const void *, const void *);
+ void (*t_augment)(void *);
+ unsigned int t_offset; /* offset of rb_entry in type */
};
struct rbt_tree {
- struct rb_entry *rbt_root;
+ struct rb_entry *rbt_root;
};
struct rb_entry {
- struct rb_entry *rbt_parent;
- struct rb_entry *rbt_left;
- struct rb_entry *rbt_right;
- unsigned int rbt_color;
+ struct rb_entry *rbt_parent;
+ struct rb_entry *rbt_left;
+ struct rb_entry *rbt_right;
+ unsigned int rbt_color;
};
-#define RB_HEAD(_name, _type) \
-struct _name { \
- struct rbt_tree rbh_root; \
-}
+#define RB_HEAD(_name, _type) \
+ struct _name { \
+ struct rbt_tree rbh_root; \
+ }
#define RB_ENTRY(_type) struct rb_entry
-static inline void
-_rb_init(struct rbt_tree *rbt)
+static inline void _rb_init(struct rbt_tree *rbt)
{
rbt->rbt_root = NULL;
}
-static inline int
-_rb_empty(struct rbt_tree *rbt)
+static inline int _rb_empty(struct rbt_tree *rbt)
{
return (rbt->rbt_root == NULL);
}
-void *_rb_insert(const struct rb_type *, struct rbt_tree *, void *);
-void *_rb_remove(const struct rb_type *, struct rbt_tree *, void *);
-void *_rb_find(const struct rb_type *, struct rbt_tree *, const void *);
-void *_rb_nfind(const struct rb_type *, struct rbt_tree *, const void *);
-void *_rb_root(const struct rb_type *, struct rbt_tree *);
-void *_rb_min(const struct rb_type *, struct rbt_tree *);
-void *_rb_max(const struct rb_type *, struct rbt_tree *);
-void *_rb_next(const struct rb_type *, void *);
-void *_rb_prev(const struct rb_type *, void *);
-void *_rb_left(const struct rb_type *, void *);
-void *_rb_right(const struct rb_type *, void *);
-void *_rb_parent(const struct rb_type *, void *);
-void _rb_set_left(const struct rb_type *, void *, void *);
-void _rb_set_right(const struct rb_type *, void *, void *);
-void _rb_set_parent(const struct rb_type *, void *, void *);
-void _rb_poison(const struct rb_type *, void *, unsigned long);
-int _rb_check(const struct rb_type *, void *, unsigned long);
+void *_rb_insert(const struct rb_type *, struct rbt_tree *, void *);
+void *_rb_remove(const struct rb_type *, struct rbt_tree *, void *);
+void *_rb_find(const struct rb_type *, struct rbt_tree *, const void *);
+void *_rb_nfind(const struct rb_type *, struct rbt_tree *, const void *);
+void *_rb_root(const struct rb_type *, struct rbt_tree *);
+void *_rb_min(const struct rb_type *, struct rbt_tree *);
+void *_rb_max(const struct rb_type *, struct rbt_tree *);
+void *_rb_next(const struct rb_type *, void *);
+void *_rb_prev(const struct rb_type *, void *);
+void *_rb_left(const struct rb_type *, void *);
+void *_rb_right(const struct rb_type *, void *);
+void *_rb_parent(const struct rb_type *, void *);
+void _rb_set_left(const struct rb_type *, void *, void *);
+void _rb_set_right(const struct rb_type *, void *, void *);
+void _rb_set_parent(const struct rb_type *, void *, void *);
+void _rb_poison(const struct rb_type *, void *, unsigned long);
+int _rb_check(const struct rb_type *, void *, unsigned long);
#define RB_INITIALIZER(_head) { { NULL } }
-#define RB_PROTOTYPE(_name, _type, _field, _cmp) \
-extern const struct rb_type *const _name##_RB_TYPE; \
- \
-__attribute__((__unused__)) static inline void \
-_name##_RB_INIT(struct _name *head) \
-{ \
- _rb_init(&head->rbh_root); \
-} \
- \
-__attribute__((__unused__)) static inline struct _type * \
-_name##_RB_INSERT(struct _name *head, struct _type *elm) \
-{ \
- return _rb_insert(_name##_RB_TYPE, &head->rbh_root, elm); \
-} \
- \
-__attribute__((__unused__)) static inline struct _type * \
-_name##_RB_REMOVE(struct _name *head, struct _type *elm) \
-{ \
- return _rb_remove(_name##_RB_TYPE, &head->rbh_root, elm); \
-} \
- \
-__attribute__((__unused__)) static inline struct _type * \
-_name##_RB_FIND(struct _name *head, const struct _type *key) \
-{ \
- return _rb_find(_name##_RB_TYPE, &head->rbh_root, key); \
-} \
- \
-__attribute__((__unused__)) static inline struct _type * \
-_name##_RB_NFIND(struct _name *head, const struct _type *key) \
-{ \
- return _rb_nfind(_name##_RB_TYPE, &head->rbh_root, key); \
-} \
- \
-__attribute__((__unused__)) static inline struct _type * \
-_name##_RB_ROOT(struct _name *head) \
-{ \
- return _rb_root(_name##_RB_TYPE, &head->rbh_root); \
-} \
- \
-__attribute__((__unused__)) static inline int \
-_name##_RB_EMPTY(struct _name *head) \
-{ \
- return _rb_empty(&head->rbh_root); \
-} \
- \
-__attribute__((__unused__)) static inline struct _type * \
-_name##_RB_MIN(struct _name *head) \
-{ \
- return _rb_min(_name##_RB_TYPE, &head->rbh_root); \
-} \
- \
-__attribute__((__unused__)) static inline struct _type * \
-_name##_RB_MAX(struct _name *head) \
-{ \
- return _rb_max(_name##_RB_TYPE, &head->rbh_root); \
-} \
- \
-__attribute__((__unused__)) static inline struct _type * \
-_name##_RB_NEXT(struct _type *elm) \
-{ \
- return _rb_next(_name##_RB_TYPE, elm); \
-} \
- \
-__attribute__((__unused__)) static inline struct _type * \
-_name##_RB_PREV(struct _type *elm) \
-{ \
- return _rb_prev(_name##_RB_TYPE, elm); \
-} \
- \
-__attribute__((__unused__)) static inline struct _type * \
-_name##_RB_LEFT(struct _type *elm) \
-{ \
- return _rb_left(_name##_RB_TYPE, elm); \
-} \
- \
-__attribute__((__unused__)) static inline struct _type * \
-_name##_RB_RIGHT(struct _type *elm) \
-{ \
- return _rb_right(_name##_RB_TYPE, elm); \
-} \
- \
-__attribute__((__unused__)) static inline struct _type * \
-_name##_RB_PARENT(struct _type *elm) \
-{ \
- return _rb_parent(_name##_RB_TYPE, elm); \
-} \
- \
-__attribute__((__unused__)) static inline void \
-_name##_RB_SET_LEFT(struct _type *elm, struct _type *left) \
-{ \
- return _rb_set_left(_name##_RB_TYPE, elm, left); \
-} \
- \
-__attribute__((__unused__)) static inline void \
-_name##_RB_SET_RIGHT(struct _type *elm, struct _type *right) \
-{ \
- return _rb_set_right(_name##_RB_TYPE, elm, right); \
-} \
- \
-__attribute__((__unused__)) static inline void \
-_name##_RB_SET_PARENT(struct _type *elm, struct _type *parent) \
-{ \
- return _rb_set_parent(_name##_RB_TYPE, elm, parent); \
-} \
- \
-__attribute__((__unused__)) static inline void \
-_name##_RB_POISON(struct _type *elm, unsigned long poison) \
-{ \
- return _rb_poison(_name##_RB_TYPE, elm, poison); \
-} \
- \
-__attribute__((__unused__)) static inline int \
-_name##_RB_CHECK(struct _type *elm, unsigned long poison) \
-{ \
- return _rb_check(_name##_RB_TYPE, elm, poison); \
-}
-
-#define RB_GENERATE_INTERNAL(_name, _type, _field, _cmp, _aug) \
-static int \
-_name##_RB_COMPARE(const void *lptr, const void *rptr) \
-{ \
- const struct _type *l = lptr, *r = rptr; \
- return _cmp(l, r); \
-} \
-static const struct rb_type _name##_RB_INFO = { \
- _name##_RB_COMPARE, \
- _aug, \
- offsetof(struct _type, _field), \
-}; \
-const struct rb_type *const _name##_RB_TYPE = &_name##_RB_INFO;
-
-#define RB_GENERATE_AUGMENT(_name, _type, _field, _cmp, _aug) \
-static void \
-_name##_RB_AUGMENT(void *ptr) \
-{ \
- struct _type *p = ptr; \
- return _aug(p); \
-} \
-RB_GENERATE_INTERNAL(_name, _type, _field, _cmp, _name##_RB_AUGMENT)
-
-#define RB_GENERATE(_name, _type, _field, _cmp) \
- RB_GENERATE_INTERNAL(_name, _type, _field, _cmp, NULL)
+#define RB_PROTOTYPE(_name, _type, _field, _cmp) \
+ extern const struct rb_type *const _name##_RB_TYPE; \
+ \
+ __attribute__((__unused__)) static inline void _name##_RB_INIT( \
+ struct _name *head) \
+ { \
+ _rb_init(&head->rbh_root); \
+ } \
+ \
+ __attribute__((__unused__)) static inline struct _type \
+ *_name##_RB_INSERT(struct _name *head, struct _type *elm) \
+ { \
+ return _rb_insert(_name##_RB_TYPE, &head->rbh_root, elm); \
+ } \
+ \
+ __attribute__((__unused__)) static inline struct _type \
+ *_name##_RB_REMOVE(struct _name *head, struct _type *elm) \
+ { \
+ return _rb_remove(_name##_RB_TYPE, &head->rbh_root, elm); \
+ } \
+ \
+ __attribute__((__unused__)) static inline struct _type \
+ *_name##_RB_FIND(struct _name *head, const struct _type *key) \
+ { \
+ return _rb_find(_name##_RB_TYPE, &head->rbh_root, key); \
+ } \
+ \
+ __attribute__((__unused__)) static inline struct _type \
+ *_name##_RB_NFIND(struct _name *head, const struct _type *key) \
+ { \
+ return _rb_nfind(_name##_RB_TYPE, &head->rbh_root, key); \
+ } \
+ \
+ __attribute__((__unused__)) static inline struct _type \
+ *_name##_RB_ROOT(struct _name *head) \
+ { \
+ return _rb_root(_name##_RB_TYPE, &head->rbh_root); \
+ } \
+ \
+ __attribute__((__unused__)) static inline int _name##_RB_EMPTY( \
+ struct _name *head) \
+ { \
+ return _rb_empty(&head->rbh_root); \
+ } \
+ \
+ __attribute__((__unused__)) static inline struct _type \
+ *_name##_RB_MIN(struct _name *head) \
+ { \
+ return _rb_min(_name##_RB_TYPE, &head->rbh_root); \
+ } \
+ \
+ __attribute__((__unused__)) static inline struct _type \
+ *_name##_RB_MAX(struct _name *head) \
+ { \
+ return _rb_max(_name##_RB_TYPE, &head->rbh_root); \
+ } \
+ \
+ __attribute__((__unused__)) static inline struct _type \
+ *_name##_RB_NEXT(struct _type *elm) \
+ { \
+ return _rb_next(_name##_RB_TYPE, elm); \
+ } \
+ \
+ __attribute__((__unused__)) static inline struct _type \
+ *_name##_RB_PREV(struct _type *elm) \
+ { \
+ return _rb_prev(_name##_RB_TYPE, elm); \
+ } \
+ \
+ __attribute__((__unused__)) static inline struct _type \
+ *_name##_RB_LEFT(struct _type *elm) \
+ { \
+ return _rb_left(_name##_RB_TYPE, elm); \
+ } \
+ \
+ __attribute__((__unused__)) static inline struct _type \
+ *_name##_RB_RIGHT(struct _type *elm) \
+ { \
+ return _rb_right(_name##_RB_TYPE, elm); \
+ } \
+ \
+ __attribute__((__unused__)) static inline struct _type \
+ *_name##_RB_PARENT(struct _type *elm) \
+ { \
+ return _rb_parent(_name##_RB_TYPE, elm); \
+ } \
+ \
+ __attribute__((__unused__)) static inline void _name##_RB_SET_LEFT( \
+ struct _type *elm, struct _type *left) \
+ { \
+ return _rb_set_left(_name##_RB_TYPE, elm, left); \
+ } \
+ \
+ __attribute__((__unused__)) static inline void _name##_RB_SET_RIGHT( \
+ struct _type *elm, struct _type *right) \
+ { \
+ return _rb_set_right(_name##_RB_TYPE, elm, right); \
+ } \
+ \
+ __attribute__((__unused__)) static inline void _name##_RB_SET_PARENT( \
+ struct _type *elm, struct _type *parent) \
+ { \
+ return _rb_set_parent(_name##_RB_TYPE, elm, parent); \
+ } \
+ \
+ __attribute__((__unused__)) static inline void _name##_RB_POISON( \
+ struct _type *elm, unsigned long poison) \
+ { \
+ return _rb_poison(_name##_RB_TYPE, elm, poison); \
+ } \
+ \
+ __attribute__((__unused__)) static inline int _name##_RB_CHECK( \
+ struct _type *elm, unsigned long poison) \
+ { \
+ return _rb_check(_name##_RB_TYPE, elm, poison); \
+ }
+
+#define RB_GENERATE_INTERNAL(_name, _type, _field, _cmp, _aug) \
+ static int _name##_RB_COMPARE(const void *lptr, const void *rptr) \
+ { \
+ const struct _type *l = lptr, *r = rptr; \
+ return _cmp(l, r); \
+ } \
+ static const struct rb_type _name##_RB_INFO = { \
+ _name##_RB_COMPARE, _aug, offsetof(struct _type, _field), \
+ }; \
+ const struct rb_type *const _name##_RB_TYPE = &_name##_RB_INFO;
+
+#define RB_GENERATE_AUGMENT(_name, _type, _field, _cmp, _aug) \
+ static void _name##_RB_AUGMENT(void *ptr) \
+ { \
+ struct _type *p = ptr; \
+ return _aug(p); \
+ } \
+ RB_GENERATE_INTERNAL(_name, _type, _field, _cmp, _name##_RB_AUGMENT)
+
+#define RB_GENERATE(_name, _type, _field, _cmp) \
+ RB_GENERATE_INTERNAL(_name, _type, _field, _cmp, NULL)
#define RB_INIT(_name, _head) _name##_RB_INIT(_head)
#define RB_INSERT(_name, _head, _elm) _name##_RB_INSERT(_head, _elm)
#define RB_POISON(_name, _elm, _p) _name##_RB_POISON(_elm, _p)
#define RB_CHECK(_name, _elm, _p) _name##_RB_CHECK(_elm, _p)
-#define RB_FOREACH(_e, _name, _head) \
- for ((_e) = RB_MIN(_name, (_head)); \
- (_e) != NULL; \
+#define RB_FOREACH(_e, _name, _head) \
+ for ((_e) = RB_MIN(_name, (_head)); (_e) != NULL; \
(_e) = RB_NEXT(_name, (_e)))
-#define RB_FOREACH_SAFE(_e, _name, _head, _n) \
- for ((_e) = RB_MIN(_name, (_head)); \
- (_e) != NULL && ((_n) = RB_NEXT(_name, (_e)), 1); \
- (_e) = (_n))
+#define RB_FOREACH_SAFE(_e, _name, _head, _n) \
+ for ((_e) = RB_MIN(_name, (_head)); \
+ (_e) != NULL && ((_n) = RB_NEXT(_name, (_e)), 1); (_e) = (_n))
-#define RB_FOREACH_REVERSE(_e, _name, _head) \
- for ((_e) = RB_MAX(_name, (_head)); \
- (_e) != NULL; \
+#define RB_FOREACH_REVERSE(_e, _name, _head) \
+ for ((_e) = RB_MAX(_name, (_head)); (_e) != NULL; \
(_e) = RB_PREV(_name, (_e)))
-#define RB_FOREACH_REVERSE_SAFE(_e, _name, _head, _n) \
- for ((_e) = RB_MAX(_name, (_head)); \
- (_e) != NULL && ((_n) = RB_PREV(_name, (_e)), 1); \
- (_e) = (_n))
+#define RB_FOREACH_REVERSE_SAFE(_e, _name, _head, _n) \
+ for ((_e) = RB_MAX(_name, (_head)); \
+ (_e) != NULL && ((_n) = RB_PREV(_name, (_e)), 1); (_e) = (_n))
-#endif /* _SYS_TREE_H_ */
+#endif /* _SYS_TREE_H_ */
match = 1;
if (type == longer_display) {
- if ((p.family == pentry->prefix.family) &&
- (prefix_match(&p, &pentry->prefix)))
+ if ((p.family == pentry->prefix.family)
+ && (prefix_match(&p, &pentry->prefix)))
match = 1;
}
for (pentry = plist->head; pentry; pentry = pentry->next) {
if (prefix) {
- if (pentry->prefix.family == p.family &&
- prefix_match(&pentry->prefix, &p))
+ if (pentry->prefix.family == p.family
+ && prefix_match(&pentry->prefix, &p))
pentry->hitcnt = 0;
} else
pentry->hitcnt = 0;
* If no pointer is sent in, do not return anything.
* If it is a empty plist return a NULL pointer.
*/
-extern enum prefix_list_type prefix_list_apply_which_prefix(
- struct prefix_list *plist,
- struct prefix **which,
- void *object);
+extern enum prefix_list_type
+prefix_list_apply_which_prefix(struct prefix_list *plist, struct prefix **which,
+ void *object);
#define prefix_list_apply(A, B) prefix_list_apply_which_prefix((A), NULL, (B))
extern struct prefix_list *prefix_bgp_orf_lookup(afi_t, const char *);
static const struct in6_addr maskbytes6[] = {
/* /0 */ {{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /1 */ {{{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /2 */ {{{0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /3 */ {{{0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /4 */ {{{0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /5 */ {{{0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /6 */ {{{0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /7 */ {{{0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /8 */ {{{0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /9 */ {{{0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /10 */ {{{0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /11 */ {{{0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /12 */ {{{0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /13 */ {{{0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /14 */ {{{0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /15 */ {{{0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /16 */ {{{0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /17 */ {{{0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /18 */ {{{0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /19 */ {{{0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /20 */ {{{0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /21 */ {{{0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /22 */ {{{0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /23 */ {{{0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /24 */ {{{0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /25 */ {{{0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /26 */ {{{0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /27 */ {{{0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /28 */ {{{0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /29 */ {{{0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /30 */ {{{0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /31 */ {{{0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /32 */ {{{0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /33 */ {{{0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /34 */ {{{0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /35 */ {{{0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /36 */ {{{0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /37 */ {{{0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /38 */ {{{0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /39 */ {{{0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /40 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /41 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /42 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /43 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /44 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /45 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /46 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /47 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /48 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /49 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /50 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /51 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /52 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /53 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /54 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /55 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /56 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /57 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /58 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /59 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /60 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /61 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /62 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /63 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /64 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /65 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /66 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /67 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /68 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /69 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /70 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /71 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /72 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /73 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /74 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /75 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /76 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /77 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /78 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /79 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /80 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /81 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /82 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /83 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /84 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /85 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /86 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /87 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /88 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00}}},
- /* /89 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00}}},
- /* /90 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00}}},
- /* /91 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00}}},
- /* /92 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00}}},
- /* /93 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00}}},
- /* /94 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00}}},
- /* /95 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00}}},
- /* /96 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00}}},
- /* /97 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00}}},
- /* /98 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00}}},
- /* /99 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00}}},
- /* /100 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00}}},
- /* /101 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00}}},
- /* /102 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00}}},
- /* /103 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00}}},
- /* /104 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00}}},
- /* /105 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00}}},
- /* /106 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00}}},
- /* /107 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00}}},
- /* /108 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00}}},
- /* /109 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00}}},
- /* /110 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00}}},
- /* /111 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00}}},
- /* /112 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00}}},
- /* /113 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00}}},
- /* /114 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00}}},
- /* /115 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00}}},
- /* /116 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00}}},
- /* /117 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00}}},
- /* /118 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00}}},
- /* /119 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00}}},
- /* /120 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00}}},
- /* /121 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80}}},
- /* /122 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0}}},
- /* /123 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0}}},
- /* /124 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0}}},
- /* /125 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8}}},
- /* /126 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc}}},
- /* /127 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe}}},
- /* /128 */ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
- 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}}}};
+ /* /1 */
+ {{{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /2 */
+ {{{0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /3 */
+ {{{0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /4 */
+ {{{0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /5 */
+ {{{0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /6 */
+ {{{0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /7 */
+ {{{0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /8 */
+ {{{0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /9 */
+ {{{0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /10 */
+ {{{0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /11 */
+ {{{0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /12 */
+ {{{0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /13 */
+ {{{0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /14 */
+ {{{0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /15 */
+ {{{0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /16 */
+ {{{0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /17 */
+ {{{0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /18 */
+ {{{0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /19 */
+ {{{0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /20 */
+ {{{0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /21 */
+ {{{0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /22 */
+ {{{0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /23 */
+ {{{0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /24 */
+ {{{0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /25 */
+ {{{0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /26 */
+ {{{0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /27 */
+ {{{0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /28 */
+ {{{0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /29 */
+ {{{0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /30 */
+ {{{0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /31 */
+ {{{0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /32 */
+ {{{0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /33 */
+ {{{0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /34 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /35 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /36 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /37 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /38 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /39 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /40 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /41 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /42 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /43 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /44 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /45 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /46 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /47 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /48 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /49 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /50 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /51 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /52 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /53 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /54 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /55 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /56 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /57 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /58 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /59 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /60 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /61 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /62 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /63 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /64 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /65 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /66 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /67 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /68 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /69 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /70 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /71 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /72 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /73 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /74 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /75 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /76 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /77 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /78 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /79 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /80 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /81 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /82 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /83 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /84 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /85 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf8,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /86 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfc,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /87 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /88 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0x00, 0x00, 0x00, 0x00, 0x00}}},
+ /* /89 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0x80, 0x00, 0x00, 0x00, 0x00}}},
+ /* /90 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xc0, 0x00, 0x00, 0x00, 0x00}}},
+ /* /91 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xe0, 0x00, 0x00, 0x00, 0x00}}},
+ /* /92 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xf0, 0x00, 0x00, 0x00, 0x00}}},
+ /* /93 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xf8, 0x00, 0x00, 0x00, 0x00}}},
+ /* /94 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xfc, 0x00, 0x00, 0x00, 0x00}}},
+ /* /95 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xfe, 0x00, 0x00, 0x00, 0x00}}},
+ /* /96 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0x00, 0x00, 0x00, 0x00}}},
+ /* /97 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0x80, 0x00, 0x00, 0x00}}},
+ /* /98 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xc0, 0x00, 0x00, 0x00}}},
+ /* /99 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xe0, 0x00, 0x00, 0x00}}},
+ /* /100 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xf0, 0x00, 0x00, 0x00}}},
+ /* /101 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xf8, 0x00, 0x00, 0x00}}},
+ /* /102 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xfc, 0x00, 0x00, 0x00}}},
+ /* /103 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xfe, 0x00, 0x00, 0x00}}},
+ /* /104 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x00, 0x00, 0x00}}},
+ /* /105 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0x80, 0x00, 0x00}}},
+ /* /106 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xc0, 0x00, 0x00}}},
+ /* /107 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xe0, 0x00, 0x00}}},
+ /* /108 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xf0, 0x00, 0x00}}},
+ /* /109 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xf8, 0x00, 0x00}}},
+ /* /110 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xfc, 0x00, 0x00}}},
+ /* /111 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xfe, 0x00, 0x00}}},
+ /* /112 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0x00, 0x00}}},
+ /* /113 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0x80, 0x00}}},
+ /* /114 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xc0, 0x00}}},
+ /* /115 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xe0, 0x00}}},
+ /* /116 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xf0, 0x00}}},
+ /* /117 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xf8, 0x00}}},
+ /* /118 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xfc, 0x00}}},
+ /* /119 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xfe, 0x00}}},
+ /* /120 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0x00}}},
+ /* /121 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0x80}}},
+ /* /122 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xc0}}},
+ /* /123 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xe0}}},
+ /* /124 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xf0}}},
+ /* /125 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xf8}}},
+ /* /126 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xfc}}},
+ /* /127 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xfe}}},
+ /* /128 */
+ {{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff}}}};
/* Number of bits in prefix type. */
#ifndef PNBBY
* a comparison to zero, let's assume
*/
if (!slash && is_zero_mac(&(p->eth_addr)))
- p->prefixlen = 0;
+ p->prefixlen = 0;
ret = 1;
p->u.prefix_evpn.route_type, p->u.prefix_evpn.eth_tag,
inet_ntop(family, &p->u.prefix_evpn.ip.ip.addr, buf,
PREFIX2STR_BUFFER),
- p->u.prefix_evpn.ip_prefix_length,
- p->prefixlen);
+ p->u.prefix_evpn.ip_prefix_length, p->prefixlen);
} else {
sprintf(str, "Unsupported EVPN route type %d",
- p->u.prefix_evpn.route_type);
+ p->u.prefix_evpn.route_type);
}
return str;
* padding and unused prefix bytes. */
memset(©, 0, sizeof(copy));
prefix_copy(©, (struct prefix *)pp);
- return jhash(©, offsetof(struct prefix, u.prefix)
- + PSIZE(copy.prefixlen), 0x55aa5a5a);
+ return jhash(©,
+ offsetof(struct prefix, u.prefix) + PSIZE(copy.prefixlen),
+ 0x55aa5a5a);
}
extern int str2prefix_ipv4(const char *, struct prefix_ipv4 *);
extern void apply_mask_ipv4(struct prefix_ipv4 *);
-#define PREFIX_COPY(DST, SRC) \
+#define PREFIX_COPY(DST, SRC) \
*((struct prefix *)(DST)) = *((const struct prefix *)(SRC))
-#define PREFIX_COPY_IPV4(DST, SRC) \
+#define PREFIX_COPY_IPV4(DST, SRC) \
*((struct prefix_ipv4 *)(DST)) = *((const struct prefix_ipv4 *)(SRC));
extern int prefix_ipv4_any(const struct prefix_ipv4 *);
if (!p)
return 0;
- if ((p->family == AF_INET) &&
- (p->u.prefix4.s_addr == INADDR_ANY) &&
- (p->prefixlen == 0))
+ if ((p->family == AF_INET) && (p->u.prefix4.s_addr == INADDR_ANY)
+ && (p->prefixlen == 0))
return 1;
- if ((p->family == AF_INET6) &&
- (p->prefixlen == 0) &&
- (!memcmp(&p->u.prefix6, &in6addr_any,
- sizeof(struct in6_addr))))
+ if ((p->family == AF_INET6) && (p->prefixlen == 0)
+ && (!memcmp(&p->u.prefix6, &in6addr_any, sizeof(struct in6_addr))))
return 1;
return 0;
{
if (!nodes) {
pthread_rwlock_init(&nodes_lock, NULL);
- nodes = hash_create_size(16, qobj_key,
- qobj_cmp,
- "QOBJ Hash");
+ nodes = hash_create_size(16, qobj_key, qobj_cmp, "QOBJ Hash");
}
}
(SIMPLEQ_EMPTY((head)) \
? NULL \
: ((struct type *)(void *)((char *)((head)->sqh_last) \
- - offsetof(struct type, \
- field))))
+ - offsetof(struct type, field))))
#define STAILQ_NEXT(elm, field) SIMPLEQ_NEXT(elm, field)
#define STAILQ_REMOVE(head, elm, type, field) \
do { \
size_t remain = ringbuf_remain(buf);
if (offset >= remain)
return 0;
- size_t copysize = MAX(MIN(remain - offset, size), (size_t) 0);
+ size_t copysize = MAX(MIN(remain - offset, size), (size_t)0);
size_t tocopy = copysize;
size_t cstart = (buf->start + offset) % buf->size;
if (tocopy >= buf->size - cstart) {
}
break;
case RMAP_RULE_MISSING:
- vty_out(vty, "%% [%s] Can't find rule.\n",
- frr_protonameinst);
+ vty_out(vty, "%% [%s] Can't find rule.\n", frr_protonameinst);
return CMD_WARNING_CONFIG_FAILED;
break;
case RMAP_COMPILE_ERROR:
ret = route_map_delete_match(index, command, dep_name);
switch (ret) {
case RMAP_RULE_MISSING:
- vty_out(vty, "%% [%s] Can't find rule.\n",
- frr_protonameinst);
+ vty_out(vty, "%% [%s] Can't find rule.\n", frr_protonameinst);
retval = CMD_WARNING_CONFIG_FAILED;
break;
case RMAP_COMPILE_ERROR:
ret = route_map_add_set(index, command, arg);
switch (ret) {
case RMAP_RULE_MISSING:
- vty_out(vty, "%% [%s] Can't find rule.\n",
- frr_protonameinst);
+ vty_out(vty, "%% [%s] Can't find rule.\n", frr_protonameinst);
return CMD_WARNING_CONFIG_FAILED;
break;
case RMAP_COMPILE_ERROR:
ret = route_map_delete_set(index, command, arg);
switch (ret) {
case RMAP_RULE_MISSING:
- vty_out(vty, "%% [%s] Can't find rule.\n",
- frr_protonameinst);
+ vty_out(vty, "%% [%s] Can't find rule.\n", frr_protonameinst);
return CMD_WARNING_CONFIG_FAILED;
break;
case RMAP_COMPILE_ERROR:
dep_entry = XCALLOC(MTYPE_ROUTE_MAP_DEP, sizeof(struct route_map_dep));
dep_entry->dep_name = XSTRDUP(MTYPE_ROUTE_MAP_NAME, dep_name);
- dep_entry->dep_rmap_hash = hash_create_size(8,
- route_map_dep_hash_make_key,
- route_map_rmap_hash_cmp,
- "Route Map Dep Hash");
+ dep_entry->dep_rmap_hash =
+ hash_create_size(8, route_map_dep_hash_make_key,
+ route_map_rmap_hash_cmp, "Route Map Dep Hash");
dep_entry->this_hash = NULL;
return ((void *)dep_entry);
route_match_vec = vector_init(1);
route_set_vec = vector_init(1);
route_map_master_hash =
- hash_create_size(8, route_map_hash_key_make,
- route_map_hash_cmp,
+ hash_create_size(8, route_map_hash_key_make, route_map_hash_cmp,
"Route Map Master Hash");
for (i = 1; i < ROUTE_MAP_DEP_MAX; i++)
- route_map_dep_hash[i] =
- hash_create_size(8, route_map_dep_hash_make_key,
- route_map_dep_hash_cmp,
- "Route Map Dep Hash");
+ route_map_dep_hash[i] = hash_create_size(
+ 8, route_map_dep_hash_make_key, route_map_dep_hash_cmp,
+ "Route Map Dep Hash");
cmd_variable_handler_register(rmap_var_handlers);
};
/* Route map apply error. */
-enum {
- RMAP_COMPILE_SUCCESS,
+enum { RMAP_COMPILE_SUCCESS,
- /* Route map rule is missing. */
- RMAP_RULE_MISSING,
+ /* Route map rule is missing. */
+ RMAP_RULE_MISSING,
- /* Route map rule can't compile */
- RMAP_COMPILE_ERROR
-};
+ /* Route map rule can't compile */
+ RMAP_COMPILE_ERROR };
/* Route map rule list. */
struct route_map_rule_list {
* return 1;
* }
*
- * In this case, sbuf_example uses a string buffer with undefined size, which will
- * be allocated on the heap by sbuf. The caller of sbuf_example is expected to free
+ * In this case, sbuf_example uses a string buffer with undefined size, which
+ * will
+ * be allocated on the heap by sbuf. The caller of sbuf_example is expected to
+ * free
* the string returned in parser_log.
*/
struct timeval remain =
thread_timer_remain(backoff->t_holddown);
vty_out(vty, "%s Still runs for %lld msec\n",
- prefix, (long long)remain.tv_sec * 1000
+ prefix,
+ (long long)remain.tv_sec * 1000
+ remain.tv_usec / 1000);
} else {
vty_out(vty, "%s Inactive\n", prefix);
struct timeval remain =
thread_timer_remain(backoff->t_timetolearn);
vty_out(vty, "%s Still runs for %lld msec\n",
- prefix, (long long)remain.tv_sec * 1000
+ prefix,
+ (long long)remain.tv_sec * 1000
+ remain.tv_usec / 1000);
} else {
vty_out(vty, "%s Inactive\n", prefix);
assert(ENDP_VALID(S, (S)->endp)); \
} while (0)
-#define STREAM_BOUND_WARN(S, WHAT) \
- do { \
- zlog_warn("%s: Attempt to %s out of bounds", __func__, \
- (WHAT)); \
- STREAM_WARN_OFFSETS(S); \
- assert(0); \
+#define STREAM_BOUND_WARN(S, WHAT) \
+ do { \
+ zlog_warn("%s: Attempt to %s out of bounds", __func__, \
+ (WHAT)); \
+ STREAM_WARN_OFFSETS(S); \
+ assert(0); \
} while (0)
-#define STREAM_BOUND_WARN2(S, WHAT) \
- do { \
- zlog_warn("%s: Attempt to %s out of bounds", __func__, \
- (WHAT)); \
- STREAM_WARN_OFFSETS(S); \
+#define STREAM_BOUND_WARN2(S, WHAT) \
+ do { \
+ zlog_warn("%s: Attempt to %s out of bounds", __func__, \
+ (WHAT)); \
+ STREAM_WARN_OFFSETS(S); \
} while (0)
/* XXX: Deprecated macro: do not use */
return false;
}
- *word = s->data[s->getp++] << 8;
+ *word = s->data[s->getp++] << 8;
*word |= s->data[s->getp++];
return true;
return false;
}
- *l = (unsigned int)(s->data[s->getp++]) << 24;
+ *l = (unsigned int)(s->data[s->getp++]) << 24;
*l |= s->data[s->getp++] << 16;
*l |= s->data[s->getp++] << 8;
*l |= s->data[s->getp++];
return true;
-
}
u_int32_t stream_getl(struct stream *s)
* the stream functions but we need a transition
* plan.
*/
-#define STREAM_GETC(S, P) \
- do { \
- uint8_t _pval; \
- if (!stream_getc2((S), &_pval)) \
- goto stream_failure; \
- (P) = _pval; \
+#define STREAM_GETC(S, P) \
+ do { \
+ uint8_t _pval; \
+ if (!stream_getc2((S), &_pval)) \
+ goto stream_failure; \
+ (P) = _pval; \
} while (0)
-#define STREAM_GETW(S, P) \
- do { \
- uint16_t _pval; \
- if (!stream_getw2((S), &_pval)) \
- goto stream_failure; \
- (P) = _pval; \
+#define STREAM_GETW(S, P) \
+ do { \
+ uint16_t _pval; \
+ if (!stream_getw2((S), &_pval)) \
+ goto stream_failure; \
+ (P) = _pval; \
} while (0)
-#define STREAM_GETL(S, P) \
- do { \
- uint32_t _pval; \
- if (!stream_getl2((S), &_pval)) \
- goto stream_failure; \
- (P) = _pval; \
+#define STREAM_GETL(S, P) \
+ do { \
+ uint32_t _pval; \
+ if (!stream_getl2((S), &_pval)) \
+ goto stream_failure; \
+ (P) = _pval; \
} while (0)
-#define STREAM_GET(P, STR, SIZE) \
- do { \
- if (!stream_get2((P), (STR), (SIZE))) \
- goto stream_failure; \
+#define STREAM_GET(P, STR, SIZE) \
+ do { \
+ if (!stream_get2((P), (STR), (SIZE))) \
+ goto stream_failure; \
} while (0)
#endif /* _ZEBRA_STREAM_H */
/* CLI start ---------------------------------------------------------------- */
static unsigned int cpu_record_hash_key(struct cpu_thread_history *a)
{
- int size = sizeof (&a->func);
+ int size = sizeof(&a->func);
return jhash(&a->func, size, 0);
}
}
rv->cpu_record = hash_create_size(
- 8,
- (unsigned int (*)(void *))cpu_record_hash_key,
+ 8, (unsigned int (*)(void *))cpu_record_hash_key,
(int (*)(const void *, const void *))cpu_record_hash_cmp,
"Thread Hash");
zlog_debug(
"[!] Received cancellation request for nonexistent rw job");
zlog_debug("[!] threadmaster: %s | fd: %d",
- master->name ? master->name : "", fd);
+ master->name ? master->name : "", fd);
return;
}
int new = 0;
if (debug_vrf)
- zlog_debug("VRF_GET: %s(%u)",
- name == NULL ? "(NULL)" : name, vrf_id);
+ zlog_debug("VRF_GET: %s(%u)", name == NULL ? "(NULL)" : name,
+ vrf_id);
/* Nothing to see, move along here */
if (!name && vrf_id == VRF_UNKNOWN)
ret = vrf_switch_to_netns(vrf_id);
if (ret < 0)
- zlog_err("%s: Can't switch to VRF %u (%s)",
- __func__, vrf_id, safe_strerror(errno));
+ zlog_err("%s: Can't switch to VRF %u (%s)", __func__, vrf_id,
+ safe_strerror(errno));
ret = socket(domain, type, protocol);
save_errno = errno;
ret2 = vrf_switchback_to_initial();
if (ret2 < 0)
- zlog_err("%s: Can't switchback from VRF %u (%s)",
- __func__, vrf_id, safe_strerror(errno));
+ zlog_err("%s: Can't switchback from VRF %u (%s)", __func__,
+ vrf_id, safe_strerror(errno));
errno = save_errno;
if (ret <= 0)
return ret;
if (strlen(vrfname) > VRF_NAMSIZ) {
if (vty)
vty_out(vty,
- "%% VRF name %s invalid: length exceeds %d bytes\n",
- vrfname, VRF_NAMSIZ);
+ "%% VRF name %s invalid: length exceeds %d bytes\n",
+ vrfname, VRF_NAMSIZ);
else
zlog_warn(
- "%% VRF name %s invalid: length exceeds %d bytes\n",
- vrfname, VRF_NAMSIZ);
+ "%% VRF name %s invalid: length exceeds %d bytes\n",
+ vrfname, VRF_NAMSIZ);
return CMD_WARNING_CONFIG_FAILED;
}
return CMD_SUCCESS;
}
-int vrf_netns_handler_create(struct vty *vty, struct vrf *vrf,
- char *pathname, ns_id_t ns_id)
+int vrf_netns_handler_create(struct vty *vty, struct vrf *vrf, char *pathname,
+ ns_id_t ns_id)
{
struct ns *ns = NULL;
return CMD_WARNING_CONFIG_FAILED;
}
if (vrf->ns_ctxt != NULL) {
- ns = (struct ns *) vrf->ns_ctxt;
+ ns = (struct ns *)vrf->ns_ctxt;
if (ns && 0 != strcmp(ns->name, pathname)) {
if (vty)
vty_out(vty,
- "VRF %u already configured with NETNS %s\n",
- vrf->vrf_id, ns->name);
+ "VRF %u already configured with NETNS %s\n",
+ vrf->vrf_id, ns->name);
else
zlog_warn(
- "VRF %u already configured with NETNS %s",
- vrf->vrf_id, ns->name);
+ "VRF %u already configured with NETNS %s",
+ vrf->vrf_id, ns->name);
return CMD_WARNING_CONFIG_FAILED;
}
}
if (vrf2 == vrf)
return CMD_SUCCESS;
if (vty)
- vty_out(vty, "NS %s is already configured"
+ vty_out(vty,
+ "NS %s is already configured"
" with VRF %u(%s)\n",
- ns->name, vrf2->vrf_id, vrf2->name);
+ ns->name, vrf2->vrf_id, vrf2->name);
else
zlog_warn("NS %s is already configured with VRF %u(%s)",
ns->name, vrf2->vrf_id, vrf2->name);
if (!ns_enable(ns, vrf_update_vrf_id)) {
if (vty)
vty_out(vty, "Can not associate NS %u with NETNS %s\n",
- ns->ns_id, ns->name);
+ ns->ns_id, ns->name);
else
zlog_warn("Can not associate NS %u with NETNS %s",
ns->ns_id, ns->name);
if (vrf_is_mapped_on_netns(vrf_id))
return fd;
#ifdef SO_BINDTODEVICE
- ret = setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, name,
- strlen(name));
+ ret = setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, name, strlen(name));
if (ret < 0)
- zlog_debug("bind to interface %s failed, errno=%d",
- name, errno);
+ zlog_debug("bind to interface %s failed, errno=%d", name,
+ errno);
#endif /* SO_BINDTODEVICE */
return ret;
}
int vrf_getaddrinfo(const char *node, const char *service,
- const struct addrinfo *hints,
- struct addrinfo **res, vrf_id_t vrf_id)
+ const struct addrinfo *hints, struct addrinfo **res,
+ vrf_id_t vrf_id)
{
int ret, ret2, save_errno;
ret = vrf_switch_to_netns(vrf_id);
if (ret < 0)
- zlog_err("%s: Can't switch to VRF %u (%s)",
- __func__, vrf_id, safe_strerror(errno));
+ zlog_err("%s: Can't switch to VRF %u (%s)", __func__, vrf_id,
+ safe_strerror(errno));
ret = getaddrinfo(node, service, hints, res);
save_errno = errno;
ret2 = vrf_switchback_to_initial();
if (ret2 < 0)
- zlog_err("%s: Can't switchback from VRF %u (%s)",
- __func__, vrf_id, safe_strerror(errno));
+ zlog_err("%s: Can't switchback from VRF %u (%s)", __func__,
+ vrf_id, safe_strerror(errno));
errno = save_errno;
return ret;
}
ret = vrf_switch_to_netns(vrf_id);
if (ret < 0) {
- zlog_err("%s: Can't switch to VRF %u (%s)",
- __func__, vrf_id, safe_strerror(errno));
+ zlog_err("%s: Can't switch to VRF %u (%s)", __func__, vrf_id,
+ safe_strerror(errno));
return 0;
}
rc = ioctl(d, request, params);
saved_errno = errno;
ret = vrf_switchback_to_initial();
if (ret < 0)
- zlog_err("%s: Can't switchback from VRF %u (%s)",
- __func__, vrf_id, safe_strerror(errno));
+ zlog_err("%s: Can't switchback from VRF %u (%s)", __func__,
+ vrf_id, safe_strerror(errno));
errno = saved_errno;
return rc;
}
ret = vrf_switch_to_netns(vrf_id);
if (ret < 0)
- zlog_err("%s: Can't switch to VRF %u (%s)",
- __func__, vrf_id, safe_strerror(errno));
+ zlog_err("%s: Can't switch to VRF %u (%s)", __func__, vrf_id,
+ safe_strerror(errno));
ret = sockunion_socket(su);
save_errno = errno;
ret2 = vrf_switchback_to_initial();
if (ret2 < 0)
- zlog_err("%s: Can't switchback from VRF %u (%s)",
- __func__, vrf_id, safe_strerror(errno));
+ zlog_err("%s: Can't switchback from VRF %u (%s)", __func__,
+ vrf_id, safe_strerror(errno));
errno = save_errno;
if (ret <= 0)
*/
/* Create a socket serving for the given VRF */
-extern int vrf_socket(int domain, int type,
- int protocol, vrf_id_t vrf_id,
+extern int vrf_socket(int domain, int type, int protocol, vrf_id_t vrf_id,
char *name);
-extern int vrf_sockunion_socket(const union sockunion *su,
- vrf_id_t vrf_id, char *name);
+extern int vrf_sockunion_socket(const union sockunion *su, vrf_id_t vrf_id,
+ char *name);
extern int vrf_bind(vrf_id_t vrf_id, int fd, char *name);
/* VRF ioctl operations */
extern int vrf_getaddrinfo(const char *node, const char *service,
- const struct addrinfo *hints,
- struct addrinfo **res, vrf_id_t vrf_id);
+ const struct addrinfo *hints, struct addrinfo **res,
+ vrf_id_t vrf_id);
extern int vrf_ioctl(vrf_id_t vrf_id, int d, unsigned long request, char *args);
/* API to create a VRF. either from vty
* or through discovery
*/
-extern int vrf_handler_create(struct vty *vty,
- const char *name,
+extern int vrf_handler_create(struct vty *vty, const char *name,
struct vrf **vrf);
/* API to associate a VRF with a NETNS.
* should be called from zebra only
*/
extern int vrf_netns_handler_create(struct vty *vty, struct vrf *vrf,
- char *pathname, ns_id_t ns_id);
+ char *pathname, ns_id_t ns_id);
/* used internally to enable or disable VRF.
* Notify a change in the VRF ID of the VRF
message = "Command returned Incomplete";
break;
case CMD_ERR_EXEED_ARGC_MAX:
- message = "Command exceeded maximum number of Arguments";
+ message =
+ "Command exceeded maximum number of Arguments";
break;
default:
message = "Command returned unhandled error message";
nl = strchr(vty->error_buf, '\n');
if (nl)
*nl = '\0';
- zlog_err("ERROR: %s on config line %u: %s",
- message, line_num, vty->error_buf);
+ zlog_err("ERROR: %s on config line %u: %s", message, line_num,
+ vty->error_buf);
}
vty_close(vty);
if (config_file != NULL) {
if (!IS_DIRECTORY_SEP(config_file[0])) {
if (getcwd(cwd, MAXPATHLEN) == NULL) {
- zlog_err("Failure to determine Current Working Directory %d!",
+ zlog_err(
+ "Failure to determine Current Working Directory %d!",
errno);
exit(1);
}
if (confp == NULL) {
zlog_err("%s: failed to open configuration file %s: %s",
- __func__, fullpath, safe_strerror(errno));
+ __func__, fullpath, safe_strerror(errno));
confp = vty_use_backup_config(fullpath);
if (confp)
- zlog_warn("WARNING: using backup configuration file!");
+ zlog_warn(
+ "WARNING: using backup configuration file!");
else {
zlog_err("can't open configuration file [%s]",
- config_file);
+ config_file);
exit(1);
}
}
confp = fopen(config_default_dir, "r");
if (confp == NULL) {
zlog_err("%s: failed to open configuration file %s: %s",
- __func__, config_default_dir,
- safe_strerror(errno));
+ __func__, config_default_dir,
+ safe_strerror(errno));
confp = vty_use_backup_config(config_default_dir);
if (confp) {
- zlog_warn("WARNING: using backup configuration file!");
+ zlog_warn(
+ "WARNING: using backup configuration file!");
fullpath = config_default_dir;
} else {
zlog_err("can't open configuration file [%s]",
- config_default_dir);
+ config_default_dir);
goto tmp_free_and_out;
}
} else
*/
if (!chdir(SYSCONFDIR)) {
zlog_err("Failure to chdir to %s, errno: %d",
- SYSCONFDIR, errno);
+ SYSCONFDIR, errno);
exit(-1);
}
if (getcwd(cwd, MAXPATHLEN) == NULL) {
- zlog_err("Failure to getcwd, errno: %d",
- errno);
+ zlog_err("Failure to getcwd, errno: %d", errno);
exit(-1);
}
}
struct structname *ptr = VTY_GET_CONTEXT_SUB(structname); \
VTY_CHECK_CONTEXT(ptr);
#define VTY_DECLVAR_INSTANCE_CONTEXT(structname, ptr) \
- if (vty->qobj_index == 0) \
- return CMD_NOT_MY_INSTANCE; \
+ if (vty->qobj_index == 0) \
+ return CMD_NOT_MY_INSTANCE; \
struct structname *ptr = VTY_GET_CONTEXT(structname); \
VTY_CHECK_CONTEXT(ptr);
static int work_queue_schedule(struct work_queue *wq, unsigned int delay)
{
/* if appropriate, schedule work queue thread */
- if (CHECK_FLAG(wq->flags, WQ_UNPLUGGED) && (wq->thread == NULL) &&
- !work_queue_empty(wq)) {
+ if (CHECK_FLAG(wq->flags, WQ_UNPLUGGED) && (wq->thread == NULL)
+ && !work_queue_empty(wq)) {
wq->thread = NULL;
thread_add_timer_msec(wq->master, work_queue_run, wq, delay,
&wq->thread);
return;
}
-static void work_queue_item_requeue(struct work_queue *wq, struct work_queue_item *item)
+static void work_queue_item_requeue(struct work_queue *wq,
+ struct work_queue_item *item)
{
work_queue_item_dequeue(wq, item);
} spec;
/* remaining fields should be opaque to users */
- STAILQ_HEAD(work_queue_items, work_queue_item) items; /* queue item list */
- int item_count; /* queued items */
+ STAILQ_HEAD(work_queue_items, work_queue_item)
+ items; /* queue item list */
+ int item_count; /* queued items */
unsigned long runs; /* runs count */
unsigned long yields; /* yields count */
return (wq->item_count == 0) ? true : false;
}
-static inline struct work_queue_item *work_queue_last_item(struct work_queue *wq)
+static inline struct work_queue_item *
+work_queue_last_item(struct work_queue *wq)
{
return STAILQ_LAST(&wq->items, work_queue_item, wq);
}
/* This file local debug flag. */
int zclient_debug = 0;
-struct zclient_options zclient_options_default = { .receive_notify = false };
+struct zclient_options zclient_options_default = {.receive_notify = false};
/* Allocate zclient structure. */
struct zclient *zclient_new_notify(struct thread_master *master,
&zclient->mi_redist[afi][zclient->redist_default],
zclient->instance);
- zclient_init(zclient, zclient->redist_default,
- zclient->instance, zclient->privs);
+ zclient_init(zclient, zclient->redist_default, zclient->instance,
+ zclient->privs);
}
/**
zclient->privs->change(ZPRIVS_LOWER);
/* Connect to zebra. */
- ret = connect(sock, (struct sockaddr *)&zclient_addr,
- zclient_addr_len);
+ ret = connect(sock, (struct sockaddr *)&zclient_addr, zclient_addr_len);
if (ret < 0) {
if (zclient_debug)
zlog_warn("%s connect failure: %d(%s)",
for (ALL_LIST_ELEMENTS_RO(
zclient->mi_redist[afi][i]
- .instances, node, id))
+ .instances,
+ node, id))
if (!(i == zclient->redist_default
&& *id == zclient->instance))
zebra_redistribute_send(
ZEBRA_REDISTRIBUTE_ADD,
- zclient, afi, i,
- *id,
+ zclient, afi, i, *id,
VRF_DEFAULT);
}
}
for (ALL_LIST_ELEMENTS_RO(
zclient->mi_redist[afi][i]
- .instances, node, id))
+ .instances,
+ node, id))
if (!(i == zclient->redist_default
&& *id == zclient->instance))
zebra_redistribute_send(
ZEBRA_REDISTRIBUTE_DELETE,
- zclient, afi, i,
- *id,
+ zclient, afi, i, *id,
VRF_DEFAULT);
}
}
/* Initialize zebra client. Argument redist_default is unwanted
redistribute route type. */
-void zclient_init(struct zclient *zclient, int redist_default,
- u_short instance, struct zebra_privs_t *privs)
+void zclient_init(struct zclient *zclient, int redist_default, u_short instance,
+ struct zebra_privs_t *privs)
{
int afi, i;
stream_putl(s, api_nh->ifindex);
break;
default:
- zlog_warn("%s: Specified Nexthop type %d does not exist",
- __PRETTY_FUNCTION__, api_nh->type);
+ zlog_warn(
+ "%s: Specified Nexthop type %d does not exist",
+ __PRETTY_FUNCTION__, api_nh->type);
return -1;
}
STREAM_GETC(s, api->type);
if (api->type > ZEBRA_ROUTE_MAX) {
zlog_warn("%s: Specified route type: %d is not a legal value\n",
- __PRETTY_FUNCTION__, api->type);
+ __PRETTY_FUNCTION__, api->type);
return -1;
}
switch (api->prefix.family) {
case AF_INET:
if (api->prefix.prefixlen > IPV4_MAX_PREFIXLEN) {
- zlog_warn("%s: V4 prefixlen is %d which should not be more than 32",
- __PRETTY_FUNCTION__, api->prefix.prefixlen);
+ zlog_warn(
+ "%s: V4 prefixlen is %d which should not be more than 32",
+ __PRETTY_FUNCTION__, api->prefix.prefixlen);
return -1;
}
break;
case AF_INET6:
if (api->prefix.prefixlen > IPV6_MAX_PREFIXLEN) {
- zlog_warn("%s: v6 prefixlen is %d which should not be more than 128",
- __PRETTY_FUNCTION__, api->prefix.prefixlen);
+ zlog_warn(
+ "%s: v6 prefixlen is %d which should not be more than 128",
+ __PRETTY_FUNCTION__, api->prefix.prefixlen);
return -1;
}
break;
api->src_prefix.family = AF_INET6;
STREAM_GETC(s, api->src_prefix.prefixlen);
if (api->src_prefix.prefixlen > IPV6_MAX_PREFIXLEN) {
- zlog_warn("%s: SRC Prefix prefixlen received: %d is too large",
- __PRETTY_FUNCTION__,
- api->src_prefix.prefixlen);
+ zlog_warn(
+ "%s: SRC Prefix prefixlen received: %d is too large",
+ __PRETTY_FUNCTION__, api->src_prefix.prefixlen);
return -1;
}
STREAM_GET(&api->src_prefix.prefix, s,
if (api->prefix.family != AF_INET6
|| api->src_prefix.prefixlen == 0) {
- zlog_warn("%s: SRC prefix specified in some manner that makes no sense",
- __PRETTY_FUNCTION__);
+ zlog_warn(
+ "%s: SRC prefix specified in some manner that makes no sense",
+ __PRETTY_FUNCTION__);
return -1;
}
}
STREAM_GETL(s, api_nh->ifindex);
break;
default:
- zlog_warn("%s: Specified nexthop type %d does not exist",
- __PRETTY_FUNCTION__,
- api_nh->type);
+ zlog_warn(
+ "%s: Specified nexthop type %d does not exist",
+ __PRETTY_FUNCTION__, api_nh->type);
return -1;
}
STREAM_GETC(s, p->family);
STREAM_GETC(s, p->prefixlen);
- STREAM_GET(&p->u.prefix, s,
- prefix_blen(p));
+ STREAM_GET(&p->u.prefix, s, prefix_blen(p));
STREAM_GETL(s, t);
*tableid = t;
STREAM_GETW(s, nhr->prefix.family);
STREAM_GETC(s, nhr->prefix.prefixlen);
- switch(nhr->prefix.family) {
+ switch (nhr->prefix.family) {
case AF_INET:
STREAM_GET(&nhr->prefix.u.prefix4.s_addr, s, IPV4_MAX_BYTELEN);
break;
STREAM_GETL(s, nhr->metric);
STREAM_GETC(s, nhr->nexthop_num);
- for (i = 0; i < nhr->nexthop_num ; i++) {
+ for (i = 0; i < nhr->nexthop_num; i++) {
STREAM_GETC(s, nhr->nexthops[i].type);
switch (nhr->nexthops[i].type) {
case NEXTHOP_TYPE_IPV4:
case NEXTHOP_TYPE_IPV4_IFINDEX:
- STREAM_GET(&nhr->nexthops[i].gate.ipv4.s_addr,
- s, IPV4_MAX_BYTELEN);
+ STREAM_GET(&nhr->nexthops[i].gate.ipv4.s_addr, s,
+ IPV4_MAX_BYTELEN);
STREAM_GETL(s, nhr->nexthops[i].ifindex);
break;
case NEXTHOP_TYPE_IFINDEX:
break;
case NEXTHOP_TYPE_IPV6:
case NEXTHOP_TYPE_IPV6_IFINDEX:
- STREAM_GET(&nhr->nexthops[i].gate.ipv6,
- s, IPV6_MAX_BYTELEN);
+ STREAM_GET(&nhr->nexthops[i].gate.ipv6, s,
+ IPV6_MAX_BYTELEN);
STREAM_GETL(s, nhr->nexthops[i].ifindex);
break;
case NEXTHOP_TYPE_BLACKHOLE:
extern struct zclient *zclient_new_notify(struct thread_master *m,
struct zclient_options *opt);
-#define zclient_new(A) zclient_new_notify((A), &zclient_options_default); \
+#define zclient_new(A) \
+ zclient_new_notify((A), &zclient_options_default); \
CPP_WARN("Please transition to using zclient_new_notify");
-extern void zclient_init(struct zclient *, int, u_short, struct zebra_privs_t *privs);
+extern void zclient_init(struct zclient *, int, u_short,
+ struct zebra_privs_t *privs);
extern int zclient_start(struct zclient *);
extern void zclient_stop(struct zclient *);
extern void zclient_reset(struct zclient *);
extern void zebra_router_id_update_read(struct stream *s, struct prefix *rid);
#if CONFDATE > 20180823
-CPP_NOTICE("zapi_ipv4_route, zapi_ipv6_route, zapi_ipv4_route_ipv6_nexthop as well as the zapi_ipv4 and zapi_ipv6 data structures should be removed now");
+CPP_NOTICE(
+ "zapi_ipv4_route, zapi_ipv6_route, zapi_ipv4_route_ipv6_nexthop as well as the zapi_ipv4 and zapi_ipv6 data structures should be removed now");
#endif
extern int zapi_ipv4_route(u_char, struct zclient *, struct prefix_ipv4 *,
#endif
#ifndef HAVE_LIBCRYPT
-# ifdef HAVE_LIBCRYPTO
-# include <openssl/des.h>
+#ifdef HAVE_LIBCRYPTO
+#include <openssl/des.h>
# define crypt DES_crypt
-# endif
+#endif
#endif
#include "openbsd-tree.h"
#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
-#define debugf(level, ...) \
- do { \
- if (unlikely(debug_flags & level)) \
- zlog_debug(__VA_ARGS__); \
- } while(0)
+#define debugf(level, ...) \
+ do { \
+ if (unlikely(debug_flags & level)) \
+ zlog_debug(__VA_ARGS__); \
+ } while (0)
#elif defined __GNUC__
-#define debugf(level, _args...) \
- do { \
- if (unlikely(debug_flags & level)) \
- zlog_debug(_args); \
- } while(0)
+#define debugf(level, _args...) \
+ do { \
+ if (unlikely(debug_flags & level)) \
+ zlog_debug(_args); \
+ } while (0)
#else
-static inline void debugf(int level, const char *format, ...) { }
+static inline void debugf(int level, const char *format, ...)
+{
+}
#endif
-
int os_socket(void)
{
if (nhrp_socket_fd < 0)
- nhrp_socket_fd = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_NHRP));
+ nhrp_socket_fd =
+ socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_NHRP));
return nhrp_socket_fd;
}
-int os_sendmsg(const uint8_t *buf, size_t len, int ifindex, const uint8_t *addr, size_t addrlen)
+int os_sendmsg(const uint8_t *buf, size_t len, int ifindex, const uint8_t *addr,
+ size_t addrlen)
{
struct sockaddr_ll lladdr;
struct iovec iov = {
- .iov_base = (void*) buf,
- .iov_len = len,
+ .iov_base = (void *)buf, .iov_len = len,
};
struct msghdr msg = {
.msg_name = &lladdr,
return 0;
}
-int os_recvmsg(uint8_t *buf, size_t *len, int *ifindex, uint8_t *addr, size_t *addrlen)
+int os_recvmsg(uint8_t *buf, size_t *len, int *ifindex, uint8_t *addr,
+ size_t *addrlen)
{
struct sockaddr_ll lladdr;
struct iovec iov = {
- .iov_base = buf,
- .iov_len = *len,
+ .iov_base = buf, .iov_len = *len,
};
struct msghdr msg = {
.msg_name = &lladdr,
*len = r;
*ifindex = lladdr.sll_ifindex;
- if (*addrlen <= (size_t) lladdr.sll_addr) {
+ if (*addrlen <= (size_t)lladdr.sll_addr) {
if (memcmp(lladdr.sll_addr, "\x00\x00\x00\x00", 4) != 0) {
memcpy(addr, lladdr.sll_addr, lladdr.sll_halen);
*addrlen = lladdr.sll_halen;
#endif
#ifndef container_of
-#define container_of(ptr, type, member) ({ \
- const typeof( ((type *)0)->member ) *__mptr = (ptr); \
- (type *)( (char *)__mptr - offsetof(type,member) );})
+#define container_of(ptr, type, member) \
+ ({ \
+ const typeof(((type *)0)->member) *__mptr = (ptr); \
+ (type *)((char *)__mptr - offsetof(type, member)); \
+ })
#endif
struct hlist_head {
h->first = n;
}
-static inline void hlist_add_after(struct hlist_node *n, struct hlist_node *prev)
+static inline void hlist_add_after(struct hlist_node *n,
+ struct hlist_node *prev)
{
n->next = prev->next;
n->pprev = &prev->next;
#define hlist_entry(ptr, type, member) container_of(ptr,type,member)
-#define hlist_for_each(pos, head) \
+#define hlist_for_each(pos, head) \
for (pos = (head)->first; pos; pos = pos->next)
-#define hlist_for_each_safe(pos, n, head) \
- for (pos = (head)->first; pos && ({ n = pos->next; 1; }); pos = n)
+#define hlist_for_each_safe(pos, n, head) \
+ for (pos = (head)->first; pos && ({ \
+ n = pos->next; \
+ 1; \
+ }); \
+ pos = n)
-#define hlist_for_each_entry(tpos, pos, head, member) \
- for (pos = (head)->first; pos && \
- ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+#define hlist_for_each_entry(tpos, pos, head, member) \
+ for (pos = (head)->first; \
+ pos && ({ \
+ tpos = hlist_entry(pos, typeof(*tpos), member); \
+ 1; \
+ }); \
pos = pos->next)
-#define hlist_for_each_entry_safe(tpos, pos, n, head, member) \
- for (pos = (head)->first; \
- pos && ({ n = pos->next; 1; }) && \
- ({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+#define hlist_for_each_entry_safe(tpos, pos, n, head, member) \
+ for (pos = (head)->first; \
+ pos && ({ \
+ n = pos->next; \
+ 1; \
+ }) \
+ && ({ \
+ tpos = hlist_entry(pos, typeof(*tpos), member); \
+ 1; \
+ }); \
pos = n)
list->prev = list;
}
-static inline void __list_add(struct list_head *new,
- struct list_head *prev,
+static inline void __list_add(struct list_head *new, struct list_head *prev,
struct list_head *next)
{
next->prev = new;
__list_add(new, head->prev, head);
}
-static inline void __list_del(struct list_head * prev, struct list_head * next)
+static inline void __list_del(struct list_head *prev, struct list_head *next)
{
next->prev = prev;
prev->next = next;
return !list_hashed(n);
}
-#define list_next(ptr, type, member) \
- (list_hashed(ptr) ? container_of((ptr)->next,type,member) : NULL)
+#define list_next(ptr, type, member) \
+ (list_hashed(ptr) ? container_of((ptr)->next, type, member) : NULL)
#define list_entry(ptr, type, member) container_of(ptr,type,member)
-#define list_for_each(pos, head) \
+#define list_for_each(pos, head) \
for (pos = (head)->next; pos != (head); pos = pos->next)
-#define list_for_each_safe(pos, n, head) \
- for (pos = (head)->next, n = pos->next; pos != (head); \
- pos = n, n = pos->next)
+#define list_for_each_safe(pos, n, head) \
+ for (pos = (head)->next, n = pos->next; pos != (head); \
+ pos = n, n = pos->next)
-#define list_for_each_entry(pos, head, member) \
- for (pos = list_entry((head)->next, typeof(*pos), member); \
- &pos->member != (head); \
+#define list_for_each_entry(pos, head, member) \
+ for (pos = list_entry((head)->next, typeof(*pos), member); \
+ &pos->member != (head); \
pos = list_entry(pos->member.next, typeof(*pos), member))
-#define list_for_each_entry_safe(pos, n, head, member) \
- for (pos = list_entry((head)->next, typeof(*pos), member), \
- n = list_entry(pos->member.next, typeof(*pos), member); \
- &pos->member != (head); \
+#define list_for_each_entry_safe(pos, n, head, member) \
+ for (pos = list_entry((head)->next, typeof(*pos), member), \
+ n = list_entry(pos->member.next, typeof(*pos), member); \
+ &pos->member != (head); \
pos = n, n = list_entry(n->member.next, typeof(*n), member))
#endif
void netlink_init(void);
int netlink_configure_arp(unsigned int ifindex, int pf);
-void netlink_update_binding(struct interface *ifp, union sockunion *proto, union sockunion *nbma);
+void netlink_update_binding(struct interface *ifp, union sockunion *proto,
+ union sockunion *nbma);
void netlink_set_nflog_group(int nlgroup);
-void netlink_gre_get_info(unsigned int ifindex, uint32_t *gre_key, unsigned int *link_index, struct in_addr *saddr);
+void netlink_gre_get_info(unsigned int ifindex, uint32_t *gre_key,
+ unsigned int *link_index, struct in_addr *saddr);
void netlink_gre_set_link(unsigned int ifindex, unsigned int link_index);
typedef void (*netlink_dispatch_f)(struct nlmsghdr *msg, struct zbuf *zb);
-void netlink_update_binding(struct interface *ifp, union sockunion *proto, union sockunion *nbma)
+void netlink_update_binding(struct interface *ifp, union sockunion *proto,
+ union sockunion *nbma)
{
struct nlmsghdr *n;
struct ndmsg *ndm;
struct zbuf *zb = zbuf_alloc(512);
- n = znl_nlmsg_push(zb, nbma ? RTM_NEWNEIGH : RTM_DELNEIGH, NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE);
+ n = znl_nlmsg_push(zb, nbma ? RTM_NEWNEIGH : RTM_DELNEIGH,
+ NLM_F_REQUEST | NLM_F_REPLACE | NLM_F_CREATE);
ndm = znl_push(zb, sizeof(*ndm));
- *ndm = (struct ndmsg) {
+ *ndm = (struct ndmsg){
.ndm_family = sockunion_family(proto),
.ndm_ifindex = ifp->ifindex,
.ndm_type = RTN_UNICAST,
.ndm_state = nbma ? NUD_REACHABLE : NUD_FAILED,
};
- znl_rta_push(zb, NDA_DST, sockunion_get_addr(proto), family2addrsize(sockunion_family(proto)));
+ znl_rta_push(zb, NDA_DST, sockunion_get_addr(proto),
+ family2addrsize(sockunion_family(proto)));
if (nbma)
- znl_rta_push(zb, NDA_LLADDR, sockunion_get_addr(nbma), family2addrsize(sockunion_family(nbma)));
+ znl_rta_push(zb, NDA_LLADDR, sockunion_get_addr(nbma),
+ family2addrsize(sockunion_family(nbma)));
znl_nlmsg_complete(zb, n);
zbuf_send(zb, netlink_req_fd);
zbuf_recv(zb, netlink_req_fd);
int state;
ndm = znl_pull(zb, sizeof(*ndm));
- if (!ndm) return;
+ if (!ndm)
+ return;
sockunion_family(&addr) = AF_UNSPEC;
while ((rta = znl_rta_pull(zb, &payload)) != NULL) {
len = zbuf_used(&payload);
switch (rta->rta_type) {
case NDA_DST:
- sockunion_set(&addr, ndm->ndm_family, zbuf_pulln(&payload, len), len);
+ sockunion_set(&addr, ndm->ndm_family,
+ zbuf_pulln(&payload, len), len);
break;
}
}
if (msg->nlmsg_type == RTM_GETNEIGH) {
debugf(NHRP_DEBUG_KERNEL, "Netlink: who-has %s dev %s",
- sockunion2str(&addr, buf, sizeof buf),
- ifp->name);
+ sockunion2str(&addr, buf, sizeof buf), ifp->name);
if (c->cur.type >= NHRP_CACHE_CACHED) {
nhrp_cache_set_used(c, 1);
- netlink_update_binding(ifp, &addr, &c->cur.peer->vc->remote.nbma);
+ netlink_update_binding(ifp, &addr,
+ &c->cur.peer->vc->remote.nbma);
}
} else {
debugf(NHRP_DEBUG_KERNEL, "Netlink: update %s dev %s nud %x",
- sockunion2str(&addr, buf, sizeof buf),
- ifp->name, ndm->ndm_state);
+ sockunion2str(&addr, buf, sizeof buf), ifp->name,
+ ndm->ndm_state);
- state = (msg->nlmsg_type == RTM_NEWNEIGH) ? ndm->ndm_state : NUD_FAILED;
+ state = (msg->nlmsg_type == RTM_NEWNEIGH) ? ndm->ndm_state
+ : NUD_FAILED;
nhrp_cache_set_used(c, state == NUD_REACHABLE);
}
}
zbuf_init(&zb, buf, sizeof(buf), 0);
while (zbuf_recv(&zb, fd) > 0) {
while ((n = znl_nlmsg_pull(&zb, &payload)) != 0) {
- debugf(NHRP_DEBUG_KERNEL, "Netlink: Received msg_type %u, msg_flags %u",
- n->nlmsg_type, n->nlmsg_flags);
+ debugf(NHRP_DEBUG_KERNEL,
+ "Netlink: Received msg_type %u, msg_flags %u",
+ n->nlmsg_type, n->nlmsg_flags);
switch (n->nlmsg_type) {
case RTM_GETNEIGH:
case RTM_NEWNEIGH:
struct nfulnl_msg_config_cmd cmd;
struct zbuf *zb = zbuf_alloc(512);
- n = znl_nlmsg_push(zb, (NFNL_SUBSYS_ULOG<<8) | NFULNL_MSG_CONFIG, NLM_F_REQUEST | NLM_F_ACK);
+ n = znl_nlmsg_push(zb, (NFNL_SUBSYS_ULOG << 8) | NFULNL_MSG_CONFIG,
+ NLM_F_REQUEST | NLM_F_ACK);
nf = znl_push(zb, sizeof(*nf));
- *nf = (struct nfgenmsg) {
+ *nf = (struct nfgenmsg){
.nfgen_family = AF_UNSPEC,
.version = NFNETLINK_V0,
.res_id = htons(group),
uint32_t *in_ndx = NULL;
nf = znl_pull(zb, sizeof(*nf));
- if (!nf) return;
+ if (!nf)
+ return;
memset(&pktpl, 0, sizeof(pktpl));
while ((rta = znl_rta_pull(zb, &rtapl)) != NULL) {
case NFULA_PAYLOAD:
pktpl = rtapl;
break;
- /* NFULA_HWHDR exists and is supposed to contain source
- * hardware address. However, for ip_gre it seems to be
- * the nexthop destination address if the packet matches
- * route. */
+ /* NFULA_HWHDR exists and is supposed to contain source
+ * hardware address. However, for ip_gre it seems to be
+ * the nexthop destination address if the packet matches
+ * route. */
}
}
zbuf_init(&zb, buf, sizeof(buf), 0);
while (zbuf_recv(&zb, fd) > 0) {
while ((n = znl_nlmsg_pull(&zb, &payload)) != 0) {
- debugf(NHRP_DEBUG_KERNEL, "Netlink-log: Received msg_type %u, msg_flags %u",
- n->nlmsg_type, n->nlmsg_flags);
+ debugf(NHRP_DEBUG_KERNEL,
+ "Netlink-log: Received msg_type %u, msg_flags %u",
+ n->nlmsg_type, n->nlmsg_flags);
switch (n->nlmsg_type) {
- case (NFNL_SUBSYS_ULOG<<8) | NFULNL_MSG_PACKET:
+ case (NFNL_SUBSYS_ULOG << 8) | NFULNL_MSG_PACKET:
netlink_log_indication(n, &payload);
break;
}
}
netlink_nflog_group = nlgroup;
if (nlgroup) {
- netlink_log_fd = znl_open(NETLINK_NETFILTER, 0);
+ netlink_log_fd = znl_open(NETLINK_NETFILTER, 0);
if (netlink_log_fd < 0)
return;
if (netlink_listen_fd < 0)
return;
- thread_add_read(master, netlink_route_recv, 0, netlink_listen_fd,
- NULL);
+ thread_add_read(master, netlink_route_recv, 0, netlink_listen_fd, NULL);
}
int netlink_configure_arp(unsigned int ifindex, int pf)
n = znl_nlmsg_push(zb, RTM_SETNEIGHTBL, NLM_F_REQUEST | NLM_F_REPLACE);
ndtm = znl_push(zb, sizeof(*ndtm));
- *ndtm = (struct ndtmsg) {
+ *ndtm = (struct ndtmsg){
.ndtm_family = pf,
};
- znl_rta_push(zb, NDTA_NAME, pf == AF_INET ? "arp_cache" : "ndisc_cache", 10);
+ znl_rta_push(zb, NDTA_NAME, pf == AF_INET ? "arp_cache" : "ndisc_cache",
+ 10);
rta = znl_rta_nested_push(zb, NDTA_PARMS);
znl_rta_push_u32(zb, NDTPA_IFINDEX, ifindex);
#include "netlink.h"
#include "znl.h"
-static int __netlink_gre_get_data(struct zbuf *zb, struct zbuf *data, int ifindex)
+static int __netlink_gre_get_data(struct zbuf *zb, struct zbuf *data,
+ int ifindex)
{
struct nlmsghdr *n;
struct ifinfomsg *ifi;
n = znl_nlmsg_push(zb, RTM_GETLINK, NLM_F_REQUEST);
ifi = znl_push(zb, sizeof(*ifi));
- *ifi = (struct ifinfomsg) {
+ *ifi = (struct ifinfomsg){
.ifi_index = ifindex,
};
znl_nlmsg_complete(zb, n);
- if (zbuf_send(zb, netlink_req_fd) < 0 ||
- zbuf_recv(zb, netlink_req_fd) < 0)
+ if (zbuf_send(zb, netlink_req_fd) < 0
+ || zbuf_recv(zb, netlink_req_fd) < 0)
return -1;
n = znl_nlmsg_pull(zb, &payload);
- if (!n) return -1;
+ if (!n)
+ return -1;
if (n->nlmsg_type != RTM_NEWLINK)
return -1;
if (!ifi)
return -1;
- debugf(NHRP_DEBUG_KERNEL, "netlink-link-gre: ifindex %u, receive msg_type %u, msg_flags %u",
- ifi->ifi_index, n->nlmsg_type, n->nlmsg_flags);
+ debugf(NHRP_DEBUG_KERNEL,
+ "netlink-link-gre: ifindex %u, receive msg_type %u, msg_flags %u",
+ ifi->ifi_index, n->nlmsg_type, n->nlmsg_flags);
if (ifi->ifi_index != ifindex)
return -1;
while ((rta = znl_rta_pull(&payload, &rtapayload)) != NULL)
if (rta->rta_type == IFLA_LINKINFO)
break;
- if (!rta) return -1;
+ if (!rta)
+ return -1;
payload = rtapayload;
while ((rta = znl_rta_pull(&payload, &rtapayload)) != NULL)
if (rta->rta_type == IFLA_INFO_DATA)
break;
- if (!rta) return -1;
+ if (!rta)
+ return -1;
*data = rtapayload;
return 0;
}
-void netlink_gre_get_info(unsigned int ifindex, uint32_t *gre_key, unsigned int *link_index, struct in_addr *saddr)
+void netlink_gre_get_info(unsigned int ifindex, uint32_t *gre_key,
+ unsigned int *link_index, struct in_addr *saddr)
{
struct zbuf *zb = zbuf_alloc(8192), data, rtapl;
struct rtattr *rta;
n = znl_nlmsg_push(zb, RTM_NEWLINK, NLM_F_REQUEST);
ifi = znl_push(zb, sizeof(*ifi));
- *ifi = (struct ifinfomsg) {
+ *ifi = (struct ifinfomsg){
.ifi_index = ifindex,
};
rta_info = znl_rta_nested_push(zb, IFLA_LINKINFO);
unsigned long nhrp_cache_counts[NHRP_CACHE_NUM_TYPES];
-const char * const nhrp_cache_type_str[] = {
- [NHRP_CACHE_INVALID] = "invalid",
- [NHRP_CACHE_INCOMPLETE] = "incomplete",
- [NHRP_CACHE_NEGATIVE] = "negative",
- [NHRP_CACHE_CACHED] = "cached",
- [NHRP_CACHE_DYNAMIC] = "dynamic",
- [NHRP_CACHE_NHS] = "nhs",
- [NHRP_CACHE_STATIC] = "static",
- [NHRP_CACHE_LOCAL] = "local",
+const char *const nhrp_cache_type_str[] = {
+ [NHRP_CACHE_INVALID] = "invalid",
+ [NHRP_CACHE_INCOMPLETE] = "incomplete",
+ [NHRP_CACHE_NEGATIVE] = "negative",
+ [NHRP_CACHE_CACHED] = "cached",
+ [NHRP_CACHE_DYNAMIC] = "dynamic",
+ [NHRP_CACHE_NHS] = "nhs",
+ [NHRP_CACHE_STATIC] = "static",
+ [NHRP_CACHE_LOCAL] = "local",
};
static unsigned int nhrp_cache_protocol_key(void *peer_data)
p = XMALLOC(MTYPE_NHRP_CACHE, sizeof(struct nhrp_cache));
if (p) {
- *p = (struct nhrp_cache) {
+ *p = (struct nhrp_cache){
.cur.type = NHRP_CACHE_INVALID,
.new.type = NHRP_CACHE_INVALID,
.remote_addr = key->remote_addr,
.ifp = key->ifp,
- .notifier_list = NOTIFIER_LIST_INITIALIZER(&p->notifier_list),
+ .notifier_list =
+ NOTIFIER_LIST_INITIALIZER(&p->notifier_list),
};
nhrp_cache_counts[p->cur.type]++;
}
XFREE(MTYPE_NHRP_CACHE, c);
}
-struct nhrp_cache *nhrp_cache_get(struct interface *ifp, union sockunion *remote_addr, int create)
+struct nhrp_cache *nhrp_cache_get(struct interface *ifp,
+ union sockunion *remote_addr, int create)
{
struct nhrp_interface *nifp = ifp->info;
struct nhrp_cache key;
if (!nifp->cache_hash) {
- nifp->cache_hash = hash_create(nhrp_cache_protocol_key,
- nhrp_cache_protocol_cmp,
- "NHRP Cache");
+ nifp->cache_hash =
+ hash_create(nhrp_cache_protocol_key,
+ nhrp_cache_protocol_cmp, "NHRP Cache");
if (!nifp->cache_hash)
return NULL;
}
key.remote_addr = *remote_addr;
key.ifp = ifp;
- return hash_get(nifp->cache_hash, &key, create ? nhrp_cache_alloc : NULL);
+ return hash_get(nifp->cache_hash, &key,
+ create ? nhrp_cache_alloc : NULL);
}
static int nhrp_cache_do_free(struct thread *t)
sockunion2hostprefix(&c->remote_addr, &pfx);
if (p && nhrp_peer_check(p, 1)) {
- netlink_update_binding(p->ifp, &c->remote_addr, &p->vc->remote.nbma);
- nhrp_route_announce(1, c->cur.type, &pfx, c->ifp, NULL, c->cur.mtu);
+ netlink_update_binding(p->ifp, &c->remote_addr,
+ &p->vc->remote.nbma);
+ nhrp_route_announce(1, c->cur.type, &pfx, c->ifp, NULL,
+ c->cur.mtu);
if (c->cur.type >= NHRP_CACHE_DYNAMIC) {
nhrp_route_update_nhrp(&pfx, c->ifp);
c->nhrp_route_installed = 1;
if (c->route_installed) {
sockunion2hostprefix(&c->remote_addr, &pfx);
notifier_call(&c->notifier_list, NOTIFY_CACHE_DOWN);
- nhrp_route_announce(0, c->cur.type, &pfx, NULL, NULL, 0);
+ nhrp_route_announce(0, c->cur.type, &pfx, NULL, NULL,
+ 0);
c->route_installed = 0;
}
}
}
-static void nhrp_cache_peer_notifier(struct notifier_block *n, unsigned long cmd)
+static void nhrp_cache_peer_notifier(struct notifier_block *n,
+ unsigned long cmd)
{
- struct nhrp_cache *c = container_of(n, struct nhrp_cache, peer_notifier);
+ struct nhrp_cache *c =
+ container_of(n, struct nhrp_cache, peer_notifier);
switch (cmd) {
case NOTIFY_PEER_UP:
switch (c->cur.type) {
case NHRP_CACHE_INVALID:
if (!c->t_auth)
- thread_add_timer_msec(master, nhrp_cache_do_free, c,
- 10, &c->t_timeout);
+ thread_add_timer_msec(master, nhrp_cache_do_free, c, 10,
+ &c->t_timeout);
break;
default:
if (c->cur.expires)
struct nhrp_cache *c = container_of(r, struct nhrp_cache, eventid);
char buf[SU_ADDRSTRLEN];
- debugf(NHRP_DEBUG_COMMON, "cache: %s %s: %s",
- c->ifp->name, sockunion2str(&c->remote_addr, buf, sizeof buf),
- (const char *) arg);
+ debugf(NHRP_DEBUG_COMMON, "cache: %s %s: %s", c->ifp->name,
+ sockunion2str(&c->remote_addr, buf, sizeof buf),
+ (const char *)arg);
nhrp_reqid_free(&nhrp_event_reqid, r);
if (arg && strcmp(arg, "accept") == 0) {
if (c->cur.peer) {
- netlink_update_binding(c->cur.peer->ifp, &c->remote_addr, NULL);
+ netlink_update_binding(c->cur.peer->ifp,
+ &c->remote_addr, NULL);
nhrp_peer_notify_del(c->cur.peer, &c->peer_notifier);
nhrp_peer_unref(c->cur.peer);
}
c->cur.peer = nhrp_peer_ref(c->cur.peer);
nhrp_cache_reset_new(c);
if (c->cur.peer)
- nhrp_peer_notify_add(c->cur.peer, &c->peer_notifier, nhrp_cache_peer_notifier);
+ nhrp_peer_notify_add(c->cur.peer, &c->peer_notifier,
+ nhrp_cache_peer_notifier);
nhrp_cache_update_route(c);
notifier_call(&c->notifier_list, NOTIFY_CACHE_BINDING_CHANGE);
} else {
{
struct nhrp_cache *c = THREAD_ARG(t);
c->t_auth = NULL;
- nhrp_cache_authorize_binding(&c->eventid, (void *) "timeout");
+ nhrp_cache_authorize_binding(&c->eventid, (void *)"timeout");
return 0;
}
-static void nhrp_cache_newpeer_notifier(struct notifier_block *n, unsigned long cmd)
+static void nhrp_cache_newpeer_notifier(struct notifier_block *n,
+ unsigned long cmd)
{
- struct nhrp_cache *c = container_of(n, struct nhrp_cache, newpeer_notifier);
+ struct nhrp_cache *c =
+ container_of(n, struct nhrp_cache, newpeer_notifier);
switch (cmd) {
case NOTIFY_PEER_UP:
if (nhrp_peer_check(c->new.peer, 1)) {
- evmgr_notify("authorize-binding", c, nhrp_cache_authorize_binding);
- thread_add_timer(master, nhrp_cache_do_auth_timeout,
- c, 10, &c->t_auth);
+ evmgr_notify("authorize-binding", c,
+ nhrp_cache_authorize_binding);
+ thread_add_timer(master, nhrp_cache_do_auth_timeout, c,
+ 10, &c->t_auth);
}
break;
case NOTIFY_PEER_DOWN:
}
}
-int nhrp_cache_update_binding(struct nhrp_cache *c, enum nhrp_cache_type type, int holding_time, struct nhrp_peer *p, uint32_t mtu, union sockunion *nbma_oa)
+int nhrp_cache_update_binding(struct nhrp_cache *c, enum nhrp_cache_type type,
+ int holding_time, struct nhrp_peer *p,
+ uint32_t mtu, union sockunion *nbma_oa)
{
if (c->cur.type > type || c->new.type > type) {
nhrp_peer_unref(p);
mtu = 0;
/* Opennhrp announces nbma mtu, but we use protocol mtu.
* This heuristic tries to fix up it. */
- if (mtu > 1420) mtu = (mtu & -16) - 80;
+ if (mtu > 1420)
+ mtu = (mtu & -16) - 80;
break;
default:
mtu = 0;
nhrp_cache_reset_new(c);
if (c->cur.type == type && c->cur.peer == p && c->cur.mtu == mtu) {
- if (holding_time > 0) c->cur.expires = monotime(NULL) + holding_time;
- if (nbma_oa) c->cur.remote_nbma_natoa = *nbma_oa;
- else memset(&c->cur.remote_nbma_natoa, 0, sizeof c->cur.remote_nbma_natoa);
+ if (holding_time > 0)
+ c->cur.expires = monotime(NULL) + holding_time;
+ if (nbma_oa)
+ c->cur.remote_nbma_natoa = *nbma_oa;
+ else
+ memset(&c->cur.remote_nbma_natoa, 0,
+ sizeof c->cur.remote_nbma_natoa);
nhrp_peer_unref(p);
} else {
c->new.type = type;
c->new.peer = p;
c->new.mtu = mtu;
- if (nbma_oa) c->new.remote_nbma_natoa = *nbma_oa;
+ if (nbma_oa)
+ c->new.remote_nbma_natoa = *nbma_oa;
if (holding_time > 0)
c->new.expires = monotime(NULL) + holding_time;
else if (holding_time < 0)
nhrp_cache_reset_new(c);
- if (c->new.type == NHRP_CACHE_INVALID ||
- c->new.type >= NHRP_CACHE_STATIC ||
- c->map) {
- nhrp_cache_authorize_binding(&c->eventid, (void *) "accept");
+ if (c->new.type == NHRP_CACHE_INVALID
+ || c->new.type >= NHRP_CACHE_STATIC || c->map) {
+ nhrp_cache_authorize_binding(&c->eventid,
+ (void *)"accept");
} else {
- nhrp_peer_notify_add(c->new.peer, &c->newpeer_notifier, nhrp_cache_newpeer_notifier);
- nhrp_cache_newpeer_notifier(&c->newpeer_notifier, NOTIFY_PEER_UP);
- thread_add_timer(master, nhrp_cache_do_auth_timeout,
- c, 60, &c->t_auth);
+ nhrp_peer_notify_add(c->new.peer, &c->newpeer_notifier,
+ nhrp_cache_newpeer_notifier);
+ nhrp_cache_newpeer_notifier(&c->newpeer_notifier,
+ NOTIFY_PEER_UP);
+ thread_add_timer(master, nhrp_cache_do_auth_timeout, c,
+ 60, &c->t_auth);
}
}
nhrp_cache_update_timers(c);
ic->cb(b->data, ic->ctx);
}
-void nhrp_cache_foreach(struct interface *ifp, void (*cb)(struct nhrp_cache *, void *), void *ctx)
+void nhrp_cache_foreach(struct interface *ifp,
+ void (*cb)(struct nhrp_cache *, void *), void *ctx)
{
struct nhrp_interface *nifp = ifp->info;
struct nhrp_cache_iterator_ctx ic = {
- .cb = cb,
- .ctx = ctx,
+ .cb = cb, .ctx = ctx,
};
if (nifp->cache_hash)
hash_iterate(nifp->cache_hash, nhrp_cache_iterator, &ic);
}
-void nhrp_cache_notify_add(struct nhrp_cache *c, struct notifier_block *n, notifier_fn_t fn)
+void nhrp_cache_notify_add(struct nhrp_cache *c, struct notifier_block *n,
+ notifier_fn_t fn)
{
notifier_add(n, &c->notifier_list, fn);
}
struct zbuf ibuf;
struct zbuf_queue obuf;
int fd;
- uint8_t ibuf_data[4*1024];
+ uint8_t ibuf_data[4 * 1024];
};
static int evmgr_reconnect(struct thread *t);
while (zbuf_may_pull_until(zb, "\n", &zl)) {
len = zbuf_used(&zl) - 1;
- if (len >= sizeof(buf)-1)
+ if (len >= sizeof(buf) - 1)
continue;
memcpy(buf, zbuf_pulln(&zl, len), len);
buf[len] = 0;
if (sscanf(buf, "result=%63s", result) != 1)
continue;
}
- debugf(NHRP_DEBUG_EVENT, "evmgr: received: eventid=%d result=%s", eventid, result);
+ debugf(NHRP_DEBUG_EVENT, "evmgr: received: eventid=%d result=%s",
+ eventid, result);
if (eventid && result[0]) {
- struct nhrp_reqid *r = nhrp_reqid_lookup(&nhrp_event_reqid, eventid);
- if (r) r->cb(r, result);
+ struct nhrp_reqid *r =
+ nhrp_reqid_lookup(&nhrp_event_reqid, eventid);
+ if (r)
+ r->cb(r, result);
}
}
struct zbuf msg;
evmgr->t_read = NULL;
- if (zbuf_read(ibuf, evmgr->fd, (size_t) -1) < 0) {
+ if (zbuf_read(ibuf, evmgr->fd, (size_t)-1) < 0) {
evmgr_connection_error(evmgr);
return 0;
}
size_t i;
char *ptr;
- ptr = zbuf_pushn(zb, 2*vallen);
- if (!ptr) return;
+ ptr = zbuf_pushn(zb, 2 * vallen);
+ if (!ptr)
+ return;
for (i = 0; i < vallen; i++) {
uint8_t b = val[i];
va_start(va, fmt);
for (pos = fmt; (nxt = strchr(pos, '%')) != NULL; pos = nxt + 2) {
- zbuf_put(zb, pos, nxt-pos);
+ zbuf_put(zb, pos, nxt - pos);
switch (nxt[1]) {
case '%':
zbuf_put8(zb, '%');
break;
case 'u':
- zb->tail += snprintf((char *) zb->tail, zbuf_tailroom(zb), "%u", va_arg(va, uint32_t));
+ zb->tail +=
+ snprintf((char *)zb->tail, zbuf_tailroom(zb),
+ "%u", va_arg(va, uint32_t));
break;
case 's':
str = va_arg(va, const char *);
break;
case 'U':
su = va_arg(va, const union sockunion *);
- if (sockunion2str(su, (char *) zb->tail, zbuf_tailroom(zb)))
- zb->tail += strlen((char *) zb->tail);
+ if (sockunion2str(su, (char *)zb->tail,
+ zbuf_tailroom(zb)))
+ zb->tail += strlen((char *)zb->tail);
else
zbuf_set_werror(zb);
break;
int fd;
evmgr->t_reconnect = NULL;
- if (evmgr->fd >= 0 || !nhrp_event_socket_path) return 0;
+ if (evmgr->fd >= 0 || !nhrp_event_socket_path)
+ return 0;
fd = sock_open_unix(nhrp_event_socket_path);
if (fd < 0) {
zlog_warn("%s: failure connecting nhrp-event socket: %s",
- __PRETTY_FUNCTION__, strerror(errno));
+ __PRETTY_FUNCTION__, strerror(errno));
zbufq_reset(&evmgr->obuf);
thread_add_timer(master, evmgr_reconnect, evmgr, 10,
&evmgr->t_reconnect);
void evmgr_set_socket(const char *socket)
{
if (nhrp_event_socket_path) {
- free((char *) nhrp_event_socket_path);
+ free((char *)nhrp_event_socket_path);
nhrp_event_socket_path = NULL;
}
if (socket)
{
}
-void evmgr_notify(const char *name, struct nhrp_cache *c, void (*cb)(struct nhrp_reqid *, void *))
+void evmgr_notify(const char *name, struct nhrp_cache *c,
+ void (*cb)(struct nhrp_reqid *, void *))
{
struct event_manager *evmgr = &evmgr_connection;
struct nhrp_vc *vc;
afi_t afi = family2afi(sockunion_family(&c->remote_addr));
if (!nhrp_event_socket_path) {
- cb(&c->eventid, (void*) "accept");
+ cb(&c->eventid, (void *)"accept");
return;
}
debugf(NHRP_DEBUG_EVENT, "evmgr: sending event %s", name);
vc = c->new.peer ? c->new.peer->vc : NULL;
- zb = zbuf_alloc(1024 + (vc ? (vc->local.certlen + vc->remote.certlen) * 2 : 0));
+ zb = zbuf_alloc(
+ 1024 + (vc ? (vc->local.certlen + vc->remote.certlen) * 2 : 0));
if (cb) {
nhrp_reqid_free(&nhrp_event_reqid, &c->eventid);
- evmgr_put(zb,
- "eventid=%u\n",
- nhrp_reqid_alloc(&nhrp_event_reqid, &c->eventid, cb));
+ evmgr_put(zb, "eventid=%u\n",
+ nhrp_reqid_alloc(&nhrp_event_reqid, &c->eventid, cb));
}
evmgr_put(zb,
- "event=%s\n"
- "type=%s\n"
- "old_type=%s\n"
- "num_nhs=%u\n"
- "interface=%s\n"
- "local_addr=%U\n",
- name,
- nhrp_cache_type_str[c->new.type],
- nhrp_cache_type_str[c->cur.type],
- (unsigned int) nhrp_cache_counts[NHRP_CACHE_NHS],
- c->ifp->name,
- &nifp->afi[afi].addr);
+ "event=%s\n"
+ "type=%s\n"
+ "old_type=%s\n"
+ "num_nhs=%u\n"
+ "interface=%s\n"
+ "local_addr=%U\n",
+ name, nhrp_cache_type_str[c->new.type],
+ nhrp_cache_type_str[c->cur.type],
+ (unsigned int)nhrp_cache_counts[NHRP_CACHE_NHS], c->ifp->name,
+ &nifp->afi[afi].addr);
if (vc) {
evmgr_put(zb,
- "vc_initiated=%s\n"
- "local_nbma=%U\n"
- "local_cert=%H\n"
- "remote_addr=%U\n"
- "remote_nbma=%U\n"
- "remote_cert=%H\n",
- c->new.peer->requested ? "yes" : "no",
- &vc->local.nbma,
- vc->local.cert, vc->local.certlen,
- &c->remote_addr, &vc->remote.nbma,
- vc->remote.cert, vc->remote.certlen);
+ "vc_initiated=%s\n"
+ "local_nbma=%U\n"
+ "local_cert=%H\n"
+ "remote_addr=%U\n"
+ "remote_nbma=%U\n"
+ "remote_cert=%H\n",
+ c->new.peer->requested ? "yes" : "no",
+ &vc->local.nbma, vc->local.cert, vc->local.certlen,
+ &c->remote_addr, &vc->remote.nbma, vc->remote.cert,
+ vc->remote.certlen);
}
evmgr_submit(evmgr, zb);
}
-
afi_t afi;
nifp = XCALLOC(MTYPE_NHRP_IF, sizeof(struct nhrp_interface));
- if (!nifp) return 0;
+ if (!nifp)
+ return 0;
ifp->info = nifp;
nifp->ifp = ifp;
new_mtu = 0;
if (new_mtu != if_ad->mtu) {
- debugf(NHRP_DEBUG_IF, "%s: MTU changed to %d", ifp->name, new_mtu);
+ debugf(NHRP_DEBUG_IF, "%s: MTU changed to %d", ifp->name,
+ new_mtu);
if_ad->mtu = new_mtu;
- notifier_call(&nifp->notifier_list, NOTIFY_INTERFACE_MTU_CHANGED);
+ notifier_call(&nifp->notifier_list,
+ NOTIFY_INTERFACE_MTU_CHANGED);
}
}
{
struct nhrp_interface *nifp = ifp->info;
- if (!nifp->source || !nifp->nbmaifp ||
- (ifindex_t)nifp->linkidx == nifp->nbmaifp->ifindex)
+ if (!nifp->source || !nifp->nbmaifp
+ || (ifindex_t)nifp->linkidx == nifp->nbmaifp->ifindex)
return;
nifp->linkidx = nifp->nbmaifp->ifindex;
- debugf(NHRP_DEBUG_IF, "%s: bound device index changed to %d", ifp->name, nifp->linkidx);
+ debugf(NHRP_DEBUG_IF, "%s: bound device index changed to %d", ifp->name,
+ nifp->linkidx);
netlink_gre_set_link(ifp->ifindex, nifp->linkidx);
}
-static void nhrp_interface_interface_notifier(struct notifier_block *n, unsigned long cmd)
+static void nhrp_interface_interface_notifier(struct notifier_block *n,
+ unsigned long cmd)
{
- struct nhrp_interface *nifp = container_of(n, struct nhrp_interface, nbmanifp_notifier);
+ struct nhrp_interface *nifp =
+ container_of(n, struct nhrp_interface, nbmanifp_notifier);
struct interface *nbmaifp = nifp->nbmaifp;
struct nhrp_interface *nbmanifp = nbmaifp->info;
char buf[SU_ADDRSTRLEN];
case NOTIFY_INTERFACE_ADDRESS_CHANGED:
nifp->nbma = nbmanifp->afi[AFI_IP].addr;
nhrp_interface_update(nifp->ifp);
- notifier_call(&nifp->notifier_list, NOTIFY_INTERFACE_NBMA_CHANGED);
+ notifier_call(&nifp->notifier_list,
+ NOTIFY_INTERFACE_NBMA_CHANGED);
debugf(NHRP_DEBUG_IF, "%s: NBMA change: address %s",
- nifp->ifp->name,
- sockunion2str(&nifp->nbma, buf, sizeof buf));
+ nifp->ifp->name,
+ sockunion2str(&nifp->nbma, buf, sizeof buf));
break;
}
}
sockunion_family(&nbma) = AF_UNSPEC;
if (nifp->source)
- nbmaifp = if_lookup_by_name(nifp->source, VRF_DEFAULT);
+ nbmaifp = if_lookup_by_name(nifp->source, VRF_DEFAULT);
switch (ifp->ll_type) {
case ZEBRA_LLT_IPGRE: {
- struct in_addr saddr = {0};
- netlink_gre_get_info(ifp->ifindex, &nifp->grekey, &nifp->linkidx, &saddr);
- debugf(NHRP_DEBUG_IF, "%s: GRE: %x %x %x", ifp->name, nifp->grekey, nifp->linkidx, saddr.s_addr);
- if (saddr.s_addr)
- sockunion_set(&nbma, AF_INET, (u_char *) &saddr.s_addr, sizeof(saddr.s_addr));
- else if (!nbmaifp && nifp->linkidx != IFINDEX_INTERNAL)
- nbmaifp = if_lookup_by_index(nifp->linkidx, VRF_DEFAULT);
- }
- break;
+ struct in_addr saddr = {0};
+ netlink_gre_get_info(ifp->ifindex, &nifp->grekey,
+ &nifp->linkidx, &saddr);
+ debugf(NHRP_DEBUG_IF, "%s: GRE: %x %x %x", ifp->name,
+ nifp->grekey, nifp->linkidx, saddr.s_addr);
+ if (saddr.s_addr)
+ sockunion_set(&nbma, AF_INET, (u_char *)&saddr.s_addr,
+ sizeof(saddr.s_addr));
+ else if (!nbmaifp && nifp->linkidx != IFINDEX_INTERNAL)
+ nbmaifp =
+ if_lookup_by_index(nifp->linkidx, VRF_DEFAULT);
+ } break;
default:
break;
}
notifier_del(&nifp->nbmanifp_notifier);
nifp->nbmaifp = nbmaifp;
if (nbmaifp) {
- notifier_add(&nifp->nbmanifp_notifier, &nbmanifp->notifier_list, nhrp_interface_interface_notifier);
- debugf(NHRP_DEBUG_IF, "%s: bound to %s", ifp->name, nbmaifp->name);
+ notifier_add(&nifp->nbmanifp_notifier,
+ &nbmanifp->notifier_list,
+ nhrp_interface_interface_notifier);
+ debugf(NHRP_DEBUG_IF, "%s: bound to %s", ifp->name,
+ nbmaifp->name);
}
}
nifp->nbma = nbma;
nhrp_interface_update(nifp->ifp);
debugf(NHRP_DEBUG_IF, "%s: NBMA address changed", ifp->name);
- notifier_call(&nifp->notifier_list, NOTIFY_INTERFACE_NBMA_CHANGED);
+ notifier_call(&nifp->notifier_list,
+ NOTIFY_INTERFACE_NBMA_CHANGED);
}
nhrp_interface_update(ifp);
}
-static void nhrp_interface_update_address(struct interface *ifp, afi_t afi, int force)
+static void nhrp_interface_update_address(struct interface *ifp, afi_t afi,
+ int force)
{
const int family = afi2family(afi);
struct nhrp_interface *nifp = ifp->info;
best = c;
continue;
}
- if ((best->flags & ZEBRA_IFA_SECONDARY) && !(c->flags & ZEBRA_IFA_SECONDARY)) {
+ if ((best->flags & ZEBRA_IFA_SECONDARY)
+ && !(c->flags & ZEBRA_IFA_SECONDARY)) {
best = c;
continue;
}
- if (!(best->flags & ZEBRA_IFA_SECONDARY) && (c->flags & ZEBRA_IFA_SECONDARY))
+ if (!(best->flags & ZEBRA_IFA_SECONDARY)
+ && (c->flags & ZEBRA_IFA_SECONDARY))
continue;
if (best->address->prefixlen > c->address->prefixlen) {
best = c;
}
/* On NHRP interfaces a host prefix is required */
- if (best && if_ad->configured && best->address->prefixlen != 8 * prefix_blen(best->address)) {
+ if (best && if_ad->configured
+ && best->address->prefixlen != 8 * prefix_blen(best->address)) {
zlog_notice("%s: %s is not a host prefix", ifp->name,
- prefix2str(best->address, buf, sizeof buf));
+ prefix2str(best->address, buf, sizeof buf));
best = NULL;
}
if (sockunion_family(&if_ad->addr) != AF_UNSPEC) {
nc = nhrp_cache_get(ifp, &if_ad->addr, 0);
- if (nc) nhrp_cache_update_binding(nc, NHRP_CACHE_LOCAL, -1, NULL, 0, NULL);
+ if (nc)
+ nhrp_cache_update_binding(nc, NHRP_CACHE_LOCAL, -1,
+ NULL, 0, NULL);
}
- debugf(NHRP_DEBUG_KERNEL, "%s: IPv%d address changed to %s",
- ifp->name, afi == AFI_IP ? 4 : 6,
- best ? prefix2str(best->address, buf, sizeof buf) : "(none)");
+ debugf(NHRP_DEBUG_KERNEL, "%s: IPv%d address changed to %s", ifp->name,
+ afi == AFI_IP ? 4 : 6,
+ best ? prefix2str(best->address, buf, sizeof buf) : "(none)");
if_ad->addr = addr;
if (if_ad->configured && sockunion_family(&if_ad->addr) != AF_UNSPEC) {
nc = nhrp_cache_get(ifp, &addr, 1);
- if (nc) nhrp_cache_update_binding(nc, NHRP_CACHE_LOCAL, 0, NULL, 0, NULL);
+ if (nc)
+ nhrp_cache_update_binding(nc, NHRP_CACHE_LOCAL, 0, NULL,
+ 0, NULL);
}
notifier_call(&nifp->notifier_list, NOTIFY_INTERFACE_ADDRESS_CHANGED);
for (afi = 0; afi < AFI_MAX; afi++) {
if_ad = &nifp->afi[afi];
- if (sockunion_family(&nifp->nbma) == AF_UNSPEC ||
- ifp->ifindex == IFINDEX_INTERNAL || !if_is_up(ifp) ||
- !if_ad->network_id) {
+ if (sockunion_family(&nifp->nbma) == AF_UNSPEC
+ || ifp->ifindex == IFINDEX_INTERNAL || !if_is_up(ifp)
+ || !if_ad->network_id) {
if (if_ad->configured) {
if_ad->configured = 0;
nhrp_interface_update_address(ifp, afi, 1);
}
if (!if_ad->configured) {
- os_configure_dmvpn(ifp->ifindex, ifp->name, afi2family(afi));
+ os_configure_dmvpn(ifp->ifindex, ifp->name,
+ afi2family(afi));
if_ad->configured = 1;
nhrp_interface_update_address(ifp, afi, 1);
}
if (enabled != nifp->enabled) {
nifp->enabled = enabled;
- notifier_call(&nifp->notifier_list, enabled ? NOTIFY_INTERFACE_UP : NOTIFY_INTERFACE_DOWN);
+ notifier_call(&nifp->notifier_list,
+ enabled ? NOTIFY_INTERFACE_UP
+ : NOTIFY_INTERFACE_DOWN);
}
}
-int nhrp_interface_add(int cmd, struct zclient *client, zebra_size_t length, vrf_id_t vrf_id)
+int nhrp_interface_add(int cmd, struct zclient *client, zebra_size_t length,
+ vrf_id_t vrf_id)
{
struct interface *ifp;
return 0;
debugf(NHRP_DEBUG_IF, "if-add: %s, ifindex: %u, hw_type: %d %s",
- ifp->name, ifp->ifindex,
- ifp->ll_type, if_link_type_str(ifp->ll_type));
+ ifp->name, ifp->ifindex, ifp->ll_type,
+ if_link_type_str(ifp->ll_type));
nhrp_interface_update_nbma(ifp);
return 0;
}
-int nhrp_interface_delete(int cmd, struct zclient *client,
- zebra_size_t length, vrf_id_t vrf_id)
+int nhrp_interface_delete(int cmd, struct zclient *client, zebra_size_t length,
+ vrf_id_t vrf_id)
{
struct interface *ifp;
struct stream *s;
return 0;
}
-int nhrp_interface_up(int cmd, struct zclient *client,
- zebra_size_t length, vrf_id_t vrf_id)
+int nhrp_interface_up(int cmd, struct zclient *client, zebra_size_t length,
+ vrf_id_t vrf_id)
{
struct interface *ifp;
return 0;
}
-int nhrp_interface_down(int cmd, struct zclient *client,
- zebra_size_t length, vrf_id_t vrf_id)
+int nhrp_interface_down(int cmd, struct zclient *client, zebra_size_t length,
+ vrf_id_t vrf_id)
{
struct interface *ifp;
if (ifc == NULL)
return 0;
- debugf(NHRP_DEBUG_IF, "if-addr-add: %s: %s",
- ifc->ifp->name,
- prefix2str(ifc->address, buf, sizeof buf));
+ debugf(NHRP_DEBUG_IF, "if-addr-add: %s: %s", ifc->ifp->name,
+ prefix2str(ifc->address, buf, sizeof buf));
- nhrp_interface_update_address(ifc->ifp, family2afi(PREFIX_FAMILY(ifc->address)), 0);
+ nhrp_interface_update_address(
+ ifc->ifp, family2afi(PREFIX_FAMILY(ifc->address)), 0);
return 0;
}
if (ifc == NULL)
return 0;
- debugf(NHRP_DEBUG_IF, "if-addr-del: %s: %s",
- ifc->ifp->name,
- prefix2str(ifc->address, buf, sizeof buf));
+ debugf(NHRP_DEBUG_IF, "if-addr-del: %s: %s", ifc->ifp->name,
+ prefix2str(ifc->address, buf, sizeof buf));
- nhrp_interface_update_address(ifc->ifp, family2afi(PREFIX_FAMILY(ifc->address)), 0);
+ nhrp_interface_update_address(
+ ifc->ifp, family2afi(PREFIX_FAMILY(ifc->address)), 0);
connected_free(ifc);
return 0;
}
-void nhrp_interface_notify_add(struct interface *ifp, struct notifier_block *n, notifier_fn_t fn)
+void nhrp_interface_notify_add(struct interface *ifp, struct notifier_block *n,
+ notifier_fn_t fn)
{
struct nhrp_interface *nifp = ifp->info;
notifier_add(n, &nifp->notifier_list, fn);
notifier_del(n);
}
-void nhrp_interface_set_protection(struct interface *ifp, const char *profile, const char *fallback_profile)
+void nhrp_interface_set_protection(struct interface *ifp, const char *profile,
+ const char *fallback_profile)
{
struct nhrp_interface *nifp = ifp->info;
- if (nifp->ipsec_profile) free(nifp->ipsec_profile);
+ if (nifp->ipsec_profile)
+ free(nifp->ipsec_profile);
nifp->ipsec_profile = profile ? strdup(profile) : NULL;
- if (nifp->ipsec_fallback_profile) free(nifp->ipsec_fallback_profile);
- nifp->ipsec_fallback_profile = fallback_profile ? strdup(fallback_profile) : NULL;
+ if (nifp->ipsec_fallback_profile)
+ free(nifp->ipsec_fallback_profile);
+ nifp->ipsec_fallback_profile =
+ fallback_profile ? strdup(fallback_profile) : NULL;
notifier_call(&nifp->notifier_list, NOTIFY_INTERFACE_ADDRESS_CHANGED);
}
{
struct nhrp_interface *nifp = ifp->info;
- if (nifp->source) free(nifp->source);
+ if (nifp->source)
+ free(nifp->source);
nifp->source = ifname ? strdup(ifname) : NULL;
nhrp_interface_update_nbma(ifp);
struct timeval current_time;
/* nhrpd options. */
-struct option longopts[] = {
- { 0 }
-};
+struct option longopts[] = {{0}};
/* nhrpd privileges */
-static zebra_capabilities_t _caps_p [] = {
- ZCAP_NET_RAW,
- ZCAP_NET_ADMIN,
- ZCAP_DAC_OVERRIDE, /* for now needed to write to /proc/sys/net/ipv4/<if>/send_redirect */
+static zebra_capabilities_t _caps_p[] = {
+ ZCAP_NET_RAW, ZCAP_NET_ADMIN,
+ ZCAP_DAC_OVERRIDE, /* for now needed to write to
+ /proc/sys/net/ipv4/<if>/send_redirect */
};
struct zebra_privs_t nhrpd_privs = {
while (1) {
opt = frr_getopt(argc, argv, 0);
- if(opt < 0) break;
+ if (opt < 0)
+ break;
switch (opt) {
case 0:
}
static struct quagga_signal_t sighandlers[] = {
- { .signal = SIGUSR1, .handler = &nhrp_sigusr1, },
- { .signal = SIGINT, .handler = &nhrp_request_stop, },
- { .signal = SIGTERM, .handler = &nhrp_request_stop, },
+ {
+ .signal = SIGUSR1,
+ .handler = &nhrp_sigusr1,
+ },
+ {
+ .signal = SIGINT,
+ .handler = &nhrp_request_stop,
+ },
+ {
+ .signal = SIGTERM,
+ .handler = &nhrp_request_stop,
+ },
};
-FRR_DAEMON_INFO(nhrpd, NHRP,
- .vty_port = NHRP_VTY_PORT,
+FRR_DAEMON_INFO(nhrpd, NHRP, .vty_port = NHRP_VTY_PORT,
- .proghelp = "Implementation of the NHRP routing protocol.",
+ .proghelp = "Implementation of the NHRP routing protocol.",
- .signals = sighandlers,
- .n_signals = array_size(sighandlers),
+ .signals = sighandlers, .n_signals = array_size(sighandlers),
- .privs = &nhrpd_privs,
-)
+ .privs = &nhrpd_privs, )
int main(int argc, char **argv)
{
static void nhrp_reg_reply(struct nhrp_reqid *reqid, void *arg)
{
struct nhrp_packet_parser *p = arg;
- struct nhrp_registration *r = container_of(reqid, struct nhrp_registration, reqid);
+ struct nhrp_registration *r =
+ container_of(reqid, struct nhrp_registration, reqid);
struct nhrp_nhs *nhs = r->nhs;
struct interface *ifp = nhs->ifp;
struct nhrp_interface *nifp = ifp->info;
debugf(NHRP_DEBUG_COMMON, "NHS: Reg.reply received");
ok = 1;
- while ((cie = nhrp_cie_pull(&p->payload, p->hdr, &cie_nbma, &cie_proto)) != NULL) {
- proto = sockunion_family(&cie_proto) != AF_UNSPEC ? &cie_proto : &p->src_proto;
+ while ((cie = nhrp_cie_pull(&p->payload, p->hdr, &cie_nbma, &cie_proto))
+ != NULL) {
+ proto = sockunion_family(&cie_proto) != AF_UNSPEC
+ ? &cie_proto
+ : &p->src_proto;
debugf(NHRP_DEBUG_COMMON, "NHS: CIE registration: %s: %d",
- sockunion2str(proto, buf, sizeof(buf)),
- cie->code);
- if (!((cie->code == NHRP_CODE_SUCCESS) ||
- (cie->code == NHRP_CODE_ADMINISTRATIVELY_PROHIBITED && nhs->hub)))
+ sockunion2str(proto, buf, sizeof(buf)), cie->code);
+ if (!((cie->code == NHRP_CODE_SUCCESS)
+ || (cie->code == NHRP_CODE_ADMINISTRATIVELY_PROHIBITED
+ && nhs->hub)))
ok = 0;
}
switch (htons(ext->type) & ~NHRP_EXTENSION_FLAG_COMPULSORY) {
case NHRP_EXTENSION_NAT_ADDRESS:
/* NHS adds second CIE if NAT is detected */
- if (nhrp_cie_pull(&extpl, p->hdr, &cie_nbma, &cie_proto) &&
- nhrp_cie_pull(&extpl, p->hdr, &cie_nbma, &cie_proto)) {
+ if (nhrp_cie_pull(&extpl, p->hdr, &cie_nbma, &cie_proto)
+ && nhrp_cie_pull(&extpl, p->hdr, &cie_nbma,
+ &cie_proto)) {
nifp->nat_nbma = cie_nbma;
- debugf(NHRP_DEBUG_IF, "%s: NAT detected, real NBMA address: %s",
- ifp->name, sockunion2str(&nifp->nbma, buf, sizeof(buf)));
+ debugf(NHRP_DEBUG_IF,
+ "%s: NAT detected, real NBMA address: %s",
+ ifp->name,
+ sockunion2str(&nifp->nbma, buf,
+ sizeof(buf)));
}
break;
}
r->proto_addr = p->dst_proto;
c = nhrp_cache_get(ifp, &p->dst_proto, 1);
- if (c) nhrp_cache_update_binding(c, NHRP_CACHE_NHS, holdtime, nhrp_peer_ref(r->peer), 0, NULL);
+ if (c)
+ nhrp_cache_update_binding(c, NHRP_CACHE_NHS, holdtime,
+ nhrp_peer_ref(r->peer), 0, NULL);
}
static int nhrp_reg_timeout(struct thread *t)
if (r->timeout >= 16 && sockunion_family(&r->proto_addr) != AF_UNSPEC) {
nhrp_reqid_free(&nhrp_packet_reqid, &r->reqid);
c = nhrp_cache_get(r->nhs->ifp, &r->proto_addr, 0);
- if (c) nhrp_cache_update_binding(c, NHRP_CACHE_NHS, -1, NULL, 0, NULL);
+ if (c)
+ nhrp_cache_update_binding(c, NHRP_CACHE_NHS, -1, NULL,
+ 0, NULL);
sockunion_family(&r->proto_addr) = AF_UNSPEC;
}
r->timeout <<= 1;
- if (r->timeout > 64) r->timeout = 2;
- thread_add_timer_msec(master, nhrp_reg_send_req, r, 10,
- &r->t_register);
+ if (r->timeout > 64)
+ r->timeout = 2;
+ thread_add_timer_msec(master, nhrp_reg_send_req, r, 10, &r->t_register);
return 0;
}
static void nhrp_reg_peer_notify(struct notifier_block *n, unsigned long cmd)
{
- struct nhrp_registration *r = container_of(n, struct nhrp_registration, peer_notifier);
+ struct nhrp_registration *r =
+ container_of(n, struct nhrp_registration, peer_notifier);
char buf[SU_ADDRSTRLEN];
switch (cmd) {
case NOTIFY_PEER_IFCONFIG_CHANGED:
case NOTIFY_PEER_MTU_CHANGED:
debugf(NHRP_DEBUG_COMMON, "NHS: Flush timer for %s",
- sockunion2str(&r->peer->vc->remote.nbma, buf, sizeof buf));
+ sockunion2str(&r->peer->vc->remote.nbma, buf,
+ sizeof buf));
THREAD_TIMER_OFF(r->t_register);
thread_add_timer_msec(master, nhrp_reg_send_req, r, 10,
&r->t_register);
r->t_register = NULL;
if (!nhrp_peer_check(r->peer, 2)) {
debugf(NHRP_DEBUG_COMMON, "NHS: Waiting link for %s",
- sockunion2str(&r->peer->vc->remote.nbma, buf1, sizeof buf1));
+ sockunion2str(&r->peer->vc->remote.nbma, buf1,
+ sizeof buf1));
thread_add_timer(master, nhrp_reg_send_req, r, 120,
&r->t_register);
return 0;
sockunion2str(&if_ad->addr, buf1, sizeof(buf1));
sockunion2str(dst_proto, buf2, sizeof(buf2));
- debugf(NHRP_DEBUG_COMMON, "NHS: Register %s -> %s (timeout %d)", buf1, buf2, r->timeout);
+ debugf(NHRP_DEBUG_COMMON, "NHS: Register %s -> %s (timeout %d)", buf1,
+ buf2, r->timeout);
/* No protocol address configured for tunnel interface */
if (sockunion_family(&if_ad->addr) == AF_UNSPEC)
return 0;
zb = zbuf_alloc(1400);
- hdr = nhrp_packet_push(zb, NHRP_PACKET_REGISTRATION_REQUEST, &nifp->nbma, &if_ad->addr, dst_proto);
+ hdr = nhrp_packet_push(zb, NHRP_PACKET_REGISTRATION_REQUEST,
+ &nifp->nbma, &if_ad->addr, dst_proto);
hdr->hop_count = 1;
if (!(if_ad->flags & NHRP_IFF_REG_NO_UNIQUE))
hdr->flags |= htons(NHRP_FLAG_REGISTRATION_UNIQUE);
- hdr->u.request_id = htonl(nhrp_reqid_alloc(&nhrp_packet_reqid, &r->reqid, nhrp_reg_reply));
+ hdr->u.request_id = htonl(nhrp_reqid_alloc(&nhrp_packet_reqid,
+ &r->reqid, nhrp_reg_reply));
/* FIXME: push CIE for each local protocol address */
cie = nhrp_cie_push(zb, NHRP_CODE_SUCCESS, NULL, NULL);
XFREE(MTYPE_NHRP_REGISTRATION, r);
}
-static struct nhrp_registration *nhrp_reg_by_nbma(struct nhrp_nhs *nhs, const union sockunion *nbma_addr)
+static struct nhrp_registration *
+nhrp_reg_by_nbma(struct nhrp_nhs *nhs, const union sockunion *nbma_addr)
{
struct nhrp_registration *r;
- list_for_each_entry(r, &nhs->reglist_head, reglist_entry)
- if (sockunion_same(&r->peer->vc->remote.nbma, nbma_addr))
- return r;
+ list_for_each_entry(
+ r, &nhs->reglist_head,
+ reglist_entry) if (sockunion_same(&r->peer->vc->remote.nbma,
+ nbma_addr)) return r;
return NULL;
}
-static void nhrp_nhs_resolve_cb(struct resolver_query *q, int n, union sockunion *addrs)
+static void nhrp_nhs_resolve_cb(struct resolver_query *q, int n,
+ union sockunion *addrs)
{
struct nhrp_nhs *nhs = container_of(q, struct nhrp_nhs, dns_resolve);
struct nhrp_interface *nifp = nhs->ifp->info;
thread_add_timer(master, nhrp_nhs_resolve, nhs, 2 * 60 * 60,
&nhs->t_resolve);
- list_for_each_entry(reg, &nhs->reglist_head, reglist_entry)
- reg->mark = 1;
+ list_for_each_entry(reg, &nhs->reglist_head, reglist_entry) reg->mark =
+ 1;
nhs->hub = 0;
for (i = 0; i < n; i++) {
reg->timeout = 1;
list_init(®->reglist_entry);
list_add_tail(®->reglist_entry, &nhs->reglist_head);
- nhrp_peer_notify_add(reg->peer, ®->peer_notifier, nhrp_reg_peer_notify);
+ nhrp_peer_notify_add(reg->peer, ®->peer_notifier,
+ nhrp_reg_peer_notify);
thread_add_timer_msec(master, nhrp_reg_send_req, reg, 50,
®->t_register);
}
- list_for_each_entry_safe(reg, regn, &nhs->reglist_head, reglist_entry) {
+ list_for_each_entry_safe(reg, regn, &nhs->reglist_head, reglist_entry)
+ {
if (reg->mark)
nhrp_reg_delete(reg);
}
{
struct nhrp_nhs *nhs = THREAD_ARG(t);
- resolver_resolve(&nhs->dns_resolve, AF_INET, nhs->nbma_fqdn, nhrp_nhs_resolve_cb);
+ resolver_resolve(&nhs->dns_resolve, AF_INET, nhs->nbma_fqdn,
+ nhrp_nhs_resolve_cb);
return 0;
}
-int nhrp_nhs_add(struct interface *ifp, afi_t afi, union sockunion *proto_addr, const char *nbma_fqdn)
+int nhrp_nhs_add(struct interface *ifp, afi_t afi, union sockunion *proto_addr,
+ const char *nbma_fqdn)
{
struct nhrp_interface *nifp = ifp->info;
struct nhrp_nhs *nhs;
- if (sockunion_family(proto_addr) != AF_UNSPEC &&
- sockunion_family(proto_addr) != afi2family(afi))
+ if (sockunion_family(proto_addr) != AF_UNSPEC
+ && sockunion_family(proto_addr) != afi2family(afi))
return NHRP_ERR_PROTOCOL_ADDRESS_MISMATCH;
- list_for_each_entry(nhs, &nifp->afi[afi].nhslist_head, nhslist_entry) {
- if (sockunion_family(&nhs->proto_addr) != AF_UNSPEC &&
- sockunion_family(proto_addr) != AF_UNSPEC &&
- sockunion_same(&nhs->proto_addr, proto_addr))
+ list_for_each_entry(nhs, &nifp->afi[afi].nhslist_head, nhslist_entry)
+ {
+ if (sockunion_family(&nhs->proto_addr) != AF_UNSPEC
+ && sockunion_family(proto_addr) != AF_UNSPEC
+ && sockunion_same(&nhs->proto_addr, proto_addr))
return NHRP_ERR_ENTRY_EXISTS;
if (strcmp(nhs->nbma_fqdn, nbma_fqdn) == 0)
}
nhs = XMALLOC(MTYPE_NHRP_NHS, sizeof(struct nhrp_nhs));
- if (!nhs) return NHRP_ERR_NO_MEMORY;
+ if (!nhs)
+ return NHRP_ERR_NO_MEMORY;
- *nhs = (struct nhrp_nhs) {
+ *nhs = (struct nhrp_nhs){
.afi = afi,
.ifp = ifp,
.proto_addr = *proto_addr,
return NHRP_OK;
}
-int nhrp_nhs_del(struct interface *ifp, afi_t afi, union sockunion *proto_addr, const char *nbma_fqdn)
+int nhrp_nhs_del(struct interface *ifp, afi_t afi, union sockunion *proto_addr,
+ const char *nbma_fqdn)
{
struct nhrp_interface *nifp = ifp->info;
struct nhrp_nhs *nhs, *nnhs;
int ret = NHRP_ERR_ENTRY_NOT_FOUND;
- if (sockunion_family(proto_addr) != AF_UNSPEC &&
- sockunion_family(proto_addr) != afi2family(afi))
+ if (sockunion_family(proto_addr) != AF_UNSPEC
+ && sockunion_family(proto_addr) != afi2family(afi))
return NHRP_ERR_PROTOCOL_ADDRESS_MISMATCH;
- list_for_each_entry_safe(nhs, nnhs, &nifp->afi[afi].nhslist_head, nhslist_entry) {
+ list_for_each_entry_safe(nhs, nnhs, &nifp->afi[afi].nhslist_head,
+ nhslist_entry)
+ {
if (!sockunion_same(&nhs->proto_addr, proto_addr))
continue;
if (strcmp(nhs->nbma_fqdn, nbma_fqdn) != 0)
nhrp_reg_delete(r);
THREAD_OFF(nhs->t_resolve);
list_del(&nhs->nhslist_entry);
- free((void*) nhs->nbma_fqdn);
+ free((void *)nhs->nbma_fqdn);
XFREE(MTYPE_NHRP_NHS, nhs);
return 0;
}
FOR_ALL_INTERFACES (vrf, ifp) {
nifp = ifp->info;
for (afi = 0; afi < AFI_MAX; afi++) {
- list_for_each_entry_safe(nhs, tmp, &nifp->afi[afi].nhslist_head, nhslist_entry)
- nhrp_nhs_free(nhs);
+ list_for_each_entry_safe(
+ nhs, tmp, &nifp->afi[afi].nhslist_head,
+ nhslist_entry) nhrp_nhs_free(nhs);
}
}
}
-void nhrp_nhs_foreach(struct interface *ifp, afi_t afi, void (*cb)(struct nhrp_nhs *, struct nhrp_registration *, void *), void *ctx)
+void nhrp_nhs_foreach(struct interface *ifp, afi_t afi,
+ void (*cb)(struct nhrp_nhs *, struct nhrp_registration *,
+ void *),
+ void *ctx)
{
struct nhrp_interface *nifp = ifp->info;
struct nhrp_nhs *nhs;
struct nhrp_registration *reg;
- list_for_each_entry(nhs, &nifp->afi[afi].nhslist_head, nhslist_entry) {
+ list_for_each_entry(nhs, &nifp->afi[afi].nhslist_head, nhslist_entry)
+ {
if (!list_empty(&nhs->reglist_head)) {
- list_for_each_entry(reg, &nhs->reglist_head, reglist_entry)
- cb(nhs, reg, ctx);
+ list_for_each_entry(reg, &nhs->reglist_head,
+ reglist_entry) cb(nhs, reg, ctx);
} else
cb(nhs, 0, ctx);
}
static uint16_t family2proto(int family)
{
switch (family) {
- case AF_INET: return ETH_P_IP;
- case AF_INET6: return ETH_P_IPV6;
+ case AF_INET:
+ return ETH_P_IP;
+ case AF_INET6:
+ return ETH_P_IPV6;
}
return 0;
}
static int proto2family(uint16_t proto)
{
switch (proto) {
- case ETH_P_IP: return AF_INET;
- case ETH_P_IPV6: return AF_INET6;
+ case ETH_P_IP:
+ return AF_INET;
+ case ETH_P_IPV6:
+ return AF_INET6;
}
return AF_UNSPEC;
}
-struct nhrp_packet_header *nhrp_packet_push(
- struct zbuf *zb, uint8_t type,
- const union sockunion *src_nbma,
- const union sockunion *src_proto,
- const union sockunion *dst_proto)
+struct nhrp_packet_header *nhrp_packet_push(struct zbuf *zb, uint8_t type,
+ const union sockunion *src_nbma,
+ const union sockunion *src_proto,
+ const union sockunion *dst_proto)
{
struct nhrp_packet_header *hdr;
hdr = zbuf_push(zb, struct nhrp_packet_header);
- if (!hdr) return NULL;
+ if (!hdr)
+ return NULL;
- *hdr = (struct nhrp_packet_header) {
+ *hdr = (struct nhrp_packet_header){
.afnum = htons(family2afi(sockunion_family(src_nbma))),
- .protocol_type = htons(family2proto(sockunion_family(src_proto))),
+ .protocol_type =
+ htons(family2proto(sockunion_family(src_proto))),
.version = NHRP_VERSION_RFC2332,
.type = type,
.hop_count = 64,
};
zbuf_put(zb, sockunion_get_addr(src_nbma), hdr->src_nbma_address_len);
- zbuf_put(zb, sockunion_get_addr(src_proto), hdr->src_protocol_address_len);
- zbuf_put(zb, sockunion_get_addr(dst_proto), hdr->dst_protocol_address_len);
+ zbuf_put(zb, sockunion_get_addr(src_proto),
+ hdr->src_protocol_address_len);
+ zbuf_put(zb, sockunion_get_addr(dst_proto),
+ hdr->dst_protocol_address_len);
return hdr;
}
-struct nhrp_packet_header *nhrp_packet_pull(
- struct zbuf *zb,
- union sockunion *src_nbma,
- union sockunion *src_proto,
- union sockunion *dst_proto)
+struct nhrp_packet_header *nhrp_packet_pull(struct zbuf *zb,
+ union sockunion *src_nbma,
+ union sockunion *src_proto,
+ union sockunion *dst_proto)
{
struct nhrp_packet_header *hdr;
hdr = zbuf_pull(zb, struct nhrp_packet_header);
- if (!hdr) return NULL;
-
- sockunion_set(
- src_nbma, afi2family(htons(hdr->afnum)),
- zbuf_pulln(zb, hdr->src_nbma_address_len + hdr->src_nbma_subaddress_len),
- hdr->src_nbma_address_len + hdr->src_nbma_subaddress_len);
- sockunion_set(
- src_proto, proto2family(htons(hdr->protocol_type)),
- zbuf_pulln(zb, hdr->src_protocol_address_len),
- hdr->src_protocol_address_len);
- sockunion_set(
- dst_proto, proto2family(htons(hdr->protocol_type)),
- zbuf_pulln(zb, hdr->dst_protocol_address_len),
- hdr->dst_protocol_address_len);
+ if (!hdr)
+ return NULL;
+
+ sockunion_set(src_nbma, afi2family(htons(hdr->afnum)),
+ zbuf_pulln(zb,
+ hdr->src_nbma_address_len
+ + hdr->src_nbma_subaddress_len),
+ hdr->src_nbma_address_len + hdr->src_nbma_subaddress_len);
+ sockunion_set(src_proto, proto2family(htons(hdr->protocol_type)),
+ zbuf_pulln(zb, hdr->src_protocol_address_len),
+ hdr->src_protocol_address_len);
+ sockunion_set(dst_proto, proto2family(htons(hdr->protocol_type)),
+ zbuf_pulln(zb, hdr->dst_protocol_address_len),
+ hdr->dst_protocol_address_len);
return hdr;
}
uint16_t nhrp_packet_calculate_checksum(const uint8_t *pdu, uint16_t len)
{
- const uint16_t *pdu16 = (const uint16_t *) pdu;
+ const uint16_t *pdu16 = (const uint16_t *)pdu;
uint32_t csum = 0;
int i;
unsigned short size;
if (hdr->extension_offset)
- nhrp_ext_push(zb, hdr, NHRP_EXTENSION_END | NHRP_EXTENSION_FLAG_COMPULSORY);
+ nhrp_ext_push(zb, hdr,
+ NHRP_EXTENSION_END
+ | NHRP_EXTENSION_FLAG_COMPULSORY);
size = zb->tail - (uint8_t *)hdr;
hdr->packet_size = htons(size);
hdr->checksum = 0;
- hdr->checksum = nhrp_packet_calculate_checksum((uint8_t *) hdr, size);
+ hdr->checksum = nhrp_packet_calculate_checksum((uint8_t *)hdr, size);
}
-struct nhrp_cie_header *nhrp_cie_push(
- struct zbuf *zb,
- uint8_t code,
- const union sockunion *nbma,
- const union sockunion *proto)
+struct nhrp_cie_header *nhrp_cie_push(struct zbuf *zb, uint8_t code,
+ const union sockunion *nbma,
+ const union sockunion *proto)
{
struct nhrp_cie_header *cie;
cie = zbuf_push(zb, struct nhrp_cie_header);
- *cie = (struct nhrp_cie_header) {
+ *cie = (struct nhrp_cie_header){
.code = code,
};
if (nbma) {
}
if (proto) {
cie->protocol_address_len = sockunion_get_addrlen(proto);
- zbuf_put(zb, sockunion_get_addr(proto), cie->protocol_address_len);
+ zbuf_put(zb, sockunion_get_addr(proto),
+ cie->protocol_address_len);
}
return cie;
}
-struct nhrp_cie_header *nhrp_cie_pull(
- struct zbuf *zb,
- struct nhrp_packet_header *hdr,
- union sockunion *nbma,
- union sockunion *proto)
+struct nhrp_cie_header *nhrp_cie_pull(struct zbuf *zb,
+ struct nhrp_packet_header *hdr,
+ union sockunion *nbma,
+ union sockunion *proto)
{
struct nhrp_cie_header *cie;
cie = zbuf_pull(zb, struct nhrp_cie_header);
- if (!cie) return NULL;
+ if (!cie)
+ return NULL;
if (cie->nbma_address_len + cie->nbma_subaddress_len) {
- sockunion_set(
- nbma, afi2family(htons(hdr->afnum)),
- zbuf_pulln(zb, cie->nbma_address_len + cie->nbma_subaddress_len),
- cie->nbma_address_len + cie->nbma_subaddress_len);
+ sockunion_set(nbma, afi2family(htons(hdr->afnum)),
+ zbuf_pulln(zb,
+ cie->nbma_address_len
+ + cie->nbma_subaddress_len),
+ cie->nbma_address_len + cie->nbma_subaddress_len);
} else {
sockunion_family(nbma) = AF_UNSPEC;
}
if (cie->protocol_address_len) {
- sockunion_set(
- proto, proto2family(htons(hdr->protocol_type)),
- zbuf_pulln(zb, cie->protocol_address_len),
- cie->protocol_address_len);
+ sockunion_set(proto, proto2family(htons(hdr->protocol_type)),
+ zbuf_pulln(zb, cie->protocol_address_len),
+ cie->protocol_address_len);
} else {
sockunion_family(proto) = AF_UNSPEC;
}
return cie;
}
-struct nhrp_extension_header *nhrp_ext_push(struct zbuf *zb, struct nhrp_packet_header *hdr, uint16_t type)
+struct nhrp_extension_header *
+nhrp_ext_push(struct zbuf *zb, struct nhrp_packet_header *hdr, uint16_t type)
{
struct nhrp_extension_header *ext;
ext = zbuf_push(zb, struct nhrp_extension_header);
- if (!ext) return NULL;
+ if (!ext)
+ return NULL;
if (!hdr->extension_offset)
- hdr->extension_offset = htons(zb->tail - (uint8_t*) hdr - sizeof(struct nhrp_extension_header));
+ hdr->extension_offset =
+ htons(zb->tail - (uint8_t *)hdr
+ - sizeof(struct nhrp_extension_header));
- *ext = (struct nhrp_extension_header) {
- .type = htons(type),
- .length = 0,
+ *ext = (struct nhrp_extension_header){
+ .type = htons(type), .length = 0,
};
return ext;
}
void nhrp_ext_complete(struct zbuf *zb, struct nhrp_extension_header *ext)
{
- ext->length = htons(zb->tail - (uint8_t*)ext - sizeof(struct nhrp_extension_header));
+ ext->length = htons(zb->tail - (uint8_t *)ext
+ - sizeof(struct nhrp_extension_header));
}
-struct nhrp_extension_header *nhrp_ext_pull(struct zbuf *zb, struct zbuf *payload)
+struct nhrp_extension_header *nhrp_ext_pull(struct zbuf *zb,
+ struct zbuf *payload)
{
struct nhrp_extension_header *ext;
uint16_t plen;
ext = zbuf_pull(zb, struct nhrp_extension_header);
- if (!ext) return NULL;
+ if (!ext)
+ return NULL;
plen = htons(ext->length);
zbuf_init(payload, zbuf_pulln(zb, plen), plen, plen);
return ext;
}
-void nhrp_ext_request(struct zbuf *zb, struct nhrp_packet_header *hdr, struct interface *ifp)
+void nhrp_ext_request(struct zbuf *zb, struct nhrp_packet_header *hdr,
+ struct interface *ifp)
{
/* Place holders for standard extensions */
- nhrp_ext_push(zb, hdr, NHRP_EXTENSION_FORWARD_TRANSIT_NHS | NHRP_EXTENSION_FLAG_COMPULSORY);
- nhrp_ext_push(zb, hdr, NHRP_EXTENSION_REVERSE_TRANSIT_NHS | NHRP_EXTENSION_FLAG_COMPULSORY);
- nhrp_ext_push(zb, hdr, NHRP_EXTENSION_RESPONDER_ADDRESS | NHRP_EXTENSION_FLAG_COMPULSORY);
+ nhrp_ext_push(zb, hdr,
+ NHRP_EXTENSION_FORWARD_TRANSIT_NHS
+ | NHRP_EXTENSION_FLAG_COMPULSORY);
+ nhrp_ext_push(zb, hdr,
+ NHRP_EXTENSION_REVERSE_TRANSIT_NHS
+ | NHRP_EXTENSION_FLAG_COMPULSORY);
+ nhrp_ext_push(zb, hdr,
+ NHRP_EXTENSION_RESPONDER_ADDRESS
+ | NHRP_EXTENSION_FLAG_COMPULSORY);
}
-int nhrp_ext_reply(struct zbuf *zb, struct nhrp_packet_header *hdr, struct interface *ifp, struct nhrp_extension_header *ext, struct zbuf *extpayload)
+int nhrp_ext_reply(struct zbuf *zb, struct nhrp_packet_header *hdr,
+ struct interface *ifp, struct nhrp_extension_header *ext,
+ struct zbuf *extpayload)
{
struct nhrp_interface *nifp = ifp->info;
struct nhrp_afi_data *ad = &nifp->afi[htons(hdr->afnum)];
return 0;
dst = nhrp_ext_push(zb, hdr, htons(ext->type));
- if (!dst) goto err;
+ if (!dst)
+ goto err;
switch (type) {
case NHRP_EXTENSION_RESPONDER_ADDRESS:
- cie = nhrp_cie_push(zb, NHRP_CODE_SUCCESS, &nifp->nbma, &ad->addr);
- if (!cie) goto err;
+ cie = nhrp_cie_push(zb, NHRP_CODE_SUCCESS, &nifp->nbma,
+ &ad->addr);
+ if (!cie)
+ goto err;
cie->holding_time = htons(ad->holdtime);
break;
default:
if (type & NHRP_EXTENSION_FLAG_COMPULSORY)
goto err;
- /* fallthru */
+ /* fallthru */
case NHRP_EXTENSION_FORWARD_TRANSIT_NHS:
case NHRP_EXTENSION_REVERSE_TRANSIT_NHS:
/* Supported compulsory extensions, and any
thread_add_read(master, nhrp_packet_recvraw, 0, fd, NULL);
zb = zbuf_alloc(1500);
- if (!zb) return 0;
+ if (!zb)
+ return 0;
len = zbuf_size(zb);
addrlen = sizeof(addr);
}
ifp = if_lookup_by_index(ifindex, VRF_DEFAULT);
- if (!ifp) goto err;
+ if (!ifp)
+ goto err;
p = nhrp_peer_get(ifp, &remote_nbma);
- if (!p) goto err;
+ if (!p)
+ goto err;
nhrp_peer_recv(p, zb);
nhrp_peer_unref(p);
nhrp_peer_ref(p);
p->online = online;
if (online) {
- notifier_call(&p->notifier_list, NOTIFY_PEER_UP);
+ notifier_call(&p->notifier_list,
+ NOTIFY_PEER_UP);
} else {
p->requested = p->fallback_requested = 0;
- notifier_call(&p->notifier_list, NOTIFY_PEER_DOWN);
+ notifier_call(&p->notifier_list,
+ NOTIFY_PEER_DOWN);
}
nhrp_peer_unref(p);
}
if (vc && p->vc != vc) {
nhrp_vc_notify_del(p->vc, &p->vc_notifier);
p->vc = vc;
- nhrp_vc_notify_add(p->vc, &p->vc_notifier, nhrp_peer_vc_notify);
+ nhrp_vc_notify_add(p->vc, &p->vc_notifier,
+ nhrp_peer_vc_notify);
__nhrp_peer_check(p);
}
/* fallthru */ /* to post config update */
p = XMALLOC(MTYPE_NHRP_PEER, sizeof(*p));
if (p) {
- *p = (struct nhrp_peer) {
+ *p = (struct nhrp_peer){
.ref = 0,
.ifp = key->ifp,
.vc = key->vc,
- .notifier_list = NOTIFIER_LIST_INITIALIZER(&p->notifier_list),
+ .notifier_list =
+ NOTIFIER_LIST_INITIALIZER(&p->notifier_list),
};
nhrp_vc_notify_add(p->vc, &p->vc_notifier, nhrp_peer_vc_notify);
- nhrp_interface_notify_add(p->ifp, &p->ifp_notifier, nhrp_peer_ifp_notify);
+ nhrp_interface_notify_add(p->ifp, &p->ifp_notifier,
+ nhrp_peer_ifp_notify);
}
return p;
}
-struct nhrp_peer *nhrp_peer_get(struct interface *ifp, const union sockunion *remote_nbma)
+struct nhrp_peer *nhrp_peer_get(struct interface *ifp,
+ const union sockunion *remote_nbma)
{
struct nhrp_interface *nifp = ifp->info;
struct nhrp_peer key, *p;
struct nhrp_vc *vc;
if (!nifp->peer_hash) {
- nifp->peer_hash = hash_create(nhrp_peer_key,
- nhrp_peer_cmp,
+ nifp->peer_hash = hash_create(nhrp_peer_key, nhrp_peer_cmp,
"NHRP Peer Hash");
- if (!nifp->peer_hash) return NULL;
+ if (!nifp->peer_hash)
+ return NULL;
}
vc = nhrp_vc_get(&nifp->nbma, remote_nbma, 1);
- if (!vc) return NULL;
+ if (!vc)
+ return NULL;
key.ifp = ifp;
key.vc = vc;
p = hash_get(nifp->peer_hash, &key, nhrp_peer_create);
nhrp_peer_ref(p);
- if (p->ref == 1) __nhrp_peer_check(p);
+ if (p->ref == 1)
+ __nhrp_peer_check(p);
return p;
}
struct nhrp_peer *nhrp_peer_ref(struct nhrp_peer *p)
{
- if (p) p->ref++;
+ if (p)
+ p->ref++;
return p;
}
if (p->online)
return 0;
- if (nifp->ipsec_fallback_profile && !p->prio && !p->fallback_requested) {
+ if (nifp->ipsec_fallback_profile && !p->prio
+ && !p->fallback_requested) {
p->fallback_requested = 1;
- vici_request_vc(nifp->ipsec_fallback_profile,
- &vc->local.nbma, &vc->remote.nbma, p->prio);
+ vici_request_vc(nifp->ipsec_fallback_profile, &vc->local.nbma,
+ &vc->remote.nbma, p->prio);
thread_add_timer(master, nhrp_peer_request_timeout, p, 30,
&p->t_fallback);
} else {
p->prio = establish > 1;
p->requested = 1;
- vici_request_vc(nifp->ipsec_profile, &vc->local.nbma, &vc->remote.nbma, p->prio);
+ vici_request_vc(nifp->ipsec_profile, &vc->local.nbma, &vc->remote.nbma,
+ p->prio);
thread_add_timer(master, nhrp_peer_request_timeout, p,
(nifp->ipsec_fallback_profile && !p->prio) ? 15 : 30,
&p->t_fallback);
return 0;
}
-void nhrp_peer_notify_add(struct nhrp_peer *p, struct notifier_block *n, notifier_fn_t fn)
+void nhrp_peer_notify_add(struct nhrp_peer *p, struct notifier_block *n,
+ notifier_fn_t fn)
{
notifier_add(n, &p->notifier_list, fn);
}
return;
debugf(NHRP_DEBUG_KERNEL, "PACKET: Send %s -> %s",
- sockunion2str(&p->vc->local.nbma, buf[0], sizeof buf[0]),
- sockunion2str(&p->vc->remote.nbma, buf[1], sizeof buf[1]));
+ sockunion2str(&p->vc->local.nbma, buf[0], sizeof buf[0]),
+ sockunion2str(&p->vc->remote.nbma, buf[1], sizeof buf[1]));
- os_sendmsg(zb->head, zbuf_used(zb),
- p->ifp->ifindex,
- sockunion_get_addr(&p->vc->remote.nbma),
- sockunion_get_addrlen(&p->vc->remote.nbma));
+ os_sendmsg(zb->head, zbuf_used(zb), p->ifp->ifindex,
+ sockunion_get_addr(&p->vc->remote.nbma),
+ sockunion_get_addrlen(&p->vc->remote.nbma));
zbuf_reset(zb);
}
return;
}
- if (p->if_ad->network_id &&
- p->route_type == NHRP_ROUTE_OFF_NBMA &&
- p->route_prefix.prefixlen < 8) {
- debugf(NHRP_DEBUG_COMMON, "Shortcut to more generic than /8 dropped");
+ if (p->if_ad->network_id && p->route_type == NHRP_ROUTE_OFF_NBMA
+ && p->route_prefix.prefixlen < 8) {
+ debugf(NHRP_DEBUG_COMMON,
+ "Shortcut to more generic than /8 dropped");
return;
}
debugf(NHRP_DEBUG_COMMON, "Parsing and replying to Resolution Req");
- if (nhrp_route_address(p->ifp, &p->src_proto, NULL, &peer) != NHRP_ROUTE_NBMA_NEXTHOP)
+ if (nhrp_route_address(p->ifp, &p->src_proto, NULL, &peer)
+ != NHRP_ROUTE_NBMA_NEXTHOP)
return;
#if 0
/* Create reply */
zb = zbuf_alloc(1500);
- hdr = nhrp_packet_push(zb, NHRP_PACKET_RESOLUTION_REPLY, &p->src_nbma, &p->src_proto, &p->dst_proto);
+ hdr = nhrp_packet_push(zb, NHRP_PACKET_RESOLUTION_REPLY, &p->src_nbma,
+ &p->src_proto, &p->dst_proto);
/* Copied information from request */
- hdr->flags = p->hdr->flags & htons(NHRP_FLAG_RESOLUTION_SOURCE_IS_ROUTER|NHRP_FLAG_RESOLUTION_SOURCE_STABLE);
- hdr->flags |= htons(NHRP_FLAG_RESOLUTION_DESTINATION_STABLE | NHRP_FLAG_RESOLUTION_AUTHORATIVE);
+ hdr->flags =
+ p->hdr->flags & htons(NHRP_FLAG_RESOLUTION_SOURCE_IS_ROUTER
+ | NHRP_FLAG_RESOLUTION_SOURCE_STABLE);
+ hdr->flags |= htons(NHRP_FLAG_RESOLUTION_DESTINATION_STABLE
+ | NHRP_FLAG_RESOLUTION_AUTHORATIVE);
hdr->u.request_id = p->hdr->u.request_id;
/* CIE payload */
- cie = nhrp_cie_push(zb, NHRP_CODE_SUCCESS, &nifp->nbma, &p->if_ad->addr);
+ cie = nhrp_cie_push(zb, NHRP_CODE_SUCCESS, &nifp->nbma,
+ &p->if_ad->addr);
cie->holding_time = htons(p->if_ad->holdtime);
cie->mtu = htons(p->if_ad->mtu);
if (p->if_ad->network_id && p->route_type == NHRP_ROUTE_OFF_NBMA)
case NHRP_EXTENSION_NAT_ADDRESS:
if (sockunion_family(&nifp->nat_nbma) == AF_UNSPEC)
break;
- ext = nhrp_ext_push(zb, hdr, NHRP_EXTENSION_NAT_ADDRESS);
- if (!ext) goto err;
- cie = nhrp_cie_push(zb, NHRP_CODE_SUCCESS, &nifp->nat_nbma, &p->if_ad->addr);
- if (!cie) goto err;
+ ext = nhrp_ext_push(zb, hdr,
+ NHRP_EXTENSION_NAT_ADDRESS);
+ if (!ext)
+ goto err;
+ cie = nhrp_cie_push(zb, NHRP_CODE_SUCCESS,
+ &nifp->nat_nbma, &p->if_ad->addr);
+ if (!cie)
+ goto err;
nhrp_ext_complete(zb, ext);
break;
default:
struct nhrp_cie_header *cie;
struct nhrp_extension_header *ext;
struct nhrp_cache *c;
- union sockunion cie_nbma, cie_proto, *proto_addr, *nbma_addr, *nbma_natoa;
+ union sockunion cie_nbma, cie_proto, *proto_addr, *nbma_addr,
+ *nbma_natoa;
int holdtime, prefix_len, hostprefix_len, natted = 0;
size_t paylen;
void *pay;
/* Create reply */
zb = zbuf_alloc(1500);
- hdr = nhrp_packet_push(zb, NHRP_PACKET_REGISTRATION_REPLY,
- &p->src_nbma, &p->src_proto, &p->if_ad->addr);
+ hdr = nhrp_packet_push(zb, NHRP_PACKET_REGISTRATION_REPLY, &p->src_nbma,
+ &p->src_proto, &p->if_ad->addr);
/* Copied information from request */
- hdr->flags = p->hdr->flags & htons(NHRP_FLAG_REGISTRATION_UNIQUE | NHRP_FLAG_REGISTRATION_NAT);
+ hdr->flags = p->hdr->flags & htons(NHRP_FLAG_REGISTRATION_UNIQUE
+ | NHRP_FLAG_REGISTRATION_NAT);
hdr->u.request_id = p->hdr->u.request_id;
/* Copy payload CIEs */
paylen = zbuf_used(&p->payload);
pay = zbuf_pushn(zb, paylen);
- if (!pay) goto err;
+ if (!pay)
+ goto err;
memcpy(pay, zbuf_pulln(&p->payload, paylen), paylen);
zbuf_init(&payload, pay, paylen, paylen);
- while ((cie = nhrp_cie_pull(&payload, hdr, &cie_nbma, &cie_proto)) != NULL) {
+ while ((cie = nhrp_cie_pull(&payload, hdr, &cie_nbma, &cie_proto))
+ != NULL) {
prefix_len = cie->prefix_length;
if (prefix_len == 0 || prefix_len >= hostprefix_len)
prefix_len = hostprefix_len;
- if (prefix_len != hostprefix_len && !(p->hdr->flags & htons(NHRP_FLAG_REGISTRATION_UNIQUE))) {
+ if (prefix_len != hostprefix_len
+ && !(p->hdr->flags
+ & htons(NHRP_FLAG_REGISTRATION_UNIQUE))) {
cie->code = NHRP_CODE_BINDING_NON_UNIQUE;
continue;
}
continue;
}
- proto_addr = (sockunion_family(&cie_proto) == AF_UNSPEC) ? &p->src_proto : &cie_proto;
- nbma_addr = (sockunion_family(&cie_nbma) == AF_UNSPEC) ? &p->src_nbma : &cie_nbma;
+ proto_addr = (sockunion_family(&cie_proto) == AF_UNSPEC)
+ ? &p->src_proto
+ : &cie_proto;
+ nbma_addr = (sockunion_family(&cie_nbma) == AF_UNSPEC)
+ ? &p->src_nbma
+ : &cie_nbma;
nbma_natoa = NULL;
if (natted) {
nbma_natoa = nbma_addr;
}
holdtime = htons(cie->holding_time);
- if (!holdtime) holdtime = p->if_ad->holdtime;
+ if (!holdtime)
+ holdtime = p->if_ad->holdtime;
c = nhrp_cache_get(ifp, proto_addr, 1);
if (!c) {
continue;
}
- if (!nhrp_cache_update_binding(c, NHRP_CACHE_DYNAMIC, holdtime, nhrp_peer_ref(p->peer), htons(cie->mtu), nbma_natoa)) {
+ if (!nhrp_cache_update_binding(c, NHRP_CACHE_DYNAMIC, holdtime,
+ nhrp_peer_ref(p->peer),
+ htons(cie->mtu), nbma_natoa)) {
cie->code = NHRP_CODE_ADMINISTRATIVELY_PROHIBITED;
continue;
}
while ((ext = nhrp_ext_pull(&p->extensions, &payload)) != NULL) {
switch (htons(ext->type) & ~NHRP_EXTENSION_FLAG_COMPULSORY) {
case NHRP_EXTENSION_NAT_ADDRESS:
- ext = nhrp_ext_push(zb, hdr, NHRP_EXTENSION_NAT_ADDRESS);
- if (!ext) goto err;
+ ext = nhrp_ext_push(zb, hdr,
+ NHRP_EXTENSION_NAT_ADDRESS);
+ if (!ext)
+ goto err;
zbuf_copy(zb, &payload, zbuf_used(&payload));
if (natted) {
nhrp_cie_push(zb, NHRP_CODE_SUCCESS,
- &p->peer->vc->remote.nbma,
- &p->src_proto);
+ &p->peer->vc->remote.nbma,
+ &p->src_proto);
}
nhrp_ext_complete(zb, ext);
break;
zbuf_free(zb);
}
-static int parse_ether_packet(struct zbuf *zb, uint16_t protocol_type, union sockunion *src, union sockunion *dst)
+static int parse_ether_packet(struct zbuf *zb, uint16_t protocol_type,
+ union sockunion *src, union sockunion *dst)
{
switch (protocol_type) {
case ETH_P_IP: {
- struct iphdr *iph = zbuf_pull(zb, struct iphdr);
- if (iph) {
- if (src) sockunion_set(src, AF_INET, (uint8_t*) &iph->saddr, sizeof(iph->saddr));
- if (dst) sockunion_set(dst, AF_INET, (uint8_t*) &iph->daddr, sizeof(iph->daddr));
- }
+ struct iphdr *iph = zbuf_pull(zb, struct iphdr);
+ if (iph) {
+ if (src)
+ sockunion_set(src, AF_INET,
+ (uint8_t *)&iph->saddr,
+ sizeof(iph->saddr));
+ if (dst)
+ sockunion_set(dst, AF_INET,
+ (uint8_t *)&iph->daddr,
+ sizeof(iph->daddr));
}
- break;
+ } break;
case ETH_P_IPV6: {
- struct ipv6hdr *iph = zbuf_pull(zb, struct ipv6hdr);
- if (iph) {
- if (src) sockunion_set(src, AF_INET6, (uint8_t*) &iph->saddr, sizeof(iph->saddr));
- if (dst) sockunion_set(dst, AF_INET6, (uint8_t*) &iph->daddr, sizeof(iph->daddr));
- }
+ struct ipv6hdr *iph = zbuf_pull(zb, struct ipv6hdr);
+ if (iph) {
+ if (src)
+ sockunion_set(src, AF_INET6,
+ (uint8_t *)&iph->saddr,
+ sizeof(iph->saddr));
+ if (dst)
+ sockunion_set(dst, AF_INET6,
+ (uint8_t *)&iph->daddr,
+ sizeof(iph->daddr));
}
- break;
+ } break;
default:
return 0;
}
return 1;
}
-void nhrp_peer_send_indication(struct interface *ifp, uint16_t protocol_type, struct zbuf *pkt)
+void nhrp_peer_send_indication(struct interface *ifp, uint16_t protocol_type,
+ struct zbuf *pkt)
{
union sockunion dst;
struct zbuf *zb, payload;
struct nhrp_peer *p;
char buf[2][SU_ADDRSTRLEN];
- if (!nifp->enabled) return;
+ if (!nifp->enabled)
+ return;
payload = *pkt;
if (!parse_ether_packet(&payload, protocol_type, &dst, NULL))
if_ad = &nifp->afi[family2afi(sockunion_family(&dst))];
if (!(if_ad->flags & NHRP_IFF_REDIRECT)) {
- debugf(NHRP_DEBUG_COMMON, "Send Traffic Indication to %s about packet to %s ignored",
- sockunion2str(&p->vc->remote.nbma, buf[0], sizeof buf[0]),
- sockunion2str(&dst, buf[1], sizeof buf[1]));
+ debugf(NHRP_DEBUG_COMMON,
+ "Send Traffic Indication to %s about packet to %s ignored",
+ sockunion2str(&p->vc->remote.nbma, buf[0],
+ sizeof buf[0]),
+ sockunion2str(&dst, buf[1], sizeof buf[1]));
return;
}
- debugf(NHRP_DEBUG_COMMON, "Send Traffic Indication to %s (online=%d) about packet to %s",
- sockunion2str(&p->vc->remote.nbma, buf[0], sizeof buf[0]),
- p->online,
- sockunion2str(&dst, buf[1], sizeof buf[1]));
+ debugf(NHRP_DEBUG_COMMON,
+ "Send Traffic Indication to %s (online=%d) about packet to %s",
+ sockunion2str(&p->vc->remote.nbma, buf[0], sizeof buf[0]),
+ p->online, sockunion2str(&dst, buf[1], sizeof buf[1]));
/* Create reply */
zb = zbuf_alloc(1500);
- hdr = nhrp_packet_push(zb, NHRP_PACKET_TRAFFIC_INDICATION, &nifp->nbma, &if_ad->addr, &dst);
+ hdr = nhrp_packet_push(zb, NHRP_PACKET_TRAFFIC_INDICATION, &nifp->nbma,
+ &if_ad->addr, &dst);
hdr->hop_count = 0;
/* Payload is the packet causing indication */
char buf[2][SU_ADDRSTRLEN];
hdr = nhrp_packet_pull(&origmsg, &src_nbma, &src_proto, &dst_proto);
- if (!hdr) return;
+ if (!hdr)
+ return;
- debugf(NHRP_DEBUG_COMMON, "Error Indication from %s about packet to %s ignored",
- sockunion2str(&pp->src_proto, buf[0], sizeof buf[0]),
- sockunion2str(&dst_proto, buf[1], sizeof buf[1]));
+ debugf(NHRP_DEBUG_COMMON,
+ "Error Indication from %s about packet to %s ignored",
+ sockunion2str(&pp->src_proto, buf[0], sizeof buf[0]),
+ sockunion2str(&dst_proto, buf[1], sizeof buf[1]));
reqid = nhrp_reqid_lookup(&nhrp_packet_reqid, htonl(hdr->u.request_id));
if (reqid)
union sockunion dst;
char buf[2][SU_ADDRSTRLEN];
- if (!parse_ether_packet(&p->payload, htons(p->hdr->protocol_type), NULL, &dst))
+ if (!parse_ether_packet(&p->payload, htons(p->hdr->protocol_type), NULL,
+ &dst))
return;
- debugf(NHRP_DEBUG_COMMON, "Traffic Indication from %s about packet to %s: %s",
- sockunion2str(&p->src_proto, buf[0], sizeof buf[0]),
- sockunion2str(&dst, buf[1], sizeof buf[1]),
- (p->if_ad->flags & NHRP_IFF_SHORTCUT) ? "trying shortcut" : "ignored");
+ debugf(NHRP_DEBUG_COMMON,
+ "Traffic Indication from %s about packet to %s: %s",
+ sockunion2str(&p->src_proto, buf[0], sizeof buf[0]),
+ sockunion2str(&dst, buf[1], sizeof buf[1]),
+ (p->if_ad->flags & NHRP_IFF_SHORTCUT) ? "trying shortcut"
+ : "ignored");
if (p->if_ad->flags & NHRP_IFF_SHORTCUT)
nhrp_shortcut_initiate(&dst);
enum packet_type_t type;
const char *name;
void (*handler)(struct nhrp_packet_parser *);
-} packet_types[] = {
- [0] = {
- .type = PACKET_UNKNOWN,
- .name = "UNKNOWN",
- },
- [NHRP_PACKET_RESOLUTION_REQUEST] = {
- .type = PACKET_REQUEST,
- .name = "Resolution-Request",
- .handler = nhrp_handle_resolution_req,
- },
- [NHRP_PACKET_RESOLUTION_REPLY] = {
- .type = PACKET_REPLY,
- .name = "Resolution-Reply",
- },
- [NHRP_PACKET_REGISTRATION_REQUEST] = {
- .type = PACKET_REQUEST,
- .name = "Registration-Request",
- .handler = nhrp_handle_registration_request,
- },
- [NHRP_PACKET_REGISTRATION_REPLY] = {
- .type = PACKET_REPLY,
- .name = "Registration-Reply",
- },
- [NHRP_PACKET_PURGE_REQUEST] = {
- .type = PACKET_REQUEST,
- .name = "Purge-Request",
- },
- [NHRP_PACKET_PURGE_REPLY] = {
- .type = PACKET_REPLY,
- .name = "Purge-Reply",
- },
- [NHRP_PACKET_ERROR_INDICATION] = {
- .type = PACKET_INDICATION,
- .name = "Error-Indication",
- .handler = nhrp_handle_error_ind,
- },
- [NHRP_PACKET_TRAFFIC_INDICATION] = {
- .type = PACKET_INDICATION,
- .name = "Traffic-Indication",
- .handler = nhrp_handle_traffic_ind,
- }
-};
-
-static void nhrp_peer_forward(struct nhrp_peer *p, struct nhrp_packet_parser *pp)
+} packet_types[] = {[0] =
+ {
+ .type = PACKET_UNKNOWN,
+ .name = "UNKNOWN",
+ },
+ [NHRP_PACKET_RESOLUTION_REQUEST] =
+ {
+ .type = PACKET_REQUEST,
+ .name = "Resolution-Request",
+ .handler = nhrp_handle_resolution_req,
+ },
+ [NHRP_PACKET_RESOLUTION_REPLY] =
+ {
+ .type = PACKET_REPLY,
+ .name = "Resolution-Reply",
+ },
+ [NHRP_PACKET_REGISTRATION_REQUEST] =
+ {
+ .type = PACKET_REQUEST,
+ .name = "Registration-Request",
+ .handler = nhrp_handle_registration_request,
+ },
+ [NHRP_PACKET_REGISTRATION_REPLY] =
+ {
+ .type = PACKET_REPLY,
+ .name = "Registration-Reply",
+ },
+ [NHRP_PACKET_PURGE_REQUEST] =
+ {
+ .type = PACKET_REQUEST,
+ .name = "Purge-Request",
+ },
+ [NHRP_PACKET_PURGE_REPLY] =
+ {
+ .type = PACKET_REPLY,
+ .name = "Purge-Reply",
+ },
+ [NHRP_PACKET_ERROR_INDICATION] =
+ {
+ .type = PACKET_INDICATION,
+ .name = "Error-Indication",
+ .handler = nhrp_handle_error_ind,
+ },
+ [NHRP_PACKET_TRAFFIC_INDICATION] = {
+ .type = PACKET_INDICATION,
+ .name = "Traffic-Indication",
+ .handler = nhrp_handle_traffic_ind,
+ }};
+
+static void nhrp_peer_forward(struct nhrp_peer *p,
+ struct nhrp_packet_parser *pp)
{
struct zbuf *zb, extpl;
struct nhrp_packet_header *hdr;
/* Create forward packet - copy header */
zb = zbuf_alloc(1500);
- hdr = nhrp_packet_push(zb, pp->hdr->type, &pp->src_nbma, &pp->src_proto, &pp->dst_proto);
+ hdr = nhrp_packet_push(zb, pp->hdr->type, &pp->src_nbma, &pp->src_proto,
+ &pp->dst_proto);
hdr->flags = pp->hdr->flags;
hdr->hop_count = pp->hdr->hop_count - 1;
hdr->u.request_id = pp->hdr->u.request_id;
break;
dst = nhrp_ext_push(zb, hdr, htons(ext->type));
- if (!dst) goto err;
+ if (!dst)
+ goto err;
switch (type) {
case NHRP_EXTENSION_FORWARD_TRANSIT_NHS:
case NHRP_EXTENSION_REVERSE_TRANSIT_NHS:
zbuf_put(zb, extpl.head, len);
- if ((type == NHRP_EXTENSION_REVERSE_TRANSIT_NHS) ==
- (packet_types[hdr->type].type == PACKET_REPLY)) {
+ if ((type == NHRP_EXTENSION_REVERSE_TRANSIT_NHS)
+ == (packet_types[hdr->type].type == PACKET_REPLY)) {
/* Check NHS list for forwarding loop */
- while ((cie = nhrp_cie_pull(&extpl, pp->hdr, &cie_nbma, &cie_protocol)) != NULL) {
- if (sockunion_same(&p->vc->remote.nbma, &cie_nbma))
+ while ((cie = nhrp_cie_pull(&extpl, pp->hdr,
+ &cie_nbma,
+ &cie_protocol))
+ != NULL) {
+ if (sockunion_same(&p->vc->remote.nbma,
+ &cie_nbma))
goto err;
}
/* Append our selves to the list */
- cie = nhrp_cie_push(zb, NHRP_CODE_SUCCESS, &nifp->nbma, &if_ad->addr);
- if (!cie) goto err;
+ cie = nhrp_cie_push(zb, NHRP_CODE_SUCCESS,
+ &nifp->nbma, &if_ad->addr);
+ if (!cie)
+ goto err;
cie->holding_time = htons(if_ad->holdtime);
}
break;
/* FIXME: RFC says to just copy, but not
* append our selves to the transit NHS list */
goto err;
- /* fallthru */
+ /* fallthru */
case NHRP_EXTENSION_RESPONDER_ADDRESS:
/* Supported compulsory extensions, and any
* non-compulsory that is not explicitly handled,
if (likely(!(debug_flags & NHRP_DEBUG_COMMON)))
return;
- zbuf_init(&zhdr, zb->buf, zb->tail-zb->buf, zb->tail-zb->buf);
+ zbuf_init(&zhdr, zb->buf, zb->tail - zb->buf, zb->tail - zb->buf);
hdr = nhrp_packet_pull(&zhdr, &src_nbma, &src_proto, &dst_proto);
sockunion2str(&src_proto, buf[0], sizeof buf[0]);
sockunion2str(&dst_proto, buf[1], sizeof buf[1]);
reply = packet_types[hdr->type].type == PACKET_REPLY;
- debugf(NHRP_DEBUG_COMMON, "%s %s(%d) %s -> %s",
- dir,
- packet_types[hdr->type].name ? : "Unknown",
- hdr->type,
- reply ? buf[1] : buf[0],
- reply ? buf[0] : buf[1]);
+ debugf(NHRP_DEBUG_COMMON, "%s %s(%d) %s -> %s", dir,
+ packet_types[hdr->type].name ?: "Unknown", hdr->type,
+ reply ? buf[1] : buf[0], reply ? buf[0] : buf[1]);
}
static int proto2afi(uint16_t proto)
{
switch (proto) {
- case ETH_P_IP: return AFI_IP;
- case ETH_P_IPV6: return AFI_IP6;
+ case ETH_P_IP:
+ return AFI_IP;
+ case ETH_P_IPV6:
+ return AFI_IP6;
}
return AF_UNSPEC;
}
afi_t nbma_afi, proto_afi;
debugf(NHRP_DEBUG_KERNEL, "PACKET: Recv %s -> %s",
- sockunion2str(&vc->remote.nbma, buf[0], sizeof buf[0]),
- sockunion2str(&vc->local.nbma, buf[1], sizeof buf[1]));
+ sockunion2str(&vc->remote.nbma, buf[0], sizeof buf[0]),
+ sockunion2str(&vc->local.nbma, buf[1], sizeof buf[1]));
if (!p->online) {
info = "peer not online";
nbma_afi = htons(hdr->afnum);
proto_afi = proto2afi(htons(hdr->protocol_type));
- if (hdr->type > NHRP_PACKET_MAX ||
- hdr->version != NHRP_VERSION_RFC2332 ||
- nbma_afi >= AFI_MAX || proto_afi == AF_UNSPEC ||
- packet_types[hdr->type].type == PACKET_UNKNOWN ||
- htons(hdr->packet_size) > realsize) {
- zlog_info("From %s: error: packet type %d, version %d, AFI %d, proto %x, size %d (real size %d)",
- sockunion2str(&vc->remote.nbma, buf[0], sizeof buf[0]),
- (int) hdr->type, (int) hdr->version,
- (int) nbma_afi, (int) htons(hdr->protocol_type),
- (int) htons(hdr->packet_size), (int) realsize);
+ if (hdr->type > NHRP_PACKET_MAX || hdr->version != NHRP_VERSION_RFC2332
+ || nbma_afi >= AFI_MAX || proto_afi == AF_UNSPEC
+ || packet_types[hdr->type].type == PACKET_UNKNOWN
+ || htons(hdr->packet_size) > realsize) {
+ zlog_info(
+ "From %s: error: packet type %d, version %d, AFI %d, proto %x, size %d (real size %d)",
+ sockunion2str(&vc->remote.nbma, buf[0], sizeof buf[0]),
+ (int)hdr->type, (int)hdr->version, (int)nbma_afi,
+ (int)htons(hdr->protocol_type),
+ (int)htons(hdr->packet_size), (int)realsize);
goto drop;
}
pp.if_ad = &((struct nhrp_interface *)ifp->info)->afi[proto_afi];
* pre-handled. */
/* Figure out if this is local */
- target_addr = (packet_types[hdr->type].type == PACKET_REPLY) ? &pp.src_proto : &pp.dst_proto;
+ target_addr = (packet_types[hdr->type].type == PACKET_REPLY)
+ ? &pp.src_proto
+ : &pp.dst_proto;
if (sockunion_same(&pp.src_proto, &pp.dst_proto))
pp.route_type = NHRP_ROUTE_LOCAL;
else
- pp.route_type = nhrp_route_address(pp.ifp, target_addr, &pp.route_prefix, &peer);
+ pp.route_type = nhrp_route_address(pp.ifp, target_addr,
+ &pp.route_prefix, &peer);
switch (pp.route_type) {
case NHRP_ROUTE_LOCAL:
nhrp_packet_debug(zb, "!LOCAL");
if (packet_types[hdr->type].type == PACKET_REPLY) {
- reqid = nhrp_reqid_lookup(&nhrp_packet_reqid, htonl(hdr->u.request_id));
+ reqid = nhrp_reqid_lookup(&nhrp_packet_reqid,
+ htonl(hdr->u.request_id));
if (reqid) {
reqid->cb(reqid, &pp);
break;
drop:
if (info) {
- zlog_info("From %s: error: %s",
- sockunion2str(&vc->remote.nbma, buf[0], sizeof buf[0]),
- info);
+ zlog_info(
+ "From %s: error: %s",
+ sockunion2str(&vc->remote.nbma, buf[0], sizeof buf[0]),
+ info);
}
- if (peer) nhrp_peer_unref(peer);
+ if (peer)
+ nhrp_peer_unref(peer);
zbuf_free(zb);
}
/* NHRP Packet Structures */
struct nhrp_packet_header {
/* Fixed header */
- uint16_t afnum;
- uint16_t protocol_type;
- uint8_t snap[5];
- uint8_t hop_count;
- uint16_t packet_size;
- uint16_t checksum;
- uint16_t extension_offset;
- uint8_t version;
- uint8_t type;
- uint8_t src_nbma_address_len;
- uint8_t src_nbma_subaddress_len;
+ uint16_t afnum;
+ uint16_t protocol_type;
+ uint8_t snap[5];
+ uint8_t hop_count;
+ uint16_t packet_size;
+ uint16_t checksum;
+ uint16_t extension_offset;
+ uint8_t version;
+ uint8_t type;
+ uint8_t src_nbma_address_len;
+ uint8_t src_nbma_subaddress_len;
/* Mandatory header */
- uint8_t src_protocol_address_len;
- uint8_t dst_protocol_address_len;
- uint16_t flags;
+ uint8_t src_protocol_address_len;
+ uint8_t dst_protocol_address_len;
+ uint16_t flags;
union {
- uint32_t request_id;
+ uint32_t request_id;
struct {
- uint16_t code;
- uint16_t offset;
+ uint16_t code;
+ uint16_t offset;
} error;
} u;
} __attribute__((packed));
struct nhrp_cie_header {
- uint8_t code;
- uint8_t prefix_length;
- uint16_t unused;
- uint16_t mtu;
- uint16_t holding_time;
- uint8_t nbma_address_len;
- uint8_t nbma_subaddress_len;
- uint8_t protocol_address_len;
- uint8_t preference;
+ uint8_t code;
+ uint8_t prefix_length;
+ uint16_t unused;
+ uint16_t mtu;
+ uint16_t holding_time;
+ uint8_t nbma_address_len;
+ uint8_t nbma_subaddress_len;
+ uint8_t protocol_address_len;
+ uint8_t preference;
} __attribute__((packed));
struct nhrp_extension_header {
- uint16_t type;
- uint16_t length;
+ uint16_t type;
+ uint16_t length;
} __attribute__((packed));
struct nhrp_cisco_authentication_extension {
- uint32_t type;
- uint8_t secret[8];
+ uint32_t type;
+ uint8_t secret[8];
} __attribute__((packed));
#endif
struct interface *nhrp_ifp;
};
-static struct route_node *nhrp_route_update_get(const struct prefix *p, int create)
+static struct route_node *nhrp_route_update_get(const struct prefix *p,
+ int create)
{
struct route_node *rn;
afi_t afi = family2afi(PREFIX_FAMILY(p));
if (create) {
rn = route_node_get(zebra_rib[afi], p);
if (!rn->info) {
- rn->info = XCALLOC(MTYPE_NHRP_ROUTE, sizeof(struct route_info));
+ rn->info = XCALLOC(MTYPE_NHRP_ROUTE,
+ sizeof(struct route_info));
route_lock_node(rn);
}
return rn;
{
struct route_info *ri = rn->info;
- if (!ri->ifp && !ri->nhrp_ifp && sockunion_family(&ri->via) == AF_UNSPEC) {
+ if (!ri->ifp && !ri->nhrp_ifp
+ && sockunion_family(&ri->via) == AF_UNSPEC) {
XFREE(MTYPE_NHRP_ROUTE, rn->info);
rn->info = NULL;
route_unlock_node(rn);
route_unlock_node(rn);
}
-static void nhrp_route_update_zebra(const struct prefix *p, union sockunion *nexthop, struct interface *ifp)
+static void nhrp_route_update_zebra(const struct prefix *p,
+ union sockunion *nexthop,
+ struct interface *ifp)
{
struct route_node *rn;
struct route_info *ri;
- rn = nhrp_route_update_get(p, (sockunion_family(nexthop) != AF_UNSPEC) || ifp);
+ rn = nhrp_route_update_get(
+ p, (sockunion_family(nexthop) != AF_UNSPEC) || ifp);
if (rn) {
ri = rn->info;
ri->via = *nexthop;
}
}
-void nhrp_route_announce(int add, enum nhrp_cache_type type, const struct prefix *p, struct interface *ifp, const union sockunion *nexthop, uint32_t mtu)
+void nhrp_route_announce(int add, enum nhrp_cache_type type,
+ const struct prefix *p, struct interface *ifp,
+ const union sockunion *nexthop, uint32_t mtu)
{
struct zapi_route api;
struct zapi_nexthop *api_nh;
char buf[2][PREFIX_STRLEN];
prefix2str(&api.prefix, buf[0], sizeof(buf[0]));
- zlog_debug("Zebra send: route %s %s nexthop %s metric %u"
+ zlog_debug(
+ "Zebra send: route %s %s nexthop %s metric %u"
" count %d dev %s",
add ? "add" : "del", buf[0],
- nexthop ? inet_ntop(api.prefix.family, &api_nh->gate, buf[1], sizeof(buf[1])) : "<onlink>",
+ nexthop ? inet_ntop(api.prefix.family, &api_nh->gate,
+ buf[1], sizeof(buf[1]))
+ : "<onlink>",
api.metric, api.nexthop_num, ifp ? ifp->name : "none");
}
&api);
}
-int nhrp_route_read(int cmd, struct zclient *zclient, zebra_size_t length, vrf_id_t vrf_id)
+int nhrp_route_read(int cmd, struct zclient *zclient, zebra_size_t length,
+ vrf_id_t vrf_id)
{
struct zapi_route api;
struct zapi_nexthop *api_nh;
}
if (api_nh->ifindex != IFINDEX_INTERNAL)
- ifp = if_lookup_by_index(api_nh->ifindex, VRF_DEFAULT);
+ ifp = if_lookup_by_index(api_nh->ifindex, VRF_DEFAULT);
}
added = (cmd == ZEBRA_REDISTRIBUTE_ROUTE_ADD);
debugf(NHRP_DEBUG_ROUTE, "if-route-%s: %s via %s dev %s",
- added ? "add" : "del",
- prefix2str(&api.prefix, buf[0], sizeof buf[0]),
- sockunion2str(&nexthop_addr, buf[1], sizeof buf[1]),
- ifp ? ifp->name : "(none)");
+ added ? "add" : "del",
+ prefix2str(&api.prefix, buf[0], sizeof buf[0]),
+ sockunion2str(&nexthop_addr, buf[1], sizeof buf[1]),
+ ifp ? ifp->name : "(none)");
nhrp_route_update_zebra(&api.prefix, &nexthop_addr, ifp);
nhrp_shortcut_prefix_change(&api.prefix, !added);
return 0;
}
-int nhrp_route_get_nexthop(const union sockunion *addr, struct prefix *p, union sockunion *via, struct interface **ifp)
+int nhrp_route_get_nexthop(const union sockunion *addr, struct prefix *p,
+ union sockunion *via, struct interface **ifp)
{
struct route_node *rn;
struct route_info *ri;
sockunion2hostprefix(addr, &lookup);
rn = route_node_match(zebra_rib[afi], &lookup);
- if (!rn) return 0;
+ if (!rn)
+ return 0;
ri = rn->info;
if (ri->nhrp_ifp) {
debugf(NHRP_DEBUG_ROUTE, "lookup %s: nhrp_if=%s",
- prefix2str(&lookup, buf, sizeof buf),
- ri->nhrp_ifp->name);
+ prefix2str(&lookup, buf, sizeof buf),
+ ri->nhrp_ifp->name);
- if (via) sockunion_family(via) = AF_UNSPEC;
- if (ifp) *ifp = ri->nhrp_ifp;
+ if (via)
+ sockunion_family(via) = AF_UNSPEC;
+ if (ifp)
+ *ifp = ri->nhrp_ifp;
} else {
debugf(NHRP_DEBUG_ROUTE, "lookup %s: zebra route dev %s",
- prefix2str(&lookup, buf, sizeof buf),
- ri->ifp ? ri->ifp->name : "(none)");
+ prefix2str(&lookup, buf, sizeof buf),
+ ri->ifp ? ri->ifp->name : "(none)");
- if (via) *via = ri->via;
- if (ifp) *ifp = ri->ifp;
+ if (via)
+ *via = ri->via;
+ if (ifp)
+ *ifp = ri->ifp;
}
- if (p) *p = rn->p;
+ if (p)
+ *p = rn->p;
route_unlock_node(rn);
return 1;
}
-enum nhrp_route_type nhrp_route_address(struct interface *in_ifp, union sockunion *addr, struct prefix *p, struct nhrp_peer **peer)
+enum nhrp_route_type nhrp_route_address(struct interface *in_ifp,
+ union sockunion *addr, struct prefix *p,
+ struct nhrp_peer **peer)
{
struct interface *ifp = in_ifp;
struct nhrp_interface *nifp;
c = nhrp_cache_get(ifp, addr, 0);
if (c && c->cur.type == NHRP_CACHE_LOCAL) {
- if (p) memset(p, 0, sizeof(*p));
+ if (p)
+ memset(p, 0, sizeof(*p));
return NHRP_ROUTE_LOCAL;
}
}
if (ifp) {
/* Departing from nbma network? */
nifp = ifp->info;
- if (network_id && network_id != nifp->afi[afi].network_id)
+ if (network_id
+ && network_id != nifp->afi[afi].network_id)
return NHRP_ROUTE_OFF_NBMA;
}
if (sockunion_family(&via[i]) == AF_UNSPEC)
if (ifp) {
c = nhrp_cache_get(ifp, addr, 0);
if (c && c->cur.type >= NHRP_CACHE_DYNAMIC) {
- if (p) memset(p, 0, sizeof(*p));
+ if (p)
+ memset(p, 0, sizeof(*p));
if (c->cur.type == NHRP_CACHE_LOCAL)
return NHRP_ROUTE_LOCAL;
- if (peer) *peer = nhrp_peer_ref(c->cur.peer);
+ if (peer)
+ *peer = nhrp_peer_ref(c->cur.peer);
return NHRP_ROUTE_NBMA_NEXTHOP;
}
}
return NHRP_ROUTE_BLACKHOLE;
}
-static void
-nhrp_zebra_connected (struct zclient *zclient)
+static void nhrp_zebra_connected(struct zclient *zclient)
{
zclient_send_reg_requests(zclient, VRF_DEFAULT);
zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD, zclient, AFI_IP,
- ZEBRA_ROUTE_ALL, 0, VRF_DEFAULT);
+ ZEBRA_ROUTE_ALL, 0, VRF_DEFAULT);
zebra_redistribute_send(ZEBRA_REDISTRIBUTE_ADD, zclient, AFI_IP6,
- ZEBRA_ROUTE_ALL, 0, VRF_DEFAULT);
+ ZEBRA_ROUTE_ALL, 0, VRF_DEFAULT);
}
void nhrp_zebra_init(void)
if (s->expiring && s->cache && s->cache->used) {
debugf(NHRP_DEBUG_ROUTE, "Shortcut %s used and expiring",
- prefix2str(s->p, buf, sizeof buf));
+ prefix2str(s->p, buf, sizeof buf));
nhrp_shortcut_send_resolution_req(s);
}
}
struct nhrp_shortcut *s = THREAD_ARG(t);
s->t_timer = NULL;
- thread_add_timer(master, nhrp_shortcut_do_purge, s,
- s->holding_time / 3, &s->t_timer);
+ thread_add_timer(master, nhrp_shortcut_do_purge, s, s->holding_time / 3,
+ &s->t_timer);
s->expiring = 1;
nhrp_shortcut_check_use(s);
return 0;
}
-static void nhrp_shortcut_cache_notify(struct notifier_block *n, unsigned long cmd)
+static void nhrp_shortcut_cache_notify(struct notifier_block *n,
+ unsigned long cmd)
{
- struct nhrp_shortcut *s = container_of(n, struct nhrp_shortcut, cache_notifier);
+ struct nhrp_shortcut *s =
+ container_of(n, struct nhrp_shortcut, cache_notifier);
switch (cmd) {
case NOTIFY_CACHE_UP:
if (!s->route_installed) {
- nhrp_route_announce(1, s->type, s->p, NULL, &s->cache->remote_addr, 0);
+ nhrp_route_announce(1, s->type, s->p, NULL,
+ &s->cache->remote_addr, 0);
s->route_installed = 1;
}
break;
case NOTIFY_CACHE_DOWN:
case NOTIFY_CACHE_DELETE:
if (s->route_installed) {
- nhrp_route_announce(0, NHRP_CACHE_INVALID, s->p, NULL, NULL, 0);
+ nhrp_route_announce(0, NHRP_CACHE_INVALID, s->p, NULL,
+ NULL, 0);
s->route_installed = 0;
}
if (cmd == NOTIFY_CACHE_DELETE)
}
}
-static void nhrp_shortcut_update_binding(struct nhrp_shortcut *s, enum nhrp_cache_type type, struct nhrp_cache *c, int holding_time)
+static void nhrp_shortcut_update_binding(struct nhrp_shortcut *s,
+ enum nhrp_cache_type type,
+ struct nhrp_cache *c, int holding_time)
{
s->type = type;
if (c != s->cache) {
}
s->cache = c;
if (s->cache) {
- nhrp_cache_notify_add(s->cache, &s->cache_notifier, nhrp_shortcut_cache_notify);
+ nhrp_cache_notify_add(s->cache, &s->cache_notifier,
+ nhrp_shortcut_cache_notify);
if (s->cache->route_installed) {
- /* Force renewal of Zebra announce on prefix change */
+ /* Force renewal of Zebra announce on prefix
+ * change */
s->route_installed = 0;
- nhrp_shortcut_cache_notify(&s->cache_notifier, NOTIFY_CACHE_UP);
+ nhrp_shortcut_cache_notify(&s->cache_notifier,
+ NOTIFY_CACHE_UP);
}
}
if (!s->cache || !s->cache->route_installed)
- nhrp_shortcut_cache_notify(&s->cache_notifier, NOTIFY_CACHE_DOWN);
+ nhrp_shortcut_cache_notify(&s->cache_notifier,
+ NOTIFY_CACHE_DOWN);
}
if (s->type == NHRP_CACHE_NEGATIVE && !s->route_installed) {
nhrp_route_announce(1, s->type, s->p, NULL, NULL, 0);
nhrp_reqid_free(&nhrp_packet_reqid, &s->reqid);
debugf(NHRP_DEBUG_ROUTE, "Shortcut %s purged",
- prefix2str(s->p, buf, sizeof buf));
+ prefix2str(s->p, buf, sizeof buf));
nhrp_shortcut_update_binding(s, NHRP_CACHE_INVALID, NULL, 0);
rn = route_node_get(shortcut_rib[afi], p);
if (!rn->info) {
- s = rn->info = XCALLOC(MTYPE_NHRP_SHORTCUT, sizeof(struct nhrp_shortcut));
+ s = rn->info = XCALLOC(MTYPE_NHRP_SHORTCUT,
+ sizeof(struct nhrp_shortcut));
s->type = NHRP_CACHE_INVALID;
s->p = &rn->p;
debugf(NHRP_DEBUG_ROUTE, "Shortcut %s created",
- prefix2str(s->p, buf, sizeof buf));
+ prefix2str(s->p, buf, sizeof buf));
} else {
s = rn->info;
route_unlock_node(rn);
return s;
}
-static void nhrp_shortcut_recv_resolution_rep(struct nhrp_reqid *reqid, void *arg)
+static void nhrp_shortcut_recv_resolution_rep(struct nhrp_reqid *reqid,
+ void *arg)
{
struct nhrp_packet_parser *pp = arg;
- struct nhrp_shortcut *s = container_of(reqid, struct nhrp_shortcut, reqid);
+ struct nhrp_shortcut *s =
+ container_of(reqid, struct nhrp_shortcut, reqid);
struct nhrp_shortcut *ps;
struct nhrp_extension_header *ext;
struct nhrp_cie_header *cie;
struct nhrp_cache *c = NULL;
- union sockunion *proto, cie_proto, *nbma, *nbma_natoa, cie_nbma, nat_nbma;
+ union sockunion *proto, cie_proto, *nbma, *nbma_natoa, cie_nbma,
+ nat_nbma;
struct prefix prefix, route_prefix;
struct zbuf extpl;
char bufp[PREFIX_STRLEN], buf[3][SU_ADDRSTRLEN];
thread_add_timer(master, nhrp_shortcut_do_purge, s, 1, &s->t_timer);
if (pp->hdr->type != NHRP_PACKET_RESOLUTION_REPLY) {
- if (pp->hdr->type == NHRP_PACKET_ERROR_INDICATION &&
- pp->hdr->u.error.code == NHRP_ERROR_PROTOCOL_ADDRESS_UNREACHABLE) {
- debugf(NHRP_DEBUG_COMMON, "Shortcut: Resolution: Protocol address unreachable");
- nhrp_shortcut_update_binding(s, NHRP_CACHE_NEGATIVE, NULL, holding_time);
+ if (pp->hdr->type == NHRP_PACKET_ERROR_INDICATION
+ && pp->hdr->u.error.code
+ == NHRP_ERROR_PROTOCOL_ADDRESS_UNREACHABLE) {
+ debugf(NHRP_DEBUG_COMMON,
+ "Shortcut: Resolution: Protocol address unreachable");
+ nhrp_shortcut_update_binding(s, NHRP_CACHE_NEGATIVE,
+ NULL, holding_time);
} else {
- debugf(NHRP_DEBUG_COMMON, "Shortcut: Resolution failed");
+ debugf(NHRP_DEBUG_COMMON,
+ "Shortcut: Resolution failed");
}
return;
}
/* Minor sanity check */
prefix2sockunion(s->p, &cie_proto);
if (!sockunion_same(&cie_proto, &pp->dst_proto)) {
- debugf(NHRP_DEBUG_COMMON, "Shortcut: Warning dst_proto altered from %s to %s",
- sockunion2str(&cie_proto, buf[0], sizeof buf[0]),
- sockunion2str(&pp->dst_proto, buf[1], sizeof buf[1]));
+ debugf(NHRP_DEBUG_COMMON,
+ "Shortcut: Warning dst_proto altered from %s to %s",
+ sockunion2str(&cie_proto, buf[0], sizeof buf[0]),
+ sockunion2str(&pp->dst_proto, buf[1], sizeof buf[1]));
}
/* One or more CIEs should be given as reply, we support only one */
cie = nhrp_cie_pull(&pp->payload, pp->hdr, &cie_nbma, &cie_proto);
if (!cie || cie->code != NHRP_CODE_SUCCESS) {
- debugf(NHRP_DEBUG_COMMON, "Shortcut: CIE code %d", cie ? cie->code : -1);
+ debugf(NHRP_DEBUG_COMMON, "Shortcut: CIE code %d",
+ cie ? cie->code : -1);
return;
}
- proto = sockunion_family(&cie_proto) != AF_UNSPEC ? &cie_proto : &pp->dst_proto;
+ proto = sockunion_family(&cie_proto) != AF_UNSPEC ? &cie_proto
+ : &pp->dst_proto;
if (cie->holding_time)
holding_time = htons(cie->holding_time);
prefix.prefixlen = cie->prefix_length;
/* Sanity check prefix length */
- if (prefix.prefixlen >= 8*prefix_blen(&prefix) || prefix.prefixlen == 0) {
- prefix.prefixlen = 8*prefix_blen(&prefix);
- } else if (nhrp_route_address(NULL, &pp->dst_proto, &route_prefix, NULL) == NHRP_ROUTE_NBMA_NEXTHOP) {
+ if (prefix.prefixlen >= 8 * prefix_blen(&prefix)
+ || prefix.prefixlen == 0) {
+ prefix.prefixlen = 8 * prefix_blen(&prefix);
+ } else if (nhrp_route_address(NULL, &pp->dst_proto, &route_prefix, NULL)
+ == NHRP_ROUTE_NBMA_NEXTHOP) {
if (prefix.prefixlen < route_prefix.prefixlen)
prefix.prefixlen = route_prefix.prefixlen;
}
- debugf(NHRP_DEBUG_COMMON, "Shortcut: %s is at proto %s cie-nbma %s nat-nbma %s cie-holdtime %d",
- prefix2str(&prefix, bufp, sizeof bufp),
- sockunion2str(proto, buf[0], sizeof buf[0]),
- sockunion2str(&cie_nbma, buf[1], sizeof buf[1]),
- sockunion2str(&nat_nbma, buf[2], sizeof buf[2]),
- htons(cie->holding_time));
+ debugf(NHRP_DEBUG_COMMON,
+ "Shortcut: %s is at proto %s cie-nbma %s nat-nbma %s cie-holdtime %d",
+ prefix2str(&prefix, bufp, sizeof bufp),
+ sockunion2str(proto, buf[0], sizeof buf[0]),
+ sockunion2str(&cie_nbma, buf[1], sizeof buf[1]),
+ sockunion2str(&nat_nbma, buf[2], sizeof buf[2]),
+ htons(cie->holding_time));
/* Update cache entry for the protocol to nbma binding */
if (sockunion_family(&nat_nbma) != AF_UNSPEC) {
if (sockunion_family(nbma)) {
c = nhrp_cache_get(pp->ifp, proto, 1);
if (c) {
- nhrp_cache_update_binding(
- c, NHRP_CACHE_CACHED, holding_time,
- nhrp_peer_get(pp->ifp, nbma),
- htons(cie->mtu), nbma_natoa);
+ nhrp_cache_update_binding(c, NHRP_CACHE_CACHED,
+ holding_time,
+ nhrp_peer_get(pp->ifp, nbma),
+ htons(cie->mtu), nbma_natoa);
}
}
ps = nhrp_shortcut_get(&prefix);
if (ps) {
ps->addr = s->addr;
- nhrp_shortcut_update_binding(ps, NHRP_CACHE_CACHED, c, holding_time);
+ nhrp_shortcut_update_binding(ps, NHRP_CACHE_CACHED, c,
+ holding_time);
}
}
struct nhrp_interface *nifp;
struct nhrp_peer *peer;
- if (nhrp_route_address(NULL, &s->addr, NULL, &peer) != NHRP_ROUTE_NBMA_NEXTHOP)
+ if (nhrp_route_address(NULL, &s->addr, NULL, &peer)
+ != NHRP_ROUTE_NBMA_NEXTHOP)
return;
if (s->type == NHRP_CACHE_INVALID || s->type == NHRP_CACHE_NEGATIVE)
/* Create request */
zb = zbuf_alloc(1500);
- hdr = nhrp_packet_push(zb, NHRP_PACKET_RESOLUTION_REQUEST,
- &nifp->nbma, &nifp->afi[family2afi(sockunion_family(&s->addr))].addr, &s->addr);
- hdr->u.request_id = htonl(nhrp_reqid_alloc(&nhrp_packet_reqid, &s->reqid, nhrp_shortcut_recv_resolution_rep));
- hdr->flags = htons(NHRP_FLAG_RESOLUTION_SOURCE_IS_ROUTER |
- NHRP_FLAG_RESOLUTION_AUTHORATIVE |
- NHRP_FLAG_RESOLUTION_SOURCE_STABLE);
+ hdr = nhrp_packet_push(
+ zb, NHRP_PACKET_RESOLUTION_REQUEST, &nifp->nbma,
+ &nifp->afi[family2afi(sockunion_family(&s->addr))].addr,
+ &s->addr);
+ hdr->u.request_id =
+ htonl(nhrp_reqid_alloc(&nhrp_packet_reqid, &s->reqid,
+ nhrp_shortcut_recv_resolution_rep));
+ hdr->flags = htons(NHRP_FLAG_RESOLUTION_SOURCE_IS_ROUTER
+ | NHRP_FLAG_RESOLUTION_AUTHORATIVE
+ | NHRP_FLAG_RESOLUTION_SOURCE_STABLE);
/* RFC2332 - One or zero CIEs, if CIE is present contains:
* - Prefix length: widest acceptable prefix we accept (if U set, 0xff)
route_table_finish(shortcut_rib[AFI_IP6]);
}
-void nhrp_shortcut_foreach(afi_t afi, void (*cb)(struct nhrp_shortcut *, void *), void *ctx)
+void nhrp_shortcut_foreach(afi_t afi,
+ void (*cb)(struct nhrp_shortcut *, void *),
+ void *ctx)
{
struct route_table *rt = shortcut_rib[afi];
struct route_node *rn;
route_table_iter_t iter;
- if (!rt) return;
+ if (!rt)
+ return;
route_table_iter_init(&iter, rt);
while ((rn = route_table_iter_next(&iter)) != NULL) {
- if (rn->info) cb(rn->info, ctx);
+ if (rn->info)
+ cb(rn->info, ctx);
}
route_table_iter_cleanup(&iter);
}
void nhrp_shortcut_prefix_change(const struct prefix *p, int deleted)
{
struct purge_ctx pctx = {
- .p = p,
- .deleted = deleted,
+ .p = p, .deleted = deleted,
};
- nhrp_shortcut_foreach(family2afi(PREFIX_FAMILY(p)), nhrp_shortcut_purge_prefix, &pctx);
+ nhrp_shortcut_foreach(family2afi(PREFIX_FAMILY(p)),
+ nhrp_shortcut_purge_prefix, &pctx);
}
-
static unsigned int nhrp_vc_key(void *peer_data)
{
struct nhrp_vc *vc = peer_data;
- return jhash_2words(
- sockunion_hash(&vc->local.nbma),
- sockunion_hash(&vc->remote.nbma),
- 0);
+ return jhash_2words(sockunion_hash(&vc->local.nbma),
+ sockunion_hash(&vc->remote.nbma), 0);
}
static int nhrp_vc_cmp(const void *cache_data, const void *key_data)
{
const struct nhrp_vc *a = cache_data;
const struct nhrp_vc *b = key_data;
- return sockunion_same(&a->local.nbma, &b->local.nbma) &&
- sockunion_same(&a->remote.nbma, &b->remote.nbma);
+ return sockunion_same(&a->local.nbma, &b->local.nbma)
+ && sockunion_same(&a->remote.nbma, &b->remote.nbma);
}
static void *nhrp_vc_alloc(void *data)
vc = XMALLOC(MTYPE_NHRP_VC, sizeof(struct nhrp_vc));
if (vc) {
- *vc = (struct nhrp_vc) {
+ *vc = (struct nhrp_vc){
.local.nbma = key->local.nbma,
.remote.nbma = key->remote.nbma,
- .notifier_list = NOTIFIER_LIST_INITIALIZER(&vc->notifier_list),
+ .notifier_list =
+ NOTIFIER_LIST_INITIALIZER(&vc->notifier_list),
};
}
XFREE(MTYPE_NHRP_VC, data);
}
-struct nhrp_vc *nhrp_vc_get(const union sockunion *src, const union sockunion *dst, int create)
+struct nhrp_vc *nhrp_vc_get(const union sockunion *src,
+ const union sockunion *dst, int create)
{
struct nhrp_vc key;
key.local.nbma = *src;
uint32_t child_hash = child_id % ZEBRA_NUM_OF(childlist_head);
int abort_migration = 0;
- list_for_each_entry(lsa, &childlist_head[child_hash], childlist_entry) {
+ list_for_each_entry(lsa, &childlist_head[child_hash], childlist_entry)
+ {
if (lsa->id == child_id) {
sa = lsa;
break;
}
if (!sa) {
- if (!vc) return 0;
+ if (!vc)
+ return 0;
sa = XMALLOC(MTYPE_NHRP_VC, sizeof(struct child_sa));
- if (!sa) return 0;
+ if (!sa)
+ return 0;
- *sa = (struct child_sa) {
+ *sa = (struct child_sa){
.id = child_id,
- .childlist_entry = LIST_INITIALIZER(sa->childlist_entry),
+ .childlist_entry =
+ LIST_INITIALIZER(sa->childlist_entry),
.vc = NULL,
};
- list_add_tail(&sa->childlist_entry, &childlist_head[child_hash]);
+ list_add_tail(&sa->childlist_entry,
+ &childlist_head[child_hash]);
}
if (sa->vc == vc)
/* Notify old VC of migration */
sa->vc->abort_migration = 0;
debugf(NHRP_DEBUG_COMMON, "IPsec NBMA change of %s to %s",
- sockunion2str(&sa->vc->remote.nbma, buf[0], sizeof buf[0]),
- sockunion2str(&vc->remote.nbma, buf[1], sizeof buf[1]));
+ sockunion2str(&sa->vc->remote.nbma, buf[0],
+ sizeof buf[0]),
+ sockunion2str(&vc->remote.nbma, buf[1], sizeof buf[1]));
nhrp_vc_update(sa->vc, NOTIFY_VC_IPSEC_UPDATE_NBMA);
abort_migration = sa->vc->abort_migration;
}
if (sa->vc) {
/* Deattach old VC */
sa->vc->ipsec--;
- if (!sa->vc->ipsec) nhrp_vc_ipsec_reset(sa->vc);
+ if (!sa->vc->ipsec)
+ nhrp_vc_ipsec_reset(sa->vc);
nhrp_vc_update(sa->vc, NOTIFY_VC_IPSEC_CHANGED);
}
return abort_migration;
}
-void nhrp_vc_notify_add(struct nhrp_vc *vc, struct notifier_block *n, notifier_fn_t action)
+void nhrp_vc_notify_add(struct nhrp_vc *vc, struct notifier_block *n,
+ notifier_fn_t action)
{
notifier_add(n, &vc->notifier_list, action);
}
void nhrp_vc_foreach(void (*cb)(struct nhrp_vc *, void *), void *ctx)
{
struct nhrp_vc_iterator_ctx ic = {
- .cb = cb,
- .ctx = ctx,
+ .cb = cb, .ctx = ctx,
};
hash_iterate(nhrp_vc_hash, nhrp_vc_iterator, &ic);
}
{
size_t i;
- nhrp_vc_hash = hash_create(nhrp_vc_key,
- nhrp_vc_cmp,
- "NHRP VC hash");
+ nhrp_vc_hash = hash_create(nhrp_vc_key, nhrp_vc_cmp, "NHRP VC hash");
for (i = 0; i < ZEBRA_NUM_OF(childlist_head); i++)
list_init(&childlist_head[i]);
}
size_t i;
for (i = 0; i < ZEBRA_NUM_OF(childlist_head); i++) {
- list_for_each_entry_safe(sa, n, &childlist_head[i], childlist_entry)
+ list_for_each_entry_safe(sa, n, &childlist_head[i],
+ childlist_entry)
nhrp_vc_ipsec_updown(sa->id, 0);
}
}
#include "netlink.h"
static struct cmd_node zebra_node = {
- .node = ZEBRA_NODE,
+ .node = ZEBRA_NODE,
.prompt = "%s(config-router)# ",
- .vtysh = 1,
+ .vtysh = 1,
};
static struct cmd_node nhrp_interface_node = {
- .node = INTERFACE_NODE,
+ .node = INTERFACE_NODE,
.prompt = "%s(config-if)# ",
- .vtysh = 1,
+ .vtysh = 1,
};
#define NHRP_DEBUG_FLAGS_CMD "<all|common|event|interface|kernel|route|vici>"
-#define NHRP_DEBUG_FLAGS_STR \
- "All messages\n" \
- "Common messages (default)\n" \
- "Event manager messages\n" \
- "Interface messages\n" \
- "Kernel messages\n" \
- "Route messages\n" \
+#define NHRP_DEBUG_FLAGS_STR \
+ "All messages\n" \
+ "Common messages (default)\n" \
+ "Event manager messages\n" \
+ "Interface messages\n" \
+ "Kernel messages\n" \
+ "Route messages\n" \
"VICI messages\n"
static const struct message debug_flags_desc[] = {
- { NHRP_DEBUG_ALL, "all" },
- { NHRP_DEBUG_COMMON, "common" },
- { NHRP_DEBUG_IF, "interface" },
- { NHRP_DEBUG_KERNEL, "kernel" },
- { NHRP_DEBUG_ROUTE, "route" },
- { NHRP_DEBUG_VICI, "vici" },
- { NHRP_DEBUG_EVENT, "event" },
- { 0 }
-};
+ {NHRP_DEBUG_ALL, "all"}, {NHRP_DEBUG_COMMON, "common"},
+ {NHRP_DEBUG_IF, "interface"}, {NHRP_DEBUG_KERNEL, "kernel"},
+ {NHRP_DEBUG_ROUTE, "route"}, {NHRP_DEBUG_VICI, "vici"},
+ {NHRP_DEBUG_EVENT, "event"}, {0}};
static const struct message interface_flags_desc[] = {
- { NHRP_IFF_SHORTCUT, "shortcut" },
- { NHRP_IFF_REDIRECT, "redirect" },
- { NHRP_IFF_REG_NO_UNIQUE, "registration no-unique" },
- { 0 }
-};
+ {NHRP_IFF_SHORTCUT, "shortcut"},
+ {NHRP_IFF_REDIRECT, "redirect"},
+ {NHRP_IFF_REG_NO_UNIQUE, "registration no-unique"},
+ {0}};
static int nhrp_vty_return(struct vty *vty, int ret)
{
- static const char * const errmsgs[] = {
- [NHRP_ERR_FAIL] = "Command failed",
- [NHRP_ERR_NO_MEMORY] = "Out of memory",
- [NHRP_ERR_UNSUPPORTED_INTERFACE] = "NHRP not supported on this interface",
- [NHRP_ERR_NHRP_NOT_ENABLED] = "NHRP not enabled (set 'nhrp network-id' first)",
- [NHRP_ERR_ENTRY_EXISTS] = "Entry exists already",
- [NHRP_ERR_ENTRY_NOT_FOUND] = "Entry not found",
- [NHRP_ERR_PROTOCOL_ADDRESS_MISMATCH] = "Protocol address family does not match command (ip/ipv6 mismatch)",
+ static const char *const errmsgs[] = {
+ [NHRP_ERR_FAIL] = "Command failed",
+ [NHRP_ERR_NO_MEMORY] = "Out of memory",
+ [NHRP_ERR_UNSUPPORTED_INTERFACE] =
+ "NHRP not supported on this interface",
+ [NHRP_ERR_NHRP_NOT_ENABLED] =
+ "NHRP not enabled (set 'nhrp network-id' first)",
+ [NHRP_ERR_ENTRY_EXISTS] = "Entry exists already",
+ [NHRP_ERR_ENTRY_NOT_FOUND] = "Entry not found",
+ [NHRP_ERR_PROTOCOL_ADDRESS_MISMATCH] =
+ "Protocol address family does not match command (ip/ipv6 mismatch)",
};
const char *str = NULL;
char buf[256];
snprintf(buf, sizeof(buf), "Unknown error %d", ret);
}
- vty_out (vty, "%% %s\n", str);
+ vty_out(vty, "%% %s\n", str);
- return CMD_WARNING_CONFIG_FAILED;;
+ return CMD_WARNING_CONFIG_FAILED;
+ ;
}
-static int toggle_flag(
- struct vty *vty, const struct message *flag_desc,
- const char *name, int on_off, unsigned *flags)
+static int toggle_flag(struct vty *vty, const struct message *flag_desc,
+ const char *name, int on_off, unsigned *flags)
{
int i;
return CMD_SUCCESS;
}
- vty_out (vty, "%% Invalid value %s\n", name);
- return CMD_WARNING_CONFIG_FAILED;;
+ vty_out(vty, "%% Invalid value %s\n", name);
+ return CMD_WARNING_CONFIG_FAILED;
+ ;
}
#ifndef NO_DEBUG
{
int i;
- vty_out (vty, "NHRP debugging status:\n");
+ vty_out(vty, "NHRP debugging status:\n");
for (i = 0; debug_flags_desc[i].str != NULL; i++) {
if (debug_flags_desc[i].key == NHRP_DEBUG_ALL)
if (!(debug_flags_desc[i].key & debug_flags))
continue;
- vty_out (vty, " NHRP %s debugging is on\n",
+ vty_out(vty, " NHRP %s debugging is on\n",
debug_flags_desc[i].str);
}
"NHRP information\n"
NHRP_DEBUG_FLAGS_STR)
{
- return toggle_flag(vty, debug_flags_desc, argv[2]->text, 1, &debug_flags);
+ return toggle_flag(vty, debug_flags_desc, argv[2]->text, 1,
+ &debug_flags);
}
DEFUN(no_debug_nhrp, no_debug_nhrp_cmd,
"NHRP information\n"
NHRP_DEBUG_FLAGS_STR)
{
- return toggle_flag(vty, debug_flags_desc, argv[3]->text, 0, &debug_flags);
+ return toggle_flag(vty, debug_flags_desc, argv[3]->text, 0,
+ &debug_flags);
}
#endif /* NO_DEBUG */
{
#ifndef NO_DEBUG
if (debug_flags == NHRP_DEBUG_ALL) {
- vty_out (vty, "debug nhrp all\n");
+ vty_out(vty, "debug nhrp all\n");
} else {
int i;
continue;
if (!(debug_flags & debug_flags_desc[i].key))
continue;
- vty_out (vty, "debug nhrp %s\n",
- debug_flags_desc[i].str);
+ vty_out(vty, "debug nhrp %s\n",
+ debug_flags_desc[i].str);
}
}
- vty_out (vty, "!\n");
+ vty_out(vty, "!\n");
#endif /* NO_DEBUG */
if (nhrp_event_socket_path) {
- vty_out (vty, "nhrp event socket %s\n",
- nhrp_event_socket_path);
+ vty_out(vty, "nhrp event socket %s\n", nhrp_event_socket_path);
}
if (netlink_nflog_group) {
- vty_out (vty, "nhrp nflog-group %d\n",
- netlink_nflog_group);
+ vty_out(vty, "nhrp nflog-group %d\n", netlink_nflog_group);
}
return 0;
static const char *afi_to_cmd(afi_t afi)
{
- if (afi == AFI_IP6) return "ipv6";
+ if (afi == AFI_IP6)
+ return "ipv6";
return "ip";
}
VTY_DECLVAR_CONTEXT(interface, ifp);
nhrp_interface_set_protection(ifp, argv[4]->arg,
- argc > 6 ? argv[6]->arg : NULL);
+ argc > 6 ? argv[6]->arg : NULL);
return CMD_SUCCESS;
}
struct nhrp_interface *nifp = ifp->info;
afi_t afi = cmd_to_afi(argv[0]);
- return toggle_flag(vty, interface_flags_desc, argv[2]->text, 1, &nifp->afi[afi].flags);
+ return toggle_flag(vty, interface_flags_desc, argv[2]->text, 1,
+ &nifp->afi[afi].flags);
}
DEFUN(if_no_nhrp_flags, if_no_nhrp_flags_cmd,
struct nhrp_interface *nifp = ifp->info;
afi_t afi = cmd_to_afi(argv[1]);
- return toggle_flag(vty, interface_flags_desc, argv[3]->text, 0, &nifp->afi[afi].flags);
+ return toggle_flag(vty, interface_flags_desc, argv[3]->text, 0,
+ &nifp->afi[afi].flags);
}
DEFUN(if_nhrp_reg_flags, if_nhrp_reg_flags_cmd,
afi_t afi = cmd_to_afi(argv[0]);
char name[256];
snprintf(name, sizeof(name), "registration %s", argv[3]->text);
- return toggle_flag(vty, interface_flags_desc, name, 1, &nifp->afi[afi].flags);
+ return toggle_flag(vty, interface_flags_desc, name, 1,
+ &nifp->afi[afi].flags);
}
DEFUN(if_no_nhrp_reg_flags, if_no_nhrp_reg_flags_cmd,
afi_t afi = cmd_to_afi(argv[1]);
char name[256];
snprintf(name, sizeof(name), "registration %s", argv[4]->text);
- return toggle_flag(vty, interface_flags_desc, name, 0, &nifp->afi[afi].flags);
+ return toggle_flag(vty, interface_flags_desc, name, 0,
+ &nifp->afi[afi].flags);
}
DEFUN(if_nhrp_holdtime, if_nhrp_holdtime_cmd,
if (argv[3]->arg[0] == 'o') {
nifp->afi[AFI_IP].configured_mtu = -1;
} else {
- nifp->afi[AFI_IP].configured_mtu = strtoul(argv[3]->arg, NULL,
- 10);
+ nifp->afi[AFI_IP].configured_mtu =
+ strtoul(argv[3]->arg, NULL, 10);
}
nhrp_interface_update_mtu(ifp, AFI_IP);
union sockunion proto_addr, nbma_addr;
struct nhrp_cache *c;
- if (str2sockunion(argv[3]->arg, &proto_addr) < 0 ||
- afi2family(afi) != sockunion_family(&proto_addr))
+ if (str2sockunion(argv[3]->arg, &proto_addr) < 0
+ || afi2family(afi) != sockunion_family(&proto_addr))
return nhrp_vty_return(vty, NHRP_ERR_PROTOCOL_ADDRESS_MISMATCH);
c = nhrp_cache_get(ifp, &proto_addr, 1);
c->map = 1;
if (strmatch(argv[4]->text, "local")) {
- nhrp_cache_update_binding(c, NHRP_CACHE_LOCAL, 0, NULL, 0, NULL);
- } else{
+ nhrp_cache_update_binding(c, NHRP_CACHE_LOCAL, 0, NULL, 0,
+ NULL);
+ } else {
if (str2sockunion(argv[4]->arg, &nbma_addr) < 0)
return nhrp_vty_return(vty, NHRP_ERR_FAIL);
nhrp_cache_update_binding(c, NHRP_CACHE_STATIC, 0,
- nhrp_peer_get(ifp, &nbma_addr), 0, NULL);
+ nhrp_peer_get(ifp, &nbma_addr), 0,
+ NULL);
}
return CMD_SUCCESS;
"IPv4 protocol address\n"
"IPv6 protocol address\n")
{
- VTY_DECLVAR_CONTEXT(interface,ifp);
+ VTY_DECLVAR_CONTEXT(interface, ifp);
afi_t afi = cmd_to_afi(argv[1]);
union sockunion proto_addr;
struct nhrp_cache *c;
- if (str2sockunion(argv[4]->arg, &proto_addr) < 0 ||
- afi2family(afi) != sockunion_family(&proto_addr))
+ if (str2sockunion(argv[4]->arg, &proto_addr) < 0
+ || afi2family(afi) != sockunion_family(&proto_addr))
return nhrp_vty_return(vty, NHRP_ERR_PROTOCOL_ADDRESS_MISMATCH);
c = nhrp_cache_get(ifp, &proto_addr, 0);
return;
if (!ctx->count) {
- vty_out (vty, "%-8s %-8s %-24s %-24s %-6s %s\n",
- "Iface",
- "Type",
- "Protocol",
- "NBMA",
- "Flags",
- "Identity");
+ vty_out(vty, "%-8s %-8s %-24s %-24s %-6s %s\n", "Iface", "Type",
+ "Protocol", "NBMA", "Flags", "Identity");
}
ctx->count++;
- vty_out(ctx->vty, "%-8s %-8s %-24s %-24s %c%c%c %s\n",
- c->ifp->name,
+ vty_out(ctx->vty, "%-8s %-8s %-24s %-24s %c%c%c %s\n", c->ifp->name,
nhrp_cache_type_str[c->cur.type],
sockunion2str(&c->remote_addr, buf[0], sizeof buf[0]),
- c->cur.peer ? sockunion2str(&c->cur.peer->vc->remote.nbma, buf[1], sizeof buf[1]) : "-",
- c->used ? 'U' : ' ',
- c->t_timeout ? 'T' : ' ',
+ c->cur.peer ? sockunion2str(&c->cur.peer->vc->remote.nbma,
+ buf[1], sizeof buf[1])
+ : "-",
+ c->used ? 'U' : ' ', c->t_timeout ? 'T' : ' ',
c->t_auth ? 'A' : ' ',
c->cur.peer ? c->cur.peer->vc->remote.id : "-");
}
-static void show_ip_nhrp_nhs(struct nhrp_nhs *n, struct nhrp_registration *reg, void *pctx)
+static void show_ip_nhrp_nhs(struct nhrp_nhs *n, struct nhrp_registration *reg,
+ void *pctx)
{
struct info_ctx *ctx = pctx;
struct vty *vty = ctx->vty;
char buf[2][SU_ADDRSTRLEN];
if (!ctx->count) {
- vty_out (vty, "%-8s %-24s %-16s %-16s\n",
- "Iface",
- "FQDN",
- "NBMA",
- "Protocol");
+ vty_out(vty, "%-8s %-24s %-16s %-16s\n", "Iface", "FQDN",
+ "NBMA", "Protocol");
}
ctx->count++;
- vty_out (vty, "%-8s %-24s %-16s %-16s\n",
- n->ifp->name,
- n->nbma_fqdn,
- (reg && reg->peer) ? sockunion2str(®->peer->vc->remote.nbma,
- buf[0], sizeof buf[0])
- : "-",
- sockunion2str(reg ? ®->proto_addr : &n->proto_addr,
- buf[1], sizeof buf[1]));
+ vty_out(vty, "%-8s %-24s %-16s %-16s\n", n->ifp->name, n->nbma_fqdn,
+ (reg && reg->peer) ? sockunion2str(®->peer->vc->remote.nbma,
+ buf[0], sizeof buf[0])
+ : "-",
+ sockunion2str(reg ? ®->proto_addr : &n->proto_addr, buf[1],
+ sizeof buf[1]));
}
static void show_ip_nhrp_shortcut(struct nhrp_shortcut *s, void *pctx)
char buf1[PREFIX_STRLEN], buf2[SU_ADDRSTRLEN];
if (!ctx->count) {
- vty_out (vty, "%-8s %-24s %-24s %s\n",
- "Type",
- "Prefix",
- "Via",
+ vty_out(vty, "%-8s %-24s %-24s %s\n", "Type", "Prefix", "Via",
"Identity");
}
ctx->count++;
c = s->cache;
- vty_out(ctx->vty, "%-8s %-24s %-24s %s\n",
- nhrp_cache_type_str[s->type],
+ vty_out(ctx->vty, "%-8s %-24s %-24s %s\n", nhrp_cache_type_str[s->type],
prefix2str(s->p, buf1, sizeof buf1),
c ? sockunion2str(&c->remote_addr, buf2, sizeof buf2) : "",
(c && c->cur.peer) ? c->cur.peer->vc->remote.id : "");
return;
vty_out(ctx->vty,
- "Type: %s\n"
- "Flags:%s%s\n"
- "Protocol-Address: %s/%zu\n",
- nhrp_cache_type_str[c->cur.type],
- (c->cur.peer && c->cur.peer->online) ? " up": "",
- c->used ? " used": "",
- sockunion2str(&c->remote_addr, buf, sizeof buf),
- 8 * family2addrsize(sockunion_family(&c->remote_addr)));
+ "Type: %s\n"
+ "Flags:%s%s\n"
+ "Protocol-Address: %s/%zu\n",
+ nhrp_cache_type_str[c->cur.type],
+ (c->cur.peer && c->cur.peer->online) ? " up" : "",
+ c->used ? " used" : "",
+ sockunion2str(&c->remote_addr, buf, sizeof buf),
+ 8 * family2addrsize(sockunion_family(&c->remote_addr)));
if (c->cur.peer) {
- vty_out(ctx->vty,
- "NBMA-Address: %s\n",
- sockunion2str(&c->cur.peer->vc->remote.nbma,
- buf, sizeof buf));
+ vty_out(ctx->vty, "NBMA-Address: %s\n",
+ sockunion2str(&c->cur.peer->vc->remote.nbma, buf,
+ sizeof buf));
}
if (sockunion_family(&c->cur.remote_nbma_natoa) != AF_UNSPEC) {
- vty_out(ctx->vty,
- "NBMA-NAT-OA-Address: %s\n",
- sockunion2str(&c->cur.remote_nbma_natoa, buf, sizeof buf));
+ vty_out(ctx->vty, "NBMA-NAT-OA-Address: %s\n",
+ sockunion2str(&c->cur.remote_nbma_natoa, buf,
+ sizeof buf));
}
vty_out(ctx->vty, "\n\n");
struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
struct interface *ifp;
struct info_ctx ctx = {
- .vty = vty,
- .afi = cmd_to_afi(argv[1]),
+ .vty = vty, .afi = cmd_to_afi(argv[1]),
};
if (argc <= 3 || argv[3]->text[0] == 'c') {
} else if (argv[3]->text[0] == 's') {
nhrp_shortcut_foreach(ctx.afi, show_ip_nhrp_shortcut, &ctx);
} else {
- vty_out (vty, "Status: ok\n\n");
+ vty_out(vty, "Status: ok\n\n");
ctx.count++;
FOR_ALL_INTERFACES (vrf, ifp)
nhrp_cache_foreach(ifp, show_ip_opennhrp_cache, &ctx);
}
if (!ctx.count) {
- vty_out (vty, "%% No entries\n");
+ vty_out(vty, "%% No entries\n");
return CMD_WARNING;
}
struct vty *vty = ctx;
char buf[2][SU_ADDRSTRLEN];
- vty_out (vty, "%-24s %-24s %c %-4d %-24s\n",
+ vty_out(vty, "%-24s %-24s %c %-4d %-24s\n",
sockunion2str(&vc->local.nbma, buf[0], sizeof buf[0]),
sockunion2str(&vc->remote.nbma, buf[1], sizeof buf[1]),
- notifier_active(&vc->notifier_list) ? 'n' : ' ',
- vc->ipsec,
+ notifier_active(&vc->notifier_list) ? 'n' : ' ', vc->ipsec,
vc->remote.id);
}
SHOW_STR
"DMVPN information\n")
{
- vty_out (vty, "%-24s %-24s %-6s %-4s %-24s\n",
- "Src",
- "Dst",
- "Flags",
- "SAs",
- "Identity");
+ vty_out(vty, "%-24s %-24s %-6s %-4s %-24s\n", "Src", "Dst", "Flags",
+ "SAs", "Identity");
nhrp_vc_foreach(show_dmvpn_entry, vty);
struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
struct interface *ifp;
struct info_ctx ctx = {
- .vty = vty,
- .afi = cmd_to_afi(argv[1]),
- .count = 0,
+ .vty = vty, .afi = cmd_to_afi(argv[1]), .count = 0,
};
if (argc <= 3 || argv[3]->text[0] == 'c') {
}
if (!ctx.count) {
- vty_out (vty, "%% No entries\n");
+ vty_out(vty, "%% No entries\n");
return CMD_WARNING;
}
- vty_out (vty, "%% %d entries cleared\n", ctx.count);
+ vty_out(vty, "%% %d entries cleared\n", ctx.count);
return CMD_SUCCESS;
}
struct vty *vty = ctx->vty;
char buf[2][SU_ADDRSTRLEN];
- if (!c->map) return;
- if (sockunion_family(&c->remote_addr) != ctx->family) return;
+ if (!c->map)
+ return;
+ if (sockunion_family(&c->remote_addr) != ctx->family)
+ return;
- vty_out (vty, " %s nhrp map %s %s\n",
- ctx->aficmd,
+ vty_out(vty, " %s nhrp map %s %s\n", ctx->aficmd,
sockunion2str(&c->remote_addr, buf[0], sizeof buf[0]),
- c->cur.type == NHRP_CACHE_LOCAL ? "local" : sockunion2str(&c->cur.peer->vc->remote.nbma, buf[1], sizeof buf[1]));
+ c->cur.type == NHRP_CACHE_LOCAL
+ ? "local"
+ : sockunion2str(&c->cur.peer->vc->remote.nbma, buf[1],
+ sizeof buf[1]));
}
static int interface_config_write(struct vty *vty)
FOR_ALL_INTERFACES (vrf, ifp) {
vty_frame(vty, "interface %s\n", ifp->name);
if (ifp->desc)
- vty_out (vty, " description %s\n", ifp->desc);
+ vty_out(vty, " description %s\n", ifp->desc);
nifp = ifp->info;
if (nifp->ipsec_profile) {
if (nifp->ipsec_fallback_profile)
vty_out(vty, " fallback-profile %s",
nifp->ipsec_fallback_profile);
- vty_out (vty, "\n");
+ vty_out(vty, "\n");
}
if (nifp->source)
- vty_out (vty, " tunnel source %s\n",
- nifp->source);
+ vty_out(vty, " tunnel source %s\n", nifp->source);
for (afi = 0; afi < AFI_MAX; afi++) {
struct nhrp_afi_data *ad = &nifp->afi[afi];
aficmd = afi_to_cmd(afi);
if (ad->network_id)
- vty_out (vty, " %s nhrp network-id %u\n",
- aficmd,ad->network_id);
+ vty_out(vty, " %s nhrp network-id %u\n", aficmd,
+ ad->network_id);
if (ad->holdtime != NHRPD_DEFAULT_HOLDTIME)
- vty_out (vty, " %s nhrp holdtime %u\n",
- aficmd,ad->holdtime);
+ vty_out(vty, " %s nhrp holdtime %u\n", aficmd,
+ ad->holdtime);
if (ad->configured_mtu < 0)
- vty_out (vty, " %s nhrp mtu opennhrp\n",
- aficmd);
+ vty_out(vty, " %s nhrp mtu opennhrp\n", aficmd);
else if (ad->configured_mtu)
- vty_out (vty, " %s nhrp mtu %u\n",
- aficmd,ad->configured_mtu);
+ vty_out(vty, " %s nhrp mtu %u\n", aficmd,
+ ad->configured_mtu);
for (i = 0; interface_flags_desc[i].str != NULL; i++) {
if (!(ad->flags & interface_flags_desc[i].key))
continue;
- vty_out (vty, " %s nhrp %s\n",
- aficmd, interface_flags_desc[i].str);
+ vty_out(vty, " %s nhrp %s\n", aficmd,
+ interface_flags_desc[i].str);
}
- mapctx = (struct write_map_ctx) {
+ mapctx = (struct write_map_ctx){
.vty = vty,
.family = afi2family(afi),
.aficmd = aficmd,
};
- nhrp_cache_foreach(ifp, interface_config_write_nhrp_map, &mapctx);
+ nhrp_cache_foreach(ifp, interface_config_write_nhrp_map,
+ &mapctx);
- list_for_each_entry(nhs, &ad->nhslist_head, nhslist_entry) {
- vty_out (vty, " %s nhrp nhs %s nbma %s\n",
+ list_for_each_entry(nhs, &ad->nhslist_head,
+ nhslist_entry)
+ {
+ vty_out(vty, " %s nhrp nhs %s nbma %s\n",
aficmd,
- sockunion_family(&nhs->proto_addr) == AF_UNSPEC ? "dynamic" : sockunion2str(&nhs->proto_addr, buf, sizeof buf),
+ sockunion_family(&nhs->proto_addr)
+ == AF_UNSPEC
+ ? "dynamic"
+ : sockunion2str(
+ &nhs->proto_addr, buf,
+ sizeof buf),
nhs->nbma_fqdn);
}
}
install_default(ZEBRA_NODE);
/* access-list commands */
- access_list_init ();
+ access_list_init();
/* global commands */
install_element(VIEW_NODE, &show_debugging_nhrp_cmd);
extern struct thread_master *master;
-enum {
- NHRP_OK = 0,
- NHRP_ERR_FAIL,
- NHRP_ERR_NO_MEMORY,
- NHRP_ERR_UNSUPPORTED_INTERFACE,
- NHRP_ERR_NHRP_NOT_ENABLED,
- NHRP_ERR_ENTRY_EXISTS,
- NHRP_ERR_ENTRY_NOT_FOUND,
- NHRP_ERR_PROTOCOL_ADDRESS_MISMATCH,
- __NHRP_ERR_MAX
-};
+enum { NHRP_OK = 0,
+ NHRP_ERR_FAIL,
+ NHRP_ERR_NO_MEMORY,
+ NHRP_ERR_UNSUPPORTED_INTERFACE,
+ NHRP_ERR_NHRP_NOT_ENABLED,
+ NHRP_ERR_ENTRY_EXISTS,
+ NHRP_ERR_ENTRY_NOT_FOUND,
+ NHRP_ERR_PROTOCOL_ADDRESS_MISMATCH,
+ __NHRP_ERR_MAX };
#define NHRP_ERR_MAX (__NHRP_ERR_MAX - 1)
struct notifier_block;
struct list_head notifier_head;
};
-#define NOTIFIER_LIST_INITIALIZER(l) \
- { .notifier_head = LIST_INITIALIZER((l)->notifier_head) }
+#define NOTIFIER_LIST_INITIALIZER(l) \
+ { \
+ .notifier_head = LIST_INITIALIZER((l)->notifier_head) \
+ }
static inline void notifier_init(struct notifier_list *l)
{
list_init(&l->notifier_head);
}
-static inline void notifier_add(struct notifier_block *n, struct notifier_list *l, notifier_fn_t action)
+static inline void notifier_add(struct notifier_block *n,
+ struct notifier_list *l, notifier_fn_t action)
{
n->action = action;
list_add_tail(&n->notifier_entry, &l->notifier_head);
};
void resolver_init(void);
-void resolver_resolve(struct resolver_query *query, int af, const char *hostname, void (*cb)(struct resolver_query *, int, union sockunion *));
+void resolver_resolve(struct resolver_query *query, int af,
+ const char *hostname, void (*cb)(struct resolver_query *,
+ int, union sockunion *));
void nhrp_zebra_init(void);
void nhrp_zebra_terminate(void);
NHRP_CACHE_NUM_TYPES
};
-extern const char * const nhrp_cache_type_str[];
+extern const char *const nhrp_cache_type_str[];
extern unsigned long nhrp_cache_counts[NHRP_CACHE_NUM_TYPES];
struct nhrp_cache {
unsigned hub : 1;
afi_t afi;
union sockunion proto_addr;
- const char *nbma_fqdn; /* IP-address or FQDN */
+ const char *nbma_fqdn; /* IP-address or FQDN */
struct thread *t_resolve;
struct resolver_query dns_resolve;
void nhrp_interface_update(struct interface *ifp);
void nhrp_interface_update_mtu(struct interface *ifp, afi_t afi);
-int nhrp_interface_add(int cmd, struct zclient *client, zebra_size_t length, vrf_id_t vrf_id);
-int nhrp_interface_delete(int cmd, struct zclient *client, zebra_size_t length, vrf_id_t vrf_id);
-int nhrp_interface_up(int cmd, struct zclient *client, zebra_size_t length, vrf_id_t vrf_id);
-int nhrp_interface_down(int cmd, struct zclient *client, zebra_size_t length, vrf_id_t vrf_id);
-int nhrp_interface_address_add(int cmd, struct zclient *client, zebra_size_t length, vrf_id_t vrf_id);
-int nhrp_interface_address_delete(int cmd, struct zclient *client, zebra_size_t length, vrf_id_t vrf_id);
-
-void nhrp_interface_notify_add(struct interface *ifp, struct notifier_block *n, notifier_fn_t fn);
+int nhrp_interface_add(int cmd, struct zclient *client, zebra_size_t length,
+ vrf_id_t vrf_id);
+int nhrp_interface_delete(int cmd, struct zclient *client, zebra_size_t length,
+ vrf_id_t vrf_id);
+int nhrp_interface_up(int cmd, struct zclient *client, zebra_size_t length,
+ vrf_id_t vrf_id);
+int nhrp_interface_down(int cmd, struct zclient *client, zebra_size_t length,
+ vrf_id_t vrf_id);
+int nhrp_interface_address_add(int cmd, struct zclient *client,
+ zebra_size_t length, vrf_id_t vrf_id);
+int nhrp_interface_address_delete(int cmd, struct zclient *client,
+ zebra_size_t length, vrf_id_t vrf_id);
+
+void nhrp_interface_notify_add(struct interface *ifp, struct notifier_block *n,
+ notifier_fn_t fn);
void nhrp_interface_notify_del(struct interface *ifp, struct notifier_block *n);
-void nhrp_interface_set_protection(struct interface *ifp, const char *profile, const char *fallback_profile);
+void nhrp_interface_set_protection(struct interface *ifp, const char *profile,
+ const char *fallback_profile);
void nhrp_interface_set_source(struct interface *ifp, const char *ifname);
-int nhrp_nhs_add(struct interface *ifp, afi_t afi, union sockunion *proto_addr, const char *nbma_fqdn);
-int nhrp_nhs_del(struct interface *ifp, afi_t afi, union sockunion *proto_addr, const char *nbma_fqdn);
+int nhrp_nhs_add(struct interface *ifp, afi_t afi, union sockunion *proto_addr,
+ const char *nbma_fqdn);
+int nhrp_nhs_del(struct interface *ifp, afi_t afi, union sockunion *proto_addr,
+ const char *nbma_fqdn);
int nhrp_nhs_free(struct nhrp_nhs *nhs);
void nhrp_nhs_terminate(void);
-void nhrp_nhs_foreach(struct interface *ifp, afi_t afi, void (*cb)(struct nhrp_nhs *, struct nhrp_registration *, void *), void *ctx);
+void nhrp_nhs_foreach(struct interface *ifp, afi_t afi,
+ void (*cb)(struct nhrp_nhs *, struct nhrp_registration *,
+ void *),
+ void *ctx);
void nhrp_route_update_nhrp(const struct prefix *p, struct interface *ifp);
-void nhrp_route_announce(int add, enum nhrp_cache_type type, const struct prefix *p, struct interface *ifp, const union sockunion *nexthop, uint32_t mtu);
-int nhrp_route_read(int command, struct zclient *zclient, zebra_size_t length, vrf_id_t vrf_id);
-int nhrp_route_get_nexthop(const union sockunion *addr, struct prefix *p, union sockunion *via, struct interface **ifp);
-enum nhrp_route_type nhrp_route_address(struct interface *in_ifp, union sockunion *addr, struct prefix *p, struct nhrp_peer **peer);
+void nhrp_route_announce(int add, enum nhrp_cache_type type,
+ const struct prefix *p, struct interface *ifp,
+ const union sockunion *nexthop, uint32_t mtu);
+int nhrp_route_read(int command, struct zclient *zclient, zebra_size_t length,
+ vrf_id_t vrf_id);
+int nhrp_route_get_nexthop(const union sockunion *addr, struct prefix *p,
+ union sockunion *via, struct interface **ifp);
+enum nhrp_route_type nhrp_route_address(struct interface *in_ifp,
+ union sockunion *addr, struct prefix *p,
+ struct nhrp_peer **peer);
void nhrp_config_init(void);
void nhrp_shortcut_init(void);
void nhrp_shortcut_terminate(void);
void nhrp_shortcut_initiate(union sockunion *addr);
-void nhrp_shortcut_foreach(afi_t afi, void (*cb)(struct nhrp_shortcut *, void *), void *ctx);
+void nhrp_shortcut_foreach(afi_t afi,
+ void (*cb)(struct nhrp_shortcut *, void *),
+ void *ctx);
void nhrp_shortcut_purge(struct nhrp_shortcut *s, int force);
void nhrp_shortcut_prefix_change(const struct prefix *p, int deleted);
-struct nhrp_cache *nhrp_cache_get(struct interface *ifp, union sockunion *remote_addr, int create);
-void nhrp_cache_foreach(struct interface *ifp, void (*cb)(struct nhrp_cache *, void *), void *ctx);
+struct nhrp_cache *nhrp_cache_get(struct interface *ifp,
+ union sockunion *remote_addr, int create);
+void nhrp_cache_foreach(struct interface *ifp,
+ void (*cb)(struct nhrp_cache *, void *), void *ctx);
void nhrp_cache_set_used(struct nhrp_cache *, int);
-int nhrp_cache_update_binding(struct nhrp_cache *, enum nhrp_cache_type type, int holding_time, struct nhrp_peer *p, uint32_t mtu, union sockunion *nbma_natoa);
-void nhrp_cache_notify_add(struct nhrp_cache *c, struct notifier_block *, notifier_fn_t);
+int nhrp_cache_update_binding(struct nhrp_cache *, enum nhrp_cache_type type,
+ int holding_time, struct nhrp_peer *p,
+ uint32_t mtu, union sockunion *nbma_natoa);
+void nhrp_cache_notify_add(struct nhrp_cache *c, struct notifier_block *,
+ notifier_fn_t);
void nhrp_cache_notify_del(struct nhrp_cache *c, struct notifier_block *);
void nhrp_vc_init(void);
void nhrp_vc_terminate(void);
-struct nhrp_vc *nhrp_vc_get(const union sockunion *src, const union sockunion *dst, int create);
+struct nhrp_vc *nhrp_vc_get(const union sockunion *src,
+ const union sockunion *dst, int create);
int nhrp_vc_ipsec_updown(uint32_t child_id, struct nhrp_vc *vc);
-void nhrp_vc_notify_add(struct nhrp_vc *, struct notifier_block *, notifier_fn_t);
+void nhrp_vc_notify_add(struct nhrp_vc *, struct notifier_block *,
+ notifier_fn_t);
void nhrp_vc_notify_del(struct nhrp_vc *, struct notifier_block *);
void nhrp_vc_foreach(void (*cb)(struct nhrp_vc *, void *), void *ctx);
void nhrp_vc_reset(void);
void vici_init(void);
void vici_terminate(void);
-void vici_request_vc(const char *profile, union sockunion *src, union sockunion *dst, int prio);
+void vici_request_vc(const char *profile, union sockunion *src,
+ union sockunion *dst, int prio);
extern const char *nhrp_event_socket_path;
void evmgr_init(void);
void evmgr_terminate(void);
void evmgr_set_socket(const char *socket);
-void evmgr_notify(const char *name, struct nhrp_cache *c, void (*cb)(struct nhrp_reqid *, void *));
+void evmgr_notify(const char *name, struct nhrp_cache *c,
+ void (*cb)(struct nhrp_reqid *, void *));
-struct nhrp_packet_header *nhrp_packet_push(
- struct zbuf *zb, uint8_t type,
- const union sockunion *src_nbma,
- const union sockunion *src_proto,
- const union sockunion *dst_proto);
+struct nhrp_packet_header *nhrp_packet_push(struct zbuf *zb, uint8_t type,
+ const union sockunion *src_nbma,
+ const union sockunion *src_proto,
+ const union sockunion *dst_proto);
void nhrp_packet_complete(struct zbuf *zb, struct nhrp_packet_header *hdr);
uint16_t nhrp_packet_calculate_checksum(const uint8_t *pdu, uint16_t len);
-struct nhrp_packet_header *nhrp_packet_pull(
- struct zbuf *zb,
- union sockunion *src_nbma,
- union sockunion *src_proto,
- union sockunion *dst_proto);
-
-struct nhrp_cie_header *nhrp_cie_push(
- struct zbuf *zb, uint8_t code,
- const union sockunion *nbma,
- const union sockunion *proto);
-struct nhrp_cie_header *nhrp_cie_pull(
- struct zbuf *zb,
- struct nhrp_packet_header *hdr,
- union sockunion *nbma,
- union sockunion *proto);
-
-struct nhrp_extension_header *nhrp_ext_push(struct zbuf *zb, struct nhrp_packet_header *hdr, uint16_t type);
+struct nhrp_packet_header *nhrp_packet_pull(struct zbuf *zb,
+ union sockunion *src_nbma,
+ union sockunion *src_proto,
+ union sockunion *dst_proto);
+
+struct nhrp_cie_header *nhrp_cie_push(struct zbuf *zb, uint8_t code,
+ const union sockunion *nbma,
+ const union sockunion *proto);
+struct nhrp_cie_header *nhrp_cie_pull(struct zbuf *zb,
+ struct nhrp_packet_header *hdr,
+ union sockunion *nbma,
+ union sockunion *proto);
+
+struct nhrp_extension_header *
+nhrp_ext_push(struct zbuf *zb, struct nhrp_packet_header *hdr, uint16_t type);
void nhrp_ext_complete(struct zbuf *zb, struct nhrp_extension_header *ext);
-struct nhrp_extension_header *nhrp_ext_pull(struct zbuf *zb, struct zbuf *payload);
-void nhrp_ext_request(struct zbuf *zb, struct nhrp_packet_header *hdr, struct interface *);
-int nhrp_ext_reply(struct zbuf *zb, struct nhrp_packet_header *hdr, struct interface *ifp, struct nhrp_extension_header *ext, struct zbuf *extpayload);
-
-uint32_t nhrp_reqid_alloc(struct nhrp_reqid_pool *, struct nhrp_reqid *r, void (*cb)(struct nhrp_reqid *, void *));
+struct nhrp_extension_header *nhrp_ext_pull(struct zbuf *zb,
+ struct zbuf *payload);
+void nhrp_ext_request(struct zbuf *zb, struct nhrp_packet_header *hdr,
+ struct interface *);
+int nhrp_ext_reply(struct zbuf *zb, struct nhrp_packet_header *hdr,
+ struct interface *ifp, struct nhrp_extension_header *ext,
+ struct zbuf *extpayload);
+
+uint32_t nhrp_reqid_alloc(struct nhrp_reqid_pool *, struct nhrp_reqid *r,
+ void (*cb)(struct nhrp_reqid *, void *));
void nhrp_reqid_free(struct nhrp_reqid_pool *, struct nhrp_reqid *r);
struct nhrp_reqid *nhrp_reqid_lookup(struct nhrp_reqid_pool *, uint32_t reqid);
int nhrp_packet_init(void);
-struct nhrp_peer *nhrp_peer_get(struct interface *ifp, const union sockunion *remote_nbma);
+struct nhrp_peer *nhrp_peer_get(struct interface *ifp,
+ const union sockunion *remote_nbma);
struct nhrp_peer *nhrp_peer_ref(struct nhrp_peer *p);
void nhrp_peer_unref(struct nhrp_peer *p);
int nhrp_peer_check(struct nhrp_peer *p, int establish);
-void nhrp_peer_notify_add(struct nhrp_peer *p, struct notifier_block *, notifier_fn_t);
+void nhrp_peer_notify_add(struct nhrp_peer *p, struct notifier_block *,
+ notifier_fn_t);
void nhrp_peer_notify_del(struct nhrp_peer *p, struct notifier_block *);
void nhrp_peer_recv(struct nhrp_peer *p, struct zbuf *zb);
void nhrp_peer_send(struct nhrp_peer *p, struct zbuf *zb);
int os_socket(void);
-int os_sendmsg(const uint8_t *buf, size_t len, int ifindex, const uint8_t *addr, size_t addrlen);
-int os_recvmsg(uint8_t *buf, size_t *len, int *ifindex, uint8_t *addr, size_t *addrlen);
+int os_sendmsg(const uint8_t *buf, size_t len, int ifindex, const uint8_t *addr,
+ size_t addrlen);
+int os_recvmsg(uint8_t *buf, size_t *len, int *ifindex, uint8_t *addr,
+ size_t *addrlen);
int os_configure_dmvpn(unsigned int ifindex, const char *ifname, int af);
return a->request_id == b->request_id;
}
-uint32_t nhrp_reqid_alloc(struct nhrp_reqid_pool *p, struct nhrp_reqid *r, void (*cb)(struct nhrp_reqid *, void *))
+uint32_t nhrp_reqid_alloc(struct nhrp_reqid_pool *p, struct nhrp_reqid *r,
+ void (*cb)(struct nhrp_reqid *, void *))
{
if (!p->reqid_hash) {
- p->reqid_hash = hash_create(nhrp_reqid_key,
- nhrp_reqid_cmp,
+ p->reqid_hash = hash_create(nhrp_reqid_key, nhrp_reqid_cmp,
"NHRP reqid Hash");
p->next_request_id = 1;
}
if (r->cb != cb) {
r->request_id = p->next_request_id;
- if (++p->next_request_id == 0) p->next_request_id = 1;
+ if (++p->next_request_id == 0)
+ p->next_request_id = 1;
r->cb = cb;
hash_get(p->reqid_hash, r, hash_alloc_intern);
}
struct nhrp_reqid *nhrp_reqid_lookup(struct nhrp_reqid_pool *p, uint32_t reqid)
{
struct nhrp_reqid key;
- if (!p->reqid_hash) return 0;
+ if (!p->reqid_hash)
+ return 0;
key.request_id = reqid;
return hash_lookup(p->reqid_hash, &key);
}
-
-
ares_process_fd(r->channel, fd, ARES_SOCKET_BAD);
if (vector_lookup(r->read_threads, fd) == THREAD_RUNNING) {
t = NULL;
- thread_add_read(master, resolver_cb_socket_readable, r, fd,
- &t);
+ thread_add_read(master, resolver_cb_socket_readable, r, fd, &t);
vector_set_index(r->read_threads, fd, t);
}
resolver_update_timeouts(r);
{
struct timeval *tv, tvbuf;
- if (r->timeout == THREAD_RUNNING) return;
+ if (r->timeout == THREAD_RUNNING)
+ return;
THREAD_OFF(r->timeout);
tv = ares_timeout(r->channel, NULL, &tvbuf);
if (tv) {
unsigned int timeoutms = tv->tv_sec * 1000 + tv->tv_usec / 1000;
- thread_add_timer_msec(master, resolver_cb_timeout, r,
- timeoutms, &r->timeout);
+ thread_add_timer_msec(master, resolver_cb_timeout, r, timeoutms,
+ &r->timeout);
}
}
-static void ares_socket_cb(void *data, ares_socket_t fd, int readable, int writable)
+static void ares_socket_cb(void *data, ares_socket_t fd, int readable,
+ int writable)
{
- struct resolver_state *r = (struct resolver_state *) data;
+ struct resolver_state *r = (struct resolver_state *)data;
struct thread *t;
if (readable) {
t = vector_lookup_ensure(r->read_threads, fd);
if (!t) {
- thread_add_read(master, resolver_cb_socket_readable,
- r, fd, &t);
+ thread_add_read(master, resolver_cb_socket_readable, r,
+ fd, &t);
vector_set_index(r->read_threads, fd, t);
}
} else {
if (writable) {
t = vector_lookup_ensure(r->write_threads, fd);
if (!t) {
- thread_add_read(master, resolver_cb_socket_writable,
- r, fd, &t);
+ thread_add_read(master, resolver_cb_socket_writable, r,
+ fd, &t);
vector_set_index(r->write_threads, fd, t);
}
} else {
state.read_threads = vector_init(1);
state.write_threads = vector_init(1);
- ares_opts = (struct ares_options) {
+ ares_opts = (struct ares_options){
.sock_state_cb = &ares_socket_cb,
.sock_state_cb_data = &state,
.timeout = 2,
};
ares_init_options(&state.channel, &ares_opts,
- ARES_OPT_SOCK_STATE_CB | ARES_OPT_TIMEOUT |
- ARES_OPT_TRIES);
+ ARES_OPT_SOCK_STATE_CB | ARES_OPT_TIMEOUT
+ | ARES_OPT_TRIES);
}
-static void ares_address_cb(void *arg, int status, int timeouts, struct hostent *he)
+static void ares_address_cb(void *arg, int status, int timeouts,
+ struct hostent *he)
{
- struct resolver_query *query = (struct resolver_query *) arg;
+ struct resolver_query *query = (struct resolver_query *)arg;
union sockunion addr[16];
size_t i;
addr[i].sa.sa_family = he->h_addrtype;
switch (he->h_addrtype) {
case AF_INET:
- memcpy(&addr[i].sin.sin_addr, (uint8_t *) he->h_addr_list[i], he->h_length);
+ memcpy(&addr[i].sin.sin_addr,
+ (uint8_t *)he->h_addr_list[i], he->h_length);
break;
case AF_INET6:
- memcpy(&addr[i].sin6.sin6_addr, (uint8_t *) he->h_addr_list[i], he->h_length);
+ memcpy(&addr[i].sin6.sin6_addr,
+ (uint8_t *)he->h_addr_list[i], he->h_length);
break;
}
}
- debugf(NHRP_DEBUG_COMMON, "[%p] Resolved with %d results", query, (int) i);
+ debugf(NHRP_DEBUG_COMMON, "[%p] Resolved with %d results", query,
+ (int)i);
query->callback(query, i, &addr[0]);
query->callback = NULL;
}
-void resolver_resolve(struct resolver_query *query, int af, const char *hostname, void (*callback)(struct resolver_query *, int, union sockunion *))
+void resolver_resolve(struct resolver_query *query, int af,
+ const char *hostname,
+ void (*callback)(struct resolver_query *, int,
+ union sockunion *))
{
if (query->callback != NULL) {
- zlog_err("Trying to resolve '%s', but previous query was not finished yet", hostname);
+ zlog_err(
+ "Trying to resolve '%s', but previous query was not finished yet",
+ hostname);
return;
}
static int blob_equal(const struct blob *b, const char *str)
{
- if (!b || b->len != (int) strlen(str)) return 0;
+ if (!b || b->len != (int)strlen(str))
+ return 0;
return memcmp(b->ptr, str, b->len) == 0;
}
static int blob2buf(const struct blob *b, char *buf, size_t n)
{
- if (!b || b->len >= (int) n) return 0;
+ if (!b || b->len >= (int)n)
+ return 0;
memcpy(buf, b->ptr, b->len);
buf[b->len] = 0;
return 1;
thread_add_timer(master, vici_reconnect, vici, 2, &vici->t_reconnect);
}
-static void vici_parse_message(
- struct vici_conn *vici, struct zbuf *msg,
- void (*parser)(struct vici_message_ctx *ctx, enum vici_type_t msgtype, const struct blob *key, const struct blob *val),
- struct vici_message_ctx *ctx)
+static void vici_parse_message(struct vici_conn *vici, struct zbuf *msg,
+ void (*parser)(struct vici_message_ctx *ctx,
+ enum vici_type_t msgtype,
+ const struct blob *key,
+ const struct blob *val),
+ struct vici_message_ctx *ctx)
{
uint8_t *type;
- struct blob key = { 0 };
- struct blob val = { 0 };
+ struct blob key = {0};
+ struct blob val = {0};
while ((type = zbuf_may_pull(msg, uint8_t)) != NULL) {
switch (*type) {
case VICI_SECTION_START:
key.len = zbuf_get8(msg);
key.ptr = zbuf_pulln(msg, key.len);
- debugf(NHRP_DEBUG_VICI, "VICI: Section start '%.*s'", key.len, key.ptr);
+ debugf(NHRP_DEBUG_VICI, "VICI: Section start '%.*s'",
+ key.len, key.ptr);
parser(ctx, *type, &key, NULL);
ctx->nsections++;
break;
key.ptr = zbuf_pulln(msg, key.len);
val.len = zbuf_get_be16(msg);
val.ptr = zbuf_pulln(msg, val.len);
- debugf(NHRP_DEBUG_VICI, "VICI: Key '%.*s'='%.*s'", key.len, key.ptr, val.len, val.ptr);
+ debugf(NHRP_DEBUG_VICI, "VICI: Key '%.*s'='%.*s'",
+ key.len, key.ptr, val.len, val.ptr);
parser(ctx, *type, &key, &val);
break;
case VICI_LIST_START:
key.len = zbuf_get8(msg);
key.ptr = zbuf_pulln(msg, key.len);
- debugf(NHRP_DEBUG_VICI, "VICI: List start '%.*s'", key.len, key.ptr);
+ debugf(NHRP_DEBUG_VICI, "VICI: List start '%.*s'",
+ key.len, key.ptr);
break;
case VICI_LIST_ITEM:
val.len = zbuf_get_be16(msg);
val.ptr = zbuf_pulln(msg, val.len);
- debugf(NHRP_DEBUG_VICI, "VICI: List item: '%.*s'", val.len, val.ptr);
+ debugf(NHRP_DEBUG_VICI, "VICI: List item: '%.*s'",
+ val.len, val.ptr);
parser(ctx, *type, &key, &val);
break;
case VICI_LIST_END:
debugf(NHRP_DEBUG_VICI, "VICI: List end");
break;
default:
- debugf(NHRP_DEBUG_VICI, "VICI: Unsupported message component type %d", *type);
+ debugf(NHRP_DEBUG_VICI,
+ "VICI: Unsupported message component type %d",
+ *type);
return;
}
}
} local, remote;
};
-static void parse_sa_message(
- struct vici_message_ctx *ctx,
- enum vici_type_t msgtype,
- const struct blob *key, const struct blob *val)
+static void parse_sa_message(struct vici_message_ctx *ctx,
+ enum vici_type_t msgtype, const struct blob *key,
+ const struct blob *val)
{
- struct handle_sa_ctx *sactx = container_of(ctx, struct handle_sa_ctx, msgctx);
+ struct handle_sa_ctx *sactx =
+ container_of(ctx, struct handle_sa_ctx, msgctx);
struct nhrp_vc *vc;
char buf[512];
/* End of child-sa section, update nhrp_vc */
int up = sactx->child_ok || sactx->event == 1;
if (up) {
- vc = nhrp_vc_get(&sactx->local.host, &sactx->remote.host, up);
+ vc = nhrp_vc_get(&sactx->local.host,
+ &sactx->remote.host, up);
if (vc) {
- blob2buf(&sactx->local.id, vc->local.id, sizeof(vc->local.id));
- if (blob2buf(&sactx->local.cert, (char*)vc->local.cert, sizeof(vc->local.cert)))
- vc->local.certlen = sactx->local.cert.len;
- blob2buf(&sactx->remote.id, vc->remote.id, sizeof(vc->remote.id));
- if (blob2buf(&sactx->remote.cert, (char*)vc->remote.cert, sizeof(vc->remote.cert)))
- vc->remote.certlen = sactx->remote.cert.len;
- sactx->kill_ikesa |= nhrp_vc_ipsec_updown(sactx->child_uniqueid, vc);
+ blob2buf(&sactx->local.id, vc->local.id,
+ sizeof(vc->local.id));
+ if (blob2buf(&sactx->local.cert,
+ (char *)vc->local.cert,
+ sizeof(vc->local.cert)))
+ vc->local.certlen =
+ sactx->local.cert.len;
+ blob2buf(&sactx->remote.id,
+ vc->remote.id,
+ sizeof(vc->remote.id));
+ if (blob2buf(&sactx->remote.cert,
+ (char *)vc->remote.cert,
+ sizeof(vc->remote.cert)))
+ vc->remote.certlen =
+ sactx->remote.cert.len;
+ sactx->kill_ikesa |=
+ nhrp_vc_ipsec_updown(
+ sactx->child_uniqueid,
+ vc);
}
} else {
nhrp_vc_ipsec_updown(sactx->child_uniqueid, 0);
switch (key->ptr[0]) {
case 'l':
- if (blob_equal(key, "local-host") && ctx->nsections == 1) {
+ if (blob_equal(key, "local-host")
+ && ctx->nsections == 1) {
if (blob2buf(val, buf, sizeof(buf)))
- if (str2sockunion(buf, &sactx->local.host) < 0)
- zlog_err("VICI: bad strongSwan local-host: %s", buf);
- } else if (blob_equal(key, "local-id") && ctx->nsections == 1) {
+ if (str2sockunion(buf,
+ &sactx->local.host)
+ < 0)
+ zlog_err(
+ "VICI: bad strongSwan local-host: %s",
+ buf);
+ } else if (blob_equal(key, "local-id")
+ && ctx->nsections == 1) {
sactx->local.id = *val;
- } else if (blob_equal(key, "local-cert-data") && ctx->nsections == 1) {
+ } else if (blob_equal(key, "local-cert-data")
+ && ctx->nsections == 1) {
sactx->local.cert = *val;
}
break;
case 'r':
- if (blob_equal(key, "remote-host") && ctx->nsections == 1) {
+ if (blob_equal(key, "remote-host")
+ && ctx->nsections == 1) {
if (blob2buf(val, buf, sizeof(buf)))
- if (str2sockunion(buf, &sactx->remote.host) < 0)
- zlog_err("VICI: bad strongSwan remote-host: %s", buf);
- } else if (blob_equal(key, "remote-id") && ctx->nsections == 1) {
+ if (str2sockunion(buf,
+ &sactx->remote.host)
+ < 0)
+ zlog_err(
+ "VICI: bad strongSwan remote-host: %s",
+ buf);
+ } else if (blob_equal(key, "remote-id")
+ && ctx->nsections == 1) {
sactx->remote.id = *val;
- } else if (blob_equal(key, "remote-cert-data") && ctx->nsections == 1) {
+ } else if (blob_equal(key, "remote-cert-data")
+ && ctx->nsections == 1) {
sactx->remote.cert = *val;
}
break;
case 'u':
- if (blob_equal(key, "uniqueid") && blob2buf(val, buf, sizeof(buf))) {
+ if (blob_equal(key, "uniqueid")
+ && blob2buf(val, buf, sizeof(buf))) {
if (ctx->nsections == 3)
- sactx->child_uniqueid = strtoul(buf, NULL, 0);
+ sactx->child_uniqueid =
+ strtoul(buf, NULL, 0);
else if (ctx->nsections == 1)
- sactx->ike_uniqueid = strtoul(buf, NULL, 0);
+ sactx->ike_uniqueid =
+ strtoul(buf, NULL, 0);
}
break;
case 's':
if (blob_equal(key, "state") && ctx->nsections == 3) {
sactx->child_ok =
- (sactx->event == 0 &&
- (blob_equal(val, "INSTALLED") ||
- blob_equal(val, "REKEYED")));
+ (sactx->event == 0
+ && (blob_equal(val, "INSTALLED")
+ || blob_equal(val, "REKEYED")));
}
break;
}
}
}
-static void parse_cmd_response(
- struct vici_message_ctx *ctx,
- enum vici_type_t msgtype,
- const struct blob *key, const struct blob *val)
+static void parse_cmd_response(struct vici_message_ctx *ctx,
+ enum vici_type_t msgtype, const struct blob *key,
+ const struct blob *val)
{
char buf[512];
switch (msgtype) {
case VICI_KEY_VALUE:
- if (blob_equal(key, "errmsg") && blob2buf(val, buf, sizeof(buf)))
+ if (blob_equal(key, "errmsg")
+ && blob2buf(val, buf, sizeof(buf)))
zlog_err("VICI: strongSwan: %s", buf);
break;
default:
vici_parse_message(vici, msg, parse_sa_message, &ctx.msgctx);
if (ctx.kill_ikesa && ctx.ike_uniqueid) {
- debugf(NHRP_DEBUG_COMMON, "VICI: Deleting IKE_SA %u", ctx.ike_uniqueid);
+ debugf(NHRP_DEBUG_COMMON, "VICI: Deleting IKE_SA %u",
+ ctx.ike_uniqueid);
snprintf(buf, sizeof buf, "%u", ctx.ike_uniqueid);
- vici_submit_request(
- vici, "terminate",
- VICI_KEY_VALUE, "ike-id", strlen(buf), buf,
- VICI_END);
+ vici_submit_request(vici, "terminate", VICI_KEY_VALUE, "ike-id",
+ strlen(buf), buf, VICI_END);
}
}
name.len = zbuf_get8(msg);
name.ptr = zbuf_pulln(msg, name.len);
- debugf(NHRP_DEBUG_VICI, "VICI: Event '%.*s'", name.len, name.ptr);
- if (blob_equal(&name, "list-sa") ||
- blob_equal(&name, "child-updown") ||
- blob_equal(&name, "child-rekey"))
+ debugf(NHRP_DEBUG_VICI, "VICI: Event '%.*s'", name.len,
+ name.ptr);
+ if (blob_equal(&name, "list-sa")
+ || blob_equal(&name, "child-updown")
+ || blob_equal(&name, "child-rekey"))
vici_recv_sa(vici, msg, 0);
- else if (blob_equal(&name, "child-state-installed") ||
- blob_equal(&name, "child-state-rekeyed"))
+ else if (blob_equal(&name, "child-state-installed")
+ || blob_equal(&name, "child-state-rekeyed"))
vici_recv_sa(vici, msg, 1);
else if (blob_equal(&name, "child-state-destroying"))
vici_recv_sa(vici, msg, 2);
break;
case VICI_EVENT_UNKNOWN:
case VICI_CMD_UNKNOWN:
- zlog_err("VICI: StrongSwan does not support mandatory events (unpatched?)");
+ zlog_err(
+ "VICI: StrongSwan does not support mandatory events (unpatched?)");
break;
case VICI_EVENT_CONFIRM:
break;
struct zbuf pktbuf;
vici->t_read = NULL;
- if (zbuf_read(ibuf, vici->fd, (size_t) -1) < 0) {
+ if (zbuf_read(ibuf, vici->fd, (size_t)-1) < 0) {
vici_connection_error(vici);
return 0;
}
}
/* Handle packet */
- zbuf_init(&pktbuf, hdrlen, htonl(*hdrlen)+4, htonl(*hdrlen)+4);
+ zbuf_init(&pktbuf, hdrlen, htonl(*hdrlen) + 4,
+ htonl(*hdrlen) + 4);
vici_recv_message(vici, &pktbuf);
} while (1);
int type;
obuf = zbuf_alloc(256);
- if (!obuf) return;
+ if (!obuf)
+ return;
hdrlen = zbuf_push(obuf, uint32_t);
zbuf_put8(obuf, VICI_CMD_REQUEST);
namelen = strlen(name);
obuf = zbuf_alloc(4 + 1 + 1 + namelen);
- if (!obuf) return;
+ if (!obuf)
+ return;
hdrlen = zbuf_push(obuf, uint32_t);
zbuf_put8(obuf, VICI_EVENT_REGISTER);
int fd;
vici->t_reconnect = NULL;
- if (vici->fd >= 0) return 0;
+ if (vici->fd >= 0)
+ return 0;
fd = sock_open_unix("/var/run/charon.vici");
if (fd < 0) {
- debugf(NHRP_DEBUG_VICI, "%s: failure connecting VICI socket: %s",
- __PRETTY_FUNCTION__, strerror(errno));
+ debugf(NHRP_DEBUG_VICI,
+ "%s: failure connecting VICI socket: %s",
+ __PRETTY_FUNCTION__, strerror(errno));
thread_add_timer(master, vici_reconnect, vici, 2,
&vici->t_reconnect);
return 0;
thread_add_read(master, vici_read, vici, vici->fd, &vici->t_read);
/* Send event subscribtions */
- //vici_register_event(vici, "child-updown");
- //vici_register_event(vici, "child-rekey");
+ // vici_register_event(vici, "child-updown");
+ // vici_register_event(vici, "child-rekey");
vici_register_event(vici, "child-state-installed");
vici_register_event(vici, "child-state-rekeyed");
vici_register_event(vici, "child-state-destroying");
{
}
-void vici_request_vc(const char *profile, union sockunion *src, union sockunion *dst, int prio)
+void vici_request_vc(const char *profile, union sockunion *src,
+ union sockunion *dst, int prio)
{
struct vici_conn *vici = &vici_connection;
char buf[2][SU_ADDRSTRLEN];
sockunion2str(src, buf[0], sizeof buf[0]);
sockunion2str(dst, buf[1], sizeof buf[1]);
- vici_submit_request(
- vici, "initiate",
- VICI_KEY_VALUE, "child", strlen(profile), profile,
- VICI_KEY_VALUE, "timeout", (size_t) 2, "-1",
- VICI_KEY_VALUE, "async", (size_t) 1, "1",
- VICI_KEY_VALUE, "init-limits", (size_t) 1, prio ? "0" : "1",
- VICI_KEY_VALUE, "my-host", strlen(buf[0]), buf[0],
- VICI_KEY_VALUE, "other-host", strlen(buf[1]), buf[1],
- VICI_END);
+ vici_submit_request(vici, "initiate", VICI_KEY_VALUE, "child",
+ strlen(profile), profile, VICI_KEY_VALUE, "timeout",
+ (size_t)2, "-1", VICI_KEY_VALUE, "async", (size_t)1,
+ "1", VICI_KEY_VALUE, "init-limits", (size_t)1,
+ prio ? "0" : "1", VICI_KEY_VALUE, "my-host",
+ strlen(buf[0]), buf[0], VICI_KEY_VALUE,
+ "other-host", strlen(buf[1]), buf[1], VICI_END);
}
int sock_open_unix(const char *path)
if (fd < 0)
return -1;
- memset(&addr, 0, sizeof (struct sockaddr_un));
+ memset(&addr, 0, sizeof(struct sockaddr_un));
addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, path, sizeof(addr.sun_path) - 1);
- ret = connect(fd, (struct sockaddr *) &addr, sizeof(addr.sun_family) + strlen(addr.sun_path));
+ ret = connect(fd, (struct sockaddr *)&addr,
+ sizeof(addr.sun_family) + strlen(addr.sun_path));
if (ret < 0) {
close(fd);
return -1;
enum vici_type_t {
- VICI_START = 0,
+ VICI_START = 0,
VICI_SECTION_START = 1,
- VICI_SECTION_END = 2,
- VICI_KEY_VALUE = 3,
- VICI_LIST_START = 4,
- VICI_LIST_ITEM = 5,
- VICI_LIST_END = 6,
- VICI_END = 7
+ VICI_SECTION_END = 2,
+ VICI_KEY_VALUE = 3,
+ VICI_LIST_START = 4,
+ VICI_LIST_ITEM = 5,
+ VICI_LIST_END = 6,
+ VICI_END = 7
};
enum vici_operation_t {
if (!zb)
return NULL;
- zbuf_init(zb, zb+1, size, 0);
+ zbuf_init(zb, zb + 1, size, 0);
zb->allocated = 1;
return zb;
void zbuf_init(struct zbuf *zb, void *buf, size_t len, size_t datalen)
{
- *zb = (struct zbuf) {
+ *zb = (struct zbuf){
.buf = buf,
.end = (uint8_t *)buf + len,
.head = buf,
void zbuf_reset_head(struct zbuf *zb, void *ptr)
{
- zassert((void*)zb->buf <= ptr && ptr <= (void*)zb->tail);
+ zassert((void *)zb->buf <= ptr && ptr <= (void *)zb->tail);
zb->head = ptr;
}
maxlen = zbuf_tailroom(zb);
r = read(fd, zb->tail, maxlen);
- if (r > 0) zb->tail += r;
- else if (r == 0) r = -2;
- else if (r < 0 && ERRNO_IO_RETRY(errno)) r = 0;
+ if (r > 0)
+ zb->tail += r;
+ else if (r == 0)
+ r = -2;
+ else if (r < 0 && ERRNO_IO_RETRY(errno))
+ r = 0;
return r;
}
zb->head += r;
if (zb->head == zb->tail)
zbuf_reset(zb);
- }
- else if (r == 0) r = -2;
- else if (r < 0 && ERRNO_IO_RETRY(errno)) r = 0;
+ } else if (r == 0)
+ r = -2;
+ else if (r < 0 && ERRNO_IO_RETRY(errno))
+ r = 0;
return r;
}
zbuf_remove_headroom(zb);
r = recv(fd, zb->tail, zbuf_tailroom(zb), 0);
- if (r > 0) zb->tail += r;
- else if (r == 0) r = -2;
- else if (r < 0 && ERRNO_IO_RETRY(errno)) r = 0;
+ if (r > 0)
+ zb->tail += r;
+ else if (r == 0)
+ r = -2;
+ else if (r < 0 && ERRNO_IO_RETRY(errno))
+ r = 0;
return r;
}
uint8_t *ptr;
ptr = memmem(zb->head, zbuf_used(zb), sep, seplen);
- if (!ptr) return NULL;
+ if (!ptr)
+ return NULL;
len = ptr - zb->head + seplen;
zbuf_init(msg, zbuf_pulln(zb, len), len, len);
void zbufq_init(struct zbuf_queue *zbq)
{
- *zbq = (struct zbuf_queue) {
+ *zbq = (struct zbuf_queue){
.queue_head = LIST_INITIALIZER(zbq->queue_head),
};
}
{
struct zbuf *buf, *bufn;
- list_for_each_entry_safe(buf, bufn, &zbq->queue_head, queue_list) {
+ list_for_each_entry_safe(buf, bufn, &zbq->queue_head, queue_list)
+ {
list_del(&buf->queue_list);
zbuf_free(buf);
}
ssize_t r;
size_t iovcnt = 0;
- list_for_each_entry_safe(zb, zbn, &zbq->queue_head, queue_list) {
- iov[iovcnt++] = (struct iovec) {
- .iov_base = zb->head,
- .iov_len = zbuf_used(zb),
+ list_for_each_entry_safe(zb, zbn, &zbq->queue_head, queue_list)
+ {
+ iov[iovcnt++] = (struct iovec){
+ .iov_base = zb->head, .iov_len = zbuf_used(zb),
};
if (iovcnt >= ZEBRA_NUM_OF(iov))
break;
if (r < 0)
return r;
- list_for_each_entry_safe(zb, zbn, &zbq->queue_head, queue_list) {
+ list_for_each_entry_safe(zb, zbn, &zbq->queue_head, queue_list)
+ {
if (r < (ssize_t)zbuf_used(zb)) {
zb->head += r;
return 1;
dst = zbuf_pushn(zdst, len);
src = zbuf_pulln(zsrc, len);
- if (!dst || !src) return;
+ if (!dst || !src)
+ return;
memcpy(dst, src, len);
}
{
void *head = zb->head;
if (size > zbuf_used(zb)) {
- if (error) zbuf_set_rerror(zb);
+ if (error)
+ zbuf_set_rerror(zb);
return NULL;
}
zb->head += size;
static inline void zbuf_get(struct zbuf *zb, void *dst, size_t len)
{
void *src = zbuf_pulln(zb, len);
- if (src) memcpy(dst, src, len);
+ if (src)
+ memcpy(dst, src, len);
}
static inline uint8_t zbuf_get8(struct zbuf *zb)
{
uint8_t *src = zbuf_pull(zb, uint8_t);
- if (src) return *src;
+ if (src)
+ return *src;
return 0;
}
} __attribute__((packed));
struct unaligned32 *v = zbuf_pull(zb, struct unaligned32);
- if (v) return v->value;
+ if (v)
+ return v->value;
return 0;
}
} __attribute__((packed));
struct unaligned16 *v = zbuf_pull(zb, struct unaligned16);
- if (v) return be16toh(v->value);
+ if (v)
+ return be16toh(v->value);
return 0;
}
{
void *tail = zb->tail;
if (size > zbuf_tailroom(zb)) {
- if (error) zbuf_set_werror(zb);
+ if (error)
+ zbuf_set_werror(zb);
return NULL;
}
zb->tail += size;
static inline void zbuf_put(struct zbuf *zb, const void *src, size_t len)
{
void *dst = zbuf_pushn(zb, len);
- if (dst) memcpy(dst, src, len);
+ if (dst)
+ memcpy(dst, src, len);
}
static inline void zbuf_put8(struct zbuf *zb, uint8_t val)
{
uint8_t *dst = zbuf_push(zb, uint8_t);
- if (dst) *dst = val;
+ if (dst)
+ *dst = val;
}
static inline void zbuf_put_be16(struct zbuf *zb, uint16_t val)
} __attribute__((packed));
struct unaligned16 *v = zbuf_push(zb, struct unaligned16);
- if (v) v->value = htobe16(val);
+ if (v)
+ v->value = htobe16(val);
}
static inline void zbuf_put_be32(struct zbuf *zb, uint32_t val)
} __attribute__((packed));
struct unaligned32 *v = zbuf_push(zb, struct unaligned32);
- if (v) v->value = htobe32(val);
+ if (v)
+ v->value = htobe32(val);
}
void zbuf_copy(struct zbuf *zb, struct zbuf *src, size_t len);
struct nlmsghdr *n;
n = znl_push(zb, sizeof(*n));
- if (!n) return NULL;
+ if (!n)
+ return NULL;
- *n = (struct nlmsghdr) {
- .nlmsg_type = type,
- .nlmsg_flags = flags,
+ *n = (struct nlmsghdr){
+ .nlmsg_type = type, .nlmsg_flags = flags,
};
return n;
}
void znl_nlmsg_complete(struct zbuf *zb, struct nlmsghdr *n)
{
- n->nlmsg_len = zb->tail - (uint8_t*)n;
+ n->nlmsg_len = zb->tail - (uint8_t *)n;
}
struct nlmsghdr *znl_nlmsg_pull(struct zbuf *zb, struct zbuf *payload)
size_t plen;
n = znl_pull(zb, sizeof(*n));
- if (!n) return NULL;
+ if (!n)
+ return NULL;
plen = n->nlmsg_len - sizeof(*n);
zbuf_init(payload, znl_pull(zb, plen), plen, plen);
return n;
}
-struct rtattr *znl_rta_push(struct zbuf *zb, uint16_t type, const void *val, size_t len)
+struct rtattr *znl_rta_push(struct zbuf *zb, uint16_t type, const void *val,
+ size_t len)
{
struct rtattr *rta;
uint8_t *dst;
rta = znl_push(zb, ZNL_ALIGN(sizeof(*rta)) + ZNL_ALIGN(len));
- if (!rta) return NULL;
+ if (!rta)
+ return NULL;
- *rta = (struct rtattr) {
- .rta_type = type,
- .rta_len = ZNL_ALIGN(sizeof(*rta)) + len,
+ *rta = (struct rtattr){
+ .rta_type = type, .rta_len = ZNL_ALIGN(sizeof(*rta)) + len,
};
- dst = (uint8_t *)(rta+1);
+ dst = (uint8_t *)(rta + 1);
memcpy(dst, val, len);
- memset(dst+len, 0, ZNL_ALIGN(len) - len);
+ memset(dst + len, 0, ZNL_ALIGN(len) - len);
return rta;
}
struct rtattr *rta;
rta = znl_push(zb, sizeof(*rta));
- if (!rta) return NULL;
+ if (!rta)
+ return NULL;
- *rta = (struct rtattr) {
+ *rta = (struct rtattr){
.rta_type = type,
};
return rta;
void znl_rta_nested_complete(struct zbuf *zb, struct rtattr *rta)
{
- size_t len = zb->tail - (uint8_t*) rta;
+ size_t len = zb->tail - (uint8_t *)rta;
size_t align = ZNL_ALIGN(len) - len;
if (align) {
void *dst = zbuf_pushn(zb, align);
- if (dst) memset(dst, 0, align);
+ if (dst)
+ memset(dst, 0, align);
}
rta->rta_len = len;
}
size_t plen;
rta = znl_pull(zb, sizeof(*rta));
- if (!rta) return NULL;
+ if (!rta)
+ return NULL;
if (rta->rta_len > sizeof(*rta)) {
plen = rta->rta_len - sizeof(*rta);
memset(&addr, 0, sizeof(addr));
addr.nl_family = AF_NETLINK;
addr.nl_groups = groups;
- if (bind(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0)
+ if (bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
goto error;
return fd;
close(fd);
return -1;
}
-
void znl_nlmsg_complete(struct zbuf *zb, struct nlmsghdr *n);
struct nlmsghdr *znl_nlmsg_pull(struct zbuf *zb, struct zbuf *payload);
-struct rtattr *znl_rta_push(struct zbuf *zb, uint16_t type, const void *val, size_t len);
+struct rtattr *znl_rta_push(struct zbuf *zb, uint16_t type, const void *val,
+ size_t len);
struct rtattr *znl_rta_push_u32(struct zbuf *zb, uint16_t type, uint32_t val);
struct rtattr *znl_rta_nested_push(struct zbuf *zb, uint16_t type);
void znl_rta_nested_complete(struct zbuf *zb, struct rtattr *rta);
struct rtattr *znl_rta_pull(struct zbuf *zb, struct zbuf *payload);
int znl_open(int protocol, int groups);
-
if (prefix_list_apply(PREFIX_LIST_OUT(area), &route->prefix)
!= PREFIX_PERMIT) {
if (is_debug) {
- inet_ntop(AF_INET,
- &(ADV_ROUTER_IN_PREFIX(
- &route->prefix)),
- buf, sizeof(buf));
+ inet_ntop(
+ AF_INET,
+ &(ADV_ROUTER_IN_PREFIX(&route->prefix)),
+ buf, sizeof(buf));
zlog_debug(
"prefix %s was denied by filter-list out",
buf);
if (prefix_list_apply(PREFIX_LIST_IN(oa), &prefix)
!= PREFIX_PERMIT) {
if (is_debug)
- zlog_debug(
- "Prefix was denied by prefix-list");
+ zlog_debug("Prefix was denied by prefix-list");
if (old)
ospf6_route_remove(old, table);
return;
if (is_debug)
zlog_debug("%s: Update route: %s nh count %u",
- __PRETTY_FUNCTION__,
- buf, listcount(route->nh_list));
+ __PRETTY_FUNCTION__, buf,
+ listcount(route->nh_list));
/* Update RIB/FIB */
if (table->hook_add)
ospf6_route_delete(route);
} else {
if (is_debug)
- zlog_debug("Install route: %s nh count %u",
- buf, listcount(route->nh_list));
+ zlog_debug("Install route: %s nh count %u", buf,
+ listcount(route->nh_list));
/* ospf6_ia_add_nw_route (table, &prefix, route); */
ospf6_route_add(route, table);
}
.lh_short_name = "IAP",
.lh_show = ospf6_inter_area_prefix_lsa_show,
.lh_get_prefix_str = ospf6_inter_area_prefix_lsa_get_prefix_str,
- .lh_debug = 0
-};
+ .lh_debug = 0};
struct ospf6_lsa_handler inter_router_handler = {
.lh_type = OSPF6_LSTYPE_INTER_ROUTER,
.lh_short_name = "IAR",
.lh_show = ospf6_inter_area_router_lsa_show,
.lh_get_prefix_str = ospf6_inter_area_router_lsa_get_prefix_str,
- .lh_debug = 0
-};
+ .lh_debug = 0};
void ospf6_abr_init(void)
{
case OSPF6_LSTYPE_ROUTER:
case OSPF6_LSTYPE_NETWORK:
if (IS_OSPF6_DEBUG_EXAMIN_TYPE(lsa->header->type)) {
- zlog_debug("%s Examin LSA %s", __PRETTY_FUNCTION__, lsa->name);
+ zlog_debug("%s Examin LSA %s", __PRETTY_FUNCTION__,
+ lsa->name);
zlog_debug(" Schedule SPF Calculation for %s",
OSPF6_AREA(lsa->lsdb->data)->name);
}
if (strmatch(inout, "in")) {
PREFIX_LIST_IN(area) = plist;
XFREE(MTYPE_OSPF6_PLISTNAME, PREFIX_NAME_IN(area));
- PREFIX_NAME_IN(area) = XSTRDUP(MTYPE_OSPF6_PLISTNAME,
- plistname);
+ PREFIX_NAME_IN(area) =
+ XSTRDUP(MTYPE_OSPF6_PLISTNAME, plistname);
ospf6_abr_reimport(area);
} else {
PREFIX_LIST_OUT(area) = plist;
XFREE(MTYPE_OSPF6_PLISTNAME, PREFIX_NAME_OUT(area));
- PREFIX_NAME_OUT(area) = XSTRDUP(MTYPE_OSPF6_PLISTNAME,
- plistname);
+ PREFIX_NAME_OUT(area) =
+ XSTRDUP(MTYPE_OSPF6_PLISTNAME, plistname);
ospf6_abr_enable_area(area);
}
adv_router = oi->area->ospf6->router_id;
for (ALL_LSDB_TYPED_ADVRTR(ospf6->lsdb, type, adv_router, lsa)) {
if (IS_OSPF6_DEBUG_ASBR)
- zlog_debug("%s: Send update of AS-External LSA %s seq 0x%x",
- __PRETTY_FUNCTION__, lsa->name,
- ntohl(lsa->header->seqnum));
+ zlog_debug(
+ "%s: Send update of AS-External LSA %s seq 0x%x",
+ __PRETTY_FUNCTION__, lsa->name,
+ ntohl(lsa->header->seqnum));
ospf6_flood_interface(NULL, lsa, oi);
}
for (old_route = old; old_route; old_route = old_route->next) {
bool route_updated = false;
- if (!ospf6_route_is_same(old_route, route) ||
- (old_route->path.type != route->path.type))
+ if (!ospf6_route_is_same(old_route, route)
+ || (old_route->path.type != route->path.type))
continue;
/* Current and New route has same origin,
* delete old entry.
*/
for (ALL_LIST_ELEMENTS(old_route->paths, anode, anext,
- o_path)) {
+ o_path)) {
/* Check old route path and route has same
* origin.
*/
- if (o_path->area_id != route->path.area_id ||
- (memcmp(&(o_path)->origin, &(route)->path.origin,
- sizeof(struct ospf6_ls_origin)) != 0))
+ if (o_path->area_id != route->path.area_id
+ || (memcmp(&(o_path)->origin, &(route)->path.origin,
+ sizeof(struct ospf6_ls_origin))
+ != 0))
continue;
/* Cost is not same then delete current path */
- if ((o_path->cost == route->path.cost) &&
- (o_path->u.cost_e2 == route->path.u.cost_e2))
+ if ((o_path->cost == route->path.cost)
+ && (o_path->u.cost_e2 == route->path.u.cost_e2))
continue;
if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
prefix2str(&old_route->prefix, buf,
sizeof(buf));
- zlog_debug("%s: route %s cost old %u new %u is not same, replace route",
- __PRETTY_FUNCTION__, buf,
- o_path->cost, route->path.cost);
+ zlog_debug(
+ "%s: route %s cost old %u new %u is not same, replace route",
+ __PRETTY_FUNCTION__, buf, o_path->cost,
+ route->path.cost);
}
/* Remove selected current rout path's nh from
*/
for (ALL_LIST_ELEMENTS_RO(o_path->nh_list, nnode, nh)) {
for (ALL_LIST_ELEMENTS(old_route->nh_list,
- rnode, rnext, rnh)) {
+ rnode, rnext, rnh)) {
if (!ospf6_nexthop_is_same(rnh, nh))
continue;
listnode_delete(old_route->nh_list,
- rnh);
+ rnh);
ospf6_nexthop_delete(rnh);
route_updated = true;
}
* Update FIB with effective NHs.
*/
if (listcount(old_route->paths)) {
- if (old_route->path.origin.id ==
- route->path.origin.id &&
- old_route->path.origin.adv_router ==
- route->path.origin.adv_router) {
+ if (old_route->path.origin.id
+ == route->path.origin.id
+ && old_route->path.origin.adv_router
+ == route->path.origin
+ .adv_router) {
struct ospf6_path *h_path;
h_path = (struct ospf6_path *)
- listgetdata(listhead(old_route->paths));
+ listgetdata(listhead(
+ old_route->paths));
old_route->path.origin.type =
h_path->origin.type;
old_route->path.origin.id =
if (route_updated) {
for (ALL_LIST_ELEMENTS(old_route->paths,
- anode, anext, o_path)) {
+ anode, anext,
+ o_path)) {
ospf6_merge_nexthops(
old_route->nh_list,
o_path->nh_list);
* nh_list
*/
if (ospf6->route_table->hook_add)
- (*ospf6->route_table->hook_add)
- (old_route);
+ (*ospf6->route_table->hook_add)(
+ old_route);
break;
}
} else {
if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
prefix2str(&old_route->prefix, buf,
sizeof(buf));
- zlog_debug("%s: route %s old cost %u new cost %u, delete old entry.",
- __PRETTY_FUNCTION__, buf,
- old_route->path.cost,
- route->path.cost);
+ zlog_debug(
+ "%s: route %s old cost %u new cost %u, delete old entry.",
+ __PRETTY_FUNCTION__, buf,
+ old_route->path.cost,
+ route->path.cost);
}
ospf6_route_remove(old_route,
ospf6->route_table);
/* Current and New Route prefix or route type
* is not same skip this current node.
*/
- if (!ospf6_route_is_same(old_route, route) ||
- (old_route->path.type != route->path.type))
+ if (!ospf6_route_is_same(old_route, route)
+ || (old_route->path.type != route->path.type))
continue;
/* Old Route and New Route have Equal Cost, Merge NHs */
- if ((old_route->path.cost == route->path.cost) &&
- (old_route->path.u.cost_e2 == route->path.u.cost_e2)) {
+ if ((old_route->path.cost == route->path.cost)
+ && (old_route->path.u.cost_e2 == route->path.u.cost_e2)) {
if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
prefix2str(&old_route->prefix, buf,
sizeof(buf));
- zlog_debug("%s: old route %s path cost %u e2 %u",
- __PRETTY_FUNCTION__, buf,
- old_route->path.cost,
- old_route->path.u.cost_e2);
+ zlog_debug(
+ "%s: old route %s path cost %u e2 %u",
+ __PRETTY_FUNCTION__, buf,
+ old_route->path.cost,
+ old_route->path.u.cost_e2);
}
route_found = true;
/* check if this path exists already in
*/
for (ALL_LIST_ELEMENTS_RO(old_route->paths, anode,
o_path)) {
- if (o_path->area_id == route->path.area_id &&
- (memcmp(&(o_path)->origin,
- &(route)->path.origin,
- sizeof(struct ospf6_ls_origin)) == 0))
+ if (o_path->area_id == route->path.area_id
+ && (memcmp(&(o_path)->origin,
+ &(route)->path.origin,
+ sizeof(struct ospf6_ls_origin))
+ == 0))
break;
}
/* If path is not found in old_route paths's list,
/* Update RIB/FIB */
if (ospf6->route_table->hook_add)
- (*ospf6->route_table->hook_add)
- (old_route);
+ (*ospf6->route_table->hook_add)(
+ old_route);
/* Add the new path to route's path list */
listnode_add_sort(old_route->paths, ecmp_path);
if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
prefix2str(&route->prefix, buf,
sizeof(buf));
- zlog_debug("%s: route %s another path added with nh %u, effective paths %u nh %u",
+ zlog_debug(
+ "%s: route %s another path added with nh %u, effective paths %u nh %u",
__PRETTY_FUNCTION__, buf,
listcount(ecmp_path->nh_list),
- old_route->paths ?
- listcount(old_route->paths)
- : 0,
+ old_route->paths
+ ? listcount(
+ old_route
+ ->paths)
+ : 0,
listcount(old_route->nh_list));
}
} else {
for (ALL_LIST_ELEMENTS_RO(o_path->nh_list,
nnode, nh)) {
for (ALL_LIST_ELEMENTS(
- old_route->nh_list,
- rnode, rnext, rnh)) {
+ old_route->nh_list, rnode,
+ rnext, rnh)) {
if (!ospf6_nexthop_is_same(rnh,
nh))
continue;
}
list_delete_all_node(o_path->nh_list);
ospf6_copy_nexthops(o_path->nh_list,
- route->nh_list);
+ route->nh_list);
/* Merge nexthop to existing route's nh_list */
- ospf6_route_merge_nexthops(old_route,
- route);
+ ospf6_route_merge_nexthops(old_route, route);
if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
- prefix2str(&route->prefix,
- buf, sizeof(buf));
- zlog_debug("%s: existing route %s with effective nh count %u",
- __PRETTY_FUNCTION__, buf,
- old_route->nh_list ?
- listcount(old_route->nh_list)
- : 0);
+ prefix2str(&route->prefix, buf,
+ sizeof(buf));
+ zlog_debug(
+ "%s: existing route %s with effective nh count %u",
+ __PRETTY_FUNCTION__, buf,
+ old_route->nh_list
+ ? listcount(
+ old_route
+ ->nh_list)
+ : 0);
}
/* Update RIB/FIB */
if (ospf6->route_table->hook_add)
- (*ospf6->route_table->hook_add)
- (old_route);
-
+ (*ospf6->route_table->hook_add)(
+ old_route);
}
/* Delete the new route its info added to existing
* route.
prefix2str(&route->prefix, buf, sizeof(buf));
zlog_debug("%s: AS-External %u route add %s cost %u(%u) nh %u",
__PRETTY_FUNCTION__,
- (route->path.type == OSPF6_PATH_TYPE_EXTERNAL1)
- ? 1 : 2, buf, route->path.cost,
- route->path.u.cost_e2,
+ (route->path.type == OSPF6_PATH_TYPE_EXTERNAL1) ? 1
+ : 2,
+ buf, route->path.cost, route->path.u.cost_e2,
listcount(route->nh_list));
}
*/
ospf6_asbr_update_route_ecmp_path(old, route);
}
-
}
void ospf6_asbr_lsa_remove(struct ospf6_lsa *lsa,
} else {
route_to_del->path.type = OSPF6_PATH_TYPE_EXTERNAL1;
route_to_del->path.metric_type = 1;
- route_to_del->path.cost =
- asbr_entry->path.cost +
- OSPF6_ASBR_METRIC(external);
+ route_to_del->path.cost = asbr_entry->path.cost
+ + OSPF6_ASBR_METRIC(external);
route_to_del->path.u.cost_e2 = 0;
}
}
if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
prefix2str(&prefix, buf, sizeof(buf));
- zlog_debug("%s: Current route %s cost %u e2 %u, route to del cost %u e2 %u",
- __PRETTY_FUNCTION__, buf, route->path.cost,
- route->path.u.cost_e2,
- route_to_del->path.cost,
- route_to_del->path.u.cost_e2);
+ zlog_debug(
+ "%s: Current route %s cost %u e2 %u, route to del cost %u e2 %u",
+ __PRETTY_FUNCTION__, buf, route->path.cost,
+ route->path.u.cost_e2, route_to_del->path.cost,
+ route_to_del->path.u.cost_e2);
}
- for (ospf6_route_lock(route); route &&
- ospf6_route_is_prefix(&prefix, route); route = nroute) {
+ for (ospf6_route_lock(route);
+ route && ospf6_route_is_prefix(&prefix, route); route = nroute) {
nroute = ospf6_route_next(route);
if (route->type != OSPF6_DEST_TYPE_NETWORK)
* replace from paths list.
*/
for (ALL_LIST_ELEMENTS(route->paths, anode, anext,
- o_path)) {
+ o_path)) {
if ((o_path->origin.type != lsa->header->type)
- || (o_path->origin.adv_router !=
- lsa->header->adv_router) ||
- (o_path->origin.id != lsa->header->id))
+ || (o_path->origin.adv_router
+ != lsa->header->adv_router)
+ || (o_path->origin.id != lsa->header->id))
continue;
/* Compare LSA cost with current
* route info.
*/
- if (!asbr_entry && (o_path->cost !=
- route_to_del->path.cost ||
- o_path->u.cost_e2 !=
- route_to_del->path.u.cost_e2)) {
+ if (!asbr_entry
+ && (o_path->cost != route_to_del->path.cost
+ || o_path->u.cost_e2
+ != route_to_del->path.u
+ .cost_e2)) {
if (IS_OSPF6_DEBUG_EXAMIN(
- AS_EXTERNAL)) {
+ AS_EXTERNAL)) {
prefix2str(&prefix, buf,
sizeof(buf));
zlog_debug(
- "%s: route %s to delete is not same, cost %u del cost %u. skip",
- __PRETTY_FUNCTION__, buf,
- route->path.cost,
- route_to_del->path.cost);
+ "%s: route %s to delete is not same, cost %u del cost %u. skip",
+ __PRETTY_FUNCTION__,
+ buf, route->path.cost,
+ route_to_del->path
+ .cost);
}
continue;
}
- if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
+ if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
prefix2str(&prefix, buf, sizeof(buf));
zlog_debug(
"%s: route %s path found with nh %u to remove.",
for (ALL_LIST_ELEMENTS_RO(o_path->nh_list,
nnode, nh)) {
for (ALL_LIST_ELEMENTS(route->nh_list,
- rnode, rnext, rnh)) {
+ rnode, rnext,
+ rnh)) {
if (!ospf6_nexthop_is_same(rnh,
- nh))
+ nh))
continue;
listnode_delete(route->nh_list,
rnh);
if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
prefix2str(&route->prefix, buf,
sizeof(buf));
- zlog_debug("%s: AS-External %u route %s update paths %u nh %u"
- , __PRETTY_FUNCTION__,
- (route->path.type ==
- OSPF6_PATH_TYPE_EXTERNAL1)
- ? 1 : 2, buf,
- listcount(route->paths),
- listcount(route->nh_list));
+ zlog_debug(
+ "%s: AS-External %u route %s update paths %u nh %u",
+ __PRETTY_FUNCTION__,
+ (route->path.type
+ == OSPF6_PATH_TYPE_EXTERNAL1)
+ ? 1
+ : 2,
+ buf, listcount(route->paths),
+ listcount(route->nh_list));
}
/* Update RIB/FIB with effective nh_list */
* replace route's primary path with
* route's paths list head.
*/
- if (route->path.origin.id == lsa->header->id &&
- route->path.origin.adv_router ==
- lsa->header->adv_router) {
+ if (route->path.origin.id == lsa->header->id
+ && route->path.origin.adv_router
+ == lsa->header->adv_router) {
struct ospf6_path *h_path;
h_path = (struct ospf6_path *)
- listgetdata(listhead(route->paths));
+ listgetdata(
+ listhead(route->paths));
route->path.origin.type =
h_path->origin.type;
route->path.origin.id =
/* Compare LSA origin and cost with current route info.
* if any check fails skip del this route node.
*/
- if (asbr_entry && (!ospf6_route_is_same_origin(route,
- route_to_del) ||
- (route->path.type != route_to_del->path.type) ||
- (route->path.cost != route_to_del->path.cost) ||
- (route->path.u.cost_e2 !=
- route_to_del->path.u.cost_e2))) {
+ if (asbr_entry
+ && (!ospf6_route_is_same_origin(route, route_to_del)
+ || (route->path.type != route_to_del->path.type)
+ || (route->path.cost != route_to_del->path.cost)
+ || (route->path.u.cost_e2
+ != route_to_del->path.u.cost_e2))) {
if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
prefix2str(&prefix, buf, sizeof(buf));
- zlog_debug("%s: route %s to delete is not same, cost %u del cost %u. skip",
- __PRETTY_FUNCTION__, buf,
- route->path.cost,
- route_to_del->path.cost);
+ zlog_debug(
+ "%s: route %s to delete is not same, cost %u del cost %u. skip",
+ __PRETTY_FUNCTION__, buf,
+ route->path.cost,
+ route_to_del->path.cost);
}
continue;
}
- if ((route->path.origin.type != lsa->header->type) ||
- (route->path.origin.adv_router !=
- lsa->header->adv_router) ||
- (route->path.origin.id != lsa->header->id))
+ if ((route->path.origin.type != lsa->header->type)
+ || (route->path.origin.adv_router
+ != lsa->header->adv_router)
+ || (route->path.origin.id != lsa->header->id))
continue;
}
if (IS_OSPF6_DEBUG_EXAMIN(AS_EXTERNAL)) {
prefix2str(&route->prefix, buf, sizeof(buf));
- zlog_debug("%s: AS-External %u route remove %s cost %u(%u) nh %u",
- __PRETTY_FUNCTION__,
- route->path.type == OSPF6_PATH_TYPE_EXTERNAL1
- ? 1 : 2, buf, route->path.cost,
- route->path.u.cost_e2,
- listcount(route->nh_list));
+ zlog_debug(
+ "%s: AS-External %u route remove %s cost %u(%u) nh %u",
+ __PRETTY_FUNCTION__,
+ route->path.type == OSPF6_PATH_TYPE_EXTERNAL1
+ ? 1
+ : 2,
+ buf, route->path.cost, route->path.u.cost_e2,
+ listcount(route->nh_list));
}
ospf6_route_remove(route, ospf6->route_table);
}
ospf6->t_distribute_update = NULL;
if (ospf6->rmap[arg_type].name)
- ospf6->rmap[arg_type].map = route_map_lookup_by_name(
- ospf6->rmap[arg_type].name);
+ ospf6->rmap[arg_type].map =
+ route_map_lookup_by_name(ospf6->rmap[arg_type].name);
if (ospf6->rmap[arg_type].map) {
if (IS_OSPF6_DEBUG_ASBR)
zlog_debug("%s: route-map %s update, reset redist %s",
if (ospf6->t_distribute_update)
return;
- args = XCALLOC(MTYPE_OSPF6_DIST_ARGS, sizeof(void *)*2);
+ args = XCALLOC(MTYPE_OSPF6_DIST_ARGS, sizeof(void *) * 2);
args[0] = ospf6;
args[1] = (void *)((ptrdiff_t)type);
ospf6->rmap[type].map = route_map_lookup_by_name(
ospf6->rmap[type].name);
- if (mapname && ospf6->rmap[type].map &&
- (strcmp(ospf6->rmap[type].name, mapname) == 0)) {
+ if (mapname && ospf6->rmap[type].map
+ && (strcmp(ospf6->rmap[type].name, mapname) == 0)) {
if (IS_OSPF6_DEBUG_ASBR)
- zlog_debug("%s: route-map %s update, reset redist %s",
- __PRETTY_FUNCTION__, mapname,
- ZROUTE_NAME(type));
+ zlog_debug(
+ "%s: route-map %s update, reset redist %s",
+ __PRETTY_FUNCTION__, mapname,
+ ZROUTE_NAME(type));
ospf6_asbr_distribute_list_update(type);
}
} else
if (ospf6 == NULL)
return;
for (type = 0; type < ZEBRA_ROUTE_MAX; type++) {
- if ((ospf6->rmap[type].name) &&
- (strcmp(ospf6->rmap[type].name, name) == 0)) {
+ if ((ospf6->rmap[type].name)
+ && (strcmp(ospf6->rmap[type].name, name) == 0)) {
ospf6_asbr_distribute_list_update(type);
}
}
inet_ntop(AF_INET, &prefix_id.u.prefix4, ibuf,
sizeof(ibuf));
prefix2str(prefix, pbuf, sizeof(pbuf));
- zlog_debug("Advertise as AS-External Id:%s prefix %s metric %u",
- ibuf, pbuf, match->path.metric_type);
+ zlog_debug(
+ "Advertise as AS-External Id:%s prefix %s metric %u",
+ ibuf, pbuf, match->path.metric_type);
}
match->path.origin.id = htonl(info->id);
.lh_short_name = "ASE",
.lh_show = ospf6_as_external_lsa_show,
.lh_get_prefix_str = ospf6_as_external_lsa_get_prefix_str,
- .lh_debug = 0
-};
+ .lh_debug = 0};
void ospf6_asbr_init(void)
{
|| IS_OSPF6_DEBUG_EXAMIN_TYPE(lsa->header->type))
zlog_debug("%s Install LSA: %s age %d seqnum %x in LSDB.",
__PRETTY_FUNCTION__, lsa->name,
- ntohs(lsa->header->age),
- ntohl(lsa->header->seqnum));
+ ntohs(lsa->header->age), ntohl(lsa->header->seqnum));
/* actually install */
lsa->installed = now;
/* RFC2740 section 3.5.2. Sending Link State Update packets */
/* RFC2328 section 13.3 Next step in the flooding procedure */
-void ospf6_flood_interface(struct ospf6_neighbor *from,
- struct ospf6_lsa *lsa,
- struct ospf6_interface *oi)
+void ospf6_flood_interface(struct ospf6_neighbor *from, struct ospf6_lsa *lsa,
+ struct ospf6_interface *oi)
{
struct listnode *node, *nnode;
struct ospf6_neighbor *on;
if (ospf6->inst_shutdown) {
if (is_debug)
- zlog_debug("%s: Send LSA %s (age %d) update now",
- __PRETTY_FUNCTION__, lsa->name,
- ntohs(lsa->header->age));
+ zlog_debug(
+ "%s: Send LSA %s (age %d) update now",
+ __PRETTY_FUNCTION__, lsa->name,
+ ntohs(lsa->header->age));
ospf6_lsupdate_send_neighbor_now(on, lsa);
continue;
} else {
zlog_debug("Received is duplicated LSA");
SET_FLAG(new->flag, OSPF6_LSA_DUPLICATE);
}
- if (old->header->adv_router ==
- from->ospf6_if->area->ospf6->router_id
+ if (old->header->adv_router
+ == from->ospf6_if->area->ospf6->router_id
&& OSPF6_LSA_IS_MAXAGE(new)) {
ospf6_acknowledge_lsa(new, ismore_recent, from);
ospf6_lsa_delete(new);
if (is_debug)
- zlog_debug("%s: Received is self orig MAXAGE LSA %s, discard (ismore_recent %d)",
- __PRETTY_FUNCTION__, old->name,
- ismore_recent);
+ zlog_debug(
+ "%s: Received is self orig MAXAGE LSA %s, discard (ismore_recent %d)",
+ __PRETTY_FUNCTION__, old->name,
+ ismore_recent);
return;
}
}
/* Neighbor router sent recent age for LSA,
* Router could be restarted while current copy is
* MAXAGEd and not removed.*/
- if (OSPF6_LSA_IS_MAXAGE(old) &&
- !OSPF6_LSA_IS_MAXAGE(new)) {
+ if (OSPF6_LSA_IS_MAXAGE(old)
+ && !OSPF6_LSA_IS_MAXAGE(new)) {
if (is_debug)
- zlog_debug("%s: Current copy of LSA %s is MAXAGE, but new has recent Age.",
- old->name,
- __PRETTY_FUNCTION__);
+ zlog_debug(
+ "%s: Current copy of LSA %s is MAXAGE, but new has recent Age.",
+ old->name, __PRETTY_FUNCTION__);
ospf6_lsa_purge(old);
if (new->header->adv_router
- != from->ospf6_if->area->
- ospf6->router_id)
+ != from->ospf6_if->area->ospf6->router_id)
ospf6_flood(from, new);
ospf6_install_lsa(new);
bw = oi->interface->speed;
} else {
bw = oi->interface->bandwidth ? oi->interface->bandwidth
- : OSPF6_INTERFACE_BANDWIDTH;
+ : OSPF6_INTERFACE_BANDWIDTH;
}
refbw = ospf6 ? ospf6->ref_bandwidth : OSPF6_REFERENCE_BANDWIDTH;
return CMD_SUCCESS;
}
-static int ospf6_interface_show_traffic(struct vty *vty,
- uint32_t vrf_id,
+static int ospf6_interface_show_traffic(struct vty *vty, uint32_t vrf_id,
struct interface *intf_ifp,
int display_once)
{
if (!display_once) {
vty_out(vty, "\n");
- vty_out(vty, "%-12s%-17s%-17s%-17s%-17s%-17s\n",
- "Interface", " HELLO", " DB-Desc", " LS-Req",
- " LS-Update", " LS-Ack");
+ vty_out(vty, "%-12s%-17s%-17s%-17s%-17s%-17s\n", "Interface",
+ " HELLO", " DB-Desc", " LS-Req", " LS-Update",
+ " LS-Ack");
vty_out(vty, "%-10s%-18s%-18s%-17s%-17s%-17s\n", "",
- " Rx/Tx", " Rx/Tx", " Rx/Tx", " Rx/Tx", " Rx/Tx");
+ " Rx/Tx", " Rx/Tx", " Rx/Tx", " Rx/Tx",
+ " Rx/Tx");
vty_out(vty,
- "--------------------------------------------------------------------------------------------\n");
+ "--------------------------------------------------------------------------------------------\n");
}
if (intf_ifp == NULL) {
continue;
vty_out(vty,
- "%-10s %8u/%-8u %7u/%-7u %7u/%-7u %7u/%-7u %7u/%-7u\n",
+ "%-10s %8u/%-8u %7u/%-7u %7u/%-7u %7u/%-7u %7u/%-7u\n",
oi->interface->name, oi->hello_in,
- oi->hello_out,
- oi->db_desc_in, oi->db_desc_out,
- oi->ls_req_in, oi->ls_req_out,
- oi->ls_upd_in, oi->ls_upd_out,
- oi->ls_ack_in, oi->ls_ack_out);
+ oi->hello_out, oi->db_desc_in, oi->db_desc_out,
+ oi->ls_req_in, oi->ls_req_out, oi->ls_upd_in,
+ oi->ls_upd_out, oi->ls_ack_in, oi->ls_ack_out);
}
} else {
oi = intf_ifp->info;
vty_out(vty,
"%-10s %8u/%-8u %7u/%-7u %7u/%-7u %7u/%-7u %7u/%-7u\n",
- oi->interface->name, oi->hello_in,
- oi->hello_out,
- oi->db_desc_in, oi->db_desc_out,
- oi->ls_req_in, oi->ls_req_out,
- oi->ls_upd_in, oi->ls_upd_out,
+ oi->interface->name, oi->hello_in, oi->hello_out,
+ oi->db_desc_in, oi->db_desc_out, oi->ls_req_in,
+ oi->ls_req_out, oi->ls_upd_in, oi->ls_upd_out,
oi->ls_ack_in, oi->ls_ack_out);
}
intf_name = argv[idx_ifname]->arg;
ifp = if_lookup_by_name(intf_name, VRF_DEFAULT);
if (ifp == NULL) {
- vty_out(vty,
- "No such Interface: %s\n",
- intf_name);
+ vty_out(vty, "No such Interface: %s\n", intf_name);
return CMD_WARNING;
}
if (ifp->info == NULL) {
}
}
- ospf6_interface_show_traffic(vty, VRF_DEFAULT, ifp,
- display_once);
+ ospf6_interface_show_traffic(vty, VRF_DEFAULT, ifp, display_once);
return CMD_SUCCESS;
install_element(VIEW_NODE, &show_ipv6_ospf6_interface_ifname_cmd);
install_element(VIEW_NODE,
&show_ipv6_ospf6_interface_ifname_prefix_cmd);
- install_element(VIEW_NODE,
- &show_ipv6_ospf6_interface_traffic_cmd);
+ install_element(VIEW_NODE, &show_ipv6_ospf6_interface_traffic_cmd);
install_element(INTERFACE_NODE, &ipv6_ospf6_cost_cmd);
install_element(INTERFACE_NODE, &no_ipv6_ospf6_cost_cmd);
ospf6_router_lsa_options_set(oa, router_lsa);
/* describe links for each interfaces */
- lsdesc = (struct ospf6_router_lsdesc *)((caddr_t)router_lsa
+ lsdesc = (struct ospf6_router_lsdesc
+ *)((caddr_t)router_lsa
+ sizeof(struct ospf6_router_lsa));
for (ALL_LIST_ELEMENTS(oa->if_list, node, nnode, oi)) {
lsa_header->type = htons(OSPF6_LSTYPE_ROUTER);
lsa_header->id = htonl(link_state_id);
lsa_header->adv_router = oa->ospf6->router_id;
- lsa_header->seqnum =
- ospf6_new_ls_seqnum(lsa_header->type,
- lsa_header->id,
- lsa_header->adv_router, oa->lsdb);
+ lsa_header->seqnum = ospf6_new_ls_seqnum(
+ lsa_header->type, lsa_header->id,
+ lsa_header->adv_router, oa->lsdb);
lsa_header->length =
htons((caddr_t)lsdesc - (caddr_t)buffer);
memset(buffer, 0, sizeof(buffer));
lsa_header = (struct ospf6_lsa_header *)buffer;
router_lsa =
- (struct ospf6_router_lsa *)((caddr_t)lsa_header
+ (struct ospf6_router_lsa
+ *)((caddr_t)lsa_header
+ sizeof(struct ospf6_lsa_header));
ospf6_router_lsa_options_set(oa, router_lsa);
/* describe links for each interfaces */
- lsdesc = (struct ospf6_router_lsdesc *)
- ((caddr_t)router_lsa +
- sizeof(struct ospf6_router_lsa));
+ lsdesc = (struct ospf6_router_lsdesc
+ *)((caddr_t)router_lsa
+ + sizeof(struct ospf6_router_lsa));
link_state_id++;
}
ospf6_lsa_purge(old);
/* find previous LSA */
old_next = ospf6_lsdb_lookup(
- htons(OSPF6_LSTYPE_INTRA_PREFIX),
- htonl(++ls_id),
- oa->ospf6->router_id, oa->lsdb);
+ htons(OSPF6_LSTYPE_INTRA_PREFIX),
+ htonl(++ls_id), oa->ospf6->router_id, oa->lsdb);
while (old_next) {
ospf6_lsa_purge(old_next);
old_next = ospf6_lsdb_lookup(
htons(OSPF6_LSTYPE_INTRA_PREFIX),
- htonl(++ls_id),
- oa->ospf6->router_id, oa->lsdb);
+ htonl(++ls_id), oa->ospf6->router_id,
+ oa->lsdb);
}
}
return 0;
/* prepare buffer */
memset(buffer, 0, sizeof(buffer));
lsa_header = (struct ospf6_lsa_header *)buffer;
- intra_prefix_lsa = (struct ospf6_intra_prefix_lsa *)((caddr_t)lsa_header
+ intra_prefix_lsa = (struct ospf6_intra_prefix_lsa
+ *)((caddr_t)lsa_header
+ sizeof(struct ospf6_lsa_header));
/* Fill Intra-Area-Prefix-LSA */
ospf6_lsa_purge(old);
/* find previous LSA */
old_next = ospf6_lsdb_lookup(
- htons(OSPF6_LSTYPE_INTRA_PREFIX),
- htonl(++ls_id),
- oa->ospf6->router_id, oa->lsdb);
+ htons(OSPF6_LSTYPE_INTRA_PREFIX),
+ htonl(++ls_id), oa->ospf6->router_id, oa->lsdb);
while (old_next) {
ospf6_lsa_purge(old_next);
old_next = ospf6_lsdb_lookup(
htons(OSPF6_LSTYPE_INTRA_PREFIX),
- htonl(++ls_id),
- oa->ospf6->router_id, oa->lsdb);
+ htonl(++ls_id), oa->ospf6->router_id,
+ oa->lsdb);
}
}
ospf6_route_table_delete(route_advertise);
lsa_header->type = htons(OSPF6_LSTYPE_INTRA_PREFIX);
lsa_header->id = htonl(ls_id++);
lsa_header->adv_router = oa->ospf6->router_id;
- lsa_header->seqnum =
- ospf6_new_ls_seqnum(lsa_header->type,
- lsa_header->id,
- lsa_header->adv_router,
- oa->lsdb);
- lsa_header->length = htons((caddr_t)op -
- (caddr_t)lsa_header);
+ lsa_header->seqnum = ospf6_new_ls_seqnum(
+ lsa_header->type, lsa_header->id,
+ lsa_header->adv_router, oa->lsdb);
+ lsa_header->length =
+ htons((caddr_t)op - (caddr_t)lsa_header);
/* LSA checksum */
ospf6_lsa_checksum(lsa_header);
/* Prepare next buffer */
memset(buffer, 0, sizeof(buffer));
lsa_header = (struct ospf6_lsa_header *)buffer;
- intra_prefix_lsa = (struct ospf6_intra_prefix_lsa *)
- ((caddr_t)lsa_header
- + sizeof(struct ospf6_lsa_header));
+ intra_prefix_lsa =
+ (struct ospf6_intra_prefix_lsa
+ *)((caddr_t)lsa_header
+ + sizeof(struct ospf6_lsa_header));
/* Fill Intra-Area-Prefix-LSA */
intra_prefix_lsa->ref_type = htons(OSPF6_LSTYPE_ROUTER);
/* Put next set of prefixes to advertise */
prefix_num = 0;
- op = (struct ospf6_prefix *)((caddr_t)intra_prefix_lsa
- + sizeof(struct ospf6_intra_prefix_lsa));
+ op = (struct ospf6_prefix
+ *)((caddr_t)intra_prefix_lsa
+ + sizeof(struct
+ ospf6_intra_prefix_lsa));
}
op->prefix_length = route->prefix.prefixlen;
oa->name);
}
-struct ospf6_lsa_handler router_handler = {
- .lh_type = OSPF6_LSTYPE_ROUTER,
- .lh_name = "Router",
- .lh_short_name = "Rtr",
- .lh_show = ospf6_router_lsa_show,
- .lh_get_prefix_str = ospf6_router_lsa_get_nbr_id,
- .lh_debug = 0
-};
-
-struct ospf6_lsa_handler network_handler = {
- .lh_type = OSPF6_LSTYPE_NETWORK,
- .lh_name = "Network",
- .lh_short_name = "Net",
- .lh_show = ospf6_network_lsa_show,
- .lh_get_prefix_str = ospf6_network_lsa_get_ar_id,
- .lh_debug = 0
-};
-
-struct ospf6_lsa_handler link_handler = {
- .lh_type = OSPF6_LSTYPE_LINK,
- .lh_name = "Link",
- .lh_short_name = "Lnk",
- .lh_show = ospf6_link_lsa_show,
- .lh_get_prefix_str = ospf6_link_lsa_get_prefix_str,
- .lh_debug = 0
-};
+struct ospf6_lsa_handler router_handler = {.lh_type = OSPF6_LSTYPE_ROUTER,
+ .lh_name = "Router",
+ .lh_short_name = "Rtr",
+ .lh_show = ospf6_router_lsa_show,
+ .lh_get_prefix_str =
+ ospf6_router_lsa_get_nbr_id,
+ .lh_debug = 0};
+
+struct ospf6_lsa_handler network_handler = {.lh_type = OSPF6_LSTYPE_NETWORK,
+ .lh_name = "Network",
+ .lh_short_name = "Net",
+ .lh_show = ospf6_network_lsa_show,
+ .lh_get_prefix_str =
+ ospf6_network_lsa_get_ar_id,
+ .lh_debug = 0};
+
+struct ospf6_lsa_handler link_handler = {.lh_type = OSPF6_LSTYPE_LINK,
+ .lh_name = "Link",
+ .lh_short_name = "Lnk",
+ .lh_show = ospf6_link_lsa_show,
+ .lh_get_prefix_str =
+ ospf6_link_lsa_get_prefix_str,
+ .lh_debug = 0};
struct ospf6_lsa_handler intra_prefix_handler = {
.lh_type = OSPF6_LSTYPE_INTRA_PREFIX,
.lh_short_name = "INP",
.lh_show = ospf6_intra_prefix_lsa_show,
.lh_get_prefix_str = ospf6_intra_prefix_lsa_get_prefix_str,
- .lh_debug = 0
-};
+ .lh_debug = 0};
void ospf6_intra_init(void)
{
0, &(oi)->thread_intra_prefix_lsa); \
} while (0)
-#define OSPF6_AS_EXTERN_LSA_SCHEDULE(oi) \
+#define OSPF6_AS_EXTERN_LSA_SCHEDULE(oi) \
do { \
if (!CHECK_FLAG((oi)->flag, OSPF6_INTERFACE_DISABLE)) \
- thread_add_event( \
- master, \
- ospf6_orig_as_external_lsa, oi, \
- 0, &(oi)->thread_as_extern_lsa); \
+ thread_add_event(master, ospf6_orig_as_external_lsa, \
+ oi, 0, &(oi)->thread_as_extern_lsa); \
} while (0)
#define OSPF6_NETWORK_LSA_EXECUTE(oi) \
lsa_size = ntohs(header->length); /* XXX vulnerable */
/* allocate memory for this LSA */
- new_header =
- (struct ospf6_lsa_header *)XMALLOC(MTYPE_OSPF6_LSA_HEADER,
- lsa_size);
+ new_header = (struct ospf6_lsa_header *)XMALLOC(MTYPE_OSPF6_LSA_HEADER,
+ lsa_size);
/* copy LSA from original header */
memcpy(new_header, header, lsa_size);
ospf6->inst_shutdown = 1;
for (ALL_LIST_ELEMENTS_RO(ospf6->area_list, node, oa)) {
- end = ospf6_lsdb_head(oa->lsdb_self, 0, 0,
- ospf6->router_id, &lsa);
+ end = ospf6_lsdb_head(oa->lsdb_self, 0, 0, ospf6->router_id,
+ &lsa);
while (lsa) {
/* RFC 2328 (14.1): Set MAXAGE */
lsa->header->age = htons(OSPF_LSA_MAXAGE);
unsigned int i;
unsigned int size = strlen(h->lh_name);
- if (!strcmp(h->lh_name, "unknown") && h->lh_type != OSPF6_LSTYPE_UNKNOWN) {
+ if (!strcmp(h->lh_name, "unknown")
+ && h->lh_type != OSPF6_LSTYPE_UNKNOWN) {
snprintf(buf, sizeof(buf), "%#04hx", h->lh_type);
return buf;
}
const char *name;
const char *short_name;
int (*show)(struct vty *, struct ospf6_lsa *);
- char *(*get_prefix_str)(struct ospf6_lsa *, char *buf, int buflen,
- int pos);
+ char *(*get_prefix_str)(struct ospf6_lsa *, char *buf,
+ int buflen, int pos);
} s;
#define lh_type s.type
#define lh_name s.name
ospf6_lsa_show_summary_header(vty);
end = ospf6_lsdb_head(lsdb, !!type + !!(type && adv_router),
- type ? *type : 0,
- adv_router ? *adv_router : 0,
+ type ? *type : 0, adv_router ? *adv_router : 0,
&lsa);
while (lsa) {
if ((!adv_router || lsa->header->adv_router == *adv_router)
if (on) {
on->ospf6_if->ls_upd_out++;
- if ((on->ospf6_if->state == OSPF6_INTERFACE_POINTTOPOINT) ||
- (on->ospf6_if->state == OSPF6_INTERFACE_DR) ||
- (on->ospf6_if->state == OSPF6_INTERFACE_BDR)) {
+ if ((on->ospf6_if->state == OSPF6_INTERFACE_POINTTOPOINT)
+ || (on->ospf6_if->state == OSPF6_INTERFACE_DR)
+ || (on->ospf6_if->state == OSPF6_INTERFACE_BDR)) {
ospf6_send(on->ospf6_if->linklocal_addr,
&allspfrouters6, on->ospf6_if, oh);
} else {
oi->ls_upd_out++;
- if ((oi->state == OSPF6_INTERFACE_POINTTOPOINT) ||
- (oi->state == OSPF6_INTERFACE_DR) ||
- (oi->state == OSPF6_INTERFACE_BDR)) {
+ if ((oi->state == OSPF6_INTERFACE_POINTTOPOINT)
+ || (oi->state == OSPF6_INTERFACE_DR)
+ || (oi->state == OSPF6_INTERFACE_BDR)) {
ospf6_send(oi->linklocal_addr, &allspfrouters6, oi, oh);
} else {
ospf6_send(oi->linklocal_addr, &alldrouters6, oi, oh);
memset(sendbuf, 0, iobuflen);
oh = (struct ospf6_header *)sendbuf;
- lsupdate = (struct ospf6_lsupdate *)((caddr_t)oh
- + sizeof(struct ospf6_header));
+ lsupdate = (struct ospf6_lsupdate
+ *)((caddr_t)oh
+ + sizeof(struct
+ ospf6_header));
p = (u_char *)((caddr_t)lsupdate
+ sizeof(struct ospf6_lsupdate));
oh->length = htons(p - sendbuf);
lsupdate->lsa_number = htonl(lsa_cnt);
- if (on->ospf6_if->state ==
- OSPF6_INTERFACE_POINTTOPOINT) {
+ if (on->ospf6_if->state
+ == OSPF6_INTERFACE_POINTTOPOINT) {
ospf6_send(on->ospf6_if->linklocal_addr,
&allspfrouters6,
on->ospf6_if, oh);
memset(sendbuf, 0, iobuflen);
oh = (struct ospf6_header *)sendbuf;
- lsupdate = (struct ospf6_lsupdate *)((caddr_t)oh
- + sizeof(struct ospf6_header));
- p = (u_char *)((caddr_t)lsupdate +
- sizeof(struct ospf6_lsupdate));
+ lsupdate = (struct ospf6_lsupdate
+ *)((caddr_t)oh
+ + sizeof(struct
+ ospf6_header));
+ p = (u_char *)((caddr_t)lsupdate
+ + sizeof(struct ospf6_lsupdate));
lsa_cnt = 0;
}
}
oh->length = htons(p - sendbuf);
lsupdate->lsa_number = htonl(lsa_cnt);
- if (IS_OSPF6_DEBUG_FLOODING ||
- IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_LSUPDATE, SEND))
+ if (IS_OSPF6_DEBUG_FLOODING
+ || IS_OSPF6_DEBUG_MESSAGE(OSPF6_MESSAGE_TYPE_LSUPDATE, SEND))
zlog_debug("%s: Send lsupdate with lsa %s (age %u)",
- __PRETTY_FUNCTION__, lsa->name,
- ntohs(lsa->header->age));
+ __PRETTY_FUNCTION__, lsa->name,
+ ntohs(lsa->header->age));
ospf6_send_lsupdate(on, NULL, oh);
ospf6_send_lsupdate(NULL, oi, oh);
if (IS_OSPF6_DEBUG_MESSAGE(
- OSPF6_MESSAGE_TYPE_LSUPDATE, SEND))
+ OSPF6_MESSAGE_TYPE_LSUPDATE, SEND))
zlog_debug("%s: LSUpdate length %d",
__PRETTY_FUNCTION__,
ntohs(oh->length));
memset(sendbuf, 0, iobuflen);
oh = (struct ospf6_header *)sendbuf;
- lsupdate = (struct ospf6_lsupdate *)((caddr_t)oh
- + sizeof(struct ospf6_header));
+ lsupdate = (struct ospf6_lsupdate
+ *)((caddr_t)oh
+ + sizeof(struct
+ ospf6_header));
p = (u_char *)((caddr_t)lsupdate
- + sizeof(struct ospf6_lsupdate));
+ + sizeof(struct ospf6_lsupdate));
lsa_cnt = 0;
}
}
on->ospf6_if->ls_ack_out++;
ospf6_send(on->ospf6_if->linklocal_addr,
- &on->linklocal_addr,
- on->ospf6_if, oh);
+ &on->linklocal_addr, on->ospf6_if,
+ oh);
memset(sendbuf, 0, iobuflen);
oh = (struct ospf6_header *)sendbuf;
- p = (u_char *)((caddr_t)oh +
- sizeof(struct ospf6_header));
+ p = (u_char *)((caddr_t)oh
+ + sizeof(struct ospf6_header));
lsa_cnt = 0;
}
}
}
OSPF6_INTRA_PREFIX_LSA_SCHEDULE_STUB(on->ospf6_if->area);
- if (prev_state == OSPF6_NEIGHBOR_LOADING &&
- next_state == OSPF6_NEIGHBOR_FULL) {
+ if (prev_state == OSPF6_NEIGHBOR_LOADING
+ && next_state == OSPF6_NEIGHBOR_FULL) {
OSPF6_AS_EXTERN_LSA_SCHEDULE(on->ospf6_if);
on->ospf6_if->area->full_nbrs++;
}
memcpy(new, path, sizeof(struct ospf6_path));
new->nh_list = list_new();
new->nh_list->cmp = (int (*)(void *, void *))ospf6_nexthop_cmp;
- new->nh_list->del = (void (*) (void *))ospf6_nexthop_delete;
+ new->nh_list->del = (void (*)(void *))ospf6_nexthop_delete;
return new;
}
route = XCALLOC(MTYPE_OSPF6_ROUTE, sizeof(struct ospf6_route));
route->nh_list = list_new();
route->nh_list->cmp = (int (*)(void *, void *))ospf6_nexthop_cmp;
- route->nh_list->del = (void (*) (void *))ospf6_nexthop_delete;
+ route->nh_list->del = (void (*)(void *))ospf6_nexthop_delete;
route->paths = list_new();
route->paths->cmp = (int (*)(void *, void *))ospf6_path_cmp;
- route->paths->del = (void (*)(void *))ospf6_path_free;
+ route->paths->del = (void (*)(void *))ospf6_path_free;
return route;
}
for (target = ospf6_route_lookup(&route->prefix, table); target;
target = target->next) {
- if (target->type == route->type &&
- (memcmp(&target->prefix, &route->prefix,
- sizeof(struct prefix)) == 0) &&
- target->path.type == route->path.type &&
- target->path.cost == route->path.cost &&
- target->path.u.cost_e2 == route->path.u.cost_e2 &&
- ospf6_route_cmp_nexthops(target, route) == 0)
+ if (target->type == route->type
+ && (memcmp(&target->prefix, &route->prefix,
+ sizeof(struct prefix))
+ == 0)
+ && target->path.type == route->path.type
+ && target->path.cost == route->path.cost
+ && target->path.u.cost_e2 == route->path.u.cost_e2
+ && ospf6_route_cmp_nexthops(target, route) == 0)
return target;
}
return NULL;
}
if (IS_OSPF6_DEBUG_ROUTE(MEMORY))
- zlog_debug("%s %p: route add %p cost %u: update of %p old cost %u",
- ospf6_route_table_name(table), (void *)table,
- (void *)route, route->path.cost, (void *)old,
- old->path.cost);
+ zlog_debug(
+ "%s %p: route add %p cost %u: update of %p old cost %u",
+ ospf6_route_table_name(table), (void *)table,
+ (void *)route, route->path.cost, (void *)old,
+ old->path.cost);
else if (IS_OSPF6_DEBUG_ROUTE(TABLE))
zlog_debug("%s: route add: update",
ospf6_route_table_name(table));
if (len)
id = htonl(*offset);
offset += len;
- //offsetlen -= len; // Add back in if we need it again
+ // offsetlen -= len; // Add back in if we need it again
if (exact) {
if (v->magic & OSPFv3WWASTABLE) {
len = (offsetlen < 1 ? 0 : 1);
if (len)
instid = *offset;
- //offset += len; // Add back in if we ever start using again
- //offsetlen -= len;
+ // offset += len; // Add back in if we ever start using again
+ // offsetlen -= len;
if (exact) {
oi = ospf6_interface_lookup_by_ifindex(ifindex);
len = (offsetlen < 1 ? 0 : 1);
if (len)
rtrid = htonl(*offset);
- //offset += len; // Add back in if we ever start looking at data
- //offsetlen -= len;
+ // offset += len; // Add back in if we ever start looking at data
+ // offsetlen -= len;
if (exact) {
oi = ospf6_interface_lookup_by_ifindex(ifindex);
v->type = OSPF6_VERTEX_TYPE_ROUTER;
/* Router LSA use Link ID 0 as base in vertex_id */
ospf6_linkstate_prefix(lsa->header->adv_router, htonl(0),
- &v->vertex_id);
+ &v->vertex_id);
} else if (ntohs(lsa->header->type) == OSPF6_LSTYPE_NETWORK) {
v->type = OSPF6_VERTEX_TYPE_NETWORK;
/* vertex_id */
ospf6_linkstate_prefix(lsa->header->adv_router, lsa->header->id,
- &v->vertex_id);
+ &v->vertex_id);
} else
assert(0);
__func__, v->name,
((ntohs(lsa->header->type) == OSPF6_LSTYPE_ROUTER)
? "Router"
- : "N/W"), ntohs(lsa->header->type),
- lsa->name);
+ : "N/W"),
+ ntohs(lsa->header->type), lsa->name);
/* Associated LSA */
v->nh_list = list_new();
v->nh_list->cmp = (int (*)(void *, void *))ospf6_nexthop_cmp;
- v->nh_list->del = (void (*) (void *))ospf6_nexthop_delete;
+ v->nh_list->del = (void (*)(void *))ospf6_nexthop_delete;
v->parent = NULL;
v->child_list = list_new();
} else if (route && route->path.cost == v->cost) {
if (IS_OSPF6_DEBUG_SPF(PROCESS)) {
prefix2str(&route->prefix, pbuf, sizeof(pbuf));
- zlog_debug(" another path found to route %s lsa %s, merge",
- pbuf, v->lsa->name);
+ zlog_debug(
+ " another path found to route %s lsa %s, merge",
+ pbuf, v->lsa->name);
}
ospf6_spf_merge_nexthops_to_route(route, v);
prev = (struct ospf6_vertex *)route->route_option;
assert(prev->hops <= v->hops);
- if ((VERTEX_IS_TYPE(ROUTER, v) &&
- route->path.origin.id != v->lsa->header->id)) {
+ if ((VERTEX_IS_TYPE(ROUTER, v)
+ && route->path.origin.id != v->lsa->header->id)) {
if (IS_OSPF6_DEBUG_SPF(PROCESS)) {
- zlog_debug("%s: V lsa %s id %u, route id %u are different",
- __PRETTY_FUNCTION__, v->lsa->name,
- ntohl(v->lsa->header->id),
- ntohl(route->path.origin.id));
+ zlog_debug(
+ "%s: V lsa %s id %u, route id %u are different",
+ __PRETTY_FUNCTION__, v->lsa->name,
+ ntohl(v->lsa->header->id),
+ ntohl(route->path.origin.id));
}
return 0;
}
ospf6_vertex_delete(v);
return -1;
-
}
/* There should be no case where candidate being installed (variable
if (IS_OSPF6_DEBUG_SPF(PROCESS))
zlog_debug(
" New candidate: %s hops %d cost %d",
- w->name, w->hops, w->cost);
+ w->name, w->hops, w->cost);
pqueue_enqueue(w, candidate_list);
}
}
uint32_t interface_id;
caddr_t lsd;
- lsa_length = sizeof(struct ospf6_lsa_header) +
- sizeof(struct ospf6_router_lsa);
+ lsa_length = sizeof(struct ospf6_lsa_header)
+ + sizeof(struct ospf6_router_lsa);
total_lsa_length = lsa_length;
type = htons(OSPF6_LSTYPE_ROUTER);
rtr_lsa = ospf6_lsdb_next(end, rtr_lsa);
continue;
}
- lsa_header = (struct ospf6_lsa_header *) rtr_lsa->header;
- total_lsa_length += (ntohs(lsa_header->length)
- - lsa_length);
+ lsa_header = (struct ospf6_lsa_header *)rtr_lsa->header;
+ total_lsa_length += (ntohs(lsa_header->length) - lsa_length);
num_lsa++;
rtr_lsa = ospf6_lsdb_next(end, rtr_lsa);
}
if (IS_OSPF6_DEBUG_SPF(PROCESS))
zlog_debug("%s: adv_router %s num_lsa %u to convert.",
- __PRETTY_FUNCTION__, ifbuf, num_lsa);
+ __PRETTY_FUNCTION__, ifbuf, num_lsa);
if (num_lsa == 1)
return lsa;
lsd = OSPF6_LSA_HEADER_END(rtr_lsa->header) + 4;
interface_id = ROUTER_LSDESC_GET_IFID(lsd);
inet_ntop(AF_INET, &interface_id, ifbuf, sizeof(ifbuf));
- zlog_debug("%s: Next Router LSA %s to aggreat with len %u interface_id %s",
- __PRETTY_FUNCTION__, rtr_lsa->name,
- ntohs(lsa_header->length), ifbuf);
+ zlog_debug(
+ "%s: Next Router LSA %s to aggreat with len %u interface_id %s",
+ __PRETTY_FUNCTION__, rtr_lsa->name,
+ ntohs(lsa_header->length), ifbuf);
}
/* Append Next Link State ID LSA */
- lsa_header = (struct ospf6_lsa_header *) rtr_lsa->header;
+ lsa_header = (struct ospf6_lsa_header *)rtr_lsa->header;
memcpy(new_header, (OSPF6_LSA_HEADER_END(rtr_lsa->header) + 4),
(ntohs(lsa_header->length) - lsa_length));
new_header += (ntohs(lsa_header->length) - lsa_length);
for (ALL_LSDB(area->temp_router_lsa_lsdb, lsa)) {
if (IS_OSPF6_DEBUG_SPF(PROCESS))
- zlog_debug("%s Remove LSA %s lsa->lock %u lsdb count %u",
- __PRETTY_FUNCTION__,
- lsa->name, lsa->lock,
- area->temp_router_lsa_lsdb->count);
+ zlog_debug(
+ "%s Remove LSA %s lsa->lock %u lsdb count %u",
+ __PRETTY_FUNCTION__, lsa->name, lsa->lock,
+ area->temp_router_lsa_lsdb->count);
ospf6_lsdb_remove(lsa, area->temp_router_lsa_lsdb);
}
}
#if CONFDATE > 20180828
CPP_NOTICE("ospf6: `router-id A.B.C.D` deprecated 2017/08/28")
#endif
-ALIAS_HIDDEN(ospf6_router_id,
- ospf6_router_id_hdn_cmd,
- "router-id A.B.C.D",
- "Configure OSPF6 Router-ID\n"
- V4NOTATION_STR)
+ALIAS_HIDDEN(ospf6_router_id, ospf6_router_id_hdn_cmd, "router-id A.B.C.D",
+ "Configure OSPF6 Router-ID\n" V4NOTATION_STR)
#if CONFDATE > 20180828
CPP_NOTICE("ospf6: `no router-id A.B.C.D` deprecated 2017/08/28")
#endif
-ALIAS_HIDDEN(no_ospf6_router_id,
- no_ospf6_router_id_hdn_cmd,
+ALIAS_HIDDEN(no_ospf6_router_id, no_ospf6_router_id_hdn_cmd,
"no router-id [A.B.C.D]",
- NO_STR
- "Configure OSPF6 Router-ID\n"
- V4NOTATION_STR)
+ NO_STR "Configure OSPF6 Router-ID\n" V4NOTATION_STR)
DEFUN (ospf6_log_adjacency_changes,
ospf6_log_adjacency_changes_cmd,
lsdb = oa->lsdb_self;
else
lsdb = oa->lsdb;
- if (ospf6_create_single_router_lsa(oa, lsdb,
- adv_router) == NULL) {
+ if (ospf6_create_single_router_lsa(oa, lsdb, adv_router)
+ == NULL) {
vty_out(vty, "Adv router is not found in LSDB.");
return CMD_SUCCESS;
}
"looking at area %s",
inet_ntoa(area->area_id));
- LSDB_LOOP(NSSA_LSDB(area), rn, lsa)
+ LSDB_LOOP (NSSA_LSDB(area), rn, lsa)
ospf_abr_translate_nssa(area, lsa);
}
/* NSSA Translator is not checked, because it may have gone away,
and we would want to flush any residuals anyway */
- LSDB_LOOP(EXTERNAL_LSDB(ospf), rn, lsa)
+ LSDB_LOOP (EXTERNAL_LSDB(ospf), rn, lsa)
if (CHECK_FLAG(lsa->flags, OSPF_LSA_LOCAL_XLT)) {
UNSET_FLAG(lsa->flags, OSPF_LSA_APPROVED);
if (IS_DEBUG_OSPF_NSSA)
"ospf_abr_unapprove_summaries(): "
"considering area %s",
inet_ntoa(area->area_id));
- LSDB_LOOP(SUMMARY_LSDB(area), rn, lsa)
+ LSDB_LOOP (SUMMARY_LSDB(area), rn, lsa)
if (ospf_lsa_is_self_originated(ospf, lsa)) {
if (IS_DEBUG_OSPF_EVENT)
zlog_debug(
UNSET_FLAG(lsa->flags, OSPF_LSA_APPROVED);
}
- LSDB_LOOP(ASBR_SUMMARY_LSDB(area), rn, lsa)
+ LSDB_LOOP (ASBR_SUMMARY_LSDB(area), rn, lsa)
if (ospf_lsa_is_self_originated(ospf, lsa)) {
if (IS_DEBUG_OSPF_EVENT)
zlog_debug(
if (IS_DEBUG_OSPF_NSSA)
zlog_debug("ospf_abr_remove_unapproved_translates(): Start");
- LSDB_LOOP(EXTERNAL_LSDB(ospf), rn, lsa)
+ LSDB_LOOP (EXTERNAL_LSDB(ospf), rn, lsa)
ospf_abr_remove_unapproved_translates_apply(ospf, lsa);
if (IS_DEBUG_OSPF_NSSA)
"looking at area %s",
inet_ntoa(area->area_id));
- LSDB_LOOP(SUMMARY_LSDB(area), rn, lsa)
+ LSDB_LOOP (SUMMARY_LSDB(area), rn, lsa)
if (ospf_lsa_is_self_originated(ospf, lsa))
if (!CHECK_FLAG(lsa->flags, OSPF_LSA_APPROVED))
ospf_lsa_flush_area(lsa, area);
- LSDB_LOOP(ASBR_SUMMARY_LSDB(area), rn, lsa)
+ LSDB_LOOP (ASBR_SUMMARY_LSDB(area), rn, lsa)
if (ospf_lsa_is_self_originated(ospf, lsa))
if (!CHECK_FLAG(lsa->flags, OSPF_LSA_APPROVED))
ospf_lsa_flush_area(lsa, area);
if (CHECK_FLAG(range->flags,
OSPF_AREA_RANGE_ADVERTISE)) {
if (range->specifics)
- ospf_add_discard_route(ospf,
- ospf->new_table, area,
+ ospf_add_discard_route(
+ ospf, ospf->new_table,
+ area,
(struct prefix_ipv4
*)&rn->p);
else
- ospf_delete_discard_route(ospf,
- ospf->new_table,
+ ospf_delete_discard_route(
+ ospf, ospf->new_table,
(struct prefix_ipv4
*)&rn->p);
}
struct lsa_filter_type {
u_int16_t typemask; /* bitmask for selecting LSA types (1..16) */
u_char origin; /* selects according to origin. */
- /* $FRR indent$ */
- /* clang-format off */
#define NON_SELF_ORIGINATED 0
#define SELF_ORIGINATED (OSPF_LSA_SELF)
#define ANY_ORIGIN 2
if (i) {
/* Check msg type. */
if (mask & Power2[OSPF_ROUTER_LSA])
- LSDB_LOOP(ROUTER_LSDB(area), rn, lsa)
+ LSDB_LOOP (ROUTER_LSDB(area), rn, lsa)
apiserver_sync_callback(
lsa, (void *)¶m, seqnum);
if (mask & Power2[OSPF_NETWORK_LSA])
- LSDB_LOOP(NETWORK_LSDB(area), rn, lsa)
+ LSDB_LOOP (NETWORK_LSDB(area), rn, lsa)
apiserver_sync_callback(
lsa, (void *)¶m, seqnum);
if (mask & Power2[OSPF_SUMMARY_LSA])
- LSDB_LOOP(SUMMARY_LSDB(area), rn, lsa)
+ LSDB_LOOP (SUMMARY_LSDB(area), rn, lsa)
apiserver_sync_callback(
lsa, (void *)¶m, seqnum);
if (mask & Power2[OSPF_ASBR_SUMMARY_LSA])
- LSDB_LOOP(ASBR_SUMMARY_LSDB(area), rn, lsa)
+ LSDB_LOOP (ASBR_SUMMARY_LSDB(area), rn, lsa)
apiserver_sync_callback(
lsa, (void *)¶m, seqnum);
if (mask & Power2[OSPF_OPAQUE_LINK_LSA])
- LSDB_LOOP(OPAQUE_LINK_LSDB(area), rn, lsa)
+ LSDB_LOOP (OPAQUE_LINK_LSDB(area), rn, lsa)
apiserver_sync_callback(
lsa, (void *)¶m, seqnum);
if (mask & Power2[OSPF_OPAQUE_AREA_LSA])
- LSDB_LOOP(OPAQUE_AREA_LSDB(area), rn, lsa)
+ LSDB_LOOP (OPAQUE_AREA_LSDB(area), rn, lsa)
apiserver_sync_callback(
lsa, (void *)¶m, seqnum);
}
/* For AS-external LSAs */
if (ospf->lsdb) {
if (mask & Power2[OSPF_AS_EXTERNAL_LSA])
- LSDB_LOOP(EXTERNAL_LSDB(ospf), rn, lsa)
+ LSDB_LOOP (EXTERNAL_LSDB(ospf), rn, lsa)
apiserver_sync_callback(lsa, (void *)¶m,
seqnum);
}
/* For AS-external opaque LSAs */
if (ospf->lsdb) {
if (mask & Power2[OSPF_OPAQUE_AS_LSA])
- LSDB_LOOP(OPAQUE_AS_LSDB(ospf), rn, lsa)
+ LSDB_LOOP (OPAQUE_AS_LSDB(ospf), rn, lsa)
apiserver_sync_callback(lsa, (void *)¶m,
seqnum);
}
case OSPF_OPAQUE_LINK_LSA:
for (ALL_LIST_ELEMENTS(ospf->areas, node, nnode, area))
- LSDB_LOOP(OPAQUE_LINK_LSDB(area), rn, lsa)
+ LSDB_LOOP (OPAQUE_LINK_LSDB(area), rn, lsa)
apiserver_flush_opaque_type_callback(
lsa, (void *)¶m, 0);
break;
case OSPF_OPAQUE_AREA_LSA:
for (ALL_LIST_ELEMENTS(ospf->areas, node, nnode, area))
- LSDB_LOOP(OPAQUE_AREA_LSDB(area), rn, lsa)
+ LSDB_LOOP (OPAQUE_AREA_LSDB(area), rn, lsa)
apiserver_flush_opaque_type_callback(
lsa, (void *)¶m, 0);
break;
case OSPF_OPAQUE_AS_LSA:
- LSDB_LOOP(OPAQUE_LINK_LSDB(ospf), rn, lsa)
+ LSDB_LOOP (OPAQUE_LINK_LSDB(ospf), rn, lsa)
apiserver_flush_opaque_type_callback(lsa,
(void *)¶m, 0);
break;
/* Remove route from zebra. */
if (or->type == OSPF_DESTINATION_NETWORK)
- ospf_zebra_delete(ospf,
- (struct prefix_ipv4 *)&rn->p,
- or);
+ ospf_zebra_delete(
+ ospf, (struct prefix_ipv4 *)&rn->p, or);
ospf_route_free(or);
rn->info = NULL;
}
/* Add an External info for AS-external-LSA. */
-struct external_info *ospf_external_info_add(struct ospf *ospf, u_char type,
- u_short instance,
- struct prefix_ipv4 p,
- ifindex_t ifindex,
- struct in_addr nexthop,
- route_tag_t tag)
+struct external_info *
+ospf_external_info_add(struct ospf *ospf, u_char type, u_short instance,
+ struct prefix_ipv4 p, ifindex_t ifindex,
+ struct in_addr nexthop, route_tag_t tag)
{
struct external_info *new;
struct route_node *rn;
zlog_warn(
"Redistribute[%s][%d][%u]: %s/%d discarding old info with NH %s.",
ospf_redist_string(type), instance,
- ospf->vrf_id, inet_ntoa(p.prefix),
- p.prefixlen, inetbuf);
+ ospf->vrf_id, inet_ntoa(p.prefix), p.prefixlen,
+ inetbuf);
XFREE(MTYPE_OSPF_EXTERNAL_INFO, rn->info);
rn->info = NULL;
}
extern void ospf_reset_route_map_set_values(struct route_map_set_values *);
extern int ospf_route_map_set_compare(struct route_map_set_values *,
struct route_map_set_values *);
-extern struct external_info *ospf_external_info_add(struct ospf *,
- u_char, u_short,
- struct prefix_ipv4,
+extern struct external_info *ospf_external_info_add(struct ospf *, u_char,
+ u_short, struct prefix_ipv4,
ifindex_t, struct in_addr,
route_tag_t);
-extern void ospf_external_info_delete(struct ospf*, u_char, u_short,
+extern void ospf_external_info_delete(struct ospf *, u_char, u_short,
struct prefix_ipv4);
-extern struct external_info *ospf_external_info_lookup(struct ospf*, u_char,
- u_short,
- struct prefix_ipv4 *);
+extern struct external_info *
+ospf_external_info_lookup(struct ospf *, u_char, u_short, struct prefix_ipv4 *);
extern struct ospf_route *ospf_external_route_lookup(struct ospf *,
struct prefix_ipv4 *);
extern void ospf_asbr_status_update(struct ospf *, u_char);
if ((or = rn->info)) {
if (!(new_rn = route_node_lookup(new_external_route,
&rn->p)))
- ospf_zebra_delete(ospf,
- (struct prefix_ipv4 *)&rn->p,
- or);
+ ospf_zebra_delete(
+ ospf, (struct prefix_ipv4 *)&rn->p, or);
else
route_unlock_node(new_rn);
}
if ((or = rn->info) != NULL)
if (!ospf_ase_route_match_same(old_external_route,
&rn->p, or))
- ospf_zebra_add(ospf,
- (struct prefix_ipv4 *)&rn->p,
- or);
+ ospf_zebra_add(
+ ospf, (struct prefix_ipv4 *)&rn->p, or);
return 0;
}
monotime(&start_time);
/* Calculate external route for each AS-external-LSA */
- LSDB_LOOP(EXTERNAL_LSDB(ospf), rn, lsa)
+ LSDB_LOOP (EXTERNAL_LSDB(ospf), rn, lsa)
ospf_ase_calculate_route(ospf, lsa);
/* This version simple adds to the table all NSSA areas */
inet_ntoa(area->area_id));
if (area->external_routing == OSPF_AREA_NSSA)
- LSDB_LOOP(NSSA_LSDB(area), rn, lsa)
+ LSDB_LOOP (NSSA_LSDB(area), rn, lsa)
ospf_ase_calculate_route(ospf,
lsa);
}
/* kevinm: And add the NSSA routes in ospf_top */
- LSDB_LOOP(NSSA_LSDB(ospf), rn, lsa)
+ LSDB_LOOP (NSSA_LSDB(ospf), rn, lsa)
ospf_ase_calculate_route(ospf, lsa);
/* Compare old and new external routing table and install the
monotime(&stop_time);
if (IS_DEBUG_OSPF_EVENT)
- zlog_info("SPF Processing Time(usecs): External Routes: %lld\n",
- (stop_time.tv_sec - start_time.tv_sec) * 1000000LL
- + (stop_time.tv_usec - start_time.tv_usec));
+ zlog_info(
+ "SPF Processing Time(usecs): External Routes: %lld\n",
+ (stop_time.tv_sec - start_time.tv_sec)
+ * 1000000LL
+ + (stop_time.tv_usec
+ - start_time.tv_usec));
}
return 0;
}
zlog_info("EXT (%s): Register Extended Link Opaque LSA", __func__);
rc = ospf_register_opaque_functab(
OSPF_OPAQUE_AREA_LSA, OPAQUE_TYPE_EXTENDED_LINK_LSA,
- ospf_ext_link_new_if, /* new if */
- ospf_ext_link_del_if, /* del if */
+ ospf_ext_link_new_if, /* new if */
+ ospf_ext_link_del_if, /* del if */
ospf_ext_link_ism_change, /* ism change */
ospf_ext_link_nsm_change, /* nsm change */
NULL, /* Write router config. */
if ((algorithm != SR_ALGORITHM_SPF)
&& (algorithm != SR_ALGORITHM_STRICT_SPF)) {
- zlog_warn(
- "EXT (%s): unrecognized algorithm, not SPF or S-SPF",
- __func__);
+ zlog_warn("EXT (%s): unrecognized algorithm, not SPF or S-SPF",
+ __func__);
return;
}
htons(SID_INDEX_SIZE(EXT_SUBTLV_PREFIX_SID_SIZE));
exti->node_sid.value = htonl(value);
}
-
}
/* Adjacency SID SubTLV - section 6.1 */
exti->adj_sid[index].flags = flags; /* Set computed flags */
exti->adj_sid[index].mtid = 0; /* Multi-Topology is not supported */
exti->adj_sid[index].weight = 0; /* Load-Balancing is not supported */
-
}
/* LAN Adjacency SID SubTLV - section 6.2 */
exti->lan_sid[index].mtid = 0; /* Multi-Topology is not supported */
exti->lan_sid[index].weight = 0; /* Load-Balancing is not supported */
exti->lan_sid[index].neighbor_id = neighbor_id;
-
}
/* Experimental SubTLV from Cisco */
TLV_TYPE(exti->rmt_itf_addr) = htons(EXT_SUBTLV_RMT_ITF_ADDR);
TLV_LEN(exti->rmt_itf_addr) = htons(sizeof(struct in_addr));
exti->rmt_itf_addr.value = rmtif;
-
}
/*
* @return instance number if update is OK, 0 otherwise
*/
uint32_t ospf_ext_schedule_prefix_index(struct interface *ifp, uint32_t index,
- struct prefix_ipv4 *p, uint8_t flags)
+ struct prefix_ipv4 *p, uint8_t flags)
{
int rc = 0;
struct ext_itf *exti;
ospf_ext_pref_lsa_schedule(exti, REORIGINATE_THIS_LSA);
} else {
if (IS_DEBUG_OSPF_SR)
- zlog_debug(
- "EXT (%s): Remove prefix for interface %s",
- __func__, ifp->name);
+ zlog_debug("EXT (%s): Remove prefix for interface %s",
+ __func__, ifp->name);
if (CHECK_FLAG(exti->flags, EXT_LPFLG_LSA_ENGAGED)) {
ospf_ext_pref_lsa_schedule(exti, FLUSH_THIS_LSA);
struct ext_itf *exti;
if (IS_DEBUG_OSPF_SR)
- zlog_debug(
- "EXT (%s): %s Extended LSAs for Segment Routing ",
- __func__, enable ? "Enable" : "Disable");
+ zlog_debug("EXT (%s): %s Extended LSAs for Segment Routing ",
+ __func__, enable ? "Enable" : "Disable");
if (enable) {
OspfEXT.enabled = true;
int rc = -1;
if (lookup_ext_by_ifp(ifp) != NULL) {
- zlog_warn(
- "EXT (%s): interface %s is already in use",
- __func__, ifp ? ifp->name : "-");
+ zlog_warn("EXT (%s): interface %s is already in use", __func__,
+ ifp ? ifp->name : "-");
rc = 0; /* Do nothing here. */
return rc;
}
rc = 0;
} else {
- zlog_warn(
- "EXT (%s): interface %s is not found",
- __func__, ifp ? ifp->name : "-");
+ zlog_warn("EXT (%s): interface %s is not found", __func__,
+ ifp ? ifp->name : "-");
}
return rc;
/* Get interface information for Segment Routing */
exti = lookup_ext_by_ifp(oi->ifp);
if (exti == NULL) {
- zlog_warn(
- "EXT (%s): Cannot get Extended info. from OI(%s)",
- __func__, IF_NAME(oi));
+ zlog_warn("EXT (%s): Cannot get Extended info. from OI(%s)",
+ __func__, IF_NAME(oi));
return;
}
exti->instance = get_ext_link_instance_value();
exti->type = OPAQUE_TYPE_EXTENDED_LINK_LSA;
- zlog_debug(
- "EXT (%s): Set %s SID to interface %s ", __func__,
- exti->stype == ADJ_SID ? "Adj." : "LAN Adj.",
- oi->ifp->name);
+ zlog_debug("EXT (%s): Set %s SID to interface %s ", __func__,
+ exti->stype == ADJ_SID ? "Adj." : "LAN Adj.",
+ oi->ifp->name);
}
}
/* Get interface information for Segment Routing */
exti = lookup_ext_by_ifp(oi->ifp);
if (exti == NULL) {
- zlog_warn(
- "EXT (%s): Cannot get Extended info. from OI(%s)",
- __func__, IF_NAME(oi));
+ zlog_warn("EXT (%s): Cannot get Extended info. from OI(%s)",
+ __func__, IF_NAME(oi));
return;
}
exti->instance = get_ext_pref_instance_value();
exti->type = OPAQUE_TYPE_EXTENDED_PREFIX_LSA;
- zlog_debug(
- "EXT (%s): Set Node SID to interface %s ", __func__,
- oi->ifp->name);
+ zlog_debug("EXT (%s): Set Node SID to interface %s ", __func__,
+ oi->ifp->name);
/* Complete SRDB if the interface belongs to a Prefix */
if (OspfEXT.enabled)
/* Get interface information for Segment Routing */
exti = lookup_ext_by_ifp(oi->ifp);
if (exti == NULL) {
- zlog_warn(
- "EXT (%s): Cannot get Extended info. from OI(%s)",
- __func__, IF_NAME(oi));
+ zlog_warn("EXT (%s): Cannot get Extended info. from OI(%s)",
+ __func__, IF_NAME(oi));
return;
}
if (oi->area == NULL || oi->area->ospf == NULL) {
- zlog_warn(
- "EXT (%s): Cannot refer to OSPF from OI(%s)",
- __func__, IF_NAME(oi));
+ zlog_warn("EXT (%s): Cannot refer to OSPF from OI(%s)",
+ __func__, IF_NAME(oi));
return;
}
}
if (IS_DEBUG_OSPF_SR)
- zlog_debug(
- "EXT (%s): Complete %s SID to interface %s ", __func__,
- exti->stype == ADJ_SID ? "Adj." : "LAN Adj.",
- oi->ifp->name);
+ zlog_debug("EXT (%s): Complete %s SID to interface %s ",
+ __func__,
+ exti->stype == ADJ_SID ? "Adj." : "LAN Adj.",
+ oi->ifp->name);
/* flood this links params if everything is ok */
SET_FLAG(exti->flags, EXT_LPFLG_LSA_ACTIVE);
else
ospf_ext_link_lsa_schedule(exti, REORIGINATE_THIS_LSA);
}
-
}
/* Callbacks to handle Extended Link Segment Routing LSA information */
static void build_tlv_header(struct stream *s, struct tlv_header *tlvh)
{
stream_put(s, tlvh, sizeof(struct tlv_header));
-
}
static void build_tlv(struct stream *s, struct tlv_header *tlvh)
build_tlv_header(s, tlvh);
stream_put(s, TLV_DATA(tlvh), TLV_BODY_SIZE(tlvh));
}
-
}
/* Build an Extended Prefix Opaque LSA body for extended prefix TLV */
return;
/* Adjust Extended Prefix TLV size */
- TLV_LEN(exti->prefix) =
- htons(ntohs(TLV_LEN(exti->node_sid)) + EXT_TLV_PREFIX_SIZE
- + TLV_HDR_SIZE);
+ TLV_LEN(exti->prefix) = htons(ntohs(TLV_LEN(exti->node_sid))
+ + EXT_TLV_PREFIX_SIZE + TLV_HDR_SIZE);
/* Build LSA body for an Extended Prefix TLV */
build_tlv_header(s, &exti->prefix.header);
stream_put(s, TLV_DATA(&exti->prefix.header), EXT_TLV_PREFIX_SIZE);
/* Then add Prefix SID SubTLV */
build_tlv(s, &exti->node_sid.header);
-
}
/* Build an Extended Link Opaque LSA body for extended link TLV */
if (exti->stype == ADJ_SID) {
/* Adjust Extended Link TLV size for Adj. SID */
size = EXT_TLV_LINK_SIZE + 2 * EXT_SUBTLV_ADJ_SID_SIZE
- + 2 * TLV_HDR_SIZE;
+ + 2 * TLV_HDR_SIZE;
if (ntohs(TLV_TYPE(exti->rmt_itf_addr)) != 0)
size = size + EXT_SUBTLV_RMT_ITF_ADDR_SIZE
- + TLV_HDR_SIZE;
+ + TLV_HDR_SIZE;
TLV_LEN(exti->link) = htons(size);
/* Build LSA body for an Extended Link TLV with Adj. SID */
} else {
/* Adjust Extended Link TLV size for LAN SID */
size = EXT_TLV_LINK_SIZE
- + 2 * (EXT_SUBTLV_LAN_ADJ_SID_SIZE + TLV_HDR_SIZE);
+ + 2 * (EXT_SUBTLV_LAN_ADJ_SID_SIZE + TLV_HDR_SIZE);
TLV_LEN(exti->link) = htons(size);
/* Build LSA body for an Extended Link TLV with LAN SID */
build_tlv(s, &exti->lan_sid[1].header);
build_tlv(s, &exti->lan_sid[0].header);
}
-
}
/* Create new Extended Prefix opaque-LSA for every extended prefix */
zlog_debug(
"EXT (%s): LSA[Type%u:%s]: Originate Opaque-LSA "
"Extended Link Opaque LSA: Area(%s), Link(%s)",
- __func__, new->data->type, inet_ntoa(new->data->id),
- area_id, exti->ifp->name);
+ __func__, new->data->type, inet_ntoa(new->data->id),
+ area_id, exti->ifp->name);
ospf_lsa_header_dump(new->data);
}
if (!OspfEXT.enabled) {
zlog_info(
"EXT (%s): Segment Routing "
- "functionality is Disabled now", __func__);
+ "functionality is Disabled now",
+ __func__);
rc = 0; /* This is not an error case. */
return rc;
}
if (IS_DEBUG_OSPF_SR)
- zlog_debug(
- "EXT (%s): Start Originate Prefix LSA for area %s",
- __func__, inet_ntoa(area->area_id));
+ zlog_debug("EXT (%s): Start Originate Prefix LSA for area %s",
+ __func__, inet_ntoa(area->area_id));
/* Check if Extended Prefix Opaque LSA is already engaged */
for (ALL_LIST_ELEMENTS_RO(OspfEXT.iflist, node, exti)) {
EXT_LPFLG_LSA_FORCED_REFRESH)) {
zlog_warn(
"EXT (%s): Refresh instead of "
- "Originate", __func__);
+ "Originate",
+ __func__);
UNSET_FLAG(exti->flags,
EXT_LPFLG_LSA_FORCED_REFRESH);
ospf_ext_pref_lsa_schedule(exti,
if (!OspfEXT.enabled) {
zlog_info(
"EXT (%s): Segment Routing "
- "functionality is Disabled now", __func__);
+ "functionality is Disabled now",
+ __func__);
rc = 0; /* This is not an error case. */
return rc;
}
EXT_LPFLG_LSA_FORCED_REFRESH)) {
zlog_warn(
"EXT (%s): Refresh instead of "
- "Originate", __func__);
+ "Originate",
+ __func__);
UNSET_FLAG(exti->flags,
EXT_LPFLG_LSA_FORCED_REFRESH);
ospf_ext_link_lsa_schedule(exti,
*/
zlog_info(
"EXT (%s): Segment Routing functionality is "
- "Disabled", __func__);
+ "Disabled",
+ __func__);
/* Flush it anyway. */
lsa->data->ls_age = htons(OSPF_LSA_MAXAGE);
}
/* Check if Interface was not disable in the interval */
if ((exti != NULL) && !CHECK_FLAG(exti->flags, EXT_LPFLG_LSA_ACTIVE)) {
zlog_warn("EXT (%s): Interface was Disabled: Flush it!",
- __func__);
+ __func__);
/* Flush it anyway. */
lsa->data->ls_age = htons(OSPF_LSA_MAXAGE);
}
* This LSA must have flushed before due to OSPF-SR status
* change. It seems a slip among routers in the routing domain.
*/
- zlog_info(
- "EXT (%s): Segment Routing functionality is Disabled",
- __func__);
+ zlog_info("EXT (%s): Segment Routing functionality is Disabled",
+ __func__);
/* Flush it anyway. */
lsa->data->ls_age = htons(OSPF_LSA_MAXAGE);
}
/* Check if Interface was not disable in the interval */
if ((exti != NULL) && !CHECK_FLAG(exti->flags, EXT_LPFLG_LSA_ACTIVE)) {
- zlog_warn(
- "EXT (%s): Interface was Disabled: Flush it!",
- __func__);
+ zlog_warn("EXT (%s): Interface was Disabled: Flush it!",
+ __func__);
lsa->data->ls_age = htons(OSPF_LSA_MAXAGE);
}
if (!(CHECK_FLAG(exti->flags, EXT_LPFLG_LSA_ACTIVE)))
return;
- zlog_debug(
- "EXT (%s): Schedule %s%s%s LSA for interface %s", __func__,
- opcode == REORIGINATE_THIS_LSA ? "Re-Originate" : "",
- opcode == REFRESH_THIS_LSA ? "Refresh" : "",
- opcode == FLUSH_THIS_LSA ? "Flush" : "",
- exti->ifp ? exti->ifp->name : "-");
+ zlog_debug("EXT (%s): Schedule %s%s%s LSA for interface %s", __func__,
+ opcode == REORIGINATE_THIS_LSA ? "Re-Originate" : "",
+ opcode == REFRESH_THIS_LSA ? "Refresh" : "",
+ opcode == FLUSH_THIS_LSA ? "Flush" : "",
+ exti->ifp ? exti->ifp->name : "-");
/* Set LSA header information */
if (exti->area == NULL) {
zlog_warn(
"EXT (%s): Flooding is Area scope but area is not yet "
- "set", __func__);
+ "set",
+ __func__);
if (OspfEXT.area == NULL) {
top = ospf_lookup_by_vrf_id(VRF_DEFAULT);
OspfEXT.area = ospf_area_lookup_by_area_id(
zlog_warn("EXT (%s): Unknown opcode", __func__);
break;
}
-
}
/* Schedule Extended Link Opaque LSA origination/refreshment/flushing */
if (!(CHECK_FLAG(exti->flags, EXT_LPFLG_LSA_ACTIVE)))
return;
- zlog_debug(
- "EXT (%s): Schedule %s%s%s LSA for interface %s", __func__,
- opcode == REORIGINATE_THIS_LSA ? "Re-Originate" : "",
- opcode == REFRESH_THIS_LSA ? "Refresh" : "",
- opcode == FLUSH_THIS_LSA ? "Flush" : "",
- exti->ifp ? exti->ifp->name : "-");
+ zlog_debug("EXT (%s): Schedule %s%s%s LSA for interface %s", __func__,
+ opcode == REORIGINATE_THIS_LSA ? "Re-Originate" : "",
+ opcode == REFRESH_THIS_LSA ? "Refresh" : "",
+ opcode == FLUSH_THIS_LSA ? "Flush" : "",
+ exti->ifp ? exti->ifp->name : "-");
/* Set LSA header information */
if (exti->area == NULL) {
zlog_warn(
"EXT (%s): Flooding is Area scope but area is not "
- "yet set", __func__);
+ "yet set",
+ __func__);
if (OspfEXT.area == NULL) {
top = ospf_lookup_by_vrf_id(VRF_DEFAULT);
OspfEXT.area = ospf_area_lookup_by_area_id(
zlog_warn("EXT (%s): Unknown opcode", __func__);
break;
}
-
}
/* Schedule Extended Link or Prefix depending of the Type of LSA */
/* Cisco experimental SubTLV */
static uint16_t show_vty_ext_link_rmt_itf_addr(struct vty *vty,
- struct tlv_header *tlvh)
+ struct tlv_header *tlvh)
{
struct ext_subtlv_rmt_itf_addr *top;
/* Adjacency SID SubTLV */
static uint16_t show_vty_ext_link_adj_sid(struct vty *vty,
- struct tlv_header *tlvh)
+ struct tlv_header *tlvh)
{
struct ext_subtlv_adj_sid *top = (struct ext_subtlv_adj_sid *)tlvh;
/* LAN Adjacency SubTLV */
static uint16_t show_vty_ext_link_lan_adj_sid(struct vty *vty,
- struct tlv_header *tlvh)
+ struct tlv_header *tlvh)
{
struct ext_subtlv_lan_adj_sid *top =
(struct ext_subtlv_lan_adj_sid *)tlvh;
break;
}
}
-
}
/* Prefix SID SubTLV */
static uint16_t show_vty_ext_pref_pref_sid(struct vty *vty,
- struct tlv_header *tlvh)
+ struct tlv_header *tlvh)
{
struct ext_subtlv_prefix_sid *top =
(struct ext_subtlv_prefix_sid *)tlvh;
break;
}
}
-
}
extern void ospf_ext_finish(void);
extern void ospf_ext_update_sr(bool enable);
extern uint32_t ospf_ext_schedule_prefix_index(struct interface *ifp,
- uint32_t index,
- struct prefix_ipv4 *p,
- uint8_t flags);
+ uint32_t index,
+ struct prefix_ipv4 *p,
+ uint8_t flags);
#endif /* _FRR_OSPF_EXT_PREF_H_ */
break;
case OSPF_OPAQUE_AS_LSA:
ospf_opaque_lsa_refresh(new);
- /* Reconsideration may needed. */ /* XXX */
+ /* Reconsideration may needed. */ /* XXX */
break;
default:
break;
struct ospf_lsa *lsa;
struct route_node *rn;
- LSDB_LOOP(lsdb_rt, rn, lsa)
+ LSDB_LOOP (lsdb_rt, rn, lsa)
process_summary_lsa(area, rt, rtrs, lsa);
}
struct ospf_lsa *lsa;
struct route_node *rn;
- LSDB_LOOP(lsdb_rt, rn, lsa)
+ LSDB_LOOP (lsdb_rt, rn, lsa)
process_transit_summary_lsa(area, rt, rtrs, lsa);
}
}
if (IS_DEBUG_OSPF_EVENT)
- zlog_debug("ospf_vl_new(): creating pseudo zebra interface vrf id %u",
- ospf->vrf_id);
+ zlog_debug(
+ "ospf_vl_new(): creating pseudo zebra interface vrf id %u",
+ ospf->vrf_id);
snprintf(ifname, sizeof(ifname), "VLINK%d", vlink_count);
vi = if_create(ifname, ospf->vrf_id);
/* Neighbor information. */
struct route_table *nbrs; /* OSPF Neighbor List */
struct ospf_neighbor *nbr_self; /* Neighbor Self */
- /* $FRR indent$ */
- /* clang-format off */
#define DR(I) ((I)->nbr_self->d_router)
#define BDR(I) ((I)->nbr_self->bd_router)
#define OPTIONS(I) ((I)->nbr_self->options)
/* If there is no default route via redistribute,
then originate AS-external-LSA with nexthop 0 (self). */
nexthop.s_addr = 0;
- ospf_external_info_add(ospf, DEFAULT_ROUTE, 0, p, 0,
- nexthop, 0);
+ ospf_external_info_add(ospf, DEFAULT_ROUTE, 0, p, 0, nexthop,
+ 0);
}
if ((ei = ospf_default_external_info(ospf)))
for (ALL_LIST_ELEMENTS(ospf->areas, node, nnode, area)) {
if (area->external_routing == OSPF_AREA_NSSA) {
- lsa = ospf_lsa_lookup(ospf, area,
- OSPF_AS_NSSA_LSA, p->prefix,
- ospf->router_id);
+ lsa = ospf_lsa_lookup(ospf, area, OSPF_AS_NSSA_LSA,
+ p->prefix, ospf->router_id);
if (!lsa) {
if (IS_DEBUG_OSPF(lsa, LSA_FLOODING))
zlog_debug(
if (!is_prefix_default(&ei->p)) {
struct ospf_lsa *lsa;
- lsa = ospf_external_info_find_lsa(ospf,
- &ei->p);
+ lsa = ospf_external_info_find_lsa(
+ ospf, &ei->p);
if (lsa)
- ospf_external_lsa_refresh(ospf,
- lsa, ei, force);
+ ospf_external_lsa_refresh(
+ ospf, lsa, ei, force);
else
- ospf_external_lsa_originate(ospf
- , ei);
+ ospf_external_lsa_originate(
+ ospf, ei);
}
}
}
#if 0
/* This doesn't exist yet... */
ospf_summary_incremental_update(new); */
-#else /* #if 0 */
+#else /* #if 0 */
ospf_spf_calculate_schedule(ospf, SPF_FLAG_SUMMARY_LSA_INSTALL);
#endif /* #if 0 */
}
ospf->t_maxage_walker = NULL;
for (ALL_LIST_ELEMENTS(ospf->areas, node, nnode, area)) {
- LSDB_LOOP(ROUTER_LSDB(area), rn, lsa)
+ LSDB_LOOP (ROUTER_LSDB(area), rn, lsa)
ospf_lsa_maxage_walker_remover(ospf, lsa);
- LSDB_LOOP(NETWORK_LSDB(area), rn, lsa)
+ LSDB_LOOP (NETWORK_LSDB(area), rn, lsa)
ospf_lsa_maxage_walker_remover(ospf, lsa);
- LSDB_LOOP(SUMMARY_LSDB(area), rn, lsa)
+ LSDB_LOOP (SUMMARY_LSDB(area), rn, lsa)
ospf_lsa_maxage_walker_remover(ospf, lsa);
- LSDB_LOOP(ASBR_SUMMARY_LSDB(area), rn, lsa)
+ LSDB_LOOP (ASBR_SUMMARY_LSDB(area), rn, lsa)
ospf_lsa_maxage_walker_remover(ospf, lsa);
- LSDB_LOOP(OPAQUE_AREA_LSDB(area), rn, lsa)
+ LSDB_LOOP (OPAQUE_AREA_LSDB(area), rn, lsa)
ospf_lsa_maxage_walker_remover(ospf, lsa);
- LSDB_LOOP(OPAQUE_LINK_LSDB(area), rn, lsa)
+ LSDB_LOOP (OPAQUE_LINK_LSDB(area), rn, lsa)
ospf_lsa_maxage_walker_remover(ospf, lsa);
- LSDB_LOOP(NSSA_LSDB(area), rn, lsa)
+ LSDB_LOOP (NSSA_LSDB(area), rn, lsa)
ospf_lsa_maxage_walker_remover(ospf, lsa);
}
/* for AS-external-LSAs. */
if (ospf->lsdb) {
- LSDB_LOOP(EXTERNAL_LSDB(ospf), rn, lsa)
+ LSDB_LOOP (EXTERNAL_LSDB(ospf), rn, lsa)
ospf_lsa_maxage_walker_remover(ospf, lsa);
- LSDB_LOOP(OPAQUE_AS_LSDB(ospf), rn, lsa)
+ LSDB_LOOP (OPAQUE_AS_LSDB(ospf), rn, lsa)
ospf_lsa_maxage_walker_remover(ospf, lsa);
}
need_to_flush_ase = 1;
}
- LSDB_LOOP(SUMMARY_LSDB(area), rn, lsa)
+ LSDB_LOOP (SUMMARY_LSDB(area), rn, lsa)
ospf_lsa_flush_schedule(ospf, lsa);
- LSDB_LOOP(ASBR_SUMMARY_LSDB(area), rn, lsa)
+ LSDB_LOOP (ASBR_SUMMARY_LSDB(area), rn, lsa)
ospf_lsa_flush_schedule(ospf, lsa);
- LSDB_LOOP(OPAQUE_LINK_LSDB(area), rn, lsa)
+ LSDB_LOOP (OPAQUE_LINK_LSDB(area), rn, lsa)
ospf_lsa_flush_schedule(ospf, lsa);
- LSDB_LOOP(OPAQUE_AREA_LSDB(area), rn, lsa)
+ LSDB_LOOP (OPAQUE_AREA_LSDB(area), rn, lsa)
ospf_lsa_flush_schedule(ospf, lsa);
}
if (need_to_flush_ase) {
- LSDB_LOOP(EXTERNAL_LSDB(ospf), rn, lsa)
+ LSDB_LOOP (EXTERNAL_LSDB(ospf), rn, lsa)
ospf_lsa_flush_schedule(ospf, lsa);
- LSDB_LOOP(OPAQUE_AS_LSDB(ospf), rn, lsa)
+ LSDB_LOOP (OPAQUE_AS_LSDB(ospf), rn, lsa)
ospf_lsa_flush_schedule(ospf, lsa);
}
#include "ospfd/ospf_bfd.h"
/* ospfd privileges */
-zebra_capabilities_t _caps_p[] = {
- ZCAP_NET_RAW, ZCAP_BIND, ZCAP_NET_ADMIN, ZCAP_SYS_ADMIN
-};
+zebra_capabilities_t _caps_p[] = {ZCAP_NET_RAW, ZCAP_BIND, ZCAP_NET_ADMIN,
+ ZCAP_SYS_ADMIN};
struct zebra_privs_t ospfd_privs = {
#if defined(FRR_USER) && defined(FRR_GROUP)
rn = route_node_get(oi->nbrs, &p);
if (rn->info) {
/* There is already pseudo neighbor. */
- zlog_warn("router_id %s already present in neighbor table. node refcount %u",
- inet_ntoa(router_id), rn->lock);
+ zlog_warn(
+ "router_id %s already present in neighbor table. node refcount %u",
+ inet_ntoa(router_id), rn->lock);
route_unlock_node(rn);
} else
rn->info = oi->nbr_self;
if (oi->type == OSPF_IFTYPE_VIRTUALLINK
|| oi->type == OSPF_IFTYPE_POINTOPOINT)
- key.u.prefix4 =
- ospfh->router_id; /* index vlink and ptp nbrs by
- router-id */
+ key.u.prefix4 = ospfh->router_id; /* index vlink and ptp nbrs by
+ router-id */
else
key.u.prefix4 = iph->ip_src;
safe_strerror(errno));
else {
if (IS_DEBUG_OSPF_EVENT)
- zlog_debug("interface %s [%u] join AllSPFRouters Multicast group.",
- inet_ntoa(p->u.prefix4), ifindex);
+ zlog_debug(
+ "interface %s [%u] join AllSPFRouters Multicast group.",
+ inet_ntoa(p->u.prefix4), ifindex);
}
return ret;
safe_strerror(errno));
else {
if (IS_DEBUG_OSPF_EVENT)
- zlog_debug("interface %s [%u] leave AllSPFRouters Multicast group.",
- inet_ntoa(p->u.prefix4), ifindex);
+ zlog_debug(
+ "interface %s [%u] leave AllSPFRouters Multicast group.",
+ inet_ntoa(p->u.prefix4), ifindex);
}
return ret;
safe_strerror(errno));
}
- ospf_sock = vrf_socket(AF_INET, SOCK_RAW, IPPROTO_OSPFIGP,
- ospf->vrf_id, ospf->name);
+ ospf_sock = vrf_socket(AF_INET, SOCK_RAW, IPPROTO_OSPFIGP, ospf->vrf_id,
+ ospf->name);
if (ospf_sock < 0) {
int save_errno = errno;
/* Send proactive ARP requests */
ospf_proactively_arp(nbr);
- LSDB_LOOP(ROUTER_LSDB(area), rn, lsa)
+ LSDB_LOOP (ROUTER_LSDB(area), rn, lsa)
ospf_db_summary_add(nbr, lsa);
- LSDB_LOOP(NETWORK_LSDB(area), rn, lsa)
+ LSDB_LOOP (NETWORK_LSDB(area), rn, lsa)
ospf_db_summary_add(nbr, lsa);
- LSDB_LOOP(SUMMARY_LSDB(area), rn, lsa)
+ LSDB_LOOP (SUMMARY_LSDB(area), rn, lsa)
ospf_db_summary_add(nbr, lsa);
- LSDB_LOOP(ASBR_SUMMARY_LSDB(area), rn, lsa)
+ LSDB_LOOP (ASBR_SUMMARY_LSDB(area), rn, lsa)
ospf_db_summary_add(nbr, lsa);
/* Process only if the neighbor is opaque capable. */
if (CHECK_FLAG(nbr->options, OSPF_OPTION_O)) {
- LSDB_LOOP(OPAQUE_LINK_LSDB(area), rn, lsa)
+ LSDB_LOOP (OPAQUE_LINK_LSDB(area), rn, lsa)
ospf_db_summary_add(nbr, lsa);
- LSDB_LOOP(OPAQUE_AREA_LSDB(area), rn, lsa)
+ LSDB_LOOP (OPAQUE_AREA_LSDB(area), rn, lsa)
ospf_db_summary_add(nbr, lsa);
}
if (CHECK_FLAG(nbr->options, OSPF_OPTION_NP)) {
- LSDB_LOOP(NSSA_LSDB(area), rn, lsa)
+ LSDB_LOOP (NSSA_LSDB(area), rn, lsa)
ospf_db_summary_add(nbr, lsa);
}
if (nbr->oi->type != OSPF_IFTYPE_VIRTUALLINK
&& area->external_routing == OSPF_AREA_DEFAULT)
- LSDB_LOOP(EXTERNAL_LSDB(nbr->oi->ospf), rn, lsa)
+ LSDB_LOOP (EXTERNAL_LSDB(nbr->oi->ospf), rn, lsa)
ospf_db_summary_add(nbr, lsa);
if (CHECK_FLAG(nbr->options, OSPF_OPTION_O)
&& (nbr->oi->type != OSPF_IFTYPE_VIRTUALLINK
&& area->external_routing == OSPF_AREA_DEFAULT))
- LSDB_LOOP(OPAQUE_AS_LSDB(nbr->oi->ospf), rn, lsa)
+ LSDB_LOOP (OPAQUE_AS_LSDB(nbr->oi->ospf), rn, lsa)
ospf_db_summary_add(nbr, lsa);
return 0;
}
if (CHECK_FLAG(oi->ospf->config, OSPF_LOG_ADJACENCY_DETAIL))
- zlog_info("%s:(%s, %s -> %s): "
+ zlog_info(
+ "%s:(%s, %s -> %s): "
"scheduling new router-LSA origination",
__PRETTY_FUNCTION__, inet_ntoa(nbr->router_id),
lookup_msg(ospf_nsm_state_msg, old_state, NULL),
{
struct opaque_info_per_type *oipt = (struct opaque_info_per_type *)val;
- switch (oipt->lsa_type) {
- case OSPF_OPAQUE_LINK_LSA: {
- struct ospf_interface *oi =
- (struct ospf_interface *)(oipt->owner);
- listnode_delete(oi->opaque_lsa_self, oipt);
- break;
- }
- case OSPF_OPAQUE_AREA_LSA: {
- struct ospf_area *area = (struct ospf_area *)(oipt->owner);
- listnode_delete(area->opaque_lsa_self, oipt);
- break;
- }
- case OSPF_OPAQUE_AS_LSA: {
- struct ospf *top = (struct ospf *)(oipt->owner);
- listnode_delete(top->opaque_lsa_self, oipt);
- break;
- }
- default:
- zlog_warn("free_opaque_info_owner: Unexpected LSA-type(%u)",
- oipt->lsa_type);
- break; /* This case may not exist. */
- }
+ switch (oipt->lsa_type) {
+ case OSPF_OPAQUE_LINK_LSA: {
+ struct ospf_interface *oi =
+ (struct ospf_interface *)(oipt->owner);
+ listnode_delete(oi->opaque_lsa_self, oipt);
+ break;
+ }
+ case OSPF_OPAQUE_AREA_LSA: {
+ struct ospf_area *area = (struct ospf_area *)(oipt->owner);
+ listnode_delete(area->opaque_lsa_self, oipt);
+ break;
+ }
+ case OSPF_OPAQUE_AS_LSA: {
+ struct ospf *top = (struct ospf *)(oipt->owner);
+ listnode_delete(top->opaque_lsa_self, oipt);
+ break;
+ }
+ default:
+ zlog_warn("free_opaque_info_owner: Unexpected LSA-type(%u)",
+ oipt->lsa_type);
+ break; /* This case may not exist. */
+ }
}
static void free_opaque_info_per_type(void *val)
* list_isempty (oipt->id_list)
* not being empty.
*/
- if (
- oipt->t_opaque_lsa_self
- != NULL /* Waiting for a thread call. */
- || oipt->status == PROC_SUSPEND) /* Cannot
- originate
- now. */
+ if (oipt->t_opaque_lsa_self
+ != NULL /* Waiting for a thread call. */
+ || oipt->status == PROC_SUSPEND) /* Cannot
+ originate
+ now. */
continue;
ospf_opaque_lsa_reoriginate_schedule(
* list_isempty (oipt->id_list)
* not being empty.
*/
- if (
- oipt->t_opaque_lsa_self
- != NULL /* Waiting for a thread call. */
- || oipt->status == PROC_SUSPEND) /* Cannot
- originate
- now. */
+ if (oipt->t_opaque_lsa_self
+ != NULL /* Waiting for a thread call. */
+ || oipt->status == PROC_SUSPEND) /* Cannot
+ originate
+ now. */
continue;
ospf_opaque_lsa_reoriginate_schedule(
* list_isempty (oipt->id_list)
* not being empty.
*/
- if (
- oipt->t_opaque_lsa_self
- != NULL /* Waiting for a thread call. */
- || oipt->status == PROC_SUSPEND) /* Cannot
- originate
- now. */
+ if (oipt->t_opaque_lsa_self
+ != NULL /* Waiting for a thread call. */
+ || oipt->status == PROC_SUSPEND) /* Cannot
+ originate
+ now. */
continue;
ospf_opaque_lsa_reoriginate_schedule((void *)top,
#define SET_OPAQUE_LSID(type, id) \
((((unsigned)(type) << 24) & LSID_OPAQUE_TYPE_MASK) \
- | ((id) & LSID_OPAQUE_ID_MASK))
+ | ((id)&LSID_OPAQUE_ID_MASK))
/*
* Opaque LSA types will be assigned by IANA.
* used for various LSA opaque usage e.g. Traffic Engineering.
*/
struct tlv_header {
- u_int16_t type; /* Type of Value */
- u_int16_t length; /* Length of Value portion only, in bytes */
+ u_int16_t type; /* Type of Value */
+ u_int16_t length; /* Length of Value portion only, in bytes */
};
#define TLV_HDR_SIZE (sizeof(struct tlv_header))
-#define TLV_BODY_SIZE(tlvh) \
- (ROUNDUP(ntohs((tlvh)->length), sizeof(u_int32_t)))
+#define TLV_BODY_SIZE(tlvh) (ROUNDUP(ntohs((tlvh)->length), sizeof(u_int32_t)))
#define TLV_SIZE(tlvh) (TLV_HDR_SIZE + TLV_BODY_SIZE(tlvh))
-#define TLV_HDR_TOP(lsah) \
+#define TLV_HDR_TOP(lsah) \
(struct tlv_header *)((char *)(lsah) + OSPF_LSA_HEADER_SIZE)
-#define TLV_HDR_NEXT(tlvh) \
+#define TLV_HDR_NEXT(tlvh) \
(struct tlv_header *)((char *)(tlvh) + TLV_SIZE(tlvh))
-#define TLV_HDR_SUBTLV(tlvh) \
+#define TLV_HDR_SUBTLV(tlvh) \
(struct tlv_header *)((char *)(tlvh) + TLV_HDR_SIZE)
#define TLV_DATA(tlvh) (void *)((char *)(tlvh) + TLV_HDR_SIZE)
#define TLV_HDR(tlvh) tlvh.header
/* Following declaration concerns the Opaque LSA management */
-enum lsa_opcode {
- REORIGINATE_THIS_LSA,
- REFRESH_THIS_LSA,
- FLUSH_THIS_LSA
-};
+enum lsa_opcode { REORIGINATE_THIS_LSA, REFRESH_THIS_LSA, FLUSH_THIS_LSA };
/* Prototypes. */
}
if (listcount(update) > 0)
- ospf_ls_upd_send(nbr, update,
- OSPF_SEND_PACKET_DIRECT, 0);
+ ospf_ls_upd_send(nbr, update, OSPF_SEND_PACKET_DIRECT,
+ 0);
list_delete_and_null(&update);
}
static u_int16_t ipid = 0;
u_int16_t maxdatasize;
#endif /* WANT_OSPF_WRITE_FRAGMENT */
- /* $FRR indent$ */
- /* clang-format off */
#define OSPF_WRITE_IPHL_SHIFT 2
int pkt_count = 0;
msg.msg_controllen = cm->cmsg_len;
#endif
- /* Sadly we can not rely on kernels to fragment packets
- * because of either IP_HDRINCL and/or multicast
- * destination being set.
- */
+/* Sadly we can not rely on kernels to fragment packets
+ * because of either IP_HDRINCL and/or multicast
+ * destination being set.
+ */
#ifdef WANT_OSPF_WRITE_FRAGMENT
if (op->length > maxdatasize)
}
switch (type) {
- case OSPF_MSG_HELLO:
- oi->hello_out++;
- break;
- case OSPF_MSG_DB_DESC:
- oi->db_desc_out++;
- break;
- case OSPF_MSG_LS_REQ:
- oi->ls_req_out++;
- break;
- case OSPF_MSG_LS_UPD:
- oi->ls_upd_out++;
- break;
- case OSPF_MSG_LS_ACK:
- oi->ls_ack_out++;
- break;
- default:
- break;
+ case OSPF_MSG_HELLO:
+ oi->hello_out++;
+ break;
+ case OSPF_MSG_DB_DESC:
+ oi->db_desc_out++;
+ break;
+ case OSPF_MSG_LS_REQ:
+ oi->ls_req_out++;
+ break;
+ case OSPF_MSG_LS_UPD:
+ oi->ls_upd_out++;
+ break;
+ case OSPF_MSG_LS_ACK:
+ oi->ls_ack_out++;
+ break;
+ default:
+ break;
}
/* Now delete packet from queue. */
/* We're Slave---obey */
if (CHECK_FLAG(oi->ospf->config,
OSPF_LOG_ADJACENCY_DETAIL))
- zlog_info("Packet[DD]: Neighbor %s Negotiation done (Slave).",
- inet_ntoa(nbr->router_id));
+ zlog_info(
+ "Packet[DD]: Neighbor %s Negotiation done (Slave).",
+ inet_ntoa(nbr->router_id));
nbr->dd_seqnum = ntohl(dd->dd_seqnum);
/* Send rest of Link State Update. */
if (listcount(ls_upd) > 0) {
if (oi->type == OSPF_IFTYPE_NBMA)
- ospf_ls_upd_send(nbr, ls_upd,
- OSPF_SEND_PACKET_DIRECT, 0);
+ ospf_ls_upd_send(nbr, ls_upd, OSPF_SEND_PACKET_DIRECT,
+ 0);
else
- ospf_ls_upd_send(nbr, ls_upd,
- OSPF_SEND_PACKET_INDIRECT, 0);
+ ospf_ls_upd_send(nbr, ls_upd, OSPF_SEND_PACKET_INDIRECT,
+ 0);
list_delete_and_null(&ls_upd);
} else
return 0;
}
/* only MD5 crypto method can pass ospf_packet_examin() */
- if (
- NULL == (ck = listgetdata(listtail(
- OSPF_IF_PARAM(oi, auth_crypt))))
- || ospfh->u.crypt.key_id != ck->key_id ||
- /* Condition above uses the last key ID on the list,
- which is
- different from what ospf_crypt_key_lookup() does. A
- bug? */
- !ospf_check_md5_digest(oi, ospfh)) {
+ if (NULL == (ck = listgetdata(
+ listtail(OSPF_IF_PARAM(oi, auth_crypt))))
+ || ospfh->u.crypt.key_id != ck->key_id ||
+ /* Condition above uses the last key ID on the list,
+ which is
+ different from what ospf_crypt_key_lookup() does. A
+ bug? */
+ !ospf_check_md5_digest(oi, ospfh)) {
if (IS_DEBUG_OSPF_PACKET(ospfh->type - 1, RECV))
zlog_warn("interface %s: MD5 auth failed",
IF_NAME(oi));
if (IS_DEBUG_OSPF_EVENT) {
if (oi->ospf->vrf_id)
- zlog_debug("%s: Hello Tx interface %s ospf vrf %s id %u",
- __PRETTY_FUNCTION__, oi->ifp->name,
- ospf_vrf_id_to_name(oi->ospf->vrf_id),
- oi->ospf->vrf_id);
+ zlog_debug(
+ "%s: Hello Tx interface %s ospf vrf %s id %u",
+ __PRETTY_FUNCTION__, oi->ifp->name,
+ ospf_vrf_id_to_name(oi->ospf->vrf_id),
+ oi->ospf->vrf_id);
}
/* Add packet to the top of the interface output queue, so that they
* can't get delayed by things like long queues of LS Update packets
ospf_ls_upd_queue_send(oi, send_update_list,
rn->p.u.prefix4, 1);
-
}
} else
thread_add_event(master, ospf_ls_upd_send_queue_event, oi, 0,
- &oi->t_ls_upd_event);
+ &oi->t_ls_upd_event);
}
static void ospf_ls_ack_send_list(struct ospf_interface *oi, struct list *ack,
return;
snprintf(ping_nbr, sizeof(ping_nbr),
- "ping -c 1 -I %s %s > /dev/null 2>&1 &",
- nbr->oi->ifp->name, inet_ntoa(nbr->address.u.prefix4));
+ "ping -c 1 -I %s %s > /dev/null 2>&1 &", nbr->oi->ifp->name,
+ inet_ntoa(nbr->address.u.prefix4));
ret = system(ping_nbr);
if (IS_DEBUG_OSPF_EVENT)
scope, OPAQUE_TYPE_ROUTER_INFORMATION_LSA,
NULL, /* new interface */
NULL, /* del interface */
- ospf_router_info_ism_change,
- ospf_router_info_nsm_change,
+ ospf_router_info_ism_change, ospf_router_info_nsm_change,
ospf_router_info_config_write_router,
NULL, /* Config. write interface */
NULL, /* Config. write debug */
- ospf_router_info_show_info,
- ospf_router_info_lsa_originate,
- ospf_router_info_lsa_refresh,
- ospf_router_info_lsa_update,
+ ospf_router_info_show_info, ospf_router_info_lsa_originate,
+ ospf_router_info_lsa_refresh, ospf_router_info_lsa_update,
NULL); /* del_lsa_hook */
if (rc != 0) {
/* Set TLV type and length == only 1 Algorithm */
TLV_TYPE(OspfRI.sr_info.algo) = htons(RI_SR_TLV_SR_ALGORITHM);
TLV_LEN(OspfRI.sr_info.algo) = htons(sizeof(uint8_t));
-
}
/* unset Aglogithm SubTLV */
/* Unset TLV type and length */
TLV_TYPE(OspfRI.sr_info.algo) = htons(0);
TLV_LEN(OspfRI.sr_info.algo) = htons(0);
-
}
/* Segment Routing Global Block SubTLV - section 3.2 */
TLV_TYPE(OspfRI.sr_info.range.lower) = htons(SUBTLV_SID_LABEL);
TLV_LEN(OspfRI.sr_info.range.lower) = htons(SID_RANGE_LABEL_LENGTH);
OspfRI.sr_info.range.lower.value = htonl(SET_LABEL(srgb.lower_bound));
-
}
/* Unset this SRGB SubTLV */
TLV_LEN(OspfRI.sr_info.range) = htons(0);
TLV_TYPE(OspfRI.sr_info.range.lower) = htons(0);
TLV_LEN(OspfRI.sr_info.range.lower) = htons(0);
-
}
/* Set Maximum Stack Depth for this router */
TLV_TYPE(OspfRI.sr_info.msd) = htons(RI_SR_TLV_NODE_MSD);
TLV_LEN(OspfRI.sr_info.msd) = htons(sizeof(uint32_t));
OspfRI.sr_info.msd.value = msd;
-
}
/* Unset this router MSD */
{
TLV_TYPE(OspfRI.sr_info.msd) = htons(0);
TLV_LEN(OspfRI.sr_info.msd) = htons(0);
-
}
static void unset_param(struct tlv_header *tlv)
if (IS_DEBUG_OSPF_SR)
zlog_debug("RI-> %s Routing Information for Segment Routing",
- enable ? "Enable" : "Disable");
+ enable ? "Enable" : "Disable");
/* Unset or Set SR parameters */
if (!enable) {
if (OspfRI.pce_info.enabled) {
/* Compute PCE Info header first */
- set_pce_header (&OspfRI.pce_info);
+ set_pce_header(&OspfRI.pce_info);
/* Build PCE TLV */
build_tlv_header(s, &OspfRI.pce_info.pce_header.header);
opcode == FLUSH_THIS_LSA ? "Flush" : "");
/* Check LSA flags state coherence */
- if (!CHECK_FLAG(OspfRI.flags, RIFLG_LSA_ENGAGED) && (opcode != REORIGINATE_THIS_LSA))
+ if (!CHECK_FLAG(OspfRI.flags, RIFLG_LSA_ENGAGED)
+ && (opcode != REORIGINATE_THIS_LSA))
return;
- if (CHECK_FLAG(OspfRI.flags, RIFLG_LSA_ENGAGED) && (opcode == REORIGINATE_THIS_LSA))
+ if (CHECK_FLAG(OspfRI.flags, RIFLG_LSA_ENGAGED)
+ && (opcode == REORIGINATE_THIS_LSA))
opcode = REFRESH_THIS_LSA;
top = ospf_lookup_by_vrf_id(VRF_DEFAULT);
return 0;
/* Process only Router Information LSA */
- if (GET_OPAQUE_TYPE(ntohl(lsa->data->id.s_addr)) !=
- OPAQUE_TYPE_ROUTER_INFORMATION_LSA)
+ if (GET_OPAQUE_TYPE(ntohl(lsa->data->id.s_addr))
+ != OPAQUE_TYPE_ROUTER_INFORMATION_LSA)
return 0;
/* Check if it is not my LSA */
* Followings are vty session control functions.
*------------------------------------------------------------------------*/
-static u_int16_t show_vty_router_cap(struct vty *vty,
- struct tlv_header *tlvh)
+static u_int16_t show_vty_router_cap(struct vty *vty, struct tlv_header *tlvh)
{
struct ri_tlv_router_cap *top = (struct ri_tlv_router_cap *)tlvh;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_unknown_tlv(struct vty *vty,
- struct tlv_header *tlvh)
+static u_int16_t show_vty_unknown_tlv(struct vty *vty, struct tlv_header *tlvh)
{
if (vty != NULL)
vty_out(vty, " Unknown TLV: [type(0x%x), length(0x%x)]\n",
/* Refresh RI LSA if already engaged */
if (CHECK_FLAG(OspfRI.flags, RIFLG_LSA_ENGAGED)) {
- zlog_debug ("RI-> Refresh LSA following configuration");
- ospf_router_info_lsa_schedule (REFRESH_THIS_LSA);
+ zlog_debug("RI-> Refresh LSA following configuration");
+ ospf_router_info_lsa_schedule(REFRESH_THIS_LSA);
} else {
zlog_debug("RI-> Initial origination following configuration");
ospf_router_info_lsa_schedule(REORIGINATE_THIS_LSA);
&pce->pce_cap_flag.header);
} else {
- vty_out(vty,
- " PCE info is disabled on this router\n");
+ vty_out(vty, " PCE info is disabled on this router\n");
}
return CMD_SUCCESS;
void ospf_route_free(struct ospf_route * or)
{
if (or->paths)
- list_delete_and_null(&or->paths);
+ list_delete_and_null(& or->paths);
XFREE(MTYPE_OSPF_ROUTE, or);
}
for (rn = route_top(rt); rn; rn = route_next(rn))
if ((or = rn->info) != NULL) {
if (or->type == OSPF_DESTINATION_NETWORK)
- ospf_zebra_delete(ospf,
- (struct prefix_ipv4 *)&rn->p,
- or);
+ ospf_zebra_delete(
+ ospf, (struct prefix_ipv4 *)&rn->p, or);
else if (or->type == OSPF_DESTINATION_DISCARD)
- ospf_zebra_delete_discard(ospf,
- (struct prefix_ipv4 *)&rn->p);
+ ospf_zebra_delete_discard(
+ ospf, (struct prefix_ipv4 *)&rn->p);
}
}
cmprt,
(struct prefix_ipv4 *)&rn
->p))
- ospf_zebra_delete(ospf,
+ ospf_zebra_delete(
+ ospf,
(struct prefix_ipv4
*)&rn->p,
or);
cmprt,
(struct prefix_ipv4 *)&rn
->p))
- ospf_zebra_delete_discard(ospf,
+ ospf_zebra_delete_discard(
+ ospf,
(struct prefix_ipv4
*)&rn->p);
}
if (!ospf_route_match_same(
ospf->old_table,
(struct prefix_ipv4 *)&rn->p, or))
- ospf_zebra_add(ospf,
+ ospf_zebra_add(
+ ospf,
(struct prefix_ipv4 *)&rn->p,
or);
} else if (or->type == OSPF_DESTINATION_DISCARD)
if (!ospf_route_match_same(
ospf->old_table,
(struct prefix_ipv4 *)&rn->p, or))
- ospf_zebra_add_discard(ospf,
+ ospf_zebra_add_discard(
+ ospf,
(struct prefix_ipv4 *)&rn->p);
}
}
}
int ospf_add_discard_route(struct ospf *ospf, struct route_table *rt,
- struct ospf_area *area,
- struct prefix_ipv4 *p)
+ struct ospf_area *area, struct prefix_ipv4 *p)
{
struct route_node *rn;
struct ospf_route * or, *new_or;
struct route_map *old = ROUTEMAP(red);
/* Update route-map. */
- ROUTEMAP(red) = route_map_lookup_by_name(
- ROUTEMAP_NAME(red));
-
- /* No update for this distribute type. */
- if (old == NULL && ROUTEMAP(red) == NULL)
+ ROUTEMAP(red) =
+ route_map_lookup_by_name(
+ ROUTEMAP_NAME(red));
+
+ /* No update for this distribute type.
+ */
+ if (old == NULL
+ && ROUTEMAP(red) == NULL)
continue;
- ospf_distribute_list_update(ospf, type,
- red->instance);
+ ospf_distribute_list_update(
+ ospf, type, red->instance);
}
}
}
for (ALL_LIST_ELEMENTS_RO(red_list, node, red)) {
if (ROUTEMAP_NAME(red) && ROUTEMAP(red)
&& !strcmp(ROUTEMAP_NAME(red), name)) {
- ospf_distribute_list_update(ospf, type,
- red->instance);
+ ospf_distribute_list_update(
+ ospf, type, red->instance);
}
}
}
return SNMP_INTEGER(0);
break;
case OSPFAREASUMMARY: /* 9 */
- /* $FRR indent$ */
- /* clang-format off */
#define OSPF_noAreaSummary 1
#define OSPF_sendAreaSummary 2
if (area->no_summary)
return SNMP_INTEGER(SNMP_VALID);
break;
case OSPFSTUBMETRICTYPE: /* 5 */
-/* OSPF Metric type. */
+ /* OSPF Metric type. */
#define OSPF_ospfMetric 1
#define OSPF_comparableCost 2
#define OSPF_nonComparable 3
return SNMP_INTEGER(SNMP_VALID);
break;
case OSPFAREARANGEEFFECT: /* 5 */
- /* $FRR indent$ */
- /* clang-format off */
#define OSPF_advertiseMatching 1
#define OSPF_doNotAdvertiseMatching 2
return SNMP_INTEGER(OSPF_advertiseMatching);
return SNMP_INTEGER(SNMP_VALID);
break;
case OSPFIFMULTICASTFORWARDING: /* 18 */
- /* $FRR indent$ */
- /* clang-format off */
#define ospf_snmp_multiforward_blocked 1
#define ospf_snmp_multiforward_multicast 2
#define ospf_snmp_multiforward_unicast 3
* path is found to a vertex already on the candidate list, store the new cost.
*/
static void ospf_spf_next(struct vertex *v, struct ospf *ospf,
- struct ospf_area *area,
- struct pqueue *candidate)
+ struct ospf_area *area, struct pqueue *candidate)
{
struct ospf_lsa *w_lsa = NULL;
u_char *p;
ospf_ase_calculate_timer_add(ospf);
if (IS_DEBUG_OSPF_EVENT)
- zlog_debug("%s: ospf install new route, vrf %s id %u new_table count %lu",
- __PRETTY_FUNCTION__,
- ospf_vrf_id_to_name(ospf->vrf_id),
- ospf->vrf_id, new_table->count);
+ zlog_debug(
+ "%s: ospf install new route, vrf %s id %u new_table count %lu",
+ __PRETTY_FUNCTION__, ospf_vrf_id_to_name(ospf->vrf_id),
+ ospf->vrf_id, new_table->count);
/* Update routing table. */
monotime(&start_time);
ospf_route_install(ospf, new_table);
del_sid_nhlfe(srl->nhlfe[0]);
del_sid_nhlfe(srl->nhlfe[1]);
XFREE(MTYPE_OSPF_SR_PARAMS, val);
-
}
/* Functions to remove an SR Prefix */
del_sid_nhlfe(srp->nhlfe);
XFREE(MTYPE_OSPF_SR_PARAMS, val);
-
}
/* Allocate new Segment Routine node */
/* Start by looking to Router Info & Extended LSA in lsdb */
if ((ospf != NULL) && (ospf->backbone != NULL)) {
- LSDB_LOOP(OPAQUE_AREA_LSDB(ospf->backbone), rn, lsa)
- {
+ LSDB_LOOP (OPAQUE_AREA_LSDB(ospf->backbone), rn, lsa) {
if (IS_LSA_MAXAGE(lsa) || IS_LSA_SELF(lsa))
continue;
int lsa_id =
static struct ospf_path *get_nexthop_by_addr(struct ospf *top,
struct prefix_ipv4 p)
{
- struct ospf_route *or;
+ struct ospf_route * or ;
struct ospf_path *path;
struct listnode *node;
struct route_node *rn;
case EXT_SUBTLV_PREFIX_SID:
psid = (struct ext_subtlv_prefix_sid *)sub_tlvh;
if (psid->algorithm != SR_ALGORITHM_SPF) {
- zlog_err(
- "SR (%s): Unsupported Algorithm",
- __func__);
+ zlog_err("SR (%s): Unsupported Algorithm",
+ __func__);
XFREE(MTYPE_OSPF_SR_PARAMS, srp);
return NULL;
}
zlog_debug(
"SR (%s): Process Router "
"Information LSA 4.0.0.%u from %s",
- __func__,
- GET_OPAQUE_ID(ntohl(lsah->id.s_addr)),
+ __func__, GET_OPAQUE_ID(ntohl(lsah->id.s_addr)),
inet_ntoa(lsah->adv_router));
/* Sanity check */
/* Sanity check */
if (srn == NULL) {
- zlog_err(
- "SR (%s): Abort! can't create SR node in hash table",
- __func__);
+ zlog_err("SR (%s): Abort! can't create SR node in hash table",
+ __func__);
return;
}
zlog_err(
"SR (%s): Abort! Wrong "
"LSA ID 4.0.0.%u for SR node %s/%u",
- __func__,
- GET_OPAQUE_ID(ntohl(lsah->id.s_addr)),
+ __func__, GET_OPAQUE_ID(ntohl(lsah->id.s_addr)),
inet_ntoa(lsah->adv_router), srn->instance);
return;
}
/* Check that we collect mandatory parameters */
if (srn->algo[0] == SR_ALGORITHM_UNSET || srgb.range_size == 0
|| srgb.lower_bound == 0) {
- zlog_warn(
- "SR (%s): Missing mandatory parameters. Abort!",
- __func__);
+ zlog_warn("SR (%s): Missing mandatory parameters. Abort!",
+ __func__);
hash_release(OspfSR.neighbors, &(srn->adv_router));
XFREE(MTYPE_OSPF_SR_PARAMS, srn);
return;
void *))update_out_nhlfe,
(void *)srn);
}
-
}
/*
struct lsa_header *lsah = (struct lsa_header *)lsa->data;
if (IS_DEBUG_OSPF_SR)
- zlog_debug(
- "SR (%s): Remove SR node %s from lsa_id 4.0.0.%u",
- __func__, inet_ntoa(lsah->adv_router),
- GET_OPAQUE_ID(ntohl(lsah->id.s_addr)));
+ zlog_debug("SR (%s): Remove SR node %s from lsa_id 4.0.0.%u",
+ __func__, inet_ntoa(lsah->adv_router),
+ GET_OPAQUE_ID(ntohl(lsah->id.s_addr)));
/* Sanity check */
if (OspfSR.neighbors == NULL) {
/* Sanity check */
if (srn == NULL) {
- zlog_err(
- "SR (%s): Abort! no entry in SRDB for SR Node %s",
- __func__, inet_ntoa(lsah->adv_router));
+ zlog_err("SR (%s): Abort! no entry in SRDB for SR Node %s",
+ __func__, inet_ntoa(lsah->adv_router));
return;
}
if ((srn->instance != 0) && (srn->instance != ntohl(lsah->id.s_addr))) {
- zlog_err(
- "SR (%s): Abort! Wrong LSA ID 4.0.0.%u for SR node %s",
- __func__, GET_OPAQUE_ID(ntohl(lsah->id.s_addr)),
- inet_ntoa(lsah->adv_router));
+ zlog_err("SR (%s): Abort! Wrong LSA ID 4.0.0.%u for SR node %s",
+ __func__, GET_OPAQUE_ID(ntohl(lsah->id.s_addr)),
+ inet_ntoa(lsah->adv_router));
return;
}
/* Remove SR node */
sr_node_del(srn);
-
}
/* Update Segment Routing from Extended Link LSA */
/* Sanity check */
if (srn == NULL) {
- zlog_err(
- "SR (%s): Abort! can't create SR node in hash table",
- __func__);
+ zlog_err("SR (%s): Abort! can't create SR node in hash table",
+ __func__);
return;
}
uint32_t instance = ntohl(lsah->id.s_addr);
if (IS_DEBUG_OSPF_SR)
- zlog_debug(
- "SR (%s): Remove Extended Link LSA 8.0.0.%u from %s",
- __func__, GET_OPAQUE_ID(ntohl(lsah->id.s_addr)),
- inet_ntoa(lsah->adv_router));
+ zlog_debug("SR (%s): Remove Extended Link LSA 8.0.0.%u from %s",
+ __func__, GET_OPAQUE_ID(ntohl(lsah->id.s_addr)),
+ inet_ntoa(lsah->adv_router));
/* Sanity check */
if (OspfSR.neighbors == NULL) {
* processing Router Information LSA deletion
*/
if (srn == NULL) {
- zlog_warn(
- "SR (%s): Stop! no entry in SRDB for SR Node %s",
- __func__, inet_ntoa(lsah->adv_router));
+ zlog_warn("SR (%s): Stop! no entry in SRDB for SR Node %s",
+ __func__, inet_ntoa(lsah->adv_router));
return;
}
} else {
zlog_warn(
"SR (%s): Didn't found corresponding SR Link 8.0.0.%u "
- "for SR Node %s", __func__,
- GET_OPAQUE_ID(ntohl(lsah->id.s_addr)),
+ "for SR Node %s",
+ __func__, GET_OPAQUE_ID(ntohl(lsah->id.s_addr)),
inet_ntoa(lsah->adv_router));
}
-
}
/* Update Segment Routing from Extended Prefix LSA */
if (IS_DEBUG_OSPF_SR)
zlog_debug(
"SR (%s): Process Extended Prefix LSA "
- "7.0.0.%u from %s", __func__,
- GET_OPAQUE_ID(ntohl(lsah->id.s_addr)),
+ "7.0.0.%u from %s",
+ __func__, GET_OPAQUE_ID(ntohl(lsah->id.s_addr)),
inet_ntoa(lsah->adv_router));
/* Sanity check */
/* Sanity check */
if (srn == NULL) {
- zlog_err(
- "SR (%s): Abort! can't create SR node in hash table",
- __func__);
+ zlog_err("SR (%s): Abort! can't create SR node in hash table",
+ __func__);
return;
}
* processing Router Information LSA deletion
*/
if (srn == NULL) {
- zlog_warn(
- "SR (%s): Stop! no entry in SRDB for SR Node %s",
- __func__, inet_ntoa(lsah->adv_router));
+ zlog_warn("SR (%s): Stop! no entry in SRDB for SR Node %s",
+ __func__, inet_ntoa(lsah->adv_router));
return;
}
} else {
zlog_warn(
"SR (%s): Didn't found corresponding SR Prefix "
- "7.0.0.%u for SR Node %s", __func__,
- GET_OPAQUE_ID(ntohl(lsah->id.s_addr)),
+ "7.0.0.%u for SR Node %s",
+ __func__, GET_OPAQUE_ID(ntohl(lsah->id.s_addr)),
inet_ntoa(lsah->adv_router));
}
-
}
/* Get Label for Extended Link SID */
for (ALL_LIST_ELEMENTS_RO(OspfSR.self->ext_prefix, node, srp)) {
if ((srp->nhlfe.ifindex == ifp->ifindex)
|| ((IPV4_ADDR_SAME(&srp->nhlfe.prefv4.prefix,
- &p->u.prefix4))
- && (srp->nhlfe.prefv4.prefixlen == p->prefixlen))) {
+ &p->u.prefix4))
+ && (srp->nhlfe.prefv4.prefixlen == p->prefixlen))) {
/* Update Interface & Prefix info */
srp->nhlfe.ifindex = ifp->ifindex;
IPV4_ADDR_COPY(&srp->nhlfe.prefv4.prefix,
- &p->u.prefix4);
+ &p->u.prefix4);
srp->nhlfe.prefv4.prefixlen = p->prefixlen;
srp->nhlfe.prefv4.family = p->family;
IPV4_ADDR_COPY(&srp->nhlfe.nexthop, &p->u.prefix4);
/* OK. Let's Schedule Extended Prefix LSA */
- srp->instance = ospf_ext_schedule_prefix_index(ifp,
- srp->sid, &srp->nhlfe.prefv4, srp->flags);
+ srp->instance = ospf_ext_schedule_prefix_index(
+ ifp, srp->sid, &srp->nhlfe.prefv4, srp->flags);
/* Install NHLFE if NO-PHP is requested */
if (CHECK_FLAG(srp->flags,
- EXT_SUBTLV_PREFIX_SID_NPFLG)) {
- srp->nhlfe.label_in = index2label(srp->sid,
- OspfSR.self->srgb);
+ EXT_SUBTLV_PREFIX_SID_NPFLG)) {
+ srp->nhlfe.label_in = index2label(
+ srp->sid, OspfSR.self->srgb);
srp->nhlfe.label_out = MPLS_LABEL_IMPLICIT_NULL;
add_sid_nhlfe(srp->nhlfe);
}
zlog_debug("SR (%s): SPF Processing Time(usecs): %lld\n",
__func__,
(stop_time.tv_sec - start_time.tv_sec) * 1000000LL
- + (stop_time.tv_usec - start_time.tv_usec));
+ + (stop_time.tv_usec - start_time.tv_usec));
OspfSR.update = false;
return 1;
if ((OspfSR.srgb.lower_bound != MPLS_DEFAULT_MIN_SRGB_LABEL)
|| (OspfSR.srgb.range_size != MPLS_DEFAULT_MAX_SRGB_SIZE)) {
vty_out(vty, " segment-routing global-block %u %u\n",
- OspfSR.srgb.lower_bound,
- OspfSR.srgb.lower_bound +
- OspfSR.srgb.range_size - 1);
+ OspfSR.srgb.lower_bound,
+ OspfSR.srgb.lower_bound + OspfSR.srgb.range_size
+ - 1);
}
if (OspfSR.msd != 0)
vty_out(vty, " segment-routing node-msd %u\n",
inet_ntoa(srp->nhlfe.prefv4.prefix),
srp->nhlfe.prefv4.prefixlen, srp->sid,
CHECK_FLAG(srp->flags,
- EXT_SUBTLV_PREFIX_SID_NPFLG) ?
- " no-php-flag" : "");
+ EXT_SUBTLV_PREFIX_SID_NPFLG)
+ ? " no-php-flag"
+ : "");
}
}
}
return CMD_SUCCESS;
if (ospf->vrf_id != VRF_DEFAULT) {
- vty_out(vty, "Segment Routing is only supported in default "
- "VRF\n");
+ vty_out(vty,
+ "Segment Routing is only supported in default "
+ "VRF\n");
return CMD_WARNING_CONFIG_FAILED;
}
/* Get network prefix */
argv_find(argv, argc, "A.B.C.D/M", &idx);
if (!str2prefix(argv[idx]->arg, &p)) {
- vty_out(vty, "Invalid prefix format %s\n",
- argv[idx]->arg);
+ vty_out(vty, "Invalid prefix format %s\n", argv[idx]->arg);
return CMD_WARNING_CONFIG_FAILED;
}
}
if (IS_DEBUG_OSPF_SR)
- zlog_debug(
- "SR (%s): Add new index %u to Prefix %s/%u",
- __func__, index, inet_ntoa(new->nhlfe.prefv4.prefix),
- new->nhlfe.prefv4.prefixlen);
+ zlog_debug("SR (%s): Add new index %u to Prefix %s/%u",
+ __func__, index, inet_ntoa(new->nhlfe.prefv4.prefix),
+ new->nhlfe.prefv4.prefixlen);
/* Get Interface and check if it is a Loopback */
ifp = if_lookup_prefix(&p, VRF_DEFAULT);
listnode_add(OspfSR.self->ext_prefix, new);
zlog_warn(
"Interface for prefix %s/%u not found. Deferred LSA "
- "flooding", inet_ntoa(p.u.prefix4), p.prefixlen);
+ "flooding",
+ inet_ntoa(p.u.prefix4), p.prefixlen);
return CMD_SUCCESS;
}
/* Search if this prefix already exist */
for (ALL_LIST_ELEMENTS_RO(OspfSR.self->ext_prefix, node, srp)) {
if ((IPV4_ADDR_SAME(&srp->nhlfe.prefv4.prefix, &p.u.prefix4)
- && srp->nhlfe.prefv4.prefixlen == p.prefixlen))
+ && srp->nhlfe.prefv4.prefixlen == p.prefixlen))
break;
else
srp = NULL;
}
/* Finally, update Extended Prefix LSA */
- new->instance = ospf_ext_schedule_prefix_index(ifp, new->sid,
- &new->nhlfe.prefv4, new->flags);
+ new->instance = ospf_ext_schedule_prefix_index(
+ ifp, new->sid, &new->nhlfe.prefv4, new->flags);
if (new->instance == 0) {
vty_out(vty, "Unable to set index %u for prefix %s/%u\n", index,
inet_ntoa(p.u.prefix4), p.prefixlen);
argv_find(argv, argc, "A.B.C.D/M", &idx);
rc = str2prefix(argv[idx]->arg, &p);
if (!rc) {
- vty_out(vty, "Invalid prefix format %s\n",
- argv[idx]->arg);
+ vty_out(vty, "Invalid prefix format %s\n", argv[idx]->arg);
return CMD_WARNING_CONFIG_FAILED;
}
}
if (IS_DEBUG_OSPF_SR)
- zlog_debug(
- "SR (%s): Remove Prefix %s/%u with index %u",
- __func__, inet_ntoa(srp->nhlfe.prefv4.prefix),
- srp->nhlfe.prefv4.prefixlen, srp->sid);
+ zlog_debug("SR (%s): Remove Prefix %s/%u with index %u",
+ __func__, inet_ntoa(srp->nhlfe.prefv4.prefix),
+ srp->nhlfe.prefv4.prefixlen, srp->sid);
/* Delete NHLFE is NO-PHP is set */
if (CHECK_FLAG(srp->flags, EXT_SUBTLV_PREFIX_SID_NPFLG))
}
-
static void show_sr_node(struct vty *vty, struct json_object *json,
- struct sr_node *srn)
+ struct sr_node *srn)
{
struct listnode *node;
if (json) {
json_node = json_object_new_object();
json_object_string_add(json_node, "routerID",
- inet_ntoa(srn->adv_router));
+ inet_ntoa(srn->adv_router));
json_object_int_add(json_node, "srgbSize",
- srn->srgb.range_size);
+ srn->srgb.range_size);
json_object_int_add(json_node, "srgbLabel",
- srn->srgb.lower_bound);
+ srn->srgb.lower_bound);
json_algo = json_object_new_array();
json_object_object_add(json_node, "algorithms", json_algo);
for (int i = 0; i < ALGORITHM_COUNT; i++) {
snprintf(tmp, 2, "%u", i);
json_object_string_add(json_obj, tmp,
- srn->algo[i] == SR_ALGORITHM_SPF ?
- "SPF" : "S-SPF");
+ srn->algo[i] == SR_ALGORITHM_SPF
+ ? "SPF"
+ : "S-SPF");
json_object_array_add(json_algo, json_obj);
}
if (srn->msd != 0)
json_object_int_add(json_node, "nodeMsd", srn->msd);
} else {
vty_out(vty, "SR-Node: %s", inet_ntoa(srn->adv_router));
- vty_out(vty, "\tSRGB (Size/Label): %u/%u",
- srn->srgb.range_size, srn->srgb.lower_bound);
+ vty_out(vty, "\tSRGB (Size/Label): %u/%u", srn->srgb.range_size,
+ srn->srgb.lower_bound);
vty_out(vty, "\tAlgorithm(s): %s",
srn->algo[0] == SR_ALGORITHM_SPF ? "SPF" : "S-SPF");
for (int i = 1; i < ALGORITHM_COUNT; i++) {
if (srn->algo[i] == SR_ALGORITHM_UNSET)
continue;
vty_out(vty, "/%s",
- srn->algo[i] == SR_ALGORITHM_SPF ?
- "SPF" : "S-SPF");
+ srn->algo[i] == SR_ALGORITHM_SPF ? "SPF"
+ : "S-SPF");
}
if (srn->msd != 0)
vty_out(vty, "\tMSD: %u", srn->msd);
"--------------------- --------- ---------------\n");
}
for (ALL_LIST_ELEMENTS_RO(srn->ext_prefix, node, srp)) {
- snprintf(pref, 19, "%s/%u",
- inet_ntoa(srp->nhlfe.prefv4.prefix),
- srp->nhlfe.prefv4.prefixlen);
+ snprintf(pref, 19, "%s/%u", inet_ntoa(srp->nhlfe.prefv4.prefix),
+ srp->nhlfe.prefv4.prefixlen);
snprintf(sid, 22, "SR Pfx (idx %u)", srp->sid);
if (srp->nhlfe.label_out == MPLS_LABEL_IMPLICIT_NULL)
sprintf(label, "pop");
if (!json_prefix) {
json_prefix = json_object_new_array();
json_object_object_add(json_node,
- "extendedPrefix", json_prefix);
+ "extendedPrefix",
+ json_prefix);
}
json_obj = json_object_new_object();
json_object_string_add(json_obj, "prefix", pref);
json_object_int_add(json_obj, "sid", srp->sid);
json_object_int_add(json_obj, "inputLabel",
- srp->nhlfe.label_in);
- json_object_string_add(json_obj, "outputLabel",
- label);
+ srp->nhlfe.label_in);
+ json_object_string_add(json_obj, "outputLabel", label);
json_object_string_add(json_obj, "interface",
- itf ? itf->name : "-");
+ itf ? itf->name : "-");
json_object_string_add(json_obj, "nexthop",
- inet_ntoa(srp->nhlfe.nexthop));
+ inet_ntoa(srp->nhlfe.nexthop));
json_object_array_add(json_prefix, json_obj);
} else {
- vty_out(vty, "%18s %8u %9s %21s %9s %15s\n",
- pref, srp->nhlfe.label_in, label,
- sid, itf ? itf->name : "-",
+ vty_out(vty, "%18s %8u %9s %21s %9s %15s\n", pref,
+ srp->nhlfe.label_in, label, sid,
+ itf ? itf->name : "-",
inet_ntoa(srp->nhlfe.nexthop));
}
}
for (ALL_LIST_ELEMENTS_RO(srn->ext_link, node, srl)) {
snprintf(pref, 19, "%s/%u",
- inet_ntoa(srl->nhlfe[0].prefv4.prefix),
- srl->nhlfe[0].prefv4.prefixlen);
+ inet_ntoa(srl->nhlfe[0].prefv4.prefix),
+ srl->nhlfe[0].prefv4.prefixlen);
snprintf(sid, 22, "SR Adj. (lbl %u)", srl->sid[0]);
if (srl->nhlfe[0].label_out == MPLS_LABEL_IMPLICIT_NULL)
sprintf(label, "pop");
if (json) {
if (!json_link) {
json_link = json_object_new_array();
- json_object_object_add(json_node,
- "extendedLink", json_link);
+ json_object_object_add(
+ json_node, "extendedLink", json_link);
}
/* Primary Link */
json_obj = json_object_new_object();
json_object_string_add(json_obj, "prefix", pref);
json_object_int_add(json_obj, "sid", srl->sid[0]);
json_object_int_add(json_obj, "inputLabel",
- srl->nhlfe[0].label_in);
- json_object_string_add(json_obj, "outputLabel",
- label);
+ srl->nhlfe[0].label_in);
+ json_object_string_add(json_obj, "outputLabel", label);
json_object_string_add(json_obj, "interface",
- itf ? itf->name : "-");
- json_object_string_add(json_obj, "nexthop",
+ itf ? itf->name : "-");
+ json_object_string_add(
+ json_obj, "nexthop",
inet_ntoa(srl->nhlfe[0].nexthop));
json_object_array_add(json_link, json_obj);
/* Backup Link */
json_object_string_add(json_obj, "prefix", pref);
json_object_int_add(json_obj, "sid", srl->sid[1]);
json_object_int_add(json_obj, "inputLabel",
- srl->nhlfe[1].label_in);
- json_object_string_add(json_obj, "outputLabel",
- label);
+ srl->nhlfe[1].label_in);
+ json_object_string_add(json_obj, "outputLabel", label);
json_object_string_add(json_obj, "interface",
- itf ? itf->name : "-");
- json_object_string_add(json_obj, "nexthop",
+ itf ? itf->name : "-");
+ json_object_string_add(
+ json_obj, "nexthop",
inet_ntoa(srl->nhlfe[1].nexthop));
json_object_array_add(json_link, json_obj);
} else {
- vty_out(vty, "%18s %8u %9s %21s %9s %15s\n",
- pref, srl->nhlfe[0].label_in,
- label, sid, itf ? itf->name : "-",
+ vty_out(vty, "%18s %8u %9s %21s %9s %15s\n", pref,
+ srl->nhlfe[0].label_in, label, sid,
+ itf ? itf->name : "-",
inet_ntoa(srl->nhlfe[0].nexthop));
snprintf(sid, 22, "SR Adj. (lbl %u)", srl->sid[1]);
if (srl->nhlfe[1].label_out == MPLS_LABEL_IMPLICIT_NULL)
sprintf(label, "pop");
else
sprintf(label, "%u", srl->nhlfe[1].label_out);
- vty_out(vty, "%18s %8u %9s %21s %9s %15s\n",
- pref, srl->nhlfe[1].label_in,
- label, sid, itf ? itf->name : "-",
+ vty_out(vty, "%18s %8u %9s %21s %9s %15s\n", pref,
+ srl->nhlfe[1].label_in, label, sid,
+ itf ? itf->name : "-",
inet_ntoa(srl->nhlfe[1].nexthop));
}
}
json = json_object_new_object();
json_node_array = json_object_new_array();
json_object_string_add(json, "srdbID",
- inet_ntoa(OspfSR.self->adv_router));
+ inet_ntoa(OspfSR.self->adv_router));
json_object_object_add(json, "srNodes", json_node_array);
} else {
vty_out(vty,
show_sr_node(vty, json_node_array, srn);
if (uj) {
vty_out(vty, "%s\n",
- json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
}
return CMD_SUCCESS;
if (argv_find(argv, argc, "A.B.C.D", &idx)) {
if (!inet_aton(argv[idx]->arg, &rid)) {
- vty_out(vty,
- "Specified Router ID %s is invalid\n",
+ vty_out(vty, "Specified Router ID %s is invalid\n",
argv[idx]->arg);
return CMD_WARNING_CONFIG_FAILED;
}
show_sr_node(vty, json_node_array, srn);
if (uj) {
vty_out(vty, "%s\n",
- json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
}
return CMD_SUCCESS;
/* No parameters have been provided, Iterate through all the SRDB */
if (uj) {
- hash_iterate(
- OspfSR.neighbors,
- (void (*)(struct hash_backet *, void *))show_json_srdb,
- (void *)json_node_array);
- vty_out(vty, "%s\n",
- json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ hash_iterate(OspfSR.neighbors, (void (*)(struct hash_backet *,
+ void *))show_json_srdb,
+ (void *)json_node_array);
+ vty_out(vty, "%s\n", json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
} else {
- hash_iterate(
- OspfSR.neighbors,
- (void (*)(struct hash_backet *, void *))show_vty_srdb,
- (void *)vty);
+ hash_iterate(OspfSR.neighbors, (void (*)(struct hash_backet *,
+ void *))show_vty_srdb,
+ (void *)vty);
}
return CMD_SUCCESS;
}
install_element(OSPF_NODE, &no_sr_node_msd_cmd);
install_element(OSPF_NODE, &sr_prefix_sid_cmd);
install_element(OSPF_NODE, &no_sr_prefix_sid_cmd);
-
}
return NULL;
}
-static void ospf_mpls_te_foreach_area(void (*func)(struct mpls_te_link *lp,
- enum lsa_opcode sched_opcode),
- enum lsa_opcode sched_opcode)
+static void ospf_mpls_te_foreach_area(
+ void (*func)(struct mpls_te_link *lp, enum lsa_opcode sched_opcode),
+ enum lsa_opcode sched_opcode)
{
struct listnode *node, *nnode;
struct listnode *node2;
ifp->name);
/* Search OSPF Interface parameters for this interface */
- for (rn = route_top (IF_OIFS (ifp)); rn; rn = route_next (rn)) {
+ for (rn = route_top(IF_OIFS(ifp)); rn; rn = route_next(rn)) {
if ((oi = rn->info) == NULL)
continue;
if (OspfMplsTE.enabled)
if (lp->area != NULL) {
if (CHECK_FLAG(lp->flags, LPFLG_LSA_ENGAGED))
- ospf_mpls_te_lsa_schedule(lp, REFRESH_THIS_LSA);
+ ospf_mpls_te_lsa_schedule(
+ lp, REFRESH_THIS_LSA);
else
- ospf_mpls_te_lsa_schedule(lp, REORIGINATE_THIS_LSA);
+ ospf_mpls_te_lsa_schedule(
+ lp, REORIGINATE_THIS_LSA);
}
} else {
/* If MPLS TE is disable on this interface, flush LSA if it is
if (CHECK_FLAG(lp->flags, LPFLG_LSA_ENGAGED))
ospf_mpls_te_lsa_schedule(lp, REFRESH_THIS_LSA);
else
- ospf_mpls_te_lsa_schedule(lp, REORIGINATE_THIS_LSA);
+ ospf_mpls_te_lsa_schedule(lp,
+ REORIGINATE_THIS_LSA);
}
break;
default:
struct mpls_te_link *lp;
int rc = -1;
- if ((!OspfMplsTE.enabled)
- || (OspfMplsTE.inter_as == Off)) {
+ if ((!OspfMplsTE.enabled) || (OspfMplsTE.inter_as == Off)) {
zlog_info(
"ospf_mpls_te_lsa_originate_as: MPLS-TE Inter-AS is disabled for now.");
rc = 0; /* This is not an error case. */
if (CHECK_FLAG(lp->flags, LPFLG_LSA_ENGAGED)) {
if (CHECK_FLAG(lp->flags, LPFLG_LSA_FORCED_REFRESH)) {
- UNSET_FLAG(lp->flags,LPFLG_LSA_FORCED_REFRESH);
+ UNSET_FLAG(lp->flags, LPFLG_LSA_FORCED_REFRESH);
ospf_mpls_te_lsa_schedule(lp, REFRESH_THIS_LSA);
}
continue;
* Followings are vty session control functions.
*------------------------------------------------------------------------*/
-static u_int16_t show_vty_router_addr(struct vty *vty,
- struct tlv_header *tlvh)
+static u_int16_t show_vty_router_addr(struct vty *vty, struct tlv_header *tlvh)
{
struct te_tlv_router_addr *top = (struct te_tlv_router_addr *)tlvh;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_link_header(struct vty *vty,
- struct tlv_header *tlvh)
+static u_int16_t show_vty_link_header(struct vty *vty, struct tlv_header *tlvh)
{
struct te_tlv_link *top = (struct te_tlv_link *)tlvh;
return TLV_SIZE(tlvh);
}
-static u_int16_t show_vty_unknown_tlv(struct vty *vty,
- struct tlv_header *tlvh)
+static u_int16_t show_vty_unknown_tlv(struct vty *vty, struct tlv_header *tlvh)
{
if (vty != NULL)
vty_out(vty, " Unknown TLV: [type(0x%x), length(0x%x)]\n",
if (IS_DEBUG_OSPF_EVENT)
zlog_debug("MPLS-TE: Inter-AS support OFF");
- if ((OspfMplsTE.enabled)
- && (OspfMplsTE.inter_as != Off)) {
+ if ((OspfMplsTE.enabled) && (OspfMplsTE.inter_as != Off)) {
OspfMplsTE.inter_as = Off;
/* Flush all Inter-AS LSA */
for (ALL_LIST_ELEMENTS(OspfMplsTE.iflist, node, nnode, lp))
{
struct mpls_te_link *lp;
- if ((OspfMplsTE.enabled) && HAS_LINK_PARAMS(ifp)
- && !if_is_loopback(ifp) && if_is_up(ifp)
+ if ((OspfMplsTE.enabled) && HAS_LINK_PARAMS(ifp) && !if_is_loopback(ifp)
+ && if_is_up(ifp)
&& ((lp = lookup_linkparams_by_ifp(ifp)) != NULL)) {
/* Continue only if interface is not passive or support Inter-AS
* TEv2 */
}
return CMD_SUCCESS;
}
- ospf = ospf_lookup_by_inst_name (inst, vrf_name);
+ ospf = ospf_lookup_by_inst_name(inst, vrf_name);
if (ospf == NULL || !ospf->oi_running)
return CMD_SUCCESS;
vrf = vrf_lookup_by_id(ospf->vrf_id);
#define TE_LINK_SUBTLV_LINK_ID 2
struct te_link_subtlv_link_id {
struct tlv_header header; /* Value length is 4 octets. */
- struct in_addr value; /* Same as router-lsa's link-id. */
+ struct in_addr value; /* Same as router-lsa's link-id. */
};
/* Link Sub-TLV: Local Interface IP Address */ /* Optional */
#define TE_LINK_SUBTLV_LCLIF_IPADDR 3
struct te_link_subtlv_lclif_ipaddr {
struct tlv_header header; /* Value length is 4 x N octets. */
- struct in_addr value[1]; /* Local IP address(es). */
+ struct in_addr value[1]; /* Local IP address(es). */
};
/* Link Sub-TLV: Remote Interface IP Address */ /* Optional */
#define TE_LINK_SUBTLV_RMTIF_IPADDR 4
struct te_link_subtlv_rmtif_ipaddr {
struct tlv_header header; /* Value length is 4 x N octets. */
- struct in_addr value[1]; /* Neighbor's IP address(es). */
+ struct in_addr value[1]; /* Neighbor's IP address(es). */
};
/* Link Sub-TLV: Traffic Engineering Metric */ /* Optional */
#define TE_LINK_SUBTLV_TE_METRIC 5
struct te_link_subtlv_te_metric {
struct tlv_header header; /* Value length is 4 octets. */
- u_int32_t value; /* Link metric for TE purpose. */
+ u_int32_t value; /* Link metric for TE purpose. */
};
/* Link Sub-TLV: Maximum Bandwidth */ /* Optional */
#define TE_LINK_SUBTLV_MAX_BW 6
struct te_link_subtlv_max_bw {
struct tlv_header header; /* Value length is 4 octets. */
- float value; /* bytes/sec */
+ float value; /* bytes/sec */
};
/* Link Sub-TLV: Maximum Reservable Bandwidth */ /* Optional */
#define TE_LINK_SUBTLV_MAX_RSV_BW 7
struct te_link_subtlv_max_rsv_bw {
struct tlv_header header; /* Value length is 4 octets. */
- float value; /* bytes/sec */
+ float value; /* bytes/sec */
};
/* Link Sub-TLV: Unreserved Bandwidth */ /* Optional */
#define TE_LINK_SUBTLV_UNRSV_BW 8
#define TE_LINK_SUBTLV_UNRSV_SIZE 32
struct te_link_subtlv_unrsv_bw {
- struct tlv_header header; /* Value length is 32 octets. */
+ struct tlv_header header; /* Value length is 32 octets. */
float value[MAX_CLASS_TYPE]; /* One for each priority level. */
};
#define TE_LINK_SUBTLV_RSC_CLSCLR 9
struct te_link_subtlv_rsc_clsclr {
struct tlv_header header; /* Value length is 4 octets. */
- u_int32_t value; /* Admin. group membership. */
+ u_int32_t value; /* Admin. group membership. */
};
/* For RFC6827 */
#define TE_LINK_SUBTLV_LRRID_SIZE 8
struct te_link_subtlv_lrrid {
struct tlv_header header; /* Value length is 8 octets. */
- struct in_addr local; /* Local TE Router Identifier */
- struct in_addr remote; /* Remote TE Router Identifier */
+ struct in_addr local; /* Local TE Router Identifier */
+ struct in_addr remote; /* Remote TE Router Identifier */
};
/* RFC4203: Link Local/Remote Identifiers */
#define TE_LINK_SUBTLV_LLRI_SIZE 8
struct te_link_subtlv_llri {
struct tlv_header header; /* Value length is 8 octets. */
- u_int32_t local; /* Link Local Identifier */
- u_int32_t remote; /* Link Remote Identifier */
+ u_int32_t local; /* Link Local Identifier */
+ u_int32_t remote; /* Link Remote Identifier */
};
/* Inter-RA Export Upward sub-TLV (12) and Inter-RA Export Downward sub-TLV (13)
#define TE_LINK_SUBTLV_RAS 21
struct te_link_subtlv_ras {
struct tlv_header header; /* Value length is 4 octets. */
- u_int32_t value; /* Remote AS number */
+ u_int32_t value; /* Remote AS number */
};
/* IPv4 Remote ASBR ID Sub-TLV */
#define TE_LINK_SUBTLV_RIP 22
struct te_link_subtlv_rip {
struct tlv_header header; /* Value length is 4 octets. */
- struct in_addr value; /* Remote ASBR IP address */
+ struct in_addr value; /* Remote ASBR IP address */
};
/* SUBTLV 24 is IPv6 Remote ASBR ID (RFC5392). see ospf6d */
return i;
}
-#define OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf) \
- if (argv_find(argv, argc, "vrf", &idx_vrf)) { \
- vrf_name = argv[idx_vrf + 1]->arg; \
- all_vrf = strmatch(vrf_name, "all"); \
+#define OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf) \
+ if (argv_find(argv, argc, "vrf", &idx_vrf)) { \
+ vrf_name = argv[idx_vrf + 1]->arg; \
+ all_vrf = strmatch(vrf_name, "all"); \
}
static struct ospf *ospf_cmd_lookup_ospf(struct vty *vty,
struct cmd_token *argv[],
- const int argc,
- uint32_t enable,
+ const int argc, uint32_t enable,
u_short *instance)
{
struct ospf *ospf = NULL;
if (ospf->vrf_id != VRF_UNKNOWN)
ospf->oi_running = 1;
if (IS_DEBUG_OSPF_EVENT)
- zlog_debug("Config command 'router ospf %d' received, vrf %s id %u oi_running %u",
- instance, ospf->name ? ospf->name : "NIL",
- ospf->vrf_id, ospf->oi_running);
+ zlog_debug(
+ "Config command 'router ospf %d' received, vrf %s id %u oi_running %u",
+ instance, ospf->name ? ospf->name : "NIL",
+ ospf->vrf_id, ospf->oi_running);
VTY_PUSH_CONTEXT(OSPF_NODE, ospf);
/* Activate 'ip ospf area x' configured interfaces for given
rn = route_next(rn)) {
if (rn->info != NULL) {
vty_out(vty,
- "Interface %s has area config but please remove all network commands first.\n",
- ifp->name);
+ "Interface %s has area config but please remove all network commands first.\n",
+ ifp->name);
return ret;
}
}
ifp = if_get_by_name(argv[1]->arg, ospf->vrf_id, 0);
if (ifp == NULL) {
- vty_out(vty, "interface %s not found.\n",
- (char *)argv[1]->arg);
+ vty_out(vty, "interface %s not found.\n", (char *)argv[1]->arg);
return CMD_WARNING_CONFIG_FAILED;
}
ifp = if_get_by_name(argv[2]->arg, ospf->vrf_id, 0);
if (ifp == NULL) {
- vty_out(vty, "interface %s not found.\n",
- (char *)argv[2]->arg);
+ vty_out(vty, "interface %s not found.\n", (char *)argv[2]->arg);
return CMD_WARNING_CONFIG_FAILED;
}
vty_out(vty,
"Please remove all ip ospf area x.x.x.x commands first.\n");
if (IS_DEBUG_OSPF_EVENT)
- zlog_debug("%s ospf vrf %s num of %u ip osp area x config",
- __PRETTY_FUNCTION__,
- ospf->name ? ospf->name : "NIL",
- ospf->if_ospf_cli_count);
+ zlog_debug(
+ "%s ospf vrf %s num of %u ip osp area x config",
+ __PRETTY_FUNCTION__,
+ ospf->name ? ospf->name : "NIL",
+ ospf->if_ospf_cli_count);
return CMD_WARNING_CONFIG_FAILED;
}
area = ospf_area_get(ospf, area_id);
ospf_area_display_format_set(ospf, area, format);
- area->auth_type = strmatch(argv[0]->text, "no") ? OSPF_AUTH_NULL : OSPF_AUTH_CRYPTOGRAPHIC;
+ area->auth_type = strmatch(argv[0]->text, "no")
+ ? OSPF_AUTH_NULL
+ : OSPF_AUTH_CRYPTOGRAPHIC;
return CMD_SUCCESS;
}
#if CONFDATE > 20180708
CPP_NOTICE("ospf: `timers lsa arrival (0-1000)` deprecated 2017/07/08")
#endif
-ALIAS_HIDDEN (ospf_timers_lsa_min_arrival,
- ospf_timers_lsa_arrival_cmd,
- "timers lsa arrival (0-1000)",
- "adjust routing timers\n"
- "throttling link state advertisement delays\n"
- "ospf minimum arrival interval delay\n"
- "delay (msec) between accepted lsas\n");
+ALIAS_HIDDEN(ospf_timers_lsa_min_arrival, ospf_timers_lsa_arrival_cmd,
+ "timers lsa arrival (0-1000)",
+ "adjust routing timers\n"
+ "throttling link state advertisement delays\n"
+ "ospf minimum arrival interval delay\n"
+ "delay (msec) between accepted lsas\n");
#if CONFDATE > 20180708
CPP_NOTICE("ospf: `no timers lsa arrival (0-1000)` deprecated 2017/07/08")
#endif
-ALIAS_HIDDEN (no_ospf_timers_lsa_min_arrival,
- no_ospf_timers_lsa_arrival_cmd,
- "no timers lsa arrival (0-1000)",
- NO_STR
- "adjust routing timers\n"
- "throttling link state advertisement delays\n"
- "ospf minimum arrival interval delay\n"
- "delay (msec) between accepted lsas\n");
+ALIAS_HIDDEN(no_ospf_timers_lsa_min_arrival, no_ospf_timers_lsa_arrival_cmd,
+ "no timers lsa arrival (0-1000)", NO_STR
+ "adjust routing timers\n"
+ "throttling link state advertisement delays\n"
+ "ospf minimum arrival interval delay\n"
+ "delay (msec) between accepted lsas\n");
DEFUN (ospf_neighbor,
if (uj)
json = json_object_new_object();
- /* vrf input is provided could be all or specific vrf*/
+ /* vrf input is provided could be all or specific vrf*/
if (vrf_name) {
use_vrf = 1;
if (all_vrf) {
}
if (uj) {
vty_out(vty, "%s\n",
- json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
}
return ret;
}
}
- if (ospf) {
+ if (ospf) {
show_ip_ospf_common(vty, ospf, json, use_vrf);
if (uj)
- vty_out(vty, "%s\n", json_object_to_json_string_ext(
- json, JSON_C_TO_STRING_PRETTY));
+ vty_out(vty, "%s\n",
+ json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
}
if (uj)
ret = show_ip_ospf_common(vty, ospf, json, 0);
if (uj) {
- vty_out(vty, "%s\n", json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ vty_out(vty, "%s\n", json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
}
}
if (use_json)
json_object_object_add(json_vrf, "interfaces",
- json_interface);
+ json_interface);
} else {
/* Interface name is specified. */
ifp = if_lookup_by_name(intf_name, ospf->vrf_id);
u_char use_json)
{
if (use_json) {
- json_object_int_add(json_interface_sub,
- "ifIndex",
- oi->ifp->ifindex);
- json_object_int_add(json_interface_sub,
- "helloIn",
- oi->hello_in);
- json_object_int_add(json_interface_sub,
- "helloOut",
- oi->hello_out);
- json_object_int_add(json_interface_sub,
- "dbDescIn",
- oi->db_desc_in);
- json_object_int_add(json_interface_sub,
- "dbDescOut",
- oi->db_desc_out);
- json_object_int_add(json_interface_sub,
- "lsReqIn",
- oi->ls_req_in);
- json_object_int_add(json_interface_sub,
- "lsReqOut",
- oi->ls_req_out);
- json_object_int_add(json_interface_sub,
- "lsUpdIn",
- oi->ls_upd_in);
- json_object_int_add(json_interface_sub,
- "lsUpdOut",
- oi->ls_upd_out);
- json_object_int_add(json_interface_sub,
- "lsAckIn",
- oi->ls_ack_in);
- json_object_int_add(json_interface_sub,
- "lsAckOut",
- oi->ls_ack_out);
+ json_object_int_add(json_interface_sub, "ifIndex",
+ oi->ifp->ifindex);
+ json_object_int_add(json_interface_sub, "helloIn",
+ oi->hello_in);
+ json_object_int_add(json_interface_sub, "helloOut",
+ oi->hello_out);
+ json_object_int_add(json_interface_sub, "dbDescIn",
+ oi->db_desc_in);
+ json_object_int_add(json_interface_sub, "dbDescOut",
+ oi->db_desc_out);
+ json_object_int_add(json_interface_sub, "lsReqIn",
+ oi->ls_req_in);
+ json_object_int_add(json_interface_sub, "lsReqOut",
+ oi->ls_req_out);
+ json_object_int_add(json_interface_sub, "lsUpdIn",
+ oi->ls_upd_in);
+ json_object_int_add(json_interface_sub, "lsUpdOut",
+ oi->ls_upd_out);
+ json_object_int_add(json_interface_sub, "lsAckIn",
+ oi->ls_ack_in);
+ json_object_int_add(json_interface_sub, "lsAckOut",
+ oi->ls_ack_out);
} else {
vty_out(vty,
"%-10s %8u/%-8u %7u/%-7u %7u/%-7u %7u/%-7u %7u/%-7u\n",
- oi->ifp->name, oi->hello_in,
- oi->hello_out,
- oi->db_desc_in, oi->db_desc_out,
- oi->ls_req_in, oi->ls_req_out,
- oi->ls_upd_in, oi->ls_upd_out,
+ oi->ifp->name, oi->hello_in, oi->hello_out,
+ oi->db_desc_in, oi->db_desc_out, oi->ls_req_in,
+ oi->ls_req_out, oi->ls_upd_in, oi->ls_upd_out,
oi->ls_ack_in, oi->ls_ack_out);
}
}
/* OSPFv2 Packet Counters */
-static int show_ip_ospf_interface_traffic_common(struct vty *vty,
- struct ospf *ospf,
- char *intf_name,
- json_object *json,
- int display_once,
- u_char use_vrf,
- u_char use_json)
+static int show_ip_ospf_interface_traffic_common(
+ struct vty *vty, struct ospf *ospf, char *intf_name, json_object *json,
+ int display_once, u_char use_vrf, u_char use_json)
{
struct vrf *vrf = NULL;
struct interface *ifp = NULL;
if (!use_json && !display_once) {
vty_out(vty, "\n");
- vty_out(vty, "%-12s%-17s%-17s%-17s%-17s%-17s\n",
- "Interface", " HELLO", " DB-Desc", " LS-Req",
- " LS-Update", " LS-Ack");
+ vty_out(vty, "%-12s%-17s%-17s%-17s%-17s%-17s\n", "Interface",
+ " HELLO", " DB-Desc", " LS-Req", " LS-Update",
+ " LS-Ack");
vty_out(vty, "%-10s%-18s%-18s%-17s%-17s%-17s\n", "",
- " Rx/Tx", " Rx/Tx", " Rx/Tx", " Rx/Tx", " Rx/Tx");
+ " Rx/Tx", " Rx/Tx", " Rx/Tx", " Rx/Tx",
+ " Rx/Tx");
vty_out(vty,
- "--------------------------------------------------------------------------------------------\n");
+ "--------------------------------------------------------------------------------------------\n");
} else if (use_json) {
if (use_vrf)
json_vrf = json_object_new_object();
continue;
for (rn = route_top(IF_OIFS(ifp)); rn;
- rn = route_next(rn)) {
+ rn = route_next(rn)) {
oi = rn->info;
if (oi == NULL)
json_object_new_object();
}
- show_ip_ospf_interface_traffic_sub(vty, oi,
- json_interface_sub,
- use_json);
+ show_ip_ospf_interface_traffic_sub(
+ vty, oi, json_interface_sub, use_json);
if (use_json) {
- json_object_object_add(json_vrf,
- ifp->name,
- json_interface_sub);
+ json_object_object_add(
+ json_vrf, ifp->name,
+ json_interface_sub);
}
}
}
struct ospf_interface *oi;
if (ospf_oi_count(ifp) == 0) {
- vty_out(vty, " OSPF not enabled on this interface %s\n",
+ vty_out(vty,
+ " OSPF not enabled on this interface %s\n",
ifp->name);
return CMD_SUCCESS;
}
json_object_new_object();
}
- show_ip_ospf_interface_traffic_sub(vty, oi,
- json_interface_sub,
- use_json);
+ show_ip_ospf_interface_traffic_sub(
+ vty, oi, json_interface_sub, use_json);
if (use_json) {
- json_object_object_add(json_vrf,
- ifp->name,
- json_interface_sub);
+ json_object_object_add(
+ json_vrf, ifp->name,
+ json_interface_sub);
}
}
}
for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
if (!ospf->oi_running)
continue;
- ret = show_ip_ospf_interface_common(vty,
- ospf,
- intf_name,
- use_vrf,
- json,
- uj);
+ ret = show_ip_ospf_interface_common(
+ vty, ospf, intf_name, use_vrf, json,
+ uj);
}
if (uj) {
vty_out(vty, "%s\n",
- json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
}
}
if (uj) {
- vty_out(vty, "%s\n", json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ vty_out(vty, "%s\n", json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
}
ret = show_ip_ospf_interface_common(vty, ospf, intf_name, 0, json, uj);
if (uj) {
- vty_out(vty, "%s\n", json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ vty_out(vty, "%s\n", json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
}
if (!ospf->oi_running)
continue;
- ret = show_ip_ospf_interface_traffic_common(vty,
- ospf, intf_name,
- json,
- display_once,
- use_vrf,
- uj);
+ ret = show_ip_ospf_interface_traffic_common(
+ vty, ospf, intf_name, json,
+ display_once, use_vrf, uj);
display_once = 1;
}
if (uj) {
vty_out(vty, "%s\n",
- json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
}
return CMD_SUCCESS;
}
- ret = show_ip_ospf_interface_traffic_common(vty, ospf,
- intf_name, json,
- display_once,
- use_vrf, uj);
+ ret = show_ip_ospf_interface_traffic_common(
+ vty, ospf, intf_name, json, display_once, use_vrf, uj);
} else {
ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
if (ospf == NULL || !ospf->oi_running) {
return CMD_SUCCESS;
}
- ret = show_ip_ospf_interface_traffic_common(vty, ospf,
- intf_name, json,
- display_once,
- use_vrf, uj);
+ ret = show_ip_ospf_interface_traffic_common(
+ vty, ospf, intf_name, json, display_once, use_vrf, uj);
}
if (uj) {
- vty_out(vty, "%s\n", json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ vty_out(vty, "%s\n", json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
}
if (use_json) {
char neigh_str[INET_ADDRSTRLEN];
- if (prev_nbr &&
- !IPV4_ADDR_SAME(&prev_nbr->src, &nbr->src)) {
+ if (prev_nbr
+ && !IPV4_ADDR_SAME(&prev_nbr->src,
+ &nbr->src)) {
/* Start new neigh list */
json_neigh_array = NULL;
}
- if (nbr->state == NSM_Attempt &&
- nbr->router_id.s_addr == 0)
+ if (nbr->state == NSM_Attempt
+ && nbr->router_id.s_addr == 0)
strlcpy(neigh_str, "neighbor",
sizeof(neigh_str));
else
&json_neigh_array);
if (!json_neigh_array) {
- json_neigh_array = json_object_new_array();
- json_object_object_add(json, neigh_str,
- json_neigh_array);
+ json_neigh_array =
+ json_object_new_array();
+ json_object_object_add(
+ json, neigh_str,
+ json_neigh_array);
}
- json_neighbor =
- json_object_new_object();
+ json_neighbor = json_object_new_object();
ospf_nbr_state_message(nbr, msgbuf, 16);
long time_store;
- time_store = monotime_until(
+ time_store =
+ monotime_until(
&nbr->t_inactivity->u.sands,
- NULL) / 1000LL;
+ NULL)
+ / 1000LL;
- json_object_int_add(json_neighbor,
- "priority",
+ json_object_int_add(json_neighbor, "priority",
nbr->priority);
json_object_string_add(json_neighbor, "state",
msgbuf);
json_object_int_add(json_neighbor,
"deadTimeMsecs",
time_store);
- json_object_string_add(json_neighbor,
- "address",
+ json_object_string_add(json_neighbor, "address",
inet_ntoa(nbr->src));
json_object_string_add(json_neighbor,
"ifaceName",
IF_NAME(oi));
+ json_object_int_add(
+ json_neighbor, "retransmitCounter",
+ ospf_ls_retransmit_count(nbr));
json_object_int_add(json_neighbor,
- "retransmitCounter",
- ospf_ls_retransmit_count(nbr));
- json_object_int_add(json_neighbor,
- "requestCounter",
- ospf_ls_request_count(nbr));
+ "requestCounter",
+ ospf_ls_request_count(nbr));
json_object_int_add(json_neighbor,
- "dbSummaryCounter",
- ospf_db_summary_count(nbr));
+ "dbSummaryCounter",
+ ospf_db_summary_count(nbr));
json_object_array_add(json_neigh_array,
json_neighbor);
} else {
ospf_nbr_state_message(nbr, msgbuf, 16);
- if (nbr->state == NSM_Attempt &&
- nbr->router_id.s_addr == 0)
- vty_out(vty,
- "%-15s %3d %-15s ",
- "-",
- nbr->priority,
- msgbuf);
+ if (nbr->state == NSM_Attempt
+ && nbr->router_id.s_addr == 0)
+ vty_out(vty, "%-15s %3d %-15s ", "-",
+ nbr->priority, msgbuf);
else
- vty_out(vty,
- "%-15s %3d %-15s ",
+ vty_out(vty, "%-15s %3d %-15s ",
inet_ntoa(nbr->router_id),
- nbr->priority,
- msgbuf);
+ nbr->priority, msgbuf);
vty_out(vty, "%9s ",
ospf_timer_dump(nbr->t_inactivity,
timebuf,
sizeof(timebuf)));
vty_out(vty, "%-15s ", inet_ntoa(nbr->src));
- vty_out(vty,
- "%-20s %5ld %5ld %5d\n",
+ vty_out(vty, "%-20s %5ld %5ld %5d\n",
IF_NAME(oi),
ospf_ls_retransmit_count(nbr),
ospf_ls_request_count(nbr),
}
if (use_json) {
- json_object_object_add(json_vrf, "neighbors",
- json_nbr_sub);
+ json_object_object_add(json_vrf, "neighbors", json_nbr_sub);
if (use_vrf) {
if (ospf->vrf_id == VRF_DEFAULT)
json_object_object_add(json, "default",
for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
if (!ospf->oi_running)
continue;
- ret = show_ip_ospf_neighbor_common(vty, ospf,
- json, uj,
- use_vrf);
+ ret = show_ip_ospf_neighbor_common(
+ vty, ospf, json, uj, use_vrf);
}
if (uj) {
vty_out(vty, "%s\n",
- json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
}
if (uj) {
vty_out(vty, "%s\n",
- json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
}
}
ret = show_ip_ospf_neighbor_common(vty, ospf, json, uj, 0);
if (uj) {
- vty_out(vty, "%s\n", json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ vty_out(vty, "%s\n", json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
}
}
static int show_ip_ospf_neighbor_all_common(struct vty *vty, struct ospf *ospf,
- json_object *json,
- u_char use_json,
+ json_object *json, u_char use_json,
u_char use_vrf)
{
struct listnode *node;
for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
if (!ospf->oi_running)
continue;
- ret = show_ip_ospf_neighbor_all_common(vty,
- ospf,
- json,
- uj,
- use_vrf);
+ ret = show_ip_ospf_neighbor_all_common(
+ vty, ospf, json, uj, use_vrf);
}
if (uj) {
vty_out(vty, "%s\n",
- json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
}
use_vrf);
if (uj) {
vty_out(vty, "%s\n",
- json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
}
}
continue;
if (!ifp || ifp->vrf_id != ospf->vrf_id)
continue;
- ret = show_ip_ospf_neighbor_int_common(vty, ospf,
- idx_ifname, argv, uj, 0);
+ ret = show_ip_ospf_neighbor_int_common(vty, ospf, idx_ifname,
+ argv, uj, 0);
}
return ret;
if (!uj)
show_ip_ospf_neighbour_header(vty);
- return show_ip_ospf_neighbor_int_common(vty, ospf, idx_ifname,
- argv, uj, 0);
+ return show_ip_ospf_neighbor_int_common(vty, ospf, idx_ifname, argv, uj,
+ 0);
}
static void show_ip_ospf_nbr_nbma_detail_sub(struct vty *vty,
static void show_ip_ospf_neighbor_detail_sub(struct vty *vty,
struct ospf_interface *oi,
struct ospf_neighbor *nbr,
- json_object *json,
- u_char use_json)
+ json_object *json, u_char use_json)
{
char timebuf[OSPF_TIME_DUMP_SIZE];
json_object *json_sub = NULL;
static int show_ip_ospf_neighbor_id_common(struct vty *vty, struct ospf *ospf,
int arg_base,
struct cmd_token **argv,
- u_char use_json,
- u_char use_vrf)
+ u_char use_json, u_char use_vrf)
{
struct listnode *node;
struct ospf_neighbor *nbr;
for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
if (!ospf->oi_running)
continue;
- ret = show_ip_ospf_neighbor_id_common(vty, ospf, 0,
- argv, uj, 0);
+ ret = show_ip_ospf_neighbor_id_common(vty, ospf, 0, argv, uj,
+ 0);
}
return ret;
static int show_ip_ospf_neighbor_detail_common(struct vty *vty,
struct ospf *ospf,
json_object *json,
- u_char use_json,
- u_char use_vrf)
+ u_char use_json, u_char use_vrf)
{
struct ospf_interface *oi;
struct listnode *node;
for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
if (!ospf->oi_running)
continue;
- ret = show_ip_ospf_neighbor_detail_common(vty,
- ospf,
- json,
- uj,
- use_vrf);
+ ret = show_ip_ospf_neighbor_detail_common(
+ vty, ospf, json, uj, use_vrf);
}
if (uj) {
vty_out(vty, "%s\n",
- json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
}
use_vrf);
if (uj) {
vty_out(vty, "%s\n",
- json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
}
}
for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
if (!ospf->oi_running)
continue;
- ret = show_ip_ospf_neighbor_detail_all_common(vty,
- ospf,
- json,
- uj,
- use_vrf);
+ ret = show_ip_ospf_neighbor_detail_all_common(
+ vty, ospf, json, uj, use_vrf);
}
if (uj) {
vty_out(vty, "%s\n",
- json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
}
uj, use_vrf);
if (uj) {
vty_out(vty, "%s\n",
- json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
}
}
ret = show_ip_ospf_neighbor_detail_all_common(vty, ospf, json, uj, 0);
if (uj) {
- vty_out(vty, "%s\n", json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ vty_out(vty, "%s\n", json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
}
if (!ospf->oi_running)
return CMD_SUCCESS;
- return show_ip_ospf_neighbor_int_detail_common(vty, ospf, idx_ifname, argv, uj);
+ return show_ip_ospf_neighbor_int_detail_common(vty, ospf, idx_ifname,
+ argv, uj);
}
/* Show functions */
vty_out(vty, "%s\n",
show_database_header[type]);
- LSDB_LOOP(AREA_LSDB(area, type), rn, lsa)
+ LSDB_LOOP (AREA_LSDB(area, type), rn, lsa)
show_lsa_summary(vty, lsa, self);
vty_out(vty, "\n");
show_database_desc[type]);
vty_out(vty, "%s\n", show_database_header[type]);
- LSDB_LOOP(AS_LSDB(ospf, type), rn, lsa)
+ LSDB_LOOP (AS_LSDB(ospf, type), rn, lsa)
show_lsa_summary(vty, lsa, self);
vty_out(vty, "\n");
static int show_ip_ospf_database_common(struct vty *vty, struct ospf *ospf,
int arg_base, int argc,
- struct cmd_token **argv,
- u_char use_vrf)
+ struct cmd_token **argv, u_char use_vrf)
{
int idx_type = 4;
int type, ret;
for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
if (!ospf->oi_running)
continue;
- ret = show_ip_ospf_database_common(vty, ospf,
- idx_vrf ? 2
- : 0, argc,
- argv,
- use_vrf);
+ ret = show_ip_ospf_database_common(
+ vty, ospf, idx_vrf ? 2 : 0, argc, argv,
+ use_vrf);
}
} else {
ospf = ospf_lookup_by_inst_name(inst, vrf_name);
if (ospf == NULL || !ospf->oi_running)
return CMD_SUCCESS;
- ret = (show_ip_ospf_database_common(vty, ospf, idx_vrf ?
- 2 : 0, argc, argv,
- use_vrf));
+ ret = (show_ip_ospf_database_common(
+ vty, ospf, idx_vrf ? 2 : 0, argc, argv,
+ use_vrf));
}
} else {
/* Display default ospf (instance 0) info */
for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
if (!ospf->oi_running)
continue;
- ret = (show_ip_ospf_database_common(vty, ospf,
- idx ? 2 : 0,
- argc, argv,
- use_vrf));
+ ret = (show_ip_ospf_database_common(
+ vty, ospf, idx ? 2 : 0, argc, argv,
+ use_vrf));
}
} else {
ospf = ospf_lookup_by_inst_name(inst, vrf_name);
if ((ospf == NULL) || !ospf->oi_running)
return CMD_SUCCESS;
- ret = (show_ip_ospf_database_common(vty, ospf, idx ? 2 :
- 0, argc, argv,
- use_vrf));
+ ret = (show_ip_ospf_database_common(
+ vty, ospf, idx ? 2 : 0, argc, argv, use_vrf));
}
} else {
/* Display default ospf (instance 0) info */
return CMD_NOT_MY_INSTANCE;
if (!ospf->oi_running)
return CMD_SUCCESS;
- return (show_ip_ospf_database_type_adv_router_common(vty, ospf,
- idx ? 1 : 0,
- argc,
- argv,
- use_vrf));
+ return (show_ip_ospf_database_type_adv_router_common(
+ vty, ospf, idx ? 1 : 0, argc, argv, use_vrf));
}
OSPF_FIND_VRF_ARGS(argv, argc, idx_vrf, vrf_name, all_vrf);
for (ALL_LIST_ELEMENTS_RO(om->ospf, node, ospf)) {
if (!ospf->oi_running)
continue;
- ret = show_ip_ospf_database_type_adv_router_common(vty,
- ospf, idx ? 1 : 0, argc, argv,
- use_vrf);
+ ret = show_ip_ospf_database_type_adv_router_common(
+ vty, ospf, idx ? 1 : 0, argc, argv,
+ use_vrf);
}
} else {
ospf = ospf_lookup_by_inst_name(inst, vrf_name);
if ((ospf == NULL) || !ospf->oi_running)
return CMD_SUCCESS;
- ret = show_ip_ospf_database_type_adv_router_common(vty,
- ospf, idx ? 1 : 0, argc, argv,
- use_vrf);
+ ret = show_ip_ospf_database_type_adv_router_common(
+ vty, ospf, idx ? 1 : 0, argc, argv, use_vrf);
}
} else {
/* Display default ospf (instance 0) info */
ospf = ospf_lookup_by_vrf_id(VRF_DEFAULT);
if (ospf == NULL || !ospf->oi_running)
return CMD_SUCCESS;
- ret = show_ip_ospf_database_type_adv_router_common(vty, ospf,
- idx ? 1 : 0,
- argc, argv,
- use_vrf);
+ ret = show_ip_ospf_database_type_adv_router_common(
+ vty, ospf, idx ? 1 : 0, argc, argv, use_vrf);
}
return ret;
/*return (show_ip_ospf_database_type_adv_router_common(
// Check if we have an address arg and proccess it
if (argc == idx + 3) {
if (!inet_aton(argv[idx + 2]->arg, &addr)) {
- vty_out(vty, "Please specify Intf Address by A.B.C.D\n");
+ vty_out(vty,
+ "Please specify Intf Address by A.B.C.D\n");
return CMD_WARNING_CONFIG_FAILED;
}
// update/create address-level params
// Check if we have an address arg and proccess it
if (argc == idx + 3) {
if (!inet_aton(argv[idx + 2]->arg, &addr)) {
- vty_out(vty, "Please specify Intf Address by A.B.C.D\n");
+ vty_out(vty,
+ "Please specify Intf Address by A.B.C.D\n");
return CMD_WARNING_CONFIG_FAILED;
}
params = ospf_lookup_if_params(ifp, addr);
*json_nexthop = NULL;
if (!json)
- vty_out(vty, "============ OSPF network routing table ============\n");
+ vty_out(vty,
+ "============ OSPF network routing table ============\n");
for (rn = route_top(rt); rn; rn = route_next(rn)) {
if ((or = rn->info) == NULL)
json_route = json_object_new_object();
if (json) {
- json_object_object_add(json, buf1, json_route);
- json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_NOSLASHESCAPE);
-
+ json_object_object_add(json, buf1, json_route);
+ json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_NOSLASHESCAPE);
}
switch (or->path_type) {
if (or->type == OSPF_DESTINATION_NETWORK) {
if (json) {
json_object_string_add(json_route,
- "routeType",
- "N IA");
- json_object_int_add(json_route,
- "cost",
+ "routeType",
+ "N IA");
+ json_object_int_add(json_route, "cost",
or->cost);
json_object_string_add(
- json_route,
- "area",
- inet_ntoa(
- or->u.std.area_id));
+ json_route, "area",
+ inet_ntoa(or->u.std.area_id));
} else {
vty_out(vty,
- "N IA %-18s [%d] area: %s\n",
+ "N IA %-18s [%d] area: %s\n",
buf1, or->cost,
- inet_ntoa(or->u.std.area_id));
+ inet_ntoa(or->u.std.area_id));
}
- } else if (or->type ==
- OSPF_DESTINATION_DISCARD) {
+ } else if (or->type == OSPF_DESTINATION_DISCARD) {
if (json) {
json_object_string_add(json_route,
- "routeType",
- "D IA");
+ "routeType",
+ "D IA");
} else {
vty_out(vty,
"D IA %-18s Discard entry\n",
break;
case OSPF_PATH_INTRA_AREA:
if (json) {
- json_object_string_add(json_route,
- "routeType", "N");
+ json_object_string_add(json_route, "routeType",
+ "N");
json_object_int_add(json_route, "cost",
- or->cost);
- json_object_string_add(json_route,
- "area", inet_ntoa(or->u.std.area_id));
+ or->cost);
+ json_object_string_add(
+ json_route, "area",
+ inet_ntoa(or->u.std.area_id));
} else {
vty_out(vty, "N %-18s [%d] area: %s\n",
buf1, or->cost,
if (json) {
json_nexthop_array = json_object_new_array();
json_object_object_add(json_route, "nexthops",
- json_nexthop_array);
+ json_nexthop_array);
}
for (ALL_LIST_ELEMENTS(or->paths, pnode, pnnode,
path)) {
if (json) {
- json_nexthop =
- json_object_new_object();
- json_object_array_add(json_nexthop_array,
- json_nexthop);
+ json_nexthop = json_object_new_object();
+ json_object_array_add(
+ json_nexthop_array,
+ json_nexthop);
}
if (if_lookup_by_index(path->ifindex,
ospf->vrf_id)) {
if (json) {
json_object_string_add(
json_nexthop,
- "ip",
- " ");
+ "ip", " ");
json_object_string_add(
json_nexthop,
"directly attached to",
ifindex2ifname(
- path->ifindex,
- ospf->vrf_id));
+ path->ifindex,
+ ospf->vrf_id));
} else {
vty_out(vty,
- "%24s directly attached to %s\n",
- "",
- ifindex2ifname(
- path->ifindex,
- ospf->vrf_id));
+ "%24s directly attached to %s\n",
+ "",
+ ifindex2ifname(
+ path->ifindex,
+ ospf->vrf_id));
}
} else {
if (json) {
json_nexthop,
"ip",
inet_ntoa(
- path->nexthop));
+ path->nexthop));
json_object_string_add(
json_nexthop,
"via",
ifindex2ifname(
- path->ifindex,
- ospf->vrf_id));
+ path->ifindex,
+ ospf->vrf_id));
} else {
vty_out(vty,
- "%24s via %s, %s\n",
- "",
- inet_ntoa(
- path->nexthop),
- ifindex2ifname(
- path->ifindex,
- ospf->vrf_id));
+ "%24s via %s, %s\n",
+ "",
+ inet_ntoa(
+ path->nexthop),
+ ifindex2ifname(
+ path->ifindex,
+ ospf->vrf_id));
}
}
}
*json_nexthop = NULL;
if (!json)
- vty_out(vty, "============ OSPF router routing table =============\n");
+ vty_out(vty,
+ "============ OSPF router routing table =============\n");
for (rn = route_top(rtrs); rn; rn = route_next(rn)) {
if (rn->info == NULL)
json_route = json_object_new_object();
if (json) {
- json_object_object_add(json,
- inet_ntoa(rn->p.u.prefix4),
- json_route);
- json_object_string_add(json_route, "routeType",
- "R ");
+ json_object_object_add(json, inet_ntoa(rn->p.u.prefix4),
+ json_route);
+ json_object_string_add(json_route, "routeType", "R ");
} else {
vty_out(vty, "R %-15s ",
inet_ntoa(rn->p.u.prefix4));
}
- for (ALL_LIST_ELEMENTS_RO((struct list *)rn->info, node,
- or)) {
+ for (ALL_LIST_ELEMENTS_RO((struct list *)rn->info, node, or)) {
if (flag++) {
if (!json)
vty_out(vty, "%24s", "");
if (json) {
json_object_int_add(json_route, "cost",
or->cost);
- json_object_string_add(json_route,
- "area",
+ json_object_string_add(
+ json_route, "area",
inet_ntoa(or->u.std.area_id));
- if (or->path_type ==
- OSPF_PATH_INTER_AREA)
- json_object_boolean_true_add(
- json_route,
- "IA");
+ if (or->path_type == OSPF_PATH_INTER_AREA)
+ json_object_boolean_true_add(json_route,
+ "IA");
if (or->u.std.flags & ROUTER_LSA_BORDER)
- json_object_string_add(
- json_route,
- "routerType",
- "abr");
- else if (or->u.std.flags &
- ROUTER_LSA_EXTERNAL)
- json_object_string_add(
- json_route,
- "routerType",
- "asbr");
+ json_object_string_add(json_route,
+ "routerType",
+ "abr");
+ else if (or->u.std.flags & ROUTER_LSA_EXTERNAL)
+ json_object_string_add(json_route,
+ "routerType",
+ "asbr");
} else {
vty_out(vty, "%s [%d] area: %s",
- (or->path_type == OSPF_PATH_INTER_AREA
- ? "IA"
- : " "),
- or->cost, inet_ntoa(or->u.std.area_id));
+ (or->path_type == OSPF_PATH_INTER_AREA
+ ? "IA"
+ : " "),
+ or->cost, inet_ntoa(or->u.std.area_id));
/* Show flags. */
vty_out(vty, "%s%s\n",
- (or->u.std.flags & ROUTER_LSA_BORDER
- ? ", ABR"
- : ""),
- (or->u.std.flags & ROUTER_LSA_EXTERNAL
- ? ", ASBR"
- : ""));
+ (or->u.std.flags & ROUTER_LSA_BORDER
+ ? ", ABR"
+ : ""),
+ (or->u.std.flags & ROUTER_LSA_EXTERNAL
+ ? ", ASBR"
+ : ""));
}
if (json) {
- json_nexthop_array =
- json_object_new_array();
+ json_nexthop_array = json_object_new_array();
json_object_object_add(json_route, "nexthops",
- json_nexthop_array);
+ json_nexthop_array);
}
- for (ALL_LIST_ELEMENTS_RO(or->paths, pnode,
- path)) {
+ for (ALL_LIST_ELEMENTS_RO(or->paths, pnode, path)) {
if (json) {
- json_nexthop =
- json_object_new_object();
+ json_nexthop = json_object_new_object();
json_object_array_add(
json_nexthop_array,
json_nexthop);
if (json) {
json_object_string_add(
json_nexthop,
- "ip",
- " ");
+ "ip", " ");
json_object_string_add(
json_nexthop,
"directly attached to",
ospf->vrf_id));
} else {
vty_out(vty,
- "%24s directly attached to %s\n",
- "",
- ifindex2ifname(
- path->ifindex,
- ospf->vrf_id));
+ "%24s directly attached to %s\n",
+ "",
+ ifindex2ifname(
+ path->ifindex,
+ ospf->vrf_id));
}
} else {
if (json) {
json_object_string_add(
json_nexthop,
"ip",
- inet_ntoa(path->nexthop));
+ inet_ntoa(
+ path->nexthop));
json_object_string_add(
json_nexthop,
"via",
ospf->vrf_id));
} else {
vty_out(vty,
- "%24s via %s, %s\n",
- "",
- inet_ntoa(
- path->nexthop),
- ifindex2ifname(
- path->ifindex,
- ospf->vrf_id));
+ "%24s via %s, %s\n",
+ "",
+ inet_ntoa(
+ path->nexthop),
+ ifindex2ifname(
+ path->ifindex,
+ ospf->vrf_id));
}
}
}
*json_nexthop = NULL;
if (!json)
- vty_out(vty, "============ OSPF external routing table ===========\n");
+ vty_out(vty,
+ "============ OSPF external routing table ===========\n");
for (rn = route_top(rt); rn; rn = route_next(rn)) {
if ((er = rn->info) == NULL)
rn->p.prefixlen);
json_route = json_object_new_object();
if (json) {
- json_object_object_add(json, buf1, json_route);
- json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_NOSLASHESCAPE);
-
+ json_object_object_add(json, buf1, json_route);
+ json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_NOSLASHESCAPE);
}
switch (er->path_type) {
case OSPF_PATH_TYPE1_EXTERNAL:
if (json) {
- json_object_string_add(json_route,
- "routeType",
+ json_object_string_add(json_route, "routeType",
"N E1");
json_object_int_add(json_route, "cost",
- er->cost);
+ er->cost);
} else {
vty_out(vty,
- "N E1 %-18s [%d] tag: %" ROUTE_TAG_PRI
- "\n",
- buf1, er->cost, er->u.ext.tag);
+ "N E1 %-18s [%d] tag: %" ROUTE_TAG_PRI
+ "\n",
+ buf1, er->cost, er->u.ext.tag);
}
break;
case OSPF_PATH_TYPE2_EXTERNAL:
if (json) {
- json_object_string_add(json_route,
- "routeType",
+ json_object_string_add(json_route, "routeType",
"N E2");
json_object_int_add(json_route, "cost",
- er->cost);
+ er->cost);
} else {
vty_out(vty,
- "N E2 %-18s [%d/%d] tag: %"
- ROUTE_TAG_PRI
- "\n", buf1, er->cost,
- er->u.ext.type2_cost,
+ "N E2 %-18s [%d/%d] tag: %" ROUTE_TAG_PRI
+ "\n",
+ buf1, er->cost, er->u.ext.type2_cost,
er->u.ext.tag);
}
break;
if (json) {
json_nexthop_array = json_object_new_array();
json_object_object_add(json_route, "nexthops",
- json_nexthop_array);
+ json_nexthop_array);
}
- for (ALL_LIST_ELEMENTS(er->paths, pnode, pnnode,
- path)) {
+ for (ALL_LIST_ELEMENTS(er->paths, pnode, pnnode, path)) {
if (json) {
json_nexthop = json_object_new_object();
- json_object_array_add(json_nexthop_array
- ,json_nexthop);
+ json_object_array_add(json_nexthop_array,
+ json_nexthop);
}
- if (if_lookup_by_index(path->ifindex,
- ospf->vrf_id)) {
+ if (if_lookup_by_index(path->ifindex, ospf->vrf_id)) {
if (path->nexthop.s_addr == 0) {
if (json) {
json_object_string_add(
- json_nexthop,
- "ip",
- " ");
+ json_nexthop, "ip",
+ " ");
json_object_string_add(
json_nexthop,
"directly attached to",
ifindex2ifname(
- path->ifindex,
- ospf->vrf_id));
+ path->ifindex,
+ ospf->vrf_id));
} else {
vty_out(vty,
- "%24s directly attached to %s\n",
- "",
- ifindex2ifname(
- path->ifindex,
- ospf->vrf_id));
+ "%24s directly attached to %s\n",
+ "",
+ ifindex2ifname(
+ path->ifindex,
+ ospf->vrf_id));
}
} else {
if (json) {
json_object_string_add(
- json_nexthop,
- "ip",
+ json_nexthop, "ip",
inet_ntoa(
- path->nexthop));
+ path->nexthop));
json_object_string_add(
- json_nexthop,
- "via",
+ json_nexthop, "via",
ifindex2ifname(
- path->ifindex,
- ospf->vrf_id));
+ path->ifindex,
+ ospf->vrf_id));
} else {
vty_out(vty,
- "%24s via %s, %s\n",
- "",
- inet_ntoa(
- path->nexthop),
- ifindex2ifname(
- path->ifindex,
- ospf->vrf_id));
+ "%24s via %s, %s\n",
+ "",
+ inet_ntoa(
+ path->nexthop),
+ ifindex2ifname(
+ path->ifindex,
+ ospf->vrf_id));
}
}
}
}
static int show_ip_ospf_border_routers_common(struct vty *vty,
- struct ospf *ospf,
- u_char use_vrf)
+ struct ospf *ospf, u_char use_vrf)
{
if (ospf->instance)
vty_out(vty, "\nOSPF Instance: %d\n\n", ospf->instance);
if (!ospf->oi_running)
continue;
- ret = show_ip_ospf_border_routers_common(vty,
- ospf,
- use_vrf);
+ ret = show_ip_ospf_border_routers_common(
+ vty, ospf, use_vrf);
}
} else {
ospf = ospf_lookup_by_inst_name(inst, vrf_name);
if (json) {
if (use_vrf) {
- //json_object_object_add(json_vrf, "areas", json_areas);
+ // json_object_object_add(json_vrf, "areas",
+ // json_areas);
if (ospf->vrf_id == VRF_DEFAULT)
json_object_object_add(json, "default",
json_vrf);
else
name = ospf->name;
- vrf_id_ui = (ospf->vrf_id == VRF_UNKNOWN) ? -1 :
- (int64_t) ospf->vrf_id;
+ vrf_id_ui = (ospf->vrf_id == VRF_UNKNOWN)
+ ? -1
+ : (int64_t)ospf->vrf_id;
if (uj) {
json_object_int_add(json_vrf, "vrfId", vrf_id_ui);
json_object_object_add(json_vrfs, name, json_vrf);
} else {
- vty_out(vty, "%-25s %-5d %-16s \n",
- name, ospf->vrf_id, inet_ntoa(ospf->router_id));
+ vty_out(vty, "%-25s %-5d %-16s \n", name,
+ ospf->vrf_id, inet_ntoa(ospf->router_id));
}
}
json_object_object_add(json, "vrfs", json_vrfs);
json_object_int_add(json, "totalVrfs", count);
- vty_out(vty, "%s\n", json_object_to_json_string_ext(json,
- JSON_C_TO_STRING_PRETTY));
+ vty_out(vty, "%s\n", json_object_to_json_string_ext(
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
} else {
if (count)
if (ifp->vrf_id == VRF_DEFAULT)
vty_frame(vty, "interface %s\n", ifp->name);
else
- vty_frame(vty, "interface %s vrf %s\n",
- ifp->name, vrf->name);
+ vty_frame(vty, "interface %s vrf %s\n", ifp->name,
+ vrf->name);
if (ifp->desc)
vty_out(vty, " description %s\n", ifp->desc);
/* Interface Network print. */
if (OSPF_IF_PARAM_CONFIGURED(params, type)
&& params->type != OSPF_IFTYPE_LOOPBACK) {
- if (params->type !=
- ospf_default_iftype(ifp)) {
+ if (params->type != ospf_default_iftype(ifp)) {
vty_out(vty, " ip ospf network %s",
ospf_int_type_str
- [params->type]);
+ [params->type]);
if (params != IF_DEF_PARAMS(ifp))
vty_out(vty, " %s",
inet_ntoa(
- rn->p.u.prefix4));
+ rn->p.u.prefix4));
vty_out(vty, "\n");
}
}
/* OSPF interface authentication print */
if (OSPF_IF_PARAM_CONFIGURED(params, auth_type)
- && params->auth_type != OSPF_AUTH_NOTSET) {
+ && params->auth_type != OSPF_AUTH_NOTSET) {
const char *auth_str;
/* Translation tables are not that much help
/* Simple Authentication Password print. */
if (OSPF_IF_PARAM_CONFIGURED(params, auth_simple)
- && params->auth_simple[0] != '\0') {
+ && params->auth_simple[0] != '\0') {
vty_out(vty, " ip ospf authentication-key %s",
params->auth_simple);
if (params != IF_DEF_PARAMS(ifp))
/* Cryptographic Authentication Key print. */
if (params && params->auth_crypt) {
- for (ALL_LIST_ELEMENTS_RO(
- params->auth_crypt,
- node, ck)) {
+ for (ALL_LIST_ELEMENTS_RO(params->auth_crypt,
+ node, ck)) {
vty_out(vty,
" ip ospf message-digest-key %d md5 %s",
- ck->key_id,
- ck->auth_key);
+ ck->key_id, ck->auth_key);
if (params != IF_DEF_PARAMS(ifp))
vty_out(vty, " %s",
- inet_ntoa(rn->p.u.prefix4));
+ inet_ntoa(
+ rn->p.u.prefix4));
vty_out(vty, "\n");
}
}
/* Interface Output Cost print. */
- if (OSPF_IF_PARAM_CONFIGURED(params,
- output_cost_cmd)) {
+ if (OSPF_IF_PARAM_CONFIGURED(params, output_cost_cmd)) {
vty_out(vty, " ip ospf cost %u",
params->output_cost_cmd);
if (params != IF_DEF_PARAMS(ifp))
/* Hello Interval print. */
if (OSPF_IF_PARAM_CONFIGURED(params, v_hello)
- && params->v_hello !=
- OSPF_HELLO_INTERVAL_DEFAULT) {
+ && params->v_hello != OSPF_HELLO_INTERVAL_DEFAULT) {
vty_out(vty, " ip ospf hello-interval %u",
params->v_hello);
if (params != IF_DEF_PARAMS(ifp))
/* Router Dead Interval print. */
if (OSPF_IF_PARAM_CONFIGURED(params, v_wait)
- && params->v_wait
- != OSPF_ROUTER_DEAD_INTERVAL_DEFAULT) {
+ && params->v_wait
+ != OSPF_ROUTER_DEAD_INTERVAL_DEFAULT) {
vty_out(vty, " ip ospf dead-interval ");
/* fast hello ? */
if (OSPF_IF_PARAM_CONFIGURED(params,
- fast_hello))
+ fast_hello))
vty_out(vty,
"minimal hello-multiplier %d",
params->fast_hello);
else
- vty_out(vty, "%u",
- params->v_wait);
+ vty_out(vty, "%u", params->v_wait);
if (params != IF_DEF_PARAMS(ifp))
vty_out(vty, " %s",
/* Router Priority print. */
if (OSPF_IF_PARAM_CONFIGURED(params, priority)
- && params->priority
- != OSPF_ROUTER_PRIORITY_DEFAULT) {
+ && params->priority
+ != OSPF_ROUTER_PRIORITY_DEFAULT) {
vty_out(vty, " ip ospf priority %u",
params->priority);
if (params != IF_DEF_PARAMS(ifp))
/* Retransmit Interval print. */
if (OSPF_IF_PARAM_CONFIGURED(params,
- retransmit_interval)
- && params->retransmit_interval
- != OSPF_RETRANSMIT_INTERVAL_DEFAULT) {
+ retransmit_interval)
+ && params->retransmit_interval
+ != OSPF_RETRANSMIT_INTERVAL_DEFAULT) {
vty_out(vty, " ip ospf retransmit-interval %u",
params->retransmit_interval);
if (params != IF_DEF_PARAMS(ifp))
}
/* Transmit Delay print. */
- if (OSPF_IF_PARAM_CONFIGURED(params,
- transmit_delay)
- && params->transmit_delay
- != OSPF_TRANSMIT_DELAY_DEFAULT) {
+ if (OSPF_IF_PARAM_CONFIGURED(params, transmit_delay)
+ && params->transmit_delay
+ != OSPF_TRANSMIT_DELAY_DEFAULT) {
vty_out(vty, " ip ospf transmit-delay %u",
params->transmit_delay);
if (params != IF_DEF_PARAMS(ifp))
vty_out(vty, " %s",
- inet_ntoa(rn->p.u.prefix4));
+ inet_ntoa(rn->p.u.prefix4));
vty_out(vty, "\n");
}
size_t buflen = MAX(strlen("4294967295"),
- strlen("255.255.255.255"));
+ strlen("255.255.255.255"));
char buf[buflen];
- area_id2str(buf, sizeof(buf),
- ¶ms->if_area,
- params->if_area_id_fmt);
+ area_id2str(buf, sizeof(buf), ¶ms->if_area,
+ params->if_area_id_fmt);
vty_out(vty, " area %s", buf);
if (params != IF_DEF_PARAMS(ifp))
vty_out(vty, " %s",
- inet_ntoa(rn->p.u.prefix4));
+ inet_ntoa(rn->p.u.prefix4));
vty_out(vty, "\n");
}
/* MTU ignore print. */
if (OSPF_IF_PARAM_CONFIGURED(params, mtu_ignore)
- && params->mtu_ignore !=
- OSPF_MTU_IGNORE_DEFAULT) {
+ && params->mtu_ignore != OSPF_MTU_IGNORE_DEFAULT) {
if (params->mtu_ignore == 0)
vty_out(vty, " no ip ospf mtu-ignore");
else
vty_out(vty, " ip ospf mtu-ignore");
if (params != IF_DEF_PARAMS(ifp))
vty_out(vty, " %s",
- inet_ntoa(rn->p.u.prefix4));
+ inet_ntoa(rn->p.u.prefix4));
vty_out(vty, "\n");
}
while (1) {
if (rn == NULL)
- rn = route_top(
- IF_OIFS_PARAMS(ifp));
+ rn = route_top(IF_OIFS_PARAMS(ifp));
else
rn = route_next(rn);
/* `router ospf' print. */
if (ospf->instance && ospf->name) {
- vty_out(vty, "router ospf %d vrf %s\n",
- ospf->instance, ospf->name);
+ vty_out(vty, "router ospf %d vrf %s\n", ospf->instance,
+ ospf->name);
} else if (ospf->instance) {
- vty_out(vty, "router ospf %d\n",
- ospf->instance);
+ vty_out(vty, "router ospf %d\n", ospf->instance);
} else if (ospf->name) {
- vty_out(vty, "router ospf vrf %s\n",
- ospf->name);
+ vty_out(vty, "router ospf vrf %s\n", ospf->name);
} else
vty_out(vty, "router ospf\n");
if (ospf->spf_delay != OSPF_SPF_DELAY_DEFAULT
|| ospf->spf_holdtime != OSPF_SPF_HOLDTIME_DEFAULT
|| ospf->spf_max_holdtime != OSPF_SPF_MAX_HOLDTIME_DEFAULT)
- vty_out(vty, " timers throttle spf %d %d %d\n",
- ospf->spf_delay, ospf->spf_holdtime,
- ospf->spf_max_holdtime);
+ vty_out(vty, " timers throttle spf %d %d %d\n", ospf->spf_delay,
+ ospf->spf_holdtime, ospf->spf_max_holdtime);
/* LSA timers print. */
if (ospf->min_ls_interval != OSPF_MIN_LS_INTERVAL)
config_write_stub_router(vty, ospf);
/* SPF refresh parameters print. */
- if (ospf->lsa_refresh_interval
- != OSPF_LSA_REFRESH_INTERVAL_DEFAULT)
- vty_out(vty, " refresh timer %d\n",
- ospf->lsa_refresh_interval);
+ if (ospf->lsa_refresh_interval != OSPF_LSA_REFRESH_INTERVAL_DEFAULT)
+ vty_out(vty, " refresh timer %d\n", ospf->lsa_refresh_interval);
/* Redistribute information print. */
config_write_ospf_redistribute(vty, ospf);
if (OSPF_IF_PARAM_CONFIGURED(IF_DEF_PARAMS(ifp),
passive_interface)
&& IF_DEF_PARAMS(ifp)->passive_interface
- != ospf->passive_interface_default) {
+ != ospf->passive_interface_default) {
vty_out(vty, " %spassive-interface %s\n",
- IF_DEF_PARAMS(ifp)->passive_interface
- ? ""
- : "no ",
+ IF_DEF_PARAMS(ifp)->passive_interface ? ""
+ : "no ",
ifp->name);
}
for (ALL_LIST_ELEMENTS_RO(ospf->oiflist, node, oi)) {
- if (!OSPF_IF_PARAM_CONFIGURED(oi->params,
- passive_interface))
+ if (!OSPF_IF_PARAM_CONFIGURED(oi->params, passive_interface))
continue;
if (OSPF_IF_PARAM_CONFIGURED(IF_DEF_PARAMS(oi->ifp),
passive_interface)) {
if (oi->params->passive_interface
- == IF_DEF_PARAMS(oi->ifp)
- ->passive_interface)
+ == IF_DEF_PARAMS(oi->ifp)->passive_interface)
continue;
} else if (oi->params->passive_interface
== ospf->passive_interface_default)
vty_out(vty, " %spassive-interface %s %s\n",
oi->params->passive_interface ? "" : "no ",
- oi->ifp->name,
- inet_ntoa(oi->address->u.prefix4));
+ oi->ifp->name, inet_ntoa(oi->address->u.prefix4));
}
/* Network area print. */
vty_out(vty, \
"%% You can't configure %s to backbone\n", \
NAME); \
- return CMD_WARNING; \
+ return CMD_WARNING; \
} \
}
if (IS_DEBUG_OSPF(zebra, ZEBRA_INTERFACE)) {
char buf[PREFIX2STR_BUFFER];
prefix2str(&router_id, buf, sizeof(buf));
- zlog_debug("Zebra rcvd: router id update %s vrf %s id %u",
- buf, ospf_vrf_id_to_name(vrf_id), vrf_id);
+ zlog_debug("Zebra rcvd: router id update %s vrf %s id %u", buf,
+ ospf_vrf_id_to_name(vrf_id), vrf_id);
}
ospf = ospf_lookup_by_vrf_id(vrf_id);
char buf[PREFIX2STR_BUFFER];
prefix2str(&router_id, buf, sizeof(buf));
- zlog_debug("%s: ospf instance not found for vrf %s id %u router_id %s",
- __PRETTY_FUNCTION__,
- ospf_vrf_id_to_name(vrf_id), vrf_id, buf);
+ zlog_debug(
+ "%s: ospf instance not found for vrf %s id %u router_id %s",
+ __PRETTY_FUNCTION__,
+ ospf_vrf_id_to_name(vrf_id), vrf_id, buf);
}
}
return 0;
/* VRF update for an interface. */
static int ospf_interface_vrf_update(int command, struct zclient *zclient,
- zebra_size_t length, vrf_id_t vrf_id)
+ zebra_size_t length, vrf_id_t vrf_id)
{
struct interface *ifp = NULL;
vrf_id_t new_vrf_id;
ifp = zebra_interface_vrf_update_read(zclient->ibuf, vrf_id,
- &new_vrf_id);
+ &new_vrf_id);
if (!ifp)
return 0;
if (IS_DEBUG_OSPF_EVENT)
- zlog_debug("%s: Rx Interface %s VRF change vrf_id %u New vrf %s id %u",
- __PRETTY_FUNCTION__, ifp->name, vrf_id,
- ospf_vrf_id_to_name(new_vrf_id), new_vrf_id);
+ zlog_debug(
+ "%s: Rx Interface %s VRF change vrf_id %u New vrf %s id %u",
+ __PRETTY_FUNCTION__, ifp->name, vrf_id,
+ ospf_vrf_id_to_name(new_vrf_id), new_vrf_id);
/*if_update(ifp, ifp->name, strlen(ifp->name), new_vrf_id);*/
if_update_to_new_vrf(ifp, new_vrf_id);
- return 0;
+ return 0;
}
void ospf_zebra_add(struct ospf *ospf, struct prefix_ipv4 *p,
- struct ospf_route *or)
+ struct ospf_route * or)
{
struct zapi_route api;
struct zapi_nexthop *api_nh;
}
void ospf_zebra_delete(struct ospf *ospf, struct prefix_ipv4 *p,
- struct ospf_route *or)
+ struct ospf_route * or)
{
struct zapi_route api;
instance, ospf->vrf_id);
if (IS_DEBUG_OSPF(zebra, ZEBRA_REDISTRIBUTE))
- zlog_debug("Redistribute[%s][%d] vrf id %u: Start Type[%d], Metric[%d]",
- ospf_redist_string(type), instance, ospf->vrf_id,
- metric_type(ospf, type, instance),
- metric_value(ospf, type, instance));
+ zlog_debug(
+ "Redistribute[%s][%d] vrf id %u: Start Type[%d], Metric[%d]",
+ ospf_redist_string(type), instance, ospf->vrf_id,
+ metric_type(ospf, type, instance),
+ metric_value(ospf, type, instance));
ospf_asbr_status_update(ospf, ++ospf->redistribute);
*/
for (i = 0; i < ZEBRA_ROUTE_MAX; i++)
if (i != api.type)
- ospf_external_info_delete(ospf, i,
- api.instance, p);
+ ospf_external_info_delete(ospf, i, api.instance,
+ p);
ei = ospf_external_info_add(ospf, api.type, api.instance, p,
ifindex, nexthop, api.tag);
struct ospf_lsa *lsa;
int type, default_refresh = 0, arg_type;
struct ospf *ospf = NULL;
- void **arg = THREAD_ARG (thread);
+ void **arg = THREAD_ARG(thread);
ospf = (struct ospf *)arg[0];
arg_type = (int)(intptr_t)arg[1];
zlog_info("Zebra[Redistribute]: distribute-list update timer fired!");
if (IS_DEBUG_OSPF_EVENT) {
- zlog_debug("%s: ospf distribute-list update arg_type %d vrf %s id %d",
- __PRETTY_FUNCTION__, arg_type,
- ospf_vrf_id_to_name(ospf->vrf_id), ospf->vrf_id);
+ zlog_debug(
+ "%s: ospf distribute-list update arg_type %d vrf %s id %d",
+ __PRETTY_FUNCTION__, arg_type,
+ ospf_vrf_id_to_name(ospf->vrf_id), ospf->vrf_id);
}
/* foreach all external info. */
}
/* Update distribute-list and set timer to apply access-list. */
-void ospf_distribute_list_update(struct ospf *ospf, int type,
- u_short instance)
+void ospf_distribute_list_update(struct ospf *ospf, int type, u_short instance)
{
struct route_table *rt;
struct ospf_external *ext;
- void **args = XCALLOC(MTYPE_OSPF_DIST_ARGS, sizeof(void *)*2);
+ void **args = XCALLOC(MTYPE_OSPF_DIST_ARGS, sizeof(void *) * 2);
args[0] = ospf;
- args[1] = (void *)((ptrdiff_t) type);
+ args[1] = (void *)((ptrdiff_t)type);
/* External info does not exist. */
ext = ospf_external_lookup(ospf, type, instance);
red_list = ospf->redist[type];
if (red_list)
- for (ALL_LIST_ELEMENTS_RO(red_list, node, red)) {
+ for (ALL_LIST_ELEMENTS_RO(red_list, node,
+ red)) {
if (ROUTEMAP(red)) {
- /* if route-map is not NULL it may be
+ /* if route-map is not NULL it
+ * may be
* using this access list */
ospf_distribute_list_update(
- ospf,
- type, red->instance);
+ ospf, type,
+ red->instance);
}
}
if (DISTRIBUTE_NAME(ospf, type)) {
/* Keep old access-list for distribute-list. */
- struct access_list *old = DISTRIBUTE_LIST(ospf,
- type);
+ struct access_list *old =
+ DISTRIBUTE_LIST(ospf, type);
/* Update access-list for distribute-list. */
- DISTRIBUTE_LIST(ospf, type) = access_list_lookup(
- AFI_IP, DISTRIBUTE_NAME(ospf, type));
+ DISTRIBUTE_LIST(ospf, type) =
+ access_list_lookup(
+ AFI_IP,
+ DISTRIBUTE_NAME(ospf, type));
/* No update for this distribute type. */
- if (old == NULL && DISTRIBUTE_LIST(ospf, type) == NULL)
+ if (old == NULL
+ && DISTRIBUTE_LIST(ospf, type) == NULL)
continue;
/* Schedule distribute-list update timer. */
if (DISTRIBUTE_LIST(ospf, type) == NULL
- || strcmp(DISTRIBUTE_NAME(ospf, type), access->name)
- == 0)
- ospf_distribute_list_update(ospf, type, 0);
+ || strcmp(DISTRIBUTE_NAME(ospf, type),
+ access->name)
+ == 0)
+ ospf_distribute_list_update(ospf, type,
+ 0);
}
}
red_list = ospf->redist[type];
if (red_list) {
- for (ALL_LIST_ELEMENTS_RO(red_list,
- node, red)) {
+ for (ALL_LIST_ELEMENTS_RO(red_list, node,
+ red)) {
if (ROUTEMAP(red)) {
/* if route-map is not NULL
* it may be using
/* Update filter-list in. */
if (PREFIX_NAME_IN(area))
if (strcmp(PREFIX_NAME_IN(area),
- prefix_list_name(plist)) == 0) {
+ prefix_list_name(plist))
+ == 0) {
PREFIX_LIST_IN(area) =
prefix_list_lookup(
- AFI_IP,
- PREFIX_NAME_IN(area));
+ AFI_IP,
+ PREFIX_NAME_IN(area));
abr_inv++;
}
/* Update filter-list out. */
if (PREFIX_NAME_OUT(area))
if (strcmp(PREFIX_NAME_OUT(area),
- prefix_list_name(plist)) == 0) {
+ prefix_list_name(plist))
+ == 0) {
PREFIX_LIST_IN(area) =
prefix_list_lookup(
- AFI_IP,
- PREFIX_NAME_OUT(area));
+ AFI_IP,
+ PREFIX_NAME_OUT(area));
abr_inv++;
}
}
}
u_char ospf_distance_apply(struct ospf *ospf, struct prefix_ipv4 *p,
- struct ospf_route *or)
+ struct ospf_route * or)
{
if (ospf == NULL)
extern void ospf_distance_reset(struct ospf *);
extern u_char ospf_distance_apply(struct ospf *ospf, struct prefix_ipv4 *,
struct ospf_route *);
-extern struct ospf_external *ospf_external_lookup(struct ospf*, u_char,
+extern struct ospf_external *ospf_external_lookup(struct ospf *, u_char,
u_short);
-extern struct ospf_external *ospf_external_add(struct ospf*, u_char, u_short);
+extern struct ospf_external *ospf_external_add(struct ospf *, u_char, u_short);
extern void ospf_external_del(struct ospf *, u_char, u_short);
extern struct ospf_redist *ospf_redist_lookup(struct ospf *, u_char, u_short);
extern struct ospf_redist *ospf_redist_add(struct ospf *, u_char, u_short);
if (IS_DEBUG_OSPF_EVENT)
zlog_debug("Router-ID[OLD:%s]: Update to %s",
- inet_ntoa(ospf->router_id),
- inet_ntoa(router_id));
+ inet_ntoa(ospf->router_id), inet_ntoa(router_id));
if (!IPV4_ADDR_SAME(&router_id_old, &router_id)) {
struct route_node *rn;
struct ospf_lsa *lsa;
- LSDB_LOOP(EXTERNAL_LSDB(ospf), rn, lsa)
+ LSDB_LOOP (EXTERNAL_LSDB(ospf), rn, lsa)
if (IS_LSA_SELF(lsa))
ospf_lsa_flush_schedule(ospf, lsa);
}
new->name = XSTRDUP(MTYPE_OSPF_TOP, name);
vrf = vrf_lookup_by_name(new->name);
if (IS_DEBUG_OSPF_EVENT)
- zlog_debug("%s: Create new ospf instance with vrf_name %s vrf_id %u",
- __PRETTY_FUNCTION__, name, new->vrf_id);
+ zlog_debug(
+ "%s: Create new ospf instance with vrf_name %s vrf_id %u",
+ __PRETTY_FUNCTION__, name, new->vrf_id);
if (vrf)
ospf_vrf_link(new, vrf);
} else {
if ((ospf_sock_init(new)) < 0) {
if (new->vrf_id != VRF_UNKNOWN)
zlog_warn(
- "%s: ospf_sock_init is unable to open a socket",
- __func__);
+ "%s: ospf_sock_init is unable to open a socket",
+ __func__);
return new;
}
thread_add_read(master, ospf_read, new, new->fd, &new->t_read);
struct listnode *node, *nnode;
for (ALL_LIST_ELEMENTS(om->ospf, node, nnode, ospf)) {
- if ((ospf->instance == instance) &&
- ((ospf->name == NULL && name == NULL) ||
- (ospf->name && name && strcmp(ospf->name, name) == 0)))
+ if ((ospf->instance == instance)
+ && ((ospf->name == NULL && name == NULL)
+ || (ospf->name && name
+ && strcmp(ospf->name, name) == 0)))
return ospf;
}
return NULL;
ospf_router_id_update(ospf);
else {
if (IS_DEBUG_OSPF_EVENT)
- zlog_debug("%s: ospf VRF (id %d) is not active yet, skip router id update"
- , __PRETTY_FUNCTION__,
- ospf->vrf_id);
+ zlog_debug(
+ "%s: ospf VRF (id %d) is not active yet, skip router id update",
+ __PRETTY_FUNCTION__,
+ ospf->vrf_id);
}
ospf_router_id_update(ospf);
}
if (!vrf)
return NULL;
return (vrf->info) ? (struct ospf *)vrf->info : NULL;
-
}
/* It should only be used when processing incoming info update from zebra.
for (ALL_LIST_ELEMENTS(om->ospf, node, nnode, ospf))
if ((ospf->name == NULL && vrf_name == NULL)
- || (ospf->name && vrf_name &&
- strcmp(ospf->name, vrf_name) == 0))
+ || (ospf->name && vrf_name
+ && strcmp(ospf->name, vrf_name) == 0))
return ospf;
return NULL;
}
close(ospf->fd);
stream_free(ospf->ibuf);
- LSDB_LOOP(OPAQUE_AS_LSDB(ospf), rn, lsa)
+ LSDB_LOOP (OPAQUE_AS_LSDB(ospf), rn, lsa)
ospf_discard_from_db(ospf, ospf->lsdb, lsa);
- LSDB_LOOP(EXTERNAL_LSDB(ospf), rn, lsa)
+ LSDB_LOOP (EXTERNAL_LSDB(ospf), rn, lsa)
ospf_discard_from_db(ospf, ospf->lsdb, lsa);
ospf_lsdb_delete_all(ospf->lsdb);
ospf_opaque_type10_lsa_term(area);
/* Free LSDBs. */
- LSDB_LOOP(ROUTER_LSDB(area), rn, lsa)
+ LSDB_LOOP (ROUTER_LSDB(area), rn, lsa)
ospf_discard_from_db(area->ospf, area->lsdb, lsa);
- LSDB_LOOP(NETWORK_LSDB(area), rn, lsa)
+ LSDB_LOOP (NETWORK_LSDB(area), rn, lsa)
ospf_discard_from_db(area->ospf, area->lsdb, lsa);
- LSDB_LOOP(SUMMARY_LSDB(area), rn, lsa)
+ LSDB_LOOP (SUMMARY_LSDB(area), rn, lsa)
ospf_discard_from_db(area->ospf, area->lsdb, lsa);
- LSDB_LOOP(ASBR_SUMMARY_LSDB(area), rn, lsa)
+ LSDB_LOOP (ASBR_SUMMARY_LSDB(area), rn, lsa)
ospf_discard_from_db(area->ospf, area->lsdb, lsa);
- LSDB_LOOP(NSSA_LSDB(area), rn, lsa)
+ LSDB_LOOP (NSSA_LSDB(area), rn, lsa)
ospf_discard_from_db(area->ospf, area->lsdb, lsa);
- LSDB_LOOP(OPAQUE_AREA_LSDB(area), rn, lsa)
+ LSDB_LOOP (OPAQUE_AREA_LSDB(area), rn, lsa)
ospf_discard_from_db(area->ospf, area->lsdb, lsa);
- LSDB_LOOP(OPAQUE_LINK_LSDB(area), rn, lsa)
+ LSDB_LOOP (OPAQUE_LINK_LSDB(area), rn, lsa)
ospf_discard_from_db(area->ospf, area->lsdb, lsa);
ospf_lsdb_delete_all(area->lsdb);
continue;
if (add_to_ospf) {
- if (ospf_external_info_find_lsa(
- ospf, &ei->p))
+ if (ospf_external_info_find_lsa(ospf,
+ &ei->p))
if (!ospf_distribute_check_connected(
ospf, ei))
ospf_external_lsa_flush(
- ospf,
- ei->type,
+ ospf, ei->type,
&ei->p,
ei->ifindex /*, ei->nexthop */);
} else {
if (ospf_distribute_check_connected(
ospf, ei))
ospf_external_lsa_originate(
- ospf,
- ei);
+ ospf, ei);
}
}
}
/* Find interfaces that are not configured already. */
for (ALL_LIST_ELEMENTS(ospf->oiflist, node, nnode, oi)) {
- if (oi->type == OSPF_IFTYPE_VIRTUALLINK)
- continue;
+ if (oi->type == OSPF_IFTYPE_VIRTUALLINK)
+ continue;
- ospf_network_run_subnet(ospf, oi->connected, NULL, NULL);
+ ospf_network_run_subnet(ospf, oi->connected, NULL, NULL);
}
/* Update connected redistribute. */
return;
if (IS_DEBUG_OSPF_EVENT)
- zlog_debug("%s: interface %s ifp->vrf_id %u ospf vrf %s vrf_id %u router_id %s",
- __PRETTY_FUNCTION__, ifp->name, ifp->vrf_id,
- ospf_vrf_id_to_name(ospf->vrf_id), ospf->vrf_id,
- inet_ntoa(ospf->router_id));
+ zlog_debug(
+ "%s: interface %s ifp->vrf_id %u ospf vrf %s vrf_id %u router_id %s",
+ __PRETTY_FUNCTION__, ifp->name, ifp->vrf_id,
+ ospf_vrf_id_to_name(ospf->vrf_id), ospf->vrf_id,
+ inet_ntoa(ospf->router_id));
/* OSPF must be ready. */
if (!ospf_is_ready(ospf))
int ret = 0;
if (IS_DEBUG_OSPF_EVENT)
- zlog_debug("%s: VRF %s id %u enabled",
- __PRETTY_FUNCTION__, vrf->name, vrf->vrf_id);
+ zlog_debug("%s: VRF %s id %u enabled", __PRETTY_FUNCTION__,
+ vrf->name, vrf->vrf_id);
ospf = ospf_lookup_by_name(vrf->name);
if (ospf) {
/* We have instance configured, link to VRF and make it "up". */
ospf_vrf_link(ospf, vrf);
if (IS_DEBUG_OSPF_EVENT)
- zlog_debug("%s: ospf linked to vrf %s vrf_id %u (old id %u)",
- __PRETTY_FUNCTION__, vrf->name, ospf->vrf_id,
- old_vrf_id);
+ zlog_debug(
+ "%s: ospf linked to vrf %s vrf_id %u (old id %u)",
+ __PRETTY_FUNCTION__, vrf->name, ospf->vrf_id,
+ old_vrf_id);
if (old_vrf_id != ospf->vrf_id) {
if (ospfd_privs.change(ZPRIVS_RAISE)) {
- zlog_err("ospf_sock_init: could not raise privs, %s",
- safe_strerror(errno));
+ zlog_err(
+ "ospf_sock_init: could not raise privs, %s",
+ safe_strerror(errno));
}
ret = ospf_sock_init(ospf);
if (ospfd_privs.change(ZPRIVS_LOWER)) {
- zlog_err("ospf_sock_init: could not lower privs, %s",
- safe_strerror(errno));
+ zlog_err(
+ "ospf_sock_init: could not lower privs, %s",
+ safe_strerror(errno));
}
if (ret < 0 || ospf->fd <= 0)
return 0;
- thread_add_read(master, ospf_read, ospf,
- ospf->fd, &ospf->t_read);
+ thread_add_read(master, ospf_read, ospf, ospf->fd,
+ &ospf->t_read);
ospf->oi_running = 1;
ospf_zebra_vrf_register(ospf);
ospf_router_id_update(ospf);
return 0;
if (IS_DEBUG_OSPF_EVENT)
- zlog_debug("%s: VRF %s id %d disabled.",
- __PRETTY_FUNCTION__, vrf->name, vrf->vrf_id);
+ zlog_debug("%s: VRF %s id %d disabled.", __PRETTY_FUNCTION__,
+ vrf->name, vrf->vrf_id);
ospf = ospf_lookup_by_name(vrf->name);
if (ospf) {
ospf->oi_running = 0;
if (IS_DEBUG_OSPF_EVENT)
zlog_debug("%s: ospf old_vrf_id %d unlinked",
- __PRETTY_FUNCTION__, old_vrf_id);
+ __PRETTY_FUNCTION__, old_vrf_id);
thread_cancel(ospf->t_read);
close(ospf->fd);
ospf->fd = -1;
void ospf_vrf_init(void)
{
- vrf_init(ospf_vrf_new, ospf_vrf_enable,
- ospf_vrf_disable, ospf_vrf_delete);
+ vrf_init(ospf_vrf_new, ospf_vrf_enable, ospf_vrf_disable,
+ ospf_vrf_delete);
}
void ospf_vrf_terminate(void)
struct in_addr router_id_static; /* Configured manually. */
struct in_addr router_id_zebra;
- vrf_id_t vrf_id; /* VRF Id */
- char *name; /* VRF name */
+ vrf_id_t vrf_id; /* VRF Id */
+ char *name; /* VRF name */
/* ABR/ASBR internal flags. */
u_char flags;
/* RFC3137 stub router. Configured time to stay stub / max-metric */
unsigned int stub_router_startup_time; /* seconds */
unsigned int stub_router_shutdown_time; /* seconds */
- /* $FRR indent$ */
- /* clang-format off */
#define OSPF_STUB_ROUTER_UNCONFIGURED 0
u_char stub_router_admin_set;
#define OSPF_STUB_ROUTER_ADMINISTRATIVE_SET 1
spf_hold_multiplier; /* Adaptive multiplier for hold time */
int default_originate; /* Default information originate. */
- /* $FRR indent$ */
- /* clang-format off */
#define DEFAULT_ORIGINATE_NONE 0
#define DEFAULT_ORIGINATE_ZEBRA 1
#define DEFAULT_ORIGINATE_ALWAYS 2
int external_routing; /* ExternalRoutingCapability. */
int no_summary; /* Don't inject summaries into stub.*/
int shortcut_configured; /* Area configured as shortcut. */
- /* $FRR indent$ */
- /* clang-format off */
#define OSPF_SHORTCUT_DEFAULT 0
#define OSPF_SHORTCUT_ENABLE 1
#define OSPF_SHORTCUT_DISABLE 2
u_char NSSATranslatorRole; /* NSSA configured role */
- /* $FRR indent$ */
- /* clang-format off */
#define OSPF_NSSA_ROLE_NEVER 0
#define OSPF_NSSA_ROLE_CANDIDATE 1
#define OSPF_NSSA_ROLE_ALWAYS 2
u_char NSSATranslatorState; /* NSSA operational role */
- /* $FRR indent$ */
- /* clang-format off */
#define OSPF_NSSA_TRANSLATE_DISABLED 0
#define OSPF_NSSA_TRANSLATE_ENABLED 1
int NSSATranslatorStabilityInterval;
u_char transit; /* TransitCapability. */
- /* $FRR indent$ */
- /* clang-format off */
#define OSPF_TRANSIT_FALSE 0
#define OSPF_TRANSIT_TRUE 1
struct route_table *ranges; /* Configured Area Ranges. */
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'v'},
- {0, 0, 0, 0} };
+ {0, 0, 0, 0}};
int option_index = 0;
c = getopt_long(argc, argv, "vh", long_options, &option_index);
return -1;
}
- if (setsockopt(rth->fd,SOL_SOCKET,SO_SNDBUF,&sndbuf,sizeof(sndbuf)) < 0) {
+ if (setsockopt(rth->fd, SOL_SOCKET, SO_SNDBUF, &sndbuf, sizeof(sndbuf))
+ < 0) {
perror("SO_SNDBUF");
return -1;
}
- if (setsockopt(rth->fd,SOL_SOCKET,SO_RCVBUF,&rcvbuf,sizeof(rcvbuf)) < 0) {
+ if (setsockopt(rth->fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf))
+ < 0) {
perror("SO_RCVBUF");
return -1;
}
rth->local.nl_family = AF_NETLINK;
rth->local.nl_groups = subscriptions;
- if (bind(rth->fd, (struct sockaddr*)&rth->local, sizeof(rth->local)) < 0) {
+ if (bind(rth->fd, (struct sockaddr *)&rth->local, sizeof(rth->local))
+ < 0) {
perror("Cannot bind netlink socket");
return -1;
}
addr_len = sizeof(rth->local);
- if (getsockname(rth->fd, (struct sockaddr*)&rth->local, &addr_len) < 0) {
+ if (getsockname(rth->fd, (struct sockaddr *)&rth->local, &addr_len)
+ < 0) {
perror("Cannot getsockname");
return -1;
}
return -1;
}
if (rth->local.nl_family != AF_NETLINK) {
- fprintf(stderr, "Wrong address family %d\n", rth->local.nl_family);
+ fprintf(stderr, "Wrong address family %d\n",
+ rth->local.nl_family);
return -1;
}
rth->seq = time(NULL);
memset(&req, 0, sizeof(req));
req.nlh.nlmsg_len = sizeof(req);
req.nlh.nlmsg_type = type;
- req.nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST;
+ req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
req.nlh.nlmsg_pid = 0;
req.nlh.nlmsg_seq = rth->dump = ++rth->seq;
req.g.rtgen_family = family;
- return send(rth->fd, (void*)&req, sizeof(req), 0);
+ return send(rth->fd, (void *)&req, sizeof(req), 0);
}
int rtnl_send(struct rtnl_handle *rth, const char *buf, int len)
return status;
/* Check for immediate errors */
- status = recv(rth->fd, resp, sizeof(resp), MSG_DONTWAIT|MSG_PEEK);
+ status = recv(rth->fd, resp, sizeof(resp), MSG_DONTWAIT | MSG_PEEK);
if (status < 0) {
if (errno == EAGAIN)
return 0;
for (h = (struct nlmsghdr *)resp; NLMSG_OK(h, (uint32_t)status);
h = NLMSG_NEXT(h, status)) {
if (h->nlmsg_type == NLMSG_ERROR) {
- struct nlmsgerr *err = (struct nlmsgerr*)NLMSG_DATA(h);
- if (h->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr)))
+ struct nlmsgerr *err = (struct nlmsgerr *)NLMSG_DATA(h);
+ if (h->nlmsg_len
+ < NLMSG_LENGTH(sizeof(struct nlmsgerr)))
fprintf(stderr, "ERROR truncated\n");
else
errno = -err->error;
{
struct nlmsghdr nlh;
struct sockaddr_nl nladdr;
- struct iovec iov[2] = {
- { .iov_base = &nlh, .iov_len = sizeof(nlh) },
- { .iov_base = req, .iov_len = len }
- };
+ struct iovec iov[2] = {{.iov_base = &nlh, .iov_len = sizeof(nlh)},
+ {.iov_base = req, .iov_len = len}};
struct msghdr msg = {
.msg_name = &nladdr,
- .msg_namelen = sizeof(nladdr),
+ .msg_namelen = sizeof(nladdr),
.msg_iov = iov,
.msg_iovlen = 2,
};
nlh.nlmsg_len = NLMSG_LENGTH(len);
nlh.nlmsg_type = type;
- nlh.nlmsg_flags = NLM_F_ROOT|NLM_F_MATCH|NLM_F_REQUEST;
+ nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
nlh.nlmsg_pid = 0;
nlh.nlmsg_seq = rth->dump = ++rth->seq;
}
for (a = arg; a->filter; a++) {
- struct nlmsghdr *h = (struct nlmsghdr*)buf;
+ struct nlmsghdr *h = (struct nlmsghdr *)buf;
msglen = status;
while (NLMSG_OK(h, (uint32_t)msglen)) {
int err;
- if (nladdr.nl_pid != 0 ||
- h->nlmsg_pid != rth->local.nl_pid ||
- h->nlmsg_seq != rth->dump) {
+ if (nladdr.nl_pid != 0
+ || h->nlmsg_pid != rth->local.nl_pid
+ || h->nlmsg_seq != rth->dump) {
if (a->junk) {
err = a->junk(&nladdr, h,
a->arg2);
break; /* process next filter */
}
if (h->nlmsg_type == NLMSG_ERROR) {
- struct nlmsgerr *err = (struct nlmsgerr*)NLMSG_DATA(h);
- if (h->nlmsg_len < NLMSG_LENGTH(sizeof(struct nlmsgerr))) {
+ struct nlmsgerr *err =
+ (struct nlmsgerr *)NLMSG_DATA(
+ h);
+ if (h->nlmsg_len
+ < NLMSG_LENGTH(sizeof(
+ struct nlmsgerr))) {
fprintf(stderr,
"ERROR truncated\n");
} else {
if (err < 0)
return err;
-skip_it:
+ skip_it:
h = NLMSG_NEXT(h, msglen);
}
}
}
}
-int rtnl_dump_filter(struct rtnl_handle *rth,
- rtnl_filter_t filter,
- void *arg1,
- rtnl_filter_t junk,
- void *arg2)
+int rtnl_dump_filter(struct rtnl_handle *rth, rtnl_filter_t filter, void *arg1,
+ rtnl_filter_t junk, void *arg2)
{
const struct rtnl_dump_filter_arg a[2] = {
- { .filter = filter, .arg1 = arg1, .junk = junk, .arg2 = arg2 },
- { .filter = NULL, .arg1 = NULL, .junk = NULL, .arg2 = NULL }
- };
+ {.filter = filter, .arg1 = arg1, .junk = junk, .arg2 = arg2},
+ {.filter = NULL, .arg1 = NULL, .junk = NULL, .arg2 = NULL}};
return rtnl_dump_filter_l(rth, a);
}
int rtnl_talk(struct rtnl_handle *rtnl, struct nlmsghdr *n, pid_t peer,
- unsigned groups, struct nlmsghdr *answer,
- rtnl_filter_t junk,
+ unsigned groups, struct nlmsghdr *answer, rtnl_filter_t junk,
void *jarg)
{
int status;
unsigned seq;
struct nlmsghdr *h;
struct sockaddr_nl nladdr;
- struct iovec iov = {
- .iov_base = (void*) n,
- .iov_len = n->nlmsg_len
- };
+ struct iovec iov = {.iov_base = (void *)n, .iov_len = n->nlmsg_len};
struct msghdr msg = {
.msg_name = &nladdr,
.msg_namelen = sizeof(nladdr),
.msg_iov = &iov,
.msg_iovlen = 1,
};
- char buf[16384];
+ char buf[16384];
memset(&nladdr, 0, sizeof(nladdr));
nladdr.nl_family = AF_NETLINK;
return -1;
}
- memset(buf,0,sizeof(buf));
+ memset(buf, 0, sizeof(buf));
iov.iov_base = buf;
return -1;
}
if (msg.msg_namelen != sizeof(nladdr)) {
- fprintf(stderr, "sender address length == %d\n", msg.msg_namelen);
+ fprintf(stderr, "sender address length == %d\n",
+ msg.msg_namelen);
exit(1);
}
- for (h = (struct nlmsghdr*)buf; status >= (int)sizeof(*h); ) {
+ for (h = (struct nlmsghdr *)buf; status >= (int)sizeof(*h);) {
int err;
int len = h->nlmsg_len;
int l = len - sizeof(*h);
- if (l<0 || len>status) {
+ if (l < 0 || len > status) {
if (msg.msg_flags & MSG_TRUNC) {
fprintf(stderr, "Truncated message\n");
return -1;
}
- fprintf(stderr, "!!!malformed message: len=%d\n", len);
+ fprintf(stderr,
+ "!!!malformed message: len=%d\n", len);
exit(1);
}
- if ((int)nladdr.nl_pid != peer ||
- h->nlmsg_pid != rtnl->local.nl_pid ||
- h->nlmsg_seq != seq) {
+ if ((int)nladdr.nl_pid != peer
+ || h->nlmsg_pid != rtnl->local.nl_pid
+ || h->nlmsg_seq != seq) {
if (junk) {
err = junk(&nladdr, h, jarg);
if (err < 0)
}
/* Don't forget to skip that message. */
status -= NLMSG_ALIGN(len);
- h = (struct nlmsghdr*)((char*)h + NLMSG_ALIGN(len));
+ h = (struct nlmsghdr *)((char *)h
+ + NLMSG_ALIGN(len));
continue;
}
if (h->nlmsg_type == NLMSG_ERROR) {
- struct nlmsgerr *err = (struct nlmsgerr*)NLMSG_DATA(h);
+ struct nlmsgerr *err =
+ (struct nlmsgerr *)NLMSG_DATA(h);
if (l < (int)sizeof(struct nlmsgerr)) {
fprintf(stderr, "ERROR truncated\n");
} else {
errno = -err->error;
if (errno == 0) {
if (answer)
- memcpy(answer, h, h->nlmsg_len);
+ memcpy(answer, h,
+ h->nlmsg_len);
return 0;
}
perror("RTNETLINK answers");
fprintf(stderr, "Unexpected reply!!!\n");
status -= NLMSG_ALIGN(len);
- h = (struct nlmsghdr*)((char*)h + NLMSG_ALIGN(len));
+ h = (struct nlmsghdr *)((char *)h + NLMSG_ALIGN(len));
}
if (msg.msg_flags & MSG_TRUNC) {
fprintf(stderr, "Message truncated\n");
}
}
-int rtnl_listen(struct rtnl_handle *rtnl,
- rtnl_filter_t handler,
- void *jarg)
+int rtnl_listen(struct rtnl_handle *rtnl, rtnl_filter_t handler, void *jarg)
{
int status;
struct nlmsghdr *h;
.msg_iov = &iov,
.msg_iovlen = 1,
};
- char buf[8192];
+ char buf[8192];
memset(&nladdr, 0, sizeof(nladdr));
nladdr.nl_family = AF_NETLINK;
return -1;
}
if (msg.msg_namelen != sizeof(nladdr)) {
- fprintf(stderr, "Sender address length == %d\n", msg.msg_namelen);
+ fprintf(stderr, "Sender address length == %d\n",
+ msg.msg_namelen);
exit(1);
}
- for (h =(struct nlmsghdr*)buf; status >= (int)sizeof(*h); ) {
+ for (h = (struct nlmsghdr *)buf; status >= (int)sizeof(*h);) {
int err;
int len = h->nlmsg_len;
int l = len - sizeof(*h);
- if (l<0 || len>status) {
+ if (l < 0 || len > status) {
if (msg.msg_flags & MSG_TRUNC) {
fprintf(stderr, "Truncated message\n");
return -1;
}
- fprintf(stderr, "!!!malformed message: len=%d\n", len);
+ fprintf(stderr,
+ "!!!malformed message: len=%d\n", len);
exit(1);
}
return err;
status -= NLMSG_ALIGN(len);
- h = (struct nlmsghdr*)((char*)h + NLMSG_ALIGN(len));
+ h = (struct nlmsghdr *)((char *)h + NLMSG_ALIGN(len));
}
if (msg.msg_flags & MSG_TRUNC) {
fprintf(stderr, "Message truncated\n");
}
}
-int rtnl_from_file(FILE *rtnl, rtnl_filter_t handler,
- void *jarg)
+int rtnl_from_file(FILE *rtnl, rtnl_filter_t handler, void *jarg)
{
int status;
struct sockaddr_nl nladdr;
- char buf[8192];
- struct nlmsghdr *h = (void*)buf;
+ char buf[8192];
+ struct nlmsghdr *h = (void *)buf;
memset(&nladdr, 0, sizeof(nladdr));
nladdr.nl_family = AF_NETLINK;
len = h->nlmsg_len;
l = len - sizeof(*h);
- if (l<0 || len>(int)sizeof(buf)) {
+ if (l < 0 || len > (int)sizeof(buf)) {
fprintf(stderr, "!!!malformed message: len=%d @%lu\n",
len, ftell(rtnl));
return -1;
int len = RTA_LENGTH(4);
struct rtattr *rta;
if ((int)(NLMSG_ALIGN(n->nlmsg_len) + len) > maxlen) {
- fprintf(stderr,"addattr32: Error! max allowed bound %d exceeded\n",maxlen);
+ fprintf(stderr,
+ "addattr32: Error! max allowed bound %d exceeded\n",
+ maxlen);
return -1;
}
rta = NLMSG_TAIL(n);
struct rtattr *rta;
if ((int)(NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(len)) > maxlen) {
- fprintf(stderr, "addattr_l ERROR: message exceeded bound of %d\n",maxlen);
+ fprintf(stderr,
+ "addattr_l ERROR: message exceeded bound of %d\n",
+ maxlen);
return -1;
}
rta = NLMSG_TAIL(n);
int addraw_l(struct nlmsghdr *n, int maxlen, const void *data, int len)
{
if ((int)(NLMSG_ALIGN(n->nlmsg_len) + NLMSG_ALIGN(len)) > maxlen) {
- fprintf(stderr, "addraw_l ERROR: message exceeded bound of %d\n",maxlen);
+ fprintf(stderr,
+ "addraw_l ERROR: message exceeded bound of %d\n",
+ maxlen);
return -1;
}
memcpy(NLMSG_TAIL(n), data, len);
- memset((uint8_t *) NLMSG_TAIL(n) + len, 0, NLMSG_ALIGN(len) - len);
+ memset((uint8_t *)NLMSG_TAIL(n) + len, 0, NLMSG_ALIGN(len) - len);
n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + NLMSG_ALIGN(len);
return 0;
}
struct rtattr *subrta;
if ((int)(RTA_ALIGN(rta->rta_len) + len) > maxlen) {
- fprintf(stderr,"rta_addattr32: Error! max allowed bound %d exceeded\n",maxlen);
+ fprintf(stderr,
+ "rta_addattr32: Error! max allowed bound %d exceeded\n",
+ maxlen);
return -1;
}
- subrta = (struct rtattr*)(((char*)rta) + RTA_ALIGN(rta->rta_len));
+ subrta = (struct rtattr *)(((char *)rta) + RTA_ALIGN(rta->rta_len));
subrta->rta_type = type;
subrta->rta_len = len;
memcpy(RTA_DATA(subrta), &data, 4);
return 0;
}
-int rta_addattr_l(struct rtattr *rta, int maxlen, int type,
- const void *data, int alen)
+int rta_addattr_l(struct rtattr *rta, int maxlen, int type, const void *data,
+ int alen)
{
struct rtattr *subrta;
int len = RTA_LENGTH(alen);
if ((int)(RTA_ALIGN(rta->rta_len) + RTA_ALIGN(len)) > maxlen) {
- fprintf(stderr,"rta_addattr_l: Error! max allowed bound %d exceeded\n",maxlen);
+ fprintf(stderr,
+ "rta_addattr_l: Error! max allowed bound %d exceeded\n",
+ maxlen);
return -1;
}
- subrta = (struct rtattr*)(((char*)rta) + RTA_ALIGN(rta->rta_len));
+ subrta = (struct rtattr *)(((char *)rta) + RTA_ALIGN(rta->rta_len));
subrta->rta_type = type;
subrta->rta_len = len;
memcpy(RTA_DATA(subrta), data, alen);
while (RTA_OK(rta, len)) {
if ((rta->rta_type <= max) && (!tb[rta->rta_type]))
tb[rta->rta_type] = rta;
- rta = RTA_NEXT(rta,len);
+ rta = RTA_NEXT(rta, len);
}
if (len)
- fprintf(stderr, "!!!Deficit %d, rta_len=%d\n", len, rta->rta_len);
+ fprintf(stderr, "!!!Deficit %d, rta_len=%d\n", len,
+ rta->rta_len);
return 0;
}
-int parse_rtattr_byindex(struct rtattr *tb[], int max, struct rtattr *rta, int len)
+int parse_rtattr_byindex(struct rtattr *tb[], int max, struct rtattr *rta,
+ int len)
{
int i = 0;
while (RTA_OK(rta, len)) {
if (rta->rta_type <= max && i < max)
tb[i++] = rta;
- rta = RTA_NEXT(rta,len);
+ rta = RTA_NEXT(rta, len);
}
if (len)
- fprintf(stderr, "!!!Deficit %d, rta_len=%d\n", len, rta->rta_len);
+ fprintf(stderr, "!!!Deficit %d, rta_len=%d\n", len,
+ rta->rta_len);
return i;
}
-int __parse_rtattr_nested_compat(struct rtattr *tb[], int max, struct rtattr *rta,
- int len)
+int __parse_rtattr_nested_compat(struct rtattr *tb[], int max,
+ struct rtattr *rta, int len)
{
if ((int)RTA_PAYLOAD(rta) < len)
return -1;
if (RTA_PAYLOAD(rta) >= RTA_ALIGN(len) + sizeof(struct rtattr)) {
- rta = (struct rtattr *)(uint8_t *)RTA_DATA(rta)+RTA_ALIGN(len);
+ rta = (struct rtattr *)(uint8_t *)RTA_DATA(rta)
+ + RTA_ALIGN(len);
return parse_rtattr_nested(tb, max, rta);
}
memset(tb, 0, sizeof(struct rtattr *) * (max + 1));
#include <linux/if_addr.h>
#include <linux/neighbour.h>
-struct rtnl_handle
-{
- int fd;
- struct sockaddr_nl local;
- struct sockaddr_nl peer;
- __u32 seq;
- __u32 dump;
+struct rtnl_handle {
+ int fd;
+ struct sockaddr_nl local;
+ struct sockaddr_nl peer;
+ __u32 seq;
+ __u32 dump;
};
extern int rcvbuf;
extern int rtnl_open(struct rtnl_handle *rth, unsigned subscriptions);
-extern int rtnl_open_byproto(struct rtnl_handle *rth, unsigned subscriptions, int protocol);
+extern int rtnl_open_byproto(struct rtnl_handle *rth, unsigned subscriptions,
+ int protocol);
extern void rtnl_close(struct rtnl_handle *rth);
extern int rtnl_wilddump_request(struct rtnl_handle *rth, int fam, int type);
-extern int rtnl_dump_request(struct rtnl_handle *rth, int type, void *req, int len);
+extern int rtnl_dump_request(struct rtnl_handle *rth, int type, void *req,
+ int len);
-typedef int (*rtnl_filter_t)(const struct sockaddr_nl *,
- struct nlmsghdr *n, void *);
+typedef int (*rtnl_filter_t)(const struct sockaddr_nl *, struct nlmsghdr *n,
+ void *);
-struct rtnl_dump_filter_arg
-{
+struct rtnl_dump_filter_arg {
rtnl_filter_t filter;
void *arg1;
rtnl_filter_t junk;
extern int rtnl_dump_filter_l(struct rtnl_handle *rth,
const struct rtnl_dump_filter_arg *arg);
extern int rtnl_dump_filter(struct rtnl_handle *rth, rtnl_filter_t filter,
- void *arg1,
- rtnl_filter_t junk,
- void *arg2);
+ void *arg1, rtnl_filter_t junk, void *arg2);
extern int rtnl_talk(struct rtnl_handle *rtnl, struct nlmsghdr *n, pid_t peer,
unsigned groups, struct nlmsghdr *answer,
- rtnl_filter_t junk,
- void *jarg);
+ rtnl_filter_t junk, void *jarg);
extern int rtnl_send(struct rtnl_handle *rth, const char *buf, int);
extern int rtnl_send_check(struct rtnl_handle *rth, const char *buf, int);
extern int addattr32(struct nlmsghdr *n, int maxlen, int type, __u32 data);
-extern int addattr_l(struct nlmsghdr *n, int maxlen, int type, const void *data, int alen);
+extern int addattr_l(struct nlmsghdr *n, int maxlen, int type, const void *data,
+ int alen);
extern int addraw_l(struct nlmsghdr *n, int maxlen, const void *data, int len);
extern struct rtattr *addattr_nest(struct nlmsghdr *n, int maxlen, int type);
extern int addattr_nest_end(struct nlmsghdr *n, struct rtattr *nest);
-extern struct rtattr *addattr_nest_compat(struct nlmsghdr *n, int maxlen, int type, const void *data, int len);
+extern struct rtattr *addattr_nest_compat(struct nlmsghdr *n, int maxlen,
+ int type, const void *data, int len);
extern int addattr_nest_compat_end(struct nlmsghdr *n, struct rtattr *nest);
extern int rta_addattr32(struct rtattr *rta, int maxlen, int type, __u32 data);
-extern int rta_addattr_l(struct rtattr *rta, int maxlen, int type, const void *data, int alen);
+extern int rta_addattr_l(struct rtattr *rta, int maxlen, int type,
+ const void *data, int alen);
-extern int parse_rtattr(struct rtattr *tb[], int max, struct rtattr *rta, int len);
-extern int parse_rtattr_byindex(struct rtattr *tb[], int max, struct rtattr *rta, int len);
-extern int __parse_rtattr_nested_compat(struct rtattr *tb[], int max, struct rtattr *rta, int len);
+extern int parse_rtattr(struct rtattr *tb[], int max, struct rtattr *rta,
+ int len);
+extern int parse_rtattr_byindex(struct rtattr *tb[], int max,
+ struct rtattr *rta, int len);
+extern int __parse_rtattr_nested_compat(struct rtattr *tb[], int max,
+ struct rtattr *rta, int len);
-#define parse_rtattr_nested(tb, max, rta) \
+#define parse_rtattr_nested(tb, max, rta) \
(parse_rtattr((tb), (max), RTA_DATA(rta), RTA_PAYLOAD(rta)))
-#define parse_rtattr_nested_compat(tb, max, rta, data, len) \
-({ data = RTA_PAYLOAD(rta) >= len ? RTA_DATA(rta) : NULL; \
- __parse_rtattr_nested_compat(tb, max, rta, len); })
+#define parse_rtattr_nested_compat(tb, max, rta, data, len) \
+ ({ \
+ data = RTA_PAYLOAD(rta) >= len ? RTA_DATA(rta) : NULL; \
+ __parse_rtattr_nested_compat(tb, max, rta, len); \
+ })
-extern int rtnl_listen(struct rtnl_handle *, rtnl_filter_t handler,
- void *jarg);
-extern int rtnl_from_file(FILE *, rtnl_filter_t handler,
- void *jarg);
+extern int rtnl_listen(struct rtnl_handle *, rtnl_filter_t handler, void *jarg);
+extern int rtnl_from_file(FILE *, rtnl_filter_t handler, void *jarg);
-#define NLMSG_TAIL(nmsg) \
- ((struct rtattr *) (((uint8_t *) (nmsg)) + NLMSG_ALIGN((nmsg)->nlmsg_len)))
+#define NLMSG_TAIL(nmsg) \
+ ((struct rtattr *)(((uint8_t *)(nmsg)) \
+ + NLMSG_ALIGN((nmsg)->nlmsg_len)))
#ifndef IFA_RTA
-#define IFA_RTA(r) \
- ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ifaddrmsg))))
+#define IFA_RTA(r) \
+ ((struct rtattr *)(((char *)(r)) \
+ + NLMSG_ALIGN(sizeof(struct ifaddrmsg))))
#endif
#ifndef IFA_PAYLOAD
#define IFA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct ifaddrmsg))
#endif
#ifndef IFLA_RTA
-#define IFLA_RTA(r) \
- ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ifinfomsg))))
+#define IFLA_RTA(r) \
+ ((struct rtattr *)(((char *)(r)) \
+ + NLMSG_ALIGN(sizeof(struct ifinfomsg))))
#endif
#ifndef IFLA_PAYLOAD
#define IFLA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct ifinfomsg))
#endif
#ifndef NDA_RTA
-#define NDA_RTA(r) \
- ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ndmsg))))
+#define NDA_RTA(r) \
+ ((struct rtattr *)(((char *)(r)) + NLMSG_ALIGN(sizeof(struct ndmsg))))
#endif
#ifndef NDA_PAYLOAD
#define NDA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct ndmsg))
#endif
#ifndef NDTA_RTA
-#define NDTA_RTA(r) \
- ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ndtmsg))))
+#define NDTA_RTA(r) \
+ ((struct rtattr *)(((char *)(r)) + NLMSG_ALIGN(sizeof(struct ndtmsg))))
#endif
#ifndef NDTA_PAYLOAD
#define NDTA_PAYLOAD(n) NLMSG_PAYLOAD(n,sizeof(struct ndtmsg))
}
/* Metric preference */
- pim_write_uint32(pim_msg_curr, rpt_bit_flag
- ? metric_preference | 0x80000000
- : metric_preference);
+ pim_write_uint32(pim_msg_curr,
+ rpt_bit_flag ? metric_preference | 0x80000000
+ : metric_preference);
pim_msg_curr += 4;
/* Route metric */
char str[INET_ADDRSTRLEN];
pim_inet4_dump("<bfd_nbr?>",
- neigh->source_addr,
- str, sizeof(str));
- zlog_debug("%s: Replaying Pim Neigh %s to BFD vrf_id %u",
- __PRETTY_FUNCTION__, str,
- vrf->vrf_id);
+ neigh->source_addr, str,
+ sizeof(str));
+ zlog_debug(
+ "%s: Replaying Pim Neigh %s to BFD vrf_id %u",
+ __PRETTY_FUNCTION__, str,
+ vrf->vrf_id);
}
pim_bfd_reg_dereg_nbr(neigh,
ZEBRA_BFD_DEST_UPDATE);
static void pim_show_assert_helper(struct vty *vty,
struct pim_interface *pim_ifp,
- struct pim_ifchannel *ch,
- time_t now)
+ struct pim_ifchannel *ch, time_t now)
{
char ch_src_str[INET_ADDRSTRLEN];
char ch_grp_str[INET_ADDRSTRLEN];
ifaddr = pim_ifp->primary_address;
- pim_inet4_dump("<ch_src?>", ch->sg.src, ch_src_str,
- sizeof(ch_src_str));
- pim_inet4_dump("<ch_grp?>", ch->sg.grp, ch_grp_str,
- sizeof(ch_grp_str));
+ pim_inet4_dump("<ch_src?>", ch->sg.src, ch_src_str, sizeof(ch_src_str));
+ pim_inet4_dump("<ch_grp?>", ch->sg.grp, ch_grp_str, sizeof(ch_grp_str));
pim_inet4_dump("<assrt_win?>", ch->ifassert_winner, winner_str,
sizeof(winner_str));
- pim_time_uptime(uptime, sizeof(uptime),
- now - ch->ifassert_creation);
- pim_time_timer_to_mmss(timer, sizeof(timer),
- ch->t_ifassert_timer);
+ pim_time_uptime(uptime, sizeof(uptime), now - ch->ifassert_creation);
+ pim_time_timer_to_mmss(timer, sizeof(timer), ch->t_ifassert_timer);
vty_out(vty, "%-9s %-15s %-15s %-15s %-6s %-15s %-8s %-5s\n",
- ch->interface->name, inet_ntoa(ifaddr), ch_src_str,
- ch_grp_str,
- pim_ifchannel_ifassert_name(ch->ifassert_state),
- winner_str, uptime, timer);
+ ch->interface->name, inet_ntoa(ifaddr), ch_src_str, ch_grp_str,
+ pim_ifchannel_ifassert_name(ch->ifassert_state), winner_str,
+ uptime, timer);
}
static void pim_show_assert(struct pim_instance *pim, struct vty *vty)
ifaddr = pim_ifp->primary_address;
- pim_inet4_dump("<ch_src?>", ch->sg.src, ch_src_str,
- sizeof(ch_src_str));
- pim_inet4_dump("<ch_grp?>", ch->sg.grp, ch_grp_str,
- sizeof(ch_grp_str));
+ pim_inet4_dump("<ch_src?>", ch->sg.src, ch_src_str, sizeof(ch_src_str));
+ pim_inet4_dump("<ch_grp?>", ch->sg.grp, ch_grp_str, sizeof(ch_grp_str));
vty_out(vty, "%-9s %-15s %-15s %-15s %-3s %-3s %-3s %-4s\n",
- ch->interface->name, inet_ntoa(ifaddr), ch_src_str,
- ch_grp_str,
+ ch->interface->name, inet_ntoa(ifaddr), ch_src_str, ch_grp_str,
PIM_IF_FLAG_TEST_COULD_ASSERT(ch->flags) ? "yes" : "no",
pim_macro_ch_could_assert_eval(ch) ? "yes" : "no",
- PIM_IF_FLAG_TEST_ASSERT_TRACKING_DESIRED(ch->flags)
- ? "yes"
- : "no",
- pim_macro_assert_tracking_desired_eval(ch) ? "yes"
- : "no");
+ PIM_IF_FLAG_TEST_ASSERT_TRACKING_DESIRED(ch->flags) ? "yes"
+ : "no",
+ pim_macro_assert_tracking_desired_eval(ch) ? "yes" : "no");
}
static void pim_show_assert_internal(struct pim_instance *pim, struct vty *vty)
am = pim_macro_spt_assert_metric(&ch->upstream->rpf,
pim_ifp->primary_address);
- pim_inet4_dump("<ch_src?>", ch->sg.src, ch_src_str,
- sizeof(ch_src_str));
- pim_inet4_dump("<ch_grp?>", ch->sg.grp, ch_grp_str,
- sizeof(ch_grp_str));
- pim_inet4_dump("<addr?>", am.ip_address, addr_str,
- sizeof(addr_str));
+ pim_inet4_dump("<ch_src?>", ch->sg.src, ch_src_str, sizeof(ch_src_str));
+ pim_inet4_dump("<ch_grp?>", ch->sg.grp, ch_grp_str, sizeof(ch_grp_str));
+ pim_inet4_dump("<addr?>", am.ip_address, addr_str, sizeof(addr_str));
vty_out(vty, "%-9s %-15s %-15s %-15s %-3s %4u %6u %-15s\n",
- ch->interface->name, inet_ntoa(ifaddr), ch_src_str,
- ch_grp_str, am.rpt_bit_flag ? "yes" : "no",
- am.metric_preference, am.route_metric, addr_str);
+ ch->interface->name, inet_ntoa(ifaddr), ch_src_str, ch_grp_str,
+ am.rpt_bit_flag ? "yes" : "no", am.metric_preference,
+ am.route_metric, addr_str);
}
static void pim_show_assert_metric(struct pim_instance *pim, struct vty *vty)
am = &ch->ifassert_winner_metric;
- pim_inet4_dump("<ch_src?>", ch->sg.src, ch_src_str,
- sizeof(ch_src_str));
- pim_inet4_dump("<ch_grp?>", ch->sg.grp, ch_grp_str,
- sizeof(ch_grp_str));
- pim_inet4_dump("<addr?>", am->ip_address, addr_str,
- sizeof(addr_str));
+ pim_inet4_dump("<ch_src?>", ch->sg.src, ch_src_str, sizeof(ch_src_str));
+ pim_inet4_dump("<ch_grp?>", ch->sg.grp, ch_grp_str, sizeof(ch_grp_str));
+ pim_inet4_dump("<addr?>", am->ip_address, addr_str, sizeof(addr_str));
if (am->metric_preference == PIM_ASSERT_METRIC_PREFERENCE_MAX)
snprintf(pref_str, sizeof(pref_str), "INFI");
if (am->route_metric == PIM_ASSERT_ROUTE_METRIC_MAX)
snprintf(metr_str, sizeof(metr_str), "INFI");
else
- snprintf(metr_str, sizeof(metr_str), "%6u",
- am->route_metric);
+ snprintf(metr_str, sizeof(metr_str), "%6u", am->route_metric);
vty_out(vty, "%-9s %-15s %-15s %-15s %-3s %-4s %-6s %-15s\n",
- ch->interface->name, inet_ntoa(ifaddr), ch_src_str,
- ch_grp_str, am->rpt_bit_flag ? "yes" : "no", pref_str,
- metr_str, addr_str);
+ ch->interface->name, inet_ntoa(ifaddr), ch_src_str, ch_grp_str,
+ am->rpt_bit_flag ? "yes" : "no", pref_str, metr_str, addr_str);
}
static void pim_show_assert_winner_metric(struct pim_instance *pim,
json_object *json_iface = NULL;
json_object *json_row = NULL;
- pim_inet4_dump("<ch_src?>", ch->sg.src, ch_src_str,
- sizeof(ch_src_str));
- pim_inet4_dump("<ch_grp?>", ch->sg.grp, ch_grp_str,
- sizeof(ch_grp_str));
+ pim_inet4_dump("<ch_src?>", ch->sg.src, ch_src_str, sizeof(ch_src_str));
+ pim_inet4_dump("<ch_grp?>", ch->sg.grp, ch_grp_str, sizeof(ch_grp_str));
- json_object_object_get_ex(json, ch->interface->name,
- &json_iface);
+ json_object_object_get_ex(json, ch->interface->name, &json_iface);
if (!json_iface) {
json_iface = json_object_new_object();
json_object_pim_ifp_add(json_iface, ch->interface);
- json_object_object_add(json, ch->interface->name,
- json_iface);
+ json_object_object_add(json, ch->interface->name, json_iface);
}
json_row = json_object_new_object();
json_object_string_add(json_row, "source", ch_src_str);
json_object_string_add(json_row, "group", ch_grp_str);
- json_object_string_add(
- json_row, "localMembership",
- ch->local_ifmembership == PIM_IFMEMBERSHIP_NOINFO
- ? "NOINFO"
- : "INCLUDE");
+ json_object_string_add(json_row, "localMembership",
+ ch->local_ifmembership == PIM_IFMEMBERSHIP_NOINFO
+ ? "NOINFO"
+ : "INCLUDE");
json_object_object_add(json_iface, ch_grp_str, json_row);
-
}
static void pim_show_membership(struct pim_instance *pim, struct vty *vty,
u_char uj)
json_fhr_sources =
json_object_new_object();
- pim_inet4_dump("<src?>", up->sg.src,
- src_str, sizeof(src_str));
- pim_inet4_dump("<grp?>", up->sg.grp,
- grp_str, sizeof(grp_str));
+ pim_inet4_dump("<src?>", up->sg.src, src_str,
+ sizeof(src_str));
+ pim_inet4_dump("<grp?>", up->sg.grp, grp_str,
+ sizeof(grp_str));
pim_time_uptime(uptime, sizeof(uptime),
now - up->state_transition);
* If not create it.
*/
json_object_object_get_ex(json_fhr_sources,
- grp_str,
- &json_group);
+ grp_str, &json_group);
if (!json_group) {
json_group = json_object_new_object();
- json_object_object_add(
- json_fhr_sources,
- grp_str,
- json_group);
+ json_object_object_add(json_fhr_sources,
+ grp_str,
+ json_group);
}
json_group_source = json_object_new_object();
up)) {
if (strcmp(ifp->name,
- up->rpf.source_nexthop.
- interface->name) != 0)
+ up->rpf.source_nexthop
+ .interface->name)
+ != 0)
continue;
if (!(up->flags & PIM_UPSTREAM_FLAG_MASK_FHR))
print_header = 0;
}
- pim_inet4_dump("<src?>", up->sg.src,
- src_str, sizeof(src_str));
- pim_inet4_dump("<grp?>", up->sg.grp,
- grp_str, sizeof(grp_str));
+ pim_inet4_dump("<src?>", up->sg.src, src_str,
+ sizeof(src_str));
+ pim_inet4_dump("<grp?>", up->sg.grp, grp_str,
+ sizeof(grp_str));
pim_time_uptime(uptime, sizeof(uptime),
now - up->state_transition);
vty_out(vty,
"%s : %s is a source, uptime is %s\n",
- grp_str, src_str,
- uptime);
+ grp_str, src_str, uptime);
}
if (!print_header) {
}
}
-static void pim_show_join_helper(struct vty *vty,
- struct pim_interface *pim_ifp,
- struct pim_ifchannel *ch,
- json_object *json,
- time_t now,
- u_char uj)
+static void pim_show_join_helper(struct vty *vty, struct pim_interface *pim_ifp,
+ struct pim_ifchannel *ch, json_object *json,
+ time_t now, u_char uj)
{
char ch_src_str[INET_ADDRSTRLEN];
char ch_grp_str[INET_ADDRSTRLEN];
ifaddr = pim_ifp->primary_address;
- pim_inet4_dump("<ch_src?>", ch->sg.src, ch_src_str,
- sizeof(ch_src_str));
- pim_inet4_dump("<ch_grp?>", ch->sg.grp, ch_grp_str,
- sizeof(ch_grp_str));
+ pim_inet4_dump("<ch_src?>", ch->sg.src, ch_src_str, sizeof(ch_src_str));
+ pim_inet4_dump("<ch_grp?>", ch->sg.grp, ch_grp_str, sizeof(ch_grp_str));
- pim_time_uptime_begin(uptime, sizeof(uptime), now,
- ch->ifjoin_creation);
+ pim_time_uptime_begin(uptime, sizeof(uptime), now, ch->ifjoin_creation);
pim_time_timer_to_mmss(expire, sizeof(expire),
ch->t_ifjoin_expiry_timer);
pim_time_timer_to_mmss(prune, sizeof(prune),
if (!json_iface) {
json_iface = json_object_new_object();
- json_object_pim_ifp_add(json_iface,
- ch->interface);
- json_object_object_add(
- json, ch->interface->name, json_iface);
+ json_object_pim_ifp_add(json_iface, ch->interface);
+ json_object_object_add(json, ch->interface->name,
+ json_iface);
}
json_row = json_object_new_object();
json_object_string_add(json_row, "prune", prune);
json_object_string_add(
json_row, "channelJoinName",
- pim_ifchannel_ifjoin_name(ch->ifjoin_state,
- ch->flags));
+ pim_ifchannel_ifjoin_name(ch->ifjoin_state, ch->flags));
if (PIM_IF_FLAG_TEST_S_G_RPT(ch->flags))
json_object_int_add(json_row, "SGRpt", 1);
- json_object_object_get_ex(json_iface, ch_grp_str,
- &json_grp);
+ json_object_object_get_ex(json_iface, ch_grp_str, &json_grp);
if (!json_grp) {
json_grp = json_object_new_object();
- json_object_object_add(json_grp, ch_src_str,
- json_row);
+ json_object_object_add(json_grp, ch_src_str, json_row);
json_object_object_add(json_iface, ch_grp_str,
json_grp);
} else
- json_object_object_add(json_grp, ch_src_str,
- json_row);
+ json_object_object_add(json_grp, ch_src_str, json_row);
} else {
- vty_out(vty,
- "%-9s %-15s %-15s %-15s %-10s %8s %-6s %5s\n",
- ch->interface->name, inet_ntoa(ifaddr),
- ch_src_str, ch_grp_str,
- pim_ifchannel_ifjoin_name(ch->ifjoin_state,
- ch->flags),
+ vty_out(vty, "%-9s %-15s %-15s %-15s %-10s %8s %-6s %5s\n",
+ ch->interface->name, inet_ntoa(ifaddr), ch_src_str,
+ ch_grp_str,
+ pim_ifchannel_ifjoin_name(ch->ifjoin_state, ch->flags),
uptime, expire, prune);
}
}
if (uj) {
vty_out(vty, "%s\n", json_object_to_json_string_ext(
- json, JSON_C_TO_STRING_PRETTY));
+ json, JSON_C_TO_STRING_PRETTY));
json_object_free(json);
}
}
* we are the FHR, else we just put
* the RP as the rpfAddress
*/
- if (up->flags & PIM_UPSTREAM_FLAG_MASK_FHR ||
- up->sg.src.s_addr == INADDR_ANY) {
+ if (up->flags & PIM_UPSTREAM_FLAG_MASK_FHR
+ || up->sg.src.s_addr == INADDR_ANY) {
char rpf[PREFIX_STRLEN];
struct pim_rpf *rpg;
rpg = RP(pim, up->sg.grp);
pim_inet4_dump("<rpf?>",
- rpg->rpf_addr.u.prefix4,
- rpf, sizeof(rpf));
- json_object_string_add(json_row,
- "rpfAddress", rpf);
+ rpg->rpf_addr.u.prefix4, rpf,
+ sizeof(rpf));
+ json_object_string_add(json_row, "rpfAddress",
+ rpf);
} else {
- json_object_string_add(json_row,
- "rpfAddress", src_str);
+ json_object_string_add(json_row, "rpfAddress",
+ src_str);
}
json_object_string_add(json_row, "source", src_str);
struct vty *vty,
struct pim_interface *pim_ifp,
struct pim_ifchannel *ch,
- json_object *json,
- u_char uj)
+ json_object *json, u_char uj)
{
struct pim_upstream *up = ch->upstream;
json_object *json_group = NULL;
if (!json_group) {
json_group = json_object_new_object();
- json_object_object_add(json, grp_str,
- json_group);
+ json_object_object_add(json, grp_str, json_group);
}
json_row = json_object_new_object();
json_object_string_add(json_row, "group", grp_str);
if (pim_macro_ch_lost_assert(ch))
- json_object_boolean_true_add(json_row,
- "lostAssert");
+ json_object_boolean_true_add(json_row, "lostAssert");
if (pim_macro_chisin_joins(ch))
json_object_boolean_true_add(json_row, "joins");
if (pim_macro_chisin_pim_include(ch))
- json_object_boolean_true_add(json_row,
- "pimInclude");
+ json_object_boolean_true_add(json_row, "pimInclude");
if (pim_upstream_evaluate_join_desired(pim, up))
- json_object_boolean_true_add(
- json_row, "evaluateJoinDesired");
+ json_object_boolean_true_add(json_row,
+ "evaluateJoinDesired");
json_object_object_add(json_group, src_str, json_row);
} else {
- vty_out(vty,
- "%-9s %-15s %-15s %-10s %-5s %-10s %-11s %-6s\n",
+ vty_out(vty, "%-9s %-15s %-15s %-10s %-5s %-10s %-11s %-6s\n",
ch->interface->name, src_str, grp_str,
pim_macro_ch_lost_assert(ch) ? "yes" : "no",
pim_macro_chisin_joins(ch) ? "yes" : "no",
pim_macro_chisin_pim_include(ch) ? "yes" : "no",
- PIM_UPSTREAM_FLAG_TEST_DR_JOIN_DESIRED(
- up->flags)
- ? "yes"
- : "no",
- pim_upstream_evaluate_join_desired(pim, up)
- ? "yes"
- : "no");
+ PIM_UPSTREAM_FLAG_TEST_DR_JOIN_DESIRED(up->flags)
+ ? "yes"
+ : "no",
+ pim_upstream_evaluate_join_desired(pim, up) ? "yes"
+ : "no");
}
}
RB_FOREACH (ch, pim_ifchannel_rb, &pim_ifp->ifchannel_rb) {
/* scan all interfaces */
- pim_show_join_desired_helper(pim, vty,
- pim_ifp, ch,
+ pim_show_join_desired_helper(pim, vty, pim_ifp, ch,
json, uj);
}
}
clear_pim_interfaces(pim);
}
-#define PIM_GET_PIM_INTERFACE(pim_ifp, ifp) \
- pim_ifp = ifp->info; \
- if (!pim_ifp) { \
- vty_out(vty, \
+#define PIM_GET_PIM_INTERFACE(pim_ifp, ifp) \
+ pim_ifp = ifp->info; \
+ if (!pim_ifp) { \
+ vty_out(vty, \
"%% Enable PIM and/or IGMP on this interface first\n"); \
- return CMD_WARNING_CONFIG_FAILED; \
+ return CMD_WARNING_CONFIG_FAILED; \
}
DEFUN (clear_ip_interfaces,
result = pim_ecmp_nexthop_search(vrf->info, &pnc, &nexthop,
&nht_p, &grp, 0);
else
- result = pim_ecmp_nexthop_lookup(vrf->info, &nexthop, vif_source,
- &nht_p, &grp, 0);
+ result = pim_ecmp_nexthop_lookup(vrf->info, &nexthop,
+ vif_source, &nht_p, &grp, 0);
if (!result) {
- vty_out(vty, "Nexthop Lookup failed, no usable routes returned.\n");
+ vty_out(vty,
+ "Nexthop Lookup failed, no usable routes returned.\n");
return CMD_SUCCESS;
}
return CMD_SUCCESS;
}
-static void show_mroute(struct pim_instance *pim, struct vty *vty,
- bool fill, u_char uj)
+static void show_mroute(struct pim_instance *pim, struct vty *vty, bool fill,
+ u_char uj)
{
struct listnode *node;
struct channel_oil *c_oil;
continue;
ifp_out = pim_if_find_by_vif_index(pim, oif_vif_index);
- pim_time_uptime(oif_uptime, sizeof(oif_uptime),
- now -
- s_route->c_oil.oif_creation[oif_vif_index]);
+ pim_time_uptime(
+ oif_uptime, sizeof(oif_uptime),
+ now
+ - s_route->c_oil
+ .oif_creation[oif_vif_index]);
found_oif = 1;
if (ifp_out)
}
if (result == PIM_GROUP_OVERLAP) {
- vty_out(vty, "%% Group range specified cannot exact match another\n");
+ vty_out(vty,
+ "%% Group range specified cannot exact match another\n");
return CMD_WARNING_CONFIG_FAILED;
}
int idx = 2;
char *src_ip = argv_find(argv, argc, "A.B.C.D", &idx) ? argv[idx++]->arg
- : NULL;
+ : NULL;
char *grp_ip = idx < argc && argv_find(argv, argc, "A.B.C.D", &idx)
- ? argv[idx]->arg
- : NULL;
+ ? argv[idx]->arg
+ : NULL;
if (uj)
vty_out(vty, "{ ");
}
}
-#define FREE_ADDR_LIST \
- if (hello_option_addr_list) { \
- list_delete_and_null(&hello_option_addr_list); \
+#define FREE_ADDR_LIST \
+ if (hello_option_addr_list) { \
+ list_delete_and_null(&hello_option_addr_list); \
}
#define FREE_ADDR_LIST_THEN_RETURN(code) \
struct pim_secondary_addr *sec_addr;
int changed = 0;
- for (ALL_LIST_ELEMENTS_RO(pim_ifp->sec_addr_list, node,
- sec_addr)) {
+ for (ALL_LIST_ELEMENTS_RO(pim_ifp->sec_addr_list, node, sec_addr)) {
sec_addr->flags |= PIM_SEC_ADDRF_STALE;
}
}
ferr_r pim_if_igmp_join_add(struct interface *ifp, struct in_addr group_addr,
- struct in_addr source_addr)
+ struct in_addr source_addr)
{
struct pim_interface *pim_ifp;
struct igmp_join *ij;
struct in_addr update_source; /* user can statically set the primary
* address of the interface */
- int igmp_version; /* IGMP version */
- int igmp_default_robustness_variable; /* IGMPv3 QRV */
- int
- igmp_default_query_interval; /* IGMPv3 secs between general
+ int igmp_version; /* IGMP version */
+ int igmp_default_robustness_variable; /* IGMPv3 QRV */
+ int igmp_default_query_interval; /* IGMPv3 secs between general
queries */
int igmp_query_max_response_time_dsec; /* IGMPv3 Max Response Time in
dsecs for general queries */
#include "pim_ssm.h"
#include "pim_rp.h"
-RB_GENERATE(pim_ifchannel_rb, pim_ifchannel,
- pim_ifp_rb, pim_ifchannel_compare);
+RB_GENERATE(pim_ifchannel_rb, pim_ifchannel, pim_ifp_rb, pim_ifchannel_compare);
int pim_ifchannel_compare(const struct pim_ifchannel *ch1,
const struct pim_ifchannel *ch2)
ch = THREAD_ARG(t);
if (PIM_DEBUG_TRACE)
- zlog_debug("%s: IFCHANNEL%s %s Prune Pending Timer Popped",
- __PRETTY_FUNCTION__,
- pim_str_sg_dump(&ch->sg),
- pim_ifchannel_ifjoin_name(ch->ifjoin_state,
- ch->flags));
+ zlog_debug(
+ "%s: IFCHANNEL%s %s Prune Pending Timer Popped",
+ __PRETTY_FUNCTION__, pim_str_sg_dump(&ch->sg),
+ pim_ifchannel_ifjoin_name(ch->ifjoin_state, ch->flags));
if (ch->ifjoin_state == PIM_IFJOIN_PRUNE_PENDING) {
ifp = ch->interface;
rpf.source_nexthop.interface = ifp;
rpf.rpf_addr.u.prefix4 =
pim_ifp->primary_address;
- pim_jp_agg_single_upstream_send(&rpf,
- ch->upstream,
- 0);
+ pim_jp_agg_single_upstream_send(
+ &rpf, ch->upstream, 0);
}
ifjoin_to_noinfo(ch, true);
ch->upstream);
pim_jp_agg_single_upstream_send(&parent->rpf,
- parent,
- true);
+ parent, true);
}
}
/* from here ch may have been deleted */
if (child->ifjoin_state == PIM_IFJOIN_PRUNE_PENDING_TMP)
THREAD_OFF(child->t_ifjoin_prune_pending_timer);
THREAD_OFF(child->t_ifjoin_expiry_timer);
- struct pim_upstream *parent =
- child->upstream->parent;
+ struct pim_upstream *parent = child->upstream->parent;
PIM_IF_FLAG_UNSET_S_G_RPT(child->flags);
child->ifjoin_state = PIM_IFJOIN_NOINFO;
if (I_am_RP(pim, child->sg.grp)) {
pim_channel_add_oif(
child->upstream->channel_oil,
- ch->interface,
- PIM_OIF_FLAG_PROTO_STAR);
- pim_upstream_switch(
- pim, child->upstream,
- PIM_UPSTREAM_JOINED);
+ ch->interface, PIM_OIF_FLAG_PROTO_STAR);
+ pim_upstream_switch(pim, child->upstream,
+ PIM_UPSTREAM_JOINED);
pim_jp_agg_single_upstream_send(
- &child->upstream->rpf,
- child->upstream, true);
+ &child->upstream->rpf, child->upstream,
+ true);
}
if (parent)
- pim_jp_agg_single_upstream_send(
- &parent->rpf,
- parent, true);
+ pim_jp_agg_single_upstream_send(&parent->rpf,
+ parent, true);
delete_on_noinfo(child);
break;
};
RB_HEAD(pim_ifchannel_rb, pim_ifchannel);
-RB_PROTOTYPE(pim_ifchannel_rb, pim_ifchannel,
- pim_ifp_rb, pim_ifchannel_compare);
+RB_PROTOTYPE(pim_ifchannel_rb, pim_ifchannel, pim_ifp_rb,
+ pim_ifchannel_compare);
void pim_ifchannel_free(struct pim_ifchannel *ch);
void pim_ifchannel_delete(struct pim_ifchannel *ch);
snprintf(hash_name, 64, "IGMP %s hash", ifp->name);
igmp->igmp_group_hash = hash_create(igmp_group_hash_key,
- igmp_group_hash_equal,
- hash_name);
+ igmp_group_hash_equal, hash_name);
igmp->fd = fd;
igmp->interface = ifp;
if (PIM_DEBUG_MTRACE)
zlog_debug(
"Mtrace response block of wrong"
- " length");
+ " length");
responses = responses / sizeof(struct igmp_mtrace_rsp);
#define MTRACE_UNKNOWN_COUNT (0xffffffff)
enum mtrace_fwd_code {
- MTRACE_FWD_CODE_NO_ERROR = 0x00,
- MTRACE_FWD_CODE_WRONG_IF = 0x01,
- MTRACE_FWD_CODE_PRUNE_SENT = 0x02,
- MTRACE_FWD_CODE_PRUNE_RCVD = 0x03,
- MTRACE_FWD_CODE_SCOPED = 0x04,
- MTRACE_FWD_CODE_NO_ROUTE = 0x05,
- MTRACE_FWD_CODE_WRONG_LAST_HOP = 0x06,
- MTRACE_FWD_CODE_NOT_FORWARDING = 0x07,
- MTRACE_FWD_CODE_REACHED_RP = 0x08,
- MTRACE_FWD_CODE_RPF_IF = 0x09,
- MTRACE_FWD_CODE_NO_MULTICAST = 0x0A,
- MTRACE_FWD_CODE_INFO_HIDDEN = 0x0B,
- MTRACE_FWD_CODE_NO_SPACE = 0x81,
- MTRACE_FWD_CODE_OLD_ROUTER = 0x82,
- MTRACE_FWD_CODE_ADMIN_PROHIB = 0x83
+ MTRACE_FWD_CODE_NO_ERROR = 0x00,
+ MTRACE_FWD_CODE_WRONG_IF = 0x01,
+ MTRACE_FWD_CODE_PRUNE_SENT = 0x02,
+ MTRACE_FWD_CODE_PRUNE_RCVD = 0x03,
+ MTRACE_FWD_CODE_SCOPED = 0x04,
+ MTRACE_FWD_CODE_NO_ROUTE = 0x05,
+ MTRACE_FWD_CODE_WRONG_LAST_HOP = 0x06,
+ MTRACE_FWD_CODE_NOT_FORWARDING = 0x07,
+ MTRACE_FWD_CODE_REACHED_RP = 0x08,
+ MTRACE_FWD_CODE_RPF_IF = 0x09,
+ MTRACE_FWD_CODE_NO_MULTICAST = 0x0A,
+ MTRACE_FWD_CODE_INFO_HIDDEN = 0x0B,
+ MTRACE_FWD_CODE_NO_SPACE = 0x81,
+ MTRACE_FWD_CODE_OLD_ROUTER = 0x82,
+ MTRACE_FWD_CODE_ADMIN_PROHIB = 0x83
};
enum mtrace_rtg_proto {
- MTRACE_RTG_PROTO_DVMRP = 1,
- MTRACE_RTG_PROTO_MOSPF = 2,
- MTRACE_RTG_PROTO_PIM = 3,
- MTRACE_RTG_PROTO_CBT = 4,
- MTRACE_RTG_PROTO_PIM_SPECIAL = 5,
- MTRACE_RTG_PROTO_PIM_STATIC = 6,
- MTRACE_RTG_PROTO_DVMRP_STATIC = 7,
- MTRACE_RTG_PROTO_PIM_MBGP = 8,
- MTRACE_RTG_PROTO_CBT_SPECIAL = 9,
- MTRACE_RTG_PROTO_CBT_STATIC = 10,
- MTRACE_RTG_PROTO_PIM_ASSERT = 11,
+ MTRACE_RTG_PROTO_DVMRP = 1,
+ MTRACE_RTG_PROTO_MOSPF = 2,
+ MTRACE_RTG_PROTO_PIM = 3,
+ MTRACE_RTG_PROTO_CBT = 4,
+ MTRACE_RTG_PROTO_PIM_SPECIAL = 5,
+ MTRACE_RTG_PROTO_PIM_STATIC = 6,
+ MTRACE_RTG_PROTO_DVMRP_STATIC = 7,
+ MTRACE_RTG_PROTO_PIM_MBGP = 8,
+ MTRACE_RTG_PROTO_CBT_SPECIAL = 9,
+ MTRACE_RTG_PROTO_CBT_STATIC = 10,
+ MTRACE_RTG_PROTO_PIM_ASSERT = 11,
};
struct igmp_mtrace_rsp {
pim_msdp_init(pim, master);
snprintf(hash_name, 64, "PIM %s RPF Hash", vrf->name);
- pim->rpf_hash = hash_create_size(256, pim_rpf_hash_key,
- pim_rpf_equal, hash_name);
+ pim->rpf_hash = hash_create_size(256, pim_rpf_hash_key, pim_rpf_equal,
+ hash_name);
if (PIM_DEBUG_ZEBRA)
zlog_debug("%s: NHT rpf hash init ", __PRETTY_FUNCTION__);
return -2;
}
PIM_UPSTREAM_FLAG_SET_SRC_STREAM(up->flags);
- pim_upstream_keep_alive_timer_start(up, pim_ifp->pim->keep_alive_time);
+ pim_upstream_keep_alive_timer_start(
+ up, pim_ifp->pim->keep_alive_time);
up->channel_oil = oil;
up->channel_oil->cc.pktcnt++;
pim_register_join(up);
}
#ifdef SO_BINDTODEVICE
- if (pim->vrf->vrf_id != VRF_DEFAULT &&
- setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, pim->vrf->name,
- strlen(pim->vrf->name))) {
+ if (pim->vrf->vrf_id != VRF_DEFAULT
+ && setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE, pim->vrf->name,
+ strlen(pim->vrf->name))) {
zlog_warn("Could not setsockopt SO_BINDTODEVICE: %s",
safe_strerror(errno));
close(fd);
if (PIM_DEBUG_MROUTE)
zlog_debug("%s: Add Vif %d (%s[%s])", __PRETTY_FUNCTION__,
- pim_ifp->mroute_vif_index,
- ifp->name, pim_ifp->pim->vrf->name);
+ pim_ifp->mroute_vif_index, ifp->name,
+ pim_ifp->pim->vrf->name);
memset(&vc, 0, sizeof(vc));
vc.vifc_vifi = pim_ifp->mroute_vif_index;
zlog_warn(
"%s: failure: setsockopt(fd=%d,IPPROTO_IP,MRT_ADD_VIF,vif_index=%d,ifaddr=%s,flag=%d): errno=%d: %s",
- __PRETTY_FUNCTION__,
- pim_ifp->pim->mroute_socket, ifp->ifindex, ifaddr_str,
- flags, errno, safe_strerror(errno));
+ __PRETTY_FUNCTION__, pim_ifp->pim->mroute_socket,
+ ifp->ifindex, ifaddr_str, flags, errno,
+ safe_strerror(errno));
return -2;
}
int err;
if (PIM_DEBUG_MROUTE)
- zlog_debug("%s: Del Vif %d (%s[%s])", __PRETTY_FUNCTION__,
- pim_ifp->mroute_vif_index,
- ifp->name, pim_ifp->pim->vrf->name);
+ zlog_debug("%s: Del Vif %d (%s[%s])", __PRETTY_FUNCTION__,
+ pim_ifp->mroute_vif_index, ifp->name,
+ pim_ifp->pim->vrf->name);
memset(&vc, 0, sizeof(vc));
vc.vifc_vifi = pim_ifp->mroute_vif_index;
if (PIM_DEBUG_MROUTE) {
char buf[1000];
- zlog_debug("%s(%s), vrf %s Added Route: %s", __PRETTY_FUNCTION__, name,
- pim->vrf->name,
+ zlog_debug("%s(%s), vrf %s Added Route: %s",
+ __PRETTY_FUNCTION__, name, pim->vrf->name,
pim_channel_oil_dump(c_oil, buf, sizeof(buf)));
}
if (PIM_DEBUG_MROUTE) {
char buf[1000];
- zlog_debug("%s(%s), vrf %s Deleted Route: %s", __PRETTY_FUNCTION__,
- name, pim->vrf->name,
+ zlog_debug("%s(%s), vrf %s Deleted Route: %s",
+ __PRETTY_FUNCTION__, name, pim->vrf->name,
pim_channel_oil_dump(c_oil, buf, sizeof(buf)));
}
/* protocol timers */
#define PIM_MSDP_PEER_HOLD_TIME 75
struct thread *hold_timer; // 5.4
- /* $FRR indent$ */
-/* clang-format off */
#define PIM_MSDP_PEER_KA_TIME 60
struct thread *ka_timer; // 5.5
- /* $FRR indent$ */
- /* clang-format off */
#define PIM_MSDP_PEER_CONNECT_RETRY_TIME 30
struct thread *cr_timer; // 5.6
uint32_t conn_attempts;
uint32_t est_flaps;
uint32_t sa_cnt; /* number of SAs attributed to this peer */
- /* $FRR indent$ */
- /* clang-format off */
#define PIM_MSDP_PEER_LAST_RESET_STR 20
char last_reset[PIM_MSDP_PEER_LAST_RESET_STR];
pnc->rp_list->cmp = pim_rp_list_cmp;
snprintf(hash_name, 64, "PNC %s(%s) Upstream Hash",
- prefix2str(&pnc->rpf.rpf_addr, buf1, 64),
- pim->vrf->name);
+ prefix2str(&pnc->rpf.rpf_addr, buf1, 64), pim->vrf->name);
pnc->upstream_hash = hash_create_size(8192, pim_upstream_hash_key,
- pim_upstream_equal,
- hash_name);
+ pim_upstream_equal, hash_name);
return pnc;
}
continue;
// Compute PIM RPF using cached nexthop
- pim_ecmp_nexthop_search(pim, pnc,
- &rp_info->rp.source_nexthop,
- &rp_info->rp.rpf_addr,
- &rp_info->group, 1);
+ pim_ecmp_nexthop_search(pim, pnc, &rp_info->rp.source_nexthop,
+ &rp_info->rp.rpf_addr, &rp_info->group,
+ 1);
}
}
* We have detected a case where we might need to rescan
* the inherited o_list so do it.
*/
- if (up->channel_oil
- && up->channel_oil->oil_inherited_rescan) {
+ if (up->channel_oil && up->channel_oil->oil_inherited_rescan) {
pim_upstream_inherited_olist_decide(pim, up);
up->channel_oil->oil_inherited_rescan = 0;
}
* where the mroute has not been installed
* so install it.
*/
- if (up->channel_oil
- && !up->channel_oil->installed)
+ if (up->channel_oil && !up->channel_oil->installed)
pim_mroute_add(up->channel_oil,
__PRETTY_FUNCTION__);
if (!zapi_nexthop_update_decode(zclient->ibuf, &nhr)) {
if (PIM_DEBUG_PIM_NHT)
- zlog_debug("%s: Decode of nexthop update from zebra failed",
- __PRETTY_FUNCTION__);
+ zlog_debug(
+ "%s: Decode of nexthop update from zebra failed",
+ __PRETTY_FUNCTION__);
return 0;
}
"%s: NHT Update for %s(%s) num_nh %d num_pim_nh %d vrf:%u up %ld rp %d",
__PRETTY_FUNCTION__, buf, pim->vrf->name,
nhr.nexthop_num, pnc->nexthop_num, vrf_id,
- pnc->upstream_hash->count,
- listcount(pnc->rp_list));
+ pnc->upstream_hash->count, listcount(pnc->rp_list));
}
pim_rpf_set_refresh_time();
if (num_ifindex < 1) {
if (PIM_DEBUG_PIM_NHT) {
char addr_str[INET_ADDRSTRLEN];
- pim_inet4_dump("<addr?>", addr, addr_str, sizeof(addr_str));
+ pim_inet4_dump("<addr?>", addr, addr_str,
+ sizeof(addr_str));
zlog_warn(
"%s: could not find nexthop ifindex for address %s(%s)",
- __PRETTY_FUNCTION__, addr_str,
- pim->vrf->name);
+ __PRETTY_FUNCTION__, addr_str, pim->vrf->name);
}
return 0;
}
char hash_name[64];
snprintf(hash_name, 64, "PIM %s Oil Hash", pim->vrf->name);
- pim->channel_oil_hash = hash_create_size(8192,
- pim_oil_hash_key,
- pim_oil_equal,
- hash_name);
+ pim->channel_oil_hash = hash_create_size(8192, pim_oil_hash_key,
+ pim_oil_equal, hash_name);
pim->channel_oil_list = list_new();
if (!pim->channel_oil_list) {
|| (SwitchToSptDesired(pim_ifp->pim, &sg))) {
if (sentRegisterStop) {
pim_upstream_keep_alive_timer_start(
- upstream, pim_ifp->pim->rp_keep_alive_time);
+ upstream,
+ pim_ifp->pim->rp_keep_alive_time);
} else {
pim_upstream_keep_alive_timer_start(
- upstream, pim_ifp->pim->keep_alive_time);
+ upstream,
+ pim_ifp->pim->keep_alive_time);
}
}
rn->info = rp_info;
if (PIM_DEBUG_TRACE)
- zlog_debug("Allocated: %p for rp_info: %p(224.0.0.0/4) Lock: %d",
- rn, rp_info, rn->lock);
+ zlog_debug(
+ "Allocated: %p for rp_info: %p(224.0.0.0/4) Lock: %d",
+ rn, rp_info, rn->lock);
}
void pim_rp_free(struct pim_instance *pim)
if (rp_info->plist) {
plist = prefix_list_lookup(AFI_IP, rp_info->plist);
- if (prefix_list_apply_which_prefix(plist, &p, group) == PREFIX_DENY)
+ if (prefix_list_apply_which_prefix(plist, &p, group)
+ == PREFIX_DENY)
continue;
if (!best) {
rn = route_node_match(pim->rp_table, group);
if (!rn) {
- zlog_err("%s: BUG We should have found default group information\n",
- __PRETTY_FUNCTION__);
+ zlog_err(
+ "%s: BUG We should have found default group information\n",
+ __PRETTY_FUNCTION__);
return best;
}
char buf[PREFIX_STRLEN];
route_unlock_node(rn);
- zlog_debug("Lookedup: %p for rp_info: %p(%s) Lock: %d",
- rn, rp_info,
+ zlog_debug("Lookedup: %p for rp_info: %p(%s) Lock: %d", rn,
+ rp_info,
prefix2str(&rp_info->group, buf, sizeof(buf)),
rn->lock);
}
if (PIM_DEBUG_TRACE) {
char buf[PREFIX_STRLEN];
- zlog_debug("Allocated: %p for rp_info: %p(%s) Lock: %d",
- rn, rp_info,
+ zlog_debug("Allocated: %p for rp_info: %p(%s) Lock: %d", rn,
+ rp_info,
prefix2str(&rp_info->group, buf, sizeof(buf)),
rn->lock);
}
if (PIM_DEBUG_TRACE) {
char buf[PREFIX_STRLEN];
- zlog_debug("%s:Found for Freeing: %p for rp_info: %p(%s) Lock: %d",
- __PRETTY_FUNCTION__,
- rn, rp_info,
- prefix2str(&rp_info->group, buf, sizeof(buf)),
- rn->lock);
+ zlog_debug(
+ "%s:Found for Freeing: %p for rp_info: %p(%s) Lock: %d",
+ __PRETTY_FUNCTION__, rn, rp_info,
+ prefix2str(&rp_info->group, buf,
+ sizeof(buf)),
+ rn->lock);
}
rn->info = NULL;
route_unlock_node(rn);
} else {
if (!pim_ecmp_nexthop_lookup(
pim, &rpf->source_nexthop, up->upstream_addr, &src,
- &grp, !PIM_UPSTREAM_FLAG_TEST_FHR(up->flags)
- && !PIM_UPSTREAM_FLAG_TEST_SRC_IGMP(
- up->flags)))
+ &grp,
+ !PIM_UPSTREAM_FLAG_TEST_FHR(up->flags)
+ && !PIM_UPSTREAM_FLAG_TEST_SRC_IGMP(
+ up->flags)))
return PIM_RPF_FAILURE;
}
return addr - buf;
}
-#define FREE_ADDR_LIST(hello_option_addr_list) \
- { \
- if (hello_option_addr_list) { \
- list_delete_and_null(&hello_option_addr_list); \
- hello_option_addr_list = 0; \
- } \
+#define FREE_ADDR_LIST(hello_option_addr_list) \
+ { \
+ if (hello_option_addr_list) { \
+ list_delete_and_null(&hello_option_addr_list); \
+ hello_option_addr_list = 0; \
+ } \
}
int pim_tlv_parse_addr_list(const char *ifname, struct in_addr src_addr,
if (PIM_DEBUG_TRACE)
zlog_debug(
"%s(%s): Delete %s[%s] ref count: %d , flags: %d c_oil ref count %d (Pre decrement)",
- __PRETTY_FUNCTION__, name, up->sg_str,
- pim->vrf->name, up->ref_count,
- up->flags, up->channel_oil->oil_ref_count);
+ __PRETTY_FUNCTION__, name, up->sg_str, pim->vrf->name,
+ up->ref_count, up->flags,
+ up->channel_oil->oil_ref_count);
--up->ref_count;
sizeof(rpf_addr_str));
zlog_debug(
"%s: matching neigh=%s against upstream (S,G)=%s[%s] joined=%d rpf_addr=%s",
- __PRETTY_FUNCTION__, neigh_str, up->sg_str, pim->vrf->name,
+ __PRETTY_FUNCTION__, neigh_str, up->sg_str,
+ pim->vrf->name,
up->join_state == PIM_UPSTREAM_JOINED,
rpf_addr_str);
}
if (PIM_UPSTREAM_FLAG_TEST_SRC_STREAM(up->flags)) {
pim_upstream_fhr_kat_expiry(pim, up);
if (PIM_DEBUG_TRACE)
- zlog_debug("kat expired on %s[%s]; remove stream reference",
- up->sg_str, pim->vrf->name);
+ zlog_debug(
+ "kat expired on %s[%s]; remove stream reference",
+ up->sg_str, pim->vrf->name);
PIM_UPSTREAM_FLAG_UNSET_SRC_STREAM(up->flags);
pim_upstream_del(pim, up, __PRETTY_FUNCTION__);
} else if (PIM_UPSTREAM_FLAG_TEST_SRC_LHR(up->flags)) {
pim_upstream_del(pim, up, __PRETTY_FUNCTION__);
if (parent) {
- pim_jp_agg_single_upstream_send(&parent->rpf,
- parent, true);
+ pim_jp_agg_single_upstream_send(&parent->rpf, parent,
+ true);
}
}
if (!up->channel_oil->installed) {
if (PIM_DEBUG_TRACE)
zlog_debug("%s: %s[%s] is not installed in mroute",
- __PRETTY_FUNCTION__,
- up->sg_str, pim->vrf->name);
+ __PRETTY_FUNCTION__, up->sg_str,
+ pim->vrf->name);
return;
}
if (PIM_DEBUG_TRACE)
zlog_debug(
"%s: Handling unscanned inherited_olist for %s[%s]",
- __PRETTY_FUNCTION__, up->sg_str, pim->vrf->name);
+ __PRETTY_FUNCTION__, up->sg_str,
+ pim->vrf->name);
pim_upstream_inherited_olist_decide(pim, up);
up->channel_oil->oil_inherited_rescan = 0;
}
wheel_init(master, 31000, 100, pim_upstream_hash_key,
pim_upstream_sg_running);
- snprintf(hash_name, 64, "PIM %s Upstream Hash",
- pim->vrf->name);
+ snprintf(hash_name, 64, "PIM %s Upstream Hash", pim->vrf->name);
pim->upstream_hash = hash_create_size(8192, pim_upstream_hash_key,
pim_upstream_equal, hash_name);
vrf->name, vrf->vrf_id);
if (!master) {
- zlog_debug("%s: Unable to find Master interface for %s",
- __PRETTY_FUNCTION__,
- vrf->name);
+ zlog_debug(
+ "%s: Unable to find Master interface for %s",
+ __PRETTY_FUNCTION__, vrf->name);
return 0;
}
zclient_interface_set_master(zclient, master,
prefix2str(p, buf, BUFSIZ);
zlog_debug("%s: %s(%u) connected IP address %s flags %u %s",
__PRETTY_FUNCTION__, c->ifp->name, vrf_id, buf,
- c->flags, CHECK_FLAG(c->flags, ZEBRA_IFA_SECONDARY)
- ? "secondary"
- : "primary");
+ c->flags,
+ CHECK_FLAG(c->flags, ZEBRA_IFA_SECONDARY)
+ ? "secondary"
+ : "primary");
#ifdef PIM_DEBUG_IFADDR_DUMP
dump_if_address(c->ifp);
nexthop_tab[0].route_metric);
}
- addr =
- nexthop_addr.u.prefix4; /* use nexthop addr for
- recursive lookup */
+ addr = nexthop_addr.u.prefix4; /* use nexthop addr for
+ recursive lookup */
} /* for (max_lookup) */
*/
#define QPB_ALLOC(allocator, type) (type *)qpb_alloc(allocator, sizeof(type))
-
/*
* Externs.
*/
* "network IF_OR_PREF" one */
if ((rip_enable_if_lookup(connected->ifp->name) >= 0)
|| (rip_enable_network_lookup2(connected) >= 0))
- rip_redistribute_add(
- ZEBRA_ROUTE_CONNECT,
- RIP_ROUTE_INTERFACE, &address,
- &nh, 0, 0, 0);
+ rip_redistribute_add(ZEBRA_ROUTE_CONNECT,
+ RIP_ROUTE_INTERFACE,
+ &address, &nh, 0, 0, 0);
} else {
rip_redistribute_delete(ZEBRA_ROUTE_CONNECT,
RIP_ROUTE_INTERFACE, &address,
connected->ifp->ifindex);
if (rip_redistribute_check(ZEBRA_ROUTE_CONNECT))
- rip_redistribute_add(
- ZEBRA_ROUTE_CONNECT,
- RIP_ROUTE_REDISTRIBUTE, &address,
- &nh, 0, 0, 0);
+ rip_redistribute_add(ZEBRA_ROUTE_CONNECT,
+ RIP_ROUTE_REDISTRIBUTE,
+ &address, &nh, 0, 0, 0);
}
}
}
if (type == RMAP_RIP) {
rinfo = object;
p.family = AF_INET;
- p.prefix =
- (rinfo->nh.gate.ipv4.s_addr) ?
- rinfo->nh.gate.ipv4 : rinfo->from;
+ p.prefix = (rinfo->nh.gate.ipv4.s_addr) ? rinfo->nh.gate.ipv4
+ : rinfo->from;
p.prefixlen = IPV4_MAX_BITLEN;
alist = access_list_lookup(AFI_IP, (char *)rule);
if (type == RMAP_RIP) {
rinfo = object;
p.family = AF_INET;
- p.prefix =
- (rinfo->nh.gate.ipv4.s_addr) ?
- rinfo->nh.gate.ipv4 : rinfo->from;
+ p.prefix = (rinfo->nh.gate.ipv4.s_addr) ? rinfo->nh.gate.ipv4
+ : rinfo->from;
p.prefixlen = IPV4_MAX_BITLEN;
plist = prefix_list_lookup(AFI_IP, (char *)rule);
return mod;
}
if (metric > RIP_METRIC_INFINITY) {
- zlog_info("%s: Metric specified: %ld is greater than RIP_METRIC_INFINITY, using INFINITY instead",
- __PRETTY_FUNCTION__, metric);
+ zlog_info(
+ "%s: Metric specified: %ld is greater than RIP_METRIC_INFINITY, using INFINITY instead",
+ __PRETTY_FUNCTION__, metric);
mod->metric = RIP_METRIC_INFINITY;
} else
mod->metric = metric;
if (command == ZEBRA_REDISTRIBUTE_ROUTE_ADD)
rip_redistribute_add(api.type, RIP_ROUTE_REDISTRIBUTE,
(struct prefix_ipv4 *)&api.prefix, &nh,
- api.metric, api.distance,
- api.tag);
+ api.metric, api.distance, api.tag);
else if (command == ZEBRA_REDISTRIBUTE_ROUTE_DEL)
rip_redistribute_delete(api.type, RIP_ROUTE_REDISTRIBUTE,
(struct prefix_ipv4 *)&api.prefix,
/* Get back the object */
rte->nexthop = newinfo.nexthop_out;
rte->tag = htons(newinfo.tag_out); /* XXX */
- rte->metric =
- newinfo.metric_out; /* XXX: the routemap uses the
- metric_out field */
+ rte->metric = newinfo.metric_out; /* XXX: the routemap uses the
+ metric_out field */
}
/* Once the entry has been validated, update the metric by
/* Add redistributed route to RIP table. */
void rip_redistribute_add(int type, int sub_type, struct prefix_ipv4 *p,
- struct nexthop *nh,
- unsigned int metric, unsigned char distance,
- route_tag_t tag)
+ struct nexthop *nh, unsigned int metric,
+ unsigned char distance, route_tag_t tag)
{
int ret;
struct route_node *rp = NULL;
(void)rip_ecmp_add(&newinfo);
if (IS_RIP_DEBUG_EVENT) {
- zlog_debug(
- "Redistribute new prefix %s/%d",
- inet_ntoa(p->prefix), p->prefixlen);
+ zlog_debug("Redistribute new prefix %s/%d",
+ inet_ntoa(p->prefix), p->prefixlen);
}
rip_event(RIP_TRIGGERED_UPDATE, 0);
tmp_rinfo))
if (tmp_rinfo->type == ZEBRA_ROUTE_RIP
&& tmp_rinfo->nh.ifindex
- == ifc->ifp->ifindex)
+ == ifc->ifp->ifindex)
tmp_rinfo->metric_out =
RIP_METRIC_INFINITY;
if (rinfo->type == ZEBRA_ROUTE_CONNECT
&& prefix_match((struct prefix *)p,
ifc->address))
- rinfo->metric_out =
- RIP_METRIC_INFINITY;
+ rinfo->metric_out = RIP_METRIC_INFINITY;
}
/* Prepare preamble, auth headers, if needs be */
node->info = (void *)1;
- rip_redistribute_add(ZEBRA_ROUTE_RIP, RIP_ROUTE_STATIC, &p, &nh, 0,
- 0, 0);
+ rip_redistribute_add(ZEBRA_ROUTE_RIP, RIP_ROUTE_STATIC, &p, &nh, 0, 0,
+ 0);
return CMD_SUCCESS;
}
if (len > 0)
vty_out(vty, "%*s", len, " ");
- switch(rinfo->nh.type) {
+ switch (rinfo->nh.type) {
case NEXTHOP_TYPE_IPV4:
case NEXTHOP_TYPE_IPV4_IFINDEX:
vty_out(vty, "%-20s %2d ",
extern int rip_neighbor_lookup(struct sockaddr_in *);
extern int rip_redistribute_check(int);
-extern void rip_redistribute_add(int type, int sub_type,
- struct prefix_ipv4 *p,
- struct nexthop *nh,
- unsigned int metric, unsigned char distance,
- route_tag_t tag);
+extern void rip_redistribute_add(int type, int sub_type, struct prefix_ipv4 *p,
+ struct nexthop *nh, unsigned int metric,
+ unsigned char distance, route_tag_t tag);
extern void rip_redistribute_delete(int, int, struct prefix_ipv4 *, ifindex_t);
extern void rip_redistribute_withdraw(int);
extern void rip_zebra_ipv4_add(struct route_node *);
zlog_debug("Inserting %ld routes", routes);
temp = ntohl(p.u.prefix4.s_addr);
- for (i = 0 ; i < routes ; i++) {
+ for (i = 0; i < routes; i++) {
route_add(&p, &nhop);
p.u.prefix4.s_addr = htonl(++temp);
}
zlog_debug("Removing %ld routes", routes);
temp = ntohl(p.u.prefix4.s_addr);
- for (i = 0; i < routes ; i++) {
+ for (i = 0; i < routes; i++) {
route_delete(&p);
p.u.prefix4.s_addr = htonl(++temp);
}
/* Inteface addition message from zebra. */
static int interface_add(int command, struct zclient *zclient,
- zebra_size_t length, vrf_id_t vrf_id)
+ zebra_size_t length, vrf_id_t vrf_id)
{
struct interface *ifp;
void sharp_zebra_init(void)
{
- struct zclient_options opt = { .receive_notify = true };
+ struct zclient_options opt = {.receive_notify = true};
zclient = zclient_new_notify(master, &opt);
{.fd = -1, .name = "nhrpd", .flag = VTYSH_NHRPD, .next = NULL},
{.fd = -1, .name = "eigrpd", .flag = VTYSH_EIGRPD, .next = NULL},
{.fd = -1, .name = "babeld", .flag = VTYSH_BABELD, .next = NULL},
- {.fd = -1, .name = "sharpd", .flag = VTYSH_SHARPD, .next = NULL},
+ {.fd = -1, .name = "sharpd", .flag = VTYSH_SHARPD, .next = NULL},
{.fd = -1, .name = "watchfrr", .flag = VTYSH_WATCHFRR, .next = NULL},
};
case CMD_ERR_NO_MATCH:
fprintf(stderr, "line %d: %% Unknown command[%d]: %s",
lineno, vty->node, vty->buf);
- retcode =
- CMD_ERR_NO_MATCH; /* once we have an error, we
- remember & return that */
+ retcode = CMD_ERR_NO_MATCH; /* once we have an error, we
+ remember & return that */
break;
case CMD_ERR_INCOMPLETE:
fprintf(stderr,
}
#if defined(HAVE_RPKI)
-DEFUNSH(VTYSH_BGPD,
- rpki,
- rpki_cmd,
- "rpki",
+DEFUNSH(VTYSH_BGPD, rpki, rpki_cmd, "rpki",
"Enable rpki and enter rpki configuration mode\n")
{
vty->node = RPKI_NODE;
return CMD_SUCCESS;
}
-DEFUNSH(VTYSH_BGPD,
- rpki_exit,
- rpki_exit_cmd,
- "exit",
+DEFUNSH(VTYSH_BGPD, rpki_exit, rpki_exit_cmd, "exit",
"Exit current mode and down to previous mode\n")
{
vty->node = CONFIG_NODE;
return CMD_SUCCESS;
}
-DEFUNSH(VTYSH_BGPD,
- rpki_quit,
- rpki_quit_cmd,
- "quit",
+DEFUNSH(VTYSH_BGPD, rpki_quit, rpki_quit_cmd, "quit",
"Exit current mode and down to previous mode\n")
{
return rpki_exit(self, vty, argc, argv);
"router ospf [(1-65535)] [vrf NAME]",
"Enable a routing process\n"
"Start OSPF configuration\n"
- "Instance ID\n"
- VRF_CMD_HELP_STR)
+ "Instance ID\n" VRF_CMD_HELP_STR)
{
vty->node = OSPF_NODE;
return CMD_SUCCESS;
}
DEFSH(VTYSH_ZEBRA, vtysh_no_logicalrouter_cmd,
- "no logical-router (1-65535) ns NAME",
- NO_STR
- "Enable a Logical-Router\n"
- "Specify the Logical-Router identifier\n"
- "The Name Space\n"
- "The file name in " NS_RUN_DIR ", or a full pathname\n")
+ "no logical-router (1-65535) ns NAME", NO_STR
+ "Enable a Logical-Router\n"
+ "Specify the Logical-Router identifier\n"
+ "The Name Space\n"
+ "The file name in " NS_RUN_DIR ", or a full pathname\n")
DEFUNSH(VTYSH_VRF, vtysh_vrf, vtysh_vrf_cmd, "vrf NAME",
"Select a VRF to configure\n"
"Delete a pseudo vrf's configuration\n"
"VRF's name\n")
-DEFUNSH(VTYSH_NS, vtysh_exit_logicalrouter,
- vtysh_exit_logicalrouter_cmd, "exit",
- "Exit current mode and down to previous mode\n")
+DEFUNSH(VTYSH_NS, vtysh_exit_logicalrouter, vtysh_exit_logicalrouter_cmd,
+ "exit", "Exit current mode and down to previous mode\n")
{
return vtysh_exit(vty);
}
-DEFUNSH(VTYSH_NS, vtysh_quit_logicalrouter,
- vtysh_quit_logicalrouter_cmd, "quit",
- "Exit current mode and down to previous mode\n")
+DEFUNSH(VTYSH_NS, vtysh_quit_logicalrouter, vtysh_quit_logicalrouter_cmd,
+ "quit", "Exit current mode and down to previous mode\n")
{
return vtysh_exit_logicalrouter(self, vty, argc, argv);
}
SHOW_STR
DEBUG_STR)
{
- return show_per_daemon("do show debugging\n",
- "");
+ return show_per_daemon("do show debugging\n", "");
}
DEFUN (vtysh_show_debugging_hashtable,
SHOW_STR
"Memory statistics\n")
{
- return show_per_daemon("show memory\n",
- "Memory statistics for %s:\n");
+ return show_per_daemon("show memory\n", "Memory statistics for %s:\n");
}
DEFUN (vtysh_show_modules,
}
/* Execute command in child process. */
-static void execute_command(const char *command, int argc,
- const char *arg1, const char *arg2)
+static void execute_command(const char *command, int argc, const char *arg1,
+ const char *arg2)
{
pid_t pid;
int status;
install_element(CONFIG_NODE, &vtysh_logicalrouter_cmd);
install_element(CONFIG_NODE, &vtysh_no_logicalrouter_cmd);
- install_element(LOGICALROUTER_NODE,
- &vtysh_exit_logicalrouter_cmd);
- install_element(LOGICALROUTER_NODE,
- &vtysh_quit_logicalrouter_cmd);
+ install_element(LOGICALROUTER_NODE, &vtysh_exit_logicalrouter_cmd);
+ install_element(LOGICALROUTER_NODE, &vtysh_quit_logicalrouter_cmd);
install_element(VRF_NODE, &vtysh_end_all_cmd);
install_element(VRF_NODE, &vtysh_exit_vrf_cmd);
#define VTYSH_BABELD 0x2000
#define VTYSH_SHARPD 0x4000
-
/* commands in REALLYALL are crucial to correct vtysh operation */
#define VTYSH_REALLYALL ~0U
/* watchfrr is not in ALL since library CLI functions should not be
== 0) {
config_add_line(config->line, line);
config->index = LINK_PARAMS_NODE;
- } else if (strncmp(line,
- " ip multicast boundary",
- strlen(" ip multicast boundary")) == 0) {
+ } else if (strncmp(line, " ip multicast boundary",
+ strlen(" ip multicast boundary"))
+ == 0) {
config_add_line_end(config->line, line);
} else if (config->index == LINK_PARAMS_NODE
&& strncmp(line, " exit-link-params",
== 0
|| strncmp(line, "ip extcommunity-list",
strlen("ip extcommunity-list"))
- == 0
+ == 0
|| strncmp(line, "ip large-community-list",
strlen("ip large-community-list"))
- == 0)
+ == 0)
config = config_get(COMMUNITY_LIST_NODE, line);
else if (strncmp(line, "ip route", strlen("ip route")) == 0)
config = config_get(IP_NODE, line);
*/
homedir = vtysh_get_home();
if (homedir) {
- snprintf(history_file, sizeof(history_file),
- "%s/.history_frr", homedir);
+ snprintf(history_file, sizeof(history_file), "%s/.history_frr",
+ homedir);
if (read_history(history_file) != 0) {
int fp;
if (IS_ZEBRA_DEBUG_RIB_DETAILED) {
char buf[PREFIX_STRLEN];
- zlog_debug("%u: IF %s address %s add/up, scheduling RIB processing",
- ifp->vrf_id, ifp->name,
- prefix2str(&p, buf, sizeof(buf)));
+ zlog_debug(
+ "%u: IF %s address %s add/up, scheduling RIB processing",
+ ifp->vrf_id, ifp->name,
+ prefix2str(&p, buf, sizeof(buf)));
}
rib_update(ifp->vrf_id, RIB_UPDATE_IF_CHANGE);
if (IS_ZEBRA_DEBUG_MPLS) {
char buf[PREFIX_STRLEN];
- zlog_debug("%u: IF %s IP %s address add/up, scheduling MPLS processing",
- ifp->vrf_id, ifp->name,
- prefix2str(&p, buf, sizeof(buf)));
+ zlog_debug(
+ "%u: IF %s IP %s address add/up, scheduling MPLS processing",
+ ifp->vrf_id, ifp->name,
+ prefix2str(&p, buf, sizeof(buf)));
}
mpls_mark_lsps_for_processing(vrf_info_lookup(ifp->vrf_id));
}
rib_delete(afi, SAFI_UNICAST, ifp->vrf_id, ZEBRA_ROUTE_CONNECT, 0, 0,
&p, NULL, &nh, 0, 0, false, NULL);
- rib_delete(afi, SAFI_MULTICAST, ifp->vrf_id, ZEBRA_ROUTE_CONNECT, 0,
- 0, &p, NULL, &nh, 0, 0, false, NULL);
+ rib_delete(afi, SAFI_MULTICAST, ifp->vrf_id, ZEBRA_ROUTE_CONNECT, 0, 0,
+ &p, NULL, &nh, 0, 0, false, NULL);
if (IS_ZEBRA_DEBUG_RIB_DETAILED) {
char buf[PREFIX_STRLEN];
- zlog_debug("%u: IF %s IP %s address down, scheduling RIB processing",
- ifp->vrf_id, ifp->name,
- prefix2str(&p, buf, sizeof(buf)));
+ zlog_debug(
+ "%u: IF %s IP %s address down, scheduling RIB processing",
+ ifp->vrf_id, ifp->name,
+ prefix2str(&p, buf, sizeof(buf)));
}
rib_update(ifp->vrf_id, RIB_UPDATE_IF_CHANGE);
if (IS_ZEBRA_DEBUG_MPLS) {
char buf[PREFIX_STRLEN];
- zlog_debug("%u: IF %s IP %s address down, scheduling MPLS processing",
- ifp->vrf_id, ifp->name,
- prefix2str(&p, buf, sizeof(buf)));
+ zlog_debug(
+ "%u: IF %s IP %s address down, scheduling MPLS processing",
+ ifp->vrf_id, ifp->name,
+ prefix2str(&p, buf, sizeof(buf)));
}
mpls_mark_lsps_for_processing(vrf_info_lookup(ifp->vrf_id));
}
if (IS_ZEBRA_DEBUG_RIB_DETAILED) {
char buf[PREFIX_STRLEN];
- zlog_debug("%u: IF %s IP %s address del, scheduling RIB processing",
- ifp->vrf_id, ifp->name,
- prefix2str(p, buf, sizeof(buf)));
+ zlog_debug(
+ "%u: IF %s IP %s address del, scheduling RIB processing",
+ ifp->vrf_id, ifp->name,
+ prefix2str(p, buf, sizeof(buf)));
}
rib_update(ifp->vrf_id, RIB_UPDATE_IF_CHANGE);
if (IS_ZEBRA_DEBUG_MPLS) {
char buf[PREFIX_STRLEN];
- zlog_debug("%u: IF %s IP %s address delete, scheduling MPLS processing",
- ifp->vrf_id, ifp->name,
- prefix2str(p, buf, sizeof(buf)));
+ zlog_debug(
+ "%u: IF %s IP %s address delete, scheduling MPLS processing",
+ ifp->vrf_id, ifp->name,
+ prefix2str(p, buf, sizeof(buf)));
}
mpls_mark_lsps_for_processing(vrf_info_lookup(ifp->vrf_id));
}
SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);
if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND)
- UNSET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);
+ UNSET_FLAG(zebra_debug_kernel,
+ ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);
} else if (argv_find(argv, argc, "send", &idx)) {
SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND);
if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV)
- UNSET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);
+ UNSET_FLAG(zebra_debug_kernel,
+ ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);
} else {
SET_FLAG(zebra_debug_kernel, ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV);
}
if (IS_ZEBRA_DEBUG_KERNEL) {
- if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND && IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV) {
+ if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_SEND
+ && IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV) {
vty_out(vty, "debug zebra kernel msgdump\n");
write++;
} else if (IS_ZEBRA_DEBUG_KERNEL_MSGDUMP_RECV) {
/* use ioctl to get IP address of an interface */
if (zserv_privs.change(ZPRIVS_RAISE))
zlog_err("Can't raise privileges");
- sd = vrf_socket(PF_INET, SOCK_DGRAM, IPPROTO_IP,
- interface->vrf_id, NULL);
+ sd = vrf_socket(PF_INET, SOCK_DGRAM, IPPROTO_IP, interface->vrf_id,
+ NULL);
if (sd < 0) {
if (IS_ZEBRA_DEBUG_KERNEL)
zlog_debug("Failure to read interface %s speed: %d %s",
return netlink_address(RTM_DELADDR, AF_INET, ifp, ifc);
}
-int kernel_address_add_ipv6 (struct interface *ifp, struct connected *ifc)
+int kernel_address_add_ipv6(struct interface *ifp, struct connected *ifc)
{
- return netlink_address (RTM_NEWADDR, AF_INET6, ifp, ifc);
+ return netlink_address(RTM_NEWADDR, AF_INET6, ifp, ifc);
}
-int kernel_address_delete_ipv6 (struct interface *ifp, struct connected *ifc)
+int kernel_address_delete_ipv6(struct interface *ifp, struct connected *ifc)
{
- return netlink_address (RTM_DELADDR, AF_INET6, ifp, ifc);
+ return netlink_address(RTM_DELADDR, AF_INET6, ifp, ifc);
}
int netlink_interface_addr(struct sockaddr_nl *snl, struct nlmsghdr *h,
#define ZEBRA_PTM_SUPPORT
-DEFINE_HOOK(zebra_if_extra_info, (struct vty *vty, struct interface *ifp),
- (vty, ifp))
-DEFINE_HOOK(zebra_if_config_wr, (struct vty *vty, struct interface *ifp),
- (vty, ifp))
+DEFINE_HOOK(zebra_if_extra_info, (struct vty * vty, struct interface *ifp),
+ (vty, ifp))
+DEFINE_HOOK(zebra_if_config_wr, (struct vty * vty, struct interface *ifp),
+ (vty, ifp))
static void if_down_del_nbr_connected(struct interface *ifp);
new_speed = kernel_get_speed(ifp);
if (new_speed != ifp->speed) {
zlog_info("%s: %s old speed: %u new speed: %u",
- __PRETTY_FUNCTION__, ifp->name,
- ifp->speed, new_speed);
+ __PRETTY_FUNCTION__, ifp->name, ifp->speed,
+ new_speed);
ifp->speed = new_speed;
if_add_update(ifp);
}
* of seconds and ask again. Hopefully it's all settled
* down upon startup.
*/
- thread_add_timer(zebrad.master, if_zebra_speed_update,
- ifp, 15, &zebra_if->speed_update);
+ thread_add_timer(zebrad.master, if_zebra_speed_update, ifp, 15,
+ &zebra_if->speed_update);
return 0;
}
if (!ifp->connected)
return;
- while ((node = (last ? last->next
- : listhead(ifp->connected)))) {
+ while ((node = (last ? last->next : listhead(ifp->connected)))) {
ifc = listgetdata(node);
cp = *CONNECTED_PREFIX(ifc);
apply_mask(&cp);
if (cp.family == AF_INET
- && (rn = route_node_lookup(zebra_if->ipv4_subnets,
- &cp))) {
+ && (rn = route_node_lookup(zebra_if->ipv4_subnets, &cp))) {
struct listnode *anode;
struct listnode *next;
struct listnode *first;
struct vrf *vrf;
RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name)
- if (!RB_EMPTY (if_name_head, &vrf->ifaces_by_name)) {
+ if (!RB_EMPTY(if_name_head, &vrf->ifaces_by_name)) {
vty_out(vty, "\n\tVRF %u\n\n", vrf->vrf_id);
if_show_description(vty, vrf->vrf_id);
}
Default: 0.33 * MaxRtrAdvInterval */
int MinRtrAdvInterval; /* This field is currently unused. */
- /* $FRR indent$ */
- /* clang-format off */
#define RTADV_MIN_RTR_ADV_INTERVAL (0.33 * RTADV_MAX_RTR_ADV_INTERVAL)
/* Unsolicited Router Advertisements' interval timer. */
#define BGP_RA_CONFIGURED (1<<0) /* BGP configured RA? */
#define VTY_RA_CONFIGURED (1<<1) /* Operator configured RA? */
#define VTY_RA_INTERVAL_CONFIGURED (1<<2) /* Operator configured RA interval */
- int
- NumFastReXmitsRemain; /* Loaded first with number of fast
- rexmits to do */
+ int NumFastReXmitsRemain; /* Loaded first with number of fast
+ rexmits to do */
#define RTADV_FAST_REXMIT_PERIOD 1 /* 1 sec */
#define RTADV_NUM_FAST_REXMITS 4 /* Fast Rexmit RA 4 times on certain events */
struct thread *speed_update;
};
-DECLARE_HOOK(zebra_if_extra_info, (struct vty *vty, struct interface *ifp),
- (vty, ifp))
-DECLARE_HOOK(zebra_if_config_wr, (struct vty *vty, struct interface *ifp),
- (vty, ifp))
+DECLARE_HOOK(zebra_if_extra_info, (struct vty * vty, struct interface *ifp),
+ (vty, ifp))
+DECLARE_HOOK(zebra_if_config_wr, (struct vty * vty, struct interface *ifp),
+ (vty, ifp))
static inline void zebra_if_set_ziftype(struct interface *ifp,
zebra_iftype_t zif_type,
int if_prefix_add_ipv6(struct interface *ifp, struct connected *ifc)
{
#ifdef HAVE_NETLINK
- return kernel_address_add_ipv6 (ifp, ifc);
+ return kernel_address_add_ipv6(ifp, ifc);
#endif /* HAVE_NETLINK */
}
int if_prefix_delete_ipv6(struct interface *ifp, struct connected *ifc)
{
#ifdef HAVE_NETLINK
- return kernel_address_delete_ipv6 (ifp, ifc);
+ return kernel_address_delete_ipv6(ifp, ifc);
#endif /* HAVE_NETLINK */
}
#else /* LINUX_IPV6 */
DEFINE_MTYPE_STATIC(ZEBRA, IRDP_IF, "IRDP interface data")
-#define IRDP_CONFIGED \
- do { \
- if (!irdp) { \
- vty_out(vty, "Please Configure IRDP before using this command\n"); \
- return CMD_WARNING_CONFIG_FAILED; \
- } \
- } \
- while (0)
+#define IRDP_CONFIGED \
+ do { \
+ if (!irdp) { \
+ vty_out(vty, \
+ "Please Configure IRDP before using this command\n"); \
+ return CMD_WARNING_CONFIG_FAILED; \
+ } \
+ } while (0)
static struct irdp_interface *irdp_if_get(struct interface *ifp)
{
return 0;
}
-FRR_MODULE_SETUP(
- .name = "zebra_irdp",
- .version = FRR_VERSION,
- .description = "zebra IRDP module",
- .init = irdp_module_init,
-)
+FRR_MODULE_SETUP(.name = "zebra_irdp", .version = FRR_VERSION,
+ .description = "zebra IRDP module", .init = irdp_module_init, )
if (zserv_privs.change(ZPRIVS_RAISE))
zlog_err("routing_socket: Can't raise privileges");
- routing_sock = ns_socket(AF_ROUTE, SOCK_RAW,
- 0, (ns_id_t)zns->ns->ns_id);
+ routing_sock =
+ ns_socket(AF_ROUTE, SOCK_RAW, 0, (ns_id_t)zns->ns->ns_id);
if (routing_sock < 0) {
if (zserv_privs.change(ZPRIVS_LOWER))
#endif
vrf_configure_backend(VRF_BACKEND_VRF_LITE);
- logicalrouter_configure_backend(
- LOGICALROUTER_BACKEND_NETNS);
+ logicalrouter_configure_backend(LOGICALROUTER_BACKEND_NETNS);
frr_preinit(&zebra_di, argc, argv);
case 'n':
vrf_configure_backend(VRF_BACKEND_NETNS);
logicalrouter_configure_backend(
- LOGICALROUTER_BACKEND_OFF);
+ LOGICALROUTER_BACKEND_OFF);
break;
#endif /* HAVE_NETLINK */
#if defined(HANDLE_ZAPI_FUZZING)
zebra_mpls_vty_init();
zebra_pw_vty_init();
- /* For debug purpose. */
- /* SET_FLAG (zebra_debug_event, ZEBRA_DEBUG_EVENT); */
+/* For debug purpose. */
+/* SET_FLAG (zebra_debug_event, ZEBRA_DEBUG_EVENT); */
#if defined(HANDLE_ZAPI_FUZZING)
if (fuzzing) {
afi = family2afi(rn->p.family);
if (rmap_name)
ret = zebra_import_table_route_map_check(
- afi, re->type, &rn->p, re->nexthop, re->vrf_id,
- re->tag, rmap_name);
+ afi, re->type, &rn->p, re->nexthop, re->vrf_id, re->tag,
+ rmap_name);
if (ret != RMAP_MATCH) {
zebra_del_import_table_entry(rn, re);
if (CHECK_FLAG(same->status, ROUTE_ENTRY_REMOVED))
continue;
- if (same->type == re->type
- && same->instance == re->instance
+ if (same->type == re->type && same->instance == re->instance
&& same->table == re->table
&& same->type != ZEBRA_ROUTE_CONNECT)
break;
if (same)
zebra_del_import_table_entry(rn, same);
- newre = XCALLOC(MTYPE_RE,sizeof(struct route_entry));
+ newre = XCALLOC(MTYPE_RE, sizeof(struct route_entry));
newre->type = ZEBRA_ROUTE_TABLE;
newre->distance = zebra_import_table_distance[afi][re->table];
newre->flags = re->flags;
afi = family2afi(rn->p.family);
prefix_copy(&p, &rn->p);
- rib_delete(afi, SAFI_UNICAST, re->vrf_id, ZEBRA_ROUTE_TABLE,
- re->table, re->flags, &p, NULL, re->nexthop,
- zebrad.rtm_table_default, re->metric, false, NULL);
+ rib_delete(afi, SAFI_UNICAST, re->vrf_id, ZEBRA_ROUTE_TABLE, re->table,
+ re->flags, &p, NULL, re->nexthop, zebrad.rtm_table_default,
+ re->metric, false, NULL);
return 0;
}
if (zebra_import_table_distance[afi][i]
!= ZEBRA_TABLE_DISTANCE_DEFAULT) {
- vty_out(vty,
- "%s import-table %d distance %d",
+ vty_out(vty, "%s import-table %d distance %d",
afi_str[afi], i,
zebra_import_table_distance[afi][i]);
} else {
- vty_out(vty, "%s import-table %d",
- afi_str[afi], i);
+ vty_out(vty, "%s import-table %d", afi_str[afi],
+ i);
}
rmap_name = zebra_get_import_table_route_map(afi, i);
if (rmap_name)
- vty_out(vty, " route-map %s",
- rmap_name);
+ vty_out(vty, " route-map %s", rmap_name);
vty_out(vty, "\n");
write = 1;
if (!rmap_name)
return;
- table = zebra_vrf_other_route_table(afi,
- i,
+ table = zebra_vrf_other_route_table(afi, i,
VRF_DEFAULT);
- for (rn = route_top(table); rn;
- rn = route_next(rn)) {
+ for (rn = route_top(table); rn; rn = route_next(rn)) {
/* For each entry in the non-default
* routing table,
* add the entry in the main table
&& (rn->p.family == AF_INET))
|| ((afi == AFI_IP6)
&& (rn->p.family == AF_INET6)))
- zebra_add_import_table_entry(
- rn, re, rmap_name);
+ zebra_add_import_table_entry(rn, re,
+ rmap_name);
}
}
}
(re) && ((next) = (re)->next, 1); (re) = (next))
#define RNODE_FOREACH_RE(rn, re) \
- RE_DEST_FOREACH_ROUTE(rib_dest_from_rnode(rn), re)
+ RE_DEST_FOREACH_ROUTE (rib_dest_from_rnode(rn), re)
#define RNODE_FOREACH_RE_SAFE(rn, re, next) \
- RE_DEST_FOREACH_ROUTE_SAFE(rib_dest_from_rnode(rn), re, next)
+ RE_DEST_FOREACH_ROUTE_SAFE (rib_dest_from_rnode(rn), re, next)
#if defined(HAVE_RTADV)
/* Structure which hold status of router advertisement. */
extern void zebra_vty_init(void);
-extern int static_config(struct vty *vty, struct zebra_vrf *zvrf,
- afi_t afi, safi_t safi, const char *cmd);
+extern int static_config(struct vty *vty, struct zebra_vrf *zvrf, afi_t afi,
+ safi_t safi, const char *cmd);
extern pid_t pid;
#endif /*_ZEBRA_RIB_H */
* so let's separate it out and allow the result to
* be passed back up.
*/
-extern void kernel_route_rib_pass_fail(struct route_node *rn,
- struct prefix *p,
+extern void kernel_route_rib_pass_fail(struct route_node *rn, struct prefix *p,
struct route_entry *re,
enum southbound_results res);
extern int kernel_address_add_ipv4(struct interface *, struct connected *);
extern int kernel_address_delete_ipv4(struct interface *, struct connected *);
-extern int kernel_address_add_ipv6 (struct interface *, struct connected *);
-extern int kernel_address_delete_ipv6 (struct interface *, struct connected *);
-extern int kernel_neigh_update(int cmd, int ifindex, uint32_t addr,
- char *lla, int llalen, ns_id_t ns_id);
+extern int kernel_address_add_ipv6(struct interface *, struct connected *);
+extern int kernel_address_delete_ipv6(struct interface *, struct connected *);
+extern int kernel_neigh_update(int cmd, int ifindex, uint32_t addr, char *lla,
+ int llalen, ns_id_t ns_id);
extern int kernel_interface_set_master(struct interface *master,
struct interface *slave);
* the install/failure to set/unset flags and to notify
* as needed.
*/
-extern void kernel_lsp_pass_fail(zebra_lsp_t *lsp,
- enum southbound_results res);
+extern void kernel_lsp_pass_fail(zebra_lsp_t *lsp, enum southbound_results res);
extern int mpls_kernel_init(void);
proto = ZEBRA_ROUTE_BGP;
break;
case RTPROT_OSPF:
- proto = (family == AFI_IP) ?
- ZEBRA_ROUTE_OSPF : ZEBRA_ROUTE_OSPF6;
+ proto = (family == AFI_IP) ? ZEBRA_ROUTE_OSPF
+ : ZEBRA_ROUTE_OSPF6;
break;
case RTPROT_ISIS:
proto = ZEBRA_ROUTE_ISIS;
struct rtattr *mxrta[RTAX_MAX + 1];
memset(mxrta, 0, sizeof mxrta);
- netlink_parse_rtattr(mxrta, RTAX_MAX,
- RTA_DATA(tb[RTA_METRICS]),
+ netlink_parse_rtattr(mxrta, RTAX_MAX, RTA_DATA(tb[RTA_METRICS]),
RTA_PAYLOAD(tb[RTA_METRICS]));
if (mxrta[RTAX_MTU])
*/
if (proto == ZEBRA_ROUTE_KERNEL) {
distance = (metric >> 24) & 0xFF;
- metric = (metric & 0x00FFFFFF);
+ metric = (metric & 0x00FFFFFF);
}
if (IS_ZEBRA_DEBUG_KERNEL) {
char buf[PREFIX_STRLEN];
char buf2[PREFIX_STRLEN];
- zlog_debug(
- "%s %s%s%s vrf %u metric: %d Admin Distance: %d", nl_msg_type_to_str(h->nlmsg_type),
- prefix2str(&p, buf, sizeof(buf)),
- src_p.prefixlen ? " from " : "",
- src_p.prefixlen ? prefix2str(&src_p, buf2, sizeof(buf2))
- : "",
- vrf_id, metric, distance);
+ zlog_debug("%s %s%s%s vrf %u metric: %d Admin Distance: %d",
+ nl_msg_type_to_str(h->nlmsg_type),
+ prefix2str(&p, buf, sizeof(buf)),
+ src_p.prefixlen ? " from " : "",
+ src_p.prefixlen
+ ? prefix2str(&src_p, buf2, sizeof(buf2))
+ : "",
+ vrf_id, metric, distance);
}
afi_t afi = AFI_IP;
if (index && !gate)
nh.type = NEXTHOP_TYPE_IFINDEX;
else if (index && gate)
- nh.type = (afi == AFI_IP)
- ? NEXTHOP_TYPE_IPV4_IFINDEX
- : NEXTHOP_TYPE_IPV6_IFINDEX;
+ nh.type =
+ (afi == AFI_IP)
+ ? NEXTHOP_TYPE_IPV4_IFINDEX
+ : NEXTHOP_TYPE_IPV6_IFINDEX;
else if (!index && gate)
nh.type = (afi == AFI_IP)
? NEXTHOP_TYPE_IPV4
memcpy(&nh.gate, gate, sz);
if (index) {
- ifp = if_lookup_by_index(index,
- VRF_UNKNOWN);
+ ifp = if_lookup_by_index(index, VRF_UNKNOWN);
if (ifp)
nh_vrf_id = ifp->vrf_id;
}
if (re->nexthop_num == 0)
XFREE(MTYPE_RE, re);
else
- rib_add_multipath(afi, SAFI_UNICAST, &p,
- NULL, re);
+ rib_add_multipath(afi, SAFI_UNICAST, &p, NULL,
+ re);
}
} else {
if (!tb[RTA_MULTIPATH]) {
nh.ifindex = index;
if (gate)
memcpy(&nh.gate, gate, sz);
- rib_delete(afi, SAFI_UNICAST, vrf_id,
- proto, 0, flags, &p, NULL, &nh,
- table, metric, true, NULL);
+ rib_delete(afi, SAFI_UNICAST, vrf_id, proto, 0, flags,
+ &p, NULL, &nh, table, metric, true, NULL);
} else {
/* XXX: need to compare the entire list of nexthops
* here for NLM_F_APPEND stupidity */
- rib_delete(afi, SAFI_UNICAST, vrf_id,
- proto, 0, flags, &p, NULL, NULL,
- table, metric, true, NULL);
+ rib_delete(afi, SAFI_UNICAST, vrf_id, proto, 0, flags,
+ &p, NULL, NULL, table, metric, true, NULL);
}
}
for (ALL_NEXTHOPS(re->nexthop, nexthop)) {
if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_RECURSIVE))
continue;
- if (cmd == RTM_NEWROUTE
- && !NEXTHOP_IS_ACTIVE(nexthop->flags))
+ if (cmd == RTM_NEWROUTE && !NEXTHOP_IS_ACTIVE(nexthop->flags))
continue;
if (cmd == RTM_DELROUTE
&& !CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB))
* screwed.
*/
if (old)
- netlink_route_multipath(RTM_DELROUTE, p,
- src_p, old, 0);
- ret = netlink_route_multipath(RTM_NEWROUTE, p,
- src_p, new, 0);
+ netlink_route_multipath(RTM_DELROUTE, p, src_p,
+ old, 0);
+ ret = netlink_route_multipath(RTM_NEWROUTE, p, src_p,
+ new, 0);
}
kernel_route_rib_pass_fail(rn, p, new,
- (!ret) ?
- SOUTHBOUND_INSTALL_SUCCESS :
- SOUTHBOUND_INSTALL_FAILURE);
+ (!ret) ? SOUTHBOUND_INSTALL_SUCCESS
+ : SOUTHBOUND_INSTALL_FAILURE);
return;
}
ret = netlink_route_multipath(RTM_DELROUTE, p, src_p, old, 0);
kernel_route_rib_pass_fail(rn, p, old,
- (!ret) ?
- SOUTHBOUND_DELETE_SUCCESS :
- SOUTHBOUND_DELETE_FAILURE);
+ (!ret) ? SOUTHBOUND_DELETE_SUCCESS
+ : SOUTHBOUND_DELETE_FAILURE);
}
}
nl_msg_type_to_str(h->nlmsg_type),
nl_family_to_str(ndm->ndm_family),
ifp->name, ndm->ndm_ifindex,
- (unsigned long)RTA_PAYLOAD(tb[NDA_LLADDR]));
+ (unsigned long)RTA_PAYLOAD(
+ tb[NDA_LLADDR]));
return 0;
}
* but this if statement seems overly cautious - what about
* other than ADD and DELETE?
*/
- if ((cmd == RTM_ADD
- && NEXTHOP_IS_ACTIVE(nexthop->flags))
+ if ((cmd == RTM_ADD && NEXTHOP_IS_ACTIVE(nexthop->flags))
|| (cmd == RTM_DELETE
&& CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB))) {
if (nexthop->type == NEXTHOP_TYPE_IPV4
gate = 0;
- if ((cmd == RTM_ADD
- && NEXTHOP_IS_ACTIVE(nexthop->flags))
+ if ((cmd == RTM_ADD && NEXTHOP_IS_ACTIVE(nexthop->flags))
|| (cmd == RTM_DELETE)) {
if (nexthop->type == NEXTHOP_TYPE_IPV6
|| nexthop->type == NEXTHOP_TYPE_IPV6_IFINDEX) {
zlog_err("Can't lower privileges");
if (new) {
- kernel_route_rib_pass_fail(rn, p, new,
- (!route) ?
- SOUTHBOUND_INSTALL_SUCCESS :
- SOUTHBOUND_INSTALL_FAILURE);
+ kernel_route_rib_pass_fail(
+ rn, p, new,
+ (!route) ? SOUTHBOUND_INSTALL_SUCCESS
+ : SOUTHBOUND_INSTALL_FAILURE);
} else {
kernel_route_rib_pass_fail(rn, p, old,
- (!route) ?
- SOUTHBOUND_DELETE_SUCCESS :
- SOUTHBOUND_DELETE_FAILURE);
+ (!route)
+ ? SOUTHBOUND_DELETE_SUCCESS
+ : SOUTHBOUND_DELETE_FAILURE);
}
}
SET_FLAG(zif->rtadv.ra_configured, BGP_RA_CONFIGURED);
ipv6_nd_suppress_ra_set(ifp, RA_ENABLE);
if (ra_interval
- && (ra_interval * 1000) < zif->rtadv.MaxRtrAdvInterval
- && !CHECK_FLAG(zif->rtadv.ra_configured,
- VTY_RA_INTERVAL_CONFIGURED))
+ && (ra_interval * 1000) < zif->rtadv.MaxRtrAdvInterval
+ && !CHECK_FLAG(zif->rtadv.ra_configured,
+ VTY_RA_INTERVAL_CONFIGURED))
zif->rtadv.MaxRtrAdvInterval = ra_interval * 1000;
} else {
UNSET_FLAG(zif->rtadv.ra_configured, BGP_RA_CONFIGURED);
extern void rtadv_init(struct zebra_ns *);
extern void rtadv_terminate(struct zebra_ns *);
extern void rtadv_cmd_init(void);
-extern void zebra_interface_radv_set(struct zserv *client,
- u_short length, struct zebra_vrf *zvrf,
- int enable);
+extern void zebra_interface_radv_set(struct zserv *client, u_short length,
+ struct zebra_vrf *zvrf, int enable);
#endif /* _ZEBRA_RTADV_H */
sprintf(buffer, "closed socket in read(%d): %s",
errno, safe_strerror(errno));
zfpm_connection_down(buffer);
- }
- else
+ } else
zfpm_connection_down("closed socket in read");
return 0;
}
sprintf(buffer, "failed to read message(%d) %s",
errno, safe_strerror(errno));
zfpm_connection_down(buffer);
- }
- else
+ } else
zfpm_connection_down("failed to read message");
return 0;
}
in.s_addr = zfpm_g->fpm_server;
if ((zfpm_g->fpm_server != FPM_DEFAULT_IP
- && zfpm_g->fpm_server != INADDR_ANY)
- || (zfpm_g->fpm_port != FPM_DEFAULT_PORT
- && zfpm_g->fpm_port != 0))
+ && zfpm_g->fpm_server != INADDR_ANY)
+ || (zfpm_g->fpm_port != FPM_DEFAULT_PORT && zfpm_g->fpm_port != 0))
vty_out(vty, "fpm connection ip %s port %d\n", inet_ntoa(in),
zfpm_g->fpm_port);
#define IS_ZEBRA_IF_BRIDGE_VLAN_AWARE(zif) ((zif)->l2info.br.vlan_aware == 1)
-
extern void zebra_l2_map_slave_to_bridge(struct zebra_l2info_brslave *br_slave);
extern void
zebra_l2_unmap_slave_from_bridge(struct zebra_l2info_brslave *br_slave);
afi_t afi;
/* Uninstall label forwarding entry, if previously installed. */
- if (old_label != MPLS_INVALID_LABEL &&
- old_label != MPLS_LABEL_IMPLICIT_NULL)
+ if (old_label != MPLS_INVALID_LABEL
+ && old_label != MPLS_LABEL_IMPLICIT_NULL)
lsp_uninstall(zvrf, old_label);
/* Install label forwarding entry corr. to new label, if needed. */
* Any NHLFE that was installed but is not
* selected now needs to have its flags updated.
*/
- for (nhlfe = lsp->nhlfe_list;
- nhlfe; nhlfe = nhlfe->next) {
+ for (nhlfe = lsp->nhlfe_list; nhlfe;
+ nhlfe = nhlfe->next) {
nexthop = nhlfe->nexthop;
if (!nexthop)
continue;
if (CHECK_FLAG(nhlfe->flags,
- NHLFE_FLAG_INSTALLED) &&
- !CHECK_FLAG(nhlfe->flags,
- NHLFE_FLAG_SELECTED)) {
+ NHLFE_FLAG_INSTALLED)
+ && !CHECK_FLAG(nhlfe->flags,
+ NHLFE_FLAG_SELECTED)) {
UNSET_FLAG(nhlfe->flags,
NHLFE_FLAG_INSTALLED);
UNSET_FLAG(nexthop->flags,
default:
break;
}
- vty_out(vty, "%s", CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED)
- ? " (installed)"
- : "");
+ vty_out(vty, "%s",
+ CHECK_FLAG(nhlfe->flags, NHLFE_FLAG_INSTALLED) ? " (installed)"
+ : "");
vty_out(vty, "\n");
}
/* Public functions */
-void kernel_lsp_pass_fail(zebra_lsp_t *lsp,
- enum southbound_results res)
+void kernel_lsp_pass_fail(zebra_lsp_t *lsp, enum southbound_results res)
{
struct nexthop *nexthop;
zebra_nhlfe_t *nhlfe;
nexthop = nhlfe->nexthop;
switch (nexthop->type) {
- case NEXTHOP_TYPE_IFINDEX:
- {
+ case NEXTHOP_TYPE_IFINDEX: {
struct interface *ifp;
ifp = if_lookup_by_index(
{
if (!zvrf)
return;
- zvrf->slsp_table = hash_create(label_hash,
- label_cmp,
- "ZEBRA SLSP table");
- zvrf->lsp_table = hash_create(label_hash,
- label_cmp,
- "ZEBRA LSP table");
+ zvrf->slsp_table =
+ hash_create(label_hash, label_cmp, "ZEBRA SLSP table");
+ zvrf->lsp_table = hash_create(label_hash, label_cmp, "ZEBRA LSP table");
zvrf->fec_table[AFI_IP] = route_table_init();
zvrf->fec_table[AFI_IP6] = route_table_init();
zvrf->mpls_flags = 0;
ret = netlink_mpls_multipath(RTM_NEWROUTE, lsp);
kernel_lsp_pass_fail(lsp,
- (!ret) ?
- SOUTHBOUND_INSTALL_SUCCESS :
- SOUTHBOUND_INSTALL_FAILURE);
+ (!ret) ? SOUTHBOUND_INSTALL_SUCCESS
+ : SOUTHBOUND_INSTALL_FAILURE);
}
/*
ret = netlink_mpls_multipath(RTM_NEWROUTE, lsp);
kernel_lsp_pass_fail(lsp,
- (!ret) ?
- SOUTHBOUND_INSTALL_SUCCESS :
- SOUTHBOUND_INSTALL_FAILURE);
+ (!ret) ? SOUTHBOUND_INSTALL_SUCCESS
+ : SOUTHBOUND_INSTALL_FAILURE);
}
/*
int ret;
if (!lsp) { // unexpected
- kernel_lsp_pass_fail(lsp,
- SOUTHBOUND_DELETE_FAILURE);
+ kernel_lsp_pass_fail(lsp, SOUTHBOUND_DELETE_FAILURE);
return;
}
if (!CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED)) {
- kernel_lsp_pass_fail(lsp,
- SOUTHBOUND_DELETE_FAILURE);
+ kernel_lsp_pass_fail(lsp, SOUTHBOUND_DELETE_FAILURE);
return;
}
ret = netlink_mpls_multipath(RTM_DELROUTE, lsp);
kernel_lsp_pass_fail(lsp,
- (!ret) ?
- SOUTHBOUND_DELETE_SUCCESS :
- SOUTHBOUND_DELETE_FAILURE);
+ (!ret) ? SOUTHBOUND_DELETE_SUCCESS
+ : SOUTHBOUND_DELETE_FAILURE);
}
int mpls_kernel_init(void)
ret = kernel_lsp_cmd(RTM_ADD, lsp);
kernel_lsp_pass_fail(lsp,
- (!ret) ?
- SOUTHBOUND_INSTALL_SUCCESS :
- SOUTHBOUND_INSTALL_FAILURE);
+ (!ret) ? SOUTHBOUND_INSTALL_SUCCESS
+ : SOUTHBOUND_INSTALL_FAILURE);
}
void kernel_upd_lsp(zebra_lsp_t *lsp)
ret = kernel_lsp_cmd(RTM_CHANGE, lsp);
kernel_lsp_pass_fail(lsp,
- (!ret) ?
- SOUTHBOUND_INSTALL_SUCCESS :
- SOUTHBOUND_INSTALL_FAILURE);
+ (!ret) ? SOUTHBOUND_INSTALL_SUCCESS
+ : SOUTHBOUND_INSTALL_FAILURE);
return;
}
int ret;
if (!lsp) { // unexpected
- kernel_lsp_pass_fail(lsp,
- SOUTHBOUND_DELETE_FAILURE);
+ kernel_lsp_pass_fail(lsp, SOUTHBOUND_DELETE_FAILURE);
return;
}
if (!CHECK_FLAG(lsp->flags, LSP_FLAG_INSTALLED)) {
- kernel_lsp_pass_fail(lsp,
- SOUTHBOUND_DELETE_FAILURE);
+ kernel_lsp_pass_fail(lsp, SOUTHBOUND_DELETE_FAILURE);
return;
}
ret = kernel_lsp_cmd(RTM_DELETE, lsp);
kernel_lsp_pass_fail(lsp,
- (!ret) ?
- SOUTHBOUND_DELETE_SUCCESS :
- SOUTHBOUND_DELETE_FAILURE);
+ (!ret) ? SOUTHBOUND_DELETE_SUCCESS
+ : SOUTHBOUND_DELETE_FAILURE);
}
static int kmpw_install(struct zebra_pw *pw)
#define NETLINK_SOCKET_BUFFER_SIZE 512
#define NETLINK_ALIGNTO 4
-#define NETLINK_ALIGN(len) (((len)+NETLINK_ALIGNTO-1) \
- & ~(NETLINK_ALIGNTO-1))
+#define NETLINK_ALIGN(len) \
+ (((len) + NETLINK_ALIGNTO - 1) & ~(NETLINK_ALIGNTO - 1))
#define NETLINK_NLATTR_LEN(_a, _b) (unsigned int)((char *)_a - (char *)_b)
#endif /* defined(HAVE_NETLINK) */
return nlh;
}
-static int send_receive(int sock, struct nlmsghdr *nlh,
- unsigned int seq, char *buf)
+static int send_receive(int sock, struct nlmsghdr *nlh, unsigned int seq,
+ char *buf)
{
int ret;
- static const struct sockaddr_nl snl = {
- .nl_family = AF_NETLINK
- };
+ static const struct sockaddr_nl snl = {.nl_family = AF_NETLINK};
ret = sendto(sock, (const void *)nlh, (size_t)nlh->nlmsg_len, 0,
- (struct sockaddr *) &snl, (socklen_t)sizeof(snl));
+ (struct sockaddr *)&snl, (socklen_t)sizeof(snl));
if (ret < 0) {
- zlog_err("netlink( %u) sendmsg() error: %s",
- sock, safe_strerror(errno));
+ zlog_err("netlink( %u) sendmsg() error: %s", sock,
+ safe_strerror(errno));
return -1;
}
/* reception */
struct sockaddr_nl addr;
struct iovec iov = {
- .iov_base = buf,
- .iov_len = NETLINK_SOCKET_BUFFER_SIZE,
+ .iov_base = buf, .iov_len = NETLINK_SOCKET_BUFFER_SIZE,
};
struct msghdr msg = {
- .msg_name = &addr,
- .msg_namelen = sizeof(struct sockaddr_nl),
- .msg_iov = &iov,
- .msg_iovlen = 1,
- .msg_control = NULL,
+ .msg_name = &addr,
+ .msg_namelen = sizeof(struct sockaddr_nl),
+ .msg_iov = &iov,
+ .msg_iovlen = 1,
+ .msg_control = NULL,
.msg_controllen = 0,
- .msg_flags = 0,
+ .msg_flags = 0,
};
ret = recvmsg(sock, &msg, 0);
if (ret < 0) {
}
/* nlh already points to buf */
if (nlh->nlmsg_seq != seq) {
- zlog_err("netlink recvmsg: bad sequence number %x (expected %x)",
- seq, nlh->nlmsg_seq);
+ zlog_err(
+ "netlink recvmsg: bad sequence number %x (expected %x)",
+ seq, nlh->nlmsg_seq);
return -1;
}
return ret;
static ns_id_t extract_nsid(struct nlmsghdr *nlh, char *buf)
{
ns_id_t ns_id = NS_UNKNOWN;
- int offset = NETLINK_ALIGN(sizeof(struct nlmsghdr)) +
- NETLINK_ALIGN(sizeof(struct rtgenmsg));
+ int offset = NETLINK_ALIGN(sizeof(struct nlmsghdr))
+ + NETLINK_ALIGN(sizeof(struct rtgenmsg));
int curr_length = offset;
void *tail = (void *)((char *)nlh + NETLINK_ALIGN(nlh->nlmsg_len));
struct nlattr *attr;
for (attr = (struct nlattr *)((char *)buf + offset);
- NETLINK_NLATTR_LEN(tail, attr) >= sizeof(struct nlattr) &&
- attr->nla_len >= sizeof(struct nlattr) &&
- attr->nla_len <= NETLINK_NLATTR_LEN(tail, attr);
+ NETLINK_NLATTR_LEN(tail, attr) >= sizeof(struct nlattr)
+ && attr->nla_len >= sizeof(struct nlattr)
+ && attr->nla_len <= NETLINK_NLATTR_LEN(tail, attr);
attr += NETLINK_ALIGN(attr->nla_len)) {
curr_length += attr->nla_len;
if ((attr->nla_type & NLA_TYPE_MASK) == NETNSA_NSID) {
/* netlink socket */
sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if (sock < 0) {
- zlog_err("netlink( %u) socket() error: %s",
- sock, safe_strerror(errno));
+ zlog_err("netlink( %u) socket() error: %s", sock,
+ safe_strerror(errno));
return NS_UNKNOWN;
}
memset(&snl, 0, sizeof(snl));
snl.nl_pid = 0; /* AUTO PID */
ret = bind(sock, (struct sockaddr *)&snl, sizeof(snl));
if (ret < 0) {
- zlog_err("netlink( %u) socket() bind error: %s",
- sock, safe_strerror(errno));
+ zlog_err("netlink( %u) socket() bind error: %s", sock,
+ safe_strerror(errno));
close(sock);
close(fd);
return NS_UNKNOWN;
break;
} else {
if (nlh->nlmsg_type == NLMSG_ERROR) {
- struct nlmsgerr *err = (struct nlmsgerr *)
- ((char *)nlh +
- NETLINK_ALIGN(sizeof(
- struct nlmsghdr)));
+ struct nlmsgerr *err =
+ (struct nlmsgerr
+ *)((char *)nlh
+ + NETLINK_ALIGN(sizeof(
+ struct
+ nlmsghdr)));
ret = -1;
if (err->error < 0)
}
}
len = len - NETLINK_ALIGN(nlh->nlmsg_len);
- nlh = (struct nlmsghdr *)((char *)nlh +
- NETLINK_ALIGN(nlh->nlmsg_len));
+ nlh = (struct nlmsghdr *)((char *)nlh
+ + NETLINK_ALIGN(nlh->nlmsg_len));
} while (len != 0 && return_nsid != NS_UNKNOWN && ret == 0);
if (ret <= 0) {
if (errno != EEXIST && ret != 0) {
- zlog_err("netlink( %u) recvfrom() error 2 when reading: %s",
- fd, safe_strerror(errno));
+ zlog_err(
+ "netlink( %u) recvfrom() error 2 when reading: %s",
+ fd, safe_strerror(errno));
close(sock);
close(fd);
if (errno == ENOTSUP) {
if (return_nsid != NS_UNKNOWN)
break;
} else if (nlh->nlmsg_type == NLMSG_ERROR) {
- struct nlmsgerr *err = (struct nlmsgerr *)
- ((char *)nlh +
- NETLINK_ALIGN(sizeof(
- struct nlmsghdr)));
+ struct nlmsgerr *err =
+ (struct nlmsgerr
+ *)((char *)nlh
+ + NETLINK_ALIGN(sizeof(
+ struct
+ nlmsghdr)));
if (err->error < 0)
errno = -err->error;
else
break;
}
len = len - NETLINK_ALIGN(nlh->nlmsg_len);
- nlh = (struct nlmsghdr *)((char *)nlh +
- NETLINK_ALIGN(nlh->nlmsg_len));
+ nlh = (struct nlmsghdr *)((char *)nlh
+ + NETLINK_ALIGN(
+ nlh->nlmsg_len));
} while (len != 0 && return_nsid != NS_UNKNOWN && ret == 0);
}
return NS_DEFAULT_INTERNAL;
close(fd);
return zebra_ns_id_get((char *)NS_DEFAULT_NAME);
-#else /* HAVE_NETNS */
+#else /* HAVE_NETNS */
return NS_DEFAULT_INTERNAL;
#endif /* !HAVE_NETNS */
}
-
/* if VRF with NS ID already present */
vrf = vrf_lookup_by_id((vrf_id_t)ns_id);
if (vrf) {
- zlog_warn("NS notify : same NSID used by VRF %s. Ignore NS %s creation",
- vrf->name, netnspath);
+ zlog_warn(
+ "NS notify : same NSID used by VRF %s. Ignore NS %s creation",
+ vrf->name, netnspath);
return;
}
if (vrf_handler_create(NULL, name, &vrf) != CMD_SUCCESS) {
zlog_warn("NS notify : failed to create NS %s", netnspath);
return;
}
- zlog_info("NS notify : created VRF %s NS %s",
- name, netnspath);
+ zlog_info("NS notify : created VRF %s NS %s", name, netnspath);
}
static int zebra_ns_continue_read(struct zebra_netns_info *zns_info,
return 0;
}
thread_add_timer_msec(zebrad.master, zebra_ns_ready_read,
- (void *)zns_info,
- ZEBRA_NS_POLLING_INTERVAL_MSEC, NULL);
+ (void *)zns_info, ZEBRA_NS_POLLING_INTERVAL_MSEC,
+ NULL);
return 0;
}
char buf[BUFSIZ];
ssize_t len;
- zebra_netns_notify_current = thread_add_read(zebrad.master,
- zebra_ns_notify_read,
- NULL, fd_monitor, NULL);
+ zebra_netns_notify_current = thread_add_read(
+ zebrad.master, zebra_ns_notify_read, NULL, fd_monitor, NULL);
len = read(fd_monitor, buf, sizeof(buf));
if (len < 0) {
zlog_warn("NS notify read: failed to read (%s)",
safe_strerror(errno));
return 0;
}
- for (event = (struct inotify_event *)buf;
- (char *)event < &buf[len];
- event = (struct inotify_event *)((char *)event +
- sizeof(*event) + event->len)) {
+ for (event = (struct inotify_event *)buf; (char *)event < &buf[len];
+ event = (struct inotify_event *)((char *)event + sizeof(*event)
+ + event->len)) {
char *netnspath;
struct zebra_netns_info *netnsinfo;
netnsinfo->retries = ZEBRA_NS_POLLING_MAX_RETRIES;
netnsinfo->netnspath = netnspath;
thread_add_timer_msec(zebrad.master, zebra_ns_ready_read,
- (void *)netnsinfo, 0, NULL);
+ (void *)netnsinfo, 0, NULL);
}
return 0;
}
struct stat st;
if (strcmp(dent->d_name, ".") == 0
- || strcmp(dent->d_name, "..") == 0)
+ || strcmp(dent->d_name, "..") == 0)
continue;
if (fstatat(dirfd(srcdir), dent->d_name, &st, 0) < 0) {
zlog_warn("NS parsing init: failed to parse entry %s",
zlog_warn("NS notify watch: failed to add watch (%s)",
safe_strerror(errno));
}
- zebra_netns_notify_current = thread_add_read(zebrad.master,
- zebra_ns_notify_read,
- NULL, fd_monitor, NULL);
+ zebra_netns_notify_current = thread_add_read(
+ zebrad.master, zebra_ns_notify_read, NULL, fd_monitor, NULL);
}
void zebra_ns_notify_close(void)
DEFINE_MTYPE(ZEBRA, ZEBRA_NS, "Zebra Name Space")
-static inline int
-zebra_ns_table_entry_compare(const struct zebra_ns_table *e1,
- const struct zebra_ns_table *e2);
+static inline int zebra_ns_table_entry_compare(const struct zebra_ns_table *e1,
+ const struct zebra_ns_table *e2);
RB_GENERATE(zebra_ns_table_head, zebra_ns_table, zebra_ns_table_entry,
zebra_ns_table_entry_compare);
static struct zebra_ns *dzns;
-static inline int
-zebra_ns_table_entry_compare(const struct zebra_ns_table *e1,
- const struct zebra_ns_table *e2)
+static inline int zebra_ns_table_entry_compare(const struct zebra_ns_table *e1,
+ const struct zebra_ns_table *e2)
{
if (e1->tableid == e2->tableid)
return (e1->afi - e2->afi);
static int zebra_ns_delete(struct ns *ns)
{
- struct zebra_ns *zns = (struct zebra_ns *) ns->info;
+ struct zebra_ns *zns = (struct zebra_ns *)ns->info;
if (IS_ZEBRA_DEBUG_EVENT)
zlog_info("ZNS %s with id %u (deleted)", ns->name, ns->ns_id);
return 0;
}
-struct route_table *zebra_ns_find_table(struct zebra_ns *zns,
- uint32_t tableid, afi_t afi)
+struct route_table *zebra_ns_find_table(struct zebra_ns *zns, uint32_t tableid,
+ afi_t afi)
{
struct zebra_ns_table finder;
struct zebra_ns_table *znst;
struct ns *ns;
int write = 0;
- RB_FOREACH(ns, ns_head, &ns_tree) {
+ RB_FOREACH (ns, ns_head, &ns_tree) {
if (ns->ns_id == NS_DEFAULT || ns->name == NULL)
continue;
vty_out(vty, "logical-router %u netns %s\n", ns->ns_id,
}
/* BFD client register */
-int zebra_ptm_bfd_client_register(struct zserv *client,
- u_short length)
+int zebra_ptm_bfd_client_register(struct zserv *client, u_short length)
{
struct stream *s;
unsigned int pid;
int zebra_ptm_bfd_dst_deregister(struct zserv *client, u_short length,
struct zebra_vrf *zvrf);
void zebra_ptm_show_status(struct vty *vty, struct interface *ifp);
-int zebra_ptm_bfd_client_register(struct zserv *client,
- u_short length);
+int zebra_ptm_bfd_client_register(struct zserv *client, u_short length);
void zebra_ptm_if_init(struct zebra_if *zebra_ifp);
void zebra_ptm_if_set_ptm_state(struct interface *ifp,
struct zebra_if *zebra_ifp);
/*Pending: need to think if null ifp here is ok during bootup?
There was a crash because ifp here was coming to be NULL */
if (ifp)
- if (connected_is_unnumbered(ifp) ||
- CHECK_FLAG(re->flags, ZEBRA_FLAG_EVPN_ROUTE)) {
+ if (connected_is_unnumbered(ifp)
+ || CHECK_FLAG(re->flags, ZEBRA_FLAG_EVPN_ROUTE)) {
SET_FLAG(nexthop->flags, NEXTHOP_FLAG_ONLINK);
}
* host route.
*/
if (top && rn == top)
- if (((afi == AFI_IP) && (rn->p.prefixlen != 32)) ||
- ((afi == AFI_IP6) && (rn->p.prefixlen != 128)))
+ if (((afi == AFI_IP) && (rn->p.prefixlen != 32))
+ || ((afi == AFI_IP6) && (rn->p.prefixlen != 128)))
return 0;
/* Pick up selected route. */
return 0;
dest = rib_dest_from_rnode(rn);
- if (dest && dest->selected_fib &&
- !CHECK_FLAG(dest->selected_fib->status,
- ROUTE_ENTRY_REMOVED) &&
- dest->selected_fib->type != ZEBRA_ROUTE_TABLE)
+ if (dest && dest->selected_fib
+ && !CHECK_FLAG(dest->selected_fib->status,
+ ROUTE_ENTRY_REMOVED)
+ && dest->selected_fib->type != ZEBRA_ROUTE_TABLE)
match = dest->selected_fib;
/* If there is no selected route or matched route is EGP, go up
route_unlock_node(rn);
dest = rib_dest_from_rnode(rn);
- if (dest && dest->selected_fib &&
- !CHECK_FLAG(dest->selected_fib->status, ROUTE_ENTRY_REMOVED))
+ if (dest && dest->selected_fib
+ && !CHECK_FLAG(dest->selected_fib->status,
+ ROUTE_ENTRY_REMOVED))
match = dest->selected_fib;
/* If there is no selected route or matched route is EGP, go up
route_unlock_node(rn);
dest = rib_dest_from_rnode(rn);
- if (dest && dest->selected_fib &&
- !CHECK_FLAG(dest->selected_fib->status, ROUTE_ENTRY_REMOVED))
+ if (dest && dest->selected_fib
+ && !CHECK_FLAG(dest->selected_fib->status, ROUTE_ENTRY_REMOVED))
match = dest->selected_fib;
if (!match)
/* Find out if a "selected" RR for the discovered RIB entry exists ever.
*/
- if (dest && dest->selected_fib &&
- !CHECK_FLAG(dest->selected_fib->status, ROUTE_ENTRY_REMOVED))
+ if (dest && dest->selected_fib
+ && !CHECK_FLAG(dest->selected_fib->status, ROUTE_ENTRY_REMOVED))
match = dest->selected_fib;
/* None such found :( */
struct nexthop *prev;
for (ALL_NEXTHOPS(re->nexthop, nexthop)) {
- UNSET_FLAG (nexthop->flags, NEXTHOP_FLAG_DUPLICATE);
+ UNSET_FLAG(nexthop->flags, NEXTHOP_FLAG_DUPLICATE);
for (ALL_NEXTHOPS(re->nexthop, prev)) {
if (prev == nexthop)
break;
- if (nexthop_same_firsthop (nexthop, prev))
- {
- SET_FLAG (nexthop->flags, NEXTHOP_FLAG_DUPLICATE);
+ if (nexthop_same_firsthop(nexthop, prev)) {
+ SET_FLAG(nexthop->flags,
+ NEXTHOP_FLAG_DUPLICATE);
break;
}
}
/* free RE and nexthops */
if (re->type == ZEBRA_ROUTE_STATIC)
- zebra_deregister_rnh_static_nexthops(re->vrf_id,
- re->nexthop, rn);
+ zebra_deregister_rnh_static_nexthops(re->vrf_id, re->nexthop,
+ rn);
nexthops_free(re->nexthop);
XFREE(MTYPE_RE, re);
}
continue;
if (same->instance != re->instance)
continue;
- if (same->type == ZEBRA_ROUTE_KERNEL &&
- same->metric != re->metric)
+ if (same->type == ZEBRA_ROUTE_KERNEL
+ && same->metric != re->metric)
continue;
/*
* We should allow duplicate connected routes because of
continue;
if (re->instance != instance)
continue;
- if (re->type == ZEBRA_ROUTE_KERNEL &&
- re->metric != metric)
+ if (re->type == ZEBRA_ROUTE_KERNEL && re->metric != metric)
continue;
if (re->type == ZEBRA_ROUTE_CONNECT && (rtnh = re->nexthop)
&& rtnh->type == NEXTHOP_TYPE_IFINDEX && nh) {
}
if (same) {
- if (fromkernel &&
- CHECK_FLAG(flags, ZEBRA_FLAG_SELFROUTE) &&
- !allow_delete) {
+ if (fromkernel && CHECK_FLAG(flags, ZEBRA_FLAG_SELFROUTE)
+ && !allow_delete) {
rib_install_kernel(rn, same, NULL);
route_unlock_node(rn);
* has already been queued we don't
* need to queue it up again
*/
- if (rn->info
- && CHECK_FLAG(rib_dest_from_rnode(rn)->flags,
- RIB_ROUTE_ANY_QUEUED))
+ if (rn->info && CHECK_FLAG(rib_dest_from_rnode(rn)->flags,
+ RIB_ROUTE_ANY_QUEUED))
continue;
switch (event) {
case RIB_UPDATE_IF_CHANGE:
RNODE_FOREACH_RE_SAFE (rn, re, next) {
struct nexthop *nh;
- if (re->type != ZEBRA_ROUTE_SYSTEM &&
- re->type != ZEBRA_ROUTE_KERNEL &&
- re->type != ZEBRA_ROUTE_CONNECT &&
- re->type != ZEBRA_ROUTE_STATIC)
+ if (re->type != ZEBRA_ROUTE_SYSTEM
+ && re->type != ZEBRA_ROUTE_KERNEL
+ && re->type != ZEBRA_ROUTE_CONNECT
+ && re->type != ZEBRA_ROUTE_STATIC)
continue;
if (re->type != ZEBRA_ROUTE_STATIC) {
* Determine appropriate route (RE entry) resolving a tracked BGP route
* for BGP route for import.
*/
-static
-struct route_entry *zebra_rnh_resolve_import_entry(vrf_id_t vrfid,
- int family,
- struct route_node *nrn,
- struct rnh *rnh,
- struct route_node **prn)
+static struct route_entry *
+zebra_rnh_resolve_import_entry(vrf_id_t vrfid, int family,
+ struct route_node *nrn, struct rnh *rnh,
+ struct route_node **prn)
{
struct route_table *route_table;
struct route_node *rn;
/* Unlock route node - we don't need to lock when walking the tree. */
route_unlock_node(rn);
- if (CHECK_FLAG(rnh->flags, ZEBRA_NHT_EXACT_MATCH) &&
- !prefix_same(&nrn->p, &rn->p))
+ if (CHECK_FLAG(rnh->flags, ZEBRA_NHT_EXACT_MATCH)
+ && !prefix_same(&nrn->p, &rn->p))
return NULL;
/* Identify appropriate route entry. */
- RNODE_FOREACH_RE(rn, re) {
- if (!CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED) &&
- CHECK_FLAG(re->flags, ZEBRA_FLAG_SELECTED) &&
- (re->type != ZEBRA_ROUTE_BGP))
+ RNODE_FOREACH_RE (rn, re) {
+ if (!CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED)
+ && CHECK_FLAG(re->flags, ZEBRA_FLAG_SELECTED)
+ && (re->type != ZEBRA_ROUTE_BGP))
break;
}
* Determine appropriate route (route entry) resolving a tracked
* nexthop.
*/
-static struct route_entry *zebra_rnh_resolve_nexthop_entry(vrf_id_t vrfid,
- int family,
- struct route_node *nrn,
- struct rnh *rnh,
- struct route_node **prn)
+static struct route_entry *
+zebra_rnh_resolve_nexthop_entry(vrf_id_t vrfid, int family,
+ struct route_node *nrn, struct rnh *rnh,
+ struct route_node **prn)
{
struct route_table *route_table;
struct route_node *rn;
/* Do not resolve over default route unless allowed &&
* match route to be exact if so specified
*/
- if (is_default_prefix(&rn->p) &&
- !rnh_resolve_via_default(rn->p.family))
+ if (is_default_prefix(&rn->p)
+ && !rnh_resolve_via_default(rn->p.family))
return NULL;
/* Identify appropriate route entry. */
- RNODE_FOREACH_RE(rn, re) {
+ RNODE_FOREACH_RE (rn, re) {
if (CHECK_FLAG(re->status, ROUTE_ENTRY_REMOVED))
continue;
if (!CHECK_FLAG(re->flags, ZEBRA_FLAG_SELECTED))
if (re->type == ZEBRA_ROUTE_NHRP) {
struct nexthop *nexthop;
- for (nexthop = re->nexthop;
- nexthop;
+ for (nexthop = re->nexthop; nexthop;
nexthop = nexthop->next)
if (nexthop->type
- == NEXTHOP_TYPE_IFINDEX)
+ == NEXTHOP_TYPE_IFINDEX)
break;
if (nexthop)
break;
/* Identify route entry (RE) resolving this tracked entry. */
if (type == RNH_IMPORT_CHECK_TYPE)
- re = zebra_rnh_resolve_import_entry(vrfid, family, nrn,
- rnh, &prn);
+ re = zebra_rnh_resolve_import_entry(vrfid, family, nrn, rnh,
+ &prn);
else
re = zebra_rnh_resolve_nexthop_entry(vrfid, family, nrn, rnh,
&prn);
/* Identify route entry (RIB) resolving this tracked entry. */
if (type == RNH_IMPORT_CHECK_TYPE)
- re = zebra_rnh_resolve_import_entry(vrfid, family, nrn,
- rnh, &prn);
+ re = zebra_rnh_resolve_import_entry(vrfid, family, nrn, rnh,
+ &prn);
else
re = zebra_rnh_resolve_nexthop_entry(vrfid, family, nrn, rnh,
&prn);
struct route_entry *state;
struct prefix resolved_route;
struct list *client_list;
- struct list *
- zebra_static_route_list; /* static routes dependent on this NH
- */
+ struct list
+ *zebra_static_route_list; /* static routes dependent on this NH
+ */
struct list
*zebra_pseudowire_list; /* pseudowires dependent on this NH */
struct route_node *node;
"Match prefix length of ipv6 address\n"
"Prefix length\n")
{
- return zebra_route_match_add(vty, "ipv6 address prefix-len", argv[4]->arg,
- RMAP_EVENT_MATCH_ADDED);
+ return zebra_route_match_add(vty, "ipv6 address prefix-len",
+ argv[4]->arg, RMAP_EVENT_MATCH_ADDED);
}
DEFUN (no_match_ipv6_address_prefix_len,
re, si->ifindex, si->nh_vrf_id);
break;
case STATIC_BLACKHOLE:
- nexthop = route_entry_nexthop_blackhole_add(
- re, bh_type);
+ nexthop =
+ route_entry_nexthop_blackhole_add(re, bh_type);
break;
case STATIC_IPV6_GATEWAY:
nexthop = route_entry_nexthop_ipv6_add(
re, si->ifindex, si->nh_vrf_id);
break;
case STATIC_BLACKHOLE:
- nexthop = route_entry_nexthop_blackhole_add(
- re, bh_type);
+ nexthop =
+ route_entry_nexthop_blackhole_add(re, bh_type);
break;
case STATIC_IPV6_GATEWAY:
nexthop = route_entry_nexthop_ipv6_add(
if (!stable)
return -1;
- if (!gate
- && (type == STATIC_IPV4_GATEWAY
- || type == STATIC_IPV4_GATEWAY_IFNAME
- || type == STATIC_IPV6_GATEWAY
- || type == STATIC_IPV6_GATEWAY_IFNAME))
+ if (!gate && (type == STATIC_IPV4_GATEWAY
+ || type == STATIC_IPV4_GATEWAY_IFNAME
+ || type == STATIC_IPV6_GATEWAY
+ || type == STATIC_IPV6_GATEWAY_IFNAME))
return -1;
if (!ifname
- && (type == STATIC_IFNAME
- || type == STATIC_IPV4_GATEWAY_IFNAME
+ && (type == STATIC_IFNAME || type == STATIC_IPV4_GATEWAY_IFNAME
|| type == STATIC_IPV6_GATEWAY_IFNAME))
return -1;
/* Do nothing if there is a same static route. */
for (si = rn->info; si; si = si->next) {
if (type == si->type
- && (!gate || ((afi == AFI_IP
- && IPV4_ADDR_SAME(&gate->ipv4, &si->addr.ipv4))
- || (afi == AFI_IP6
- && IPV6_ADDR_SAME(gate, &si->addr.ipv6))))
- && (!strcmp (ifname ? ifname : "", si->ifname))) {
+ && (!gate
+ || ((afi == AFI_IP
+ && IPV4_ADDR_SAME(&gate->ipv4, &si->addr.ipv4))
+ || (afi == AFI_IP6
+ && IPV6_ADDR_SAME(gate, &si->addr.ipv6))))
+ && (!strcmp(ifname ? ifname : "", si->ifname))) {
if ((distance == si->distance) && (tag == si->tag)
&& !memcmp(&si->snh_label, snh_label,
sizeof(struct static_nh_label))
/* Find same static route is the tree */
for (si = rn->info; si; si = si->next)
if (type == si->type
- && (!gate || ((afi == AFI_IP
- && IPV4_ADDR_SAME(&gate->ipv4, &si->addr.ipv4))
- || (afi == AFI_IP6
- && IPV6_ADDR_SAME(gate, &si->addr.ipv6))))
+ && (!gate
+ || ((afi == AFI_IP
+ && IPV4_ADDR_SAME(&gate->ipv4, &si->addr.ipv4))
+ || (afi == AFI_IP6
+ && IPV6_ADDR_SAME(gate, &si->addr.ipv6))))
&& (!strcmp(ifname ? ifname : "", si->ifname))
&& (!tag || (tag == si->tag))
&& (!snh_label->num_labels
return 1;
}
-static void static_ifindex_update_af(struct interface *ifp, bool up,
- afi_t afi, safi_t safi)
+static void static_ifindex_update_af(struct interface *ifp, bool up, afi_t afi,
+ safi_t safi)
{
struct route_table *stable;
struct zebra_vrf *zvrf = zebra_vrf_lookup_by_id(ifp->vrf_id);
} else {
if (si->ifindex != ifp->ifindex)
continue;
- static_uninstall_route(afi, safi, p, src_p,
- si);
+ static_uninstall_route(afi, safi, p, src_p, si);
si->ifindex = IFINDEX_INTERNAL;
}
}
assert(zvrf);
if (IS_ZEBRA_DEBUG_EVENT)
- zlog_debug("VRF %s id %u is now active",
- zvrf_name(zvrf), zvrf_id(zvrf));
+ zlog_debug("VRF %s id %u is now active", zvrf_name(zvrf),
+ zvrf_id(zvrf));
if (vrf_is_backend_netns())
zvrf->zns = zebra_ns_lookup((ns_id_t)vrf->vrf_id);
assert(zvrf);
if (IS_ZEBRA_DEBUG_EVENT)
- zlog_debug("VRF %s id %u is now inactive",
- zvrf_name(zvrf), zvrf_id(zvrf));
+ zlog_debug("VRF %s id %u is now inactive", zvrf_name(zvrf),
+ zvrf_id(zvrf));
/* Uninstall any static routes configured for this VRF. */
for (afi = AFI_IP; afi < AFI_MAX; afi++)
zebra_mpls_cleanup_tables(zvrf);
zebra_pw_exit(zvrf);
- /* Remove link-local IPv4 addresses created for BGP unnumbered peering. */
+ /* Remove link-local IPv4 addresses created for BGP unnumbered peering.
+ */
FOR_ALL_INTERFACES (vrf, ifp)
if_nbr_ipv6ll_to_ipv4ll_neigh_del_all(ifp);
struct route_node *rnode;
rib_dest_t *dest;
- for (ALL_LIST_ELEMENTS(zebrad.mq->subq[i],
- lnode, nnode, rnode)) {
+ for (ALL_LIST_ELEMENTS(zebrad.mq->subq[i], lnode, nnode,
+ rnode)) {
dest = rib_dest_from_rnode(rnode);
if (dest && rib_dest_vrf(dest) == zvrf) {
route_unlock_node(rnode);
assert(zvrf);
if (IS_ZEBRA_DEBUG_EVENT)
- zlog_debug("VRF %s id %u deleted",
- zvrf_name(zvrf), zvrf_id(zvrf));
+ zlog_debug("VRF %s id %u deleted", zvrf_name(zvrf),
+ zvrf_id(zvrf));
/* clean-up work queues */
for (i = 0; i < MQ_SIZE; i++) {
struct route_node *rnode;
rib_dest_t *dest;
- for (ALL_LIST_ELEMENTS(zebrad.mq->subq[i], lnode, nnode, rnode)) {
+ for (ALL_LIST_ELEMENTS(zebrad.mq->subq[i], lnode, nnode,
+ rnode)) {
dest = rib_dest_from_rnode(rnode);
if (dest && rib_dest_vrf(dest) == zvrf) {
route_unlock_node(rnode);
if (vrf_is_user_cfged(vrf)) {
vty_out(vty, "vrf %s\n", zvrf_name(zvrf));
if (zvrf->l3vni)
- vty_out(vty, " vni %u%s\n",
- zvrf->l3vni,
- is_l3vni_for_prefix_routes_only(zvrf->l3vni) ?
- " prefix-routes-only" :"");
+ vty_out(vty, " vni %u%s\n", zvrf->l3vni,
+ is_l3vni_for_prefix_routes_only(
+ zvrf->l3vni)
+ ? " prefix-routes-only"
+ : "");
zebra_ns_config_write(vty, (struct ns *)vrf->ns_ctxt);
vty_out(vty, "!\n");
}
/* Zebra VRF initialization. */
void zebra_vrf_init(void)
{
- vrf_init(zebra_vrf_new, zebra_vrf_enable,
- zebra_vrf_disable, zebra_vrf_delete);
+ vrf_init(zebra_vrf_new, zebra_vrf_enable, zebra_vrf_disable,
+ zebra_vrf_delete);
vrf_cmd_init(vrf_config_write);
}
/*
* special macro to allow us to get the correct zebra_vrf
*/
-#define ZEBRA_DECLVAR_CONTEXT(A, B) \
- struct vrf *A = VTY_GET_CONTEXT(vrf); \
- struct zebra_vrf *B = \
- (vrf) ? vrf->info : NULL; \
+#define ZEBRA_DECLVAR_CONTEXT(A, B) \
+ struct vrf *A = VTY_GET_CONTEXT(vrf); \
+ struct zebra_vrf *B = (vrf) ? vrf->info : NULL;
/* VNI range as per RFC 7432 */
#define CMD_VNI_RANGE "(1-16777215)"
/* General function for static route. */
-static int zebra_static_route_leak(struct vty *vty,
- struct zebra_vrf *zvrf,
- struct zebra_vrf *nh_zvrf,
- afi_t afi, safi_t safi,
- const char *negate, const char *dest_str,
- const char *mask_str, const char *src_str,
- const char *gate_str, const char *ifname,
- const char *flag_str, const char *tag_str,
- const char *distance_str,
- const char *label_str)
+static int zebra_static_route_leak(
+ struct vty *vty, struct zebra_vrf *zvrf, struct zebra_vrf *nh_zvrf,
+ afi_t afi, safi_t safi, const char *negate, const char *dest_str,
+ const char *mask_str, const char *src_str, const char *gate_str,
+ const char *ifname, const char *flag_str, const char *tag_str,
+ const char *distance_str, const char *label_str)
{
int ret;
u_char distance;
/* Null0 static route. */
if (ifname != NULL) {
- if (strncasecmp(ifname, "Null0", strlen(ifname)) == 0 ||
- strncasecmp(ifname, "reject", strlen(ifname)) == 0 ||
- strncasecmp(ifname, "blackhole", strlen(ifname)) == 0) {
- vty_out(vty, "%% Nexthop interface cannot be Null0, reject or blackhole\n");
+ if (strncasecmp(ifname, "Null0", strlen(ifname)) == 0
+ || strncasecmp(ifname, "reject", strlen(ifname)) == 0
+ || strncasecmp(ifname, "blackhole", strlen(ifname)) == 0) {
+ vty_out(vty,
+ "%% Nexthop interface cannot be Null0, reject or blackhole\n");
return CMD_WARNING_CONFIG_FAILED;
}
}
}
static int zebra_static_route(struct vty *vty, afi_t afi, safi_t safi,
- const char *negate, const char *dest_str,
- const char *mask_str, const char *src_str,
- const char *gate_str, const char *ifname,
- const char *flag_str, const char *tag_str,
- const char *distance_str, const char *vrf_name,
- const char *label_str)
+ const char *negate, const char *dest_str,
+ const char *mask_str, const char *src_str,
+ const char *gate_str, const char *ifname,
+ const char *flag_str, const char *tag_str,
+ const char *distance_str, const char *vrf_name,
+ const char *label_str)
{
struct zebra_vrf *zvrf;
struct vrf *vrf;
/* Mark as having FRR configuration */
vrf_set_user_cfged(vrf);
}
- return zebra_static_route_leak(vty, zvrf, zvrf, afi, safi,
- negate, dest_str, mask_str, src_str,
- gate_str, ifname, flag_str, tag_str,
- distance_str, label_str);
+ return zebra_static_route_leak(
+ vty, zvrf, zvrf, afi, safi, negate, dest_str, mask_str, src_str,
+ gate_str, ifname, flag_str, tag_str, distance_str, label_str);
}
MPLS_LABEL_HELPSTR)
{
return zebra_static_route(vty, AFI_IP, SAFI_UNICAST, no, prefix,
- mask_str, NULL, NULL, NULL, flag,
- tag_str, distance_str, vrf, label);
+ mask_str, NULL, NULL, NULL, flag, tag_str,
+ distance_str, vrf, label);
}
DEFPY(ip_route_blackhole_vrf,
* valid. Add an assert to make it happy
*/
assert(prefix);
- return zebra_static_route_leak(vty, zvrf, zvrf,
- AFI_IP, SAFI_UNICAST, no, prefix,
- mask_str, NULL, NULL, NULL, flag,
- tag_str, distance_str, label);
+ return zebra_static_route_leak(vty, zvrf, zvrf, AFI_IP, SAFI_UNICAST,
+ no, prefix, mask_str, NULL, NULL, NULL,
+ flag, tag_str, distance_str, label);
}
DEFPY(ip_route_address_interface,
zvrf = zebra_vrf_lookup_by_name(vrf);
if (!zvrf) {
- vty_out(vty, "%% vrf %s is not defined\n",
- vrf);
+ vty_out(vty, "%% vrf %s is not defined\n", vrf);
return CMD_WARNING_CONFIG_FAILED;
}
nh_zvrf = zvrf;
if (!nh_zvrf) {
- vty_out(vty, "%% nexthop vrf %s is not defined\n",
- nexthop_vrf);
+ vty_out(vty, "%% nexthop vrf %s is not defined\n", nexthop_vrf);
return CMD_WARNING_CONFIG_FAILED;
}
- return zebra_static_route_leak(vty, zvrf, nh_zvrf,
- AFI_IP, SAFI_UNICAST, no, prefix,
- mask_str, NULL, gate_str, ifname, flag,
- tag_str, distance_str, label);
+ return zebra_static_route_leak(
+ vty, zvrf, nh_zvrf, AFI_IP, SAFI_UNICAST, no, prefix, mask_str,
+ NULL, gate_str, ifname, flag, tag_str, distance_str, label);
}
DEFPY(ip_route_address_interface_vrf,
nh_zvrf = zvrf;
if (!nh_zvrf) {
- vty_out(vty, "%% nexthop vrf %s is not defined\n",
- nexthop_vrf);
+ vty_out(vty, "%% nexthop vrf %s is not defined\n", nexthop_vrf);
return CMD_WARNING_CONFIG_FAILED;
}
- return zebra_static_route_leak(vty, zvrf, nh_zvrf,
- AFI_IP, SAFI_UNICAST, no, prefix,
- mask_str, NULL, gate_str, ifname, flag,
- tag_str, distance_str, label);
+ return zebra_static_route_leak(
+ vty, zvrf, nh_zvrf, AFI_IP, SAFI_UNICAST, no, prefix, mask_str,
+ NULL, gate_str, ifname, flag, tag_str, distance_str, label);
}
DEFPY(ip_route,
zvrf = zebra_vrf_lookup_by_name(vrf);
if (!zvrf) {
- vty_out(vty, "%% vrf %s is not defined\n",
- vrf);
+ vty_out(vty, "%% vrf %s is not defined\n", vrf);
return CMD_WARNING_CONFIG_FAILED;
}
nh_zvrf = zvrf;
if (!nh_zvrf) {
- vty_out(vty, "%% nexthop vrf %s is not defined\n",
- nexthop_vrf);
+ vty_out(vty, "%% nexthop vrf %s is not defined\n", nexthop_vrf);
return CMD_WARNING_CONFIG_FAILED;
}
- return zebra_static_route_leak(vty, zvrf, nh_zvrf,
- AFI_IP, SAFI_UNICAST, no, prefix,
- mask_str, NULL, gate_str, ifname, flag,
- tag_str, distance_str, label);
+ return zebra_static_route_leak(
+ vty, zvrf, nh_zvrf, AFI_IP, SAFI_UNICAST, no, prefix, mask_str,
+ NULL, gate_str, ifname, flag, tag_str, distance_str, label);
}
DEFPY(ip_route_vrf,
nh_zvrf = zvrf;
if (!nh_zvrf) {
- vty_out(vty, "%% nexthop vrf %s is not defined\n",
- nexthop_vrf);
+ vty_out(vty, "%% nexthop vrf %s is not defined\n", nexthop_vrf);
return CMD_WARNING_CONFIG_FAILED;
}
- return zebra_static_route_leak(vty, zvrf, nh_zvrf,
- AFI_IP, SAFI_UNICAST, no, prefix,
- mask_str, NULL, gate_str, ifname, flag,
- tag_str, distance_str, label);
+ return zebra_static_route_leak(
+ vty, zvrf, nh_zvrf, AFI_IP, SAFI_UNICAST, no, prefix, mask_str,
+ NULL, gate_str, ifname, flag, tag_str, distance_str, label);
}
/* New RIB. Detailed information for IPv4 route. */
vty_out(vty, " Last update ");
if (uptime < ONE_DAY_SECOND)
- vty_out(vty, "%02d:%02d:%02d", tm->tm_hour,
- tm->tm_min, tm->tm_sec);
+ vty_out(vty, "%02d:%02d:%02d", tm->tm_hour, tm->tm_min,
+ tm->tm_sec);
else if (uptime < ONE_WEEK_SECOND)
- vty_out(vty, "%dd%02dh%02dm", tm->tm_yday,
- tm->tm_hour, tm->tm_min);
+ vty_out(vty, "%dd%02dh%02dm", tm->tm_yday, tm->tm_hour,
+ tm->tm_min);
else
vty_out(vty, "%02dw%dd%02dh", tm->tm_yday / 7,
tm->tm_yday - ((tm->tm_yday / 7) * 7),
vty_out(vty, " %c%s",
CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB)
- ? CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_DUPLICATE)
- ? ' ' : '*'
+ ? CHECK_FLAG(nexthop->flags,
+ NEXTHOP_FLAG_DUPLICATE)
+ ? ' '
+ : '*'
: ' ',
nexthop->rparent ? " " : "");
}
if (uptime < ONE_DAY_SECOND)
- sprintf(buf, "%02d:%02d:%02d", tm->tm_hour,
- tm->tm_min, tm->tm_sec);
+ sprintf(buf, "%02d:%02d:%02d", tm->tm_hour, tm->tm_min,
+ tm->tm_sec);
else if (uptime < ONE_WEEK_SECOND)
- sprintf(buf, "%dd%02dh%02dm", tm->tm_yday,
- tm->tm_hour, tm->tm_min);
+ sprintf(buf, "%dd%02dh%02dm", tm->tm_yday, tm->tm_hour,
+ tm->tm_min);
else
sprintf(buf, "%02dw%dd%02dh", tm->tm_yday / 7,
tm->tm_yday - ((tm->tm_yday / 7) * 7),
struct vrf *vrf =
vrf_lookup_by_id(nexthop->vrf_id);
- json_object_string_add(json_nexthop,
- "vrf",
+ json_object_string_add(json_nexthop, "vrf",
vrf->name);
}
if (CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_DUPLICATE))
} else {
vty_out(vty, " %c%*c",
CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_FIB)
- ? CHECK_FLAG(nexthop->flags, NEXTHOP_FLAG_DUPLICATE)
- ? ' ' : '*'
+ ? CHECK_FLAG(nexthop->flags,
+ NEXTHOP_FLAG_DUPLICATE)
+ ? ' '
+ : '*'
: ' ',
len - 3 + (2 * nexthop_level(nexthop)), ' ');
}
dest = rib_dest_from_rnode(rn);
RNODE_FOREACH_RE (rn, re) {
- if (use_fib
- && re != dest->selected_fib)
+ if (use_fib && re != dest->selected_fib)
continue;
if (tag && re->tag != tag)
struct vrf *vrf;
struct zebra_vrf *zvrf;
- RB_FOREACH(vrf, vrf_name_head, &vrfs_by_name) {
+ RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
if ((zvrf = vrf->info) == NULL
|| (table = zvrf->table[afi][SAFI_UNICAST]) == NULL)
continue;
struct vrf *vrf;
struct zebra_vrf *zvrf;
- RB_FOREACH(vrf, vrf_name_head, &vrfs_by_name) {
+ RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
if ((zvrf = vrf->info) == NULL
|| (table = zvrf->table[afi][SAFI_UNICAST]) == NULL)
continue;
}
/* Write static route configuration. */
-int static_config(struct vty *vty, struct zebra_vrf *zvrf,
- afi_t afi, safi_t safi, const char *cmd)
+int static_config(struct vty *vty, struct zebra_vrf *zvrf, afi_t afi,
+ safi_t safi, const char *cmd)
{
char spacing[100];
struct route_node *rn;
if ((stable = zvrf->stable[afi][safi]) == NULL)
return write;
- sprintf(spacing, "%s%s",
- (zvrf->vrf->vrf_id == VRF_DEFAULT) ? "" : " ",
+ sprintf(spacing, "%s%s", (zvrf->vrf->vrf_id == VRF_DEFAULT) ? "" : " ",
cmd);
for (rn = route_top(stable); rn; rn = srcdest_route_next(rn))
switch (si->type) {
case STATIC_IPV4_GATEWAY:
- vty_out(vty, " %s",
- inet_ntoa(si->addr.ipv4));
+ vty_out(vty, " %s", inet_ntoa(si->addr.ipv4));
break;
case STATIC_IPV6_GATEWAY:
vty_out(vty, " %s",
- inet_ntop(AF_INET6,
- &si->addr.ipv6, buf,
+ inet_ntop(AF_INET6, &si->addr.ipv6, buf,
sizeof buf));
break;
case STATIC_IFNAME:
break;
case STATIC_IPV4_GATEWAY_IFNAME:
vty_out(vty, " %s %s",
- inet_ntop(AF_INET,
- &si->addr.ipv4, buf,
+ inet_ntop(AF_INET, &si->addr.ipv4, buf,
sizeof buf),
si->ifname);
break;
case STATIC_IPV6_GATEWAY_IFNAME:
vty_out(vty, " %s %s",
- inet_ntop(AF_INET6,
- &si->addr.ipv6, buf,
+ inet_ntop(AF_INET6, &si->addr.ipv6, buf,
sizeof buf),
si->ifname);
break;
}
if (si->tag)
- vty_out(vty, " tag %" ROUTE_TAG_PRI,
- si->tag);
+ vty_out(vty, " tag %" ROUTE_TAG_PRI, si->tag);
- if (si->distance
- != ZEBRA_STATIC_DISTANCE_DEFAULT)
+ if (si->distance != ZEBRA_STATIC_DISTANCE_DEFAULT)
vty_out(vty, " %d", si->distance);
if (si->nh_vrf_id != si->vrf_id) {
if (si->snh_label.num_labels)
vty_out(vty, " label %s",
mpls_label2str(si->snh_label.num_labels,
- si->snh_label.label,
- buf, sizeof buf, 0));
+ si->snh_label.label, buf,
+ sizeof buf, 0));
vty_out(vty, "\n");
MPLS_LABEL_HELPSTR)
{
return zebra_static_route(vty, AFI_IP6, SAFI_UNICAST, no, prefix_str,
- NULL, from_str, NULL, NULL, flag,
- tag_str, distance_str, vrf, label);
+ NULL, from_str, NULL, NULL, flag, tag_str,
+ distance_str, vrf, label);
}
DEFPY(ipv6_route_blackhole_vrf,
* valid. Add an assert to make it happy
*/
assert(prefix);
- return zebra_static_route_leak(vty, zvrf, zvrf,
- AFI_IP6, SAFI_UNICAST, no, prefix_str,
- NULL, from_str, NULL, NULL, flag,
- tag_str, distance_str, label);
+ return zebra_static_route_leak(
+ vty, zvrf, zvrf, AFI_IP6, SAFI_UNICAST, no, prefix_str, NULL,
+ from_str, NULL, NULL, flag, tag_str, distance_str, label);
}
DEFPY(ipv6_route_address_interface,
zvrf = zebra_vrf_lookup_by_name(vrf);
if (!zvrf) {
- vty_out(vty, "%% vrf %s is not defined\n",
- vrf);
+ vty_out(vty, "%% vrf %s is not defined\n", vrf);
return CMD_WARNING_CONFIG_FAILED;
}
nh_zvrf = zvrf;
if (!nh_zvrf) {
- vty_out(vty, "%% nexthop vrf %s is not defined\n",
- nexthop_vrf);
+ vty_out(vty, "%% nexthop vrf %s is not defined\n", nexthop_vrf);
return CMD_WARNING_CONFIG_FAILED;
}
- return zebra_static_route_leak(vty, zvrf, nh_zvrf,
- AFI_IP6, SAFI_UNICAST, no, prefix_str,
- NULL, from_str, gate_str, ifname, NULL,
- tag_str, distance_str, label);
+ return zebra_static_route_leak(
+ vty, zvrf, nh_zvrf, AFI_IP6, SAFI_UNICAST, no, prefix_str, NULL,
+ from_str, gate_str, ifname, NULL, tag_str, distance_str, label);
}
DEFPY(ipv6_route_address_interface_vrf,
nh_zvrf = zvrf;
if (!nh_zvrf) {
- vty_out(vty, "%% nexthop vrf %s is not defined\n",
- nexthop_vrf);
+ vty_out(vty, "%% nexthop vrf %s is not defined\n", nexthop_vrf);
return CMD_WARNING_CONFIG_FAILED;
}
- return zebra_static_route_leak(vty, zvrf, nh_zvrf,
- AFI_IP6, SAFI_UNICAST, no, prefix_str,
- NULL, from_str, gate_str, ifname, NULL,
- tag_str, distance_str, label);
+ return zebra_static_route_leak(
+ vty, zvrf, nh_zvrf, AFI_IP6, SAFI_UNICAST, no, prefix_str, NULL,
+ from_str, gate_str, ifname, NULL, tag_str, distance_str, label);
}
DEFPY(ipv6_route,
zvrf = zebra_vrf_lookup_by_name(vrf);
if (!zvrf) {
- vty_out(vty, "%% vrf %s is not defined\n",
- vrf);
+ vty_out(vty, "%% vrf %s is not defined\n", vrf);
return CMD_WARNING_CONFIG_FAILED;
}
nh_zvrf = zvrf;
if (!nh_zvrf) {
- vty_out(vty, "%% nexthop vrf %s is not defined\n",
- nexthop_vrf);
+ vty_out(vty, "%% nexthop vrf %s is not defined\n", nexthop_vrf);
return CMD_WARNING_CONFIG_FAILED;
}
- return zebra_static_route_leak(vty, zvrf, nh_zvrf,
- AFI_IP6, SAFI_UNICAST, no, prefix_str,
- NULL, from_str, gate_str, ifname, NULL,
- tag_str, distance_str, label);
+ return zebra_static_route_leak(
+ vty, zvrf, nh_zvrf, AFI_IP6, SAFI_UNICAST, no, prefix_str, NULL,
+ from_str, gate_str, ifname, NULL, tag_str, distance_str, label);
}
DEFPY(ipv6_route_vrf,
nh_zvrf = zvrf;
if (!nh_zvrf) {
- vty_out(vty, "%% nexthop vrf %s is not defined\n",
- nexthop_vrf);
+ vty_out(vty, "%% nexthop vrf %s is not defined\n", nexthop_vrf);
return CMD_WARNING_CONFIG_FAILED;
}
- return zebra_static_route_leak(vty, zvrf, nh_zvrf,
- AFI_IP6, SAFI_UNICAST, no, prefix_str,
- NULL, from_str, gate_str, ifname, NULL,
- tag_str, distance_str, label);
+ return zebra_static_route_leak(
+ vty, zvrf, nh_zvrf, AFI_IP6, SAFI_UNICAST, no, prefix_str, NULL,
+ from_str, gate_str, ifname, NULL, tag_str, distance_str, label);
}
/*
continue;
vty_out(vty, "vrf %s ", zvrf_name(zvrf));
- if (zvrf_id(zvrf) == VRF_UNKNOWN
- || !zvrf_is_active(zvrf))
+ if (zvrf_id(zvrf) == VRF_UNKNOWN || !zvrf_is_active(zvrf))
vty_out(vty, "inactive");
else if (zvrf_ns_name(zvrf))
- vty_out(vty, "id %u netns %s",
- zvrf_id(zvrf), zvrf_ns_name(zvrf));
+ vty_out(vty, "id %u netns %s", zvrf_id(zvrf),
+ zvrf_ns_name(zvrf));
else
vty_out(vty, "id %u table %u", zvrf_id(zvrf),
zvrf->table_id);
}
if (!uj)
- vty_out(vty, "%-37s %-10s %-20s %-20s %-5s %-18s\n",
- "VRF", "VNI", "VxLAN IF", "L3-SVI", "State", "Rmac");
+ vty_out(vty, "%-37s %-10s %-20s %-20s %-5s %-18s\n", "VRF",
+ "VNI", "VxLAN IF", "L3-SVI", "State", "Rmac");
- RB_FOREACH(vrf, vrf_name_head, &vrfs_by_name) {
+ RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
zvrf = vrf->info;
if (!zvrf)
continue;
"Work Queue\n"
"Time in milliseconds\n")
{
- uint32_t timer = strtoul(argv[2]->arg, NULL, 10);
- zebrad.ribq->spec.hold = timer;
+ uint32_t timer = strtoul(argv[2]->arg, NULL, 10);
+ zebrad.ribq->spec.hold = timer;
- return CMD_SUCCESS;
+ return CMD_SUCCESS;
}
DEFUN_HIDDEN (no_zebra_workqueue_timer,
"Work Queue\n"
"Time in milliseconds\n")
{
- zebrad.ribq->spec.hold = ZEBRA_RIB_PROCESS_HOLD_TIME;
+ zebrad.ribq->spec.hold = ZEBRA_RIB_PROCESS_HOLD_TIME;
- return CMD_SUCCESS;
+ return CMD_SUCCESS;
}
DEFUN (no_ip_zebra_import_table,
vty_out(vty, "zebra work-queue %u\n", zebrad.ribq->spec.hold);
if (zebrad.packets_to_process != ZEBRA_ZAPI_PACKETS_TO_PROCESS)
- vty_out(vty,
- "zebra zapi-packets %u\n", zebrad.packets_to_process);
+ vty_out(vty, "zebra zapi-packets %u\n",
+ zebrad.packets_to_process);
enum multicast_mode ipv4_multicast_mode = multicast_mode_ipv4_get();
vty_out(vty,
"VRF Installs Removals Updates Installs Removals\n");
- RB_FOREACH(vrf, vrf_name_head, &vrfs_by_name) {
+ RB_FOREACH (vrf, vrf_name_head, &vrfs_by_name) {
struct zebra_vrf *zvrf = vrf->info;
vty_out(vty, "%-25s %10" PRIu64 " %10" PRIu64 " %10" PRIu64
install_element(CONFIG_NODE, &no_default_vrf_vni_mapping_cmd);
install_element(VRF_NODE, &vrf_vni_mapping_cmd);
install_element(VRF_NODE, &no_vrf_vni_mapping_cmd);
-
}
/* static function declarations */
-static int ip_prefix_send_to_client(vrf_id_t vrf_id,
- struct prefix *p,
- uint16_t cmd);
+static int ip_prefix_send_to_client(vrf_id_t vrf_id, struct prefix *p,
+ uint16_t cmd);
static void zvni_print_neigh(zebra_neigh_t *n, void *ctxt, json_object *json);
static void zvni_print_neigh_hash(struct hash_backet *backet, void *ctxt);
static void zvni_print_neigh_hash_all_vni(struct hash_backet *backet,
static void zvni_print(zebra_vni_t *zvni, void **ctxt);
static void zvni_print_hash(struct hash_backet *backet, void *ctxt[]);
-static int zvni_macip_send_msg_to_client(vni_t vni,
- struct ethaddr *macaddr,
+static int zvni_macip_send_msg_to_client(vni_t vni, struct ethaddr *macaddr,
struct ipaddr *ip, u_char flags,
u_int16_t cmd);
static unsigned int neigh_hash_keymake(void *p);
static int zvni_neigh_del_hash_entry(struct hash_backet *backet, void *arg);
static void zvni_neigh_del_from_vtep(zebra_vni_t *zvni, int uninstall,
struct in_addr *r_vtep_ip);
-static void zvni_neigh_del_all(zebra_vni_t *zvni,
- int uninstall, int upd_client, u_int32_t flags);
+static void zvni_neigh_del_all(zebra_vni_t *zvni, int uninstall, int upd_client,
+ u_int32_t flags);
static zebra_neigh_t *zvni_neigh_lookup(zebra_vni_t *zvni, struct ipaddr *ip);
-static int zvni_neigh_send_add_to_client(vni_t vni,
- struct ipaddr *ip,
+static int zvni_neigh_send_add_to_client(vni_t vni, struct ipaddr *ip,
struct ethaddr *macaddr, u_char flags);
-static int zvni_neigh_send_del_to_client(vni_t vni,
- struct ipaddr *ip,
+static int zvni_neigh_send_del_to_client(vni_t vni, struct ipaddr *ip,
struct ethaddr *macaddr, u_char flags);
static int zvni_neigh_install(zebra_vni_t *zvni, zebra_neigh_t *n);
static int zvni_neigh_uninstall(zebra_vni_t *zvni, zebra_neigh_t *n);
static zebra_vni_t *zvni_from_svi(struct interface *ifp,
- struct interface *br_if);
-static struct interface *zvni_map_to_svi(vlanid_t vid,
- struct interface *br_if);
+ struct interface *br_if);
+static struct interface *zvni_map_to_svi(vlanid_t vid, struct interface *br_if);
/* l3-vni next-hop neigh related APIs */
static zebra_neigh_t *zl3vni_nh_lookup(zebra_l3vni_t *zl3vni,
struct ethaddr *rmac);
static int zl3vni_rmac_del(zebra_l3vni_t *zl3vni, zebra_mac_t *zrmac);
static int zl3vni_rmac_install(zebra_l3vni_t *zl3vni, zebra_mac_t *zrmac);
-static int zl3vni_rmac_uninstall(zebra_l3vni_t *zl3vni,
- zebra_mac_t *zrmac);
+static int zl3vni_rmac_uninstall(zebra_l3vni_t *zl3vni, zebra_mac_t *zrmac);
/* l3-vni related APIs*/
static zebra_l3vni_t *zl3vni_lookup(vni_t vni);
static int zvni_mac_del_hash_entry(struct hash_backet *backet, void *arg);
static void zvni_mac_del_from_vtep(zebra_vni_t *zvni, int uninstall,
struct in_addr *r_vtep_ip);
-static void zvni_mac_del_all(zebra_vni_t *zvni,
- int uninstall, int upd_client, u_int32_t flags);
+static void zvni_mac_del_all(zebra_vni_t *zvni, int uninstall, int upd_client,
+ u_int32_t flags);
static zebra_mac_t *zvni_mac_lookup(zebra_vni_t *zvni, struct ethaddr *macaddr);
-static int zvni_mac_send_add_to_client(vni_t vni,
- struct ethaddr *macaddr, u_char flags);
-static int zvni_mac_send_del_to_client(vni_t vni,
- struct ethaddr *macaddr, u_char flags);
+static int zvni_mac_send_add_to_client(vni_t vni, struct ethaddr *macaddr,
+ u_char flags);
+static int zvni_mac_send_del_to_client(vni_t vni, struct ethaddr *macaddr,
+ u_char flags);
static zebra_vni_t *zvni_map_vlan(struct interface *ifp,
struct interface *br_if, vlanid_t vid);
static int zvni_mac_install(zebra_vni_t *zvni, zebra_mac_t *mac);
}
/* print a specific next hop for an l3vni */
-static void zl3vni_print_nh(zebra_neigh_t *n,
- struct vty *vty,
+static void zl3vni_print_nh(zebra_neigh_t *n, struct vty *vty,
json_object *json)
{
char buf1[ETHER_ADDR_STRLEN];
vty_out(vty, "Ip: %s\n",
ipaddr2str(&n->ip, buf2, sizeof(buf2)));
vty_out(vty, " RMAC: %s\n",
- prefix_mac2str(&n->emac, buf1, sizeof(buf1)));
+ prefix_mac2str(&n->emac, buf1, sizeof(buf1)));
vty_out(vty, " Refcount: %d\n", listcount(n->host_list));
vty_out(vty, " Prefixes:\n");
for (ALL_LIST_ELEMENTS_RO(n->host_list, node, p))
prefix2str(p, buf2, sizeof(buf2)));
} else {
json_hosts = json_object_new_array();
- json_object_string_add(json, "ip",
- ipaddr2str(&(n->ip), buf2,
- sizeof(buf2)));
- json_object_string_add(json, "routerMac",
- prefix_mac2str(&n->emac, buf2,
- sizeof(buf2)));
+ json_object_string_add(
+ json, "ip", ipaddr2str(&(n->ip), buf2, sizeof(buf2)));
+ json_object_string_add(
+ json, "routerMac",
+ prefix_mac2str(&n->emac, buf2, sizeof(buf2)));
json_object_int_add(json, "refCount", listcount(n->host_list));
for (ALL_LIST_ELEMENTS_RO(n->host_list, node, p))
json_object_array_add(json_hosts,
- json_object_new_string(
- prefix2str(p, buf2,
- sizeof(buf2))));
+ json_object_new_string(prefix2str(
+ p, buf2, sizeof(buf2))));
json_object_object_add(json, "prefixList", json_hosts);
}
}
/* Print a specific RMAC entry */
-static void zl3vni_print_rmac(zebra_mac_t *zrmac,
- struct vty *vty,
+static void zl3vni_print_rmac(zebra_mac_t *zrmac, struct vty *vty,
json_object *json)
{
char buf1[ETHER_ADDR_STRLEN];
prefix2str(p, buf2, sizeof(buf2)));
} else {
json_hosts = json_object_new_array();
- json_object_string_add(json, "routerMac",
- prefix_mac2str(&zrmac->macaddr,
- buf1,
- sizeof(buf1)));
+ json_object_string_add(
+ json, "routerMac",
+ prefix_mac2str(&zrmac->macaddr, buf1, sizeof(buf1)));
json_object_string_add(json, "vtepIp",
inet_ntoa(zrmac->fwd_info.r_vtep_ip));
json_object_int_add(json, "refCount",
listcount(zrmac->host_list));
for (ALL_LIST_ELEMENTS_RO(zrmac->host_list, node, p))
json_object_array_add(json_hosts,
- json_object_new_string(
- prefix2str(p, buf2,
- sizeof(buf2))));
+ json_object_new_string(prefix2str(
+ p, buf2, sizeof(buf2))));
json_object_object_add(json, "prefixList", json_hosts);
}
}
}
}
-static void zl3vni_print_nh_hash(struct hash_backet *backet,
- void *ctx)
+static void zl3vni_print_nh_hash(struct hash_backet *backet, void *ctx)
{
struct nh_walk_ctx *wctx = NULL;
struct vty *vty = NULL;
} else {
json_object_string_add(json_nh, "nexthopIp",
ipaddr2str(&n->ip, buf2, sizeof(buf2)));
- json_object_string_add(json_nh, "routerMac",
- prefix_mac2str(&n->emac, buf1,
- sizeof(buf1)));
+ json_object_string_add(
+ json_nh, "routerMac",
+ prefix_mac2str(&n->emac, buf1, sizeof(buf1)));
json_object_object_add(json_vni,
ipaddr2str(&(n->ip), buf2, sizeof(buf2)),
json_nh);
}
if (json == NULL) {
- vty_out(vty, "\nVNI %u #Next-Hops %u\n\n",
- zl3vni->vni, num_nh);
+ vty_out(vty, "\nVNI %u #Next-Hops %u\n\n", zl3vni->vni, num_nh);
vty_out(vty, "%-15s %-17s\n", "IP", "RMAC");
} else
json_object_int_add(json_vni, "numNextHops", num_nh);
}
if (json == NULL) {
- vty_out(vty, "\nVNI %u #RMACs %u\n\n",
- zl3vni->vni, num_rmacs);
+ vty_out(vty, "\nVNI %u #RMACs %u\n\n", zl3vni->vni, num_rmacs);
vty_out(vty, "%-17s %-21s\n", "RMAC", "Remote VTEP");
} else
json_object_int_add(json_vni, "numRmacs", num_rmacs);
json_object_object_add(json, vni_str, json_vni);
}
-static void zl3vni_print_rmac_hash(struct hash_backet *backet,
- void *ctx)
+static void zl3vni_print_rmac_hash(struct hash_backet *backet, void *ctx)
{
zebra_mac_t *zrmac = NULL;
struct rmac_walk_ctx *wctx = NULL;
if (!json) {
vty_out(vty, "%-17s %-21s\n",
prefix_mac2str(&zrmac->macaddr, buf, sizeof(buf)),
- inet_ntoa(zrmac->fwd_info.r_vtep_ip));
+ inet_ntoa(zrmac->fwd_info.r_vtep_ip));
} else {
- json_object_string_add(json_rmac, "routerMac",
- prefix_mac2str(&zrmac->macaddr, buf,
- sizeof(buf)));
+ json_object_string_add(
+ json_rmac, "routerMac",
+ prefix_mac2str(&zrmac->macaddr, buf, sizeof(buf)));
json_object_string_add(json_rmac, "vtepIp",
inet_ntoa(zrmac->fwd_info.r_vtep_ip));
- json_object_object_add(json,
- prefix_mac2str(&zrmac->macaddr, buf,
- sizeof(buf)),
- json_rmac);
+ json_object_object_add(
+ json, prefix_mac2str(&zrmac->macaddr, buf, sizeof(buf)),
+ json_rmac);
}
}
if (!json) {
vty_out(vty, "VNI: %u\n", zl3vni->vni);
vty_out(vty, " Type: %s\n", "L3");
- vty_out(vty, " Tenant VRF: %s\n",
- zl3vni_vrf_name(zl3vni));
+ vty_out(vty, " Tenant VRF: %s\n", zl3vni_vrf_name(zl3vni));
vty_out(vty, " Local Vtep Ip: %s\n",
inet_ntoa(zl3vni->local_vtep_ip));
vty_out(vty, " Vxlan-Intf: %s\n",
zl3vni_vxlan_if_name(zl3vni));
- vty_out(vty, " SVI-If: %s\n",
- zl3vni_svi_if_name(zl3vni));
- vty_out(vty, " State: %s\n",
- zl3vni_state2str(zl3vni));
+ vty_out(vty, " SVI-If: %s\n", zl3vni_svi_if_name(zl3vni));
+ vty_out(vty, " State: %s\n", zl3vni_state2str(zl3vni));
vty_out(vty, " VNI Filter: %s\n",
- CHECK_FLAG(zl3vni->filter, PREFIX_ROUTES_ONLY) ?
- "prefix-routes-only" : "none");
+ CHECK_FLAG(zl3vni->filter, PREFIX_ROUTES_ONLY)
+ ? "prefix-routes-only"
+ : "none");
vty_out(vty, " Router MAC: %s\n",
zl3vni_rmac2str(zl3vni, buf, sizeof(buf)));
vty_out(vty, " L2 VNIs: ");
zl3vni_vxlan_if_name(zl3vni));
json_object_string_add(json, "sviIntf",
zl3vni_svi_if_name(zl3vni));
- json_object_string_add(json, "state",
- zl3vni_state2str(zl3vni));
- json_object_string_add(json, "vrf",
- zl3vni_vrf_name(zl3vni));
- json_object_string_add(json, "routerMac",
- zl3vni_rmac2str(zl3vni, buf,
- sizeof(buf)));
- json_object_string_add(json, "vniFilter",
- CHECK_FLAG(zl3vni->filter,
- PREFIX_ROUTES_ONLY) ?
- "prefix-routes-only" : "none");
+ json_object_string_add(json, "state", zl3vni_state2str(zl3vni));
+ json_object_string_add(json, "vrf", zl3vni_vrf_name(zl3vni));
+ json_object_string_add(
+ json, "routerMac",
+ zl3vni_rmac2str(zl3vni, buf, sizeof(buf)));
+ json_object_string_add(
+ json, "vniFilter",
+ CHECK_FLAG(zl3vni->filter, PREFIX_ROUTES_ONLY)
+ ? "prefix-routes-only"
+ : "none");
for (ALL_LIST_ELEMENTS(zl3vni->l2vnis, node, nnode, zvni)) {
json_object_array_add(json_vni_list,
json_object_new_int(zvni->vni));
num_macs = num_valid_macs(zvni);
num_neigh = hashcount(zvni->neigh_table);
if (json == NULL) {
- vty_out(vty, " VxLAN interface: %s\n",
- zvni->vxlan_if->name);
+ vty_out(vty, " VxLAN interface: %s\n", zvni->vxlan_if->name);
vty_out(vty, " VxLAN ifIndex: %u\n", zvni->vxlan_if->ifindex);
- vty_out(vty," Local VTEP IP: %s\n",
+ vty_out(vty, " Local VTEP IP: %s\n",
inet_ntoa(zvni->local_vtep_ip));
} else {
json_object_string_add(json, "vxlanInterface",
}
/* print a L3 VNI hash entry */
-static void zl3vni_print_hash(struct hash_backet *backet,
- void *ctx[])
+static void zl3vni_print_hash(struct hash_backet *backet, void *ctx[])
{
struct vty *vty = NULL;
json_object *json = NULL;
return;
if (!json) {
- vty_out(vty,
- "%-10u %-4s %-21s %-8lu %-8lu %-15s %-37s\n",
- zl3vni->vni, "L3",
- zl3vni_vxlan_if_name(zl3vni),
+ vty_out(vty, "%-10u %-4s %-21s %-8lu %-8lu %-15s %-37s\n",
+ zl3vni->vni, "L3", zl3vni_vxlan_if_name(zl3vni),
hashcount(zl3vni->rmac_table),
- hashcount(zl3vni->nh_table),
- "n/a",
+ hashcount(zl3vni->nh_table), "n/a",
zl3vni_vrf_name(zl3vni));
} else {
char vni_str[VNI_STR_LEN];
zl3vni_vrf_name(zl3vni));
json_object_object_add(json, vni_str, json_vni);
}
-
}
/*
num_macs = num_valid_macs(zvni);
num_neigh = hashcount(zvni->neigh_table);
if (json == NULL)
- vty_out(vty,
- "%-10u %-4s %-21s %-8u %-8u %-15u %-37s\n",
+ vty_out(vty, "%-10u %-4s %-21s %-8u %-8u %-15u %-37s\n",
zvni->vni, "L2",
zvni->vxlan_if ? zvni->vxlan_if->name : "unknown",
- num_macs, num_neigh,
- num_vteps,
+ num_macs, num_neigh, num_vteps,
vrf_id_to_name(zvni->vrf_id));
else {
char vni_str[VNI_STR_LEN];
/*
* Inform BGP about local MACIP.
*/
-static int zvni_macip_send_msg_to_client(vni_t vni,
- struct ethaddr *macaddr,
+static int zvni_macip_send_msg_to_client(vni_t vni, struct ethaddr *macaddr,
struct ipaddr *ip, u_char flags,
u_int16_t cmd)
{
if (IS_ZEBRA_DEBUG_VXLAN)
zlog_debug(
"Send MACIP %s flags 0x%x MAC %s IP %s L2-VNI %u to %s",
- (cmd == ZEBRA_MACIP_ADD) ? "Add" : "Del",
- flags, prefix_mac2str(macaddr, buf, sizeof(buf)),
+ (cmd == ZEBRA_MACIP_ADD) ? "Add" : "Del", flags,
+ prefix_mac2str(macaddr, buf, sizeof(buf)),
ipaddr2str(ip, buf2, sizeof(buf2)), vni,
zebra_route_string(client->proto));
/*
* Delete all neighbor entries for this VNI.
*/
-static void zvni_neigh_del_all(zebra_vni_t *zvni,
- int uninstall, int upd_client, u_int32_t flags)
+static void zvni_neigh_del_all(zebra_vni_t *zvni, int uninstall, int upd_client,
+ u_int32_t flags)
{
struct neigh_walk_ctx wctx;
zvni->vni);
ZEBRA_NEIGH_SET_INACTIVE(n);
- zvni_neigh_send_del_to_client(
- zvni->vni, &n->ip, &n->emac, 0);
+ zvni_neigh_send_del_to_client(zvni->vni, &n->ip,
+ &n->emac, 0);
}
} else if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_REMOTE)) {
if (IS_ZEBRA_DEBUG_VXLAN)
zvni->vni);
ZEBRA_NEIGH_SET_INACTIVE(n);
- zvni_neigh_send_del_to_client(
- zvni->vni, &n->ip, &n->emac, 0);
+ zvni_neigh_send_del_to_client(zvni->vni, &n->ip,
+ &n->emac, 0);
}
}
}
/*
* Inform BGP about local neighbor addition.
*/
-static int zvni_neigh_send_add_to_client(vni_t vni,
- struct ipaddr *ip,
+static int zvni_neigh_send_add_to_client(vni_t vni, struct ipaddr *ip,
struct ethaddr *macaddr,
u_char neigh_flags)
{
- u_char flags = 0;
+ u_char flags = 0;
if (CHECK_FLAG(neigh_flags, ZEBRA_NEIGH_DEF_GW))
SET_FLAG(flags, ZEBRA_MACIP_TYPE_GW);
/*
* Inform BGP about local neighbor deletion.
*/
-static int zvni_neigh_send_del_to_client(vni_t vni,
- struct ipaddr *ip,
+static int zvni_neigh_send_del_to_client(vni_t vni, struct ipaddr *ip,
struct ethaddr *macaddr, u_char flags)
{
return zvni_macip_send_msg_to_client(vni, macaddr, ip, flags,
}
-static int zvni_advertise_subnet(zebra_vni_t *zvni,
- struct interface *ifp,
+static int zvni_advertise_subnet(zebra_vni_t *zvni, struct interface *ifp,
int advertise)
{
struct listnode *cnode = NULL, *cnnode = NULL;
apply_mask(&p);
if (advertise)
ip_prefix_send_to_client(ifp->vrf_id, &p,
- ZEBRA_IP_PREFIX_ROUTE_ADD);
+ ZEBRA_IP_PREFIX_ROUTE_ADD);
else
ip_prefix_send_to_client(ifp->vrf_id, &p,
ZEBRA_IP_PREFIX_ROUTE_DEL);
prefix_mac2str(macaddr, buf, sizeof(buf)),
ipaddr2str(ip, buf2, sizeof(buf2)));
- zvni_neigh_send_add_to_client(zvni->vni, ip, macaddr,
- n->flags);
+ zvni_neigh_send_add_to_client(zvni->vni, ip, macaddr, n->flags);
return 0;
}
/* only need to delete the entry from bgp if we sent it before */
if (IS_ZEBRA_DEBUG_VXLAN)
- zlog_debug("%u:SVI %s(%u) VNI %u, sending GW MAC %s IP %s del to BGP",
- ifp->vrf_id, ifp->name,
- ifp->ifindex, zvni->vni,
- prefix_mac2str(&(n->emac),
- NULL,
- ETHER_ADDR_STRLEN),
- ipaddr2str(ip, buf2, sizeof(buf2)));
+ zlog_debug(
+ "%u:SVI %s(%u) VNI %u, sending GW MAC %s IP %s del to BGP",
+ ifp->vrf_id, ifp->name, ifp->ifindex, zvni->vni,
+ prefix_mac2str(&(n->emac), NULL, ETHER_ADDR_STRLEN),
+ ipaddr2str(ip, buf2, sizeof(buf2)));
/* Remove neighbor from BGP. */
zvni_neigh_send_del_to_client(zvni->vni, &n->ip, &n->emac,
zl2_info = zif->l2info.vxl;
- vlan_if = zvni_map_to_svi(zl2_info.access_vlan, zif->brslave_info.br_if);
+ vlan_if =
+ zvni_map_to_svi(zl2_info.access_vlan, zif->brslave_info.br_if);
if (!vlan_if)
return;
return;
zl2_info = zif->l2info.vxl;
- vlan_if = zvni_map_to_svi(zl2_info.access_vlan,
- zif->brslave_info.br_if);
+ vlan_if =
+ zvni_map_to_svi(zl2_info.access_vlan, zif->brslave_info.br_if);
if (!vlan_if)
return;
if (pmac1 == NULL || pmac2 == NULL)
return 0;
- return (memcmp(pmac1->macaddr.octet, pmac2->macaddr.octet,
- ETH_ALEN)
+ return (memcmp(pmac1->macaddr.octet, pmac2->macaddr.octet, ETH_ALEN)
== 0);
}
&& IPV4_ADDR_SAME(&mac->fwd_info.r_vtep_ip,
&wctx->r_vtep_ip))) {
if (wctx->upd_client && (mac->flags & ZEBRA_MAC_LOCAL)) {
- zvni_mac_send_del_to_client(
- wctx->zvni->vni, &mac->macaddr,
- mac->flags);
+ zvni_mac_send_del_to_client(wctx->zvni->vni,
+ &mac->macaddr, mac->flags);
}
if (wctx->uninstall)
/*
* Delete all MAC entries for this VNI.
*/
-static void zvni_mac_del_all(zebra_vni_t *zvni,
- int uninstall, int upd_client, u_int32_t flags)
+static void zvni_mac_del_all(zebra_vni_t *zvni, int uninstall, int upd_client,
+ u_int32_t flags)
{
struct mac_walk_ctx wctx;
/*
* Inform BGP about local MAC addition.
*/
-static int zvni_mac_send_add_to_client(vni_t vni,
- struct ethaddr *macaddr,
+static int zvni_mac_send_add_to_client(vni_t vni, struct ethaddr *macaddr,
u_char mac_flags)
{
- u_char flags = 0;
+ u_char flags = 0;
if (CHECK_FLAG(mac_flags, ZEBRA_MAC_STICKY))
SET_FLAG(flags, ZEBRA_MACIP_TYPE_STICKY);
/*
* Inform BGP about local MAC deletion.
*/
-static int zvni_mac_send_del_to_client(vni_t vni,
- struct ethaddr *macaddr,
+static int zvni_mac_send_del_to_client(vni_t vni, struct ethaddr *macaddr,
u_char mac_flags)
{
- u_char flags = 0;
+ u_char flags = 0;
if (CHECK_FLAG(mac_flags, ZEBRA_MAC_STICKY))
SET_FLAG(flags, ZEBRA_MACIP_TYPE_STICKY);
/*
* Read and populate local MACs and neighbors corresponding to this VNI.
*/
-static void zvni_read_mac_neigh(zebra_vni_t *zvni,
- struct interface *ifp)
+static void zvni_read_mac_neigh(zebra_vni_t *zvni, struct interface *ifp)
{
struct zebra_ns *zns;
struct zebra_if *zif;
stream_putw_at(s, 0, stream_get_endp(s));
if (IS_ZEBRA_DEBUG_VXLAN)
- zlog_debug("Send VNI_ADD %u %s tenant vrf %s to %s",
- zvni->vni, inet_ntoa(zvni->local_vtep_ip),
+ zlog_debug("Send VNI_ADD %u %s tenant vrf %s to %s", zvni->vni,
+ inet_ntoa(zvni->local_vtep_ip),
vrf_id_to_name(zvni->vrf_id),
zebra_route_string(client->proto));
if (zl3vni) {
if (IS_ZEBRA_DEBUG_VXLAN)
- zlog_debug("create L3-VNI hash for Intf %s(%u) L3-VNI %u",
- ifp->name, ifp->ifindex, vni);
+ zlog_debug(
+ "create L3-VNI hash for Intf %s(%u) L3-VNI %u",
+ ifp->name, ifp->ifindex, vni);
/* associate with vxlan_if */
zl3vni->local_vtep_ip = vxl->vtep_ip;
}
/* cleanup L3VNI */
-static void zl3vni_cleanup_all(struct hash_backet *backet,
- void *args)
+static void zl3vni_cleanup_all(struct hash_backet *backet, void *args)
{
zebra_l3vni_t *zl3vni = NULL;
zebra_vxlan_process_l3vni_oper_down(zl3vni);
}
-static int is_host_present_in_host_list(struct list *list,
- struct prefix *host)
+static int is_host_present_in_host_list(struct list *list, struct prefix *host)
{
struct listnode *node = NULL;
struct prefix *p = NULL;
return 0;
}
-static void host_list_add_host(struct list *list,
- struct prefix *host)
+static void host_list_add_host(struct list *list, struct prefix *host)
{
struct prefix *p = NULL;
listnode_add_sort(list, p);
}
-static void host_list_delete_host(struct list *list,
- struct prefix *host)
+static void host_list_delete_host(struct list *list, struct prefix *host)
{
struct listnode *node = NULL, *nnode = NULL, *node_to_del = NULL;
struct prefix *p = NULL;
/*
* Add RMAC entry to l3-vni
*/
-static zebra_mac_t *zl3vni_rmac_add(zebra_l3vni_t *zl3vni,
- struct ethaddr *rmac)
+static zebra_mac_t *zl3vni_rmac_add(zebra_l3vni_t *zl3vni, struct ethaddr *rmac)
{
zebra_mac_t tmp_rmac;
zebra_mac_t *zrmac = NULL;
/*
* Delete MAC entry.
*/
-static int zl3vni_rmac_del(zebra_l3vni_t *zl3vni,
- zebra_mac_t *zrmac)
+static int zl3vni_rmac_del(zebra_l3vni_t *zl3vni, zebra_mac_t *zrmac)
{
zebra_mac_t *tmp_rmac;
/*
* Install remote RMAC into the kernel.
*/
-static int zl3vni_rmac_install(zebra_l3vni_t *zl3vni,
- zebra_mac_t *zrmac)
+static int zl3vni_rmac_install(zebra_l3vni_t *zl3vni, zebra_mac_t *zrmac)
{
struct zebra_if *zif = NULL;
struct zebra_l2info_vxlan *vxl = NULL;
- if (!(CHECK_FLAG(zrmac->flags, ZEBRA_MAC_REMOTE)) ||
- !(CHECK_FLAG(zrmac->flags, ZEBRA_MAC_REMOTE_RMAC)))
+ if (!(CHECK_FLAG(zrmac->flags, ZEBRA_MAC_REMOTE))
+ || !(CHECK_FLAG(zrmac->flags, ZEBRA_MAC_REMOTE_RMAC)))
return 0;
zif = zl3vni->vxlan_if->info;
vxl = &zif->l2info.vxl;
return kernel_add_mac(zl3vni->vxlan_if, vxl->access_vlan,
- &zrmac->macaddr,
- zrmac->fwd_info.r_vtep_ip, 0);
+ &zrmac->macaddr, zrmac->fwd_info.r_vtep_ip, 0);
}
/*
* Uninstall remote RMAC from the kernel.
*/
-static int zl3vni_rmac_uninstall(zebra_l3vni_t *zl3vni,
- zebra_mac_t *zrmac)
+static int zl3vni_rmac_uninstall(zebra_l3vni_t *zl3vni, zebra_mac_t *zrmac)
{
char buf[ETHER_ADDR_STRLEN];
struct zebra_if *zif = NULL;
struct zebra_l2info_vxlan *vxl = NULL;
- if (!(CHECK_FLAG(zrmac->flags, ZEBRA_MAC_REMOTE)) ||
- !(CHECK_FLAG(zrmac->flags, ZEBRA_MAC_REMOTE_RMAC)))
+ if (!(CHECK_FLAG(zrmac->flags, ZEBRA_MAC_REMOTE))
+ || !(CHECK_FLAG(zrmac->flags, ZEBRA_MAC_REMOTE_RMAC)))
return 0;
if (!zl3vni->vxlan_if) {
zlog_err(
- "RMAC %s on L3-VNI %u hash %p couldn't be uninstalled - no vxlan_if",
- prefix_mac2str(&zrmac->macaddr, buf, sizeof(buf)),
- zl3vni->vni, zl3vni);
+ "RMAC %s on L3-VNI %u hash %p couldn't be uninstalled - no vxlan_if",
+ prefix_mac2str(&zrmac->macaddr, buf, sizeof(buf)),
+ zl3vni->vni, zl3vni);
return -1;
}
}
/* handle rmac add */
-static int zl3vni_remote_rmac_add(zebra_l3vni_t *zl3vni,
- struct ethaddr *rmac,
+static int zl3vni_remote_rmac_add(zebra_l3vni_t *zl3vni, struct ethaddr *rmac,
struct ipaddr *vtep_ip,
struct prefix *host_prefix)
{
if (!zrmac) {
zlog_warn(
"Failed to add RMAC %s L3VNI %u Remote VTEP %s",
- prefix_mac2str(rmac, buf,
- sizeof(buf)),
- zl3vni->vni, ipaddr2str(vtep_ip, buf1,
- sizeof(buf1)));
+ prefix_mac2str(rmac, buf, sizeof(buf)),
+ zl3vni->vni,
+ ipaddr2str(vtep_ip, buf1, sizeof(buf1)));
return -1;
}
memset(&zrmac->fwd_info, 0, sizeof(zrmac->fwd_info));
/* handle rmac delete */
-static int zl3vni_remote_rmac_del(zebra_l3vni_t *zl3vni,
- struct ethaddr *rmac,
+static int zl3vni_remote_rmac_del(zebra_l3vni_t *zl3vni, struct ethaddr *rmac,
struct prefix *host_prefix)
{
zebra_mac_t *zrmac = NULL;
/*
* Look up nh hash entry on a l3-vni.
*/
-static zebra_neigh_t *zl3vni_nh_lookup(zebra_l3vni_t *zl3vni,
- struct ipaddr *ip)
+static zebra_neigh_t *zl3vni_nh_lookup(zebra_l3vni_t *zl3vni, struct ipaddr *ip)
{
zebra_neigh_t tmp;
zebra_neigh_t *n;
/*
* Add neighbor entry.
*/
-static zebra_neigh_t *zl3vni_nh_add(zebra_l3vni_t *zl3vni,
- struct ipaddr *ip,
+static zebra_neigh_t *zl3vni_nh_add(zebra_l3vni_t *zl3vni, struct ipaddr *ip,
struct ethaddr *mac)
{
zebra_neigh_t tmp_n;
/*
* Delete neighbor entry.
*/
-static int zl3vni_nh_del(zebra_l3vni_t *zl3vni,
- zebra_neigh_t *n)
+static int zl3vni_nh_del(zebra_l3vni_t *zl3vni, zebra_neigh_t *n)
{
zebra_neigh_t *tmp_n;
/*
* Install remote nh as neigh into the kernel.
*/
-static int zl3vni_nh_install(zebra_l3vni_t *zl3vni,
- zebra_neigh_t *n)
+static int zl3vni_nh_install(zebra_l3vni_t *zl3vni, zebra_neigh_t *n)
{
if (!is_l3vni_oper_up(zl3vni))
return -1;
- if (!(n->flags & ZEBRA_NEIGH_REMOTE) ||
- !(n->flags & ZEBRA_NEIGH_REMOTE_NH))
+ if (!(n->flags & ZEBRA_NEIGH_REMOTE)
+ || !(n->flags & ZEBRA_NEIGH_REMOTE_NH))
return 0;
return kernel_add_neigh(zl3vni->svi_if, &n->ip, &n->emac);
/*
* Uninstall remote nh from the kernel.
*/
-static int zl3vni_nh_uninstall(zebra_l3vni_t *zl3vni,
- zebra_neigh_t *n)
+static int zl3vni_nh_uninstall(zebra_l3vni_t *zl3vni, zebra_neigh_t *n)
{
- if (!(n->flags & ZEBRA_NEIGH_REMOTE) ||
- !(n->flags & ZEBRA_NEIGH_REMOTE_NH))
+ if (!(n->flags & ZEBRA_NEIGH_REMOTE)
+ || !(n->flags & ZEBRA_NEIGH_REMOTE_NH))
return 0;
if (!zl3vni->svi_if || !if_is_operative(zl3vni->svi_if))
}
/* add remote vtep as a neigh entry */
-static int zl3vni_remote_nh_add(zebra_l3vni_t *zl3vni,
- struct ipaddr *vtep_ip,
+static int zl3vni_remote_nh_add(zebra_l3vni_t *zl3vni, struct ipaddr *vtep_ip,
struct ethaddr *rmac,
struct prefix *host_prefix)
{
zlog_warn(
"Failed to add NH as Neigh (IP %s MAC %s L3-VNI %u)",
- ipaddr2str(vtep_ip, buf1,
- sizeof(buf1)),
- prefix_mac2str(rmac, buf,
- sizeof(buf)),
+ ipaddr2str(vtep_ip, buf1, sizeof(buf1)),
+ prefix_mac2str(rmac, buf, sizeof(buf)),
zl3vni->vni);
return -1;
}
}
/* handle nh neigh delete */
-static int zl3vni_remote_nh_del(zebra_l3vni_t *zl3vni,
- struct ipaddr *vtep_ip,
+static int zl3vni_remote_nh_del(zebra_l3vni_t *zl3vni, struct ipaddr *vtep_ip,
struct prefix *host_prefix)
{
zebra_neigh_t *nh = NULL;
/* handle neigh update from kernel - the only thing of interest is to
* readd stale entries.
*/
-static int zl3vni_local_nh_add_update(zebra_l3vni_t *zl3vni,
- struct ipaddr *ip, u_int16_t state)
+static int zl3vni_local_nh_add_update(zebra_l3vni_t *zl3vni, struct ipaddr *ip,
+ u_int16_t state)
{
#ifdef GNU_LINUX
zebra_neigh_t *n = NULL;
}
/* handle neigh delete from kernel */
-static int zl3vni_local_nh_del(zebra_l3vni_t *zl3vni,
- struct ipaddr *ip)
+static int zl3vni_local_nh_del(zebra_l3vni_t *zl3vni, struct ipaddr *ip)
{
zebra_neigh_t *n = NULL;
zl3vni->l2vnis->cmp = (int (*)(void *, void *))vni_hash_cmp;
/* Create hash table for remote RMAC */
- zl3vni->rmac_table =
- hash_create(mac_hash_keymake, mac_cmp,
- "Zebra L3-VNI RMAC-Table");
+ zl3vni->rmac_table = hash_create(mac_hash_keymake, mac_cmp,
+ "Zebra L3-VNI RMAC-Table");
/* Create hash table for neighbors */
zl3vni->nh_table = hash_create(neigh_hash_keymake, neigh_cmp,
- "Zebra L3-VNI next-hop table");
+ "Zebra L3-VNI next-hop table");
return zl3vni;
}
static struct interface *zl3vni_map_to_svi_if(zebra_l3vni_t *zl3vni)
{
- struct zebra_if *zif = NULL; /* zebra_if for vxlan_if */
+ struct zebra_if *zif = NULL; /* zebra_if for vxlan_if */
struct zebra_l2info_vxlan *vxl = NULL; /* l2 info for vxlan_if */
if (!zl3vni)
s = client->obuf;
stream_reset(s);
- zclient_create_header(s, ZEBRA_L3VNI_ADD,
- zl3vni_vrf_id(zl3vni));
+ zclient_create_header(s, ZEBRA_L3VNI_ADD, zl3vni_vrf_id(zl3vni));
stream_putl(s, zl3vni->vni);
stream_put(s, &rmac, sizeof(struct ethaddr));
stream_put_in_addr(s, &zl3vni->local_vtep_ip);
if (IS_ZEBRA_DEBUG_VXLAN)
zlog_debug(
- "Send L3_VNI_ADD %u VRF %s RMAC %s local-ip %s filter %s to %s",
- zl3vni->vni, vrf_id_to_name(zl3vni_vrf_id(zl3vni)),
- prefix_mac2str(&rmac, buf, sizeof(buf)),
- inet_ntoa(zl3vni->local_vtep_ip),
- CHECK_FLAG(zl3vni->filter, PREFIX_ROUTES_ONLY) ?
- "prefix-routes-only" : "none",
- zebra_route_string(client->proto));
+ "Send L3_VNI_ADD %u VRF %s RMAC %s local-ip %s filter %s to %s",
+ zl3vni->vni, vrf_id_to_name(zl3vni_vrf_id(zl3vni)),
+ prefix_mac2str(&rmac, buf, sizeof(buf)),
+ inet_ntoa(zl3vni->local_vtep_ip),
+ CHECK_FLAG(zl3vni->filter, PREFIX_ROUTES_ONLY)
+ ? "prefix-routes-only"
+ : "none",
+ zebra_route_string(client->proto));
client->l3vniadd_cnt++;
return zebra_server_send_message(client);
s = client->obuf;
stream_reset(s);
- zclient_create_header(s, ZEBRA_L3VNI_DEL,
- zl3vni_vrf_id(zl3vni));
+ zclient_create_header(s, ZEBRA_L3VNI_DEL, zl3vni_vrf_id(zl3vni));
stream_putl(s, zl3vni->vni);
/* Write packet size. */
stream_putw_at(s, 0, stream_get_endp(s));
if (IS_ZEBRA_DEBUG_VXLAN)
- zlog_debug("Send L3_VNI_DEL %u VRF %s to %s",
- zl3vni->vni,
+ zlog_debug("Send L3_VNI_DEL %u VRF %s to %s", zl3vni->vni,
vrf_id_to_name(zl3vni_vrf_id(zl3vni)),
zebra_route_string(client->proto));
zl3vni_send_del_to_client(zl3vni);
}
-static void zvni_add_to_l3vni_list(struct hash_backet *backet,
- void *ctxt)
+static void zvni_add_to_l3vni_list(struct hash_backet *backet, void *ctxt)
{
- zebra_vni_t *zvni = (zebra_vni_t *) backet->data;
- zebra_l3vni_t *zl3vni = (zebra_l3vni_t *) ctxt;
+ zebra_vni_t *zvni = (zebra_vni_t *)backet->data;
+ zebra_l3vni_t *zl3vni = (zebra_l3vni_t *)ctxt;
if (zvni->vrf_id == zl3vni_vrf_id(zl3vni))
listnode_add_sort(zl3vni->l2vnis, zvni);
/*
* handle transition of vni from l2 to l3 and vice versa
*/
-static int zebra_vxlan_handle_vni_transition(struct zebra_vrf *zvrf,
- vni_t vni, int add)
+static int zebra_vxlan_handle_vni_transition(struct zebra_vrf *zvrf, vni_t vni,
+ int add)
{
zebra_vni_t *zvni = NULL;
return 0;
if (IS_ZEBRA_DEBUG_VXLAN)
- zlog_debug("Del L2-VNI %u - transition to L3-VNI",
- vni);
+ zlog_debug("Del L2-VNI %u - transition to L3-VNI", vni);
/* Delete VNI from BGP. */
zvni_send_del_to_client(zvni->vni);
/* Delete the hash entry. */
if (zvni_del(zvni)) {
- zlog_err("Failed to del VNI hash %p, VNI %u",
- zvni, zvni->vni);
+ zlog_err("Failed to del VNI hash %p, VNI %u", zvni,
+ zvni->vni);
return -1;
}
} else {
}
/* delete and uninstall rmac hash entry */
-static void zl3vni_del_rmac_hash_entry(struct hash_backet *backet,
- void *ctx)
+static void zl3vni_del_rmac_hash_entry(struct hash_backet *backet, void *ctx)
{
zebra_mac_t *zrmac = NULL;
zebra_l3vni_t *zl3vni = NULL;
}
/* delete and uninstall nh hash entry */
-static void zl3vni_del_nh_hash_entry(struct hash_backet *backet,
- void *ctx)
+static void zl3vni_del_nh_hash_entry(struct hash_backet *backet, void *ctx)
{
zebra_neigh_t *n = NULL;
zebra_l3vni_t *zl3vni = NULL;
zl3vni_nh_del(zl3vni, n);
}
-static int ip_prefix_send_to_client(vrf_id_t vrf_id,
- struct prefix *p,
- uint16_t cmd)
+static int ip_prefix_send_to_client(vrf_id_t vrf_id, struct prefix *p,
+ uint16_t cmd)
{
struct zserv *client = NULL;
struct stream *s = NULL;
stream_putw_at(s, 0, stream_get_endp(s));
if (IS_ZEBRA_DEBUG_VXLAN)
- zlog_debug(
- "Send ip prefix %s %s on vrf %s",
+ zlog_debug("Send ip prefix %s %s on vrf %s",
prefix2str(p, buf, sizeof(buf)),
(cmd == ZEBRA_IP_PREFIX_ROUTE_ADD) ? "ADD" : "DEL",
vrf_id_to_name(vrf_id));
/* re-add remote rmac if needed */
static int zebra_vxlan_readd_remote_rmac(zebra_l3vni_t *zl3vni,
- struct ethaddr *rmac)
+ struct ethaddr *rmac)
{
char buf[ETHER_ADDR_STRLEN];
zebra_mac_t *zrmac = NULL;
if (IS_ZEBRA_DEBUG_VXLAN)
zlog_debug("Del remote RMAC %s L3VNI %u - readd",
- prefix_mac2str(rmac, buf, sizeof(buf)),
- zl3vni->vni);
+ prefix_mac2str(rmac, buf, sizeof(buf)), zl3vni->vni);
zl3vni_rmac_install(zl3vni, zrmac);
return 0;
}
/* handle evpn route in vrf table */
-void zebra_vxlan_evpn_vrf_route_add(vrf_id_t vrf_id,
- struct ethaddr *rmac,
- struct ipaddr *vtep_ip,
- struct prefix *host_prefix)
+void zebra_vxlan_evpn_vrf_route_add(vrf_id_t vrf_id, struct ethaddr *rmac,
+ struct ipaddr *vtep_ip,
+ struct prefix *host_prefix)
{
zebra_l3vni_t *zl3vni = NULL;
}
/* handle evpn vrf route delete */
-void zebra_vxlan_evpn_vrf_route_del(vrf_id_t vrf_id,
- struct ethaddr *rmac,
- struct ipaddr *vtep_ip,
- struct prefix *host_prefix)
+void zebra_vxlan_evpn_vrf_route_del(vrf_id_t vrf_id, struct ethaddr *rmac,
+ struct ipaddr *vtep_ip,
+ struct prefix *host_prefix)
{
zebra_l3vni_t *zl3vni = NULL;
zl3vni_remote_rmac_del(zl3vni, rmac, host_prefix);
}
-void zebra_vxlan_print_specific_rmac_l3vni(struct vty *vty,
- vni_t l3vni,
+void zebra_vxlan_print_specific_rmac_l3vni(struct vty *vty, vni_t l3vni,
struct ethaddr *rmac,
u_char use_json)
{
if (use_json)
vty_out(vty, "{}\n");
else
- vty_out(vty, "%% L3-VNI %u doesnt exist\n",
- l3vni);
+ vty_out(vty, "%% L3-VNI %u doesnt exist\n", l3vni);
return;
}
}
}
-void zebra_vxlan_print_rmacs_l3vni(struct vty *vty,
- vni_t l3vni,
+void zebra_vxlan_print_rmacs_l3vni(struct vty *vty, vni_t l3vni,
u_char use_json)
{
zebra_l3vni_t *zl3vni;
wctx.vty = vty;
wctx.json = json;
if (!use_json) {
- vty_out(vty,
- "Number of Remote RMACs known for this VNI: %u\n",
+ vty_out(vty, "Number of Remote RMACs known for this VNI: %u\n",
num_rmacs);
vty_out(vty, "%-17s %-21s\n", "MAC", "Remote VTEP");
} else
}
}
-void zebra_vxlan_print_rmacs_all_l3vni(struct vty *vty,
- u_char use_json)
+void zebra_vxlan_print_rmacs_all_l3vni(struct vty *vty, u_char use_json)
{
struct zebra_ns *zns = NULL;
json_object *json = NULL;
}
}
-void zebra_vxlan_print_specific_nh_l3vni(struct vty *vty,
- vni_t l3vni,
- struct ipaddr *ip,
- u_char use_json)
+void zebra_vxlan_print_specific_nh_l3vni(struct vty *vty, vni_t l3vni,
+ struct ipaddr *ip, u_char use_json)
{
zebra_l3vni_t *zl3vni = NULL;
zebra_neigh_t *n = NULL;
}
}
-void zebra_vxlan_print_nh_l3vni(struct vty *vty,
- vni_t l3vni,
- u_char use_json)
+void zebra_vxlan_print_nh_l3vni(struct vty *vty, vni_t l3vni, u_char use_json)
{
u_int32_t num_nh;
struct nh_walk_ctx wctx;
wctx.vty = vty;
wctx.json = json;
if (!use_json) {
- vty_out(vty,
- "Number of NH Neighbors known for this VNI: %u\n",
+ vty_out(vty, "Number of NH Neighbors known for this VNI: %u\n",
num_nh);
vty_out(vty, "%-15s %-17s\n", "IP", "RMAC");
} else
}
}
-void zebra_vxlan_print_nh_all_l3vni(struct vty *vty,
- u_char use_json)
+void zebra_vxlan_print_nh_all_l3vni(struct vty *vty, u_char use_json)
{
struct zebra_ns *zns = NULL;
json_object *json = NULL;
if (!json_vrfs) {
vty_out(vty, "%-37s %-10u %-20s %-20s %-5s %-18s\n",
- zvrf_name(zvrf),
- zl3vni->vni,
+ zvrf_name(zvrf), zl3vni->vni,
zl3vni_vxlan_if_name(zl3vni),
- zl3vni_svi_if_name(zl3vni),
- zl3vni_state2str(zl3vni),
+ zl3vni_svi_if_name(zl3vni), zl3vni_state2str(zl3vni),
zl3vni_rmac2str(zl3vni, buf, sizeof(buf)));
} else {
json_object *json_vrf = NULL;
json_vrf = json_object_new_object();
- json_object_string_add(json_vrf, "vrf",
- zvrf_name(zvrf));
+ json_object_string_add(json_vrf, "vrf", zvrf_name(zvrf));
json_object_int_add(json_vrf, "vni", zl3vni->vni);
json_object_string_add(json_vrf, "vxlanIntf",
zl3vni_vxlan_if_name(zl3vni));
zl3vni_svi_if_name(zl3vni));
json_object_string_add(json_vrf, "state",
zl3vni_state2str(zl3vni));
- json_object_string_add(json_vrf, "routerMac",
- zl3vni_rmac2str(zl3vni, buf,
- sizeof(buf)));
+ json_object_string_add(
+ json_vrf, "routerMac",
+ zl3vni_rmac2str(zl3vni, buf, sizeof(buf)));
json_object_array_add(json_vrfs, json_vrf);
}
}
if (use_json)
json = json_object_new_object();
else
- vty_out(vty,
- "%-10s %-4s %-21s %-8s %-8s %-15s %-37s\n",
- "VNI", "Type", "VxLAN IF", "# MACs",
- "# ARPs", "# Remote VTEPs", "Tenant VRF");
+ vty_out(vty, "%-10s %-4s %-21s %-8s %-8s %-15s %-37s\n", "VNI",
+ "Type", "VxLAN IF", "# MACs", "# ARPs",
+ "# Remote VTEPs", "Tenant VRF");
args[0] = vty;
args[1] = json;
if (IS_ZEBRA_DEBUG_VXLAN)
zlog_debug("Del neighbor %s intf %s(%u) -> L2-VNI %u",
- ipaddr2str(ip, buf, sizeof(buf)),
- ifp->name, ifp->ifindex, zvni->vni);
+ ipaddr2str(ip, buf, sizeof(buf)), ifp->name,
+ ifp->ifindex, zvni->vni);
/* If entry doesn't exist, nothing to do. */
n = zvni_neigh_lookup(zvni, ip);
/* Remove neighbor from BGP. */
if (IS_ZEBRA_NEIGH_ACTIVE(n))
- zvni_neigh_send_del_to_client(zvni->vni, &n->ip, &n->emac,
- 0);
+ zvni_neigh_send_del_to_client(zvni->vni, &n->ip, &n->emac, 0);
/* Delete this neighbor entry. */
zvni_neigh_del(zvni, n);
zmac = zvni_mac_lookup(zvni, macaddr);
if (!zmac) {
if (IS_ZEBRA_DEBUG_VXLAN)
- zlog_debug(
- "AUTO MAC %s created for neigh %s on VNI %u",
- prefix_mac2str(macaddr, buf, sizeof(buf)),
- ipaddr2str(ip, buf2, sizeof(buf2)), zvni->vni);
+ zlog_debug("AUTO MAC %s created for neigh %s on VNI %u",
+ prefix_mac2str(macaddr, buf, sizeof(buf)),
+ ipaddr2str(ip, buf2, sizeof(buf2)),
+ zvni->vni);
zmac = zvni_mac_add(zvni, macaddr);
if (!zmac) {
n = zvni_neigh_lookup(zvni, ip);
if (n) {
if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_LOCAL)) {
- if (memcmp(n->emac.octet, macaddr->octet,
- ETH_ALEN)
+ if (memcmp(n->emac.octet, macaddr->octet, ETH_ALEN)
== 0) {
/* Update any params and return - client doesn't
* care about a purely local change.
n = zvni_neigh_lookup(zvni, &ip);
if (n && !mac) {
- zlog_err(
- "Failed to locate MAC %s for neigh %s VNI %u",
- prefix_mac2str(&macaddr, buf, sizeof(buf)),
- ipaddr2str(&ip, buf1, sizeof(buf1)), vni);
+ zlog_err("Failed to locate MAC %s for neigh %s VNI %u",
+ prefix_mac2str(&macaddr, buf, sizeof(buf)),
+ ipaddr2str(&ip, buf1, sizeof(buf1)), vni);
continue;
}
continue;
/* Ignore the delete if this mac is a gateway mac-ip */
- if (mac && CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL) &&
- CHECK_FLAG(mac->flags, ZEBRA_MAC_DEF_GW)) {
- zlog_err("%u: Ignore Del for MAC %s neigh %s on VNI %u as it is configured as a default gateway",
- zvrf_id(zvrf),
- prefix_mac2str(&macaddr, buf, sizeof(buf)),
- ipaddr2str(&ip, buf1, sizeof(buf1)),
- vni);
+ if (mac && CHECK_FLAG(mac->flags, ZEBRA_MAC_LOCAL)
+ && CHECK_FLAG(mac->flags, ZEBRA_MAC_DEF_GW)) {
+ zlog_err(
+ "%u: Ignore Del for MAC %s neigh %s on VNI %u as it is configured as a default gateway",
+ zvrf_id(zvrf),
+ prefix_mac2str(&macaddr, buf, sizeof(buf)),
+ ipaddr2str(&ip, buf1, sizeof(buf1)), vni);
continue;
}
* if the MAC matches.
*/
if (CHECK_FLAG(n->flags, ZEBRA_NEIGH_REMOTE)
- && (memcmp(n->emac.octet, macaddr.octet,
- ETH_ALEN)
+ && (memcmp(n->emac.octet, macaddr.octet, ETH_ALEN)
== 0)) {
zvni_neigh_uninstall(zvni, n);
zvni_neigh_del(zvni, n);
}
} else {
if (CHECK_FLAG(mac->flags, ZEBRA_MAC_REMOTE)) {
- zvni_process_neigh_on_remote_mac_del(zvni,
- mac);
+ zvni_process_neigh_on_remote_mac_del(zvni, mac);
if (list_isempty(mac->neigh_list)) {
zvni_mac_uninstall(zvni, mac, 0);
memset(&vtep_ip, 0, sizeof(struct in_addr));
if (!EVPN_ENABLED(zvrf)) {
- zlog_warn("%s: EVPN Not turned on yet we have received a remote_macip add zapi callback",
- __PRETTY_FUNCTION__);
+ zlog_warn(
+ "%s: EVPN Not turned on yet we have received a remote_macip add zapi callback",
+ __PRETTY_FUNCTION__);
return -1;
}
/* Ignore the update if the mac is already present
as a gateway mac */
- if (mac && CHECK_FLAG(mac->flags, ZEBRA_MAC_DEF_GW) &&
- CHECK_FLAG(flags, ZEBRA_MACIP_TYPE_GW)) {
+ if (mac && CHECK_FLAG(mac->flags, ZEBRA_MAC_DEF_GW)
+ && CHECK_FLAG(flags, ZEBRA_MACIP_TYPE_GW)) {
if (IS_ZEBRA_DEBUG_VXLAN)
- zlog_debug("%u:Ignore MAC %s IP %s on VNI %u as MAC is already configured as gateway mac",
- zvrf_id(zvrf),
- prefix_mac2str(&macaddr,
- buf, sizeof(buf)),
- ipaddr2str(&ip, buf1,
- sizeof(buf1)), vni);
+ zlog_debug(
+ "%u:Ignore MAC %s IP %s on VNI %u as MAC is already configured as gateway mac",
+ zvrf_id(zvrf),
+ prefix_mac2str(&macaddr, buf,
+ sizeof(buf)),
+ ipaddr2str(&ip, buf1, sizeof(buf1)),
+ vni);
continue;
}
if (IS_ZEBRA_DEBUG_VXLAN)
zlog_debug(
"Add/update remote MAC %s intf %s(%u) VNI %u - del local",
- prefix_mac2str(macaddr, buf, sizeof(buf)),
- ifp->name, ifp->ifindex, vni);
+ prefix_mac2str(macaddr, buf, sizeof(buf)), ifp->name,
+ ifp->ifindex, vni);
/* Remove MAC from BGP. */
zvni_mac_send_del_to_client(zvni->vni, macaddr, mac->flags);
}
if (IS_ZEBRA_DEBUG_VXLAN)
- zlog_debug(
- "Add/Update %sMAC %s intf %s(%u) VID %u -> VNI %u",
- sticky ? "sticky " : "",
- prefix_mac2str(macaddr, buf, sizeof(buf)), ifp->name,
- ifp->ifindex, vid, zvni->vni);
+ zlog_debug("Add/Update %sMAC %s intf %s(%u) VID %u -> VNI %u",
+ sticky ? "sticky " : "",
+ prefix_mac2str(macaddr, buf, sizeof(buf)), ifp->name,
+ ifp->ifindex, vid, zvni->vni);
/* If same entry already exists, nothing to do. */
mac = zvni_mac_lookup(zvni, macaddr);
struct zebra_if *zif;
if (!is_evpn_enabled()) {
- zlog_warn("%s: EVPN is not enabled yet we have received a vtep del command",
- __PRETTY_FUNCTION__);
+ zlog_warn(
+ "%s: EVPN is not enabled yet we have received a vtep del command",
+ __PRETTY_FUNCTION__);
return -1;
}
struct zebra_if *zif;
if (!is_evpn_enabled()) {
- zlog_warn("%s: EVPN not enabled yet we received a vtep_add zapi call",
- __PRETTY_FUNCTION__);
+ zlog_warn(
+ "%s: EVPN not enabled yet we received a vtep_add zapi call",
+ __PRETTY_FUNCTION__);
return -1;
}
continue;
if (zvni_vtep_add(zvni, &vtep_ip) == NULL) {
- zlog_err(
- "Failed to add remote VTEP, VNI %u zvni %p",
- vni, zvni);
+ zlog_err("Failed to add remote VTEP, VNI %u zvni %p",
+ vni, zvni);
continue;
}
}
if (IS_ZEBRA_DEBUG_VXLAN)
- zlog_debug("SVI %s(%u) VNI %u VRF %s is UP, installing neighbors",
- ifp->name, ifp->ifindex, zvni->vni,
- vrf_id_to_name(ifp->vrf_id));
+ zlog_debug(
+ "SVI %s(%u) VNI %u VRF %s is UP, installing neighbors",
+ ifp->name, ifp->ifindex, zvni->vni,
+ vrf_id_to_name(ifp->vrf_id));
/* update the vrf information for l2-vni and inform bgp */
zvni->vrf_id = ifp->vrf_id;
/* Install any remote neighbors for this VNI. */
memset(&n_wctx, 0, sizeof(struct neigh_walk_ctx));
n_wctx.zvni = zvni;
- hash_iterate(zvni->neigh_table,
- zvni_install_neigh_hash,
+ hash_iterate(zvni->neigh_table, zvni_install_neigh_hash,
&n_wctx);
}
if (zl3vni) {
/* process-if-down for l3-vni */
if (IS_ZEBRA_DEBUG_VXLAN)
- zlog_debug("Intf %s(%u) L3-VNI %u is DOWN",
- ifp->name, ifp->ifindex, vni);
+ zlog_debug("Intf %s(%u) L3-VNI %u is DOWN", ifp->name,
+ ifp->ifindex, vni);
zebra_vxlan_process_l3vni_oper_down(zl3vni);
} else {
/* process if-down for l2-vni */
if (IS_ZEBRA_DEBUG_VXLAN)
- zlog_debug("Intf %s(%u) L2-VNI %u is DOWN",
- ifp->name, ifp->ifindex, vni);
+ zlog_debug("Intf %s(%u) L2-VNI %u is DOWN", ifp->name,
+ ifp->ifindex, vni);
/* Locate hash entry; it is expected to exist. */
zvni = zvni_lookup(vni);
if (zl3vni) {
if (IS_ZEBRA_DEBUG_VXLAN)
- zlog_debug("Intf %s(%u) L3-VNI %u is UP",
- ifp->name, ifp->ifindex, vni);
+ zlog_debug("Intf %s(%u) L3-VNI %u is UP", ifp->name,
+ ifp->ifindex, vni);
/* we need to associate with SVI, if any, we can associate with
* svi-if only after association with vxlan-intf is complete
struct interface *vlan_if = NULL;
if (IS_ZEBRA_DEBUG_VXLAN)
- zlog_debug("Intf %s(%u) L2-VNI %u is UP",
- ifp->name, ifp->ifindex, vni);
+ zlog_debug("Intf %s(%u) L2-VNI %u is UP", ifp->name,
+ ifp->ifindex, vni);
/* Locate hash entry; it is expected to exist. */
zvni = zvni_lookup(vni);
if (zl3vni) {
if (IS_ZEBRA_DEBUG_VXLAN)
- zlog_debug("Del L3-VNI %u intf %s(%u)",
- vni, ifp->name, ifp->ifindex);
+ zlog_debug("Del L3-VNI %u intf %s(%u)", vni, ifp->name,
+ ifp->ifindex);
/* process oper-down for l3-vni */
zebra_vxlan_process_l3vni_oper_down(zl3vni);
/* process if-del for l2-vni*/
if (IS_ZEBRA_DEBUG_VXLAN)
- zlog_debug("Del L2-VNI %u intf %s(%u)",
- vni, ifp->name, ifp->ifindex);
+ zlog_debug("Del L2-VNI %u intf %s(%u)", vni, ifp->name,
+ ifp->ifindex);
/* Locate hash entry; it is expected to exist. */
zvni = zvni_lookup(vni);
if (IS_ZEBRA_DEBUG_VXLAN)
zlog_debug(
"Update L3-VNI %u intf %s(%u) VLAN %u local IP %s master %u chg 0x%x",
- vni, ifp->name, ifp->ifindex,
- vxl->access_vlan, inet_ntoa(vxl->vtep_ip),
+ vni, ifp->name, ifp->ifindex, vxl->access_vlan,
+ inet_ntoa(vxl->vtep_ip),
zif->brslave_info.bridge_ifindex, chgflags);
/* Removed from bridge? Cleanup and return */
zl3vni->local_vtep_ip = vxl->vtep_ip;
if (is_l3vni_oper_up(zl3vni))
zebra_vxlan_process_l3vni_oper_up(
- zl3vni);
+ zl3vni);
}
}
zl3vni->local_vtep_ip = vxl->vtep_ip;
if (is_l3vni_oper_up(zl3vni))
zebra_vxlan_process_l3vni_oper_up(
- zl3vni);
+ zl3vni);
}
}
if (IS_ZEBRA_DEBUG_VXLAN)
zlog_debug(
"Update L2-VNI %u intf %s(%u) VLAN %u local IP %s master %u chg 0x%x",
- vni, ifp->name, ifp->ifindex,
- vxl->access_vlan, inet_ntoa(vxl->vtep_ip),
+ vni, ifp->name, ifp->ifindex, vxl->access_vlan,
+ inet_ntoa(vxl->vtep_ip),
zif->brslave_info.bridge_ifindex, chgflags);
/* Removed from bridge? Cleanup and return */
memset(&m_wctx, 0, sizeof(struct mac_walk_ctx));
m_wctx.zvni = zvni;
- hash_iterate(zvni->mac_table,
- zvni_install_mac_hash,
+ hash_iterate(zvni->mac_table, zvni_install_mac_hash,
&m_wctx);
memset(&n_wctx, 0, sizeof(struct neigh_walk_ctx));
if (IS_ZEBRA_DEBUG_VXLAN)
zlog_debug(
"Add L3-VNI %u intf %s(%u) VLAN %u local IP %s master %u",
- vni, ifp->name, ifp->ifindex,
- vxl->access_vlan, inet_ntoa(vxl->vtep_ip),
+ vni, ifp->name, ifp->ifindex, vxl->access_vlan,
+ inet_ntoa(vxl->vtep_ip),
zif->brslave_info.bridge_ifindex);
/* associate with vxlan_if */
zlog_debug(
"Add L2-VNI %u VRF %s intf %s(%u) VLAN %u local IP %s master %u",
vni,
- vlan_if ? vrf_id_to_name(vlan_if->vrf_id) :
- "Default",
- ifp->name, ifp->ifindex,
- vxl->access_vlan, inet_ntoa(vxl->vtep_ip),
+ vlan_if ? vrf_id_to_name(vlan_if->vrf_id)
+ : "Default",
+ ifp->name, ifp->ifindex, vxl->access_vlan,
+ inet_ntoa(vxl->vtep_ip),
zif->brslave_info.bridge_ifindex);
/* If down or not mapped to a bridge, we're done. */
return 0;
}
-int zebra_vxlan_process_vrf_vni_cmd(struct zebra_vrf *zvrf,
- vni_t vni,
- char *err, int err_str_sz,
- int filter, int add)
+int zebra_vxlan_process_vrf_vni_cmd(struct zebra_vrf *zvrf, vni_t vni,
+ char *err, int err_str_sz, int filter,
+ int add)
{
zebra_l3vni_t *zl3vni = NULL;
struct zebra_vrf *zvrf_default = NULL;
return -1;
if (IS_ZEBRA_DEBUG_VXLAN)
- zlog_debug("vrf %s vni %u %s",
- zvrf_name(zvrf),
- vni,
+ zlog_debug("vrf %s vni %u %s", zvrf_name(zvrf), vni,
add ? "ADD" : "DEL");
if (add) {
/* add the L3-VNI to the global table */
zl3vni = zl3vni_add(vni, zvrf_id(zvrf));
if (!zl3vni) {
- snprintf(err, err_str_sz,
- "Could not add L3-VNI");
+ snprintf(err, err_str_sz, "Could not add L3-VNI");
return -1;
}
zl3vni->svi_if = zl3vni_map_to_svi_if(zl3vni);
/* formulate l2vni list */
- hash_iterate(zvrf_default->vni_table,
- zvni_add_to_l3vni_list, zl3vni);
+ hash_iterate(zvrf_default->vni_table, zvni_add_to_l3vni_list,
+ zl3vni);
if (is_l3vni_oper_up(zl3vni))
zebra_vxlan_process_l3vni_oper_up(zl3vni);
zebra_vxlan_process_l3vni_oper_down(zl3vni);
/* delete and uninstall all rmacs */
- hash_iterate(zl3vni->rmac_table,
- zl3vni_del_rmac_hash_entry,
+ hash_iterate(zl3vni->rmac_table, zl3vni_del_rmac_hash_entry,
zl3vni);
/* delete and uninstall all next-hops */
- hash_iterate(zl3vni->nh_table,
- zl3vni_del_nh_hash_entry,
+ hash_iterate(zl3vni->nh_table, zl3vni_del_nh_hash_entry,
zl3vni);
zvrf->l3vni = 0;
return 0;
if (IS_ZEBRA_DEBUG_VXLAN)
- zlog_debug(
- "EVPN subnet Adv %s on VNI %d , currently %s",
- advertise ? "enabled" : "disabled", vni,
- zvni->advertise_subnet ? "enabled" : "disabled");
+ zlog_debug("EVPN subnet Adv %s on VNI %d , currently %s",
+ advertise ? "enabled" : "disabled", vni,
+ zvni->advertise_subnet ? "enabled" : "disabled");
zvni->advertise_subnet = advertise;
zl2_info = zif->l2info.vxl;
- vlan_if = zvni_map_to_svi(zl2_info.access_vlan,
- zif->brslave_info.br_if);
+ vlan_if =
+ zvni_map_to_svi(zl2_info.access_vlan, zif->brslave_info.br_if);
if (!vlan_if)
return 0;
zlog_debug(
"EVPN gateway macip Adv %s on VNI %d , currently %s",
advertise ? "enabled" : "disabled", vni,
- advertise_gw_macip_enabled(zvni)
- ? "enabled"
- : "disabled");
+ advertise_gw_macip_enabled(zvni) ? "enabled"
+ : "disabled");
if (zvni->advertise_gw_macip == advertise)
return 0;
* when disabled, the entries should be deleted and remote VTEPs and MACs
* uninstalled from the kernel.
*/
-int zebra_vxlan_advertise_all_vni(struct zserv *client,
- u_short length, struct zebra_vrf *zvrf)
+int zebra_vxlan_advertise_all_vni(struct zserv *client, u_short length,
+ struct zebra_vrf *zvrf)
{
struct stream *s = NULL;
int advertise = 0;
struct zebra_ns *zns = NULL;
if (zvrf_id(zvrf) != VRF_DEFAULT) {
- zlog_err("EVPN VNI Adv for non-default VRF %u",
- zvrf_id(zvrf));
+ zlog_err("EVPN VNI Adv for non-default VRF %u", zvrf_id(zvrf));
return -1;
}
/* Is EVPN enabled? */
#define EVPN_ENABLED(zvrf) (zvrf)->advertise_all_vni
-static inline int
-is_evpn_enabled()
+static inline int is_evpn_enabled()
{
struct zebra_vrf *zvrf = NULL;
zvrf = zebra_vrf_lookup_by_id(VRF_DEFAULT);
vni_t vni, u_char use_json);
extern void zebra_vxlan_print_vnis(struct vty *vty, struct zebra_vrf *zvrf,
u_char use_json);
-extern void zebra_vxlan_print_rmacs_l3vni(struct vty *vty, vni_t vni, u_char
- use_json);
+extern void zebra_vxlan_print_rmacs_l3vni(struct vty *vty, vni_t vni,
+ u_char use_json);
extern void zebra_vxlan_print_rmacs_all_l3vni(struct vty *vty, u_char use_json);
-extern void zebra_vxlan_print_nh_l3vni(struct vty *vty, vni_t vni, u_char
- use_json);
+extern void zebra_vxlan_print_nh_l3vni(struct vty *vty, vni_t vni,
+ u_char use_json);
extern void zebra_vxlan_print_nh_all_l3vni(struct vty *vty, u_char use_json);
extern void zebra_vxlan_print_l3vni(struct vty *vty, vni_t vni,
u_char use_json);
extern int zebra_vxlan_local_neigh_del(struct interface *ifp,
struct interface *link_if,
struct ipaddr *ip);
-extern int zebra_vxlan_remote_macip_add(struct zserv *client,
- u_short length, struct zebra_vrf *zvrf);
-extern int zebra_vxlan_remote_macip_del(struct zserv *client,
- u_short length, struct zebra_vrf *zvrf);
+extern int zebra_vxlan_remote_macip_add(struct zserv *client, u_short length,
+ struct zebra_vrf *zvrf);
+extern int zebra_vxlan_remote_macip_del(struct zserv *client, u_short length,
+ struct zebra_vrf *zvrf);
extern int zebra_vxlan_local_mac_add_update(struct interface *ifp,
struct interface *br_if,
struct ethaddr *mac, vlanid_t vid,
extern int zebra_vxlan_if_add(struct interface *ifp);
extern int zebra_vxlan_if_update(struct interface *ifp, u_int16_t chgflags);
extern int zebra_vxlan_if_del(struct interface *ifp);
-extern int zebra_vxlan_remote_vtep_add(struct zserv *client,
- u_short length, struct zebra_vrf *zvrf);
-extern int zebra_vxlan_remote_vtep_del(struct zserv *client,
- u_short length, struct zebra_vrf *zvrf);
+extern int zebra_vxlan_remote_vtep_add(struct zserv *client, u_short length,
+ struct zebra_vrf *zvrf);
+extern int zebra_vxlan_remote_vtep_del(struct zserv *client, u_short length,
+ struct zebra_vrf *zvrf);
extern int zebra_vxlan_advertise_subnet(struct zserv *client, u_short length,
struct zebra_vrf *zvrf);
-extern int zebra_vxlan_advertise_gw_macip(struct zserv *client,
- u_short length,
+extern int zebra_vxlan_advertise_gw_macip(struct zserv *client, u_short length,
struct zebra_vrf *zvrf);
-extern int zebra_vxlan_advertise_all_vni(struct zserv *client,
- u_short length,
+extern int zebra_vxlan_advertise_all_vni(struct zserv *client, u_short length,
struct zebra_vrf *zvrf);
extern int zebra_vxlan_process_vrf_vni_cmd(struct zebra_vrf *zvrf, vni_t vni,
- char *err,
- int err_str_sz, int filter, int add);
+ char *err, int err_str_sz,
+ int filter, int add);
extern void zebra_vxlan_init_tables(struct zebra_vrf *zvrf);
extern void zebra_vxlan_close_tables(struct zebra_vrf *);
extern void zebra_vxlan_cleanup_tables(struct zebra_vrf *);
{
}
-void zebra_vxlan_print_rmacs_l3vni(struct vty*, vni_t, u_char)
+void zebra_vxlan_print_rmacs_l3vni(struct vty *, vni_t, u_char)
{
}
-void zebra_vxlan_print_rmacs_all_l3vni(struct vty*, u_char)
+void zebra_vxlan_print_rmacs_all_l3vni(struct vty *, u_char)
{
}
-void zebra_vxlan_print_nh_l3vni(struct vty*, vni_t, u_char)
+void zebra_vxlan_print_nh_l3vni(struct vty *, vni_t, u_char)
{
}
-void zebra_vxlan_print_nh_all_l3vni(struct vty*, u_char)
+void zebra_vxlan_print_nh_all_l3vni(struct vty *, u_char)
{
}
*/
static inline int is_l3vni_oper_up(zebra_l3vni_t *zl3vni)
{
- return (is_evpn_enabled() && zl3vni &&
- (zl3vni->vrf_id != VRF_UNKNOWN) &&
- zl3vni->vxlan_if && if_is_operative(zl3vni->vxlan_if) &&
- zl3vni->svi_if && if_is_operative(zl3vni->svi_if));
+ return (is_evpn_enabled() && zl3vni && (zl3vni->vrf_id != VRF_UNKNOWN)
+ && zl3vni->vxlan_if && if_is_operative(zl3vni->vxlan_if)
+ && zl3vni->svi_if && if_is_operative(zl3vni->svi_if));
}
static inline const char *zl3vni_state2str(zebra_l3vni_t *zl3vni)
return zl3vni->vrf_id;
}
-static inline void zl3vni_get_rmac(zebra_l3vni_t *zl3vni,
- struct ethaddr *rmac)
+static inline void zl3vni_get_rmac(zebra_l3vni_t *zl3vni, struct ethaddr *rmac)
{
if (!zl3vni)
return;
data.l.table_id = zvrf->table_id;
if (netns_name)
- strlcpy(data.l.netns_name,
- basename((char *)netns_name), NS_NAMSIZ);
+ strlcpy(data.l.netns_name, basename((char *)netns_name),
+ NS_NAMSIZ);
else
memset(data.l.netns_name, 0, NS_NAMSIZ);
/* Pass the tableid and the netns NAME */
l += 4;
if (p.family == AF_INET) {
if (p.prefixlen > IPV4_MAX_BITLEN) {
- zlog_warn("%s: Specified prefix length %d is too large for a v4 address",
- __PRETTY_FUNCTION__, p.prefixlen);
+ zlog_warn(
+ "%s: Specified prefix length %d is too large for a v4 address",
+ __PRETTY_FUNCTION__, p.prefixlen);
return -1;
}
STREAM_GET(&p.u.prefix4.s_addr, s, IPV4_MAX_BYTELEN);
l += IPV4_MAX_BYTELEN;
} else if (p.family == AF_INET6) {
if (p.prefixlen > IPV6_MAX_BITLEN) {
- zlog_warn("%s: Specified prefix length %d is to large for a v6 address",
- __PRETTY_FUNCTION__, p.prefixlen);
+ zlog_warn(
+ "%s: Specified prefix length %d is to large for a v6 address",
+ __PRETTY_FUNCTION__, p.prefixlen);
return -1;
}
STREAM_GET(&p.u.prefix6, s, IPV6_MAX_BYTELEN);
l += 4;
if (p.family == AF_INET) {
if (p.prefixlen > IPV4_MAX_BITLEN) {
- zlog_warn("%s: Specified prefix length %d is to large for a v4 address",
- __PRETTY_FUNCTION__, p.prefixlen);
+ zlog_warn(
+ "%s: Specified prefix length %d is to large for a v4 address",
+ __PRETTY_FUNCTION__, p.prefixlen);
return -1;
}
STREAM_GET(&p.u.prefix4.s_addr, s, IPV4_MAX_BYTELEN);
l += IPV4_MAX_BYTELEN;
} else if (p.family == AF_INET6) {
if (p.prefixlen > IPV6_MAX_BITLEN) {
- zlog_warn("%s: Specified prefix length %d is to large for a v6 address",
- __PRETTY_FUNCTION__, p.prefixlen);
+ zlog_warn(
+ "%s: Specified prefix length %d is to large for a v6 address",
+ __PRETTY_FUNCTION__, p.prefixlen);
return -1;
}
STREAM_GET(&p.u.prefix6, s, IPV6_MAX_BYTELEN);
return -1;
}
STREAM_GETC(s, p.prefixlen);
- if ((p.family == AF_INET && p.prefixlen > IPV4_MAX_BITLEN) ||
- (p.family == AF_INET6 && p.prefixlen > IPV6_MAX_BITLEN)) {
- zlog_warn("%s: Specified prefix length: %d is to long for %d",
- __PRETTY_FUNCTION__, p.prefixlen, p.family);
+ if ((p.family == AF_INET && p.prefixlen > IPV4_MAX_BITLEN)
+ || (p.family == AF_INET6
+ && p.prefixlen > IPV6_MAX_BITLEN)) {
+ zlog_warn(
+ "%s: Specified prefix length: %d is to long for %d",
+ __PRETTY_FUNCTION__, p.prefixlen, p.family);
return -1;
}
l += 5;
return -1;
}
STREAM_GETC(s, p.prefixlen);
- if ((p.family == AF_INET && p.prefixlen > IPV4_MAX_BITLEN) ||
- (p.family == AF_INET6 && p.prefixlen > IPV6_MAX_BITLEN)) {
- zlog_warn("%s: Received prefix length %d which is greater than %d can support",
- __PRETTY_FUNCTION__, p.prefixlen, p.family);
+ if ((p.family == AF_INET && p.prefixlen > IPV4_MAX_BITLEN)
+ || (p.family == AF_INET6
+ && p.prefixlen > IPV6_MAX_BITLEN)) {
+ zlog_warn(
+ "%s: Received prefix length %d which is greater than %d can support",
+ __PRETTY_FUNCTION__, p.prefixlen, p.family);
return -1;
}
l += 5;
memset(&vtep_ip, 0, sizeof(struct ipaddr));
if (CHECK_FLAG(api.flags,
ZEBRA_FLAG_EVPN_ROUTE)) {
- ifindex =
- get_l3vni_svi_ifindex(vrf_id);
+ ifindex = get_l3vni_svi_ifindex(vrf_id);
} else {
ifindex = api_nh->ifindex;
}
&(api_nh->gate.ipv4),
sizeof(struct in_addr));
zebra_vxlan_evpn_vrf_route_add(
- vrf_id,
- &api.rmac,
- &vtep_ip,
- &api.prefix);
+ vrf_id, &api.rmac, &vtep_ip,
+ &api.prefix);
}
break;
}
}
if (!nexthop) {
- zlog_warn("%s: Nexthops Specified: %d but we failed to properly create one",
- __PRETTY_FUNCTION__, api.nexthop_num);
+ zlog_warn(
+ "%s: Nexthops Specified: %d but we failed to properly create one",
+ __PRETTY_FUNCTION__, api.nexthop_num);
nexthops_free(re->nexthop);
XFREE(MTYPE_RE, re);
return -1;
p.family = AF_INET;
STREAM_GETC(s, p.prefixlen);
if (p.prefixlen > IPV4_MAX_BITLEN) {
- zlog_warn("%s: Specified prefix length %d is greater than what v4 can be",
- __PRETTY_FUNCTION__, p.prefixlen);
+ zlog_warn(
+ "%s: Specified prefix length %d is greater than what v4 can be",
+ __PRETTY_FUNCTION__, p.prefixlen);
XFREE(MTYPE_RE, re);
return -1;
}
re->vrf_id);
break;
case NEXTHOP_TYPE_IPV6:
- zlog_warn("%s: Please use ZEBRA_ROUTE_ADD if you want to pass v6 nexthops",
- __PRETTY_FUNCTION__);
+ zlog_warn(
+ "%s: Please use ZEBRA_ROUTE_ADD if you want to pass v6 nexthops",
+ __PRETTY_FUNCTION__);
nexthops_free(re->nexthop);
XFREE(MTYPE_RE, re);
return -1;
route_entry_nexthop_blackhole_add(re, bh_type);
break;
default:
- zlog_warn("%s: Specified nexthop type: %d does not exist",
- __PRETTY_FUNCTION__, nexthop_type);
+ zlog_warn(
+ "%s: Specified nexthop type: %d does not exist",
+ __PRETTY_FUNCTION__, nexthop_type);
nexthops_free(re->nexthop);
XFREE(MTYPE_RE, re);
return -1;
p.family = AF_INET;
STREAM_GETC(s, p.prefixlen);
if (p.prefixlen > IPV4_MAX_BITLEN) {
- zlog_warn("%s: Prefix Length %d is greater than what a v4 address can use",
- __PRETTY_FUNCTION__, p.prefixlen);
+ zlog_warn(
+ "%s: Prefix Length %d is greater than what a v4 address can use",
+ __PRETTY_FUNCTION__, p.prefixlen);
XFREE(MTYPE_RE, re);
return -1;
}
route_entry_nexthop_blackhole_add(re, bh_type);
break;
default:
- zlog_warn("%s: Please use ZEBRA_ROUTE_ADD if you want to pass non v6 nexthops",
- __PRETTY_FUNCTION__);
+ zlog_warn(
+ "%s: Please use ZEBRA_ROUTE_ADD if you want to pass non v6 nexthops",
+ __PRETTY_FUNCTION__);
nexthops_free(re->nexthop);
XFREE(MTYPE_RE, re);
return -1;
p.family = AF_INET6;
STREAM_GETC(s, p.prefixlen);
if (p.prefixlen > IPV6_MAX_BITLEN) {
- zlog_warn("%s: Specified prefix length %d is to large for v6 prefix",
- __PRETTY_FUNCTION__, p.prefixlen);
+ zlog_warn(
+ "%s: Specified prefix length %d is to large for v6 prefix",
+ __PRETTY_FUNCTION__, p.prefixlen);
XFREE(MTYPE_RE, re);
return -1;
}
src_p.family = AF_INET6;
STREAM_GETC(s, src_p.prefixlen);
if (src_p.prefixlen > IPV6_MAX_BITLEN) {
- zlog_warn("%s: Specified src prefix length %d is to large for v6 prefix",
- __PRETTY_FUNCTION__, src_p.prefixlen);
+ zlog_warn(
+ "%s: Specified src prefix length %d is to large for v6 prefix",
+ __PRETTY_FUNCTION__, src_p.prefixlen);
XFREE(MTYPE_RE, re);
return -1;
}
route_entry_nexthop_blackhole_add(re, bh_type);
break;
default:
- zlog_warn("%s: Please use ZEBRA_ROUTE_ADD if you want to pass non v6 nexthops",
- __PRETTY_FUNCTION__);
+ zlog_warn(
+ "%s: Please use ZEBRA_ROUTE_ADD if you want to pass non v6 nexthops",
+ __PRETTY_FUNCTION__);
nexthops_free(re->nexthop);
XFREE(MTYPE_RE, re);
return -1;
STREAM_GET(&prefix.u.prefix4.s_addr, s, IPV4_MAX_BYTELEN);
STREAM_GETC(s, prefix.prefixlen);
if (prefix.prefixlen > IPV4_MAX_BITLEN) {
- zlog_warn("%s: Specified prefix length %d is greater than a v4 address can support",
- __PRETTY_FUNCTION__,
- prefix.prefixlen);
+ zlog_warn(
+ "%s: Specified prefix length %d is greater than a v4 address can support",
+ __PRETTY_FUNCTION__, prefix.prefixlen);
return;
}
STREAM_GET(&gate.ipv4.s_addr, s, IPV4_MAX_BYTELEN);
STREAM_GET(&prefix.u.prefix6, s, 16);
STREAM_GETC(s, prefix.prefixlen);
if (prefix.prefixlen > IPV6_MAX_BITLEN) {
- zlog_warn("%s: Specified prefix length %d is greater than a v6 address can support",
- __PRETTY_FUNCTION__,
- prefix.prefixlen);
+ zlog_warn(
+ "%s: Specified prefix length %d is greater than a v6 address can support",
+ __PRETTY_FUNCTION__, prefix.prefixlen);
return;
}
STREAM_GET(&gate.ipv6, s, 16);
/* external label manager */
if (lm_is_external)
- zread_relay_label_manager_request(cmd, client,
- zvrf_id(zvrf));
+ zread_relay_label_manager_request(cmd, client, zvrf_id(zvrf));
/* this is a label manager */
else {
if (cmd == ZEBRA_LABEL_MANAGER_CONNECT)
- zread_label_manager_connect(client,
- zvrf_id(zvrf));
+ zread_label_manager_connect(client, zvrf_id(zvrf));
else {
/* Sanity: don't allow 'unidentified' requests */
if (!client->proto) {
return;
}
if (cmd == ZEBRA_GET_LABEL_CHUNK)
- zread_get_label_chunk(client,
- zvrf_id(zvrf));
+ zread_get_label_chunk(client, zvrf_id(zvrf));
else if (cmd == ZEBRA_RELEASE_LABEL_CHUNK)
zread_release_label_chunk(client);
}
zebra_vrf_update_all(client);
}
-static int zread_interface_set_master(struct zserv *client,
- u_short length)
+static int zread_interface_set_master(struct zserv *client, u_short length)
{
struct interface *master;
struct interface *slave;
}
-static void zread_vrf_label(struct zserv *client,
- struct zebra_vrf *zvrf)
+static void zread_vrf_label(struct zserv *client, struct zebra_vrf *zvrf)
{
struct interface *ifp;
mpls_label_t nlabel;
bool really_remove;
really_remove = true;
- for (scrubber = AFI_IP; scrubber < AFI_MAX ; scrubber++) {
+ for (scrubber = AFI_IP; scrubber < AFI_MAX; scrubber++) {
if (scrubber == afi)
continue;
}
if (nlabel != MPLS_LABEL_NONE)
- mpls_lsp_install(def_zvrf, ltype, nlabel, MPLS_LABEL_IMPLICIT_NULL,
- NEXTHOP_TYPE_IFINDEX, NULL, ifp->ifindex);
+ mpls_lsp_install(def_zvrf, ltype, nlabel,
+ MPLS_LABEL_IMPLICIT_NULL, NEXTHOP_TYPE_IFINDEX,
+ NULL, ifp->ifindex);
zvrf->label[afi] = nlabel;
stream_failure:
return;
}
-static inline void zserv_handle_commands(struct zserv *client,
- uint16_t command,
+static inline void zserv_handle_commands(struct zserv *client, uint16_t command,
uint16_t length,
struct zebra_vrf *zvrf)
{
zread_hello(client);
break;
case ZEBRA_NEXTHOP_REGISTER:
- zserv_rnh_register(client, length, RNH_NEXTHOP_TYPE,
- zvrf);
+ zserv_rnh_register(client, length, RNH_NEXTHOP_TYPE, zvrf);
break;
case ZEBRA_NEXTHOP_UNREGISTER:
- zserv_rnh_unregister(client, length, RNH_NEXTHOP_TYPE,
- zvrf);
+ zserv_rnh_unregister(client, length, RNH_NEXTHOP_TYPE, zvrf);
break;
case ZEBRA_IMPORT_ROUTE_REGISTER:
- zserv_rnh_register(client, length, RNH_IMPORT_CHECK_TYPE,
- zvrf);
+ zserv_rnh_register(client, length, RNH_IMPORT_CHECK_TYPE, zvrf);
break;
case ZEBRA_IMPORT_ROUTE_UNREGISTER:
- zserv_rnh_unregister(client, length,
- RNH_IMPORT_CHECK_TYPE, zvrf);
+ zserv_rnh_unregister(client, length, RNH_IMPORT_CHECK_TYPE,
+ zvrf);
break;
case ZEBRA_BFD_DEST_UPDATE:
case ZEBRA_BFD_DEST_REGISTER:
if ((already = stream_get_endp(client->ibuf))
< ZEBRA_HEADER_SIZE) {
ssize_t nbyte;
- if (((nbyte =
- stream_read_try(client->ibuf, sock,
- ZEBRA_HEADER_SIZE - already))
+ if (((nbyte = stream_read_try(client->ibuf, sock,
+ ZEBRA_HEADER_SIZE
+ - already))
== 0)
|| (nbyte == -1)) {
if (IS_ZEBRA_DEBUG_EVENT)
- zlog_debug("connection closed socket [%d]",
- sock);
+ zlog_debug(
+ "connection closed socket [%d]",
+ sock);
zebra_client_close(client);
return -1;
}
/* Debug packet information. */
if (IS_ZEBRA_DEBUG_EVENT)
- zlog_debug("zebra message comes from socket [%d]", sock);
+ zlog_debug("zebra message comes from socket [%d]",
+ sock);
if (IS_ZEBRA_DEBUG_PACKET && IS_ZEBRA_DEBUG_RECV)
zlog_debug("zebra message received [%s] %d in VRF %u",
- zserv_command_string(command), length, vrf_id);
+ zserv_command_string(command), length,
+ vrf_id);
client->last_read_time = monotime(NULL);
client->last_read_cmd = command;
zvrf = zebra_vrf_lookup_by_id(vrf_id);
if (!zvrf) {
if (IS_ZEBRA_DEBUG_PACKET && IS_ZEBRA_DEBUG_RECV)
- zlog_debug("zebra received unknown VRF[%u]", vrf_id);
+ zlog_debug("zebra received unknown VRF[%u]",
+ vrf_id);
goto zclient_read_out;
}
zserv_handle_commands(client, command, length, zvrf);
if (client->t_suicide) {
- /* No need to wait for thread callback, just kill immediately.
+ /* No need to wait for thread callback, just kill
+ * immediately.
*/
zebra_client_close(client);
return -1;
struct zserv *client;
for (ALL_LIST_ELEMENTS(zebrad.client_list, node, nnode, client)) {
- if (client->proto == proto &&
- client->instance == instance)
+ if (client->proto == proto && client->instance == instance)
return client;
}
client = zebrad.client_list->head->data;
t.arg = client;
- fd = open(input, O_RDONLY|O_NONBLOCK);
+ fd = open(input, O_RDONLY | O_NONBLOCK);
t.u.fd = fd;
zebra_client_read(&t);
/* default table */
u_int32_t rtm_table_default;
- /* rib work queue */
- #define ZEBRA_RIB_PROCESS_HOLD_TIME 10
+/* rib work queue */
+#define ZEBRA_RIB_PROCESS_HOLD_TIME 10
struct work_queue *ribq;
struct meta_queue *mq;
/* LSP work queue */
struct work_queue *lsp_process_q;
- #define ZEBRA_ZAPI_PACKETS_TO_PROCESS 10
+#define ZEBRA_ZAPI_PACKETS_TO_PROCESS 10
u_int32_t packets_to_process;
};
extern struct zebra_t zebrad;
projects / matthieu / frr.git / commitdiff