/* * 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); } /** @} */