/*

 * Copyright Intel Corporation. 2012

 *

 * Authors:	John Fastabend <john.r.fastabend@lintel.com>

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms and conditions of the GNU General Public License,

 * version 2, as published by the Free Software Foundation.

 *

 * This program is distributed in the hope it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

 * more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

 * This program is free software; you can redistribute it and/or modify it

 * under the terms and conditions of the GNU General Public License,

 * version 2, as published by the Free Software Foundation.

 *

 * The full GNU General Public License is included in this distribution in

 * the file called "COPYING".

 */

#include <libcgroup.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <errno.h>

#include <getopt.h>

#include <libmnl/libmnl.h>

#include <linux/if_link.h>

#include <linux/rtnetlink.h>

#include <net/if.h>

#include <linux/dcbnl.h>

#include <sys/queue.h>

#include <signal.h>

#include <sys/select.h>

#include <syslog.h>

#include <sys/file.h>

#include <unistd.h>

#include <time.h>

#define UNUSED __attribute__((__unused__))

#define PID_FILE "/var/run/cgdcbxd.pid"

#define NET_PRIO "net_prio"

#define IFPRIOMAP "net_prio.ifpriomap"

struct cgdcbx_virt {

	char *ifname;

	int ifindex;

	__u32 iflink;

	LIST_ENTRY(cgdcbx_virt) entry;

};

struct cgdcbx_entry {

	struct dcb_app app;

	bool active;

	LIST_ENTRY(cgdcbx_entry) entry;

};

struct cgdcbx_iface {

	char *ifname;

	int mode;

	int ifindex;

	int dflt_priority;

	LIST_HEAD(cgdcbx_apps, cgdcbx_entry) apps;

	LIST_HEAD(cgdcbx_slaves, cgdcbx_virt) virt;

	LIST_ENTRY(cgdcbx_iface) entry;

};

LIST_HEAD(cgdcbx_iface_head, cgdcbx_iface) iface_list;

static void usage(const char *program_name)

{

	fprintf(stderr,

		"\n"

		"Usage: %s [-hn]"

		"\n"

		"options:\n"

		"   -h  show this usage\n"

		"   -n  don't fork daemon\n",

		program_name);

}

static int dcb_attr_cb(const struct nlattr *attr, void *data)

{

	const struct nlattr **tb = (const struct nlattr **)data;

	int type = mnl_attr_get_type(attr);

	int ret = 0;

	/* skip unsupported attribute in user-space */

	if (mnl_attr_type_valid(attr, DCB_CMD_MAX) < 0)

		return MNL_CB_OK;

	switch (type) {

	case DCB_ATTR_IFNAME:

		ret = mnl_attr_validate(attr, MNL_TYPE_STRING);

		break;

	case DCB_ATTR_APP:

		ret = mnl_attr_validate(attr, MNL_TYPE_NESTED);

		break;

	case DCB_CMD_GDCBX:

		ret = mnl_attr_validate(attr, MNL_TYPE_U8);

		break;

	}

	if (ret < 0) {

		perror("mnl_attr_validate");

		return MNL_CB_ERROR;

	}

	tb[type] = attr;

	return MNL_CB_OK;

}

static int parse_attr_ieee(const struct nlattr *attr, void *data)

{

	const struct nlattr **tb = data;

	int type = mnl_attr_get_type(attr);

	if (mnl_attr_type_valid(attr, DCB_ATTR_IEEE_MAX) < 0)

		return MNL_CB_OK;

	switch (type) {

	case DCB_ATTR_IEEE_APP_TABLE:

		if (mnl_attr_validate(attr, MNL_TYPE_NESTED) < 0) {

			perror("mnl_attr_validate: DCB_ATTR_IEEE_APP_TABLE");

			return MNL_CB_ERROR;

		}

		break;

	}

	tb[type] = attr;

	return MNL_CB_OK;

}

static int parse_attr_cee(const struct nlattr *attr, void *data)

{

	const struct nlattr **tb = data;

	int type = mnl_attr_get_type(attr);

	if (mnl_attr_type_valid(attr, DCB_ATTR_CEE_MAX) < 0)

		return MNL_CB_OK;

	switch (type) {

	case DCB_ATTR_CEE_APP_TABLE:

		if (mnl_attr_validate(attr, MNL_TYPE_NESTED) < 0) {

			perror("mnl_attr_validate: DCB_ATTR_CEE_TABLE");

			return MNL_CB_ERROR;

		}

		break;

	}

	tb[type] = attr;

	return MNL_CB_OK;

}

static struct cgdcbx_entry *__cgdcbx_lookup_app(struct cgdcbx_iface *iface,

						struct dcb_app *app)

{

	struct cgdcbx_entry *np;

	LIST_FOREACH(np, &iface->apps, entry) {

		if (np->app.selector == app->selector &&

		    np->app.protocol == app->protocol)

			return np;

	}

	return NULL;

}

static struct cgdcbx_entry *cgdcbx_lookup_app(struct cgdcbx_iface *iface,

					      struct dcb_app *app)

{

	struct cgdcbx_entry *entry = __cgdcbx_lookup_app(iface, app);

	if (entry) {

		entry->app.priority = app->priority;

		entry->active = true;

	} else {

		entry = malloc(sizeof(*entry));

		if (!entry)

			return NULL;

		memcpy(&entry->app, app, sizeof(entry->app));

		entry->active = true;

		LIST_INSERT_HEAD(&iface->apps, entry, entry);

	}

	return entry;

}

static int cgdcbx_del_cgroup(struct cgroup *cg)

{

	int err = cgroup_delete_cgroup(cg, 1);

	if (err)

		fprintf(stderr, "cgdcbx: libcgroup delete cgroup failed: %s\n",

			cgroup_strerror(err));

	return err;

}

static int link_attr_cb(const struct nlattr *attr, void *data)

{

	const struct nlattr **tb = (const struct nlattr **)data;

	int type = mnl_attr_get_type(attr);

	/* skip unsupported attribute in user-space */

	if (mnl_attr_type_valid(attr, IFLA_MAX) < 0)

		return MNL_CB_OK;

	switch (type) {

	case IFLA_IFNAME:

		if (mnl_attr_validate(attr, MNL_TYPE_STRING) < 0) {

			perror("mnl_attr_validate IFLA_IFNAME");

			return MNL_CB_ERROR;

		}

		break;

	case IFLA_LINK:

		if (mnl_attr_validate(attr, MNL_TYPE_U32) < 0) {

			perror("mnl_attr_validate IFLA_LINK");

			return MNL_CB_ERROR;

		}

		break;

	}

	tb[type] = attr;

	return MNL_CB_OK;

}

struct cgdcbx_link_data {

	struct cgdcbx_iface *iface;

	struct cgdcbx_virt *virt;

	int nlmsg_type;

	unsigned ifi_flags;

};

static int cgdcbx_link_cb(const struct nlmsghdr *nlh, void *data)

{

	struct cgdcbx_iface *iface = NULL;

	struct cgdcbx_virt *virt = NULL;

	struct cgdcbx_link_data *cgdcbx_data = data;

	const struct nlattr *tb[IFLA_MAX+1] = {};

	struct ifinfomsg *ifm = mnl_nlmsg_get_payload(nlh);

	mnl_attr_parse(nlh, sizeof(*ifm), link_attr_cb, tb);

	/* Require IFLA_IFNAME attribute to build priomap string */

	if (!tb[IFLA_IFNAME])

		goto out;

	/* Add priomap string to cgroup */

	if (tb[IFLA_LINK]) {

		struct cgdcbx_virt *v;

		__u32 iflink = mnl_attr_get_u32(tb[IFLA_LINK]);

		/* Check that device does not already exist */

		LIST_FOREACH(iface, &iface_list, entry) {

			LIST_FOREACH(virt, &iface->virt, entry) {

				if (virt->ifindex == ifm->ifi_index)

					goto out;

			}

		}

		virt = malloc(sizeof(struct cgdcbx_virt));

		if (!virt)

			goto out;

		virt->ifname = strdup(mnl_attr_get_str(tb[IFLA_IFNAME]));

		virt->ifindex = ifm->ifi_index;

		virt->iflink = iflink;

		/* Devices can be stacked on other virtual devices so we

		 * must search list of virtual devices for a map and add

		 * to virtual device list to propagate priority.

		 */

		LIST_FOREACH(iface, &iface_list, entry) {

			if (iflink == if_nametoindex(iface->ifname)) {

				LIST_INSERT_HEAD(&iface->virt, virt, entry);

				goto out;

			}

			LIST_FOREACH(v, &iface->virt, entry) {

				if (iflink == if_nametoindex(v->ifname)) {

					LIST_INSERT_HEAD(&iface->virt,

							 virt,

							 entry);

					goto out;

				}

			}

		}

		free(virt->ifname);

		free(virt);

	} else {

		/* Check that device does not already exist */

		LIST_FOREACH(iface, &iface_list, entry) {

			if (iface->ifindex == ifm->ifi_index)

				goto out;

		}

		/* If device is not being tracked wait for DCB event */

	}

	iface = NULL;

	virt = NULL;

out:

	if (cgdcbx_data) {

		cgdcbx_data->nlmsg_type = nlh->nlmsg_type;

		cgdcbx_data->iface = iface;

		cgdcbx_data->virt = virt;

		cgdcbx_data->ifi_flags = ifm->ifi_flags;

	}

	return MNL_CB_OK;

}

static void cgdcbx_write_virtmap(struct cgdcbx_virt *virt,

				 char *file, struct cgdcbx_entry *np)

{

	struct cgroup *vcg_app;

	struct cgroup_controller *vcg_ctrl;

	char value[IFNAMSIZ + 3];

	int err;

	vcg_app = cgroup_new_cgroup(file);

	if (!vcg_app) {

		fprintf(stderr,

			"cgdcbx: libcgroup %s cgroup_new_cgroup failed\n",

			file);

		return;

	}

	vcg_ctrl = cgroup_get_controller(vcg_app, NET_PRIO);

	if (!vcg_ctrl) {

		vcg_ctrl = cgroup_add_controller(vcg_app, NET_PRIO);

		if (!vcg_ctrl)

			return;

	}

	err = cgroup_create_cgroup(vcg_app, 1);

	if (err) {

		fprintf(stderr,

			"cgdcbx: libcgroup %s create failed: %s\n",

			file,

			cgroup_strerror(err));

	}

	snprintf(value, sizeof(value), "%s %i", virt->ifname, np->app.priority);

	err = cgroup_add_value_string(vcg_ctrl, IFPRIOMAP, value);

	if (err) {

		fprintf(stderr,

			"cgdcbx: %s: libcgroup %s add value failed: %s\n",

			virt->ifname, file, cgroup_strerror(err));

	}

	err = cgroup_modify_cgroup(vcg_app);

	cgroup_free(&vcg_app);

}

static void cgdcbx_write_ifpriomap(struct cgdcbx_iface *iface, char *file,

				   struct cgdcbx_entry *np)

{

	struct cgroup *cg_app;

	struct cgroup_controller *cg_ctrl;

	int err;

	cg_app = cgroup_new_cgroup(file);

	if (!cg_app) {

		fprintf(stderr,

			"cgdcbx: libcgroup %s cgroup_new_cgroup failed\n",

			file);

		return;

	}

	cg_ctrl = cgroup_get_controller(cg_app, NET_PRIO);

	if (!cg_ctrl) {

		cg_ctrl = cgroup_add_controller(cg_app, NET_PRIO);

		if (!cg_ctrl) {

			fprintf(stderr,

				"cgdcbx: libcgroup %s get & add failed\n",

				file);

			goto err;

		}

	}

	if (!np->active) {

		struct cgdcbx_iface *itr;

		struct cgdcbx_entry *entry = NULL;

		struct dcb_app app = np->app;

		entry = __cgdcbx_lookup_app(iface, &np->app);

		if (entry) {

			LIST_REMOVE(entry, entry);

			free(entry);

		} else {

			fprintf(stderr, "cgdcbx: request delete entry that does not exist\n");

		}

		LIST_FOREACH(itr, &iface_list, entry) {

			entry = __cgdcbx_lookup_app(itr, &app);

			if (entry)

				break;

		}

		/* Only remove cgroup if its not in use */

		if (!entry)

			err = cgdcbx_del_cgroup(cg_app);

	} else {

		char value[IFNAMSIZ + 3];

		struct cgdcbx_virt *virt;

		err = cgroup_create_cgroup(cg_app, 1);

		if (err) {

			fprintf(stderr,

				"cgdcbx: libcgroup %s create failed: %s\n",

				file,

				cgroup_strerror(err));

			goto err;

		}

		snprintf(value, sizeof(value), "%s %i",

			 iface->ifname, np->app.priority);

		err = cgroup_add_value_string(cg_ctrl, IFPRIOMAP, value);

		if (err) {

			fprintf(stderr,

				"cgdcbx: %s: libcgroup %s add value failed: %s\n",

				iface->ifname,

				file,

				cgroup_strerror(err));

			goto err;

		}

		/* Update any stacked devices as well */

		virt = LIST_FIRST(&iface->virt);

		while (virt) {

			cgdcbx_write_virtmap(virt, file, np);

			virt = LIST_NEXT(virt, entry);

		}

		err = cgroup_modify_cgroup(cg_app);

		if (err) {

			fprintf(stderr,

				"cgdcbx: libcgroup modify \"%s %s\" cgroup failed(%i): %s\n",

				value,

				file,

				err,

				cgroup_strerror(err));

			goto err;

		}

	}

err:

	cgroup_free(&cg_app);

}

static void cgdcbxd_update_default_iface_prio(struct cgdcbx_iface *iface)

{

	char child_name[FILENAME_MAX] = "";

	void *handle;

	struct cgroup_file_info info;

	int ret, level, group_len;

	struct cgdcbx_entry entry;

	/* Initialize dummy default priority entry */

	entry.app.selector = 1;

	entry.app.protocol = 0;

	entry.app.priority = iface->dflt_priority;

	entry.active = 1;

	ret = cgroup_walk_tree_begin(NET_PRIO, "/", 0, &handle, &info, &level);

	if (ret)

		return;

	ret = cgroup_walk_tree_set_flags(&handle, CGROUP_WALK_TYPE_POST_DIR);

	if (ret) {

		cgroup_walk_tree_end(&handle);

		return;

	}

	cgdcbx_write_ifpriomap(iface, "/", &entry);

	group_len = strlen(info.full_path);

	/*

	 * Skip the root group, it will be handled explicitly at the end.

	 */

	ret = cgroup_walk_tree_next(0, &handle, &info, level);

	while (ret == 0) {

		if (info.type == CGROUP_FILE_TYPE_DIR && info.depth > 0) {

			struct cgdcbx_entry *np;

			int selector = 0, protocol = 0;

			snprintf(child_name, sizeof(child_name), "%s",

				 info.full_path + group_len);

			sscanf(info.full_path + group_len,

			      "cgdcb-%i", &selector);

			if (selector == 1)

				sscanf(info.full_path + group_len,

				      "cgdcb-%i-%4x", &selector, &protocol);

			else

				sscanf(info.full_path + group_len,

				       "cgdcb-%i-%i", &selector, &protocol);

			LIST_FOREACH(np, &iface->apps, entry) {

				if (np->app.selector == selector &&

				    np->app.protocol == protocol)

					break;

			}

			if (!np)

				cgdcbx_write_ifpriomap(iface,

						       child_name, &entry);

		}

		ret = cgroup_walk_tree_next(0, &handle, &info, level);

	}

	cgroup_walk_tree_end(&handle);

	return;

}

static void cgdcbx_modify_cgroup(struct cgdcbx_iface *iface,

				 struct cgdcbx_entry *np)

{

	char file[19];

	/* selector == 1 and protocol == 0 is a special case which

	 * indicates the default priority should be set. All other

	 * cases use the selector-protocol control group syntax.

	 */

	if ((iface->mode == DCB_CAP_DCBX_VER_IEEE) &&

	    np->app.selector == 1 &&

	    np->app.protocol == 0) {

		snprintf(file, sizeof(file), "/");

		iface->dflt_priority = np->app.priority;

	} else if (np->app.selector == 1) {

		snprintf(file, sizeof(file), "cgdcb-%i-%04x",

			 np->app.selector,

			 np->app.protocol);

	} else {

		snprintf(file, sizeof(file), "cgdcb-%i-%i",

			 np->app.selector,

			 np->app.protocol);

	}

	cgdcbx_write_ifpriomap(iface, file, np);

}

static void cgdcbx_update_iface_cg(struct cgdcbx_iface *iface)

{

	struct cgdcbx_entry *entry;

	entry = LIST_FIRST(&iface->apps);

	while (entry) {

		struct cgdcbx_entry *np = entry;

		entry = LIST_NEXT(entry, entry);

		cgdcbx_modify_cgroup(iface, np);

	}

	return;

}

static void cgdcbx_update_iface_cg_all(void)

{

	struct cgdcbx_iface *iface;

	LIST_FOREACH(iface, &iface_list, entry) {

		cgdcbx_update_iface_cg(iface);

	}

#ifdef HAVE_CGROUP_CHANGE_ALL_CGROUPS

	cgroup_change_all_cgroups();

#endif

}

static void cgdcbx_populate_virtual_devs(void)

{

	static struct mnl_socket *nl;

	struct nlmsghdr *nlh;

	struct rtgenmsg *rt;

	char buf[MNL_SOCKET_BUFFER_SIZE];

	unsigned int portid;

	int ret, groups = 0;

	nl = mnl_socket_open(NETLINK_ROUTE);

	if (!nl) {

		perror("mnl_socket_open");

		exit(EXIT_FAILURE);

	}

	if (mnl_socket_bind(nl, groups, MNL_SOCKET_AUTOPID) < 0) {

		perror("mnl_socket_bind");

		exit(EXIT_FAILURE);

	}

	portid = mnl_socket_get_portid(nl);

	memset(buf, 0, sizeof(buf));

	nlh = mnl_nlmsg_put_header(buf);

	nlh->nlmsg_type = RTM_GETLINK;

	nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;

	nlh->nlmsg_seq = time(NULL);

	rt = mnl_nlmsg_put_extra_header(nlh, sizeof(struct rtgenmsg));

	rt->rtgen_family = AF_PACKET;

	if (mnl_socket_sendto(nl, nlh, nlh->nlmsg_len) < 0) {

		perror("cgdcbx: init_tables, mnl_socket_send");

		return;

	}

	ret = mnl_socket_recvfrom(nl, buf, sizeof(buf));

	while (ret > 0) {

		ret = mnl_cb_run(buf, ret, 0, portid,

				 cgdcbx_link_cb, NULL);

		if (ret <= MNL_CB_STOP)

			break;

		ret = mnl_socket_recvfrom(nl, buf, sizeof(buf));

	}

	mnl_socket_close(nl);

	return;

}

static void cgdcbx_free_apps(struct cgdcbx_iface *iface)

{

	struct cgdcbx_entry *app;

	app = LIST_FIRST(&iface->apps);

	while (app) {

		struct cgdcbx_entry *a = app;

		app = LIST_NEXT(app, entry);

		LIST_REMOVE(a, entry);

		free(a);

	}

}

static void cgdcbx_free_virt(struct cgdcbx_iface *iface)

{

	struct cgdcbx_virt *virt;

	virt = LIST_FIRST(&iface->virt);

	while (virt) {

		struct cgdcbx_virt *v = virt;

		virt = LIST_NEXT(virt, entry);

		LIST_REMOVE(v, entry);

		free(v->ifname);

		free(v);

	}

}

static void cgdcbx_free_iface(struct cgdcbx_iface *iface,

			      struct cgdcbx_virt *virt)

{

	if (!virt) {

		LIST_REMOVE(iface, entry);

		cgdcbx_free_apps(iface);

		cgdcbx_free_virt(iface);

		free(iface->ifname);

		free(iface);

	} else {

		LIST_REMOVE(virt, entry);

		free(virt->ifname);

		free(virt);

	}

}

static void cgdcbx_int_signal()

{

	struct cgdcbx_iface *entry;

	entry = LIST_FIRST(&iface_list);

	while (entry) {

		struct cgdcbx_iface *np = entry;

		struct cgdcbx_entry *app;

		entry = LIST_NEXT(entry, entry);

		LIST_FOREACH(app, &np->apps, entry) {

			app->active = false;

		}

		cgdcbx_update_iface_cg(np);

		cgdcbx_free_iface(np, NULL);

	}

	exit(EXIT_SUCCESS);

}

static void cgdcbx_purge_apps(struct cgdcbx_iface *iface)

{

	struct cgdcbx_entry *app;

	LIST_FOREACH(app, &iface->apps, entry)

		app->active = false;

	iface->dflt_priority = 0;

	cgdcbx_update_iface_cg(iface);

	cgdcbxd_update_default_iface_prio(iface);

}

static void cgdcbx_parse_app_table(struct cgdcbx_iface *iface,

				   struct nlattr *nested)

{

	struct nlattr *pos;

	struct cgdcbx_entry *np;

	LIST_FOREACH(np, &iface->apps, entry) {

		np->active = false;

		np->app.priority = 0;

	}

	iface->dflt_priority = 0;

	mnl_attr_for_each_nested(pos, nested) {

		struct dcb_app *app;

		struct cgdcbx_entry *entry;

		int type = mnl_attr_get_type(pos);

		if (type != DCB_ATTR_IEEE_APP)

			continue;

		app = mnl_attr_get_payload(pos);

		entry = cgdcbx_lookup_app(iface, app);

		if (!entry)

			fprintf(stderr,

				"cgdcbxd %s IEEE entry lookup failed\n",

				iface->ifname);

	}

	cgdcbx_update_iface_cg(iface);

	cgdcbxd_update_default_iface_prio(iface);

#ifdef HAVE_CGROUP_CHANGE_ALL_CGROUPS

	cgroup_change_all_cgroups();

#endif

}

static int parse_attr_cee_nested_app(const struct nlattr *attr, void *data)

{

	const struct nlattr **tb = data;

	int type = mnl_attr_get_type(attr);

	if (mnl_attr_type_valid(attr, DCB_APP_ATTR_MAX) < 0)

		return MNL_CB_OK;

	switch (type) {

	case DCB_APP_ATTR_IDTYPE:

		if (mnl_attr_validate(attr, MNL_TYPE_U8) < 0) {

			perror("mnl_attr_validate: DCB_APP_ATTR_IDTYPE");

			return MNL_CB_ERROR;

		}

		break;

	case DCB_APP_ATTR_ID:

		if (mnl_attr_validate(attr, MNL_TYPE_U16) < 0) {

			perror("mnl_attr_validate: DCB_APP_ATTR_ID");

			return MNL_CB_ERROR;

		}

		break;

	case DCB_APP_ATTR_PRIORITY:

		if (mnl_attr_validate(attr, MNL_TYPE_U8) < 0) {

			perror("mnl_attr_validate: DCB_APP_ATTR_PRIORITY");

			return MNL_CB_ERROR;

		}

		break;

	}

	tb[type] = attr;

	return MNL_CB_OK;

}

#define CGDCBX_CEE_APPSEL_ERROR	0xff

static __u8 cee2app_selector(__u8 selector)

{

	__u8 s = CGDCBX_CEE_APPSEL_ERROR;

	/* CEE Application TLV defines two selector types,

	 *   0: Application Protocol ID is L2 Ethertype

	 *   1: Application Protocol ID is Socket Number (TCP/UDP)

	 *

	 * When mapping this back to cgdcbx APP structure which

	 * is using the IEEE definitions, map 0 to the IEEE L2

	 * type (1) and TCP/UDP socket to TCP, UDP, SCTP, or DCCP

	 * socket type (4). Not a perfect match but good enough.

	 */

	switch (selector) {

	case 0:

		s = 1;

		break;

	case 1:

		s = 4;

		break;

	default:

		break;

	}

	return s;

}

static __u16 cee2app_protocol(UNUSED __u8 selector, __u16 protocol)

{

	return protocol;

}

static __u8 cee2app_priority(__u8 priority)

{

	return ffs(priority) - 1;

}

static void cgdcbx_parse_cee_app_table(struct cgdcbx_iface *iface,

				       struct nlattr *nested)

{

	struct nlattr *pos;

	struct cgdcbx_entry *np;

	LIST_FOREACH(np, &iface->apps, entry) {

		np->active = false;

		np->app.priority = 0;

	}

	iface->dflt_priority = 0;

	mnl_attr_for_each_nested(pos, nested) {

		struct dcb_app app;

		struct cgdcbx_entry *entry;

		struct nlattr *tbx[DCB_APP_ATTR_MAX + 1] = {};

		int type = mnl_attr_get_type(pos);

		__u8 selector, priority;

		__u16 protocol;

		if (type != DCB_ATTR_APP)

			continue;

		mnl_attr_parse_nested(pos, parse_attr_cee_nested_app, tbx);

		if (tbx[DCB_APP_ATTR_IDTYPE])

			selector = mnl_attr_get_u8(tbx[DCB_APP_ATTR_IDTYPE]);

		else

			continue;

		if (tbx[DCB_APP_ATTR_ID])

			protocol = mnl_attr_get_u16(tbx[DCB_APP_ATTR_ID]);

		else

			continue;

		if (tbx[DCB_APP_ATTR_PRIORITY])

			priority = mnl_attr_get_u8(tbx[DCB_APP_ATTR_PRIORITY]);

		else

			continue;

		app.selector = cee2app_selector(selector);

		app.protocol = cee2app_protocol(selector, protocol);

		app.priority = cee2app_priority(priority);

		if (app.selector != CGDCBX_CEE_APPSEL_ERROR) {

			entry = cgdcbx_lookup_app(iface, &app);

			if (!entry)

				fprintf(stderr,

					"cgdcbxd %s CEE entry lookup failed\n",

					iface->ifname);

		}

	}

	cgdcbx_update_iface_cg(iface);

	cgdcbxd_update_default_iface_prio(iface);

#ifdef HAVE_CGROUP_CHANGE_ALL_CGROUPS

	cgroup_change_all_cgroups();

#endif

}

static struct cgdcbx_iface *cgdcbx_add_iface(const char *ifname)

{

	struct cgdcbx_iface *entry = calloc(1, sizeof(*entry));

	if (!entry)

		return NULL;