/*
* lib/route/act.c Action
*
* 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 Cong Wang <xiyou.wangcong@gmail.com>
*/
/**
* @ingroup tc
* @defgroup act Action
* @{
*/
#include <netlink-private/netlink.h>
#include <netlink-private/tc.h>
#include <netlink/netlink.h>
#include <netlink/utils.h>
#include <netlink-private/route/tc-api.h>
#include <netlink/route/link.h>
static struct nl_object_ops act_obj_ops;
static struct nl_cache_ops rtnl_act_ops;
int rtnl_act_append(struct rtnl_act **head, struct rtnl_act *new)
{
struct rtnl_act *p_act;
int count = 1;
if (*head == NULL) {
*head = new;
return 0;
}
p_act = *head;
while (p_act->a_next) {
++count;
p_act = p_act->a_next;
}
if (count > TCA_ACT_MAX_PRIO)
return -NLE_RANGE;
p_act->a_next = new;
return 0;
}
int rtnl_act_remove(struct rtnl_act **head, struct rtnl_act *act)
{
struct rtnl_act *a, **ap;
for (ap = head; (a = *ap) != NULL; ap = &a->a_next)
if (a == act)
break;
if (a) {
*ap = a->a_next;
a->a_next = NULL;
return 0;
}
return -NLE_OBJ_NOTFOUND;
}
static int rtnl_act_fill_one(struct nl_msg *msg, struct rtnl_act *act, int order)
{
struct rtnl_tc *tc = TC_CAST(act);
struct rtnl_tc_ops *ops;
struct nlattr *nest;
int err = -NLE_NOMEM;
nest = nla_nest_start(msg, order);
if (!nest)
goto nla_put_failure;
if (tc->ce_mask & TCA_ATTR_KIND)
NLA_PUT_STRING(msg, TCA_ACT_KIND, tc->tc_kind);
ops = rtnl_tc_get_ops(tc);
if (ops && (ops->to_msg_fill || ops->to_msg_fill_raw)) {
struct nlattr *opts;
void *data = rtnl_tc_data(tc);
if (ops->to_msg_fill) {
if (!(opts = nla_nest_start(msg, TCA_ACT_OPTIONS)))
goto nla_put_failure;
if ((err = ops->to_msg_fill(tc, data, msg)) < 0)
goto nla_put_failure;
nla_nest_end(msg, opts);
} else if ((err = ops->to_msg_fill_raw(tc, data, msg)) < 0)
goto nla_put_failure;
}
nla_nest_end(msg, nest);
return 0;
nla_put_failure:
return err;
}
int rtnl_act_fill(struct nl_msg *msg, int attrtype, struct rtnl_act *act)
{
struct rtnl_act *p_act = act;
struct nlattr *nest;
int err, order = 0;
nest = nla_nest_start(msg, attrtype);
if (!nest)
return -NLE_MSGSIZE;
while (p_act) {
err = rtnl_act_fill_one(msg, p_act, ++order);
if (err)
return err;
p_act = p_act->a_next;
}
nla_nest_end(msg, nest);
return 0;
}
static int rtnl_act_msg_build(struct rtnl_act *act, int type, int flags,
struct nl_msg **result)
{
struct nl_msg *msg;
struct tcamsg tcahdr = {
.tca_family = AF_UNSPEC,
};
int err = -NLE_MSGSIZE;
msg = nlmsg_alloc_simple(type, flags);
if (!msg)
return -NLE_NOMEM;
if (nlmsg_append(msg, &tcahdr, sizeof(tcahdr), NLMSG_ALIGNTO) < 0)
goto nla_put_failure;
err = rtnl_act_fill(msg, TCA_ACT_TAB, act);
if (err < 0)
goto nla_put_failure;
*result = msg;
return 0;
nla_put_failure:
nlmsg_free(msg);
return err;
}
static int act_build(struct rtnl_act *act, int type, int flags,
struct nl_msg **result)
{
int err;
err = rtnl_act_msg_build(act, type, flags, result);
if (err < 0)
return err;
return 0;
}
/**
* @name Allocation/Freeing
* @{
*/
struct rtnl_act *rtnl_act_alloc(void)
{
struct rtnl_tc *tc;
tc = TC_CAST(nl_object_alloc(&act_obj_ops));
if (tc)
tc->tc_type = RTNL_TC_TYPE_ACT;
return (struct rtnl_act *) tc;
}
void rtnl_act_get(struct rtnl_act *act)
{
nl_object_get(OBJ_CAST(act));
}
void rtnl_act_put(struct rtnl_act *act)
{
nl_object_put((struct nl_object *) act);
}
/** @} */
/**
* @name Addition/Modification/Deletion
* @{
*/
/**
* Build a netlink message requesting the addition of an action
* @arg act Action to add
* @arg flags Additional netlink message flags
* @arg result Pointer to store resulting netlink message
*
* The behaviour of this function is identical to rtnl_act_add() with
* the exception that it will not send the message but return it int the
* provided return pointer instead.
*
* @see rtnl_act_add()
*
* @return 0 on success or a negative error code.
*/
int rtnl_act_build_add_request(struct rtnl_act *act, int flags,
struct nl_msg **result)
{
return act_build(act, RTM_NEWACTION, flags, result);
}
/**
* Add/Update action
* @arg sk Netlink socket
* @arg act Action to add/update
* @arg flags Additional netlink message flags
*
* Builds a \c RTM_NEWACTION netlink message requesting the addition
* of a new action and sends the message to the kernel. The
* configuration of the action is derived from the attributes of
* the specified traffic class.
*
* The following flags may be specified:
* - \c NLM_F_CREATE: Create action if it does not exist,
* otherwise -NLE_OBJ_NOTFOUND is returned.
* - \c NLM_F_EXCL: Return -NLE_EXISTS if an action with
* matching handle exists already.
*
* Existing actions with matching handles will be updated, unless
* the flag \c NLM_F_EXCL is specified. If no matching action
* exists, it will be created if the flag \c NLM_F_CREATE is set,
* otherwise the error -NLE_OBJ_NOTFOUND is returned.
*
* After sending, the function will wait for the ACK or an eventual
* error message to be received and will therefore block until the
* operation has been completed.
*
* @note Disabling auto-ack (nl_socket_disable_auto_ack()) will cause
* this function to return immediately after sending. In this case,
* it is the responsibility of the caller to handle any error
* messages returned.
*
* @return 0 on success or a negative error code.
*/
int rtnl_act_add(struct nl_sock *sk, struct rtnl_act *act, int flags)
{
struct nl_msg *msg;
int err;
if ((err = rtnl_act_build_add_request(act, flags, &msg)) < 0)
return err;
return nl_send_sync(sk, msg);
}
/**
* Build a netlink message to change action attributes
* @arg act Action to change
* @arg flags additional netlink message flags
* @arg result Pointer to store resulting message.
*
* Builds a new netlink message requesting a change of a neigh
* attributes. The netlink message header isn't fully equipped with
* all relevant fields and must thus be sent out via nl_send_auto_complete()
* or supplemented as needed.
*
* @return 0 on success or a negative error code.
*/
int rtnl_act_build_change_request(struct rtnl_act *act, int flags,
struct nl_msg **result)
{
return act_build(act, RTM_NEWACTION, NLM_F_REPLACE | flags, result);
}
/**
* Change an action
* @arg sk Netlink socket.
* @arg act action to change
* @arg flags additional netlink message flags
*
* Builds a netlink message by calling rtnl_act_build_change_request(),
* sends the request to the kernel and waits for the next ACK to be
* received and thus blocks until the request has been processed.
*
* @return 0 on sucess or a negative error if an error occured.
*/
int rtnl_act_change(struct nl_sock *sk, struct rtnl_act *act, int flags)
{
struct nl_msg *msg;
int err;
if ((err = rtnl_act_build_change_request(act, flags, &msg)) < 0)
return err;
return nl_send_sync(sk, msg);
}
/**
* Build netlink message requesting the deletion of an action
* @arg act Action to delete
* @arg flags Additional netlink message flags
* @arg result Pointer to store resulting netlink message
*
* The behaviour of this function is identical to rtnl_act_delete() with
* the exception that it will not send the message but return it in the
* provided return pointer instead.
*
* @see rtnl_act_delete()
*
* @return 0 on success or a negative error code.
*/
int rtnl_act_build_delete_request(struct rtnl_act *act, int flags,
struct nl_msg **result)
{
return act_build(act, RTM_DELACTION, flags, result);
}
/**
* Delete action
* @arg sk Netlink socket
* @arg act Action to delete
* @arg flags Additional netlink message flags
*
* Builds a \c RTM_DELACTION netlink message requesting the deletion
* of an action and sends the message to the kernel.
*
* The message is constructed out of the following attributes:
* - \c ifindex (required)
* - \c prio (required)
* - \c protocol (required)
* - \c handle (required)
* - \c parent (optional, if not specified parent equals root-qdisc)
* - \c kind (optional, must match if provided)
*
* All other action attributes including all class type specific
* attributes are ignored.
*
* After sending, the function will wait for the ACK or an eventual
* error message to be received and will therefore block until the
* operation has been completed.
*
* @note Disabling auto-ack (nl_socket_disable_auto_ack()) will cause
* this function to return immediately after sending. In this case,
* it is the responsibility of the caller to handle any error
* messages returned.
*
* @return 0 on success or a negative error code.
*/
int rtnl_act_delete(struct nl_sock *sk, struct rtnl_act *act, int flags)
{
struct nl_msg *msg;
int err;
if ((err = rtnl_act_build_delete_request(act, flags, &msg)) < 0)
return err;
return nl_send_sync(sk, msg);
}
/** @} */
static void act_dump_line(struct rtnl_tc *tc, struct nl_dump_params *p)
{
}
void rtnl_act_put_all(struct rtnl_act **head)
{
struct rtnl_act *curr, *next;
curr = *head;
while (curr) {
next = curr->a_next;
rtnl_act_put(curr);
curr = next;
}
*head = NULL;
}
int rtnl_act_parse(struct rtnl_act **head, struct nlattr *tb)
{
struct rtnl_act *act;
struct rtnl_tc_ops *ops;
struct nlattr *tb2[TCA_ACT_MAX + 1];
struct nlattr *nla[TCA_ACT_MAX_PRIO + 1];
char kind[TCKINDSIZ];
int err, i;
err = nla_parse(nla, TCA_ACT_MAX_PRIO, nla_data(tb),
NLMSG_ALIGN(nla_len(tb)), NULL);
if (err < 0)
return err;
for (i = 0; i < TCA_ACT_MAX_PRIO; i++) {
struct rtnl_tc *tc;
if (nla[i] == NULL)
continue;
act = rtnl_act_alloc();
if (!act) {
err = -NLE_NOMEM;
goto err_free;
}
tc = TC_CAST(act);
err = nla_parse(tb2, TCA_ACT_MAX, nla_data(nla[i]),
nla_len(nla[i]), NULL);
if (err < 0)
goto err_free;
if (tb2[TCA_ACT_KIND] == NULL) {
err = -NLE_MISSING_ATTR;
goto err_free;
}
nla_strlcpy(kind, tb2[TCA_ACT_KIND], sizeof(kind));
rtnl_tc_set_kind(tc, kind);
if (tb2[TCA_ACT_OPTIONS]) {
tc->tc_opts = nl_data_alloc_attr(tb2[TCA_ACT_OPTIONS]);
if (!tc->tc_opts) {
err = -NLE_NOMEM;
goto err_free;
}
tc->ce_mask |= TCA_ATTR_OPTS;
}
ops = rtnl_tc_get_ops(tc);
if (ops && ops->to_msg_parser) {
void *data = rtnl_tc_data(tc);
if (!data) {
err = -NLE_NOMEM;
goto err_free;
}
err = ops->to_msg_parser(tc, data);
if (err < 0)
goto err_free;
}
err = rtnl_act_append(head, act);
if (err < 0)
goto err_free;
}
return 0;
err_free:
rtnl_act_put (act);
rtnl_act_put_all(head);
return err;
}
static int rtnl_act_msg_parse(struct nlmsghdr *n, struct rtnl_act **act)
{
struct rtnl_tc *tc = TC_CAST(*act);
struct nl_cache *link_cache;
struct nlattr *tb[TCAA_MAX + 1];
struct tcamsg *tm;
int err;
tc->ce_msgtype = n->nlmsg_type;
err = nlmsg_parse(n, sizeof(*tm), tb, TCAA_MAX, NULL);
if (err < 0)
return err;
tm = nlmsg_data(n);
tc->tc_family = tm->tca_family;
if (tb[TCA_ACT_TAB] == NULL)
return -NLE_MISSING_ATTR;
err = rtnl_act_parse(act, tb[TCA_ACT_TAB]);
if (err < 0)
return err;
if ((link_cache = __nl_cache_mngt_require("route/link"))) {
struct rtnl_link *link;
if ((link = rtnl_link_get(link_cache, tc->tc_ifindex))) {
rtnl_tc_set_link(tc, link);
/* rtnl_tc_set_link incs refcnt */
rtnl_link_put(link);
}
}
return 0;
}
static int act_msg_parser(struct nl_cache_ops *ops, struct sockaddr_nl *who,
struct nlmsghdr *nlh, struct nl_parser_param *pp)
{
struct rtnl_act *act, *p_act;
int err;
if (!(act = rtnl_act_alloc()))
return -NLE_NOMEM;
if ((err = rtnl_act_msg_parse(nlh, &act)) < 0)
goto errout;
p_act = act;
while(p_act) {
err = pp->pp_cb(OBJ_CAST(act), pp);
if (err)
break;
p_act = p_act->a_next;
}
errout:
rtnl_act_put(act);
return err;
}
static int act_request_update(struct nl_cache *cache, struct nl_sock *sk)
{
struct tcamsg tcahdr = {
.tca_family = AF_UNSPEC,
};
return nl_send_simple(sk, RTM_GETACTION, NLM_F_DUMP, &tcahdr,
sizeof(tcahdr));
}
static struct rtnl_tc_type_ops act_ops = {
.tt_type = RTNL_TC_TYPE_ACT,
.tt_dump_prefix = "act",
.tt_dump = {
[NL_DUMP_LINE] = act_dump_line,
},
};
static struct nl_cache_ops rtnl_act_ops = {
.co_name = "route/act",
.co_hdrsize = sizeof(struct tcmsg),
.co_msgtypes = {
{ RTM_NEWACTION, NL_ACT_NEW, "new" },
{ RTM_DELACTION, NL_ACT_DEL, "del" },
{ RTM_GETACTION, NL_ACT_GET, "get" },
END_OF_MSGTYPES_LIST,
},
.co_protocol = NETLINK_ROUTE,
.co_request_update = act_request_update,
.co_msg_parser = act_msg_parser,
.co_obj_ops = &act_obj_ops,
};
static struct nl_object_ops act_obj_ops = {
.oo_name = "route/act",
.oo_size = sizeof(struct rtnl_act),
.oo_free_data = rtnl_tc_free_data,
.oo_clone = rtnl_tc_clone,
.oo_dump = {
[NL_DUMP_LINE] = rtnl_tc_dump_line,
[NL_DUMP_DETAILS] = rtnl_tc_dump_details,
[NL_DUMP_STATS] = rtnl_tc_dump_stats,
},
.oo_compare = rtnl_tc_compare,
.oo_id_attrs = (TCA_ATTR_IFINDEX | TCA_ATTR_HANDLE),
};
static void __init act_init(void)
{
rtnl_tc_type_register(&act_ops);
nl_cache_mngt_register(&rtnl_act_ops);
}
static void __exit act_exit(void)
{
nl_cache_mngt_unregister(&rtnl_act_ops);
rtnl_tc_type_unregister(&act_ops);
}
/** @} */