src: remove libmxml support

This patch removes the libmxml integration in libnftnl, since we have
JSON in place and there is no need to support two at the same time.

The JSON support is much better, for example libjansson has a better
parsing error reporting.

Moreover, libmxml 2.10 breaks the integration with libnftnl somehow,
as reported in Debian bug #83870 [0].

Also, the XML support inside libnftnl has never been in good shape, with
several tiny inconsitencies.

[0] https://bugs.debian.org/838370

Signed-off-by: Arturo Borrero Gonzalez <arturo.borrero.glez@gmail.com>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>

35 files changed, 29 insertions, 2034 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index 4a91cdb..4ab8fca 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1,7 +1,7 @@
 include $(top_srcdir)/Make_global.am
 lib_LTLIBRARIES = libnftnl.la
 
-libnftnl_la_LIBADD = ${LIBMNL_LIBS} ${LIBXML_LIBS} ${LIBJSON_LIBS}
+libnftnl_la_LIBADD = ${LIBMNL_LIBS} ${LIBJSON_LIBS}
 libnftnl_la_LDFLAGS = -Wl,--version-script=$(srcdir)/libnftnl.map	\
 		      -version-info $(LIBVERSION)
 
@@ -17,7 +17,6 @@ libnftnl_la_SOURCES = utils.c		\
 		      set.c		\
 		      set_elem.c	\
 		      ruleset.c		\
-		      mxml.c		\
 		      jansson.c		\
 		      udata.c		\
 		      expr.c		\
diff --git a/src/buffer.c b/src/buffer.c
index 57d3c0c..d97d517 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -62,10 +62,9 @@ static int nftnl_buf_put(struct nftnl_buf *b, const char *fmt, ...)
 int nftnl_buf_open(struct nftnl_buf *b, int type, const char *tag)
 {
 	switch (type) {
-	case NFTNL_OUTPUT_XML:
-		return nftnl_buf_put(b, "<%s>", tag);
 	case NFTNL_OUTPUT_JSON:
 		return nftnl_buf_put(b, "{\"%s\":{", tag);
+	case NFTNL_OUTPUT_XML:
 	default:
 		return 0;
 	}
@@ -74,8 +73,6 @@ int nftnl_buf_open(struct nftnl_buf *b, int type, const char *tag)
 int nftnl_buf_close(struct nftnl_buf *b, int type, const char *tag)
 {
 	switch (type) {
-	case NFTNL_OUTPUT_XML:
-		return nftnl_buf_put(b, "</%s>", tag);
 	case NFTNL_OUTPUT_JSON:
 		/* Remove trailing comma in json */
 		if (b->size > 0 && b->buf[b->size - 1] == ',') {
@@ -85,6 +82,7 @@ int nftnl_buf_close(struct nftnl_buf *b, int type, const char *tag)
 		}
 
 		return nftnl_buf_put(b, "}}");
+	case NFTNL_OUTPUT_XML:
 	default:
 		return 0;
 	}
@@ -96,7 +94,6 @@ int nftnl_buf_open_array(struct nftnl_buf *b, int type, const char *tag)
 	case NFTNL_OUTPUT_JSON:
 		return nftnl_buf_put(b, "{\"%s\":[", tag);
 	case NFTNL_OUTPUT_XML:
-		return nftnl_buf_put(b, "<%s>", tag);
 	default:
 		return 0;
 	}
@@ -108,7 +105,6 @@ int nftnl_buf_close_array(struct nftnl_buf *b, int type, const char *tag)
 	case NFTNL_OUTPUT_JSON:
 		return nftnl_buf_put(b, "]}");
 	case NFTNL_OUTPUT_XML:
-		return nftnl_buf_put(b, "</%s>", tag);
 	default:
 		return 0;
 	}
@@ -117,10 +113,9 @@ int nftnl_buf_close_array(struct nftnl_buf *b, int type, const char *tag)
 int nftnl_buf_u32(struct nftnl_buf *b, int type, uint32_t value, const char *tag)
 {
 	switch (type) {
-	case NFTNL_OUTPUT_XML:
-		return nftnl_buf_put(b, "<%s>%u</%s>", tag, value, tag);
 	case NFTNL_OUTPUT_JSON:
 		return nftnl_buf_put(b, "\"%s\":%u,", tag, value);
+	case NFTNL_OUTPUT_XML:
 	default:
 		return 0;
 	}
@@ -129,10 +124,9 @@ int nftnl_buf_u32(struct nftnl_buf *b, int type, uint32_t value, const char *tag
 int nftnl_buf_s32(struct nftnl_buf *b, int type, uint32_t value, const char *tag)
 {
 	switch (type) {
-	case NFTNL_OUTPUT_XML:
-		return nftnl_buf_put(b, "<%s>%d</%s>", tag, value, tag);
 	case NFTNL_OUTPUT_JSON:
 		return nftnl_buf_put(b, "\"%s\":%d,", tag, value);
+	case NFTNL_OUTPUT_XML:
 	default:
 		return 0;
 	}
@@ -141,10 +135,9 @@ int nftnl_buf_s32(struct nftnl_buf *b, int type, uint32_t value, const char *tag
 int nftnl_buf_u64(struct nftnl_buf *b, int type, uint64_t value, const char *tag)
 {
 	switch (type) {
-	case NFTNL_OUTPUT_XML:
-		return nftnl_buf_put(b, "<%s>%"PRIu64"</%s>", tag, value, tag);
 	case NFTNL_OUTPUT_JSON:
 		return nftnl_buf_put(b, "\"%s\":%"PRIu64",", tag, value);
+	case NFTNL_OUTPUT_XML:
 	default:
 		return 0;
 	}
@@ -153,10 +146,9 @@ int nftnl_buf_u64(struct nftnl_buf *b, int type, uint64_t value, const char *tag
 int nftnl_buf_str(struct nftnl_buf *b, int type, const char *str, const char *tag)
 {
 	switch (type) {
-	case NFTNL_OUTPUT_XML:
-		return nftnl_buf_put(b, "<%s>%s</%s>", tag, str, tag);
 	case NFTNL_OUTPUT_JSON:
 		return nftnl_buf_put(b, "\"%s\":\"%s\",", tag, str);
+	case NFTNL_OUTPUT_XML:
 	default:
 		return 0;
 	}
@@ -169,11 +161,7 @@ int nftnl_buf_reg(struct nftnl_buf *b, int type, union nftnl_data_reg *reg,
 
 	switch (type) {
 	case NFTNL_OUTPUT_XML:
-		ret = nftnl_buf_put(b, "<%s>", tag);
-		ret = nftnl_data_reg_snprintf(b->buf + b->off, b->len, reg,
-                                    NFTNL_OUTPUT_XML, 0, reg_type);
-		nftnl_buf_update(b, ret);
-		return nftnl_buf_put(b, "</%s>", tag);
+		return 0;
 	case NFTNL_OUTPUT_JSON:
 		nftnl_buf_put(b, "\"%s\":{", tag);
 		ret = nftnl_data_reg_snprintf(b->buf + b->off, b->len, reg,
diff --git a/src/chain.c b/src/chain.c
index dfe0cf2..49cd094 100644
--- a/src/chain.c
+++ b/src/chain.c
@@ -708,109 +708,6 @@ static int nftnl_chain_json_parse(struct nftnl_chain *c, const void *json,
 #endif
 }
 
-#ifdef XML_PARSING
-int nftnl_mxml_chain_parse(mxml_node_t *tree, struct nftnl_chain *c,
-			 struct nftnl_parse_err *err)
-{
-	const char *table, *name, *hooknum_str, *policy_str, *type, *dev;
-	int family, hooknum, policy;
-	uint64_t handle, bytes, packets, prio, use;
-
-	name = nftnl_mxml_str_parse(tree, "name", MXML_DESCEND_FIRST,
-				  NFTNL_XML_MAND, err);
-	if (name != NULL)
-		nftnl_chain_set_str(c, NFTNL_CHAIN_NAME, name);
-
-	if (nftnl_mxml_num_parse(tree, "handle", MXML_DESCEND_FIRST, BASE_DEC,
-			       &handle, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0)
-		nftnl_chain_set_u64(c, NFTNL_CHAIN_HANDLE, handle);
-
-	if (nftnl_mxml_num_parse(tree, "bytes", MXML_DESCEND_FIRST, BASE_DEC,
-			       &bytes, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0)
-		nftnl_chain_set_u64(c, NFTNL_CHAIN_BYTES, bytes);
-
-
-	if (nftnl_mxml_num_parse(tree, "packets", MXML_DESCEND_FIRST, BASE_DEC,
-			       &packets, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0)
-		nftnl_chain_set_u64(c, NFTNL_CHAIN_PACKETS, packets);
-
-	table = nftnl_mxml_str_parse(tree, "table", MXML_DESCEND_FIRST,
-				   NFTNL_XML_MAND, err);
-
-	if (table != NULL)
-		nftnl_chain_set_str(c, NFTNL_CHAIN_TABLE, table);
-
-	if (nftnl_mxml_num_parse(tree, "use", MXML_DESCEND_FIRST, BASE_DEC,
-			       &use, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0)
-		nftnl_chain_set_u64(c, NFTNL_CHAIN_PACKETS, use);
-
-	family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST,
-				       NFTNL_XML_MAND, err);
-	if (family >= 0)
-		nftnl_chain_set_u32(c, NFTNL_CHAIN_FAMILY, family);
-
-	hooknum_str = nftnl_mxml_str_parse(tree, "hooknum", MXML_DESCEND_FIRST,
-					 NFTNL_XML_OPT, err);
-	if (hooknum_str != NULL) {
-		hooknum = nftnl_str2hooknum(c->family, hooknum_str);
-		if (hooknum < 0)
-			return -1;
-		nftnl_chain_set_u32(c, NFTNL_CHAIN_HOOKNUM, hooknum);
-
-		type = nftnl_mxml_str_parse(tree, "type", MXML_DESCEND_FIRST,
-					  NFTNL_XML_MAND, err);
-
-		if (type != NULL)
-			nftnl_chain_set_str(c, NFTNL_CHAIN_TYPE, type);
-
-		if (nftnl_mxml_num_parse(tree, "prio", MXML_DESCEND, BASE_DEC,
-				       &prio, NFTNL_TYPE_S32, NFTNL_XML_MAND,
-				       err) == 0)
-			nftnl_chain_set_s32(c, NFTNL_CHAIN_PRIO, prio);
-
-		policy_str = nftnl_mxml_str_parse(tree, "policy",
-						MXML_DESCEND_FIRST,
-						NFTNL_XML_MAND, err);
-		if (policy_str != NULL) {
-			if (nftnl_str2verdict(policy_str, &policy) != 0) {
-				errno = EINVAL;
-				err->node_name = "policy";
-				err->error = NFTNL_PARSE_EBADTYPE;
-				return -1;
-			}
-			nftnl_chain_set_u32(c, NFTNL_CHAIN_POLICY,
-					       policy);
-		}
-
-		dev = nftnl_mxml_str_parse(tree, "device", MXML_DESCEND_FIRST,
-					   NFTNL_XML_MAND, err);
-		if (dev != NULL)
-			nftnl_chain_set_str(c, NFTNL_CHAIN_DEV, dev);
-	}
-
-	return 0;
-}
-#endif
-
-static int nftnl_chain_xml_parse(struct nftnl_chain *c, const void *xml,
-			       struct nftnl_parse_err *err,
-			       enum nftnl_parse_input input)
-{
-#ifdef XML_PARSING
-	int ret;
-	mxml_node_t *tree = nftnl_mxml_build_tree(xml, "chain", err, input);
-	if (tree == NULL)
-		return -1;
-
-	ret = nftnl_mxml_chain_parse(tree, c, err);
-	mxmlDelete(tree);
-	return ret;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_chain_do_parse(struct nftnl_chain *c, enum nftnl_parse_type type,
 			      const void *data, struct nftnl_parse_err *err,
 			      enum nftnl_parse_input input)
@@ -819,12 +716,10 @@ static int nftnl_chain_do_parse(struct nftnl_chain *c, enum nftnl_parse_type typ
 	struct nftnl_parse_err perr = {};
 
 	switch (type) {
-	case NFTNL_PARSE_XML:
-		ret = nftnl_chain_xml_parse(c, data, &perr, input);
-		break;
 	case NFTNL_PARSE_JSON:
 		ret = nftnl_chain_json_parse(c, data, &perr, input);
 		break;
+	case NFTNL_PARSE_XML:
 	default:
 		ret = -1;
 		errno = EOPNOTSUPP;
diff --git a/src/expr/bitwise.c b/src/expr/bitwise.c
index 9cc9347..0febc9d 100644
--- a/src/expr/bitwise.c
+++ b/src/expr/bitwise.c
@@ -209,47 +209,6 @@ nftnl_expr_bitwise_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-static int
-nftnl_expr_bitwise_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-				struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	struct nftnl_expr_bitwise *bitwise = nftnl_expr_data(e);
-	uint32_t sreg, dreg, len;
-
-	if (nftnl_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND_FIRST,
-			       NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_BITWISE_SREG, sreg);
-
-	if (nftnl_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND_FIRST,
-			       NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_BITWISE_DREG, dreg);
-
-	if (nftnl_mxml_num_parse(tree, "len", MXML_DESCEND_FIRST, BASE_DEC,
-			       &len, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_BITWISE_LEN, len);
-
-	if (nftnl_mxml_data_reg_parse(tree, "mask", &bitwise->mask, NFTNL_XML_MAND,
-				    err) == DATA_VALUE)
-		e->flags |= (1 << NFTNL_EXPR_BITWISE_MASK);
-
-	if (nftnl_mxml_data_reg_parse(tree, "xor", &bitwise->xor, NFTNL_XML_MAND,
-				    err) == DATA_VALUE)
-		e->flags |= (1 << NFTNL_EXPR_BITWISE_XOR);
-
-	/* Additional validation: mask and xor must use the same number of
-	 * data registers.
-	 */
-	if (bitwise->mask.len != bitwise->xor.len)
-		return -1;
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_expr_bitwise_export(char *buf, size_t size,
 				     const struct nftnl_expr *e, int type)
 {
@@ -341,6 +300,5 @@ struct expr_ops expr_ops_bitwise = {
 	.parse		= nftnl_expr_bitwise_parse,
 	.build		= nftnl_expr_bitwise_build,
 	.snprintf	= nftnl_expr_bitwise_snprintf,
-	.xml_parse	= nftnl_expr_bitwise_xml_parse,
 	.json_parse	= nftnl_expr_bitwise_json_parse,
 };
diff --git a/src/expr/byteorder.c b/src/expr/byteorder.c
index a7914ef..5f8e585 100644
--- a/src/expr/byteorder.c
+++ b/src/expr/byteorder.c
@@ -234,48 +234,6 @@ nftnl_expr_byteorder_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-static int
-nftnl_expr_byteorder_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-				  struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	const char *op;
-	int32_t ntoh;
-	uint32_t sreg, dreg, len, size;
-
-	if (nftnl_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND_FIRST,
-			       NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_BYTEORDER_SREG, sreg);
-
-	if (nftnl_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND, NFTNL_XML_MAND,
-			       err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_BYTEORDER_DREG, dreg);
-
-	op = nftnl_mxml_str_parse(tree, "op", MXML_DESCEND_FIRST, NFTNL_XML_MAND,
-				err);
-	if (op != NULL) {
-		ntoh = nftnl_str2ntoh(op);
-		if (ntoh < 0)
-			return -1;
-
-		nftnl_expr_set_u32(e, NFTNL_EXPR_BYTEORDER_OP, ntoh);
-	}
-
-	if (nftnl_mxml_num_parse(tree, "len", MXML_DESCEND_FIRST, BASE_DEC,
-			       &len, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_BYTEORDER_LEN, len);
-
-	if (nftnl_mxml_num_parse(tree, "size", MXML_DESCEND_FIRST, BASE_DEC,
-			       &size, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_BYTEORDER_SIZE, size);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_expr_byteorder_export(char *buf, size_t size,
 				       const struct nftnl_expr *e, int type)
 {
@@ -357,6 +315,5 @@ struct expr_ops expr_ops_byteorder = {
 	.parse		= nftnl_expr_byteorder_parse,
 	.build		= nftnl_expr_byteorder_build,
 	.snprintf	= nftnl_expr_byteorder_snprintf,
-	.xml_parse	= nftnl_expr_byteorder_xml_parse,
 	.json_parse	= nftnl_expr_byteorder_json_parse,
 };
diff --git a/src/expr/cmp.c b/src/expr/cmp.c
index a46c15a..e7ed0db 100644
--- a/src/expr/cmp.c
+++ b/src/expr/cmp.c
@@ -209,41 +209,6 @@ static int nftnl_expr_cmp_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-static int nftnl_expr_cmp_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-				       struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	struct nftnl_expr_cmp *cmp = nftnl_expr_data(e);
-	const char *op;
-	int32_t op_value;
-	uint32_t sreg;
-
-	if (nftnl_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND_FIRST,
-			       NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_CMP_SREG, sreg);
-
-	op = nftnl_mxml_str_parse(tree, "op", MXML_DESCEND_FIRST, NFTNL_XML_MAND,
-				err);
-	if (op != NULL) {
-		op_value = nftnl_str2cmp(op);
-		if (op_value < 0)
-			return -1;
-
-		nftnl_expr_set_u32(e, NFTNL_EXPR_CMP_OP, op_value);
-	}
-
-	if (nftnl_mxml_data_reg_parse(tree, "data",
-				    &cmp->data, NFTNL_XML_MAND,
-				    err) == DATA_VALUE)
-		e->flags |= (1 << NFTNL_EXPR_CMP_DATA);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_expr_cmp_export(char *buf, size_t size,
 				 const struct nftnl_expr *e, int type)
 {
@@ -320,6 +285,5 @@ struct expr_ops expr_ops_cmp = {
 	.parse		= nftnl_expr_cmp_parse,
 	.build		= nftnl_expr_cmp_build,
 	.snprintf	= nftnl_expr_cmp_snprintf,
-	.xml_parse	= nftnl_expr_cmp_xml_parse,
 	.json_parse	= nftnl_expr_cmp_json_parse,
 };
diff --git a/src/expr/counter.c b/src/expr/counter.c
index 4488afc..21901e8 100644
--- a/src/expr/counter.c
+++ b/src/expr/counter.c
@@ -137,28 +137,6 @@ nftnl_expr_counter_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-static int
-nftnl_expr_counter_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-				struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	uint64_t pkts, bytes;
-
-	if (nftnl_mxml_num_parse(tree, "pkts", MXML_DESCEND_FIRST, BASE_DEC,
-			       &pkts, NFTNL_TYPE_U64, NFTNL_XML_MAND,  err) == 0)
-		nftnl_expr_set_u64(e, NFTNL_EXPR_CTR_PACKETS, pkts);
-
-	if (nftnl_mxml_num_parse(tree, "bytes", MXML_DESCEND_FIRST, BASE_DEC,
-			       &bytes, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u64(e, NFTNL_EXPR_CTR_BYTES, bytes);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_expr_counter_export(char *buf, size_t size,
 				     const struct nftnl_expr *e, int type)
 {
@@ -223,6 +201,5 @@ struct expr_ops expr_ops_counter = {
 	.parse		= nftnl_expr_counter_parse,
 	.build		= nftnl_expr_counter_build,
 	.snprintf	= nftnl_expr_counter_snprintf,
-	.xml_parse	= nftnl_expr_counter_xml_parse,
 	.json_parse	= nftnl_expr_counter_json_parse,
 };
diff --git a/src/expr/ct.c b/src/expr/ct.c
index 0137891..e680738 100644
--- a/src/expr/ct.c
+++ b/src/expr/ct.c
@@ -263,53 +263,6 @@ err:
 }
 
 
-static int nftnl_expr_ct_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-				      struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	const char *key_str, *dir_str;
-	int key;
-	uint8_t dir;
-	uint32_t dreg, sreg;
-
-	if (nftnl_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND_FIRST,
-			       NFTNL_XML_OPT, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_CT_DREG, dreg);
-
-	if (nftnl_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND_FIRST,
-			       NFTNL_XML_OPT, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_CT_SREG, sreg);
-
-	key_str = nftnl_mxml_str_parse(tree, "key", MXML_DESCEND_FIRST,
-				     NFTNL_XML_MAND, err);
-	if (key_str != NULL) {
-		key = str2ctkey(key_str);
-		if (key < 0)
-			return -1;
-
-		nftnl_expr_set_u32(e, NFTNL_EXPR_CT_KEY, key);
-	}
-	dir_str = nftnl_mxml_str_parse(tree, "dir", MXML_DESCEND_FIRST,
-				     NFTNL_XML_OPT, err);
-	if (dir_str != NULL) {
-		if (str2ctdir(dir_str, &dir) != 0) {
-			err->node_name = "dir";
-			err->error = NFTNL_PARSE_EBADTYPE;
-			goto err;
-		}
-		nftnl_expr_set_u8(e, NFTNL_EXPR_CT_DIR, dir);
-	}
-
-	return 0;
-err:
-	errno = EINVAL;
-	return -1;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int
 nftnl_expr_ct_export(char *buf, size_t size, const struct nftnl_expr *e,
 		     int type)
@@ -402,6 +355,5 @@ struct expr_ops expr_ops_ct = {
 	.parse		= nftnl_expr_ct_parse,
 	.build		= nftnl_expr_ct_build,
 	.snprintf	= nftnl_expr_ct_snprintf,
-	.xml_parse	= nftnl_expr_ct_xml_parse,
 	.json_parse	= nftnl_expr_ct_json_parse,
 };
diff --git a/src/expr/data_reg.c b/src/expr/data_reg.c
index 395e9f6..0249258 100644
--- a/src/expr/data_reg.c
+++ b/src/expr/data_reg.c
@@ -96,94 +96,6 @@ int nftnl_data_reg_json_parse(union nftnl_data_reg *reg, json_t *data,
 }
 #endif
 
-#ifdef XML_PARSING
-static int nftnl_data_reg_verdict_xml_parse(union nftnl_data_reg *reg,
-					  mxml_node_t *tree,
-					  struct nftnl_parse_err *err)
-{
-	int verdict;
-	const char *verdict_str;
-	const char *chain;
-
-	verdict_str = nftnl_mxml_str_parse(tree, "verdict", MXML_DESCEND_FIRST,
-					 NFTNL_XML_MAND, err);
-	if (verdict_str == NULL)
-		return DATA_NONE;
-
-	if (nftnl_str2verdict(verdict_str, &verdict) != 0) {
-		err->node_name = "verdict";
-		err->error = NFTNL_PARSE_EBADTYPE;
-		errno = EINVAL;
-		return DATA_NONE;
-	}
-
-	reg->verdict = (uint32_t)verdict;
-
-	chain = nftnl_mxml_str_parse(tree, "chain", MXML_DESCEND_FIRST,
-				   NFTNL_XML_OPT, err);
-	if (chain != NULL) {
-		if (reg->chain)
-			xfree(reg->chain);
-
-		reg->chain = strdup(chain);
-	}
-
-	return DATA_VERDICT;
-}
-
-static int nftnl_data_reg_value_xml_parse(union nftnl_data_reg *reg,
-					mxml_node_t *tree,
-					struct nftnl_parse_err *err)
-{
-	int i;
-	char node_name[6];
-
-	if (nftnl_mxml_num_parse(tree, "len", MXML_DESCEND_FIRST, BASE_DEC,
-			       &reg->len, NFTNL_TYPE_U8, NFTNL_XML_MAND, err) != 0)
-		return DATA_NONE;
-
-	for (i = 0; i < div_round_up(reg->len, sizeof(uint32_t)); i++) {
-		sprintf(node_name, "data%d", i);
-
-		if (nftnl_mxml_num_parse(tree, node_name, MXML_DESCEND_FIRST,
-				       BASE_HEX, &reg->val[i], NFTNL_TYPE_U32,
-				       NFTNL_XML_MAND, err) != 0)
-			return DATA_NONE;
-	}
-
-	return DATA_VALUE;
-}
-
-int nftnl_data_reg_xml_parse(union nftnl_data_reg *reg, mxml_node_t *tree,
-			   struct nftnl_parse_err *err)
-{
-	const char *type;
-	mxml_node_t *node;
-
-	node = mxmlFindElement(tree, tree, "reg", "type", NULL,
-			       MXML_DESCEND_FIRST);
-	if (node == NULL)
-		goto err;
-
-	type = mxmlElementGetAttr(node, "type");
-
-	if (type == NULL)
-		goto err;
-
-	if (strcmp(type, "value") == 0)
-		return nftnl_data_reg_value_xml_parse(reg, node, err);
-	else if (strcmp(type, "verdict") == 0)
-		return nftnl_data_reg_verdict_xml_parse(reg, node, err);
-
-	return DATA_NONE;
-err:
-	errno = EINVAL;
-	err->node_name = "reg";
-	err->error = NFTNL_PARSE_EMISSINGNODE;
-	return DATA_NONE;
-}
-#endif
-
 static int
 nftnl_data_reg_value_snprintf_json(char *buf, size_t size,
 				   const union nftnl_data_reg *reg,
@@ -221,43 +133,6 @@ nftnl_data_reg_value_snprintf_json(char *buf, size_t size,
 	return offset;
 }
 
-static
-int nftnl_data_reg_value_snprintf_xml(char *buf, size_t size,
-				      const union nftnl_data_reg *reg,
-				      uint32_t flags)
-{
-	int len = size, offset = 0, ret, i, j;
-	uint32_t be;
-	uint8_t *tmp;
-
-	ret = snprintf(buf, len, "<reg type=\"value\">");
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-	ret = snprintf(buf+offset, len, "<len>%u</len>", reg->len);
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-	for (i = 0; i < div_round_up(reg->len, sizeof(uint32_t)); i++) {
-		ret = snprintf(buf+offset, len, "<data%d>0x", i);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-		be = htonl(reg->val[i]);
-		tmp = (uint8_t *)&be;
-
-		for (j = 0; j < sizeof(uint32_t); j++) {
-			ret = snprintf(buf+offset, len, "%.02x", tmp[j]);
-			SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-		}
-
-		ret = snprintf(buf+offset, len, "</data%d>", i);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-
-	ret = snprintf(buf+offset, len, "</reg>");
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-	return offset;
-}
-
 static int
 nftnl_data_reg_value_snprintf_default(char *buf, size_t size,
 				      const union nftnl_data_reg *reg,
@@ -292,29 +167,6 @@ nftnl_data_reg_verdict_snprintf_def(char *buf, size_t size,
 }
 
 static int
-nftnl_data_reg_verdict_snprintf_xml(char *buf, size_t size,
-				    const union nftnl_data_reg *reg,
-				    uint32_t flags)
-{
-	int len = size, offset = 0, ret = 0;
-
-	ret = snprintf(buf, size, "<reg type=\"verdict\">"
-		       "<verdict>%s</verdict>", nftnl_verdict2str(reg->verdict));
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-	if (reg->chain != NULL) {
-		ret = snprintf(buf+offset, len, "<chain>%s</chain>",
-			       reg->chain);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-
-	ret = snprintf(buf+offset, len, "</reg>");
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-	return offset;
-}
-
-static int
 nftnl_data_reg_verdict_snprintf_json(char *buf, size_t size,
 				     const union nftnl_data_reg *reg,
 				     uint32_t flags)
@@ -348,12 +200,10 @@ int nftnl_data_reg_snprintf(char *buf, size_t size,
 		case NFTNL_OUTPUT_DEFAULT:
 			return nftnl_data_reg_value_snprintf_default(buf, size,
 								   reg, flags);
-		case NFTNL_OUTPUT_XML:
-			return nftnl_data_reg_value_snprintf_xml(buf, size,
-							       reg, flags);
 		case NFTNL_OUTPUT_JSON:
 			return nftnl_data_reg_value_snprintf_json(buf, size,
 							       reg, flags);
+		case NFTNL_OUTPUT_XML:
 		default:
 			break;
 		}
@@ -363,12 +213,10 @@ int nftnl_data_reg_snprintf(char *buf, size_t size,
 		case NFTNL_OUTPUT_DEFAULT:
 			return nftnl_data_reg_verdict_snprintf_def(buf, size,
 								 reg, flags);
-		case NFTNL_OUTPUT_XML:
-			return nftnl_data_reg_verdict_snprintf_xml(buf, size,
-								 reg, flags);
 		case NFTNL_OUTPUT_JSON:
 			return nftnl_data_reg_verdict_snprintf_json(buf, size,
 								  reg, flags);
+		case NFTNL_OUTPUT_XML:
 		default:
 			break;
 		}
diff --git a/src/expr/dup.c b/src/expr/dup.c
index ac1923c..9aa332b 100644
--- a/src/expr/dup.c
+++ b/src/expr/dup.c
@@ -133,26 +133,6 @@ static int nftnl_expr_dup_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-static int nftnl_expr_dup_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-				    struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	uint32_t sreg_addr, sreg_dev;
-
-	if (nftnl_mxml_reg_parse(tree, "sreg_addr", &sreg_addr, MXML_DESCEND_FIRST,
-			       NFTNL_XML_OPT, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_DUP_SREG_ADDR, sreg_addr);
-	if (nftnl_mxml_reg_parse(tree, "sreg_dev", &sreg_dev, MXML_DESCEND_FIRST,
-			       NFTNL_XML_OPT, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_DUP_SREG_DEV, sreg_dev);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_expr_dup_export(char *buf, size_t size,
 				 const struct nftnl_expr *e, int type)
 {
@@ -227,6 +207,5 @@ struct expr_ops expr_ops_dup = {
 	.parse		= nftnl_expr_dup_parse,
 	.build		= nftnl_expr_dup_build,
 	.snprintf	= nftnl_expr_dup_snprintf,
-	.xml_parse	= nftnl_expr_dup_xml_parse,
 	.json_parse	= nftnl_expr_dup_json_parse,
 };
diff --git a/src/expr/dynset.c b/src/expr/dynset.c
index ea59145..20a5004 100644
--- a/src/expr/dynset.c
+++ b/src/expr/dynset.c
@@ -242,43 +242,6 @@ nftnl_expr_dynset_json_parse(struct nftnl_expr *e, json_t *root,
 }
 
 static int
-nftnl_expr_dynset_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-			       struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	const char *set_name;
-	uint32_t uval32;
-	uint64_t uval64;
-
-	set_name = nftnl_mxml_str_parse(tree, "set", MXML_DESCEND_FIRST,
-				      NFTNL_XML_MAND, err);
-	if (set_name != NULL)
-		nftnl_expr_set_str(e, NFTNL_EXPR_DYNSET_SET_NAME, set_name);
-
-	if (nftnl_mxml_reg_parse(tree, "sreg_key", &uval32, MXML_DESCEND,
-			       NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_DYNSET_SREG_KEY, uval32);
-
-	if (nftnl_mxml_reg_parse(tree, "sreg_data", &uval32, MXML_DESCEND,
-			       NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_DYNSET_SREG_DATA, uval32);
-
-	if (nftnl_mxml_num_parse(tree, "op", MXML_DESCEND_FIRST, BASE_DEC,
-			       &uval32, NFTNL_TYPE_U32, NFTNL_XML_MAND,  err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_DYNSET_OP, uval32);
-
-	if (nftnl_mxml_num_parse(tree, "timeout", MXML_DESCEND_FIRST, BASE_DEC,
-			       &uval64, NFTNL_TYPE_U64, NFTNL_XML_MAND,  err) == 0)
-		nftnl_expr_set_u64(e, NFTNL_EXPR_DYNSET_TIMEOUT, uval64);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
-static int
 nftnl_expr_dynset_export(char *buf, size_t size,
 			 const struct nftnl_expr *e, int type)
 {
@@ -406,6 +369,5 @@ struct expr_ops expr_ops_dynset = {
 	.parse		= nftnl_expr_dynset_parse,
 	.build		= nftnl_expr_dynset_build,
 	.snprintf	= nftnl_expr_dynset_snprintf,
-	.xml_parse	= nftnl_expr_dynset_xml_parse,
 	.json_parse	= nftnl_expr_dynset_json_parse,
 };
diff --git a/src/expr/exthdr.c b/src/expr/exthdr.c
index deb0d7c..b164e3f 100644
--- a/src/expr/exthdr.c
+++ b/src/expr/exthdr.c
@@ -221,45 +221,6 @@ nftnl_expr_exthdr_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-static int
-nftnl_expr_exthdr_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-			       struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	const char *exthdr_type;
-	int type;
-	uint32_t dreg, len, offset;
-
-	if (nftnl_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND_FIRST,
-			       NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_EXTHDR_DREG, dreg);
-
-	exthdr_type = nftnl_mxml_str_parse(tree, "exthdr_type",
-					 MXML_DESCEND_FIRST, NFTNL_XML_MAND, err);
-	if (exthdr_type != NULL) {
-		type = str2exthdr_type(exthdr_type);
-		if (type < 0)
-			return -1;
-		nftnl_expr_set_u8(e, NFTNL_EXPR_EXTHDR_TYPE, type);
-	}
-
-	/* Get and set <offset> */
-	if (nftnl_mxml_num_parse(tree, "offset", MXML_DESCEND_FIRST, BASE_DEC,
-			       &offset, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_EXTHDR_OFFSET, offset);
-
-	/* Get and set <len> */
-	if (nftnl_mxml_num_parse(tree, "len", MXML_DESCEND_FIRST, BASE_DEC,
-			       &len, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_EXTHDR_LEN, len);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_expr_exthdr_export(char *buf, size_t len,
 				    const struct nftnl_expr *e, int type)
 {
@@ -333,6 +294,5 @@ struct expr_ops expr_ops_exthdr = {
 	.parse		= nftnl_expr_exthdr_parse,
 	.build		= nftnl_expr_exthdr_build,
 	.snprintf	= nftnl_expr_exthdr_snprintf,
-	.xml_parse	= nftnl_expr_exthdr_xml_parse,
 	.json_parse	= nftnl_expr_exthdr_json_parse,
 };
diff --git a/src/expr/fwd.c b/src/expr/fwd.c
index 9c5520c..c30d494 100644
--- a/src/expr/fwd.c
+++ b/src/expr/fwd.c
@@ -116,23 +116,6 @@ static int nftnl_expr_fwd_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-static int nftnl_expr_fwd_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-				    struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	uint32_t sreg_dev;
-
-	if (nftnl_mxml_reg_parse(tree, "sreg_dev", &sreg_dev, MXML_DESCEND_FIRST,
-			       NFTNL_XML_OPT, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_FWD_SREG_DEV, sreg_dev);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_expr_fwd_export(char *buf, size_t size,
 				 const struct nftnl_expr *e, int type)
 {
@@ -198,6 +181,5 @@ struct expr_ops expr_ops_fwd = {
 	.parse		= nftnl_expr_fwd_parse,
 	.build		= nftnl_expr_fwd_build,
 	.snprintf	= nftnl_expr_fwd_snprintf,
-	.xml_parse	= nftnl_expr_fwd_xml_parse,
 	.json_parse	= nftnl_expr_fwd_json_parse,
 };
diff --git a/src/expr/hash.c b/src/expr/hash.c
index 371e766..08f09f5 100644
--- a/src/expr/hash.c
+++ b/src/expr/hash.c
@@ -207,49 +207,6 @@ static int nftnl_expr_hash_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-
-static int nftnl_expr_hash_xml_parse(struct nftnl_expr *e,
-				     mxml_node_t *tree,
-				     struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	uint32_t sreg, dreg, len, modulus, seed, offset;
-
-	if (nftnl_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND_FIRST,
-				 NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_HASH_SREG, sreg);
-
-	if (nftnl_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND_FIRST,
-				 NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_HASH_DREG, dreg);
-
-	if (nftnl_mxml_num_parse(tree, "len", MXML_DESCEND_FIRST, BASE_DEC,
-				 &len, NFTNL_TYPE_U32, NFTNL_XML_MAND,
-				 err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_HASH_LEN, len);
-
-	if (nftnl_mxml_num_parse(tree, "modulus", MXML_DESCEND_FIRST, BASE_DEC,
-				 &modulus, NFTNL_TYPE_U32, NFTNL_XML_MAND,
-				 err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_HASH_MODULUS, modulus);
-
-	if (nftnl_mxml_num_parse(tree, "seed", MXML_DESCEND_FIRST, BASE_DEC,
-				 &seed, NFTNL_TYPE_U32, NFTNL_XML_MAND,
-				 err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_HASH_SEED, seed);
-
-	if (nftnl_mxml_num_parse(tree, "offset", MXML_DESCEND_FIRST, BASE_DEC,
-				 &offset, NFTNL_TYPE_U32, NFTNL_XML_MAND,
-				 err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_HASH_OFFSET, offset);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int
 nftnl_expr_hash_snprintf_default(char *buf, size_t size,
 				 const struct nftnl_expr *e)
@@ -338,6 +295,5 @@ struct expr_ops expr_ops_hash = {
 	.parse		= nftnl_expr_hash_parse,
 	.build		= nftnl_expr_hash_build,
 	.snprintf	= nftnl_expr_hash_snprintf,
-	.xml_parse	= nftnl_expr_hash_xml_parse,
 	.json_parse	= nftnl_expr_hash_json_parse,
 };
diff --git a/src/expr/immediate.c b/src/expr/immediate.c
index 2fdae9c..0b188cc 100644
--- a/src/expr/immediate.c
+++ b/src/expr/immediate.c
@@ -210,44 +210,6 @@ nftnl_expr_immediate_json_parse(struct nftnl_expr *e, json_t *root,
 }
 
 static int
-nftnl_expr_immediate_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-				  struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	struct nftnl_expr_immediate *imm = nftnl_expr_data(e);
-	int datareg_type;
-	uint32_t reg;
-
-	if (nftnl_mxml_reg_parse(tree, "dreg", &reg, MXML_DESCEND_FIRST,
-			       NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_IMM_DREG, reg);
-
-	datareg_type = nftnl_mxml_data_reg_parse(tree, "data",
-					       &imm->data, NFTNL_XML_MAND, err);
-	if (datareg_type >= 0) {
-		switch (datareg_type) {
-		case DATA_VALUE:
-			e->flags |= (1 << NFTNL_EXPR_IMM_DATA);
-			break;
-		case DATA_VERDICT:
-			e->flags |= (1 << NFTNL_EXPR_IMM_VERDICT);
-			break;
-		case DATA_CHAIN:
-			e->flags |= (1 << NFTNL_EXPR_IMM_CHAIN);
-			break;
-		default:
-			return -1;
-		}
-	}
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
-static int
 nftnl_expr_immediate_export(char *buf, size_t size, const struct nftnl_expr *e,
 			    int type)
 {
@@ -355,6 +317,5 @@ struct expr_ops expr_ops_immediate = {
 	.parse		= nftnl_expr_immediate_parse,
 	.build		= nftnl_expr_immediate_build,
 	.snprintf	= nftnl_expr_immediate_snprintf,
-	.xml_parse	= nftnl_expr_immediate_xml_parse,
 	.json_parse	= nftnl_expr_immediate_json_parse,
 };
diff --git a/src/expr/limit.c b/src/expr/limit.c
index 9f19d53..856ab18 100644
--- a/src/expr/limit.c
+++ b/src/expr/limit.c
@@ -186,38 +186,6 @@ static int nftnl_expr_limit_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-static int nftnl_expr_limit_xml_parse(struct nftnl_expr *e,
-					 mxml_node_t *tree,
-					 struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	uint64_t rate, unit;
-	uint32_t burst, type, flags;
-
-	if (nftnl_mxml_num_parse(tree, "rate", MXML_DESCEND_FIRST, BASE_DEC,
-			       &rate, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u64(e, NFTNL_EXPR_LIMIT_RATE, rate);
-
-	if (nftnl_mxml_num_parse(tree, "unit", MXML_DESCEND_FIRST, BASE_DEC,
-			       &unit, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u64(e, NFTNL_EXPR_LIMIT_UNIT, unit);
-	if (nftnl_mxml_num_parse(tree, "burst", MXML_DESCEND_FIRST, BASE_DEC,
-			       &burst, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_LIMIT_BURST, burst);
-	if (nftnl_mxml_num_parse(tree, "type", MXML_DESCEND_FIRST, BASE_DEC,
-			       &type, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_LIMIT_TYPE, type);
-	if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC,
-			       &flags, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_LIMIT_FLAGS, flags);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static const char *get_unit(uint64_t u)
 {
 	switch (u) {
@@ -318,6 +286,5 @@ struct expr_ops expr_ops_limit = {
 	.parse		= nftnl_expr_limit_parse,
 	.build		= nftnl_expr_limit_build,
 	.snprintf	= nftnl_expr_limit_snprintf,
-	.xml_parse	= nftnl_expr_limit_xml_parse,
 	.json_parse	= nftnl_expr_limit_json_parse,
 };
diff --git a/src/expr/log.c b/src/expr/log.c
index d1e7b8d..57490d9 100644
--- a/src/expr/log.c
+++ b/src/expr/log.c
@@ -224,50 +224,6 @@ static int nftnl_expr_log_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-static int nftnl_expr_log_xml_parse(struct nftnl_expr *e,
-				       mxml_node_t *tree,
-				       struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	const char *prefix;
-	uint32_t snaplen, level, flags;
-	uint16_t group, qthreshold;
-
-	prefix = nftnl_mxml_str_parse(tree, "prefix", MXML_DESCEND_FIRST,
-				    NFTNL_XML_MAND, err);
-	if (prefix != NULL)
-		nftnl_expr_set_str(e, NFTNL_EXPR_LOG_PREFIX, prefix);
-
-	if (nftnl_mxml_num_parse(tree, "group", MXML_DESCEND_FIRST, BASE_DEC,
-			       &group, NFTNL_TYPE_U16, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u16(e, NFTNL_EXPR_LOG_GROUP, group);
-
-	if (nftnl_mxml_num_parse(tree, "snaplen", MXML_DESCEND_FIRST, BASE_DEC,
-			       &snaplen, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_LOG_SNAPLEN, snaplen);
-
-	if (nftnl_mxml_num_parse(tree, "qthreshold", MXML_DESCEND_FIRST, BASE_DEC,
-			       &qthreshold, NFTNL_TYPE_U16, NFTNL_XML_MAND,
-			       err) == 0)
-		nftnl_expr_set_u16(e, NFTNL_EXPR_LOG_QTHRESHOLD, qthreshold);
-
-	if (nftnl_mxml_num_parse(tree, "level", MXML_DESCEND_FIRST, BASE_DEC,
-			       &level, NFTNL_TYPE_U16, NFTNL_XML_MAND,
-			       err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_LOG_LEVEL, level);
-
-	if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC,
-			       &flags, NFTNL_TYPE_U16, NFTNL_XML_MAND,
-			       err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_LOG_FLAGS, flags);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_expr_log_snprintf_default(char *buf, size_t size,
 					   const struct nftnl_expr *e)
 {
@@ -370,6 +326,5 @@ struct expr_ops expr_ops_log = {
 	.parse		= nftnl_expr_log_parse,
 	.build		= nftnl_expr_log_build,
 	.snprintf	= nftnl_expr_log_snprintf,
-	.xml_parse	= nftnl_expr_log_xml_parse,
 	.json_parse	= nftnl_expr_log_json_parse,
 };
diff --git a/src/expr/lookup.c b/src/expr/lookup.c
index 1377c0c..861815f 100644
--- a/src/expr/lookup.c
+++ b/src/expr/lookup.c
@@ -197,39 +197,6 @@ nftnl_expr_lookup_json_parse(struct nftnl_expr *e, json_t *root,
 }
 
 static int
-nftnl_expr_lookup_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-			       struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	const char *set_name;
-	uint32_t sreg, dreg, flags;
-
-	set_name = nftnl_mxml_str_parse(tree, "set", MXML_DESCEND_FIRST,
-				      NFTNL_XML_MAND, err);
-	if (set_name != NULL)
-		nftnl_expr_set_str(e, NFTNL_EXPR_LOOKUP_SET, set_name);
-
-	if (nftnl_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND, NFTNL_XML_MAND,
-			       err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_LOOKUP_SREG, sreg);
-
-	if (nftnl_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND, NFTNL_XML_OPT,
-			       err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_LOOKUP_DREG, dreg);
-
-        if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC,
-				 &flags, NFTNL_TYPE_U32,
-				 NFTNL_XML_MAND, err) == 0)
-                nftnl_expr_set_u32(e, NFTNL_EXPR_LOOKUP_FLAGS, flags);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
-static int
 nftnl_expr_lookup_export(char *buf, size_t size,
 			 const struct nftnl_expr *e, int type)
 {
@@ -327,6 +294,5 @@ struct expr_ops expr_ops_lookup = {
 	.parse		= nftnl_expr_lookup_parse,
 	.build		= nftnl_expr_lookup_build,
 	.snprintf	= nftnl_expr_lookup_snprintf,
-	.xml_parse	= nftnl_expr_lookup_xml_parse,
 	.json_parse	= nftnl_expr_lookup_json_parse,
 };
diff --git a/src/expr/masq.c b/src/expr/masq.c
index 77506fe..32b5ad9 100644
--- a/src/expr/masq.c
+++ b/src/expr/masq.c
@@ -155,32 +155,6 @@ nftnl_expr_masq_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-static int
-nftnl_expr_masq_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-			     struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	uint32_t flags;
-	uint32_t reg_proto_min, reg_proto_max;
-
-	if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC,
-			       &flags, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_MASQ_FLAGS, flags);
-	if (nftnl_mxml_reg_parse(tree, "sreg_proto_min", &reg_proto_min,
-				 MXML_DESCEND, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_MASQ_REG_PROTO_MIN,
-				   reg_proto_min);
-	if (nftnl_mxml_reg_parse(tree, "sreg_proto_max", &reg_proto_max,
-				 MXML_DESCEND, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_MASQ_REG_PROTO_MAX,
-				   reg_proto_max);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
 static int nftnl_expr_masq_export(char *buf, size_t size,
 				  const struct nftnl_expr *e, int type)
 {
@@ -255,6 +229,5 @@ struct expr_ops expr_ops_masq = {
 	.parse		= nftnl_expr_masq_parse,
 	.build		= nftnl_expr_masq_build,
 	.snprintf	= nftnl_expr_masq_snprintf,
-	.xml_parse	= nftnl_expr_masq_xml_parse,
 	.json_parse	= nftnl_expr_masq_json_parse,
 };
diff --git a/src/expr/match.c b/src/expr/match.c
index c48518e..dd09e1e 100644
--- a/src/expr/match.c
+++ b/src/expr/match.c
@@ -182,26 +182,6 @@ static int nftnl_expr_match_json_parse(struct nftnl_expr *e, json_t *root,
 }
 
 
-static int nftnl_expr_match_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-					 struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	const char *name;
-
-	name = nftnl_mxml_str_parse(tree, "name", MXML_DESCEND_FIRST,
-				  NFTNL_XML_MAND, err);
-	if (name != NULL)
-		nftnl_expr_set_str(e, NFTNL_EXPR_MT_NAME, name);
-
-	/* mt->info is ignored until other solution is reached */
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_expr_match_export(char *buf, size_t size,
 				   const struct nftnl_expr *e, int type)
 {
@@ -270,6 +250,5 @@ struct expr_ops expr_ops_match = {
 	.parse		= nftnl_expr_match_parse,
 	.build		= nftnl_expr_match_build,
 	.snprintf	= nftnl_expr_match_snprintf,
-	.xml_parse 	= nftnl_expr_match_xml_parse,
 	.json_parse 	= nftnl_expr_match_json_parse,
 };
diff --git a/src/expr/meta.c b/src/expr/meta.c
index 6abf6c4..2c75841 100644
--- a/src/expr/meta.c
+++ b/src/expr/meta.c
@@ -215,38 +215,6 @@ static int nftnl_expr_meta_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-
-static int nftnl_expr_meta_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-					struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	const char *key_str;
-	int key;
-	uint32_t dreg, sreg;
-
-	key_str = nftnl_mxml_str_parse(tree, "key", MXML_DESCEND_FIRST,
-				     NFTNL_XML_MAND, err);
-	if (key_str != NULL) {
-		key = str2meta_key(key_str);
-		if (key >= 0)
-			nftnl_expr_set_u32(e, NFTNL_EXPR_META_KEY, key);
-	}
-
-	if (nftnl_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND_FIRST,
-			       NFTNL_XML_OPT, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_META_DREG, dreg);
-
-	if (nftnl_mxml_reg_parse(tree, "sreg", &sreg, MXML_DESCEND_FIRST,
-			       NFTNL_XML_OPT, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_META_SREG, sreg);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int
 nftnl_expr_meta_snprintf_default(char *buf, size_t len,
 				 const struct nftnl_expr *e)
@@ -323,6 +291,5 @@ struct expr_ops expr_ops_meta = {
 	.parse		= nftnl_expr_meta_parse,
 	.build		= nftnl_expr_meta_build,
 	.snprintf	= nftnl_expr_meta_snprintf,
-	.xml_parse 	= nftnl_expr_meta_xml_parse,
 	.json_parse 	= nftnl_expr_meta_json_parse,
 };
diff --git a/src/expr/nat.c b/src/expr/nat.c
index 485a623..29bc3a2 100644
--- a/src/expr/nat.c
+++ b/src/expr/nat.c
@@ -275,60 +275,6 @@ static int nftnl_expr_nat_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-static int nftnl_expr_nat_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-				       struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	const char *nat_type;
-	uint32_t family, nat_type_value, flags;
-	uint32_t reg_addr_min, reg_addr_max;
-	uint32_t reg_proto_min, reg_proto_max;
-
-	nat_type = nftnl_mxml_str_parse(tree, "nat_type", MXML_DESCEND_FIRST,
-				      NFTNL_XML_MAND, err);
-	if (nat_type == NULL)
-		return -1;
-
-	nat_type_value = nftnl_str2nat(nat_type);
-	if (nat_type_value < 0)
-		return -1;
-	nftnl_expr_set_u32(e, NFTNL_EXPR_NAT_TYPE, nat_type_value);
-
-	family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST,
-				       NFTNL_XML_MAND, err);
-	if (family < 0) {
-		mxmlDelete(tree);
-		return -1;
-	}
-	nftnl_expr_set_u32(e, NFTNL_EXPR_NAT_FAMILY, family);
-
-	if (nftnl_mxml_reg_parse(tree, "sreg_addr_min", &reg_addr_min,
-			       MXML_DESCEND, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_NAT_REG_ADDR_MIN, reg_addr_min);
-
-	if (nftnl_mxml_reg_parse(tree, "sreg_addr_max", &reg_addr_max,
-			       MXML_DESCEND, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_NAT_REG_ADDR_MAX, reg_addr_max);
-
-	if (nftnl_mxml_reg_parse(tree, "sreg_proto_min", &reg_proto_min,
-			       MXML_DESCEND, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_NAT_REG_PROTO_MIN, reg_proto_min);
-
-	if (nftnl_mxml_reg_parse(tree, "sreg_proto_max", &reg_proto_max,
-			       MXML_DESCEND, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_NAT_REG_PROTO_MAX, reg_proto_max);
-
-	if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND, BASE_DEC, &flags,
-			       NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_NAT_FLAGS, flags);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_expr_nat_export(char *buf, size_t size,
 				 const struct nftnl_expr *e, int type)
 {
@@ -438,6 +384,5 @@ struct expr_ops expr_ops_nat = {
 	.parse		= nftnl_expr_nat_parse,
 	.build		= nftnl_expr_nat_build,
 	.snprintf	= nftnl_expr_nat_snprintf,
-	.xml_parse	= nftnl_expr_nat_xml_parse,
 	.json_parse	= nftnl_expr_nat_json_parse,
 };
diff --git a/src/expr/numgen.c b/src/expr/numgen.c
index 8b667c2..f5ca3fd 100644
--- a/src/expr/numgen.c
+++ b/src/expr/numgen.c
@@ -171,40 +171,6 @@ static int nftnl_expr_ng_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-
-static int nftnl_expr_ng_xml_parse(struct nftnl_expr *e,
-				   mxml_node_t *tree,
-				   struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	uint32_t dreg, modulus, type, offset;
-
-	if (nftnl_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND_FIRST,
-				 NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_NG_DREG, dreg);
-
-	if (nftnl_mxml_num_parse(tree, "modulus", MXML_DESCEND_FIRST, BASE_DEC,
-				 &modulus, NFTNL_TYPE_U32, NFTNL_XML_MAND,
-				 err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_NG_MODULUS, modulus);
-
-	if (nftnl_mxml_num_parse(tree, "type", MXML_DESCEND_FIRST, BASE_DEC,
-				 &type, NFTNL_TYPE_U32, NFTNL_XML_MAND,
-				 err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_NG_TYPE, type);
-
-	if (nftnl_mxml_num_parse(tree, "offset", MXML_DESCEND_FIRST, BASE_DEC,
-				 &offset, NFTNL_TYPE_U32, NFTNL_XML_MAND,
-				 err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_NG_OFFSET, offset);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int
 nftnl_expr_ng_snprintf_default(char *buf, size_t size,
 			       const struct nftnl_expr *e)
@@ -294,6 +260,5 @@ struct expr_ops expr_ops_ng = {
 	.parse		= nftnl_expr_ng_parse,
 	.build		= nftnl_expr_ng_build,
 	.snprintf	= nftnl_expr_ng_snprintf,
-	.xml_parse	= nftnl_expr_ng_xml_parse,
 	.json_parse	= nftnl_expr_ng_json_parse,
 };
diff --git a/src/expr/payload.c b/src/expr/payload.c
index c9ab5d4..17dd4cd 100644
--- a/src/expr/payload.c
+++ b/src/expr/payload.c
@@ -251,45 +251,6 @@ nftnl_expr_payload_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-static int
-nftnl_expr_payload_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-				struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	const char *base_str;
-	int32_t base;
-	uint32_t dreg, offset, len;
-
-	if (nftnl_mxml_reg_parse(tree, "dreg", &dreg, MXML_DESCEND_FIRST,
-			       NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_PAYLOAD_DREG, dreg);
-
-	base_str = nftnl_mxml_str_parse(tree, "base", MXML_DESCEND_FIRST,
-				      NFTNL_XML_MAND, err);
-	if (base_str != NULL) {
-		base = nftnl_str2base(base_str);
-		if (base < 0)
-			return -1;
-
-		nftnl_expr_set_u32(e, NFTNL_EXPR_PAYLOAD_BASE, base);
-	}
-
-	if (nftnl_mxml_num_parse(tree, "offset", MXML_DESCEND_FIRST, BASE_DEC,
-			       &offset, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_PAYLOAD_OFFSET, offset);
-
-
-	if (nftnl_mxml_num_parse(tree, "len", MXML_DESCEND_FIRST, BASE_DEC,
-			       &len, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_PAYLOAD_LEN, len);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_expr_payload_export(char *buf, size_t size, uint32_t flags,
 				     const struct nftnl_expr *e, int type)
 {
@@ -370,6 +331,5 @@ struct expr_ops expr_ops_payload = {
 	.parse		= nftnl_expr_payload_parse,
 	.build		= nftnl_expr_payload_build,
 	.snprintf	= nftnl_expr_payload_snprintf,
-	.xml_parse	= nftnl_expr_payload_xml_parse,
 	.json_parse	= nftnl_expr_payload_json_parse,
 };
diff --git a/src/expr/queue.c b/src/expr/queue.c
index 316a9ed..8a9deda 100644
--- a/src/expr/queue.c
+++ b/src/expr/queue.c
@@ -172,41 +172,6 @@ nftnl_expr_queue_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-static int
-nftnl_expr_queue_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-			      struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	uint16_t queue_num, queue_total, flags;
-	uint32_t sreg_qnum;
-
-	if (nftnl_mxml_num_parse(tree, "num", MXML_DESCEND_FIRST, BASE_DEC,
-			       &queue_num, NFTNL_TYPE_U16, NFTNL_XML_MAND,
-			       err) == 0)
-		nftnl_expr_set_u16(e, NFTNL_EXPR_QUEUE_NUM, queue_num);
-
-	if (nftnl_mxml_num_parse(tree, "total", MXML_DESCEND_FIRST, BASE_DEC,
-			       &queue_total, NFTNL_TYPE_U16,
-			       NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u16(e, NFTNL_EXPR_QUEUE_TOTAL, queue_total);
-
-	if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC,
-			       &flags, NFTNL_TYPE_U16,
-			       NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u16(e, NFTNL_EXPR_QUEUE_FLAGS, flags);
-
-	if (nftnl_mxml_num_parse(tree, "sreg_qnum", MXML_DESCEND_FIRST, BASE_DEC,
-			       &sreg_qnum, NFTNL_TYPE_U32,
-			       NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_QUEUE_SREG_QNUM, sreg_qnum);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_expr_queue_snprintf_default(char *buf, size_t len,
 					     const struct nftnl_expr *e)
 {
@@ -312,6 +277,5 @@ struct expr_ops expr_ops_queue = {
 	.parse		= nftnl_expr_queue_parse,
 	.build		= nftnl_expr_queue_build,
 	.snprintf	= nftnl_expr_queue_snprintf,
-	.xml_parse	= nftnl_expr_queue_xml_parse,
 	.json_parse	= nftnl_expr_queue_json_parse,
 };
diff --git a/src/expr/quota.c b/src/expr/quota.c
index 47db62f..7740b24 100644
--- a/src/expr/quota.c
+++ b/src/expr/quota.c
@@ -136,27 +136,6 @@ nftnl_expr_quota_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-static int nftnl_expr_quota_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-				      struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	uint64_t bytes;
-	uint32_t flags;
-
-	if (nftnl_mxml_num_parse(tree, "bytes", MXML_DESCEND_FIRST, BASE_DEC,
-				 &bytes, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u64(e, NFTNL_EXPR_QUOTA_BYTES, bytes);
-	if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC,
-				 &flags, NFTNL_TYPE_U32, NFTNL_XML_MAND,  err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_QUOTA_FLAGS, flags);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_expr_quota_export(char *buf, size_t size,
 				   const struct nftnl_expr *e, int type)
 {
@@ -205,6 +184,5 @@ struct expr_ops expr_ops_quota = {
 	.parse		= nftnl_expr_quota_parse,
 	.build		= nftnl_expr_quota_build,
 	.snprintf	= nftnl_expr_quota_snprintf,
-	.xml_parse	= nftnl_expr_quota_xml_parse,
 	.json_parse	= nftnl_expr_quota_json_parse,
 };
diff --git a/src/expr/redir.c b/src/expr/redir.c
index d9dba00..d5bc179 100644
--- a/src/expr/redir.c
+++ b/src/expr/redir.c
@@ -157,32 +157,6 @@ nftnl_expr_redir_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-static int
-nftnl_expr_redir_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-			      struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	uint32_t reg, flags;
-
-	if (nftnl_mxml_reg_parse(tree, "sreg_proto_min", &reg,
-			       MXML_DESCEND, NFTNL_XML_OPT, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_REDIR_REG_PROTO_MIN, reg);
-
-	if (nftnl_mxml_reg_parse(tree, "sreg_proto_max", &reg,
-			       MXML_DESCEND, NFTNL_XML_OPT, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_REDIR_REG_PROTO_MAX, reg);
-
-	if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC,
-			       &flags, NFTNL_TYPE_U32, NFTNL_XML_OPT, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_REDIR_FLAGS, flags);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_expr_redir_export(char *buf, size_t size,
 				   const struct nftnl_expr *e, int type)
 {
@@ -269,6 +243,5 @@ struct expr_ops expr_ops_redir = {
 	.parse		= nftnl_expr_redir_parse,
 	.build		= nftnl_expr_redir_build,
 	.snprintf	= nftnl_expr_redir_snprintf,
-	.xml_parse	= nftnl_expr_redir_xml_parse,
 	.json_parse	= nftnl_expr_redir_json_parse,
 };
diff --git a/src/expr/reject.c b/src/expr/reject.c
index 2906082..11d8b20 100644
--- a/src/expr/reject.c
+++ b/src/expr/reject.c
@@ -137,29 +137,6 @@ nftnl_expr_reject_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-static int
-nftnl_expr_reject_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-			       struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	uint32_t type;
-	uint8_t code;
-
-	if (nftnl_mxml_num_parse(tree, "type", MXML_DESCEND_FIRST, BASE_DEC,
-			       &type, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u32(e, NFTNL_EXPR_REJECT_TYPE, type);
-
-	if (nftnl_mxml_num_parse(tree, "code", MXML_DESCEND_FIRST, BASE_DEC,
-			       &code, NFTNL_TYPE_U8, NFTNL_XML_MAND, err) == 0)
-		nftnl_expr_set_u8(e, NFTNL_EXPR_REJECT_CODE, code);
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_expr_reject_snprintf_default(char *buf, size_t len,
 					      const struct nftnl_expr *e)
 {
@@ -224,6 +201,5 @@ struct expr_ops expr_ops_reject = {
 	.parse		= nftnl_expr_reject_parse,
 	.build		= nftnl_expr_reject_build,
 	.snprintf	= nftnl_expr_reject_snprintf,
-	.xml_parse	= nftnl_expr_reject_xml_parse,
 	.json_parse	= nftnl_expr_reject_json_parse,
 };
diff --git a/src/expr/target.c b/src/expr/target.c
index 5a3301c..ed4bf7d 100644
--- a/src/expr/target.c
+++ b/src/expr/target.c
@@ -182,27 +182,6 @@ nftnl_expr_target_json_parse(struct nftnl_expr *e, json_t *root,
 #endif
 }
 
-static int
-nftnl_expr_target_xml_parse(struct nftnl_expr *e, mxml_node_t *tree,
-			       struct nftnl_parse_err *err)
-{
-#ifdef XML_PARSING
-	const char *name;
-
-	name = nftnl_mxml_str_parse(tree, "name", MXML_DESCEND_FIRST,
-				  NFTNL_XML_MAND, err);
-	if (name != NULL)
-		nftnl_expr_set_str(e, NFTNL_EXPR_TG_NAME, name);
-
-	/* tg->info is ignored until other solution is reached */
-
-	return 0;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_rule_exp_target_export(char *buf, size_t size,
 				        const struct nftnl_expr *e, int type)
 {
@@ -271,6 +250,5 @@ struct expr_ops expr_ops_target = {
 	.parse		= nftnl_expr_target_parse,
 	.build		= nftnl_expr_target_build,
 	.snprintf	= nftnl_expr_target_snprintf,
-	.xml_parse	= nftnl_expr_target_xml_parse,
 	.json_parse	= nftnl_expr_target_json_parse,
 };
diff --git a/src/mxml.c b/src/mxml.c
deleted file mode 100644
index 51dbf1b..0000000
--- a/src/mxml.c
+++ /dev/null
@@ -1,232 +0,0 @@
-/*
- * (C) 2012-2013 by Pablo Neira Ayuso <pablo@netfilter.org>
- * (C) 2013 by Arturo Borrero Gonzalez <arturo.borrero.glez@gmail.com>
- *
- * This program 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 of the License, or
- * (at your option) any later version.
- *
- * This code has been sponsored by Sophos Astaro <http://www.sophos.com>
- */
-#include "internal.h"
-
-#include <stdint.h>
-#include <limits.h>
-
-#include <linux/netfilter/nf_tables.h>
-#include <libnftnl/table.h>
-#include <libnftnl/chain.h>
-#include <libnftnl/rule.h>
-#include <libnftnl/expr.h>
-#include <libnftnl/set.h>
-
-#ifdef XML_PARSING
-mxml_node_t *nftnl_mxml_build_tree(const void *data, const char *treename,
-				 struct nftnl_parse_err *err, enum nftnl_parse_input input)
-{
-	mxml_node_t *tree;
-
-	switch (input) {
-	case NFTNL_PARSE_BUFFER:
-		tree = mxmlLoadString(NULL, data, MXML_OPAQUE_CALLBACK);
-		break;
-	case NFTNL_PARSE_FILE:
-		tree = mxmlLoadFile(NULL, (FILE *)data, MXML_OPAQUE_CALLBACK);
-		break;
-	default:
-		goto err;
-	}
-
-	if (tree == NULL) {
-		err->error = NFTNL_PARSE_EBADINPUT;
-		goto err;
-	}
-
-	if (tree->value.opaque != NULL &&
-	    strcmp(tree->value.opaque, treename) == 0)
-		return tree;
-
-	err->error = NFTNL_PARSE_EMISSINGNODE;
-	err->node_name = treename;
-
-	mxmlDelete(tree);
-err:
-	err->line = 0;
-	err->column = 0;
-	errno = EINVAL;
-	return NULL;
-}
-
-struct nftnl_expr *nftnl_mxml_expr_parse(mxml_node_t *node,
-					  struct nftnl_parse_err *err,
-					  struct nftnl_set_list *set_list)
-{
-	mxml_node_t *tree;
-	struct nftnl_expr *e;
-	const char *expr_name;
-	char *xml_text;
-	uint32_t set_id;
-	int ret;
-
-	expr_name = mxmlElementGetAttr(node, "type");
-	if (expr_name == NULL) {
-		err->node_name = "type";
-		err->error = NFTNL_PARSE_EMISSINGNODE;
-		goto err;
-	}
-
-	e = nftnl_expr_alloc(expr_name);
-	if (e == NULL)
-		goto err;
-
-	xml_text = mxmlSaveAllocString(node, MXML_NO_CALLBACK);
-	if (xml_text == NULL)
-		goto err_expr;
-
-	tree = mxmlLoadString(NULL, xml_text, MXML_OPAQUE_CALLBACK);
-	xfree(xml_text);
-
-	if (tree == NULL)
-		goto err_expr;
-
-	ret = e->ops->xml_parse(e, tree, err);
-	mxmlDelete(tree);
-
-	if (set_list != NULL &&
-	    strcmp(expr_name, "lookup") == 0 &&
-	    nftnl_set_lookup_id(e, set_list, &set_id))
-		nftnl_expr_set_u32(e, NFTNL_EXPR_LOOKUP_SET_ID, set_id);
-
-	return ret < 0 ? NULL : e;
-err_expr:
-	nftnl_expr_free(e);
-err:
-	mxmlDelete(tree);
-	errno = EINVAL;
-	return NULL;
-}
-
-int nftnl_mxml_reg_parse(mxml_node_t *tree, const char *reg_name, uint32_t *reg,
-		       uint32_t mxmlflags, uint32_t flags,
-		       struct nftnl_parse_err *err)
-{
-	mxml_node_t *node;
-
-	node = mxmlFindElement(tree, tree, reg_name, NULL, NULL, mxmlflags);
-	if (node == NULL) {
-		if (!(flags & NFTNL_XML_OPT)) {
-			err->error = NFTNL_PARSE_EMISSINGNODE;
-			errno = EINVAL;
-			goto err;
-		}
-		return -1;
-	}
-
-	if (nftnl_strtoi(node->child->value.opaque, BASE_DEC, reg,
-		       NFTNL_TYPE_U32) != 0) {
-		err->error = NFTNL_PARSE_EBADTYPE;
-		goto err;
-	}
-
-	if (*reg > NFT_REG_MAX) {
-		errno = ERANGE;
-		goto err;
-	}
-
-	return 0;
-err:
-	err->node_name = reg_name;
-	return -1;
-}
-
-int nftnl_mxml_data_reg_parse(mxml_node_t *tree, const char *node_name,
-			    union nftnl_data_reg *data_reg, uint16_t flags,
-			    struct nftnl_parse_err *err)
-{
-	mxml_node_t *node;
-
-	node = mxmlFindElement(tree, tree, node_name, NULL, NULL,
-			       MXML_DESCEND_FIRST);
-
-	/* It is necessary for the compatibility with cmpdata label. */
-	if (node == NULL || node->child == NULL)
-		node = tree;
-
-	return nftnl_data_reg_xml_parse(data_reg, node, err);
-}
-
-int
-nftnl_mxml_num_parse(mxml_node_t *tree, const char *node_name,
-		   uint32_t mxml_flags, int base, void *number,
-		   enum nftnl_type type, uint16_t flags,
-		   struct nftnl_parse_err *err)
-{
-	mxml_node_t *node = NULL;
-	int ret;
-
-	node = mxmlFindElement(tree, tree, node_name, NULL, NULL, mxml_flags);
-	if (node == NULL || node->child == NULL) {
-		if (!(flags & NFTNL_XML_OPT)) {
-			errno = EINVAL;
-			err->node_name = node_name;
-			err->error = NFTNL_PARSE_EMISSINGNODE;
-		}
-		return -1;
-	}
-
-	ret = nftnl_strtoi(node->child->value.opaque, base, number, type);
-
-	if (ret != 0) {
-		err->error = NFTNL_PARSE_EBADTYPE;
-		err->node_name = node_name;
-	}
-	return ret;
-}
-
-const char *nftnl_mxml_str_parse(mxml_node_t *tree, const char *node_name,
-			       uint32_t mxml_flags, uint16_t flags,
-			       struct nftnl_parse_err *err)
-{
-	mxml_node_t *node;
-	const char *ret;
-
-	node = mxmlFindElement(tree, tree, node_name, NULL, NULL, mxml_flags);
-	if (node == NULL || node->child == NULL) {
-		if (!(flags & NFTNL_XML_OPT)) {
-			errno = EINVAL;
-			err->node_name = node_name;
-			err->error = NFTNL_PARSE_EMISSINGNODE;
-		}
-		return NULL;
-	}
-
-	ret = node->child->value.opaque;
-	if (ret == NULL) {
-		err->node_name = node_name;
-		err->error = NFTNL_PARSE_EBADTYPE;
-	}
-	return ret;
-}
-
-int nftnl_mxml_family_parse(mxml_node_t *tree, const char *node_name,
-			  uint32_t mxml_flags, uint16_t flags,
-			  struct nftnl_parse_err *err)
-{
-	const char *family_str;
-	int family;
-
-	family_str = nftnl_mxml_str_parse(tree, node_name, mxml_flags,
-					flags, err);
-	if (family_str == NULL)
-		return -1;
-
-	family = nftnl_str2family(family_str);
-	if (family < 0) {
-		err->node_name = node_name;
-		errno = EAFNOSUPPORT;
-	}
-
-	return family;
-}
-#endif
diff --git a/src/rule.c b/src/rule.c
index 5d0097c..22026a4 100644
--- a/src/rule.c
+++ b/src/rule.c
@@ -609,92 +609,6 @@ static int nftnl_rule_json_parse(struct nftnl_rule *r, const void *json,
 #endif
 }
 
-#ifdef XML_PARSING
-int nftnl_mxml_rule_parse(mxml_node_t *tree, struct nftnl_rule *r,
-			struct nftnl_parse_err *err,
-			struct nftnl_set_list *set_list)
-{
-	mxml_node_t *node;
-	struct nftnl_expr *e;
-	const char *table, *chain;
-	int family;
-
-	family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST,
-				       NFTNL_XML_MAND, err);
-	if (family >= 0)
-		nftnl_rule_set_u32(r, NFTNL_RULE_FAMILY, family);
-
-	table = nftnl_mxml_str_parse(tree, "table", MXML_DESCEND_FIRST,
-				   NFTNL_XML_MAND, err);
-	if (table != NULL)
-		nftnl_rule_set_str(r, NFTNL_RULE_TABLE, table);
-
-	chain = nftnl_mxml_str_parse(tree, "chain", MXML_DESCEND_FIRST,
-				   NFTNL_XML_MAND, err);
-	if (chain != NULL)
-		nftnl_rule_set_str(r, NFTNL_RULE_CHAIN, chain);
-
-	if (nftnl_mxml_num_parse(tree, "handle", MXML_DESCEND_FIRST, BASE_DEC,
-			      &r->handle, NFTNL_TYPE_U64, NFTNL_XML_MAND, err) >= 0)
-		r->flags |= (1 << NFTNL_RULE_HANDLE);
-
-	if (nftnl_mxml_num_parse(tree, "compat_proto", MXML_DESCEND_FIRST,
-			       BASE_DEC, &r->compat.proto, NFTNL_TYPE_U32,
-			       NFTNL_XML_OPT, err) >= 0)
-		r->flags |= (1 << NFTNL_RULE_COMPAT_PROTO);
-
-	if (nftnl_mxml_num_parse(tree, "compat_flags", MXML_DESCEND_FIRST,
-			       BASE_DEC, &r->compat.flags, NFTNL_TYPE_U32,
-			       NFTNL_XML_OPT, err) >= 0)
-		r->flags |= (1 << NFTNL_RULE_COMPAT_FLAGS);
-
-	if (nftnl_rule_is_set(r, NFTNL_RULE_COMPAT_PROTO) !=
-			nftnl_rule_is_set(r, NFTNL_RULE_COMPAT_FLAGS)) {
-		errno = EINVAL;
-	}
-
-	if (nftnl_mxml_num_parse(tree, "position", MXML_DESCEND_FIRST,
-			       BASE_DEC, &r->position, NFTNL_TYPE_U64,
-			       NFTNL_XML_OPT, err) >= 0)
-		r->flags |= (1 << NFTNL_RULE_POSITION);
-
-	/* Iterating over <expr> */
-	for (node = mxmlFindElement(tree, tree, "expr", "type",
-				    NULL, MXML_DESCEND);
-		node != NULL;
-		node = mxmlFindElement(node, tree, "expr", "type",
-				       NULL, MXML_DESCEND)) {
-		e = nftnl_mxml_expr_parse(node, err, set_list);
-		if (e == NULL)
-			return -1;
-
-		nftnl_rule_add_expr(r, e);
-	}
-
-	return 0;
-}
-#endif
-
-static int nftnl_rule_xml_parse(struct nftnl_rule *r, const void *xml,
-			      struct nftnl_parse_err *err,
-			      enum nftnl_parse_input input,
-			      struct nftnl_set_list *set_list)
-{
-#ifdef XML_PARSING
-	int ret;
-	mxml_node_t *tree = nftnl_mxml_build_tree(xml, "rule", err, input);
-	if (tree == NULL)
-		return -1;
-
-	ret = nftnl_mxml_rule_parse(tree, r, err, set_list);
-	mxmlDelete(tree);
-	return ret;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_rule_do_parse(struct nftnl_rule *r, enum nftnl_parse_type type,
 			     const void *data, struct nftnl_parse_err *err,
 			     enum nftnl_parse_input input)
@@ -703,12 +617,10 @@ static int nftnl_rule_do_parse(struct nftnl_rule *r, enum nftnl_parse_type type,
 	struct nftnl_parse_err perr = {};
 
 	switch (type) {
-	case NFTNL_PARSE_XML:
-		ret = nftnl_rule_xml_parse(r, data, &perr, input, NULL);
-		break;
 	case NFTNL_PARSE_JSON:
 		ret = nftnl_rule_json_parse(r, data, &perr, input, NULL);
 		break;
+	case NFTNL_PARSE_XML:
 	default:
 		ret = -1;
 		errno = EOPNOTSUPP;
@@ -812,73 +724,6 @@ static int nftnl_rule_snprintf_json(char *buf, size_t size,
 	return offset;
 }
 
-static int nftnl_rule_snprintf_xml(char *buf, size_t size,
-				   const struct nftnl_rule *r,
-				   uint32_t type, uint32_t flags)
-{
-	int ret, len = size, offset = 0;
-	struct nftnl_expr *expr;
-
-	ret = snprintf(buf, len, "<rule>");
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-	if (r->flags & (1 << NFTNL_RULE_FAMILY)) {
-		ret = snprintf(buf+offset, len, "<family>%s</family>",
-			       nftnl_family2str(r->family));
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-
-	if (r->flags & (1 << NFTNL_RULE_TABLE)) {
-		ret = snprintf(buf+offset, len, "<table>%s</table>",
-			       r->table);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-
-	if (r->flags & (1 << NFTNL_RULE_CHAIN)) {
-		ret = snprintf(buf+offset, len, "<chain>%s</chain>",
-			       r->chain);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-	if (r->flags & (1 << NFTNL_RULE_HANDLE)) {
-		ret = snprintf(buf+offset, len, "<handle>%llu</handle>",
-			       (unsigned long long)r->handle);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-
-	if (r->compat.flags != 0 || r->compat.proto != 0) {
-		ret = snprintf(buf+offset, len,
-			       "<compat_flags>%u</compat_flags>"
-			       "<compat_proto>%u</compat_proto>",
-			       r->compat.flags, r->compat.proto);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-
-	if (r->flags & (1 << NFTNL_RULE_POSITION)) {
-		ret = snprintf(buf+offset, len,
-			       "<position>%"PRIu64"</position>",
-			       r->position);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-
-	list_for_each_entry(expr, &r->expr_list, head) {
-		ret = snprintf(buf+offset, len,
-				"<expr type=\"%s\">", expr->ops->name);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-		ret = nftnl_expr_snprintf(buf+offset, len, expr,
-					     type, flags);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-		ret = snprintf(buf+offset, len, "</expr>");
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-	}
-	ret = snprintf(buf+offset, len, "</rule>");
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-	return offset;
-}
-
 static int nftnl_rule_snprintf_default(char *buf, size_t size,
 				       const struct nftnl_rule *r,
 				       uint32_t type, uint32_t flags)
@@ -967,14 +812,11 @@ static int nftnl_rule_cmd_snprintf(char *buf, size_t size,
 		ret = nftnl_rule_snprintf_default(buf+offset, len, r, type,
 						inner_flags);
 		break;
-	case NFTNL_OUTPUT_XML:
-		ret = nftnl_rule_snprintf_xml(buf+offset, len, r, type,
-					    inner_flags);
-		break;
 	case NFTNL_OUTPUT_JSON:
 		ret = nftnl_rule_snprintf_json(buf+offset, len, r, type,
 					     inner_flags);
 		break;
+	case NFTNL_OUTPUT_XML:
 	default:
 		return -1;
 	}
diff --git a/src/ruleset.c b/src/ruleset.c
index 2f3c110..233ff0e 100644
--- a/src/ruleset.c
+++ b/src/ruleset.c
@@ -45,10 +45,7 @@ struct nftnl_parse_ctx {
 	void *data;
 
 	/* These fields below are not exposed to the user */
-	union {
-		json_t			*json;
-		mxml_node_t		*xml;
-	};
+	json_t *json;
 
 	uint32_t format;
 	uint32_t set_id;
@@ -215,7 +212,7 @@ uint32_t nftnl_ruleset_ctx_get_u32(const struct nftnl_parse_ctx *ctx, uint16_t a
 }
 EXPORT_SYMBOL_ALIAS(nftnl_ruleset_ctx_get_u32, nft_ruleset_ctx_get_u32);
 
-#if defined(JSON_PARSING) || defined(XML_PARSING)
+#if defined(JSON_PARSING)
 static void nftnl_ruleset_ctx_set(struct nftnl_parse_ctx *ctx, uint16_t attr,
 				void *data)
 {
@@ -268,11 +265,6 @@ static int nftnl_ruleset_parse_tables(struct nftnl_parse_ctx *ctx,
 #endif
 		break;
 	case NFTNL_OUTPUT_XML:
-#ifdef XML_PARSING
-		if (nftnl_mxml_table_parse(ctx->xml, table, err) < 0)
-			goto err;
-#endif
-		break;
 	default:
 		errno = EOPNOTSUPP;
 		goto err;
@@ -306,11 +298,6 @@ static int nftnl_ruleset_parse_chains(struct nftnl_parse_ctx *ctx,
 #endif
 		break;
 	case NFTNL_OUTPUT_XML:
-#ifdef XML_PARSING
-		if (nftnl_mxml_chain_parse(ctx->xml, chain, err) < 0)
-			goto err;
-#endif
-		break;
 	default:
 		errno = EOPNOTSUPP;
 		goto err;
@@ -368,11 +355,6 @@ static int nftnl_ruleset_parse_set_elems(struct nftnl_parse_ctx *ctx,
 #endif
 		break;
 	case NFTNL_OUTPUT_XML:
-#ifdef XML_PARSING
-		if (nftnl_mxml_set_parse(ctx->xml, set, err) < 0)
-			goto err;
-#endif
-		break;
 	default:
 		errno = EOPNOTSUPP;
 		goto err;
@@ -404,11 +386,6 @@ static int nftnl_ruleset_parse_sets(struct nftnl_parse_ctx *ctx,
 #endif
 		break;
 	case NFTNL_OUTPUT_XML:
-#ifdef XML_PARSING
-		if (nftnl_mxml_set_parse(ctx->xml, set, err) < 0)
-			goto err;
-#endif
-		break;
 	default:
 		errno = EOPNOTSUPP;
 		goto err;
@@ -441,11 +418,6 @@ static int nftnl_ruleset_parse_rules(struct nftnl_parse_ctx *ctx,
 #endif
 		break;
 	case NFTNL_OUTPUT_XML:
-#ifdef XML_PARSING
-		if (nftnl_mxml_rule_parse(ctx->xml, rule, err, ctx->set_list) < 0)
-			goto err;
-#endif
-		break;
 	default:
 		errno = EOPNOTSUPP;
 		goto err;
@@ -600,126 +572,6 @@ err1:
 #endif
 }
 
-#ifdef XML_PARSING
-static int nftnl_ruleset_xml_parse_ruleset(struct nftnl_parse_ctx *ctx,
-					 struct nftnl_parse_err *err)
-{
-	const char *node_type;
-	mxml_node_t *node, *array = ctx->xml;
-	int len = 0, ret;
-
-	for (node = mxmlFindElement(array, array, NULL, NULL, NULL,
-				    MXML_DESCEND_FIRST);
-	     node != NULL;
-	     node = mxmlFindElement(node, array, NULL, NULL, NULL,
-				    MXML_NO_DESCEND)) {
-		len++;
-		node_type = node->value.opaque;
-		ctx->xml = node;
-		if (strcmp(node_type, "table") == 0)
-			ret = nftnl_ruleset_parse_tables(ctx, err);
-		else if (strcmp(node_type, "chain") == 0)
-			ret = nftnl_ruleset_parse_chains(ctx, err);
-		else if (strcmp(node_type, "set") == 0)
-			ret = nftnl_ruleset_parse_sets(ctx, err);
-		else if (strcmp(node_type, "rule") == 0)
-			ret = nftnl_ruleset_parse_rules(ctx, err);
-		else if (strcmp(node_type, "element") == 0)
-			ret = nftnl_ruleset_parse_set_elems(ctx, err);
-		else
-			return -1;
-
-		if (ret < 0)
-			return ret;
-	}
-
-	if (len == 0 && ctx->cmd == NFTNL_CMD_FLUSH) {
-		nftnl_ruleset_ctx_set_u32(ctx, NFTNL_RULESET_CTX_TYPE,
-					NFTNL_RULESET_RULESET);
-		if (ctx->cb(ctx) < 0)
-			return -1;
-	}
-
-	return 0;
-}
-
-static int nftnl_ruleset_xml_parse_cmd(const char *cmd, struct nftnl_parse_err *err,
-				     struct nftnl_parse_ctx *ctx)
-{
-	uint32_t cmdnum;
-	mxml_node_t *nodecmd;
-
-	cmdnum = nftnl_str2cmd(cmd);
-	if (cmdnum == NFTNL_CMD_UNSPEC) {
-		err->error = NFTNL_PARSE_EMISSINGNODE;
-		err->node_name = strdup(cmd);
-		return -1;
-	}
-
-	nodecmd = mxmlFindElement(ctx->xml, ctx->xml, cmd, NULL, NULL,
-				  MXML_DESCEND_FIRST);
-
-	ctx->xml = nodecmd;
-	nftnl_ruleset_ctx_set_u32(ctx, NFTNL_RULESET_CTX_CMD, cmdnum);
-
-	if (nftnl_ruleset_xml_parse_ruleset(ctx, err) != 0)
-		goto err;
-
-	return 0;
-err:
-	return -1;
-}
-#endif
-
-static int nftnl_ruleset_xml_parse(const void *xml, struct nftnl_parse_err *err,
-				 enum nftnl_parse_input input,
-				 enum nftnl_parse_type type, void *arg,
-				 int (*cb)(const struct nftnl_parse_ctx *ctx))
-{
-#ifdef XML_PARSING
-	mxml_node_t *tree, *nodecmd = NULL;
-	char *cmd;
-	struct nftnl_parse_ctx ctx;
-
-	ctx.cb = cb;
-	ctx.format = type;
-	ctx.flags = 0;
-
-	ctx.set_list = nftnl_set_list_alloc();
-	if (ctx.set_list == NULL)
-		return -1;
-
-	if (arg != NULL)
-		nftnl_ruleset_ctx_set(&ctx, NFTNL_RULESET_CTX_DATA, arg);
-
-	tree = nftnl_mxml_build_tree(xml, "nftables", err, input);
-	if (tree == NULL)
-		goto err1;
-
-	ctx.xml = tree;
-
-	nodecmd = mxmlWalkNext(tree, tree, MXML_DESCEND_FIRST);
-	while (nodecmd != NULL) {
-		cmd = nodecmd->value.opaque;
-		if (nftnl_ruleset_xml_parse_cmd(cmd, err, &ctx) < 0)
-			goto err2;
-		nodecmd = mxmlWalkNext(tree, tree, MXML_NO_DESCEND);
-	}
-
-	nftnl_set_list_free(ctx.set_list);
-	mxmlDelete(tree);
-	return 0;
-err2:
-	mxmlDelete(tree);
-err1:
-	nftnl_set_list_free(ctx.set_list);
-	return -1;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int
 nftnl_ruleset_do_parse(enum nftnl_parse_type type, const void *data,
 		     struct nftnl_parse_err *err, enum nftnl_parse_input input,
@@ -728,12 +580,10 @@ nftnl_ruleset_do_parse(enum nftnl_parse_type type, const void *data,
 	int ret;
 
 	switch (type) {
-	case NFTNL_PARSE_XML:
-		ret = nftnl_ruleset_xml_parse(data, err, input, type, arg, cb);
-		break;
 	case NFTNL_PARSE_JSON:
 		ret = nftnl_ruleset_json_parse(data, err, input, type, arg, cb);
 		break;
+	case NFTNL_PARSE_XML:
 	default:
 		ret = -1;
 		errno = EOPNOTSUPP;
@@ -838,10 +688,9 @@ EXPORT_SYMBOL_ALIAS(nftnl_ruleset_parse_file, nft_ruleset_parse_file);
 static const char *nftnl_ruleset_o_opentag(uint32_t type)
 {
 	switch (type) {
-	case NFTNL_OUTPUT_XML:
-		return "<nftables>";
 	case NFTNL_OUTPUT_JSON:
 		return "{\"nftables\":[";
+	case NFTNL_OUTPUT_XML:
 	default:
 		return "";
 	}
@@ -865,10 +714,9 @@ static const char *nftnl_ruleset_o_separator(void *obj, uint32_t type)
 static const char *nftnl_ruleset_o_closetag(uint32_t type)
 {
 	switch (type) {
-	case NFTNL_OUTPUT_XML:
-		return "</nftables>";
 	case NFTNL_OUTPUT_JSON:
 		return "]}";
+	case NFTNL_OUTPUT_XML:
 	default:
 		return "";
 	}
@@ -1071,9 +919,9 @@ static int nftnl_ruleset_cmd_snprintf(char *buf, size_t size,
 {
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
-	case NFTNL_OUTPUT_XML:
 	case NFTNL_OUTPUT_JSON:
 		return nftnl_ruleset_do_snprintf(buf, size, r, cmd, type, flags);
+	case NFTNL_OUTPUT_XML:
 	default:
 		errno = EOPNOTSUPP;
 		return -1;
@@ -1085,11 +933,11 @@ int nftnl_ruleset_snprintf(char *buf, size_t size, const struct nftnl_ruleset *r
 {
 	switch (type) {
 	case NFTNL_OUTPUT_DEFAULT:
-	case NFTNL_OUTPUT_XML:
 	case NFTNL_OUTPUT_JSON:
 		return nftnl_ruleset_cmd_snprintf(buf, size, r,
 						nftnl_flag2cmd(flags), type,
 						flags);
+	case NFTNL_OUTPUT_XML:
 	default:
 		errno = EOPNOTSUPP;
 		return -1;
diff --git a/src/set.c b/src/set.c
index 4581e3f..a42b713 100644
--- a/src/set.c
+++ b/src/set.c
@@ -673,109 +673,6 @@ static int nftnl_set_json_parse(struct nftnl_set *s, const void *json,
 #endif
 }
 
-#ifdef XML_PARSING
-int nftnl_mxml_set_parse(mxml_node_t *tree, struct nftnl_set *s,
-		       struct nftnl_parse_err *err)
-{
-	mxml_node_t *node = NULL;
-	struct nftnl_set_elem *elem;
-	const char *name, *table;
-	int family;
-	uint32_t set_flags, key_type, key_len;
-	uint32_t data_type, data_len, policy, size;
-
-	name = nftnl_mxml_str_parse(tree, "name", MXML_DESCEND_FIRST,
-				  NFTNL_XML_MAND, err);
-	if (name == NULL)
-		return -1;
-	nftnl_set_set_str(s, NFTNL_SET_NAME, name);
-
-	table = nftnl_mxml_str_parse(tree, "table", MXML_DESCEND_FIRST,
-				   NFTNL_XML_MAND, err);
-	if (table == NULL)
-		return -1;
-	nftnl_set_set_str(s, NFTNL_SET_TABLE, table);
-
-	family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST,
-				       NFTNL_XML_MAND, err);
-	if (family >= 0)
-		nftnl_set_set_u32(s, NFTNL_SET_FAMILY, family);
-
-	if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND_FIRST, BASE_DEC,
-			       &set_flags, NFTNL_TYPE_U32, NFTNL_XML_MAND,
-			       err) == 0)
-		nftnl_set_set_u32(s, NFTNL_SET_FLAGS, set_flags);
-
-	if (nftnl_mxml_num_parse(tree, "key_type", MXML_DESCEND_FIRST, BASE_DEC,
-			       &key_type, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
-		nftnl_set_set_u32(s, NFTNL_SET_KEY_TYPE, key_type);
-
-	if (nftnl_mxml_num_parse(tree, "key_len", MXML_DESCEND_FIRST, BASE_DEC,
-			       &key_len, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) < 0)
-		return -1;
-	nftnl_set_set_u32(s, NFTNL_SET_KEY_LEN, key_len);
-
-	if (nftnl_mxml_num_parse(tree, "data_type", MXML_DESCEND_FIRST, BASE_DEC,
-			       &data_type, NFTNL_TYPE_U32,
-			       NFTNL_XML_OPT, err) == 0) {
-		nftnl_set_set_u32(s, NFTNL_SET_DATA_TYPE, data_type);
-
-		if (nftnl_mxml_num_parse(tree, "data_len", MXML_DESCEND_FIRST,
-				       BASE_DEC, &data_len, NFTNL_TYPE_U32,
-				       NFTNL_XML_MAND, err) == 0)
-			nftnl_set_set_u32(s, NFTNL_SET_DATA_LEN, data_len);
-
-	}
-
-	if (nftnl_mxml_num_parse(tree, "policy", MXML_DESCEND_FIRST,
-			       BASE_DEC, &policy, NFTNL_TYPE_U32,
-			       NFTNL_XML_OPT, err) == 0)
-		nftnl_set_set_u32(s, NFTNL_SET_POLICY, policy);
-
-	if (nftnl_mxml_num_parse(tree, "desc_size", MXML_DESCEND_FIRST,
-			       BASE_DEC, &size, NFTNL_TYPE_U32,
-			       NFTNL_XML_OPT, err) == 0)
-		nftnl_set_set_u32(s, NFTNL_SET_DESC_SIZE, policy);
-
-	for (node = mxmlFindElement(tree, tree, "set_elem", NULL,
-				    NULL, MXML_DESCEND);
-		node != NULL;
-		node = mxmlFindElement(node, tree, "set_elem", NULL,
-				       NULL, MXML_DESCEND)) {
-
-		elem = nftnl_set_elem_alloc();
-		if (elem == NULL)
-			return -1;
-
-		if (nftnl_mxml_set_elem_parse(node, elem, err) < 0)
-			return -1;
-
-		list_add_tail(&elem->head, &s->element_list);
-	}
-
-	return 0;
-}
-#endif
-
-static int nftnl_set_xml_parse(struct nftnl_set *s, const void *xml,
-			     struct nftnl_parse_err *err,
-			     enum nftnl_parse_input input)
-{
-#ifdef XML_PARSING
-	int ret;
-	mxml_node_t *tree = nftnl_mxml_build_tree(xml, "set", err, input);
-	if (tree == NULL)
-		return -1;
-
-	ret = nftnl_mxml_set_parse(tree, s, err);
-	mxmlDelete(tree);
-	return ret;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_set_do_parse(struct nftnl_set *s, enum nftnl_parse_type type,
 			    const void *data, struct nftnl_parse_err *err,
 			    enum nftnl_parse_input input)
@@ -784,12 +681,10 @@ static int nftnl_set_do_parse(struct nftnl_set *s, enum nftnl_parse_type type,
 	struct nftnl_parse_err perr = {};
 
 	switch (type) {
-	case NFTNL_PARSE_XML:
-		ret = nftnl_set_xml_parse(s, data, &perr, input);
-		break;
 	case NFTNL_PARSE_JSON:
 		ret = nftnl_set_json_parse(s, data, &perr, input);
 		break;
+	case NFTNL_PARSE_XML:
 	default:
 		ret = -1;
 		errno = EOPNOTSUPP;
@@ -959,87 +854,6 @@ static int nftnl_set_snprintf_default(char *buf, size_t size,
 	return offset;
 }
 
-static int nftnl_set_snprintf_xml(char *buf, size_t size,
-				  const struct nftnl_set *s, uint32_t flags)
-{
-	int ret;
-	int len = size, offset = 0;
-	struct nftnl_set_elem *elem;
-
-	ret = snprintf(buf, len, "<set>");
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-	if (s->flags & (1 << NFTNL_SET_FAMILY)) {
-		ret = snprintf(buf + offset, len, "<family>%s</family>",
-			       nftnl_family2str(s->family));
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-
-	if (s->flags & (1 << NFTNL_SET_TABLE)) {
-		ret = snprintf(buf + offset, len, "<table>%s</table>",
-			       s->table);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-
-	if (s->flags & (1 << NFTNL_SET_NAME)) {
-		ret = snprintf(buf + offset, len, "<name>%s</name>",
-			       s->name);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-
-	if (s->flags & (1 << NFTNL_SET_FLAGS)) {
-		ret = snprintf(buf + offset, len, "<flags>%u</flags>",
-			       s->set_flags);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-	if (s->flags & (1 << NFTNL_SET_KEY_TYPE)) {
-		ret = snprintf(buf + offset, len, "<key_type>%u</key_type>",
-			       s->key_type);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-	if (s->flags & (1 << NFTNL_SET_KEY_LEN)) {
-		ret = snprintf(buf + offset, len, "<key_len>%u</key_len>",
-			       s->key_len);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-
-	if (s->flags & (1 << NFTNL_SET_DATA_TYPE)) {
-		ret = snprintf(buf + offset, len, "<data_type>%u</data_type>",
-			       s->data_type);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-	if (s->flags & (1 << NFTNL_SET_DATA_LEN)) {
-		ret = snprintf(buf + offset, len, "<data_len>%u</data_len>",
-			       s->data_len);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-
-	if (s->flags & (1 << NFTNL_SET_POLICY)) {
-		ret = snprintf(buf + offset, len, "<policy>%u</policy>",
-			       s->policy);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-
-	if (s->flags & (1 << NFTNL_SET_DESC_SIZE)) {
-		ret = snprintf(buf + offset, len, "<desc_size>%u</desc_size>",
-			       s->desc.size);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-
-	if (!list_empty(&s->element_list)) {
-		list_for_each_entry(elem, &s->element_list, head) {
-			ret = nftnl_set_elem_snprintf(buf + offset, len, elem,
-						    NFTNL_OUTPUT_XML, flags);
-			SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-		}
-	}
-
-	ret = snprintf(buf + offset, len, "</set>");
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-	return offset;
-}
-
 static int nftnl_set_cmd_snprintf(char *buf, size_t size,
 				  const struct nftnl_set *s, uint32_t cmd,
 				  uint32_t type, uint32_t flags)
@@ -1047,6 +861,9 @@ static int nftnl_set_cmd_snprintf(char *buf, size_t size,
 	int ret, len = size, offset = 0;
 	uint32_t inner_flags = flags;
 
+	if (type == NFTNL_OUTPUT_XML)
+		return 0;
+
 	/* prevent set_elems to print as events */
 	inner_flags &= ~NFTNL_OF_EVENT_ANY;
 
@@ -1058,9 +875,6 @@ static int nftnl_set_cmd_snprintf(char *buf, size_t size,
 		ret = nftnl_set_snprintf_default(buf+offset, len, s, type,
 					       inner_flags);
 		break;
-	case NFTNL_OUTPUT_XML:
-		ret = nftnl_set_snprintf_xml(buf+offset, len, s, inner_flags);
-		break;
 	case NFTNL_OUTPUT_JSON:
 		ret = nftnl_set_snprintf_json(buf+offset, len, s, type,
 					    inner_flags);
diff --git a/src/set_elem.c b/src/set_elem.c
index db63a05..46fb7c6 100644
--- a/src/set_elem.c
+++ b/src/set_elem.c
@@ -518,62 +518,6 @@ int nftnl_set_elems_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_set *s)
 }
 EXPORT_SYMBOL_ALIAS(nftnl_set_elems_nlmsg_parse, nft_set_elems_nlmsg_parse);
 
-#ifdef XML_PARSING
-int nftnl_mxml_set_elem_parse(mxml_node_t *tree, struct nftnl_set_elem *e,
-			    struct nftnl_parse_err *err)
-{
-	int set_elem_data;
-	uint32_t set_elem_flags;
-
-	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_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_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_DATA);
-		break;
-	case DATA_VERDICT:
-		e->flags |= (1 << NFTNL_SET_ELEM_VERDICT);
-		if (e->data.chain != NULL)
-			e->flags |= (1 << NFTNL_SET_ELEM_CHAIN);
-
-		break;
-	}
-
-	return 0;
-}
-#endif
-
-static int nftnl_set_elem_xml_parse(struct nftnl_set_elem *e, const void *xml,
-				  struct nftnl_parse_err *err,
-				  enum nftnl_parse_input input)
-{
-#ifdef XML_PARSING
-	mxml_node_t *tree;
-	int ret;
-
-	tree = nftnl_mxml_build_tree(xml, "set_elem", err, input);
-	if (tree == NULL)
-		return -1;
-
-	ret = nftnl_mxml_set_elem_parse(tree, e, err);
-	mxmlDelete(tree);
-	return ret;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 static int nftnl_set_elem_json_parse(struct nftnl_set_elem *e, const void *json,
 				   struct nftnl_parse_err *err,
 				   enum nftnl_parse_input input)
@@ -601,12 +545,10 @@ nftnl_set_elem_do_parse(struct nftnl_set_elem *e, enum nftnl_parse_type type,
 	int ret;
 
 	switch (type) {
-	case NFTNL_PARSE_XML:
-		ret = nftnl_set_elem_xml_parse(e, data, err, input);
-		break;
 	case NFTNL_PARSE_JSON:
 		ret = nftnl_set_elem_json_parse(e, data, err, input);
 		break;
+	case NFTNL_PARSE_XML:
 	default:
 		errno = EOPNOTSUPP;
 		ret = -1;
@@ -715,58 +657,6 @@ static int nftnl_set_elem_snprintf_default(char *buf, size_t size,
 	return offset;
 }
 
-static int nftnl_set_elem_snprintf_xml(char *buf, size_t size,
-				       const struct nftnl_set_elem *e,
-				       uint32_t flags)
-{
-	int ret, len = size, offset = 0, type = DATA_NONE;
-
-	ret = snprintf(buf, size, "<set_elem>");
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-	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_KEY)) {
-		ret = snprintf(buf + offset, len, "<key>");
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-		ret = nftnl_data_reg_snprintf(buf + offset, len, &e->key,
-					    NFTNL_OUTPUT_XML, flags, DATA_VALUE);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-		ret = snprintf(buf + offset, len, "</key>");
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-
-	if (e->flags & (1 << NFTNL_SET_ELEM_DATA))
-		type = DATA_VALUE;
-	else if (e->flags & (1 << NFTNL_SET_ELEM_CHAIN))
-		type = DATA_CHAIN;
-	else if (e->flags & (1 << NFTNL_SET_ELEM_VERDICT))
-		type = DATA_VERDICT;
-
-	if (type != DATA_NONE) {
-		ret = snprintf(buf + offset, len, "<data>");
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-		ret = nftnl_data_reg_snprintf(buf + offset, len, &e->data,
-					    NFTNL_OUTPUT_XML, flags, type);
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-		ret = snprintf(buf + offset, len, "</data>");
-		SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-	}
-
-	ret = snprintf(buf + offset, len, "</set_elem>");
-	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
-
-	return offset;
-}
-
 static int nftnl_set_elem_cmd_snprintf(char *buf, size_t size,
 				       const struct nftnl_set_elem *e,
 				       uint32_t cmd, uint32_t type,
@@ -774,6 +664,9 @@ static int nftnl_set_elem_cmd_snprintf(char *buf, size_t size,
 {
 	int ret, len = size, offset = 0;
 
+	if (type == NFTNL_OUTPUT_XML)
+		return 0;
+
 	ret = nftnl_cmd_header_snprintf(buf + offset, len, cmd, type, flags);
 	SNPRINTF_BUFFER_SIZE(ret, size, len, offset);
 
@@ -781,9 +674,6 @@ static int nftnl_set_elem_cmd_snprintf(char *buf, size_t size,
 	case NFTNL_OUTPUT_DEFAULT:
 		ret = nftnl_set_elem_snprintf_default(buf+offset, len, e);
 		break;
-	case NFTNL_OUTPUT_XML:
-		ret = nftnl_set_elem_snprintf_xml(buf+offset, len, e, flags);
-		break;
 	case NFTNL_OUTPUT_JSON:
 		ret = nftnl_set_elem_snprintf_json(buf+offset, len, e, flags);
 		break;
diff --git a/src/table.c b/src/table.c
index 845fd68..4286d51 100644
--- a/src/table.c
+++ b/src/table.c
@@ -251,55 +251,6 @@ int nftnl_table_nlmsg_parse(const struct nlmsghdr *nlh, struct nftnl_table *t)
 }
 EXPORT_SYMBOL_ALIAS(nftnl_table_nlmsg_parse, nft_table_nlmsg_parse);
 
-#ifdef XML_PARSING
-int nftnl_mxml_table_parse(mxml_node_t *tree, struct nftnl_table *t,
-			 struct nftnl_parse_err *err)
-{
-	const char *name;
-	int family;
-	uint32_t flags, use;
-
-	name = nftnl_mxml_str_parse(tree, "name", MXML_DESCEND_FIRST,
-				  NFTNL_XML_MAND, err);
-	if (name != NULL)
-		nftnl_table_set_str(t, NFTNL_TABLE_NAME, name);
-
-	family = nftnl_mxml_family_parse(tree, "family", MXML_DESCEND_FIRST,
-				       NFTNL_XML_MAND, err);
-	if (family >= 0)
-		nftnl_table_set_u32(t, NFTNL_TABLE_FAMILY, family);
-
-	if (nftnl_mxml_num_parse(tree, "flags", MXML_DESCEND, BASE_DEC,
-			       &flags, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
-		nftnl_table_set_u32(t, NFTNL_TABLE_FLAGS, flags);
-
-	if (nftnl_mxml_num_parse(tree, "use", MXML_DESCEND, BASE_DEC,
-			       &use, NFTNL_TYPE_U32, NFTNL_XML_MAND, err) == 0)
-		nftnl_table_set_u32(t, NFTNL_TABLE_USE, use);
-
-	return 0;
-}
-#endif
-
-static int nftnl_table_xml_parse(struct nftnl_table *t, const void *data,
-			       struct nftnl_parse_err *err,
-			       enum nftnl_parse_input input)
-{
-#ifdef XML_PARSING
-	int ret;
-	mxml_node_t *tree = nftnl_mxml_build_tree(data, "table", err, input);
-	if (tree == NULL)
-		return -1;
-
-	ret = nftnl_mxml_table_parse(tree, t, err);
-	mxmlDelete(tree);
-	return ret;
-#else
-	errno = EOPNOTSUPP;
-	return -1;
-#endif
-}
-
 #ifdef JSON_PARSING
 int nftnl_jansson_parse_table(struct nftnl_table *t, json_t *tree,
 			    struct nftnl_parse_err *err)
@@ -363,12 +314,10 @@ static int nftnl_table_do_parse(struct nftnl_table *t, enum nftnl_parse_type typ
 	struct nftnl_parse_err perr = {};
 
 	switch (type) {
-	case NFTNL_PARSE_XML:
-		ret = nftnl_table_xml_parse(t, data, &perr, input);
-		break;
 	case NFTNL_PARSE_JSON:
 		ret = nftnl_table_json_parse(t, data, &perr, input);
 		break;
+	case NFTNL_PARSE_XML:
 	default:
 		ret = -1;
 		errno = EOPNOTSUPP;