Merge pull request FRRouting#12248 from pguibert6WIND/bgpasdot

lib, bgp: add initial support for asdot format

Author: riw777

bgpd/bgp_aspath.c

@@ -287,9 +287,13 @@ static struct assegment *assegment_normalise(struct assegment *head)
 	return head;
 }
 
-static struct aspath *aspath_new(void)
+static struct aspath *aspath_new(enum asnotation_mode asnotation)
 {
-	return XCALLOC(MTYPE_AS_PATH, sizeof(struct aspath));
+	struct aspath *as;
+
+	as = XCALLOC(MTYPE_AS_PATH, sizeof(struct aspath));
+	as->asnotation = asnotation;
+	return as;
 }
 
 /* Free AS path structure. */
@@ -537,8 +541,10 @@ static void aspath_make_str_count(struct aspath *as, bool make_json)
  *
  * This was changed to 10 after the well-known BGP assertion, which
  * had hit some parts of the Internet in May of 2009.
+ * plain format : '4294967295 ' : 10 + 1
+ * astod format : '65535.65535 ': 11 + 1
  */
-#define ASN_STR_LEN (10 + 1)
+#define ASN_STR_LEN (11 + 1)
 	str_size = MAX(assegment_count_asns(seg, 0) * ASN_STR_LEN + 2 + 1,
 		       ASPATH_STR_DEFAULT_LEN);
 	str_buf = XMALLOC(MTYPE_AS_STR, str_size);
@@ -569,7 +575,7 @@ static void aspath_make_str_count(struct aspath *as, bool make_json)
 
 /* We might need to increase str_buf, particularly if path has
  * differing segments types, our initial guesstimate above will
- * have been wrong. Need 10 chars for ASN, a separator each and
+ * have been wrong. Need 11 chars for ASN, a separator each and
  * potentially two segment delimiters, plus a space between each
  * segment and trailing zero.
  *
@@ -595,12 +601,11 @@ static void aspath_make_str_count(struct aspath *as, bool make_json)
 		/* write out the ASNs, with their separators, bar the last one*/
 		for (i = 0; i < seg->length; i++) {
 			if (make_json)
-				json_object_array_add(
-					jseg_list,
-					json_object_new_int64(seg->as[i]));
-
-			len += snprintf(str_buf + len, str_size - len, "%u",
-					seg->as[i]);
+				asn_asn2json_array(jseg_list, seg->as[i],
+						   as->asnotation);
+			len += snprintfrr(str_buf + len, str_size - len,
+					  ASN_FORMAT(as->asnotation),
+					  &seg->as[i]);
 
 			if (i < (seg->length - 1))
 				len += snprintf(str_buf + len, str_size - len,
@@ -691,6 +696,7 @@ struct aspath *aspath_dup(struct aspath *aspath)
 
 	new->str = XMALLOC(MTYPE_AS_STR, buflen);
 	new->str_len = aspath->str_len;
+	new->asnotation = aspath->asnotation;
 
 	/* copy the string data */
 	if (aspath->str_len > 0)
@@ -718,6 +724,7 @@ static void *aspath_hash_alloc(void *arg)
 	new->str = aspath->str;
 	new->str_len = aspath->str_len;
 	new->json = aspath->json;
+	new->asnotation = aspath->asnotation;
 
 	return new;
 }
@@ -825,7 +832,8 @@ static int assegments_parse(struct stream *s, size_t length,
 
    On error NULL is returned.
  */
-struct aspath *aspath_parse(struct stream *s, size_t length, int use32bit)
+struct aspath *aspath_parse(struct stream *s, size_t length, int use32bit,
+			    enum asnotation_mode asnotation)
 {
 	struct aspath as;
 	struct aspath *find;
@@ -840,6 +848,7 @@ struct aspath *aspath_parse(struct stream *s, size_t length, int use32bit)
 		return NULL;
 
 	memset(&as, 0, sizeof(as));
+	as.asnotation = asnotation;
 	if (assegments_parse(s, length, &as.segments, use32bit) < 0)
 		return NULL;
 
@@ -1057,7 +1066,7 @@ struct aspath *aspath_aggregate(struct aspath *as1, struct aspath *as2)
 			seg = assegment_append_asns(seg, seg1->as, match);
 
 			if (!aspath) {
-				aspath = aspath_new();
+				aspath = aspath_new(as1->asnotation);
 				aspath->segments = seg;
 			} else
 				prevseg->next = seg;
@@ -1077,7 +1086,7 @@ struct aspath *aspath_aggregate(struct aspath *as1, struct aspath *as2)
 	}
 
 	if (!aspath)
-		aspath = aspath_new();
+		aspath = aspath_new(as1->asnotation);
 
 	/* Make as-set using rest of all information. */
 	from = match;
@@ -1521,7 +1530,7 @@ struct aspath *aspath_filter_exclude(struct aspath *source,
 	struct assegment *srcseg, *exclseg, *lastseg;
 	struct aspath *newpath;
 
-	newpath = aspath_new();
+	newpath = aspath_new(source->asnotation);
 	lastseg = NULL;
 
 	for (srcseg = source->segments; srcseg; srcseg = srcseg->next) {
@@ -1751,7 +1760,7 @@ struct aspath *aspath_reconcile_as4(struct aspath *aspath,
 		newseg = assegment_append_asns(newseg, seg->as, cpasns);
 
 		if (!newpath) {
-			newpath = aspath_new();
+			newpath = aspath_new(aspath->asnotation);
 			newpath->segments = newseg;
 		} else
 			prevseg->next = newseg;
@@ -1880,16 +1889,16 @@ static void aspath_segment_add(struct aspath *as, int type)
 		as->segments = new;
 }
 
-struct aspath *aspath_empty(void)
+struct aspath *aspath_empty(enum asnotation_mode asnotation)
 {
-	return aspath_parse(NULL, 0, 1); /* 32Bit ;-) */
+	return aspath_parse(NULL, 0, 1, asnotation); /* 32Bit ;-) */
 }
 
 struct aspath *aspath_empty_get(void)
 {
 	struct aspath *aspath;
 
-	aspath = aspath_new();
+	aspath = aspath_new(bgp_get_asnotation(NULL));
 	aspath_make_str_count(aspath, false);
 	return aspath;
 }
@@ -1925,6 +1934,8 @@ static const char *aspath_gettoken(const char *buf, enum as_token *token,
 				   unsigned long *asno)
 {
 	const char *p = buf;
+	as_t asval;
+	bool found = false;
 
 	/* Skip separators (space for sequences, ',' for sets). */
 	while (isspace((unsigned char)*p) || *p == ',')
@@ -1961,38 +1972,26 @@ static const char *aspath_gettoken(const char *buf, enum as_token *token,
 		return p;
 	}
 
-	/* Check actual AS value. */
-	if (isdigit((unsigned char)*p)) {
-		as_t asval;
-
-		*token = as_token_asval;
-		asval = (*p - '0');
-		p++;
-
-		while (isdigit((unsigned char)*p)) {
-			asval *= 10;
-			asval += (*p - '0');
-			p++;
-		}
+	asval = 0;
+	p = asn_str2asn_parse(p, &asval, &found);
+	if (found) {
 		*asno = asval;
-		return p;
-	}
-
-	/* There is no match then return unknown token. */
-	*token = as_token_unknown;
-	p++;
+		*token = as_token_asval;
+	} else
+		*token = as_token_unknown;
 	return p;
 }
 
-struct aspath *aspath_str2aspath(const char *str)
+struct aspath *aspath_str2aspath(const char *str,
+				 enum asnotation_mode asnotation)
 {
 	enum as_token token = as_token_unknown;
 	unsigned short as_type;
 	unsigned long asno = 0;
 	struct aspath *aspath;
 	int needtype;
 
-	aspath = aspath_new();
+	aspath = aspath_new(asnotation);
 
 	/* We start default type as AS_SEQUENCE. */
 	as_type = AS_SEQUENCE;
@@ -2066,6 +2065,10 @@ bool aspath_cmp(const void *arg1, const void *arg2)
 	const struct assegment *seg1 = ((const struct aspath *)arg1)->segments;
 	const struct assegment *seg2 = ((const struct aspath *)arg2)->segments;
 
+	if (((const struct aspath *)arg1)->asnotation !=
+	    ((const struct aspath *)arg2)->asnotation)
+		return false;
+
 	while (seg1 || seg2) {
 		int i;
 		if ((!seg1 && seg2) || (seg1 && !seg2))

bgpd/bgp_aspath.h

@@ -57,6 +57,9 @@ struct aspath {
 	   and AS path regular expression match.  */
 	char *str;
 	unsigned short str_len;
+
+	/* AS notation used by string expression of AS path */
+	enum asnotation_mode asnotation;
 };
 
 #define ASPATH_STR_DEFAULT_LEN 32
@@ -65,7 +68,9 @@ struct aspath {
 extern void aspath_init(void);
 extern void aspath_finish(void);
 extern struct aspath *aspath_parse(struct stream *s, size_t length,
-				   int use32bit);
+				   int use32bit,
+				   enum asnotation_mode asnotation);
+
 extern struct aspath *aspath_dup(struct aspath *aspath);
 extern struct aspath *aspath_aggregate(struct aspath *as1, struct aspath *as2);
 extern struct aspath *aspath_prepend(struct aspath *as1, struct aspath *as2);
@@ -81,9 +86,10 @@ extern bool aspath_cmp_left(const struct aspath *aspath1,
 extern bool aspath_cmp_left_confed(const struct aspath *as1,
 				   const struct aspath *as2);
 extern struct aspath *aspath_delete_confed_seq(struct aspath *aspath);
-extern struct aspath *aspath_empty(void);
+extern struct aspath *aspath_empty(enum asnotation_mode asnotation);
 extern struct aspath *aspath_empty_get(void);
-extern struct aspath *aspath_str2aspath(const char *str);
+extern struct aspath *aspath_str2aspath(const char *str,
+					enum asnotation_mode asnotation);
 extern void aspath_str_update(struct aspath *as, bool make_json);
 extern void aspath_free(struct aspath *aspath);
 extern struct aspath *aspath_intern(struct aspath *aspath);

bgpd/bgp_attr.c

@@ -1054,7 +1054,7 @@ struct attr *bgp_attr_default_set(struct attr *attr, struct bgp *bgp,
 
 	attr->origin = origin;
 	attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_ORIGIN);
-	attr->aspath = aspath_empty();
+	attr->aspath = aspath_empty(bgp->asnotation);
 	attr->flag |= ATTR_FLAG_BIT(BGP_ATTR_AS_PATH);
 	attr->weight = BGP_ATTR_DEFAULT_WEIGHT;
 	attr->tag = 0;
@@ -1092,7 +1092,7 @@ struct attr *bgp_attr_aggregate_intern(
 	if (aspath)
 		attr.aspath = aspath_intern(aspath);
 	else
-		attr.aspath = aspath_empty();
+		attr.aspath = aspath_empty(bgp->asnotation);
 	attr.flag |= ATTR_FLAG_BIT(BGP_ATTR_AS_PATH);
 
 	/* Next hop attribute.  */
@@ -1590,15 +1590,19 @@ static int bgp_attr_aspath(struct bgp_attr_parser_args *args)
 	struct attr *const attr = args->attr;
 	struct peer *const peer = args->peer;
 	const bgp_size_t length = args->length;
+	enum asnotation_mode asnotation;
 
+	asnotation = bgp_get_asnotation(
+		args->peer && args->peer->bgp ? args->peer->bgp : NULL);
 	/*
 	 * peer with AS4 => will get 4Byte ASnums
 	 * otherwise, will get 16 Bit
 	 */
-	attr->aspath = aspath_parse(
-		peer->curr, length,
-		CHECK_FLAG(peer->cap, PEER_CAP_AS4_RCV)
-			&& CHECK_FLAG(peer->cap, PEER_CAP_AS4_ADV));
+	attr->aspath =
+		aspath_parse(peer->curr, length,
+			     CHECK_FLAG(peer->cap, PEER_CAP_AS4_RCV) &&
+				     CHECK_FLAG(peer->cap, PEER_CAP_AS4_ADV),
+			     asnotation);
 
 	/* In case of IBGP, length will be zero. */
 	if (!attr->aspath) {
@@ -1614,7 +1618,8 @@ static int bgp_attr_aspath(struct bgp_attr_parser_args *args)
 	 * such messages, conformant BGP speakers SHOULD use the "Treat-as-
 	 * withdraw" error handling behavior as per [RFC7606].
 	 */
-	if (peer->bgp->reject_as_sets && aspath_check_as_sets(attr->aspath)) {
+	if (peer->bgp && peer->bgp->reject_as_sets &&
+	    aspath_check_as_sets(attr->aspath)) {
 		flog_err(EC_BGP_ATTR_MAL_AS_PATH,
 			 "AS_SET and AS_CONFED_SET are deprecated from %pBP",
 			 peer);
@@ -1690,8 +1695,11 @@ static int bgp_attr_as4_path(struct bgp_attr_parser_args *args,
 	struct peer *const peer = args->peer;
 	struct attr *const attr = args->attr;
 	const bgp_size_t length = args->length;
+	enum asnotation_mode asnotation;
+
+	asnotation = bgp_get_asnotation(peer->bgp);
 
-	*as4_path = aspath_parse(peer->curr, length, 1);
+	*as4_path = aspath_parse(peer->curr, length, 1, asnotation);
 
 	/* In case of IBGP, length will be zero. */
 	if (!*as4_path) {

bgpd/bgp_btoa.c

@@ -86,7 +86,8 @@ static void attr_parse(struct stream *s, uint16_t len)
 		case BGP_ATTR_AS_PATH: {
 			struct aspath *aspath;
 
-			aspath = aspath_parse(s, length, 1);
+			aspath = aspath_parse(s, length, 1,
+					      bgp_get_asnotation(NULL));
 			printf("ASPATH: %s\n", aspath->str);
 			aspath_free(aspath);
 		} break;

bgpd/bgp_debug.c

@@ -2635,6 +2635,7 @@ const char *bgp_debug_rdpfxpath2str(afi_t afi, safi_t safi,
 	char tag_buf[30];
 	char overlay_index_buf[INET6_ADDRSTRLEN + 14];
 	const struct prefix_evpn *evp;
+	int len = 0;
 
 	/* ' with addpath ID '          17
 	 * max strlen of uint32       + 10
@@ -2688,11 +2689,15 @@ const char *bgp_debug_rdpfxpath2str(afi_t afi, safi_t safi,
 		}
 	}
 
-	if (prd)
-		snprintfrr(str, size, "RD %pRD %pFX%s%s%s %s %s", prd, pu.p,
+	if (prd) {
+		len += snprintfrr(str + len, size - len, "RD ");
+		len += snprintfrr(str + len, size - len,
+				  BGP_RD_AS_FORMAT(bgp_get_asnotation(NULL)),
+				  prd);
+		snprintfrr(str + len, size - len, " %pFX%s%s%s %s %s", pu.p,
 			   overlay_index_buf, tag_buf, pathid_buf, afi2str(afi),
 			   safi2str(safi));
-	else if (safi == SAFI_FLOWSPEC) {
+	} else if (safi == SAFI_FLOWSPEC) {
 		char return_string[BGP_FLOWSPEC_NLRI_STRING_MAX];
 		const struct prefix_fs *fs = pu.fs;
 

bgpd/bgp_evpn.c

@@ -5923,6 +5923,8 @@ void bgp_evpn_derive_auto_rd(struct bgp *bgp, struct bgpevpn *vpn)
 	vpn->prd.prefixlen = 64;
 	snprintfrr(buf, sizeof(buf), "%pI4:%hu", &bgp->router_id, vpn->rd_id);
 	(void)str2prefix_rd(buf, &vpn->prd);
+	if (vpn->prd_pretty)
+		XFREE(MTYPE_BGP, vpn->prd_pretty);
 	UNSET_FLAG(vpn->flags, VNI_FLAG_RD_CFGD);
 }
 
@@ -6027,6 +6029,8 @@ void bgp_evpn_free(struct bgp *bgp, struct bgpevpn *vpn)
 	bf_release_index(bm->rd_idspace, vpn->rd_id);
 	hash_release(bgp->vni_svi_hash, vpn);
 	hash_release(bgp->vnihash, vpn);
+	if (vpn->prd_pretty)
+		XFREE(MTYPE_BGP, vpn->prd_pretty);
 	QOBJ_UNREG(vpn);
 	XFREE(MTYPE_BGP_EVPN, vpn);
 }
@@ -6238,13 +6242,14 @@ int bgp_evpn_local_l3vni_add(vni_t l3vni, vrf_id_t vrf_id,
 
 		ret = bgp_get_vty(&bgp_vrf, &as, vrf_id_to_name(vrf_id),
 				  vrf_id == VRF_DEFAULT
-				  ? BGP_INSTANCE_TYPE_DEFAULT
-				  : BGP_INSTANCE_TYPE_VRF);
+					  ? BGP_INSTANCE_TYPE_DEFAULT
+					  : BGP_INSTANCE_TYPE_VRF,
+				  NULL, ASNOTATION_UNDEFINED);
 		switch (ret) {
 		case BGP_ERR_AS_MISMATCH:
 			flog_err(EC_BGP_EVPN_AS_MISMATCH,
-				 "BGP instance is already running; AS is %u",
-				 as);
+				 "BGP instance is already running; AS is %s",
+				 bgp_vrf->as_pretty);
 			return -1;
 		case BGP_ERR_INSTANCE_MISMATCH:
 			flog_err(EC_BGP_EVPN_INSTANCE_MISMATCH,
@@ -6660,6 +6665,9 @@ void bgp_evpn_cleanup(struct bgp *bgp)
 	list_delete(&bgp->vrf_import_rtl);
 	list_delete(&bgp->vrf_export_rtl);
 	list_delete(&bgp->l2vnis);
+
+	if (bgp->vrf_prd_pretty)
+		XFREE(MTYPE_BGP, bgp->vrf_prd_pretty);
 }
 
 /*