[mirror_frr.git] / bgpd / bgp_lcommunity.c

/* BGP Large Communities Attribute
 *
 * Copyright (C) 2016 Keyur Patel <keyur@arrcus.com>
 *
 * This file is part of FreeRangeRouting (FRR).
 *
 * FRR is free software; you can redistribute it and/or modify it under the
 * terms of the GNU General Public License as published by the Free Software
 * Foundation; either version 2, or (at your option) any later version.
 *
 * FRR is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <zebra.h>

#include "hash.h"
#include "memory.h"
#include "prefix.h"
#include "command.h"
#include "filter.h"

#include "bgpd/bgpd.h"
#include "bgpd/bgp_lcommunity.h"
#include "bgpd/bgp_aspath.h"

/* Hash of community attribute. */
static struct hash *lcomhash;

/* Allocate a new lcommunities.  */
static struct lcommunity *lcommunity_new(void)
{
	return (struct lcommunity *)XCALLOC(MTYPE_LCOMMUNITY,
					    sizeof(struct lcommunity));
}

/* Allocate lcommunities.  */
void lcommunity_free(struct lcommunity **lcom)
{
	if ((*lcom)->val)
		XFREE(MTYPE_LCOMMUNITY_VAL, (*lcom)->val);
	if ((*lcom)->str)
		XFREE(MTYPE_LCOMMUNITY_STR, (*lcom)->str);
	XFREE(MTYPE_LCOMMUNITY, *lcom);
	lcom = NULL;
}

static void lcommunity_hash_free(struct lcommunity *lcom)
{
	lcommunity_free(&lcom);
}

/* Add a new Large Communities value to Large Communities
   Attribute structure.  When the value is already exists in the
   structure, we don't add the value.  Newly added value is sorted by
   numerical order.  When the value is added to the structure return 1
   else return 0.  */
static int lcommunity_add_val(struct lcommunity *lcom,
			      struct lcommunity_val *lval)
{
	u_int8_t *p;
	int ret;
	int c;

	/* When this is fist value, just add it.  */
	if (lcom->val == NULL) {
		lcom->size++;
		lcom->val = XMALLOC(MTYPE_LCOMMUNITY_VAL, lcom_length(lcom));
		memcpy(lcom->val, lval->val, LCOMMUNITY_SIZE);
		return 1;
	}

	/* If the value already exists in the structure return 0.  */
	c = 0;
	for (p = lcom->val; c < lcom->size; p += LCOMMUNITY_SIZE, c++) {
		ret = memcmp(p, lval->val, LCOMMUNITY_SIZE);
		if (ret == 0)
			return 0;
		if (ret > 0)
			break;
	}

	/* Add the value to the structure with numerical sorting.  */
	lcom->size++;
	lcom->val =
		XREALLOC(MTYPE_LCOMMUNITY_VAL, lcom->val, lcom_length(lcom));

	memmove(lcom->val + (c + 1) * LCOMMUNITY_SIZE,
		lcom->val + c * LCOMMUNITY_SIZE,
		(lcom->size - 1 - c) * LCOMMUNITY_SIZE);
	memcpy(lcom->val + c * LCOMMUNITY_SIZE, lval->val, LCOMMUNITY_SIZE);

	return 1;
}

/* This function takes pointer to Large Communites strucutre then
   create a new Large Communities structure by uniq and sort each
   Large Communities value.  */
struct lcommunity *lcommunity_uniq_sort(struct lcommunity *lcom)
{
	int i;
	struct lcommunity *new;
	struct lcommunity_val *lval;

	if (!lcom)
		return NULL;

	new = lcommunity_new();

	for (i = 0; i < lcom->size; i++) {
		lval = (struct lcommunity_val *)(lcom->val
						 + (i * LCOMMUNITY_SIZE));
		lcommunity_add_val(new, lval);
	}
	return new;
}

/* Parse Large Communites Attribute in BGP packet.  */
struct lcommunity *lcommunity_parse(u_int8_t *pnt, u_short length)
{
	struct lcommunity tmp;
	struct lcommunity *new;

	/* Length check.  */
	if (length % LCOMMUNITY_SIZE)
		return NULL;

	/* Prepare tmporary structure for making a new Large Communities
	   Attribute.  */
	tmp.size = length / LCOMMUNITY_SIZE;
	tmp.val = pnt;

	/* Create a new Large Communities Attribute by uniq and sort each
	   Large Communities value  */
	new = lcommunity_uniq_sort(&tmp);

	return lcommunity_intern(new);
}

/* Duplicate the Large Communities Attribute structure.  */
struct lcommunity *lcommunity_dup(struct lcommunity *lcom)
{
	struct lcommunity *new;

	new = XCALLOC(MTYPE_LCOMMUNITY, sizeof(struct lcommunity));
	new->size = lcom->size;
	if (new->size) {
		new->val = XMALLOC(MTYPE_LCOMMUNITY_VAL, lcom_length(lcom));
		memcpy(new->val, lcom->val, lcom_length(lcom));
	} else
		new->val = NULL;
	return new;
}

/* Retrun string representation of communities attribute. */
char *lcommunity_str(struct lcommunity *lcom)
{
	if (!lcom->str)
		lcom->str =
			lcommunity_lcom2str(lcom, LCOMMUNITY_FORMAT_DISPLAY);
	return lcom->str;
}

/* Merge two Large Communities Attribute structure.  */
struct lcommunity *lcommunity_merge(struct lcommunity *lcom1,
				    struct lcommunity *lcom2)
{
	if (lcom1->val)
		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));

	memcpy(lcom1->val + lcom_length(lcom1), lcom2->val, lcom_length(lcom2));
	lcom1->size += lcom2->size;

	return lcom1;
}

/* Intern Large Communities Attribute.  */
struct lcommunity *lcommunity_intern(struct lcommunity *lcom)
{
	struct lcommunity *find;

	assert(lcom->refcnt == 0);

	find = (struct lcommunity *)hash_get(lcomhash, lcom, hash_alloc_intern);

	if (find != lcom)
		lcommunity_free(&lcom);

	find->refcnt++;

	if (!find->str)
		find->str =
			lcommunity_lcom2str(find, LCOMMUNITY_FORMAT_DISPLAY);

	return find;
}

/* Unintern Large Communities Attribute.  */
void lcommunity_unintern(struct lcommunity **lcom)
{
	struct lcommunity *ret;

	if ((*lcom)->refcnt)
		(*lcom)->refcnt--;

	/* Pull off from hash.  */
	if ((*lcom)->refcnt == 0) {
		/* Large community must be in the hash.  */
		ret = (struct lcommunity *)hash_release(lcomhash, *lcom);
		assert(ret != NULL);

		lcommunity_free(lcom);
	}
}

/* Utility function to make hash key.  */
unsigned int lcommunity_hash_make(void *arg)
{
	const struct lcommunity *lcom = arg;
	int size = lcom_length(lcom);
	u_int8_t *pnt = lcom->val;
	unsigned int key = 0;
	int c;

	for (c = 0; c < size; c += LCOMMUNITY_SIZE) {
		key += pnt[c];
		key += pnt[c + 1];
		key += pnt[c + 2];
		key += pnt[c + 3];
		key += pnt[c + 4];
		key += pnt[c + 5];
		key += pnt[c + 6];
		key += pnt[c + 7];
		key += pnt[c + 8];
		key += pnt[c + 9];
		key += pnt[c + 10];
		key += pnt[c + 11];
	}

	return key;
}

/* Compare two Large Communities Attribute structure.  */
int lcommunity_cmp(const void *arg1, const void *arg2)
{
	const struct lcommunity *lcom1 = arg1;
	const struct lcommunity *lcom2 = arg2;

	return (lcom1->size == lcom2->size
		&& memcmp(lcom1->val, lcom2->val, lcom_length(lcom1))
			   == 0);
}

/* Return communities hash.  */
struct hash *lcommunity_hash(void)
{
	return lcomhash;
}

/* Initialize Large Comminities related hash. */
void lcommunity_init(void)
{
	lcomhash = hash_create(lcommunity_hash_make, lcommunity_cmp, NULL);
}

void lcommunity_finish(void)
{
	hash_clean(lcomhash, (void (*)(void *))lcommunity_hash_free);
	hash_free(lcomhash);
	lcomhash = NULL;
}

/* Large Communities token enum. */
enum lcommunity_token {
	lcommunity_token_unknown = 0,
	lcommunity_token_val,
};

/* Get next Large Communities token from the string. */
static const char *lcommunity_gettoken(const char *str,
				       struct lcommunity_val *lval,
				       enum lcommunity_token *token)
{
	const char *p = str;

	/* Skip white space. */
	while (isspace((int)*p)) {
		p++;
		str++;
	}

	/* Check the end of the line. */
	if (*p == '\0')
		return NULL;

	/* Community value. */
	if (isdigit((int)*p)) {
		int separator = 0;
		int digit = 0;
		u_int32_t globaladmin = 0;
		u_int32_t localdata1 = 0;
		u_int32_t localdata2 = 0;

		while (isdigit((int)*p) || *p == ':') {
			if (*p == ':') {
				if (separator == 2) {
					*token = lcommunity_token_unknown;
					return NULL;
				} else {
					separator++;
					digit = 0;
					if (separator == 1) {
						globaladmin = localdata2;
					} else {
						localdata1 = localdata2;
					}
					localdata2 = 0;
				}
			} else {
				digit = 1;
				localdata2 *= 10;
				localdata2 += (*p - '0');
			}
			p++;
		}
		if (!digit) {
			*token = lcommunity_token_unknown;
			return NULL;
		}

		/*
		 * Copy the large comm.
		 */
		lval->val[0] = (globaladmin >> 24) & 0xff;
		lval->val[1] = (globaladmin >> 16) & 0xff;
		lval->val[2] = (globaladmin >> 8) & 0xff;
		lval->val[3] = globaladmin & 0xff;
		lval->val[4] = (localdata1 >> 24) & 0xff;
		lval->val[5] = (localdata1 >> 16) & 0xff;
		lval->val[6] = (localdata1 >> 8) & 0xff;
		lval->val[7] = localdata1 & 0xff;
		lval->val[8] = (localdata2 >> 24) & 0xff;
		lval->val[9] = (localdata2 >> 16) & 0xff;
		lval->val[10] = (localdata2 >> 8) & 0xff;
		lval->val[11] = localdata2 & 0xff;

		*token = lcommunity_token_val;
		return p;
	}
	*token = lcommunity_token_unknown;
	return p;
}

/*
  Convert string to large community attribute.
  When type is already known, please specify both str and type.

  When string includes keyword for each large community value.
  Please specify keyword_included as non-zero value.
*/
struct lcommunity *lcommunity_str2com(const char *str)
{
	struct lcommunity *lcom = NULL;
	enum lcommunity_token token = lcommunity_token_unknown;
	struct lcommunity_val lval;

	while ((str = lcommunity_gettoken(str, &lval, &token))) {
		switch (token) {
		case lcommunity_token_val:
			if (lcom == NULL)
				lcom = lcommunity_new();
			lcommunity_add_val(lcom, &lval);
			break;
		case lcommunity_token_unknown:
		default:
			if (lcom)
				lcommunity_free(&lcom);
			return NULL;
		}
	}
	return lcom;
}

int lcommunity_include(struct lcommunity *lcom, u_char *ptr)
{
	int i;
	u_char *lcom_ptr;

	lcom_ptr = lcom->val;
	for (i = 0; i < lcom->size; i++) {
		lcom_ptr += (i * LCOMMUNITY_SIZE);
		if (memcmp(ptr, lcom_ptr, LCOMMUNITY_SIZE) == 0)
			return 1;
	}
	return 0;
}

/* Convert large community attribute to string.
   The large coms will be in 65535:65531:0 format.
*/
char *lcommunity_lcom2str(struct lcommunity *lcom, int format)
{
	int i;
	u_int8_t *pnt;
#define LCOMMUNITY_STR_DEFAULT_LEN  40
	int str_size;
	int str_pnt;
	char *str_buf;
	int len = 0;
	int first = 1;
	u_int32_t globaladmin, localdata1, localdata2;

	if (lcom->size == 0) {
		str_buf = XMALLOC(MTYPE_LCOMMUNITY_STR, 1);
		str_buf[0] = '\0';
		return str_buf;
	}

	/* Prepare buffer.  */
	str_buf = XMALLOC(MTYPE_LCOMMUNITY_STR, LCOMMUNITY_STR_DEFAULT_LEN + 1);
	str_size = LCOMMUNITY_STR_DEFAULT_LEN + 1;
	str_pnt = 0;

	for (i = 0; i < lcom->size; i++) {
		/* Make it sure size is enough.  */
		while (str_pnt + LCOMMUNITY_STR_DEFAULT_LEN >= str_size) {
			str_size *= 2;
			str_buf = XREALLOC(MTYPE_LCOMMUNITY_STR, str_buf,
					   str_size);
		}

		/* Space between each value.  */
		if (!first)
			str_buf[str_pnt++] = ' ';

		pnt = lcom->val + (i * LCOMMUNITY_SIZE);

		globaladmin = (*pnt++ << 24);
		globaladmin |= (*pnt++ << 16);
		globaladmin |= (*pnt++ << 8);
		globaladmin |= (*pnt++);

		localdata1 = (*pnt++ << 24);
		localdata1 |= (*pnt++ << 16);
		localdata1 |= (*pnt++ << 8);
		localdata1 |= (*pnt++);

		localdata2 = (*pnt++ << 24);
		localdata2 |= (*pnt++ << 16);
		localdata2 |= (*pnt++ << 8);
		localdata2 |= (*pnt++);

		len = sprintf(str_buf + str_pnt, "%u:%u:%u", globaladmin,
			      localdata1, localdata2);
		str_pnt += len;
		first = 0;
	}
	return str_buf;
}

int lcommunity_match(const struct lcommunity *lcom1,
		     const struct lcommunity *lcom2)
{
	int i = 0;
	int j = 0;

	if (lcom1 == NULL && lcom2 == NULL)
		return 1;

	if (lcom1 == NULL || lcom2 == NULL)
		return 0;

	if (lcom1->size < lcom2->size)
		return 0;

	/* 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)
		    == 0)
			j++;
		i++;
	}

	if (j == lcom2->size)
		return 1;
	else
		return 0;
}

/* Delete one lcommunity. */
void lcommunity_del_val(struct lcommunity *lcom, u_char *ptr)
{
	int i = 0;
	int c = 0;

	if (!lcom->val)
		return;

	while (i < lcom->size) {
		if (memcmp(lcom->val + i * LCOMMUNITY_SIZE, ptr,
			   LCOMMUNITY_SIZE)
		    == 0) {
			c = lcom->size - i - 1;

			if (c > 0)
				memmove(lcom->val + i * LCOMMUNITY_SIZE,
					lcom->val + (i + 1) * LCOMMUNITY_SIZE,
					c * LCOMMUNITY_SIZE);

			lcom->size--;

			if (lcom->size > 0)
				lcom->val =
					XREALLOC(MTYPE_COMMUNITY_VAL, lcom->val,
						 lcom_length(lcom));
			else {
				XFREE(MTYPE_COMMUNITY_VAL, lcom->val);
				lcom->val = NULL;
			}
			return;
		}
		i++;
	}
}
Commit	Line	Data
57d187bc	1	/* BGP Large Communities Attribute
2acb4ac2 DL	2	*
	3	* Copyright (C) 2016 Keyur Patel <keyur@arrcus.com>
	4	*
	5	* This file is part of FreeRangeRouting (FRR).
	6	*
	7	* FRR is free software; you can redistribute it and/or modify it under the
	8	* terms of the GNU General Public License as published by the Free Software
	9	* Foundation; either version 2, or (at your option) any later version.
	10	*
	11	* FRR is distributed in the hope that it will be useful, but WITHOUT ANY
	12	* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
	13	* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
	14	* details.
	15	*
	16	* You should have received a copy of the GNU General Public License along
896014f4 DL	17	* with this program; see the file COPYING; if not, write to the Free Software
896014f4 DL	18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
2acb4ac2	19	*/
57d187bc JS	20
	21	#include <zebra.h>
	22
	23	#include "hash.h"
	24	#include "memory.h"
	25	#include "prefix.h"
	26	#include "command.h"
	27	#include "filter.h"
	28
	29	#include "bgpd/bgpd.h"
	30	#include "bgpd/bgp_lcommunity.h"
	31	#include "bgpd/bgp_aspath.h"
	32
	33	/* Hash of community attribute. */
	34	static struct hash *lcomhash;
	35
	36	/* Allocate a new lcommunities. */
d62a17ae	37	static struct lcommunity *lcommunity_new(void)
57d187bc	38	{
d62a17ae	39	return (struct lcommunity *)XCALLOC(MTYPE_LCOMMUNITY,
d62a17ae	40	sizeof(struct lcommunity));
57d187bc JS	41	}
	42
	43	/* Allocate lcommunities. */
d62a17ae	44	void lcommunity_free(struct lcommunity **lcom)
57d187bc	45	{
d62a17ae	46	if ((*lcom)->val)
	47	XFREE(MTYPE_LCOMMUNITY_VAL, (*lcom)->val);
	48	if ((*lcom)->str)
	49	XFREE(MTYPE_LCOMMUNITY_STR, (*lcom)->str);
	50	XFREE(MTYPE_LCOMMUNITY, *lcom);
	51	lcom = NULL;
57d187bc JS	52	}
57d187bc JS	53
d62a17ae	54	static void lcommunity_hash_free(struct lcommunity *lcom)
47350fd9	55	{
d62a17ae	56	lcommunity_free(&lcom);
47350fd9 DS	57	}
47350fd9 DS	58
57d187bc JS	59	/* Add a new Large Communities value to Large Communities
	60	Attribute structure. When the value is already exists in the
	61	structure, we don't add the value. Newly added value is sorted by
	62	numerical order. When the value is added to the structure return 1
	63	else return 0. */
d62a17ae	64	static int lcommunity_add_val(struct lcommunity *lcom,
d62a17ae	65	struct lcommunity_val *lval)
57d187bc	66	{
d62a17ae	67	u_int8_t *p;
	68	int ret;
	69	int c;
	70
	71	/* When this is fist value, just add it. */
	72	if (lcom->val == NULL) {
	73	lcom->size++;
	74	lcom->val = XMALLOC(MTYPE_LCOMMUNITY_VAL, lcom_length(lcom));
	75	memcpy(lcom->val, lval->val, LCOMMUNITY_SIZE);
	76	return 1;
	77	}
	78
	79	/* If the value already exists in the structure return 0. */
	80	c = 0;
	81	for (p = lcom->val; c < lcom->size; p += LCOMMUNITY_SIZE, c++) {
	82	ret = memcmp(p, lval->val, LCOMMUNITY_SIZE);
	83	if (ret == 0)
	84	return 0;
	85	if (ret > 0)
	86	break;
	87	}
	88
	89	/* Add the value to the structure with numerical sorting. */
	90	lcom->size++;
	91	lcom->val =
	92	XREALLOC(MTYPE_LCOMMUNITY_VAL, lcom->val, lcom_length(lcom));
	93
	94	memmove(lcom->val + (c + 1) * LCOMMUNITY_SIZE,
	95	lcom->val + c * LCOMMUNITY_SIZE,
	96	(lcom->size - 1 - c) * LCOMMUNITY_SIZE);
	97	memcpy(lcom->val + c * LCOMMUNITY_SIZE, lval->val, LCOMMUNITY_SIZE);
	98
	99	return 1;
57d187bc JS	100	}
	101
	102	/* This function takes pointer to Large Communites strucutre then
	103	create a new Large Communities structure by uniq and sort each
	104	Large Communities value. */
d62a17ae	105	struct lcommunity lcommunity_uniq_sort(struct lcommunity lcom)
57d187bc	106	{
d62a17ae	107	int i;
	108	struct lcommunity *new;
	109	struct lcommunity_val *lval;
57d187bc	110
d62a17ae	111	if (!lcom)
d62a17ae	112	return NULL;
57d187bc	113
d62a17ae	114	new = lcommunity_new();
57d187bc	115
d62a17ae	116	for (i = 0; i < lcom->size; i++) {
	117	lval = (struct lcommunity_val *)(lcom->val
	118	+ (i * LCOMMUNITY_SIZE));
	119	lcommunity_add_val(new, lval);
	120	}
	121	return new;
57d187bc JS	122	}
	123
	124	/* Parse Large Communites Attribute in BGP packet. */
d62a17ae	125	struct lcommunity lcommunity_parse(u_int8_t pnt, u_short length)
57d187bc	126	{
d62a17ae	127	struct lcommunity tmp;
d62a17ae	128	struct lcommunity *new;
57d187bc	129
d62a17ae	130	/* Length check. */
	131	if (length % LCOMMUNITY_SIZE)
	132	return NULL;
57d187bc	133
d62a17ae	134	/* Prepare tmporary structure for making a new Large Communities
	135	Attribute. */
	136	tmp.size = length / LCOMMUNITY_SIZE;
	137	tmp.val = pnt;
57d187bc	138
d62a17ae	139	/* Create a new Large Communities Attribute by uniq and sort each
	140	Large Communities value */
	141	new = lcommunity_uniq_sort(&tmp);
57d187bc	142
d62a17ae	143	return lcommunity_intern(new);
57d187bc JS	144	}
	145
	146	/* Duplicate the Large Communities Attribute structure. */
d62a17ae	147	struct lcommunity lcommunity_dup(struct lcommunity lcom)
57d187bc	148	{
d62a17ae	149	struct lcommunity *new;
	150
	151	new = XCALLOC(MTYPE_LCOMMUNITY, sizeof(struct lcommunity));
	152	new->size = lcom->size;
	153	if (new->size) {
79dab4b7 NK	154	new->val = XMALLOC(MTYPE_LCOMMUNITY_VAL, lcom_length(lcom));
79dab4b7 NK	155	memcpy(new->val, lcom->val, lcom_length(lcom));
d62a17ae	156	} else
	157	new->val = NULL;
	158	return new;
57d187bc JS	159	}
	160
	161	/* Retrun string representation of communities attribute. */
d62a17ae	162	char lcommunity_str(struct lcommunity lcom)
57d187bc	163	{
d62a17ae	164	if (!lcom->str)
	165	lcom->str =
	166	lcommunity_lcom2str(lcom, LCOMMUNITY_FORMAT_DISPLAY);
	167	return lcom->str;
57d187bc JS	168	}
	169
	170	/* Merge two Large Communities Attribute structure. */
d62a17ae	171	struct lcommunity lcommunity_merge(struct lcommunity lcom1,
d62a17ae	172	struct lcommunity *lcom2)
57d187bc	173	{
d62a17ae	174	if (lcom1->val)
	175	lcom1->val =
	176	XREALLOC(MTYPE_LCOMMUNITY_VAL, lcom1->val,
79dab4b7	177	lcom_length(lcom1) + lcom_length(lcom2));
d62a17ae	178	else
	179	lcom1->val =
	180	XMALLOC(MTYPE_LCOMMUNITY_VAL,
79dab4b7	181	lcom_length(lcom1) + lcom_length(lcom2));
d62a17ae	182
79dab4b7	183	memcpy(lcom1->val + lcom_length(lcom1), lcom2->val, lcom_length(lcom2));
d62a17ae	184	lcom1->size += lcom2->size;
	185
	186	return lcom1;
57d187bc JS	187	}
	188
	189	/* Intern Large Communities Attribute. */
d62a17ae	190	struct lcommunity lcommunity_intern(struct lcommunity lcom)
57d187bc	191	{
d62a17ae	192	struct lcommunity *find;
57d187bc	193
d62a17ae	194	assert(lcom->refcnt == 0);
57d187bc	195
d62a17ae	196	find = (struct lcommunity *)hash_get(lcomhash, lcom, hash_alloc_intern);
57d187bc	197
d62a17ae	198	if (find != lcom)
d62a17ae	199	lcommunity_free(&lcom);
57d187bc	200
d62a17ae	201	find->refcnt++;
57d187bc	202
d62a17ae	203	if (!find->str)
	204	find->str =
	205	lcommunity_lcom2str(find, LCOMMUNITY_FORMAT_DISPLAY);
57d187bc	206
d62a17ae	207	return find;
57d187bc JS	208	}
	209
	210	/* Unintern Large Communities Attribute. */
d62a17ae	211	void lcommunity_unintern(struct lcommunity **lcom)
57d187bc	212	{
d62a17ae	213	struct lcommunity *ret;
57d187bc	214
d62a17ae	215	if ((*lcom)->refcnt)
d62a17ae	216	(*lcom)->refcnt--;
57d187bc	217
d62a17ae	218	/* Pull off from hash. */
	219	if ((*lcom)->refcnt == 0) {
	220	/* Large community must be in the hash. */
	221	ret = (struct lcommunity )hash_release(lcomhash, lcom);
	222	assert(ret != NULL);
57d187bc	223
d62a17ae	224	lcommunity_free(lcom);
d62a17ae	225	}
57d187bc JS	226	}
	227
	228	/* Utility function to make hash key. */
d62a17ae	229	unsigned int lcommunity_hash_make(void *arg)
57d187bc	230	{
d62a17ae	231	const struct lcommunity *lcom = arg;
79dab4b7	232	int size = lcom_length(lcom);
d62a17ae	233	u_int8_t *pnt = lcom->val;
	234	unsigned int key = 0;
	235	int c;
	236
	237	for (c = 0; c < size; c += LCOMMUNITY_SIZE) {
	238	key += pnt[c];
	239	key += pnt[c + 1];
	240	key += pnt[c + 2];
	241	key += pnt[c + 3];
	242	key += pnt[c + 4];
	243	key += pnt[c + 5];
	244	key += pnt[c + 6];
	245	key += pnt[c + 7];
	246	key += pnt[c + 8];
	247	key += pnt[c + 9];
	248	key += pnt[c + 10];
	249	key += pnt[c + 11];
	250	}
	251
	252	return key;
57d187bc JS	253	}
	254
	255	/* Compare two Large Communities Attribute structure. */
d62a17ae	256	int lcommunity_cmp(const void arg1, const void arg2)
57d187bc	257	{
d62a17ae	258	const struct lcommunity *lcom1 = arg1;
d62a17ae	259	const struct lcommunity *lcom2 = arg2;
57d187bc	260
d62a17ae	261	return (lcom1->size == lcom2->size
79dab4b7	262	&& memcmp(lcom1->val, lcom2->val, lcom_length(lcom1))
d62a17ae	263	== 0);
57d187bc JS	264	}
	265
	266	/* Return communities hash. */
d62a17ae	267	struct hash *lcommunity_hash(void)
57d187bc	268	{
d62a17ae	269	return lcomhash;
57d187bc JS	270	}
	271
	272	/* Initialize Large Comminities related hash. */
d62a17ae	273	void lcommunity_init(void)
57d187bc	274	{
d62a17ae	275	lcomhash = hash_create(lcommunity_hash_make, lcommunity_cmp, NULL);
57d187bc JS	276	}
57d187bc JS	277
d62a17ae	278	void lcommunity_finish(void)
57d187bc	279	{
d62a17ae	280	hash_clean(lcomhash, (void ()(void ))lcommunity_hash_free);
	281	hash_free(lcomhash);
	282	lcomhash = NULL;
57d187bc JS	283	}
	284
	285	/* Large Communities token enum. */
d62a17ae	286	enum lcommunity_token {
	287	lcommunity_token_unknown = 0,
	288	lcommunity_token_val,
57d187bc JS	289	};
	290
	291	/* Get next Large Communities token from the string. */
d62a17ae	292	static const char lcommunity_gettoken(const char str,
	293	struct lcommunity_val *lval,
	294	enum lcommunity_token *token)
57d187bc	295	{
d62a17ae	296	const char *p = str;
	297
	298	/* Skip white space. */
	299	while (isspace((int)*p)) {
	300	p++;
	301	str++;
	302	}
	303
	304	/* Check the end of the line. */
	305	if (*p == '\0')
	306	return NULL;
	307
	308	/* Community value. */
	309	if (isdigit((int)*p)) {
	310	int separator = 0;
	311	int digit = 0;
	312	u_int32_t globaladmin = 0;
	313	u_int32_t localdata1 = 0;
	314	u_int32_t localdata2 = 0;
	315
	316	while (isdigit((int)p) \|\| p == ':') {
	317	if (*p == ':') {
	318	if (separator == 2) {
	319	*token = lcommunity_token_unknown;
	320	return NULL;
	321	} else {
	322	separator++;
	323	digit = 0;
	324	if (separator == 1) {
	325	globaladmin = localdata2;
	326	} else {
	327	localdata1 = localdata2;
	328	}
	329	localdata2 = 0;
	330	}
	331	} else {
	332	digit = 1;
	333	localdata2 *= 10;
	334	localdata2 += (*p - '0');
	335	}
	336	p++;
57d187bc	337	}
d62a17ae	338	if (!digit) {
	339	*token = lcommunity_token_unknown;
	340	return NULL;
57d187bc	341	}
57d187bc	342
d62a17ae	343	/*
	344	* Copy the large comm.
	345	*/
	346	lval->val[0] = (globaladmin >> 24) & 0xff;
	347	lval->val[1] = (globaladmin >> 16) & 0xff;
	348	lval->val[2] = (globaladmin >> 8) & 0xff;
	349	lval->val[3] = globaladmin & 0xff;
	350	lval->val[4] = (localdata1 >> 24) & 0xff;
	351	lval->val[5] = (localdata1 >> 16) & 0xff;
	352	lval->val[6] = (localdata1 >> 8) & 0xff;
	353	lval->val[7] = localdata1 & 0xff;
	354	lval->val[8] = (localdata2 >> 24) & 0xff;
	355	lval->val[9] = (localdata2 >> 16) & 0xff;
	356	lval->val[10] = (localdata2 >> 8) & 0xff;
	357	lval->val[11] = localdata2 & 0xff;
	358
	359	*token = lcommunity_token_val;
	360	return p;
	361	}
	362	*token = lcommunity_token_unknown;
	363	return p;
57d187bc JS	364	}
	365
	366	/*
	367	Convert string to large community attribute.
	368	When type is already known, please specify both str and type.
	369
	370	When string includes keyword for each large community value.
	371	Please specify keyword_included as non-zero value.
	372	*/
d62a17ae	373	struct lcommunity lcommunity_str2com(const char str)
57d187bc	374	{
d62a17ae	375	struct lcommunity *lcom = NULL;
	376	enum lcommunity_token token = lcommunity_token_unknown;
	377	struct lcommunity_val lval;
	378
	379	while ((str = lcommunity_gettoken(str, &lval, &token))) {
	380	switch (token) {
	381	case lcommunity_token_val:
	382	if (lcom == NULL)
	383	lcom = lcommunity_new();
	384	lcommunity_add_val(lcom, &lval);
	385	break;
	386	case lcommunity_token_unknown:
	387	default:
	388	if (lcom)
	389	lcommunity_free(&lcom);
	390	return NULL;
	391	}
	392	}
	393	return lcom;
57d187bc JS	394	}
57d187bc JS	395
d62a17ae	396	int lcommunity_include(struct lcommunity lcom, u_char ptr)
57d187bc	397	{
d62a17ae	398	int i;
	399	u_char *lcom_ptr;
	400
	401	lcom_ptr = lcom->val;
	402	for (i = 0; i < lcom->size; i++) {
	403	lcom_ptr += (i * LCOMMUNITY_SIZE);
	404	if (memcmp(ptr, lcom_ptr, LCOMMUNITY_SIZE) == 0)
	405	return 1;
	406	}
	407	return 0;
57d187bc JS	408	}
	409
	410	/* Convert large community attribute to string.
	411	The large coms will be in 65535:65531:0 format.
	412	*/
d62a17ae	413	char lcommunity_lcom2str(struct lcommunity lcom, int format)
57d187bc	414	{
d62a17ae	415	int i;
d62a17ae	416	u_int8_t *pnt;
57d187bc	417	#define LCOMMUNITY_STR_DEFAULT_LEN 40
d62a17ae	418	int str_size;
	419	int str_pnt;
	420	char *str_buf;
	421	int len = 0;
	422	int first = 1;
	423	u_int32_t globaladmin, localdata1, localdata2;
	424
	425	if (lcom->size == 0) {
	426	str_buf = XMALLOC(MTYPE_LCOMMUNITY_STR, 1);
	427	str_buf[0] = '\0';
	428	return str_buf;
57d187bc JS	429	}
57d187bc JS	430
d62a17ae	431	/* Prepare buffer. */
	432	str_buf = XMALLOC(MTYPE_LCOMMUNITY_STR, LCOMMUNITY_STR_DEFAULT_LEN + 1);
	433	str_size = LCOMMUNITY_STR_DEFAULT_LEN + 1;
	434	str_pnt = 0;
	435
	436	for (i = 0; i < lcom->size; i++) {
	437	/* Make it sure size is enough. */
	438	while (str_pnt + LCOMMUNITY_STR_DEFAULT_LEN >= str_size) {
	439	str_size *= 2;
	440	str_buf = XREALLOC(MTYPE_LCOMMUNITY_STR, str_buf,
	441	str_size);
	442	}
	443
	444	/* Space between each value. */
	445	if (!first)
	446	str_buf[str_pnt++] = ' ';
	447
8ea01902	448	pnt = lcom->val + (i * LCOMMUNITY_SIZE);
d62a17ae	449
	450	globaladmin = (*pnt++ << 24);
	451	globaladmin \|= (*pnt++ << 16);
	452	globaladmin \|= (*pnt++ << 8);
	453	globaladmin \|= (*pnt++);
	454
	455	localdata1 = (*pnt++ << 24);
	456	localdata1 \|= (*pnt++ << 16);
	457	localdata1 \|= (*pnt++ << 8);
	458	localdata1 \|= (*pnt++);
	459
	460	localdata2 = (*pnt++ << 24);
	461	localdata2 \|= (*pnt++ << 16);
	462	localdata2 \|= (*pnt++ << 8);
	463	localdata2 \|= (*pnt++);
	464
	465	len = sprintf(str_buf + str_pnt, "%u:%u:%u", globaladmin,
	466	localdata1, localdata2);
	467	str_pnt += len;
	468	first = 0;
	469	}
	470	return str_buf;
57d187bc JS	471	}
57d187bc JS	472
d62a17ae	473	int lcommunity_match(const struct lcommunity *lcom1,
d62a17ae	474	const struct lcommunity *lcom2)
57d187bc	475	{
d62a17ae	476	int i = 0;
	477	int j = 0;
	478
	479	if (lcom1 == NULL && lcom2 == NULL)
	480	return 1;
	481
	482	if (lcom1 == NULL \|\| lcom2 == NULL)
	483	return 0;
	484
	485	if (lcom1->size < lcom2->size)
	486	return 0;
	487
	488	/* Every community on com2 needs to be on com1 for this to match */
	489	while (i < lcom1->size && j < lcom2->size) {
8ea01902	490	if (memcmp(lcom1->val + (i * LCOMMUNITY_SIZE), lcom2->val + (j * LCOMMUNITY_SIZE),
d62a17ae	491	LCOMMUNITY_SIZE)
	492	== 0)
	493	j++;
	494	i++;
	495	}
	496
	497	if (j == lcom2->size)
	498	return 1;
	499	else
	500	return 0;
57d187bc JS	501	}
	502
	503	/* Delete one lcommunity. */
d62a17ae	504	void lcommunity_del_val(struct lcommunity lcom, u_char ptr)
57d187bc	505	{
d62a17ae	506	int i = 0;
	507	int c = 0;
	508
	509	if (!lcom->val)
	510	return;
	511
	512	while (i < lcom->size) {
	513	if (memcmp(lcom->val + i * LCOMMUNITY_SIZE, ptr,
	514	LCOMMUNITY_SIZE)
	515	== 0) {
	516	c = lcom->size - i - 1;
	517
	518	if (c > 0)
	519	memmove(lcom->val + i * LCOMMUNITY_SIZE,
	520	lcom->val + (i + 1) * LCOMMUNITY_SIZE,
	521	c * LCOMMUNITY_SIZE);
	522
	523	lcom->size--;
	524
	525	if (lcom->size > 0)
	526	lcom->val =
	527	XREALLOC(MTYPE_COMMUNITY_VAL, lcom->val,
	528	lcom_length(lcom));
	529	else {
	530	XFREE(MTYPE_COMMUNITY_VAL, lcom->val);
	531	lcom->val = NULL;
	532	}
	533	return;
	534	}
	535	i++;
57d187bc	536	}
57d187bc	537	}