Exemplos de nft_jansson_parse_reg em C++ (Cpp)

Exemplo n.º 1

Arquivo: bitwise.c Projeto: bazsi/libnftnl

static int
nft_rule_expr_bitwise_json_parse(struct nft_rule_expr *e, json_t *root,
				 struct nft_parse_err *err)
{
#ifdef JSON_PARSING
	struct nft_expr_bitwise *bitwise = nft_expr_data(e);
	uint32_t reg, len;

	if (nft_jansson_parse_reg(root, "sreg", NFT_TYPE_U32, &reg, err) == 0)
		nft_rule_expr_set_u32(e, NFT_EXPR_BITWISE_SREG, reg);

	if (nft_jansson_parse_reg(root, "dreg", NFT_TYPE_U32, &reg, err) == 0)
		nft_rule_expr_set_u32(e, NFT_EXPR_BITWISE_DREG, reg);

	if (nft_jansson_parse_val(root, "len", NFT_TYPE_U32, &len, err) == 0)
		nft_rule_expr_set_u32(e, NFT_EXPR_BITWISE_LEN, len);

	if (nft_jansson_data_reg_parse(root, "mask", &bitwise->mask,
				       err) == DATA_VALUE)
		e->flags |= (1 << NFT_EXPR_BITWISE_MASK);

	if (nft_jansson_data_reg_parse(root, "xor", &bitwise->xor,
				       err) == DATA_VALUE)
		e->flags |= (1 << NFT_EXPR_BITWISE_XOR);

	if (bitwise->mask.len != bitwise->xor.len)
		return -1;

	return 0;
#else
	errno = EOPNOTSUPP;
	return -1;
#endif
}

Exemplo n.º 2

Arquivo: nat.c Projeto: bazsi/libnftnl

static int nft_rule_expr_nat_json_parse(struct nft_rule_expr *e, json_t *root,
					struct nft_parse_err *err)
{
#ifdef JSON_PARSING
	const char *nat_type, *family_str;
	uint32_t reg, flags;
	int val32;

	nat_type = nft_jansson_parse_str(root, "nat_type", err);
	if (nat_type == NULL)
		return -1;

	val32 = nft_str2nat(nat_type);
	if (val32 < 0)
		return -1;

	nft_rule_expr_set_u32(e, NFT_EXPR_NAT_TYPE, val32);

	family_str = nft_jansson_parse_str(root, "family", err);
	if (family_str == NULL)
		return -1;

	val32 = nft_str2family(family_str);
	if (val32 < 0)
		return -1;

	nft_rule_expr_set_u32(e, NFT_EXPR_NAT_FAMILY, val32);

	if (nft_jansson_parse_reg(root, "sreg_addr_min", NFT_TYPE_U32,
				  &reg, err) == 0)
		nft_rule_expr_set_u32(e, NFT_EXPR_NAT_REG_ADDR_MIN, reg);

	if (nft_jansson_parse_reg(root, "sreg_addr_max", NFT_TYPE_U32,
				  &reg, err) == 0)
		nft_rule_expr_set_u32(e, NFT_EXPR_NAT_REG_ADDR_MAX, reg);

	if (nft_jansson_parse_reg(root, "sreg_proto_min", NFT_TYPE_U32,
				  &reg, err) == 0)
		nft_rule_expr_set_u32(e, NFT_EXPR_NAT_REG_PROTO_MIN, reg);

	if (nft_jansson_parse_reg(root, "sreg_proto_max", NFT_TYPE_U32,
				  &reg, err) == 0)
		nft_rule_expr_set_u32(e, NFT_EXPR_NAT_REG_PROTO_MAX, reg);

	if (nft_jansson_parse_val(root, "flags", NFT_TYPE_U32,
				  &flags, err) == 0)
		nft_rule_expr_set_u32(e, NFT_EXPR_NAT_FLAGS, flags);

	return 0;
#else
	errno = EOPNOTSUPP;
	return -1;
#endif
}

Exemplo n.º 3

Arquivo: ct.c Projeto: greearb/libnftnl-ct

static int nft_rule_expr_ct_json_parse(struct nft_rule_expr *e, json_t *root,
				       struct nft_parse_err *err)
{
#ifdef JSON_PARSING
	const char *key_str, *dir_str;
	uint32_t reg;
	uint8_t dir;
	int key;

	if (nft_jansson_parse_reg(root, "dreg", NFT_TYPE_U32, &reg, err) == 0)
		nft_rule_expr_set_u32(e, NFT_EXPR_CT_DREG, reg);

	if (nft_jansson_parse_reg(root, "sreg", NFT_TYPE_U32, &reg, err) == 0)
		nft_rule_expr_set_u32(e, NFT_EXPR_CT_SREG, reg);

	key_str = nft_jansson_parse_str(root, "key", err);
	if (key_str != NULL) {
		key = str2ctkey(key_str);
		if (key < 0)
			return -1;

		nft_rule_expr_set_u32(e, NFT_EXPR_CT_KEY, key);
	}

	dir_str = nft_jansson_parse_str(root, "dir", err);
	if (dir_str != NULL) {
		if (str2ctdir(dir_str, &dir) != 0) {
			err->node_name = "dir";
			err->error = NFT_PARSE_EBADTYPE;
			goto err;
		}
		nft_rule_expr_set_u8(e, NFT_EXPR_CT_DIR, dir);
	}

	return 0;
err:
	errno = EINVAL;
	return -1;
#else
	errno = EOPNOTSUPP;
	return -1;
#endif
}

Exemplo n.º 4

Arquivo: byteorder.c Projeto: greearb/libnftnl-ct

static int
nft_rule_expr_byteorder_json_parse(struct nft_rule_expr *e, json_t *root,
				   struct nft_parse_err *err)
{
#ifdef JSON_PARSING
	const char *op;
	uint32_t sreg, dreg, len, size;
	int ntoh;

	if (nft_jansson_parse_reg(root, "sreg", NFT_TYPE_U32, &sreg, err) == 0)
		nft_rule_expr_set_u32(e, NFT_EXPR_BYTEORDER_SREG, sreg);

	if (nft_jansson_parse_reg(root, "dreg", NFT_TYPE_U32, &dreg, err) == 0)
		nft_rule_expr_set_u32(e, NFT_EXPR_BYTEORDER_DREG, dreg);

	op = nft_jansson_parse_str(root, "op", err);
	if (op != NULL) {
		ntoh = nft_str2ntoh(op);
		if (ntoh < 0)
			return -1;

		nft_rule_expr_set_u32(e, NFT_EXPR_BYTEORDER_OP, ntoh);
	}

	if (nft_jansson_parse_val(root, "len", NFT_TYPE_U32, &len, err) == 0)
		nft_rule_expr_set_u32(e, NFT_EXPR_BYTEORDER_LEN, len);

	if (nft_jansson_parse_val(root, "size", NFT_TYPE_U32, &size, err) == 0)
		nft_rule_expr_set_u32(e, NFT_EXPR_BYTEORDER_SIZE, size);

	return 0;
#else
	errno = EOPNOTSUPP;
	return -1;
#endif
}