[mirror_ubuntu-zesty-kernel.git] / net / netfilter / nf_sockopt.c

#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/skbuff.h>
#include <linux/netfilter.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 DECLARE_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 (down_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:
	up(&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:
	down(&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;
		up(&nf_sockopt_mutex);
		schedule();
		goto restart;
	}
	list_del(&reg->list);
	up(&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 (down_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++;
					up(&nf_sockopt_mutex);
					ret = ops->get(sk, val, opt, len);
					goto out;
				}
			} else {
				if (val >= ops->set_optmin
				    && val < ops->set_optmax) {
					ops->use++;
					up(&nf_sockopt_mutex);
					ret = ops->set(sk, val, opt, *len);
					goto out;
				}
			}
		}
	}
	up(&nf_sockopt_mutex);
	return -ENOPROTOOPT;
	
 out:
	down(&nf_sockopt_mutex);
	ops->use--;
	if (ops->cleanup_task)
		wake_up_process(ops->cleanup_task);
	up(&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);
Commit	Line	Data
f6ebe77f HW	1	#include <linux/config.h>
	2	#include <linux/kernel.h>
	3	#include <linux/init.h>
	4	#include <linux/module.h>
	5	#include <linux/skbuff.h>
	6	#include <linux/netfilter.h>
	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. */
	14	static DECLARE_MUTEX(nf_sockopt_mutex);
	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
	29	if (down_interruptible(&nf_sockopt_mutex) != 0)
	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:
	51	up(&nf_sockopt_mutex);
	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:
	60	down(&nf_sockopt_mutex);
	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;
66	up(&nf_sockopt_mutex);
67	schedule();
68	goto restart;
69	}
70	list_del(&reg->list);
71	up(&nf_sockopt_mutex);
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
83	if (down_interruptible(&nf_sockopt_mutex) != 0)
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++;
93	up(&nf_sockopt_mutex);
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++;
101	up(&nf_sockopt_mutex);
102	ret = ops->set(sk, val, opt, *len);
103	goto out;
104	}
105	}
106	}
107	}
108	up(&nf_sockopt_mutex);
109	return -ENOPROTOOPT;
110
111	out:
112	down(&nf_sockopt_mutex);
113	ops->use--;
114	if (ops->cleanup_task)
115	wake_up_process(ops->cleanup_task);
116	up(&nf_sockopt_mutex);
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