[linux-2.6-block.git] / net / wireless / wext-priv.c

/*
 * This file implement the Wireless Extensions priv API.
 *
 * Authors :	Jean Tourrilhes - HPL - <jt@hpl.hp.com>
 * Copyright (c) 1997-2007 Jean Tourrilhes, All Rights Reserved.
 * Copyright	2009 Johannes Berg <johannes@sipsolutions.net>
 *
 * (As all part of the Linux kernel, this file is GPL)
 */
#include <linux/wireless.h>
#include <linux/netdevice.h>
#include <net/iw_handler.h>
#include <net/wext.h>

int iw_handler_get_private(struct net_device *		dev,
			   struct iw_request_info *	info,
			   union iwreq_data *		wrqu,
			   char *			extra)
{
	/* Check if the driver has something to export */
	if ((dev->wireless_handlers->num_private_args == 0) ||
	   (dev->wireless_handlers->private_args == NULL))
		return -EOPNOTSUPP;

	/* Check if there is enough buffer up there */
	if (wrqu->data.length < dev->wireless_handlers->num_private_args) {
		/* User space can't know in advance how large the buffer
		 * needs to be. Give it a hint, so that we can support
		 * any size buffer we want somewhat efficiently... */
		wrqu->data.length = dev->wireless_handlers->num_private_args;
		return -E2BIG;
	}

	/* Set the number of available ioctls. */
	wrqu->data.length = dev->wireless_handlers->num_private_args;

	/* Copy structure to the user buffer. */
	memcpy(extra, dev->wireless_handlers->private_args,
	       sizeof(struct iw_priv_args) * wrqu->data.length);

	return 0;
}

/* Size (in bytes) of the various private data types */
static const char iw_priv_type_size[] = {
	0,				/* IW_PRIV_TYPE_NONE */
	1,				/* IW_PRIV_TYPE_BYTE */
	1,				/* IW_PRIV_TYPE_CHAR */
	0,				/* Not defined */
	sizeof(__u32),			/* IW_PRIV_TYPE_INT */
	sizeof(struct iw_freq),		/* IW_PRIV_TYPE_FLOAT */
	sizeof(struct sockaddr),	/* IW_PRIV_TYPE_ADDR */
	0,				/* Not defined */
};

static int get_priv_size(__u16 args)
{
	int	num = args & IW_PRIV_SIZE_MASK;
	int	type = (args & IW_PRIV_TYPE_MASK) >> 12;

	return num * iw_priv_type_size[type];
}

static int adjust_priv_size(__u16 args, struct iw_point *iwp)
{
	int	num = iwp->length;
	int	max = args & IW_PRIV_SIZE_MASK;
	int	type = (args & IW_PRIV_TYPE_MASK) >> 12;

	/* Make sure the driver doesn't goof up */
	if (max < num)
		num = max;

	return num * iw_priv_type_size[type];
}

/*
 * Wrapper to call a private Wireless Extension handler.
 * We do various checks and also take care of moving data between
 * user space and kernel space.
 * It's not as nice and slimline as the standard wrapper. The cause
 * is struct iw_priv_args, which was not really designed for the
 * job we are going here.
 *
 * IMPORTANT : This function prevent to set and get data on the same
 * IOCTL and enforce the SET/GET convention. Not doing it would be
 * far too hairy...
 * If you need to set and get data at the same time, please don't use
 * a iw_handler but process it in your ioctl handler (i.e. use the
 * old driver API).
 */
static int get_priv_descr_and_size(struct net_device *dev, unsigned int cmd,
				   const struct iw_priv_args **descrp)
{
	const struct iw_priv_args *descr;
	int i, extra_size;

	descr = NULL;
	for (i = 0; i < dev->wireless_handlers->num_private_args; i++) {
		if (cmd == dev->wireless_handlers->private_args[i].cmd) {
			descr = &dev->wireless_handlers->private_args[i];
			break;
		}
	}

	extra_size = 0;
	if (descr) {
		if (IW_IS_SET(cmd)) {
			int	offset = 0;	/* For sub-ioctls */
			/* Check for sub-ioctl handler */
			if (descr->name[0] == '\0')
				/* Reserve one int for sub-ioctl index */
				offset = sizeof(__u32);

			/* Size of set arguments */
			extra_size = get_priv_size(descr->set_args);

			/* Does it fits in iwr ? */
			if ((descr->set_args & IW_PRIV_SIZE_FIXED) &&
			   ((extra_size + offset) <= IFNAMSIZ))
				extra_size = 0;
		} else {
			/* Size of get arguments */
			extra_size = get_priv_size(descr->get_args);

			/* Does it fits in iwr ? */
			if ((descr->get_args & IW_PRIV_SIZE_FIXED) &&
			   (extra_size <= IFNAMSIZ))
				extra_size = 0;
		}
	}
	*descrp = descr;
	return extra_size;
}

static int ioctl_private_iw_point(struct iw_point *iwp, unsigned int cmd,
				  const struct iw_priv_args *descr,
				  iw_handler handler, struct net_device *dev,
				  struct iw_request_info *info, int extra_size)
{
	char *extra;
	int err;

	/* Check what user space is giving us */
	if (IW_IS_SET(cmd)) {
		if (!iwp->pointer && iwp->length != 0)
			return -EFAULT;

		if (iwp->length > (descr->set_args & IW_PRIV_SIZE_MASK))
			return -E2BIG;
	} else if (!iwp->pointer)
		return -EFAULT;

	extra = kmalloc(extra_size, GFP_KERNEL);
	if (!extra)
		return -ENOMEM;

	/* If it is a SET, get all the extra data in here */
	if (IW_IS_SET(cmd) && (iwp->length != 0)) {
		if (copy_from_user(extra, iwp->pointer, extra_size)) {
			err = -EFAULT;
			goto out;
		}
	}

	/* Call the handler */
	err = handler(dev, info, (union iwreq_data *) iwp, extra);

	/* If we have something to return to the user */
	if (!err && IW_IS_GET(cmd)) {
		/* Adjust for the actual length if it's variable,
		 * avoid leaking kernel bits outside.
		 */
		if (!(descr->get_args & IW_PRIV_SIZE_FIXED))
			extra_size = adjust_priv_size(descr->get_args, iwp);

		if (copy_to_user(iwp->pointer, extra, extra_size))
			err =  -EFAULT;
	}

out:
	kfree(extra);
	return err;
}

int ioctl_private_call(struct net_device *dev, struct iwreq *iwr,
		       unsigned int cmd, struct iw_request_info *info,
		       iw_handler handler)
{
	int extra_size = 0, ret = -EINVAL;
	const struct iw_priv_args *descr;

	extra_size = get_priv_descr_and_size(dev, cmd, &descr);

	/* Check if we have a pointer to user space data or not. */
	if (extra_size == 0) {
		/* No extra arguments. Trivial to handle */
		ret = handler(dev, info, &(iwr->u), (char *) &(iwr->u));
	} else {
		ret = ioctl_private_iw_point(&iwr->u.data, cmd, descr,
					     handler, dev, info, extra_size);
	}

	/* Call commit handler if needed and defined */
	if (ret == -EIWCOMMIT)
		ret = call_commit_handler(dev);

	return ret;
}

#ifdef CONFIG_COMPAT
int compat_private_call(struct net_device *dev, struct iwreq *iwr,
			unsigned int cmd, struct iw_request_info *info,
			iw_handler handler)
{
	const struct iw_priv_args *descr;
	int ret, extra_size;

	extra_size = get_priv_descr_and_size(dev, cmd, &descr);

	/* Check if we have a pointer to user space data or not. */
	if (extra_size == 0) {
		/* No extra arguments. Trivial to handle */
		ret = handler(dev, info, &(iwr->u), (char *) &(iwr->u));
	} else {
		struct compat_iw_point *iwp_compat;
		struct iw_point iwp;

		iwp_compat = (struct compat_iw_point *) &iwr->u.data;
		iwp.pointer = compat_ptr(iwp_compat->pointer);
		iwp.length = iwp_compat->length;
		iwp.flags = iwp_compat->flags;

		ret = ioctl_private_iw_point(&iwp, cmd, descr,
					     handler, dev, info, extra_size);

		iwp_compat->pointer = ptr_to_compat(iwp.pointer);
		iwp_compat->length = iwp.length;
		iwp_compat->flags = iwp.flags;
	}

	/* Call commit handler if needed and defined */
	if (ret == -EIWCOMMIT)
		ret = call_commit_handler(dev);

	return ret;
}
#endif
Commit	Line	Data
3d23e349 JB	1	/*
	2	* This file implement the Wireless Extensions priv API.
	3	*
	4	* Authors : Jean Tourrilhes - HPL - <jt@hpl.hp.com>
	5	* Copyright (c) 1997-2007 Jean Tourrilhes, All Rights Reserved.
	6	* Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
	7	*
	8	* (As all part of the Linux kernel, this file is GPL)
	9	*/
	10	#include <linux/wireless.h>
	11	#include <linux/netdevice.h>
	12	#include <net/iw_handler.h>
	13	#include <net/wext.h>
	14
	15	int iw_handler_get_private(struct net_device * dev,
	16	struct iw_request_info * info,
	17	union iwreq_data * wrqu,
	18	char * extra)
	19	{
	20	/* Check if the driver has something to export */
	21	if ((dev->wireless_handlers->num_private_args == 0) \|\|
	22	(dev->wireless_handlers->private_args == NULL))
	23	return -EOPNOTSUPP;
	24
	25	/* Check if there is enough buffer up there */
	26	if (wrqu->data.length < dev->wireless_handlers->num_private_args) {
	27	/* User space can't know in advance how large the buffer
	28	* needs to be. Give it a hint, so that we can support
	29	* any size buffer we want somewhat efficiently... */
	30	wrqu->data.length = dev->wireless_handlers->num_private_args;
	31	return -E2BIG;
	32	}
	33
	34	/* Set the number of available ioctls. */
	35	wrqu->data.length = dev->wireless_handlers->num_private_args;
	36
	37	/* Copy structure to the user buffer. */
	38	memcpy(extra, dev->wireless_handlers->private_args,
	39	sizeof(struct iw_priv_args) * wrqu->data.length);
	40
	41	return 0;
	42	}
	43
	44	/* Size (in bytes) of the various private data types */
	45	static const char iw_priv_type_size[] = {
	46	0, /* IW_PRIV_TYPE_NONE */
	47	1, /* IW_PRIV_TYPE_BYTE */
	48	1, /* IW_PRIV_TYPE_CHAR */
	49	0, /* Not defined */
	50	sizeof(__u32), /* IW_PRIV_TYPE_INT */
	51	sizeof(struct iw_freq), /* IW_PRIV_TYPE_FLOAT */
	52	sizeof(struct sockaddr), /* IW_PRIV_TYPE_ADDR */
	53	0, /* Not defined */
	54	};
	55
	56	static int get_priv_size(__u16 args)
	57	{
	58	int num = args & IW_PRIV_SIZE_MASK;
	59	int type = (args & IW_PRIV_TYPE_MASK) >> 12;
	60
	61	return num * iw_priv_type_size[type];
	62	}
	63
	64	static int adjust_priv_size(__u16 args, struct iw_point *iwp)
65	{
66	int num = iwp->length;
67	int max = args & IW_PRIV_SIZE_MASK;
68	int type = (args & IW_PRIV_TYPE_MASK) >> 12;
69
70	/* Make sure the driver doesn't goof up */
71	if (max < num)
72	num = max;
73
74	return num * iw_priv_type_size[type];
75	}
76
77	/*
78	* Wrapper to call a private Wireless Extension handler.
79	* We do various checks and also take care of moving data between
80	* user space and kernel space.
81	* It's not as nice and slimline as the standard wrapper. The cause
82	* is struct iw_priv_args, which was not really designed for the
83	* job we are going here.
84	*
85	* IMPORTANT : This function prevent to set and get data on the same
86	* IOCTL and enforce the SET/GET convention. Not doing it would be
87	* far too hairy...
88	* If you need to set and get data at the same time, please don't use
89	* a iw_handler but process it in your ioctl handler (i.e. use the
90	* old driver API).
91	*/
92	static int get_priv_descr_and_size(struct net_device *dev, unsigned int cmd,
93	const struct iw_priv_args **descrp)
94	{
95	const struct iw_priv_args *descr;
96	int i, extra_size;
97
98	descr = NULL;
99	for (i = 0; i < dev->wireless_handlers->num_private_args; i++) {
100	if (cmd == dev->wireless_handlers->private_args[i].cmd) {
101	descr = &dev->wireless_handlers->private_args[i];
102	break;
103	}
104	}
105
106	extra_size = 0;
107	if (descr) {
108	if (IW_IS_SET(cmd)) {
109	int offset = 0; /* For sub-ioctls */
110	/* Check for sub-ioctl handler */
111	if (descr->name[0] == '\0')
112	/* Reserve one int for sub-ioctl index */
113	offset = sizeof(__u32);
114
115	/* Size of set arguments */
116	extra_size = get_priv_size(descr->set_args);
117
118	/* Does it fits in iwr ? */
119	if ((descr->set_args & IW_PRIV_SIZE_FIXED) &&
120	((extra_size + offset) <= IFNAMSIZ))
121	extra_size = 0;
122	} else {
123	/* Size of get arguments */
124	extra_size = get_priv_size(descr->get_args);
125
126	/* Does it fits in iwr ? */
127	if ((descr->get_args & IW_PRIV_SIZE_FIXED) &&
128	(extra_size <= IFNAMSIZ))
129	extra_size = 0;
130	}
131	}
132	*descrp = descr;
133	return extra_size;
134	}
135
136	static int ioctl_private_iw_point(struct iw_point *iwp, unsigned int cmd,
137	const struct iw_priv_args *descr,
138	iw_handler handler, struct net_device *dev,
139	struct iw_request_info *info, int extra_size)
140	{
141	char *extra;
142	int err;
143
144	/* Check what user space is giving us */
145	if (IW_IS_SET(cmd)) {
146	if (!iwp->pointer && iwp->length != 0)
147	return -EFAULT;
148
149	if (iwp->length > (descr->set_args & IW_PRIV_SIZE_MASK))
150	return -E2BIG;
151	} else if (!iwp->pointer)
152	return -EFAULT;
153
154	extra = kmalloc(extra_size, GFP_KERNEL);
155	if (!extra)
156	return -ENOMEM;
157
158	/* If it is a SET, get all the extra data in here */
159	if (IW_IS_SET(cmd) && (iwp->length != 0)) {
160	if (copy_from_user(extra, iwp->pointer, extra_size)) {
161	err = -EFAULT;
162	goto out;
163	}
164	}
165
166	/* Call the handler */
167	err = handler(dev, info, (union iwreq_data *) iwp, extra);
168
169	/* If we have something to return to the user */
170	if (!err && IW_IS_GET(cmd)) {
171	/* Adjust for the actual length if it's variable,
172	* avoid leaking kernel bits outside.
173	*/
174	if (!(descr->get_args & IW_PRIV_SIZE_FIXED))
175	extra_size = adjust_priv_size(descr->get_args, iwp);
176
177	if (copy_to_user(iwp->pointer, extra, extra_size))
178	err = -EFAULT;
179	}
180
181	out:
182	kfree(extra);
183	return err;
184	}
185
186	int ioctl_private_call(struct net_device dev, struct iwreq iwr,
187	unsigned int cmd, struct iw_request_info *info,
188	iw_handler handler)
189	{
190	int extra_size = 0, ret = -EINVAL;
191	const struct iw_priv_args *descr;
192
193	extra_size = get_priv_descr_and_size(dev, cmd, &descr);
194
195	/* Check if we have a pointer to user space data or not. */
196	if (extra_size == 0) {
197	/* No extra arguments. Trivial to handle */
198	ret = handler(dev, info, &(iwr->u), (char *) &(iwr->u));
199	} else {
200	ret = ioctl_private_iw_point(&iwr->u.data, cmd, descr,
201	handler, dev, info, extra_size);
202	}
203
204	/* Call commit handler if needed and defined */
205	if (ret == -EIWCOMMIT)
206	ret = call_commit_handler(dev);
207
208	return ret;
209	}
210
211	#ifdef CONFIG_COMPAT
212	int compat_private_call(struct net_device dev, struct iwreq iwr,
213	unsigned int cmd, struct iw_request_info *info,
214	iw_handler handler)
215	{
216	const struct iw_priv_args *descr;
217	int ret, extra_size;
218
219	extra_size = get_priv_descr_and_size(dev, cmd, &descr);
220
221	/* Check if we have a pointer to user space data or not. */
222	if (extra_size == 0) {
223	/* No extra arguments. Trivial to handle */
224	ret = handler(dev, info, &(iwr->u), (char *) &(iwr->u));
225	} else {
226	struct compat_iw_point *iwp_compat;
227	struct iw_point iwp;
228
229	iwp_compat = (struct compat_iw_point *) &iwr->u.data;
230	iwp.pointer = compat_ptr(iwp_compat->pointer);
231	iwp.length = iwp_compat->length;
232	iwp.flags = iwp_compat->flags;
233
234	ret = ioctl_private_iw_point(&iwp, cmd, descr,
235	handler, dev, info, extra_size);
236
237	iwp_compat->pointer = ptr_to_compat(iwp.pointer);
238	iwp_compat->length = iwp.length;
239	iwp_compat->flags = iwp.flags;
240	}
241
242	/* Call commit handler if needed and defined */
243	if (ret == -EIWCOMMIT)
244	ret = call_commit_handler(dev);
245
246	return ret;
247	}
248	#endif