[linux.git] / net / irda / irnetlink.c

/*
 * IrDA netlink layer, for stack configuration.
 *
 * Copyright (c) 2007 Samuel Ortiz <[email protected]>
 *
 * Partly based on the 802.11 nelink implementation
 * (see net/wireless/nl80211.c) which is:
 * Copyright 2006 Johannes Berg <[email protected]>
 *
 * 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 = {
	.id = GENL_ID_GENERATE,
	.name = IRDA_NL_NAME,
	.hdrsize = 0,
	.version = IRDA_NL_VERSION,
	.maxattr = IRDA_NL_CMD_MAX,
};

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]);

	IRDA_DEBUG(5, "%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]);

	IRDA_DEBUG(5, "%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 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 */
	},

};

int irda_nl_register(void)
{
	return genl_register_family_with_ops(&irda_nl_family,
		irda_nl_ops, ARRAY_SIZE(irda_nl_ops));
}

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 <[email protected]>
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 <[email protected]>
	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
	27	static struct genl_family irda_nl_family = {
	28	.id = GENL_ID_GENERATE,
	29	.name = IRDA_NL_NAME,
	30	.hdrsize = 0,
	31	.version = IRDA_NL_VERSION,
	32	.maxattr = IRDA_NL_CMD_MAX,
	33	};
	34
881d966b	35	static struct net_device * ifname_to_netdev(struct net net, struct genl_info info)
89da1ecf SO	36	{
	37	char * ifname;
	38
	39	if (!info->attrs[IRDA_NL_ATTR_IFNAME])
	40	return NULL;
	41
	42	ifname = nla_data(info->attrs[IRDA_NL_ATTR_IFNAME]);
	43
0dc47877	44	IRDA_DEBUG(5, "%s(): Looking for %s\n", __func__, ifname);
89da1ecf	45
881d966b	46	return dev_get_by_name(net, ifname);
89da1ecf SO	47	}
	48
	49	static int irda_nl_set_mode(struct sk_buff skb, struct genl_info info)
	50	{
	51	struct net_device * dev;
	52	struct irlap_cb * irlap;
	53	u32 mode;
	54
	55	if (!info->attrs[IRDA_NL_ATTR_MODE])
	56	return -EINVAL;
	57
	58	mode = nla_get_u32(info->attrs[IRDA_NL_ATTR_MODE]);
	59
0dc47877	60	IRDA_DEBUG(5, "%s(): Switching to mode: %d\n", __func__, mode);
89da1ecf	61
881d966b	62	dev = ifname_to_netdev(&init_net, info);
89da1ecf SO	63	if (!dev)
	64	return -ENODEV;
	65
	66	irlap = (struct irlap_cb *)dev->atalk_ptr;
	67	if (!irlap) {
	68	dev_put(dev);
	69	return -ENODEV;
	70	}
	71
	72	irlap->mode = mode;
	73
	74	dev_put(dev);
	75
	76	return 0;
	77	}
	78
	79	static int irda_nl_get_mode(struct sk_buff skb, struct genl_info info)
	80	{
	81	struct net_device * dev;
	82	struct irlap_cb * irlap;
	83	struct sk_buff *msg;
	84	void *hdr;
	85	int ret = -ENOBUFS;
	86
881d966b	87	dev = ifname_to_netdev(&init_net, info);
89da1ecf SO	88	if (!dev)
	89	return -ENODEV;
	90
fd2120ca	91	msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
89da1ecf SO	92	if (!msg) {
	93	dev_put(dev);
	94	return -ENOMEM;
	95	}
	96
	97	irlap = (struct irlap_cb *)dev->atalk_ptr;
	98	if (!irlap) {
	99	ret = -ENODEV;
	100	goto err_out;
	101	}
	102
15e47304	103	hdr = genlmsg_put(msg, info->snd_portid, info->snd_seq,
89da1ecf	104	&irda_nl_family, 0, IRDA_NL_CMD_GET_MODE);
07035fc1 JV	105	if (hdr == NULL) {
07035fc1 JV	106	ret = -EMSGSIZE;
89da1ecf SO	107	goto err_out;
	108	}
	109
	110	if(nla_put_string(msg, IRDA_NL_ATTR_IFNAME,
22117ea4	111	dev->name))
89da1ecf SO	112	goto err_out;
	113
	114	if(nla_put_u32(msg, IRDA_NL_ATTR_MODE, irlap->mode))
	115	goto err_out;
	116
	117	genlmsg_end(msg, hdr);
	118
134e6375	119	return genlmsg_reply(msg, info);
89da1ecf SO	120
	121	err_out:
	122	nlmsg_free(msg);
	123	dev_put(dev);
	124
	125	return ret;
	126	}
	127
b54452b0	128	static const struct nla_policy irda_nl_policy[IRDA_NL_ATTR_MAX + 1] = {
89da1ecf SO	129	[IRDA_NL_ATTR_IFNAME] = { .type = NLA_NUL_STRING,
	130	.len = IFNAMSIZ-1 },
	131	[IRDA_NL_ATTR_MODE] = { .type = NLA_U32 },
	132	};
	133
	134	static struct genl_ops irda_nl_ops[] = {
	135	{
	136	.cmd = IRDA_NL_CMD_SET_MODE,
	137	.doit = irda_nl_set_mode,
	138	.policy = irda_nl_policy,
	139	.flags = GENL_ADMIN_PERM,
	140	},
	141	{
	142	.cmd = IRDA_NL_CMD_GET_MODE,
	143	.doit = irda_nl_get_mode,
	144	.policy = irda_nl_policy,
	145	/* can be retrieved by unprivileged users */
	146	},
	147
	148	};
	149
	150	int irda_nl_register(void)
	151	{
502664ee MM	152	return genl_register_family_with_ops(&irda_nl_family,
502664ee MM	153	irda_nl_ops, ARRAY_SIZE(irda_nl_ops));
89da1ecf SO	154	}
	155
	156	void irda_nl_unregister(void)
	157	{
	158	genl_unregister_family(&irda_nl_family);
	159	}