[linux.git] / net / netfilter / nf_sockopt.c

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/skbuff.h>
#include <linux/netfilter.h>
#include <linux/mutex.h>
#include <net/sock.h>

#include "nf_internals.h"

/* Sockopts only registered and called from user context, so
   net locking would be overkill.  Also, [gs]etsockopt calls may
   sleep. */
static DEFINE_MUTEX(nf_sockopt_mutex);
static LIST_HEAD(nf_sockopts);

/* Do exclusive ranges overlap? */
static inline int overlap(int min1, int max1, int min2, int max2)
{
	return max1 > min2 && min1 < max2;
}

/* Functions to register sockopt ranges (exclusive). */
int nf_register_sockopt(struct nf_sockopt_ops *reg)
{
	struct list_head *i;
	int ret = 0;

	if (mutex_lock_interruptible(&nf_sockopt_mutex) != 0)
		return -EINTR;

	list_for_each(i, &nf_sockopts) {
		struct nf_sockopt_ops *ops = (struct nf_sockopt_ops *)i;
		if (ops->pf == reg->pf
		    && (overlap(ops->set_optmin, ops->set_optmax, 
				reg->set_optmin, reg->set_optmax)
			|| overlap(ops->get_optmin, ops->get_optmax, 
				   reg->get_optmin, reg->get_optmax))) {
			NFDEBUG("nf_sock overlap: %u-%u/%u-%u v %u-%u/%u-%u\n",
				ops->set_optmin, ops->set_optmax, 
				ops->get_optmin, ops->get_optmax, 
				reg->set_optmin, reg->set_optmax,
				reg->get_optmin, reg->get_optmax);
			ret = -EBUSY;
			goto out;
		}
	}

	list_add(&reg->list, &nf_sockopts);
out:
	mutex_unlock(&nf_sockopt_mutex);
	return ret;
}
EXPORT_SYMBOL(nf_register_sockopt);

void nf_unregister_sockopt(struct nf_sockopt_ops *reg)
{
	/* No point being interruptible: we're probably in cleanup_module() */
 restart:
	mutex_lock(&nf_sockopt_mutex);
	if (reg->use != 0) {
		/* To be woken by nf_sockopt call... */
		/* FIXME: Stuart Young's name appears gratuitously. */
		set_current_state(TASK_UNINTERRUPTIBLE);
		reg->cleanup_task = current;
		mutex_unlock(&nf_sockopt_mutex);
		schedule();
		goto restart;
	}
	list_del(&reg->list);
	mutex_unlock(&nf_sockopt_mutex);
}
EXPORT_SYMBOL(nf_unregister_sockopt);

/* Call get/setsockopt() */
static int nf_sockopt(struct sock *sk, int pf, int val, 
		      char __user *opt, int *len, int get)
{
	struct list_head *i;
	struct nf_sockopt_ops *ops;
	int ret;

	if (mutex_lock_interruptible(&nf_sockopt_mutex) != 0)
		return -EINTR;

	list_for_each(i, &nf_sockopts) {
		ops = (struct nf_sockopt_ops *)i;
		if (ops->pf == pf) {
			if (get) {
				if (val >= ops->get_optmin
				    && val < ops->get_optmax) {
					ops->use++;
					mutex_unlock(&nf_sockopt_mutex);
					ret = ops->get(sk, val, opt, len);
					goto out;
				}
			} else {
				if (val >= ops->set_optmin
				    && val < ops->set_optmax) {
					ops->use++;
					mutex_unlock(&nf_sockopt_mutex);
					ret = ops->set(sk, val, opt, *len);
					goto out;
				}
			}
		}
	}
	mutex_unlock(&nf_sockopt_mutex);
	return -ENOPROTOOPT;
	
 out:
	mutex_lock(&nf_sockopt_mutex);
	ops->use--;
	if (ops->cleanup_task)
		wake_up_process(ops->cleanup_task);
	mutex_unlock(&nf_sockopt_mutex);
	return ret;
}

int nf_setsockopt(struct sock *sk, int pf, int val, char __user *opt,
		  int len)
{
	return nf_sockopt(sk, pf, val, opt, &len, 0);
}
EXPORT_SYMBOL(nf_setsockopt);

int nf_getsockopt(struct sock *sk, int pf, int val, char __user *opt, int *len)
{
	return nf_sockopt(sk, pf, val, opt, len, 1);
}
EXPORT_SYMBOL(nf_getsockopt);

#ifdef CONFIG_COMPAT
static int compat_nf_sockopt(struct sock *sk, int pf, int val,
			     char __user *opt, int *len, int get)
{
	struct list_head *i;
	struct nf_sockopt_ops *ops;
	int ret;

	if (mutex_lock_interruptible(&nf_sockopt_mutex) != 0)
		return -EINTR;

	list_for_each(i, &nf_sockopts) {
		ops = (struct nf_sockopt_ops *)i;
		if (ops->pf == pf) {
			if (get) {
				if (val >= ops->get_optmin
				    && val < ops->get_optmax) {
					ops->use++;
					mutex_unlock(&nf_sockopt_mutex);
					if (ops->compat_get)
						ret = ops->compat_get(sk,
							val, opt, len);
					else
						ret = ops->get(sk,
							val, opt, len);
					goto out;
				}
			} else {
				if (val >= ops->set_optmin
				    && val < ops->set_optmax) {
					ops->use++;
					mutex_unlock(&nf_sockopt_mutex);
					if (ops->compat_set)
						ret = ops->compat_set(sk,
							val, opt, *len);
					else
						ret = ops->set(sk,
							val, opt, *len);
					goto out;
				}
			}
		}
	}
	mutex_unlock(&nf_sockopt_mutex);
	return -ENOPROTOOPT;

 out:
	mutex_lock(&nf_sockopt_mutex);
	ops->use--;
	if (ops->cleanup_task)
		wake_up_process(ops->cleanup_task);
	mutex_unlock(&nf_sockopt_mutex);
	return ret;
}

int compat_nf_setsockopt(struct sock *sk, int pf,
		int val, char __user *opt, int len)
{
	return compat_nf_sockopt(sk, pf, val, opt, &len, 0);
}
EXPORT_SYMBOL(compat_nf_setsockopt);

int compat_nf_getsockopt(struct sock *sk, int pf,
		int val, char __user *opt, int *len)
{
	return compat_nf_sockopt(sk, pf, val, opt, len, 1);
}
EXPORT_SYMBOL(compat_nf_getsockopt);
#endif
Commit	Line	Data
f6ebe77f HW	1	#include <linux/kernel.h>
	2	#include <linux/init.h>
	3	#include <linux/module.h>
	4	#include <linux/skbuff.h>
	5	#include <linux/netfilter.h>
4a3e2f71	6	#include <linux/mutex.h>
f6ebe77f HW	7	#include <net/sock.h>
	8
	9	#include "nf_internals.h"
	10
	11	/* Sockopts only registered and called from user context, so
	12	net locking would be overkill. Also, [gs]etsockopt calls may
	13	sleep. */
4a3e2f71	14	static DEFINE_MUTEX(nf_sockopt_mutex);
f6ebe77f HW	15	static LIST_HEAD(nf_sockopts);
	16
	17	/* Do exclusive ranges overlap? */
	18	static inline int overlap(int min1, int max1, int min2, int max2)
	19	{
	20	return max1 > min2 && min1 < max2;
	21	}
	22
	23	/* Functions to register sockopt ranges (exclusive). */
	24	int nf_register_sockopt(struct nf_sockopt_ops *reg)
	25	{
	26	struct list_head *i;
	27	int ret = 0;
	28
4a3e2f71	29	if (mutex_lock_interruptible(&nf_sockopt_mutex) != 0)
f6ebe77f HW	30	return -EINTR;
	31
	32	list_for_each(i, &nf_sockopts) {
	33	struct nf_sockopt_ops ops = (struct nf_sockopt_ops )i;
	34	if (ops->pf == reg->pf
	35	&& (overlap(ops->set_optmin, ops->set_optmax,
	36	reg->set_optmin, reg->set_optmax)
	37	\|\| overlap(ops->get_optmin, ops->get_optmax,
	38	reg->get_optmin, reg->get_optmax))) {
	39	NFDEBUG("nf_sock overlap: %u-%u/%u-%u v %u-%u/%u-%u\n",
	40	ops->set_optmin, ops->set_optmax,
	41	ops->get_optmin, ops->get_optmax,
	42	reg->set_optmin, reg->set_optmax,
	43	reg->get_optmin, reg->get_optmax);
	44	ret = -EBUSY;
	45	goto out;
	46	}
	47	}
	48
	49	list_add(&reg->list, &nf_sockopts);
	50	out:
4a3e2f71	51	mutex_unlock(&nf_sockopt_mutex);
f6ebe77f HW	52	return ret;
	53	}
	54	EXPORT_SYMBOL(nf_register_sockopt);
	55
	56	void nf_unregister_sockopt(struct nf_sockopt_ops *reg)
	57	{
	58	/* No point being interruptible: we're probably in cleanup_module() */
	59	restart:
4a3e2f71	60	mutex_lock(&nf_sockopt_mutex);
f6ebe77f HW	61	if (reg->use != 0) {
	62	/* To be woken by nf_sockopt call... */
	63	/* FIXME: Stuart Young's name appears gratuitously. */
	64	set_current_state(TASK_UNINTERRUPTIBLE);
	65	reg->cleanup_task = current;
4a3e2f71	66	mutex_unlock(&nf_sockopt_mutex);
f6ebe77f HW	67	schedule();
	68	goto restart;
	69	}
	70	list_del(&reg->list);
4a3e2f71	71	mutex_unlock(&nf_sockopt_mutex);
f6ebe77f HW	72	}
	73	EXPORT_SYMBOL(nf_unregister_sockopt);
	74
	75	/* Call get/setsockopt() */
	76	static int nf_sockopt(struct sock *sk, int pf, int val,
	77	char __user opt, int len, int get)
	78	{
	79	struct list_head *i;
	80	struct nf_sockopt_ops *ops;
	81	int ret;
	82
4a3e2f71	83	if (mutex_lock_interruptible(&nf_sockopt_mutex) != 0)
f6ebe77f HW	84	return -EINTR;
	85
	86	list_for_each(i, &nf_sockopts) {
	87	ops = (struct nf_sockopt_ops *)i;
	88	if (ops->pf == pf) {
	89	if (get) {
	90	if (val >= ops->get_optmin
	91	&& val < ops->get_optmax) {
	92	ops->use++;
4a3e2f71	93	mutex_unlock(&nf_sockopt_mutex);
f6ebe77f HW	94	ret = ops->get(sk, val, opt, len);
	95	goto out;
	96	}
	97	} else {
	98	if (val >= ops->set_optmin
	99	&& val < ops->set_optmax) {
	100	ops->use++;
4a3e2f71	101	mutex_unlock(&nf_sockopt_mutex);
f6ebe77f HW	102	ret = ops->set(sk, val, opt, *len);
	103	goto out;
	104	}
	105	}
	106	}
	107	}
4a3e2f71	108	mutex_unlock(&nf_sockopt_mutex);
f6ebe77f HW	109	return -ENOPROTOOPT;
	110
	111	out:
4a3e2f71	112	mutex_lock(&nf_sockopt_mutex);
f6ebe77f HW	113	ops->use--;
	114	if (ops->cleanup_task)
	115	wake_up_process(ops->cleanup_task);
4a3e2f71	116	mutex_unlock(&nf_sockopt_mutex);
f6ebe77f HW	117	return ret;
	118	}
	119
	120	int nf_setsockopt(struct sock sk, int pf, int val, char __user opt,
	121	int len)
	122	{
	123	return nf_sockopt(sk, pf, val, opt, &len, 0);
	124	}
	125	EXPORT_SYMBOL(nf_setsockopt);
	126
	127	int nf_getsockopt(struct sock sk, int pf, int val, char __user opt, int *len)
	128	{
	129	return nf_sockopt(sk, pf, val, opt, len, 1);
	130	}
	131	EXPORT_SYMBOL(nf_getsockopt);
	132
3fdadf7d DM	133	#ifdef CONFIG_COMPAT
3fdadf7d DM	134	static int compat_nf_sockopt(struct sock *sk, int pf, int val,
543d9cfe	135	char __user opt, int len, int get)
3fdadf7d DM	136	{
	137	struct list_head *i;
	138	struct nf_sockopt_ops *ops;
	139	int ret;
	140
	141	if (mutex_lock_interruptible(&nf_sockopt_mutex) != 0)
	142	return -EINTR;
	143
	144	list_for_each(i, &nf_sockopts) {
	145	ops = (struct nf_sockopt_ops *)i;
	146	if (ops->pf == pf) {
	147	if (get) {
	148	if (val >= ops->get_optmin
	149	&& val < ops->get_optmax) {
	150	ops->use++;
	151	mutex_unlock(&nf_sockopt_mutex);
	152	if (ops->compat_get)
	153	ret = ops->compat_get(sk,
	154	val, opt, len);
	155	else
	156	ret = ops->get(sk,
	157	val, opt, len);
	158	goto out;
	159	}
	160	} else {
	161	if (val >= ops->set_optmin
	162	&& val < ops->set_optmax) {
	163	ops->use++;
	164	mutex_unlock(&nf_sockopt_mutex);
	165	if (ops->compat_set)
	166	ret = ops->compat_set(sk,
	167	val, opt, *len);
	168	else
	169	ret = ops->set(sk,
	170	val, opt, *len);
	171	goto out;
	172	}
	173	}
	174	}
	175	}
	176	mutex_unlock(&nf_sockopt_mutex);
	177	return -ENOPROTOOPT;
	178
	179	out:
	180	mutex_lock(&nf_sockopt_mutex);
	181	ops->use--;
	182	if (ops->cleanup_task)
	183	wake_up_process(ops->cleanup_task);
	184	mutex_unlock(&nf_sockopt_mutex);
	185	return ret;
	186	}
	187
	188	int compat_nf_setsockopt(struct sock *sk, int pf,
	189	int val, char __user *opt, int len)
	190	{
	191	return compat_nf_sockopt(sk, pf, val, opt, &len, 0);
	192	}
	193	EXPORT_SYMBOL(compat_nf_setsockopt);
	194
	195	int compat_nf_getsockopt(struct sock *sk, int pf,
	196	int val, char __user opt, int len)
	197	{
	198	return compat_nf_sockopt(sk, pf, val, opt, len, 1);
	199	}
200	EXPORT_SYMBOL(compat_nf_getsockopt);
201	#endif