[mirror_ubuntu-artful-kernel.git] / net / irda / irnetlink.c

/*
 * IrDA netlink layer, for stack configuration.
 *
 * Copyright (c) 2007 Samuel Ortiz <samuel@sortiz.org>
 *
 * Partly based on the 802.11 nelink implementation
 * (see net/wireless/nl80211.c) which is:
 * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 */

#include <linux/socket.h>
#include <linux/irda.h>
#include <linux/gfp.h>
#include <net/net_namespace.h>
#include <net/sock.h>
#include <net/irda/irda.h>
#include <net/irda/irlap.h>
#include <net/genetlink.h>


static struct genl_family irda_nl_family;

static struct net_device * ifname_to_netdev(struct net *net, struct genl_info *info)
{
	char * ifname;

	if (!info->attrs[IRDA_NL_ATTR_IFNAME])
		return NULL;

	ifname = nla_data(info->attrs[IRDA_NL_ATTR_IFNAME]);

	pr_debug("%s(): Looking for %s\n", __func__, ifname);

	return dev_get_by_name(net, ifname);
}

static int irda_nl_set_mode(struct sk_buff *skb, struct genl_info *info)
{
	struct net_device * dev;
	struct irlap_cb * irlap;
	u32 mode;

	if (!info->attrs[IRDA_NL_ATTR_MODE])
		return -EINVAL;

	mode = nla_get_u32(info->attrs[IRDA_NL_ATTR_MODE]);

	pr_debug("%s(): Switching to mode: %d\n", __func__, mode);

	dev = ifname_to_netdev(&init_net, info);
	if (!dev)
		return -ENODEV;

	irlap = (struct irlap_cb *)dev->atalk_ptr;
	if (!irlap) {
		dev_put(dev);
		return -ENODEV;
	}

	irlap->mode = mode;

	dev_put(dev);

	return 0;
}

static int irda_nl_get_mode(struct sk_buff *skb, struct genl_info *info)
{
	struct net_device * dev;
	struct irlap_cb * irlap;
	struct sk_buff *msg;
	void *hdr;
	int ret = -ENOBUFS;

	dev = ifname_to_netdev(&init_net, info);
	if (!dev)
		return -ENODEV;

	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
	if (!msg) {
		dev_put(dev);
		return -ENOMEM;
	}

	irlap = (struct irlap_cb *)dev->atalk_ptr;
	if (!irlap) {
		ret = -ENODEV;
		goto err_out;
	}

	hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq,
			  &irda_nl_family, 0,  IRDA_NL_CMD_GET_MODE);
	if (hdr == NULL) {
		ret = -EMSGSIZE;
		goto err_out;
	}

	if(nla_put_string(msg, IRDA_NL_ATTR_IFNAME,
			  dev->name))
		goto err_out;

	if(nla_put_u32(msg, IRDA_NL_ATTR_MODE, irlap->mode))
		goto err_out;

	genlmsg_end(msg, hdr);

	return genlmsg_reply(msg, info);

 err_out:
	nlmsg_free(msg);
	dev_put(dev);

	return ret;
}

static const struct nla_policy irda_nl_policy[IRDA_NL_ATTR_MAX + 1] = {
	[IRDA_NL_ATTR_IFNAME] = { .type = NLA_NUL_STRING,
				  .len = IFNAMSIZ-1 },
	[IRDA_NL_ATTR_MODE] = { .type = NLA_U32 },
};

static const struct genl_ops irda_nl_ops[] = {
	{
		.cmd = IRDA_NL_CMD_SET_MODE,
		.doit = irda_nl_set_mode,
		.policy = irda_nl_policy,
		.flags = GENL_ADMIN_PERM,
	},
	{
		.cmd = IRDA_NL_CMD_GET_MODE,
		.doit = irda_nl_get_mode,
		.policy = irda_nl_policy,
		/* can be retrieved by unprivileged users */
	},

};

static struct genl_family irda_nl_family __ro_after_init = {
	.name = IRDA_NL_NAME,
	.hdrsize = 0,
	.version = IRDA_NL_VERSION,
	.maxattr = IRDA_NL_CMD_MAX,
	.module = THIS_MODULE,
	.ops = irda_nl_ops,
	.n_ops = ARRAY_SIZE(irda_nl_ops),
};

int __init irda_nl_register(void)
{
	return genl_register_family(&irda_nl_family);
}

void irda_nl_unregister(void)
{
	genl_unregister_family(&irda_nl_family);
}
Commit	Line	Data
89da1ecf SO	1	/*
	2	* IrDA netlink layer, for stack configuration.
	3	*
22e1fb25	4	* Copyright (c) 2007 Samuel Ortiz <samuel@sortiz.org>
89da1ecf SO	5	*
	6	* Partly based on the 802.11 nelink implementation
	7	* (see net/wireless/nl80211.c) which is:
	8	* Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License version 2 as
	12	* published by the Free Software Foundation.
	13	*
	14	*/
	15
	16	#include <linux/socket.h>
	17	#include <linux/irda.h>
5a0e3ad6	18	#include <linux/gfp.h>
881d966b	19	#include <net/net_namespace.h>
89da1ecf SO	20	#include <net/sock.h>
	21	#include <net/irda/irda.h>
	22	#include <net/irda/irlap.h>
	23	#include <net/genetlink.h>
	24
	25
	26
489111e5	27	static struct genl_family irda_nl_family;
89da1ecf	28
881d966b	29	static struct net_device * ifname_to_netdev(struct net net, struct genl_info info)
89da1ecf SO	30	{
	31	char * ifname;
	32
	33	if (!info->attrs[IRDA_NL_ATTR_IFNAME])
	34	return NULL;
	35
	36	ifname = nla_data(info->attrs[IRDA_NL_ATTR_IFNAME]);
	37
955a9d20	38	pr_debug("%s(): Looking for %s\n", __func__, ifname);
89da1ecf	39
881d966b	40	return dev_get_by_name(net, ifname);
89da1ecf SO	41	}
	42
	43	static int irda_nl_set_mode(struct sk_buff skb, struct genl_info info)
	44	{
	45	struct net_device * dev;
	46	struct irlap_cb * irlap;
	47	u32 mode;
	48
	49	if (!info->attrs[IRDA_NL_ATTR_MODE])
	50	return -EINVAL;
	51
	52	mode = nla_get_u32(info->attrs[IRDA_NL_ATTR_MODE]);
	53
955a9d20	54	pr_debug("%s(): Switching to mode: %d\n", __func__, mode);
89da1ecf	55
881d966b	56	dev = ifname_to_netdev(&init_net, info);
89da1ecf SO	57	if (!dev)
	58	return -ENODEV;
	59
	60	irlap = (struct irlap_cb *)dev->atalk_ptr;
	61	if (!irlap) {
	62	dev_put(dev);
	63	return -ENODEV;
	64	}
	65
	66	irlap->mode = mode;
	67
	68	dev_put(dev);
	69
	70	return 0;
	71	}
	72
	73	static int irda_nl_get_mode(struct sk_buff skb, struct genl_info info)
	74	{
	75	struct net_device * dev;
	76	struct irlap_cb * irlap;
	77	struct sk_buff *msg;
	78	void *hdr;
	79	int ret = -ENOBUFS;
	80
881d966b	81	dev = ifname_to_netdev(&init_net, info);
89da1ecf SO	82	if (!dev)
	83	return -ENODEV;
	84
fd2120ca	85	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
89da1ecf SO	86	if (!msg) {
	87	dev_put(dev);
	88	return -ENOMEM;
	89	}
	90
	91	irlap = (struct irlap_cb *)dev->atalk_ptr;
	92	if (!irlap) {
	93	ret = -ENODEV;
	94	goto err_out;
	95	}
	96
15e47304	97	hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq,
89da1ecf	98	&irda_nl_family, 0, IRDA_NL_CMD_GET_MODE);
07035fc1 JV	99	if (hdr == NULL) {
07035fc1 JV	100	ret = -EMSGSIZE;
89da1ecf SO	101	goto err_out;
	102	}
	103
	104	if(nla_put_string(msg, IRDA_NL_ATTR_IFNAME,
22117ea4	105	dev->name))
89da1ecf SO	106	goto err_out;
	107
	108	if(nla_put_u32(msg, IRDA_NL_ATTR_MODE, irlap->mode))
	109	goto err_out;
	110
	111	genlmsg_end(msg, hdr);
	112
134e6375	113	return genlmsg_reply(msg, info);
89da1ecf SO	114
	115	err_out:
	116	nlmsg_free(msg);
	117	dev_put(dev);
	118
	119	return ret;
	120	}
	121
b54452b0	122	static const struct nla_policy irda_nl_policy[IRDA_NL_ATTR_MAX + 1] = {
89da1ecf SO	123	[IRDA_NL_ATTR_IFNAME] = { .type = NLA_NUL_STRING,
	124	.len = IFNAMSIZ-1 },
	125	[IRDA_NL_ATTR_MODE] = { .type = NLA_U32 },
	126	};
	127
4534de83	128	static const struct genl_ops irda_nl_ops[] = {
89da1ecf SO	129	{
	130	.cmd = IRDA_NL_CMD_SET_MODE,
	131	.doit = irda_nl_set_mode,
	132	.policy = irda_nl_policy,
	133	.flags = GENL_ADMIN_PERM,
	134	},
	135	{
	136	.cmd = IRDA_NL_CMD_GET_MODE,
	137	.doit = irda_nl_get_mode,
	138	.policy = irda_nl_policy,
	139	/* can be retrieved by unprivileged users */
	140	},
	141
	142	};
	143
56989f6d	144	static struct genl_family irda_nl_family __ro_after_init = {
489111e5 JB	145	.name = IRDA_NL_NAME,
	146	.hdrsize = 0,
	147	.version = IRDA_NL_VERSION,
	148	.maxattr = IRDA_NL_CMD_MAX,
	149	.module = THIS_MODULE,
	150	.ops = irda_nl_ops,
	151	.n_ops = ARRAY_SIZE(irda_nl_ops),
	152	};
	153
56989f6d	154	int __init irda_nl_register(void)
89da1ecf	155	{
489111e5	156	return genl_register_family(&irda_nl_family);
89da1ecf SO	157	}
	158
	159	void irda_nl_unregister(void)
	160	{
	161	genl_unregister_family(&irda_nl_family);
	162	}