1 files changed, 68 insertions, 68 deletions

diff --git a/src/set_elem.c b/src/set_elem.c
index b66af58..3dd1658 100644
--- a/src/set_elem.c
+++ b/src/set_elem.c
@@ -41,14 +41,14 @@ EXPORT_SYMBOL(nftnl_set_elem_alloc, nft_set_elem_alloc);
 
 void nftnl_set_elem_free(struct nftnl_set_elem *s)
 {
-	if (s->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN)) {
+	if (s->flags & (1 << NFTNL_SET_ELEM_CHAIN)) {
 		if (s->data.chain) {
 			xfree(s->data.chain);
 			s->data.chain = NULL;
 		}
 	}
 
-	if (s->flags & (1 << NFTNL_SET_ELEM_ATTR_EXPR))
+	if (s->flags & (1 << NFTNL_SET_ELEM_EXPR))
 		nftnl_expr_free(s->expr);
 
 	xfree(s);
@@ -64,24 +64,24 @@ EXPORT_SYMBOL(nftnl_set_elem_attr_is_set, nft_set_elem_attr_is_set);
 void nftnl_set_elem_attr_unset(struct nftnl_set_elem *s, uint16_t attr)
 {
 	switch (attr) {
-	case NFTNL_SET_ELEM_ATTR_CHAIN:
-		if (s->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN)) {
+	case NFTNL_SET_ELEM_CHAIN:
+		if (s->flags & (1 << NFTNL_SET_ELEM_CHAIN)) {
 			if (s->data.chain) {
 				xfree(s->data.chain);
 				s->data.chain = NULL;
 			}
 		}
 		break;
-	case NFTNL_SET_ELEM_ATTR_FLAGS:
-	case NFTNL_SET_ELEM_ATTR_KEY:	/* NFTA_SET_ELEM_KEY */
-	case NFTNL_SET_ELEM_ATTR_VERDICT:	/* NFTA_SET_ELEM_DATA */
-	case NFTNL_SET_ELEM_ATTR_DATA:	/* NFTA_SET_ELEM_DATA */
-	case NFTNL_SET_ELEM_ATTR_TIMEOUT:	/* NFTA_SET_ELEM_TIMEOUT */
-	case NFTNL_SET_ELEM_ATTR_EXPIRATION:	/* NFTA_SET_ELEM_EXPIRATION */
-	case NFTNL_SET_ELEM_ATTR_USERDATA:	/* NFTA_SET_ELEM_USERDATA */
+	case NFTNL_SET_ELEM_FLAGS:
+	case NFTNL_SET_ELEM_KEY:	/* NFTA_SET_ELEM_KEY */
+	case NFTNL_SET_ELEM_VERDICT:	/* NFTA_SET_ELEM_DATA */
+	case NFTNL_SET_ELEM_DATA:	/* NFTA_SET_ELEM_DATA */
+	case NFTNL_SET_ELEM_TIMEOUT:	/* NFTA_SET_ELEM_TIMEOUT */
+	case NFTNL_SET_ELEM_EXPIRATION:	/* NFTA_SET_ELEM_EXPIRATION */
+	case NFTNL_SET_ELEM_USERDATA:	/* NFTA_SET_ELEM_USERDATA */
 		break;
-	case NFTNL_SET_ELEM_ATTR_EXPR:
-		if (s->flags & (1 << NFTNL_SET_ELEM_ATTR_EXPR)) {
+	case NFTNL_SET_ELEM_EXPR:
+		if (s->flags & (1 << NFTNL_SET_ELEM_EXPR)) {
 			nftnl_expr_free(s->expr);
 			s->expr = NULL;
 		}
@@ -98,30 +98,30 @@ void nftnl_set_elem_attr_set(struct nftnl_set_elem *s, uint16_t attr,
 			   const void *data, uint32_t data_len)
 {
 	switch(attr) {
-	case NFTNL_SET_ELEM_ATTR_FLAGS:
+	case NFTNL_SET_ELEM_FLAGS:
 		s->set_elem_flags = *((uint32_t *)data);
 		break;
-	case NFTNL_SET_ELEM_ATTR_KEY:	/* NFTA_SET_ELEM_KEY */
+	case NFTNL_SET_ELEM_KEY:	/* NFTA_SET_ELEM_KEY */
 		memcpy(&s->key.val, data, data_len);
 		s->key.len = data_len;
 		break;
-	case NFTNL_SET_ELEM_ATTR_VERDICT:	/* NFTA_SET_ELEM_DATA */
+	case NFTNL_SET_ELEM_VERDICT:	/* NFTA_SET_ELEM_DATA */
 		s->data.verdict = *((uint32_t *)data);
 		break;
-	case NFTNL_SET_ELEM_ATTR_CHAIN:	/* NFTA_SET_ELEM_DATA */
+	case NFTNL_SET_ELEM_CHAIN:	/* NFTA_SET_ELEM_DATA */
 		if (s->data.chain)
 			xfree(s->data.chain);
 
 		s->data.chain = strdup(data);
 		break;
-	case NFTNL_SET_ELEM_ATTR_DATA:	/* NFTA_SET_ELEM_DATA */
+	case NFTNL_SET_ELEM_DATA:	/* NFTA_SET_ELEM_DATA */
 		memcpy(s->data.val, data, data_len);
 		s->data.len = data_len;
 		break;
-	case NFTNL_SET_ELEM_ATTR_TIMEOUT:	/* NFTA_SET_ELEM_TIMEOUT */
+	case NFTNL_SET_ELEM_TIMEOUT:	/* NFTA_SET_ELEM_TIMEOUT */
 		s->timeout = *((uint64_t *)data);
 		break;
-	case NFTNL_SET_ELEM_ATTR_USERDATA: /* NFTA_SET_ELEM_USERDATA */
+	case NFTNL_SET_ELEM_USERDATA: /* NFTA_SET_ELEM_USERDATA */
 		s->user.data = (void *)data;
 		s->user.len  = data_len;
 		break;
@@ -156,26 +156,26 @@ const void *nftnl_set_elem_attr_get(struct nftnl_set_elem *s, uint16_t attr, uin
 		return NULL;
 
 	switch(attr) {
-	case NFTNL_SET_ELEM_ATTR_FLAGS:
+	case NFTNL_SET_ELEM_FLAGS:
 		return &s->set_elem_flags;
-	case NFTNL_SET_ELEM_ATTR_KEY:	/* NFTA_SET_ELEM_KEY */
+	case NFTNL_SET_ELEM_KEY:	/* NFTA_SET_ELEM_KEY */
 		*data_len = s->key.len;
 		return &s->key.val;
-	case NFTNL_SET_ELEM_ATTR_VERDICT:	/* NFTA_SET_ELEM_DATA */
+	case NFTNL_SET_ELEM_VERDICT:	/* NFTA_SET_ELEM_DATA */
 		return &s->data.verdict;
-	case NFTNL_SET_ELEM_ATTR_CHAIN:	/* NFTA_SET_ELEM_DATA */
+	case NFTNL_SET_ELEM_CHAIN:	/* NFTA_SET_ELEM_DATA */
 		return s->data.chain;
-	case NFTNL_SET_ELEM_ATTR_DATA:	/* NFTA_SET_ELEM_DATA */
+	case NFTNL_SET_ELEM_DATA:	/* NFTA_SET_ELEM_DATA */
 		*data_len = s->data.len;
 		return &s->data.val;
-	case NFTNL_SET_ELEM_ATTR_TIMEOUT:	/* NFTA_SET_ELEM_TIMEOUT */
+	case NFTNL_SET_ELEM_TIMEOUT:	/* NFTA_SET_ELEM_TIMEOUT */
 		return &s->timeout;
-	case NFTNL_SET_ELEM_ATTR_EXPIRATION:	/* NFTA_SET_ELEM_EXPIRATION */
+	case NFTNL_SET_ELEM_EXPIRATION:	/* NFTA_SET_ELEM_EXPIRATION */
 		return &s->expiration;
-	case NFTNL_SET_ELEM_ATTR_USERDATA:
+	case NFTNL_SET_ELEM_USERDATA:
 		*data_len = s->user.len;
 		return s->user.data;
-	case NFTNL_SET_ELEM_ATTR_EXPR:
+	case NFTNL_SET_ELEM_EXPR:
 		return s->expr;
 	}
 	return NULL;
@@ -216,7 +216,7 @@ struct nftnl_set_elem *nftnl_set_elem_clone(struct nftnl_set_elem *elem)
 
 	memcpy(newelem, elem, sizeof(*elem));
 
-	if (elem->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN))
+	if (elem->flags & (1 << NFTNL_SET_ELEM_CHAIN))
 		newelem->data.chain = strdup(elem->data.chain);
 
 	return newelem;
@@ -225,48 +225,48 @@ struct nftnl_set_elem *nftnl_set_elem_clone(struct nftnl_set_elem *elem)
 void nftnl_set_elem_nlmsg_build_payload(struct nlmsghdr *nlh,
 				      struct nftnl_set_elem *e)
 {
-	if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_FLAGS))
+	if (e->flags & (1 << NFTNL_SET_ELEM_FLAGS))
 		mnl_attr_put_u32(nlh, NFTA_SET_ELEM_FLAGS, htonl(e->set_elem_flags));
-	if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_TIMEOUT))
+	if (e->flags & (1 << NFTNL_SET_ELEM_TIMEOUT))
 		mnl_attr_put_u64(nlh, NFTA_SET_ELEM_TIMEOUT, htobe64(e->timeout));
-	if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_KEY)) {
+	if (e->flags & (1 << NFTNL_SET_ELEM_KEY)) {
 		struct nlattr *nest1;
 
 		nest1 = mnl_attr_nest_start(nlh, NFTA_SET_ELEM_KEY);
 		mnl_attr_put(nlh, NFTA_DATA_VALUE, e->key.len, e->key.val);
 		mnl_attr_nest_end(nlh, nest1);
 	}
-	if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_VERDICT)) {
+	if (e->flags & (1 << NFTNL_SET_ELEM_VERDICT)) {
 		struct nlattr *nest1, *nest2;
 
 		nest1 = mnl_attr_nest_start(nlh, NFTA_SET_ELEM_DATA);
 		nest2 = mnl_attr_nest_start(nlh, NFTA_DATA_VERDICT);
 		mnl_attr_put_u32(nlh, NFTA_VERDICT_CODE, htonl(e->data.verdict));
-		if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN))
+		if (e->flags & (1 << NFTNL_SET_ELEM_CHAIN))
 			mnl_attr_put_strz(nlh, NFTA_VERDICT_CHAIN, e->data.chain);
 
 		mnl_attr_nest_end(nlh, nest1);
 		mnl_attr_nest_end(nlh, nest2);
 	}
-	if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_DATA)) {
+	if (e->flags & (1 << NFTNL_SET_ELEM_DATA)) {
 		struct nlattr *nest1;
 
 		nest1 = mnl_attr_nest_start(nlh, NFTA_SET_ELEM_DATA);
 		mnl_attr_put(nlh, NFTA_DATA_VALUE, e->data.len, e->data.val);
 		mnl_attr_nest_end(nlh, nest1);
 	}
-	if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_USERDATA))
+	if (e->flags & (1 << NFTNL_SET_ELEM_USERDATA))
 		mnl_attr_put(nlh, NFTA_SET_ELEM_USERDATA, e->user.len, e->user.data);
 }
 
 static void nftnl_set_elem_nlmsg_build_def(struct nlmsghdr *nlh,
 					 struct nftnl_set *s)
 {
-	if (s->flags & (1 << NFTNL_SET_ATTR_NAME))
+	if (s->flags & (1 << NFTNL_SET_NAME))
 		mnl_attr_put_strz(nlh, NFTA_SET_ELEM_LIST_SET, s->name);
-	if (s->flags & (1 << NFTNL_SET_ATTR_ID))
+	if (s->flags & (1 << NFTNL_SET_ID))
 		mnl_attr_put_u32(nlh, NFTA_SET_ELEM_LIST_SET_ID, htonl(s->id));
-	if (s->flags & (1 << NFTNL_SET_ATTR_TABLE))
+	if (s->flags & (1 << NFTNL_SET_TABLE))
 		mnl_attr_put_strz(nlh, NFTA_SET_ELEM_LIST_TABLE, s->table);
 }
 
@@ -350,32 +350,32 @@ static int nftnl_set_elems_parse2(struct nftnl_set *s, const struct nlattr *nest
 	if (tb[NFTA_SET_ELEM_FLAGS]) {
 		e->set_elem_flags =
 			ntohl(mnl_attr_get_u32(tb[NFTA_SET_ELEM_FLAGS]));
-		e->flags |= (1 << NFTNL_SET_ELEM_ATTR_FLAGS);
+		e->flags |= (1 << NFTNL_SET_ELEM_FLAGS);
 	}
 	if (tb[NFTA_SET_ELEM_TIMEOUT]) {
 		e->timeout = be64toh(mnl_attr_get_u64(tb[NFTA_SET_ELEM_TIMEOUT]));
-		e->flags |= (1 << NFTNL_SET_ELEM_ATTR_TIMEOUT);
+		e->flags |= (1 << NFTNL_SET_ELEM_TIMEOUT);
 	}
 	if (tb[NFTA_SET_ELEM_EXPIRATION]) {
 		e->expiration = be64toh(mnl_attr_get_u64(tb[NFTA_SET_ELEM_EXPIRATION]));
-		e->flags |= (1 << NFTNL_SET_ELEM_ATTR_EXPIRATION);
+		e->flags |= (1 << NFTNL_SET_ELEM_EXPIRATION);
 	}
         if (tb[NFTA_SET_ELEM_KEY]) {
 		ret = nftnl_parse_data(&e->key, tb[NFTA_SET_ELEM_KEY], &type);
-		e->flags |= (1 << NFTNL_SET_ELEM_ATTR_KEY);
+		e->flags |= (1 << NFTNL_SET_ELEM_KEY);
         }
         if (tb[NFTA_SET_ELEM_DATA]) {
 		ret = nftnl_parse_data(&e->data, tb[NFTA_SET_ELEM_DATA], &type);
 		switch(type) {
 		case DATA_VERDICT:
-			e->flags |= (1 << NFTNL_SET_ELEM_ATTR_VERDICT);
+			e->flags |= (1 << NFTNL_SET_ELEM_VERDICT);
 			break;
 		case DATA_CHAIN:
-			e->flags |= (1 << NFTNL_SET_ELEM_ATTR_VERDICT) |
-				    (1 << NFTNL_SET_ELEM_ATTR_CHAIN);
+			e->flags |= (1 << NFTNL_SET_ELEM_VERDICT) |
+				    (1 << NFTNL_SET_ELEM_CHAIN);
 			break;
 		case DATA_VALUE:
-			e->flags |= (1 << NFTNL_SET_ELEM_ATTR_DATA);
+			e->flags |= (1 << NFTNL_SET_ELEM_DATA);
 			break;
 		}
         }
@@ -383,7 +383,7 @@ static int nftnl_set_elems_parse2(struct nftnl_set *s, const struct nlattr *nest
 		e->expr = nftnl_expr_parse(tb[NFTA_SET_ELEM_EXPR]);
 		if (e->expr == NULL)
 			goto err;
-		e->flags |= (1 << NFTNL_SET_ELEM_ATTR_EXPR);
+		e->flags |= (1 << NFTNL_SET_ELEM_EXPR);
 	}
 	if (tb[NFTA_SET_ELEM_USERDATA]) {
 		const void *udata =
@@ -397,7 +397,7 @@ static int nftnl_set_elems_parse2(struct nftnl_set *s, const struct nlattr *nest
 		if (e->user.data == NULL)
 			goto err;
 		memcpy(e->user.data, udata, e->user.len);
-		e->flags |= (1 << NFTNL_RULE_ATTR_USERDATA);
+		e->flags |= (1 << NFTNL_RULE_USERDATA);
 	}
 
 	if (ret < 0) {
@@ -465,23 +465,23 @@ int nftnl_set_elems_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
 		xfree(s->table);
 		s->table =
 			strdup(mnl_attr_get_str(tb[NFTA_SET_ELEM_LIST_TABLE]));
-		s->flags |= (1 << NFTNL_SET_ATTR_TABLE);
+		s->flags |= (1 << NFTNL_SET_TABLE);
 	}
 	if (tb[NFTA_SET_ELEM_LIST_SET]) {
 		xfree(s->name);
 		s->name =
 			strdup(mnl_attr_get_str(tb[NFTA_SET_ELEM_LIST_SET]));
-		s->flags |= (1 << NFTNL_SET_ATTR_NAME);
+		s->flags |= (1 << NFTNL_SET_NAME);
 	}
 	if (tb[NFTA_SET_ELEM_LIST_SET_ID]) {
 		s->id = ntohl(mnl_attr_get_u32(tb[NFTA_SET_ELEM_LIST_SET_ID]));
-		s->flags |= (1 << NFTNL_SET_ATTR_ID);
+		s->flags |= (1 << NFTNL_SET_ID);
 	}
         if (tb[NFTA_SET_ELEM_LIST_ELEMENTS])
 	 	ret = nftnl_set_elems_parse(s, tb[NFTA_SET_ELEM_LIST_ELEMENTS]);
 
 	s->family = nfg->nfgen_family;
-	s->flags |= (1 << NFTNL_SET_ATTR_FAMILY);
+	s->flags |= (1 << NFTNL_SET_FAMILY);
 
 	return ret;
 }
@@ -497,23 +497,23 @@ int nftnl_mxml_set_elem_parse(mxml_node_t *tree, struct nftnl_set_elem *e,
 	if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC,
 			       &set_elem_flags, NFTNL_TYPE_U32, NFTNL_XML_MAND,
 			       err) == 0)
-		nftnl_set_elem_attr_set_u32(e, NFTNL_SET_ELEM_ATTR_FLAGS, set_elem_flags);
+		nftnl_set_elem_attr_set_u32(e, NFTNL_SET_ELEM_FLAGS, set_elem_flags);
 
 	if (nftnl_mxml_data_reg_parse(tree, "key", &e->key,
 				    NFTNL_XML_MAND, err) == DATA_VALUE)
-		e->flags |= (1 << NFTNL_SET_ELEM_ATTR_KEY);
+		e->flags |= (1 << NFTNL_SET_ELEM_KEY);
 
 	/* <set_elem_data> is not mandatory */
 	set_elem_data = nftnl_mxml_data_reg_parse(tree, "data",
 						&e->data, NFTNL_XML_OPT, err);
 	switch (set_elem_data) {
 	case DATA_VALUE:
-		e->flags |= (1 << NFTNL_SET_ELEM_ATTR_DATA);
+		e->flags |= (1 << NFTNL_SET_ELEM_DATA);
 		break;
 	case DATA_VERDICT:
-		e->flags |= (1 << NFTNL_SET_ELEM_ATTR_VERDICT);
+		e->flags |= (1 << NFTNL_SET_ELEM_VERDICT);
 		if (e->data.chain != NULL)
-			e->flags |= (1 << NFTNL_SET_ELEM_ATTR_CHAIN);
+			e->flags |= (1 << NFTNL_SET_ELEM_CHAIN);
 
 		break;
 	}
@@ -603,7 +603,7 @@ static int nftnl_set_elem_snprintf_json(char *buf, size_t size,
 {
 	int ret, len = size, offset = 0, type = -1;
 
-	if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_FLAGS)) {
+	if (e->flags & (1 << NFTNL_SET_ELEM_FLAGS)) {
 		ret = snprintf(buf, len, "\"flags\":%u,", e->set_elem_flags);
 		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 	}
@@ -618,11 +618,11 @@ static int nftnl_set_elem_snprintf_json(char *buf, size_t size,
 	ret = snprintf(buf + offset, len, "}");
 	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 
-	if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_DATA))
+	if (e->flags & (1 << NFTNL_SET_ELEM_DATA))
 		type = DATA_VALUE;
-	else if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN))
+	else if (e->flags & (1 << NFTNL_SET_ELEM_CHAIN))
 		type = DATA_CHAIN;
-	else if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_VERDICT))
+	else if (e->flags & (1 << NFTNL_SET_ELEM_VERDICT))
 		type = DATA_VERDICT;
 
 	if (type != -1) {
@@ -691,13 +691,13 @@ static int nftnl_set_elem_snprintf_xml(char *buf, size_t size,
 	ret = snprintf(buf, size, "<set_elem>");
 	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 
-	if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_FLAGS)) {
+	if (e->flags & (1 << NFTNL_SET_ELEM_FLAGS)) {
 		ret = snprintf(buf + offset, size, "<flags>%u</flags>",
 			       e->set_elem_flags);
 		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 	}
 
-	if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_KEY)) {
+	if (e->flags & (1 << NFTNL_SET_ELEM_KEY)) {
 		ret = snprintf(buf + offset, len, "<key>");
 		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 
@@ -709,11 +709,11 @@ static int nftnl_set_elem_snprintf_xml(char *buf, size_t size,
 		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 	}
 
-	if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_DATA))
+	if (e->flags & (1 << NFTNL_SET_ELEM_DATA))
 		type = DATA_VALUE;
-	else if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_CHAIN))
+	else if (e->flags & (1 << NFTNL_SET_ELEM_CHAIN))
 		type = DATA_CHAIN;
-	else if (e->flags & (1 << NFTNL_SET_ELEM_ATTR_VERDICT))
+	else if (e->flags & (1 << NFTNL_SET_ELEM_VERDICT))
 		type = DATA_VERDICT;
 
 	if (type != DATA_NONE) {