lib/idiag/idiag_req_obj.c

/* SPDX-License-Identifier: LGPL-2.1-only */
/*
 * lib/idiag/idiagnl_req_obj.c Inet Diag Request Object
 *
 *	This library is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU Lesser General Public
 *	License as published by the Free Software Foundation version 2.1
 *	of the License.
 *
 * Copyright (c) 2013 Sassano Systems LLC <joe@sassanosystems.com>
 */

#include <netlink-private/netlink.h>
#include <netlink/idiag/req.h>
#include <linux/inet_diag.h>

/**
 * @ingroup idiag
 * @defgroup idiagnl_req Inet Diag Requests
 *
 * @details
 * @idiagnl_doc{idiagnl_req, Inet Diag Request Documentation}
 * @{
 */
struct idiagnl_req *idiagnl_req_alloc(void)
{
	return (struct idiagnl_req *) nl_object_alloc(&idiagnl_req_obj_ops);
}

void idiagnl_req_get(struct idiagnl_req *req)
{
	nl_object_get((struct nl_object *) req);
}

void idiagnl_req_put(struct idiagnl_req *req)
{
	nl_object_put((struct nl_object *) req);
}

/**
 * @name Attributes
 * @{
 */

uint8_t idiagnl_req_get_family(const struct idiagnl_req *req)
{
	return req->idiag_family;
}

void idiagnl_req_set_family(struct idiagnl_req *req, uint8_t family)
{
	req->idiag_family = family;
}

uint8_t idiagnl_req_get_ext(const struct idiagnl_req *req)
{
	return req->idiag_ext;
}

void idiagnl_req_set_ext(struct idiagnl_req *req, uint8_t ext)
{
	req->idiag_ext = ext;
}

uint32_t idiagnl_req_get_ifindex(const struct idiagnl_req *req)
{
	return req->idiag_ifindex;
}

void idiagnl_req_set_ifindex(struct idiagnl_req *req, uint32_t ifindex)
{
	req->idiag_ifindex = ifindex;
}

uint32_t idiagnl_req_get_states(const struct idiagnl_req *req)
{
	return req->idiag_states;
}

void idiagnl_req_set_states(struct idiagnl_req *req, uint32_t states)
{
	req->idiag_states = states;
}

uint32_t idiagnl_req_get_dbs(const struct idiagnl_req *req)
{
	return req->idiag_dbs;
}

void idiagnl_req_set_dbs(struct idiagnl_req *req, uint32_t dbs)
{
	req->idiag_dbs = dbs;
}

struct nl_addr *idiagnl_req_get_src(const struct idiagnl_req *req)
{
	return req->idiag_src;
}

int idiagnl_req_set_src(struct idiagnl_req *req, struct nl_addr *addr)
{
	if (req->idiag_src)
		nl_addr_put(req->idiag_src);

	nl_addr_get(addr);
	req->idiag_src = addr;

	return 0;
}

struct nl_addr *idiagnl_req_get_dst(const struct idiagnl_req *req)
{
	return req->idiag_dst;
}

int idiagnl_req_set_dst(struct idiagnl_req *req, struct nl_addr *addr)
{
	if (req->idiag_dst)
		nl_addr_put(req->idiag_dst);

	nl_addr_get(addr);
	req->idiag_dst = addr;

	return 0;
}

/** @} */

static void idiag_req_dump_line(struct nl_object *a, struct nl_dump_params *p)
{
	struct idiagnl_req *req = (struct idiagnl_req *) a;
	char buf[64] = { 0 };

	nl_dump_line(p, "%s ", nl_af2str(req->idiag_family, buf, sizeof(buf)));
	nl_dump(p, "src %s ", nl_addr2str(req->idiag_src, buf, sizeof(buf)));
	nl_dump(p, "dst %s ", nl_addr2str(req->idiag_dst, buf, sizeof(buf)));
	nl_dump(p, "iif %d ", req->idiag_ifindex);
	nl_dump(p, "\n");
}

static void idiag_req_dump_details(struct nl_object *a, struct nl_dump_params *p)
{
	struct idiagnl_req *req = (struct idiagnl_req *) a;
	char buf[64];

	nl_dump_line(p, "    ");
	nl_dump(p, "%s ", nl_af2str(req->idiag_family, buf, sizeof(buf)));
	nl_dump(p, "exts %s ",
			idiagnl_exts2str(req->idiag_ext, buf, sizeof(buf)));
	nl_dump(p, "src %s ", nl_addr2str(req->idiag_src, buf, sizeof(buf)));
	nl_dump(p, "dst %s ", nl_addr2str(req->idiag_dst, buf, sizeof(buf)));
	nl_dump(p, "iif %d ", req->idiag_ifindex);
	nl_dump(p, "states %s ", idiagnl_state2str(req->idiag_states, buf,
				sizeof(buf)));
	nl_dump(p, "dbs %d", req->idiag_dbs);
	nl_dump(p, "\n");
}

static void idiag_req_dump_stats(struct nl_object *obj, struct nl_dump_params *p)
{
	idiag_req_dump_details(obj, p);
}

static void idiagnl_req_free(struct nl_object *a)
{
	struct idiagnl_req *req = (struct idiagnl_req *) a;
	if (a == NULL)
		return;

	nl_addr_put(req->idiag_src);
	nl_addr_put(req->idiag_dst);
}

static int idiagnl_req_clone(struct nl_object *_dst, struct nl_object *_src)
{
	struct idiagnl_req *dst = (struct idiagnl_req *) _dst;
	struct idiagnl_req *src = (struct idiagnl_req *) _src;

	if (src->idiag_src)
		if (!(dst->idiag_src = nl_addr_clone(src->idiag_src)))
			return -NLE_NOMEM;

	if (src->idiag_dst)
		if (!(dst->idiag_dst = nl_addr_clone(src->idiag_dst)))
			return -NLE_NOMEM;

	return 0;
}

int idiagnl_req_parse(struct nlmsghdr *nlh, struct idiagnl_req **result)
{
	struct idiagnl_req *req = NULL;
	struct inet_diag_req *raw_req = NULL;
	struct nl_addr *src = NULL, *dst = NULL;
	int err = 0;

	req = idiagnl_req_alloc();
	if (!req)
		goto errout_nomem;

	raw_req = nlmsg_data(nlh);
	req->idiag_family = raw_req->idiag_family;
	req->idiag_ext = raw_req->idiag_ext;
	req->idiag_states = raw_req->idiag_states;
	req->idiag_dbs = raw_req->idiag_dbs;
	req->idiag_ifindex = raw_req->id.idiag_if;

	dst = nl_addr_build(raw_req->idiag_family, raw_req->id.idiag_dst,
			sizeof(raw_req->id.idiag_dst));
	if (!dst)
		goto errout_nomem;

	err = idiagnl_req_set_dst(req, dst);
	if (err < 0)
		goto errout;

	nl_addr_put(dst);

	src = nl_addr_build(raw_req->idiag_family, raw_req->id.idiag_src,
			sizeof(raw_req->id.idiag_src));
	if (!src)
		goto errout_nomem;

	err = idiagnl_req_set_src(req, src);
	if (err < 0)
		goto errout;

	nl_addr_put(src);

	*result = req;
	return 0;

errout:
	idiagnl_req_put(req);
	return err;

errout_nomem:
	err = -NLE_NOMEM;
	goto errout;
}

/** @cond SKIP */
struct nl_object_ops idiagnl_req_obj_ops = {
	.oo_name		  = "idiag/idiag_req",
	.oo_size		  = sizeof(struct idiagnl_req),
	.oo_free_data		  = idiagnl_req_free,
	.oo_clone		  = idiagnl_req_clone,
	.oo_dump		  = {
		[NL_DUMP_LINE]	  = idiag_req_dump_line,
		[NL_DUMP_DETAILS] = idiag_req_dump_details,
		[NL_DUMP_STATS]	  = idiag_req_dump_stats,
	},
};
/** @endcond */

/** @} */