src: get rid of _attr_ infix in new nftnl_ definitions

The function names are already large, trim off the _ATTR_ infix in the
attribute definitions.

Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>

21 files changed, 76 insertions, 76 deletions

diff --git a/examples/nft-chain-add.c b/examples/nft-chain-add.c
index 173af18..3afc06e 100644
--- a/examples/nft-chain-add.c
+++ b/examples/nft-chain-add.c
@@ -48,11 +48,11 @@ static struct nftnl_chain *chain_add_parse(int argc, char *argv[])
 		perror("OOM");
 		return NULL;
 	}
-	nftnl_chain_attr_set(t, NFTNL_CHAIN_TABLE, argv[2]);
-	nftnl_chain_attr_set(t, NFTNL_CHAIN_NAME, argv[3]);
+	nftnl_chain_set(t, NFTNL_CHAIN_TABLE, argv[2]);
+	nftnl_chain_set(t, NFTNL_CHAIN_NAME, argv[3]);
 	if (argc == 6) {
-		nftnl_chain_attr_set_u32(t, NFTNL_CHAIN_HOOKNUM, hooknum);
-		nftnl_chain_attr_set_u32(t, NFTNL_CHAIN_PRIO, atoi(argv[5]));
+		nftnl_chain_set_u32(t, NFTNL_CHAIN_HOOKNUM, hooknum);
+		nftnl_chain_set_u32(t, NFTNL_CHAIN_PRIO, atoi(argv[5]));
 	}
 
 	return t;
diff --git a/examples/nft-chain-del.c b/examples/nft-chain-del.c
index 29953d7..b756b46 100644
--- a/examples/nft-chain-del.c
+++ b/examples/nft-chain-del.c
@@ -30,8 +30,8 @@ static struct nftnl_chain *chain_del_parse(int argc, char *argv[])
 		return NULL;
 	}
 
-	nftnl_chain_attr_set(t, NFTNL_CHAIN_TABLE, argv[2]);
-	nftnl_chain_attr_set(t, NFTNL_CHAIN_NAME, argv[3]);
+	nftnl_chain_set(t, NFTNL_CHAIN_TABLE, argv[2]);
+	nftnl_chain_set(t, NFTNL_CHAIN_NAME, argv[3]);
 
 	return t;
 }
diff --git a/examples/nft-chain-get.c b/examples/nft-chain-get.c
index ead14fc..f5d4593 100644
--- a/examples/nft-chain-get.c
+++ b/examples/nft-chain-get.c
@@ -86,8 +86,8 @@ int main(int argc, char *argv[])
 		}
 		nlh = nftnl_chain_nlmsg_build_hdr(buf, NFT_MSG_GETCHAIN, family,
 						NLM_F_ACK, seq);
-		nftnl_chain_attr_set(t, NFTNL_CHAIN_TABLE, argv[2]);
-		nftnl_chain_attr_set(t, NFTNL_CHAIN_NAME, argv[3]);
+		nftnl_chain_set(t, NFTNL_CHAIN_TABLE, argv[2]);
+		nftnl_chain_set(t, NFTNL_CHAIN_NAME, argv[3]);
 		nftnl_chain_nlmsg_build_payload(nlh, t);
 		nftnl_chain_free(t);
 	} else if (argc >= 2) {
diff --git a/examples/nft-chain-parse-add.c b/examples/nft-chain-parse-add.c
index baf0087..cf43cc2 100644
--- a/examples/nft-chain-parse-add.c
+++ b/examples/nft-chain-parse-add.c
@@ -103,8 +103,8 @@ int main(int argc, char *argv[])
 	nftnl_chain_fprintf(stdout, c, outformat, 0);
 	fprintf(stdout, "\n");
 
-	nftnl_chain_attr_unset(c, NFTNL_CHAIN_HANDLE);
-	family = nftnl_chain_attr_get_u32(c, NFTNL_CHAIN_FAMILY);
+	nftnl_chain_unset(c, NFTNL_CHAIN_HANDLE);
+	family = nftnl_chain_get_u32(c, NFTNL_CHAIN_FAMILY);
 
 	seq = time(NULL);
 	batching = nftnl_batch_is_supported();
diff --git a/examples/nft-rule-add.c b/examples/nft-rule-add.c
index a81f459..d27c6d7 100644
--- a/examples/nft-rule-add.c
+++ b/examples/nft-rule-add.c
@@ -93,13 +93,13 @@ static struct nftnl_rule *setup_rule(uint8_t family, const char *table,
 		exit(EXIT_FAILURE);
 	}
 
-	nftnl_rule_attr_set(r, NFTNL_RULE_TABLE, table);
-	nftnl_rule_attr_set(r, NFTNL_RULE_CHAIN, chain);
-	nftnl_rule_attr_set_u32(r, NFTNL_RULE_FAMILY, family);
+	nftnl_rule_set(r, NFTNL_RULE_TABLE, table);
+	nftnl_rule_set(r, NFTNL_RULE_CHAIN, chain);
+	nftnl_rule_set_u32(r, NFTNL_RULE_FAMILY, family);
 
 	if (handle != NULL) {
 		handle_num = atoll(handle);
-		nftnl_rule_attr_set_u64(r, NFTNL_RULE_POSITION, handle_num);
+		nftnl_rule_set_u64(r, NFTNL_RULE_POSITION, handle_num);
 	}
 
 	proto = IPPROTO_TCP;
@@ -182,7 +182,7 @@ int main(int argc, char *argv[])
 
 	nlh = nftnl_rule_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
 			NFT_MSG_NEWRULE,
-			nftnl_rule_attr_get_u32(r, NFTNL_RULE_FAMILY),
+			nftnl_rule_get_u32(r, NFTNL_RULE_FAMILY),
 			NLM_F_APPEND|NLM_F_CREATE|NLM_F_ACK, seq++);
 
 	nftnl_rule_nlmsg_build_payload(nlh, r);
diff --git a/examples/nft-rule-del.c b/examples/nft-rule-del.c
index d25d5e9..4bc9727 100644
--- a/examples/nft-rule-del.c
+++ b/examples/nft-rule-del.c
@@ -74,12 +74,12 @@ int main(int argc, char *argv[])
 	}
 
 	seq = time(NULL);
-	nftnl_rule_attr_set(r, NFTNL_RULE_TABLE, argv[2]);
-	nftnl_rule_attr_set(r, NFTNL_RULE_CHAIN, argv[3]);
+	nftnl_rule_set(r, NFTNL_RULE_TABLE, argv[2]);
+	nftnl_rule_set(r, NFTNL_RULE_CHAIN, argv[3]);
 
 	/* If no handle is specified, delete all rules in the chain */
 	if (argc == 5)
-		nftnl_rule_attr_set_u64(r, NFTNL_RULE_HANDLE, atoi(argv[4]));
+		nftnl_rule_set_u64(r, NFTNL_RULE_HANDLE, atoi(argv[4]));
 
 	batch = mnl_nlmsg_batch_start(buf, sizeof(buf));
 
diff --git a/examples/nft-rule-parse-add.c b/examples/nft-rule-parse-add.c
index b296859..3707de3 100644
--- a/examples/nft-rule-parse-add.c
+++ b/examples/nft-rule-parse-add.c
@@ -66,7 +66,7 @@ static struct nftnl_rule *rule_parse_file(const char *file, uint16_t format)
 		return NULL;
 	}
 
-	nftnl_rule_attr_unset(r, NFTNL_RULE_HANDLE);
+	nftnl_rule_unset(r, NFTNL_RULE_HANDLE);
 
 	nftnl_parse_err_free(err);
 	return r;
@@ -121,7 +121,7 @@ int main(int argc, char *argv[])
 	}
 
 	rule_seq = seq;
-	family = nftnl_rule_attr_get_u32(r, NFTNL_RULE_FAMILY);
+	family = nftnl_rule_get_u32(r, NFTNL_RULE_FAMILY);
 	nlh = nftnl_rule_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
 				       NFT_MSG_NEWRULE, family,
 				       NLM_F_CREATE|NLM_F_APPEND|NLM_F_ACK,
diff --git a/examples/nft-ruleset-get.c b/examples/nft-ruleset-get.c
index 5965f79..2c9d775 100644
--- a/examples/nft-ruleset-get.c
+++ b/examples/nft-ruleset-get.c
@@ -219,7 +219,7 @@ static int mnl_setelem_get(struct mnl_socket *nf_sock, struct nftnl_set *nls)
 {
 	char buf[MNL_SOCKET_BUFFER_SIZE];
 	struct nlmsghdr *nlh;
-	uint32_t family = nftnl_set_attr_get_u32(nls, NFTNL_SET_FAMILY);
+	uint32_t family = nftnl_set_get_u32(nls, NFTNL_SET_FAMILY);
 
 	nlh = nftnl_set_nlmsg_build_hdr(buf, NFT_MSG_GETSETELEM, family,
 				      NLM_F_DUMP|NLM_F_ACK, seq);
@@ -319,19 +319,19 @@ static struct nftnl_ruleset *mnl_ruleset_dump(struct mnl_socket *nf_sock)
 
 	t = mnl_table_dump(nf_sock, NFPROTO_UNSPEC);
 	if (t != NULL)
-		nftnl_ruleset_attr_set(rs, NFTNL_RULESET_TABLELIST, t);
+		nftnl_ruleset_set(rs, NFTNL_RULESET_TABLELIST, t);
 
 	c = mnl_chain_dump(nf_sock, NFPROTO_UNSPEC);
 	if (c != NULL)
-		nftnl_ruleset_attr_set(rs, NFTNL_RULESET_CHAINLIST, c);
+		nftnl_ruleset_set(rs, NFTNL_RULESET_CHAINLIST, c);
 
 	s = mnl_set_dump(nf_sock, NFPROTO_UNSPEC);
 	if (s != NULL)
-		nftnl_ruleset_attr_set(rs, NFTNL_RULESET_SETLIST, s);
+		nftnl_ruleset_set(rs, NFTNL_RULESET_SETLIST, s);
 
 	r = mnl_rule_dump(nf_sock, NFPROTO_UNSPEC);
 	if (r != NULL)
-		nftnl_ruleset_attr_set(rs, NFTNL_RULESET_RULELIST, r);
+		nftnl_ruleset_set(rs, NFTNL_RULESET_RULELIST, r);
 
 	return rs;
 }
diff --git a/examples/nft-ruleset-parse-file.c b/examples/nft-ruleset-parse-file.c
index 7cb328c..84dc304 100644
--- a/examples/nft-ruleset-parse-file.c
+++ b/examples/nft-ruleset-parse-file.c
@@ -69,7 +69,7 @@ static int nftnl_ruleset_set_elems(const struct nftnl_parse_ctx *ctx)
 		goto err;
 
 	nlh = nftnl_set_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch), nl_type,
-				      nftnl_set_attr_get_u32(set,
+				      nftnl_set_get_u32(set,
 							   NFTNL_SET_FAMILY),
 				      nl_flags, seq++);
 
@@ -82,7 +82,7 @@ err:
 	return -1;
 }
 
-static int nftnl_ruleset_set(const struct nftnl_parse_ctx *ctx)
+static int nftnl_ruleset_parse_set(const struct nftnl_parse_ctx *ctx)
 {
 
 	struct nlmsghdr *nlh;
@@ -112,7 +112,7 @@ static int nftnl_ruleset_set(const struct nftnl_parse_ctx *ctx)
 
 	nlh = nftnl_set_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
 				      nl_type,
-				      nftnl_set_attr_get_u32(set,
+				      nftnl_set_get_u32(set,
 							   NFTNL_SET_FAMILY),
 				      nl_flags,
 				      seq++);
@@ -136,7 +136,7 @@ static int nftnl_ruleset_rule_build_msg(const struct nftnl_parse_ctx *ctx,
 	case NFTNL_CMD_ADD:
 		nl_type = NFT_MSG_NEWRULE;
 		nl_flags = NLM_F_APPEND|NLM_F_CREATE|NLM_F_ACK;
-		nftnl_rule_attr_unset(rule, NFTNL_RULE_HANDLE);
+		nftnl_rule_unset(rule, NFTNL_RULE_HANDLE);
 		break;
 	case NFTNL_CMD_DELETE:
 		nl_type = NFT_MSG_DELRULE;
@@ -149,7 +149,7 @@ static int nftnl_ruleset_rule_build_msg(const struct nftnl_parse_ctx *ctx,
 	case NFTNL_CMD_INSERT:
 		nl_type = NFT_MSG_NEWRULE;
 		nl_flags = NLM_F_CREATE|NLM_F_ACK;
-		nftnl_rule_attr_unset(rule, NFTNL_RULE_HANDLE);
+		nftnl_rule_unset(rule, NFTNL_RULE_HANDLE);
 		break;
 	default:
 		return -1;
@@ -157,7 +157,7 @@ static int nftnl_ruleset_rule_build_msg(const struct nftnl_parse_ctx *ctx,
 
 	nlh = nftnl_rule_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
 				       nl_type,
-				       nftnl_rule_attr_get_u32(rule,
+				       nftnl_rule_get_u32(rule,
 							  NFTNL_RULE_FAMILY),
 				       nl_flags,
 				       seq++);
@@ -201,21 +201,21 @@ static int nftnl_ruleset_flush_rules(const struct nftnl_parse_ctx *ctx)
 	switch (type) {
 	case NFTNL_RULESET_TABLE:
 		nlt = nftnl_ruleset_ctx_get(ctx, NFTNL_RULESET_CTX_TABLE);
-		nftnl_rule_attr_set(nlr, NFTNL_RULE_TABLE,
-				  nftnl_table_attr_get(nlt, NFTNL_TABLE_NAME));
-		nftnl_rule_attr_set(nlr, NFTNL_RULE_FAMILY,
-				nftnl_table_attr_get(nlt, NFTNL_TABLE_FAMILY));
+		nftnl_rule_set(nlr, NFTNL_RULE_TABLE,
+				  nftnl_table_get(nlt, NFTNL_TABLE_NAME));
+		nftnl_rule_set(nlr, NFTNL_RULE_FAMILY,
+				nftnl_table_get(nlt, NFTNL_TABLE_FAMILY));
 		break;
 	case NFTNL_RULESET_CHAIN:
 		nlc = nftnl_ruleset_ctx_get(ctx, NFTNL_RULESET_CTX_CHAIN);
-		nftnl_rule_attr_set(nlr, NFTNL_RULE_TABLE,
-				  nftnl_chain_attr_get(nlc,
+		nftnl_rule_set(nlr, NFTNL_RULE_TABLE,
+				  nftnl_chain_get(nlc,
 						     NFTNL_CHAIN_TABLE));
-		nftnl_rule_attr_set(nlr, NFTNL_RULE_CHAIN,
-				  nftnl_chain_attr_get(nlc,
+		nftnl_rule_set(nlr, NFTNL_RULE_CHAIN,
+				  nftnl_chain_get(nlc,
 						     NFTNL_CHAIN_NAME));
-		nftnl_rule_attr_set(nlr, NFTNL_RULE_FAMILY,
-				nftnl_chain_attr_get(nlc, NFTNL_TABLE_FAMILY));
+		nftnl_rule_set(nlr, NFTNL_RULE_FAMILY,
+				nftnl_chain_get(nlc, NFTNL_TABLE_FAMILY));
 		break;
 	default:
 		goto err;
@@ -258,10 +258,10 @@ static int nftnl_ruleset_chain(const struct nftnl_parse_ctx *ctx)
 		goto err;
 	}
 
-	nftnl_chain_attr_unset(chain, NFTNL_CHAIN_HANDLE);
+	nftnl_chain_unset(chain, NFTNL_CHAIN_HANDLE);
 	nlh = nftnl_chain_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
 					nl_type,
-					nftnl_chain_attr_get_u32(chain,
+					nftnl_chain_get_u32(chain,
 							 NFTNL_CHAIN_FAMILY),
 					nl_flags,
 					seq++);
@@ -297,7 +297,7 @@ static int nftnl_ruleset_table_build_msg(const struct nftnl_parse_ctx *ctx,
 
 	nlh = nftnl_table_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
 					nl_type,
-					nftnl_table_attr_get_u32(table,
+					nftnl_table_get_u32(table,
 							 NFTNL_TABLE_FAMILY),
 					nl_flags,
 					seq++);
@@ -358,7 +358,7 @@ static int ruleset_elems_cb(const struct nftnl_parse_ctx *ctx)
 		ret = nftnl_ruleset_rule(ctx);
 		break;
 	case NFTNL_RULESET_SET:
-		ret = nftnl_ruleset_set(ctx);
+		ret = nftnl_ruleset_parse_set(ctx);
 		break;
 	case NFTNL_RULESET_SET_ELEMS:
 		ret = nftnl_ruleset_set_elems(ctx);
diff --git a/examples/nft-set-add.c b/examples/nft-set-add.c
index a29115c..e040aca 100644
--- a/examples/nft-set-add.c
+++ b/examples/nft-set-add.c
@@ -39,12 +39,12 @@ static struct nftnl_set *setup_set(uint8_t family, const char *table,
 		exit(EXIT_FAILURE);
 	}
 
-	nftnl_set_attr_set_str(s, NFTNL_SET_TABLE, table);
-	nftnl_set_attr_set_str(s, NFTNL_SET_NAME, name);
-	nftnl_set_attr_set_u32(s, NFTNL_SET_FAMILY, family);
-	nftnl_set_attr_set_u32(s, NFTNL_SET_KEY_LEN, 2);
-	nftnl_set_attr_set_u32(s, NFTNL_SET_ID, 1);
-	nftnl_set_attr_set_u32(s, NFTNL_SET_FLAGS, NFT_SET_CONSTANT);
+	nftnl_set_set_str(s, NFTNL_SET_TABLE, table);
+	nftnl_set_set_str(s, NFTNL_SET_NAME, name);
+	nftnl_set_set_u32(s, NFTNL_SET_FAMILY, family);
+	nftnl_set_set_u32(s, NFTNL_SET_KEY_LEN, 2);
+	nftnl_set_set_u32(s, NFTNL_SET_ID, 1);
+	nftnl_set_set_u32(s, NFTNL_SET_FLAGS, NFT_SET_CONSTANT);
 
 	return s;
 }
diff --git a/examples/nft-set-del.c b/examples/nft-set-del.c
index ae87608..5e1fad3 100644
--- a/examples/nft-set-del.c
+++ b/examples/nft-set-del.c
@@ -56,8 +56,8 @@ int main(int argc, char *argv[])
 
 	nlh = nftnl_set_nlmsg_build_hdr(buf, NFT_MSG_DELSET, family,
 					NLM_F_ACK, seq);
-	nftnl_set_attr_set(t, NFTNL_SET_TABLE, argv[2]);
-	nftnl_set_attr_set(t, NFTNL_SET_NAME, argv[3]);
+	nftnl_set_set(t, NFTNL_SET_TABLE, argv[2]);
+	nftnl_set_set(t, NFTNL_SET_NAME, argv[3]);
 
 	nftnl_set_nlmsg_build_payload(nlh, t);
 	nftnl_set_free(t);
diff --git a/examples/nft-set-elem-add.c b/examples/nft-set-elem-add.c
index 178c1a2..609b7bb 100644
--- a/examples/nft-set-elem-add.c
+++ b/examples/nft-set-elem-add.c
@@ -55,8 +55,8 @@ int main(int argc, char *argv[])
 		exit(EXIT_FAILURE);
 	}
 
-	nftnl_set_attr_set(s, NFTNL_SET_TABLE, argv[2]);
-	nftnl_set_attr_set(s, NFTNL_SET_NAME, argv[3]);
+	nftnl_set_set(s, NFTNL_SET_TABLE, argv[2]);
+	nftnl_set_set(s, NFTNL_SET_NAME, argv[3]);
 
 	/* Add to dummy elements to set */
 	e = nftnl_set_elem_alloc();
@@ -66,7 +66,7 @@ int main(int argc, char *argv[])
 	}
 
 	data = 0x1;
-	nftnl_set_elem_attr_set(e, NFTNL_SET_ELEM_KEY, &data, sizeof(data));
+	nftnl_set_elem_set(e, NFTNL_SET_ELEM_KEY, &data, sizeof(data));
 	nftnl_set_elem_add(s, e);
 
 	e = nftnl_set_elem_alloc();
@@ -75,7 +75,7 @@ int main(int argc, char *argv[])
 		exit(EXIT_FAILURE);
 	}
 	data = 0x2;
-	nftnl_set_elem_attr_set(e, NFTNL_SET_ELEM_KEY, &data, sizeof(data));
+	nftnl_set_elem_set(e, NFTNL_SET_ELEM_KEY, &data, sizeof(data));
 	nftnl_set_elem_add(s, e);
 
 	nlh = nftnl_set_nlmsg_build_hdr(buf, NFT_MSG_NEWSETELEM, family,
diff --git a/examples/nft-set-elem-del.c b/examples/nft-set-elem-del.c
index 9897ff7..b53a86b 100644
--- a/examples/nft-set-elem-del.c
+++ b/examples/nft-set-elem-del.c
@@ -55,8 +55,8 @@ int main(int argc, char *argv[])
 		exit(EXIT_FAILURE);
 	}
 
-	nftnl_set_attr_set(s, NFTNL_SET_TABLE, argv[2]);
-	nftnl_set_attr_set(s, NFTNL_SET_NAME, argv[3]);
+	nftnl_set_set(s, NFTNL_SET_TABLE, argv[2]);
+	nftnl_set_set(s, NFTNL_SET_NAME, argv[3]);
 
 	/* Add to dummy elements to set */
 	e = nftnl_set_elem_alloc();
@@ -66,7 +66,7 @@ int main(int argc, char *argv[])
 	}
 
 	data = 0x1;
-	nftnl_set_elem_attr_set(e, NFTNL_SET_ELEM_KEY, &data, sizeof(data));
+	nftnl_set_elem_set(e, NFTNL_SET_ELEM_KEY, &data, sizeof(data));
 	nftnl_set_elem_add(s, e);
 
 	e = nftnl_set_elem_alloc();
@@ -75,7 +75,7 @@ int main(int argc, char *argv[])
 		exit(EXIT_FAILURE);
 	}
 	data = 0x2;
-	nftnl_set_elem_attr_set(e, NFTNL_SET_ELEM_KEY, &data, sizeof(data));
+	nftnl_set_elem_set(e, NFTNL_SET_ELEM_KEY, &data, sizeof(data));
 	nftnl_set_elem_add(s, e);
 
 	nlh = nftnl_set_nlmsg_build_hdr(buf, NFT_MSG_DELSETELEM, family,
diff --git a/examples/nft-set-elem-get.c b/examples/nft-set-elem-get.c
index f8d184b..9c637ee 100644
--- a/examples/nft-set-elem-get.c
+++ b/examples/nft-set-elem-get.c
@@ -87,8 +87,8 @@ int main(int argc, char *argv[])
 
 	nlh = nftnl_set_nlmsg_build_hdr(buf, NFT_MSG_GETSETELEM, family,
 					NLM_F_DUMP|NLM_F_ACK, seq);
-	nftnl_set_attr_set(t, NFTNL_SET_NAME, argv[3]);
-	nftnl_set_attr_set(t, NFTNL_SET_TABLE, argv[2]);
+	nftnl_set_set(t, NFTNL_SET_NAME, argv[3]);
+	nftnl_set_set(t, NFTNL_SET_TABLE, argv[2]);
 	nftnl_set_elems_nlmsg_build_payload(nlh, t);
 	nftnl_set_free(t);
 
diff --git a/examples/nft-set-get.c b/examples/nft-set-get.c
index a8a133f..245ac5f 100644
--- a/examples/nft-set-get.c
+++ b/examples/nft-set-get.c
@@ -89,7 +89,7 @@ int main(int argc, char *argv[])
 	nlh = nftnl_set_nlmsg_build_hdr(buf, NFT_MSG_GETSET, family,
 					NLM_F_DUMP|NLM_F_ACK, seq);
 	/* Use this below if you want to obtain sets per table */
-/*	nftnl_set_attr_set(t, NFT_SET_TABLE, argv[2]); */
+/*	nftnl_set_set(t, NFT_SET_TABLE, argv[2]); */
 	nftnl_set_nlmsg_build_payload(nlh, t);
 	nftnl_set_free(t);
 
diff --git a/examples/nft-set-parse-add.c b/examples/nft-set-parse-add.c
index b3fffc5..3648730 100644
--- a/examples/nft-set-parse-add.c
+++ b/examples/nft-set-parse-add.c
@@ -68,7 +68,7 @@ static struct nftnl_set *set_parse_file(const char *file, uint16_t format)
 
 	nftnl_parse_err_free(err);
 
-	nftnl_set_attr_set_u32(s, NFTNL_SET_ID, 1);
+	nftnl_set_set_u32(s, NFTNL_SET_ID, 1);
 	return s;
 
 }
@@ -121,7 +121,7 @@ int main(int argc, char *argv[])
 		mnl_nlmsg_batch_next(batch);
 	}
 
-	family = nftnl_set_attr_get_u32(s, NFTNL_SET_FAMILY);
+	family = nftnl_set_get_u32(s, NFTNL_SET_FAMILY);
 
 	set_seq = seq;
 	nlh = nftnl_set_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
diff --git a/examples/nft-table-add.c b/examples/nft-table-add.c
index bc36333..db6e39e 100644
--- a/examples/nft-table-add.c
+++ b/examples/nft-table-add.c
@@ -44,8 +44,8 @@ static struct nftnl_table *table_add_parse(int argc, char *argv[])
 		return NULL;
 	}
 
-	nftnl_table_attr_set_u32(t, NFTNL_TABLE_FAMILY, family);
-	nftnl_table_attr_set_str(t, NFTNL_TABLE_NAME, argv[2]);
+	nftnl_table_set_u32(t, NFTNL_TABLE_FAMILY, family);
+	nftnl_table_set_str(t, NFTNL_TABLE_NAME, argv[2]);
 
 	return t;
 }
@@ -84,7 +84,7 @@ int main(int argc, char *argv[])
 	}
 
 	table_seq = seq;
-	family = nftnl_table_attr_get_u32(t, NFTNL_TABLE_FAMILY);
+	family = nftnl_table_get_u32(t, NFTNL_TABLE_FAMILY);
 	nlh = nftnl_table_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
 					NFT_MSG_NEWTABLE, family,
 					NLM_F_ACK, seq++);
diff --git a/examples/nft-table-del.c b/examples/nft-table-del.c
index f3699c7..9d1f3be 100644
--- a/examples/nft-table-del.c
+++ b/examples/nft-table-del.c
@@ -44,8 +44,8 @@ static struct nftnl_table *table_del_parse(int argc, char *argv[])
 		return NULL;
 	}
 
-	nftnl_table_attr_set_str(t, NFTNL_TABLE_NAME, argv[2]);
-	nftnl_table_attr_set_u32(t, NFTNL_TABLE_FAMILY, family);
+	nftnl_table_set_str(t, NFTNL_TABLE_NAME, argv[2]);
+	nftnl_table_set_u32(t, NFTNL_TABLE_FAMILY, family);
 
 	return t;
 }
@@ -84,7 +84,7 @@ int main(int argc, char *argv[])
 	}
 
 	table_seq = seq;
-	family = nftnl_table_attr_get_u32(t, NFTNL_TABLE_FAMILY);
+	family = nftnl_table_get_u32(t, NFTNL_TABLE_FAMILY);
 	nlh = nftnl_table_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
 					NFT_MSG_DELTABLE, family,
 					NLM_F_ACK, seq++);
diff --git a/examples/nft-table-get.c b/examples/nft-table-get.c
index 84524b0..d648a11 100644
--- a/examples/nft-table-get.c
+++ b/examples/nft-table-get.c
@@ -104,7 +104,7 @@ int main(int argc, char *argv[])
 	} else {
 		nlh = nftnl_table_nlmsg_build_hdr(buf, NFT_MSG_GETTABLE, family,
 						NLM_F_ACK, seq);
-		nftnl_table_attr_set(t, NFTNL_TABLE_NAME, argv[2]);
+		nftnl_table_set(t, NFTNL_TABLE_NAME, argv[2]);
 		nftnl_table_nlmsg_build_payload(nlh, t);
 		nftnl_table_free(t);
 	}
diff --git a/examples/nft-table-parse-add.c b/examples/nft-table-parse-add.c
index 6a34f56..31d31cc 100644
--- a/examples/nft-table-parse-add.c
+++ b/examples/nft-table-parse-add.c
@@ -116,7 +116,7 @@ int main(int argc, char *argv[])
 		mnl_nlmsg_batch_next(batch);
 	}
 
-	family = nftnl_table_attr_get_u32(t, NFTNL_TABLE_FAMILY);
+	family = nftnl_table_get_u32(t, NFTNL_TABLE_FAMILY);
 
 	table_seq = seq;
 	nlh = nftnl_table_nlmsg_build_hdr(mnl_nlmsg_batch_current(batch),
diff --git a/examples/nft-table-upd.c b/examples/nft-table-upd.c
index 5b14e54..686b5a7 100644
--- a/examples/nft-table-upd.c
+++ b/examples/nft-table-upd.c
@@ -63,8 +63,8 @@ int main(int argc, char *argv[])
 		exit(EXIT_FAILURE);
 	}
 
-	nftnl_table_attr_set(t, NFTNL_TABLE_NAME, argv[2]);
-	nftnl_table_attr_set_u32(t, NFTNL_TABLE_FLAGS, flags);
+	nftnl_table_set(t, NFTNL_TABLE_NAME, argv[2]);
+	nftnl_table_set_u32(t, NFTNL_TABLE_FLAGS, flags);
 
 	nlh = nftnl_table_nlmsg_build_hdr(buf, NFT_MSG_NEWTABLE, family,
 					NLM_F_ACK, seq);