[linux-2.6-block.git] / net / netfilter / ipvs / ip_vs_app.c

/*
 * ip_vs_app.c: Application module support for IPVS
 *
 * Authors:     Wensong Zhang <wensong@linuxvirtualserver.org>
 *
 *              This program is free software; you can redistribute it and/or
 *              modify it under the terms of the GNU General Public License
 *              as published by the Free Software Foundation; either version
 *              2 of the License, or (at your option) any later version.
 *
 * Most code here is taken from ip_masq_app.c in kernel 2.2. The difference
 * is that ip_vs_app module handles the reverse direction (incoming requests
 * and outgoing responses).
 *
 *		IP_MASQ_APP application masquerading module
 *
 * Author:	Juan Jose Ciarlante, <jjciarla@raiz.uncu.edu.ar>
 *
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/skbuff.h>
#include <linux/in.h>
#include <linux/ip.h>
#include <linux/netfilter.h>
#include <net/net_namespace.h>
#include <net/protocol.h>
#include <net/tcp.h>
#include <asm/system.h>
#include <linux/stat.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
#include <linux/mutex.h>

#include <net/ip_vs.h>

EXPORT_SYMBOL(register_ip_vs_app);
EXPORT_SYMBOL(unregister_ip_vs_app);
EXPORT_SYMBOL(register_ip_vs_app_inc);

/* ipvs application list head */
static LIST_HEAD(ip_vs_app_list);
static DEFINE_MUTEX(__ip_vs_app_mutex);


/*
 *	Get an ip_vs_app object
 */
static inline int ip_vs_app_get(struct ip_vs_app *app)
{
	return try_module_get(app->module);
}


static inline void ip_vs_app_put(struct ip_vs_app *app)
{
	module_put(app->module);
}


/*
 *	Allocate/initialize app incarnation and register it in proto apps.
 */
static int
ip_vs_app_inc_new(struct ip_vs_app *app, __u16 proto, __u16 port)
{
	struct ip_vs_protocol *pp;
	struct ip_vs_app *inc;
	int ret;

	if (!(pp = ip_vs_proto_get(proto)))
		return -EPROTONOSUPPORT;

	if (!pp->unregister_app)
		return -EOPNOTSUPP;

	inc = kmemdup(app, sizeof(*inc), GFP_KERNEL);
	if (!inc)
		return -ENOMEM;
	INIT_LIST_HEAD(&inc->p_list);
	INIT_LIST_HEAD(&inc->incs_list);
	inc->app = app;
	inc->port = htons(port);
	atomic_set(&inc->usecnt, 0);

	if (app->timeouts) {
		inc->timeout_table =
			ip_vs_create_timeout_table(app->timeouts,
						   app->timeouts_size);
		if (!inc->timeout_table) {
			ret = -ENOMEM;
			goto out;
		}
	}

	ret = pp->register_app(inc);
	if (ret)
		goto out;

	list_add(&inc->a_list, &app->incs_list);
	IP_VS_DBG(9, "%s application %s:%u registered\n",
		  pp->name, inc->name, inc->port);

	return 0;

  out:
	kfree(inc->timeout_table);
	kfree(inc);
	return ret;
}


/*
 *	Release app incarnation
 */
static void
ip_vs_app_inc_release(struct ip_vs_app *inc)
{
	struct ip_vs_protocol *pp;

	if (!(pp = ip_vs_proto_get(inc->protocol)))
		return;

	if (pp->unregister_app)
		pp->unregister_app(inc);

	IP_VS_DBG(9, "%s App %s:%u unregistered\n",
		  pp->name, inc->name, inc->port);

	list_del(&inc->a_list);

	kfree(inc->timeout_table);
	kfree(inc);
}


/*
 *	Get reference to app inc (only called from softirq)
 *
 */
int ip_vs_app_inc_get(struct ip_vs_app *inc)
{
	int result;

	atomic_inc(&inc->usecnt);
	if (unlikely((result = ip_vs_app_get(inc->app)) != 1))
		atomic_dec(&inc->usecnt);
	return result;
}


/*
 *	Put the app inc (only called from timer or net softirq)
 */
void ip_vs_app_inc_put(struct ip_vs_app *inc)
{
	ip_vs_app_put(inc->app);
	atomic_dec(&inc->usecnt);
}


/*
 *	Register an application incarnation in protocol applications
 */
int
register_ip_vs_app_inc(struct ip_vs_app *app, __u16 proto, __u16 port)
{
	int result;

	mutex_lock(&__ip_vs_app_mutex);

	result = ip_vs_app_inc_new(app, proto, port);

	mutex_unlock(&__ip_vs_app_mutex);

	return result;
}


/*
 *	ip_vs_app registration routine
 */
int register_ip_vs_app(struct ip_vs_app *app)
{
	/* increase the module use count */
	ip_vs_use_count_inc();

	mutex_lock(&__ip_vs_app_mutex);

	list_add(&app->a_list, &ip_vs_app_list);

	mutex_unlock(&__ip_vs_app_mutex);

	return 0;
}


/*
 *	ip_vs_app unregistration routine
 *	We are sure there are no app incarnations attached to services
 */
void unregister_ip_vs_app(struct ip_vs_app *app)
{
	struct ip_vs_app *inc, *nxt;

	mutex_lock(&__ip_vs_app_mutex);

	list_for_each_entry_safe(inc, nxt, &app->incs_list, a_list) {
		ip_vs_app_inc_release(inc);
	}

	list_del(&app->a_list);

	mutex_unlock(&__ip_vs_app_mutex);

	/* decrease the module use count */
	ip_vs_use_count_dec();
}


/*
 *	Bind ip_vs_conn to its ip_vs_app (called by cp constructor)
 */
int ip_vs_bind_app(struct ip_vs_conn *cp, struct ip_vs_protocol *pp)
{
	return pp->app_conn_bind(cp);
}


/*
 *	Unbind cp from application incarnation (called by cp destructor)
 */
void ip_vs_unbind_app(struct ip_vs_conn *cp)
{
	struct ip_vs_app *inc = cp->app;

	if (!inc)
		return;

	if (inc->unbind_conn)
		inc->unbind_conn(inc, cp);
	if (inc->done_conn)
		inc->done_conn(inc, cp);
	ip_vs_app_inc_put(inc);
	cp->app = NULL;
}


/*
 *	Fixes th->seq based on ip_vs_seq info.
 */
static inline void vs_fix_seq(const struct ip_vs_seq *vseq, struct tcphdr *th)
{
	__u32 seq = ntohl(th->seq);

	/*
	 *	Adjust seq with delta-offset for all packets after
	 *	the most recent resized pkt seq and with previous_delta offset
	 *	for all packets	before most recent resized pkt seq.
	 */
	if (vseq->delta || vseq->previous_delta) {
		if(after(seq, vseq->init_seq)) {
			th->seq = htonl(seq + vseq->delta);
			IP_VS_DBG(9, "vs_fix_seq(): added delta (%d) to seq\n",
				  vseq->delta);
		} else {
			th->seq = htonl(seq + vseq->previous_delta);
			IP_VS_DBG(9, "vs_fix_seq(): added previous_delta "
				  "(%d) to seq\n", vseq->previous_delta);
		}
	}
}


/*
 *	Fixes th->ack_seq based on ip_vs_seq info.
 */
static inline void
vs_fix_ack_seq(const struct ip_vs_seq *vseq, struct tcphdr *th)
{
	__u32 ack_seq = ntohl(th->ack_seq);

	/*
	 * Adjust ack_seq with delta-offset for
	 * the packets AFTER most recent resized pkt has caused a shift
	 * for packets before most recent resized pkt, use previous_delta
	 */
	if (vseq->delta || vseq->previous_delta) {
		/* since ack_seq is the number of octet that is expected
		   to receive next, so compare it with init_seq+delta */
		if(after(ack_seq, vseq->init_seq+vseq->delta)) {
			th->ack_seq = htonl(ack_seq - vseq->delta);
			IP_VS_DBG(9, "vs_fix_ack_seq(): subtracted delta "
				  "(%d) from ack_seq\n", vseq->delta);

		} else {
			th->ack_seq = htonl(ack_seq - vseq->previous_delta);
			IP_VS_DBG(9, "vs_fix_ack_seq(): subtracted "
				  "previous_delta (%d) from ack_seq\n",
				  vseq->previous_delta);
		}
	}
}


/*
 *	Updates ip_vs_seq if pkt has been resized
 *	Assumes already checked proto==IPPROTO_TCP and diff!=0.
 */
static inline void vs_seq_update(struct ip_vs_conn *cp, struct ip_vs_seq *vseq,
				 unsigned flag, __u32 seq, int diff)
{
	/* spinlock is to keep updating cp->flags atomic */
	spin_lock(&cp->lock);
	if (!(cp->flags & flag) || after(seq, vseq->init_seq)) {
		vseq->previous_delta = vseq->delta;
		vseq->delta += diff;
		vseq->init_seq = seq;
		cp->flags |= flag;
	}
	spin_unlock(&cp->lock);
}

static inline int app_tcp_pkt_out(struct ip_vs_conn *cp, struct sk_buff *skb,
				  struct ip_vs_app *app)
{
	int diff;
	const unsigned int tcp_offset = ip_hdrlen(skb);
	struct tcphdr *th;
	__u32 seq;

	if (!skb_make_writable(skb, tcp_offset + sizeof(*th)))
		return 0;

	th = (struct tcphdr *)(skb_network_header(skb) + tcp_offset);

	/*
	 *	Remember seq number in case this pkt gets resized
	 */
	seq = ntohl(th->seq);

	/*
	 *	Fix seq stuff if flagged as so.
	 */
	if (cp->flags & IP_VS_CONN_F_OUT_SEQ)
		vs_fix_seq(&cp->out_seq, th);
	if (cp->flags & IP_VS_CONN_F_IN_SEQ)
		vs_fix_ack_seq(&cp->in_seq, th);

	/*
	 *	Call private output hook function
	 */
	if (app->pkt_out == NULL)
		return 1;

	if (!app->pkt_out(app, cp, skb, &diff))
		return 0;

	/*
	 *	Update ip_vs seq stuff if len has changed.
	 */
	if (diff != 0)
		vs_seq_update(cp, &cp->out_seq,
			      IP_VS_CONN_F_OUT_SEQ, seq, diff);

	return 1;
}

/*
 *	Output pkt hook. Will call bound ip_vs_app specific function
 *	called by ipvs packet handler, assumes previously checked cp!=NULL
 *	returns false if it can't handle packet (oom)
 */
int ip_vs_app_pkt_out(struct ip_vs_conn *cp, struct sk_buff *skb)
{
	struct ip_vs_app *app;

	/*
	 *	check if application module is bound to
	 *	this ip_vs_conn.
	 */
	if ((app = cp->app) == NULL)
		return 1;

	/* TCP is complicated */
	if (cp->protocol == IPPROTO_TCP)
		return app_tcp_pkt_out(cp, skb, app);

	/*
	 *	Call private output hook function
	 */
	if (app->pkt_out == NULL)
		return 1;

	return app->pkt_out(app, cp, skb, NULL);
}


static inline int app_tcp_pkt_in(struct ip_vs_conn *cp, struct sk_buff *skb,
				 struct ip_vs_app *app)
{
	int diff;
	const unsigned int tcp_offset = ip_hdrlen(skb);
	struct tcphdr *th;
	__u32 seq;

	if (!skb_make_writable(skb, tcp_offset + sizeof(*th)))
		return 0;

	th = (struct tcphdr *)(skb_network_header(skb) + tcp_offset);

	/*
	 *	Remember seq number in case this pkt gets resized
	 */
	seq = ntohl(th->seq);

	/*
	 *	Fix seq stuff if flagged as so.
	 */
	if (cp->flags & IP_VS_CONN_F_IN_SEQ)
		vs_fix_seq(&cp->in_seq, th);
	if (cp->flags & IP_VS_CONN_F_OUT_SEQ)
		vs_fix_ack_seq(&cp->out_seq, th);

	/*
	 *	Call private input hook function
	 */
	if (app->pkt_in == NULL)
		return 1;

	if (!app->pkt_in(app, cp, skb, &diff))
		return 0;

	/*
	 *	Update ip_vs seq stuff if len has changed.
	 */
	if (diff != 0)
		vs_seq_update(cp, &cp->in_seq,
			      IP_VS_CONN_F_IN_SEQ, seq, diff);

	return 1;
}

/*
 *	Input pkt hook. Will call bound ip_vs_app specific function
 *	called by ipvs packet handler, assumes previously checked cp!=NULL.
 *	returns false if can't handle packet (oom).
 */
int ip_vs_app_pkt_in(struct ip_vs_conn *cp, struct sk_buff *skb)
{
	struct ip_vs_app *app;

	/*
	 *	check if application module is bound to
	 *	this ip_vs_conn.
	 */
	if ((app = cp->app) == NULL)
		return 1;

	/* TCP is complicated */
	if (cp->protocol == IPPROTO_TCP)
		return app_tcp_pkt_in(cp, skb, app);

	/*
	 *	Call private input hook function
	 */
	if (app->pkt_in == NULL)
		return 1;

	return app->pkt_in(app, cp, skb, NULL);
}


#ifdef CONFIG_PROC_FS
/*
 *	/proc/net/ip_vs_app entry function
 */

static struct ip_vs_app *ip_vs_app_idx(loff_t pos)
{
	struct ip_vs_app *app, *inc;

	list_for_each_entry(app, &ip_vs_app_list, a_list) {
		list_for_each_entry(inc, &app->incs_list, a_list) {
			if (pos-- == 0)
				return inc;
		}
	}
	return NULL;

}

static void *ip_vs_app_seq_start(struct seq_file *seq, loff_t *pos)
{
	mutex_lock(&__ip_vs_app_mutex);

	return *pos ? ip_vs_app_idx(*pos - 1) : SEQ_START_TOKEN;
}

static void *ip_vs_app_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
	struct ip_vs_app *inc, *app;
	struct list_head *e;

	++*pos;
	if (v == SEQ_START_TOKEN)
		return ip_vs_app_idx(0);

	inc = v;
	app = inc->app;

	if ((e = inc->a_list.next) != &app->incs_list)
		return list_entry(e, struct ip_vs_app, a_list);

	/* go on to next application */
	for (e = app->a_list.next; e != &ip_vs_app_list; e = e->next) {
		app = list_entry(e, struct ip_vs_app, a_list);
		list_for_each_entry(inc, &app->incs_list, a_list) {
			return inc;
		}
	}
	return NULL;
}

static void ip_vs_app_seq_stop(struct seq_file *seq, void *v)
{
	mutex_unlock(&__ip_vs_app_mutex);
}

static int ip_vs_app_seq_show(struct seq_file *seq, void *v)
{
	if (v == SEQ_START_TOKEN)
		seq_puts(seq, "prot port    usecnt name\n");
	else {
		const struct ip_vs_app *inc = v;

		seq_printf(seq, "%-3s  %-7u %-6d %-17s\n",
			   ip_vs_proto_name(inc->protocol),
			   ntohs(inc->port),
			   atomic_read(&inc->usecnt),
			   inc->name);
	}
	return 0;
}

static const struct seq_operations ip_vs_app_seq_ops = {
	.start = ip_vs_app_seq_start,
	.next  = ip_vs_app_seq_next,
	.stop  = ip_vs_app_seq_stop,
	.show  = ip_vs_app_seq_show,
};

static int ip_vs_app_open(struct inode *inode, struct file *file)
{
	return seq_open(file, &ip_vs_app_seq_ops);
}

static const struct file_operations ip_vs_app_fops = {
	.owner	 = THIS_MODULE,
	.open	 = ip_vs_app_open,
	.read	 = seq_read,
	.llseek  = seq_lseek,
	.release = seq_release,
};
#endif


/*
 *	Replace a segment of data with a new segment
 */
int ip_vs_skb_replace(struct sk_buff *skb, gfp_t pri,
		      char *o_buf, int o_len, char *n_buf, int n_len)
{
	int diff;
	int o_offset;
	int o_left;

	EnterFunction(9);

	diff = n_len - o_len;
	o_offset = o_buf - (char *)skb->data;
	/* The length of left data after o_buf+o_len in the skb data */
	o_left = skb->len - (o_offset + o_len);

	if (diff <= 0) {
		memmove(o_buf + n_len, o_buf + o_len, o_left);
		memcpy(o_buf, n_buf, n_len);
		skb_trim(skb, skb->len + diff);
	} else if (diff <= skb_tailroom(skb)) {
		skb_put(skb, diff);
		memmove(o_buf + n_len, o_buf + o_len, o_left);
		memcpy(o_buf, n_buf, n_len);
	} else {
		if (pskb_expand_head(skb, skb_headroom(skb), diff, pri))
			return -ENOMEM;
		skb_put(skb, diff);
		memmove(skb->data + o_offset + n_len,
			skb->data + o_offset + o_len, o_left);
		skb_copy_to_linear_data_offset(skb, o_offset, n_buf, n_len);
	}

	/* must update the iph total length here */
	ip_hdr(skb)->tot_len = htons(skb->len);

	LeaveFunction(9);
	return 0;
}


int __init ip_vs_app_init(void)
{
	/* we will replace it with proc_net_ipvs_create() soon */
	proc_net_fops_create(&init_net, "ip_vs_app", 0, &ip_vs_app_fops);
	return 0;
}


void ip_vs_app_cleanup(void)
{
	proc_net_remove(&init_net, "ip_vs_app");
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* ip_vs_app.c: Application module support for IPVS
	3	*
1da177e4 LT	4	* Authors: Wensong Zhang <wensong@linuxvirtualserver.org>
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*
	11	* Most code here is taken from ip_masq_app.c in kernel 2.2. The difference
	12	* is that ip_vs_app module handles the reverse direction (incoming requests
	13	* and outgoing responses).
	14	*
	15	* IP_MASQ_APP application masquerading module
	16	*
	17	* Author: Juan Jose Ciarlante, <jjciarla@raiz.uncu.edu.ar>
	18	*
	19	*/
	20
	21	#include <linux/module.h>
	22	#include <linux/kernel.h>
	23	#include <linux/skbuff.h>
	24	#include <linux/in.h>
	25	#include <linux/ip.h>
af1e1cf0	26	#include <linux/netfilter.h>
457c4cbc	27	#include <net/net_namespace.h>
1da177e4	28	#include <net/protocol.h>
c752f073	29	#include <net/tcp.h>
1da177e4 LT	30	#include <asm/system.h>
	31	#include <linux/stat.h>
	32	#include <linux/proc_fs.h>
	33	#include <linux/seq_file.h>
57b47a53	34	#include <linux/mutex.h>
1da177e4 LT	35
	36	#include <net/ip_vs.h>
	37
	38	EXPORT_SYMBOL(register_ip_vs_app);
	39	EXPORT_SYMBOL(unregister_ip_vs_app);
	40	EXPORT_SYMBOL(register_ip_vs_app_inc);
	41
	42	/* ipvs application list head */
	43	static LIST_HEAD(ip_vs_app_list);
57b47a53	44	static DEFINE_MUTEX(__ip_vs_app_mutex);
1da177e4 LT	45
	46
	47	/*
	48	* Get an ip_vs_app object
	49	*/
	50	static inline int ip_vs_app_get(struct ip_vs_app *app)
	51	{
85b60680	52	return try_module_get(app->module);
1da177e4 LT	53	}
	54
	55
	56	static inline void ip_vs_app_put(struct ip_vs_app *app)
	57	{
85b60680	58	module_put(app->module);
1da177e4 LT	59	}
	60
	61
	62	/*
	63	* Allocate/initialize app incarnation and register it in proto apps.
	64	*/
	65	static int
	66	ip_vs_app_inc_new(struct ip_vs_app *app, __u16 proto, __u16 port)
	67	{
	68	struct ip_vs_protocol *pp;
	69	struct ip_vs_app *inc;
	70	int ret;
	71
	72	if (!(pp = ip_vs_proto_get(proto)))
	73	return -EPROTONOSUPPORT;
	74
	75	if (!pp->unregister_app)
	76	return -EOPNOTSUPP;
	77
8b2ed4bb	78	inc = kmemdup(app, sizeof(*inc), GFP_KERNEL);
1da177e4 LT	79	if (!inc)
1da177e4 LT	80	return -ENOMEM;
1da177e4 LT	81	INIT_LIST_HEAD(&inc->p_list);
	82	INIT_LIST_HEAD(&inc->incs_list);
	83	inc->app = app;
	84	inc->port = htons(port);
	85	atomic_set(&inc->usecnt, 0);
	86
	87	if (app->timeouts) {
	88	inc->timeout_table =
	89	ip_vs_create_timeout_table(app->timeouts,
	90	app->timeouts_size);
	91	if (!inc->timeout_table) {
	92	ret = -ENOMEM;
	93	goto out;
	94	}
	95	}
	96
	97	ret = pp->register_app(inc);
	98	if (ret)
	99	goto out;
	100
	101	list_add(&inc->a_list, &app->incs_list);
	102	IP_VS_DBG(9, "%s application %s:%u registered\n",
	103	pp->name, inc->name, inc->port);
	104
	105	return 0;
	106
	107	out:
a51482bd	108	kfree(inc->timeout_table);
1da177e4 LT	109	kfree(inc);
	110	return ret;
	111	}
	112
	113
	114	/*
	115	* Release app incarnation
	116	*/
	117	static void
	118	ip_vs_app_inc_release(struct ip_vs_app *inc)
	119	{
	120	struct ip_vs_protocol *pp;
	121
	122	if (!(pp = ip_vs_proto_get(inc->protocol)))
	123	return;
	124
	125	if (pp->unregister_app)
	126	pp->unregister_app(inc);
	127
	128	IP_VS_DBG(9, "%s App %s:%u unregistered\n",
	129	pp->name, inc->name, inc->port);
	130
	131	list_del(&inc->a_list);
	132
a51482bd	133	kfree(inc->timeout_table);
1da177e4 LT	134	kfree(inc);
	135	}
	136
	137
	138	/*
	139	* Get reference to app inc (only called from softirq)
	140	*
	141	*/
	142	int ip_vs_app_inc_get(struct ip_vs_app *inc)
	143	{
	144	int result;
	145
	146	atomic_inc(&inc->usecnt);
	147	if (unlikely((result = ip_vs_app_get(inc->app)) != 1))
	148	atomic_dec(&inc->usecnt);
	149	return result;
	150	}
	151
	152
	153	/*
	154	* Put the app inc (only called from timer or net softirq)
	155	*/
	156	void ip_vs_app_inc_put(struct ip_vs_app *inc)
	157	{
	158	ip_vs_app_put(inc->app);
	159	atomic_dec(&inc->usecnt);
	160	}
	161
	162
	163	/*
	164	* Register an application incarnation in protocol applications
	165	*/
	166	int
	167	register_ip_vs_app_inc(struct ip_vs_app *app, __u16 proto, __u16 port)
	168	{
	169	int result;
	170
57b47a53	171	mutex_lock(&__ip_vs_app_mutex);
1da177e4 LT	172
	173	result = ip_vs_app_inc_new(app, proto, port);
	174
57b47a53	175	mutex_unlock(&__ip_vs_app_mutex);
1da177e4 LT	176
	177	return result;
	178	}
	179
	180
	181	/*
	182	* ip_vs_app registration routine
	183	*/
	184	int register_ip_vs_app(struct ip_vs_app *app)
	185	{
	186	/* increase the module use count */
	187	ip_vs_use_count_inc();
	188
57b47a53	189	mutex_lock(&__ip_vs_app_mutex);
1da177e4 LT	190
	191	list_add(&app->a_list, &ip_vs_app_list);
	192
57b47a53	193	mutex_unlock(&__ip_vs_app_mutex);
1da177e4 LT	194
	195	return 0;
	196	}
	197
	198
	199	/*
	200	* ip_vs_app unregistration routine
	201	* We are sure there are no app incarnations attached to services
	202	*/
	203	void unregister_ip_vs_app(struct ip_vs_app *app)
	204	{
	205	struct ip_vs_app inc, nxt;
	206
57b47a53	207	mutex_lock(&__ip_vs_app_mutex);
1da177e4 LT	208
	209	list_for_each_entry_safe(inc, nxt, &app->incs_list, a_list) {
	210	ip_vs_app_inc_release(inc);
	211	}
	212
	213	list_del(&app->a_list);
	214
57b47a53	215	mutex_unlock(&__ip_vs_app_mutex);
1da177e4 LT	216
	217	/* decrease the module use count */
	218	ip_vs_use_count_dec();
	219	}
	220
	221
1da177e4 LT	222	/*
	223	* Bind ip_vs_conn to its ip_vs_app (called by cp constructor)
	224	*/
	225	int ip_vs_bind_app(struct ip_vs_conn cp, struct ip_vs_protocol pp)
	226	{
	227	return pp->app_conn_bind(cp);
	228	}
	229
	230
	231	/*
	232	* Unbind cp from application incarnation (called by cp destructor)
	233	*/
	234	void ip_vs_unbind_app(struct ip_vs_conn *cp)
	235	{
	236	struct ip_vs_app *inc = cp->app;
	237
	238	if (!inc)
	239	return;
	240
	241	if (inc->unbind_conn)
	242	inc->unbind_conn(inc, cp);
	243	if (inc->done_conn)
	244	inc->done_conn(inc, cp);
	245	ip_vs_app_inc_put(inc);
	246	cp->app = NULL;
	247	}
	248
	249
	250	/*
	251	* Fixes th->seq based on ip_vs_seq info.
	252	*/
	253	static inline void vs_fix_seq(const struct ip_vs_seq vseq, struct tcphdr th)
	254	{
	255	__u32 seq = ntohl(th->seq);
	256
	257	/*
	258	* Adjust seq with delta-offset for all packets after
	259	* the most recent resized pkt seq and with previous_delta offset
	260	* for all packets before most recent resized pkt seq.
	261	*/
	262	if (vseq->delta \|\| vseq->previous_delta) {
	263	if(after(seq, vseq->init_seq)) {
	264	th->seq = htonl(seq + vseq->delta);
	265	IP_VS_DBG(9, "vs_fix_seq(): added delta (%d) to seq\n",
	266	vseq->delta);
	267	} else {
	268	th->seq = htonl(seq + vseq->previous_delta);
	269	IP_VS_DBG(9, "vs_fix_seq(): added previous_delta "
	270	"(%d) to seq\n", vseq->previous_delta);
	271	}
	272	}
	273	}
	274
	275
	276	/*
	277	* Fixes th->ack_seq based on ip_vs_seq info.
	278	*/
	279	static inline void
	280	vs_fix_ack_seq(const struct ip_vs_seq vseq, struct tcphdr th)
	281	{
	282	__u32 ack_seq = ntohl(th->ack_seq);
	283
	284	/*
	285	* Adjust ack_seq with delta-offset for
286	* the packets AFTER most recent resized pkt has caused a shift
287	* for packets before most recent resized pkt, use previous_delta
288	*/
289	if (vseq->delta \|\| vseq->previous_delta) {
290	/* since ack_seq is the number of octet that is expected
291	to receive next, so compare it with init_seq+delta */
292	if(after(ack_seq, vseq->init_seq+vseq->delta)) {
293	th->ack_seq = htonl(ack_seq - vseq->delta);
294	IP_VS_DBG(9, "vs_fix_ack_seq(): subtracted delta "
295	"(%d) from ack_seq\n", vseq->delta);
296
297	} else {
298	th->ack_seq = htonl(ack_seq - vseq->previous_delta);
299	IP_VS_DBG(9, "vs_fix_ack_seq(): subtracted "
300	"previous_delta (%d) from ack_seq\n",
301	vseq->previous_delta);
302	}
303	}
304	}
305
306
307	/*
308	* Updates ip_vs_seq if pkt has been resized
309	* Assumes already checked proto==IPPROTO_TCP and diff!=0.
310	*/
311	static inline void vs_seq_update(struct ip_vs_conn cp, struct ip_vs_seq vseq,
312	unsigned flag, __u32 seq, int diff)
313	{
314	/* spinlock is to keep updating cp->flags atomic */
315	spin_lock(&cp->lock);
316	if (!(cp->flags & flag) \|\| after(seq, vseq->init_seq)) {
317	vseq->previous_delta = vseq->delta;
318	vseq->delta += diff;
319	vseq->init_seq = seq;
320	cp->flags \|= flag;
321	}
322	spin_unlock(&cp->lock);
323	}
324
3db05fea	325	static inline int app_tcp_pkt_out(struct ip_vs_conn cp, struct sk_buff skb,
1da177e4 LT	326	struct ip_vs_app *app)
	327	{
	328	int diff;
3db05fea	329	const unsigned int tcp_offset = ip_hdrlen(skb);
1da177e4 LT	330	struct tcphdr *th;
	331	__u32 seq;
	332
3db05fea	333	if (!skb_make_writable(skb, tcp_offset + sizeof(*th)))
1da177e4 LT	334	return 0;
1da177e4 LT	335
3db05fea	336	th = (struct tcphdr *)(skb_network_header(skb) + tcp_offset);
1da177e4 LT	337
	338	/*
	339	* Remember seq number in case this pkt gets resized
	340	*/
	341	seq = ntohl(th->seq);
	342
	343	/*
	344	* Fix seq stuff if flagged as so.
	345	*/
	346	if (cp->flags & IP_VS_CONN_F_OUT_SEQ)
	347	vs_fix_seq(&cp->out_seq, th);
	348	if (cp->flags & IP_VS_CONN_F_IN_SEQ)
	349	vs_fix_ack_seq(&cp->in_seq, th);
	350
	351	/*
	352	* Call private output hook function
	353	*/
	354	if (app->pkt_out == NULL)
	355	return 1;
	356
3db05fea	357	if (!app->pkt_out(app, cp, skb, &diff))
1da177e4 LT	358	return 0;
	359
	360	/*
	361	* Update ip_vs seq stuff if len has changed.
	362	*/
	363	if (diff != 0)
	364	vs_seq_update(cp, &cp->out_seq,
	365	IP_VS_CONN_F_OUT_SEQ, seq, diff);
	366
	367	return 1;
	368	}
	369
	370	/*
	371	* Output pkt hook. Will call bound ip_vs_app specific function
	372	* called by ipvs packet handler, assumes previously checked cp!=NULL
	373	* returns false if it can't handle packet (oom)
	374	*/
3db05fea	375	int ip_vs_app_pkt_out(struct ip_vs_conn cp, struct sk_buff skb)
1da177e4 LT	376	{
	377	struct ip_vs_app *app;
	378
	379	/*
	380	* check if application module is bound to
	381	* this ip_vs_conn.
	382	*/
	383	if ((app = cp->app) == NULL)
	384	return 1;
	385
	386	/* TCP is complicated */
	387	if (cp->protocol == IPPROTO_TCP)
3db05fea	388	return app_tcp_pkt_out(cp, skb, app);
1da177e4 LT	389
	390	/*
	391	* Call private output hook function
	392	*/
	393	if (app->pkt_out == NULL)
	394	return 1;
	395
3db05fea	396	return app->pkt_out(app, cp, skb, NULL);
1da177e4 LT	397	}
	398
	399
3db05fea	400	static inline int app_tcp_pkt_in(struct ip_vs_conn cp, struct sk_buff skb,
1da177e4 LT	401	struct ip_vs_app *app)
	402	{
	403	int diff;
3db05fea	404	const unsigned int tcp_offset = ip_hdrlen(skb);
1da177e4 LT	405	struct tcphdr *th;
	406	__u32 seq;
	407
3db05fea	408	if (!skb_make_writable(skb, tcp_offset + sizeof(*th)))
1da177e4 LT	409	return 0;
1da177e4 LT	410
3db05fea	411	th = (struct tcphdr *)(skb_network_header(skb) + tcp_offset);
1da177e4 LT	412
	413	/*
	414	* Remember seq number in case this pkt gets resized
	415	*/
	416	seq = ntohl(th->seq);
	417
	418	/*
	419	* Fix seq stuff if flagged as so.
	420	*/
	421	if (cp->flags & IP_VS_CONN_F_IN_SEQ)
	422	vs_fix_seq(&cp->in_seq, th);
	423	if (cp->flags & IP_VS_CONN_F_OUT_SEQ)
	424	vs_fix_ack_seq(&cp->out_seq, th);
	425
	426	/*
	427	* Call private input hook function
	428	*/
	429	if (app->pkt_in == NULL)
	430	return 1;
	431
3db05fea	432	if (!app->pkt_in(app, cp, skb, &diff))
1da177e4 LT	433	return 0;
	434
	435	/*
	436	* Update ip_vs seq stuff if len has changed.
	437	*/
	438	if (diff != 0)
	439	vs_seq_update(cp, &cp->in_seq,
	440	IP_VS_CONN_F_IN_SEQ, seq, diff);
	441
	442	return 1;
	443	}
	444
	445	/*
	446	* Input pkt hook. Will call bound ip_vs_app specific function
	447	* called by ipvs packet handler, assumes previously checked cp!=NULL.
	448	* returns false if can't handle packet (oom).
	449	*/
3db05fea	450	int ip_vs_app_pkt_in(struct ip_vs_conn cp, struct sk_buff skb)
1da177e4 LT	451	{
	452	struct ip_vs_app *app;
	453
	454	/*
	455	* check if application module is bound to
	456	* this ip_vs_conn.
	457	*/
	458	if ((app = cp->app) == NULL)
	459	return 1;
	460
	461	/* TCP is complicated */
	462	if (cp->protocol == IPPROTO_TCP)
3db05fea	463	return app_tcp_pkt_in(cp, skb, app);
1da177e4 LT	464
	465	/*
	466	* Call private input hook function
	467	*/
	468	if (app->pkt_in == NULL)
	469	return 1;
	470
3db05fea	471	return app->pkt_in(app, cp, skb, NULL);
1da177e4 LT	472	}
	473
	474
	475	#ifdef CONFIG_PROC_FS
	476	/*
	477	* /proc/net/ip_vs_app entry function
	478	*/
	479
	480	static struct ip_vs_app *ip_vs_app_idx(loff_t pos)
	481	{
	482	struct ip_vs_app app, inc;
	483
	484	list_for_each_entry(app, &ip_vs_app_list, a_list) {
	485	list_for_each_entry(inc, &app->incs_list, a_list) {
	486	if (pos-- == 0)
	487	return inc;
	488	}
	489	}
	490	return NULL;
	491
	492	}
	493
	494	static void ip_vs_app_seq_start(struct seq_file seq, loff_t *pos)
	495	{
57b47a53	496	mutex_lock(&__ip_vs_app_mutex);
1da177e4 LT	497
	498	return pos ? ip_vs_app_idx(pos - 1) : SEQ_START_TOKEN;
	499	}
	500
	501	static void ip_vs_app_seq_next(struct seq_file seq, void v, loff_t pos)
	502	{
	503	struct ip_vs_app inc, app;
	504	struct list_head *e;
	505
	506	++*pos;
	507	if (v == SEQ_START_TOKEN)
	508	return ip_vs_app_idx(0);
	509
	510	inc = v;
	511	app = inc->app;
	512
	513	if ((e = inc->a_list.next) != &app->incs_list)
	514	return list_entry(e, struct ip_vs_app, a_list);
	515
	516	/* go on to next application */
	517	for (e = app->a_list.next; e != &ip_vs_app_list; e = e->next) {
	518	app = list_entry(e, struct ip_vs_app, a_list);
	519	list_for_each_entry(inc, &app->incs_list, a_list) {
	520	return inc;
	521	}
	522	}
	523	return NULL;
	524	}
	525
	526	static void ip_vs_app_seq_stop(struct seq_file seq, void v)
	527	{
57b47a53	528	mutex_unlock(&__ip_vs_app_mutex);
1da177e4 LT	529	}
	530
	531	static int ip_vs_app_seq_show(struct seq_file seq, void v)
	532	{
	533	if (v == SEQ_START_TOKEN)
	534	seq_puts(seq, "prot port usecnt name\n");
	535	else {
	536	const struct ip_vs_app *inc = v;
	537
	538	seq_printf(seq, "%-3s %-7u %-6d %-17s\n",
	539	ip_vs_proto_name(inc->protocol),
	540	ntohs(inc->port),
	541	atomic_read(&inc->usecnt),
	542	inc->name);
	543	}
	544	return 0;
	545	}
	546
56b3d975	547	static const struct seq_operations ip_vs_app_seq_ops = {
1da177e4 LT	548	.start = ip_vs_app_seq_start,
	549	.next = ip_vs_app_seq_next,
	550	.stop = ip_vs_app_seq_stop,
	551	.show = ip_vs_app_seq_show,
	552	};
	553
	554	static int ip_vs_app_open(struct inode inode, struct file file)
	555	{
	556	return seq_open(file, &ip_vs_app_seq_ops);
	557	}
	558
9a32144e	559	static const struct file_operations ip_vs_app_fops = {
1da177e4 LT	560	.owner = THIS_MODULE,
	561	.open = ip_vs_app_open,
	562	.read = seq_read,
	563	.llseek = seq_lseek,
	564	.release = seq_release,
	565	};
	566	#endif
	567
	568
	569	/*
	570	* Replace a segment of data with a new segment
	571	*/
dd0fc66f	572	int ip_vs_skb_replace(struct sk_buff *skb, gfp_t pri,
1da177e4 LT	573	char o_buf, int o_len, char n_buf, int n_len)
1da177e4 LT	574	{
1da177e4 LT	575	int diff;
	576	int o_offset;
	577	int o_left;
	578
	579	EnterFunction(9);
	580
	581	diff = n_len - o_len;
	582	o_offset = o_buf - (char *)skb->data;
	583	/* The length of left data after o_buf+o_len in the skb data */
	584	o_left = skb->len - (o_offset + o_len);
	585
	586	if (diff <= 0) {
	587	memmove(o_buf + n_len, o_buf + o_len, o_left);
	588	memcpy(o_buf, n_buf, n_len);
	589	skb_trim(skb, skb->len + diff);
	590	} else if (diff <= skb_tailroom(skb)) {
	591	skb_put(skb, diff);
	592	memmove(o_buf + n_len, o_buf + o_len, o_left);
	593	memcpy(o_buf, n_buf, n_len);
	594	} else {
	595	if (pskb_expand_head(skb, skb_headroom(skb), diff, pri))
	596	return -ENOMEM;
	597	skb_put(skb, diff);
	598	memmove(skb->data + o_offset + n_len,
	599	skb->data + o_offset + o_len, o_left);
27d7ff46	600	skb_copy_to_linear_data_offset(skb, o_offset, n_buf, n_len);
1da177e4 LT	601	}
	602
	603	/* must update the iph total length here */
eddc9ec5	604	ip_hdr(skb)->tot_len = htons(skb->len);
1da177e4 LT	605
	606	LeaveFunction(9);
	607	return 0;
	608	}
	609
	610
048cf48b	611	int __init ip_vs_app_init(void)
1da177e4 LT	612	{
1da177e4 LT	613	/* we will replace it with proc_net_ipvs_create() soon */
457c4cbc	614	proc_net_fops_create(&init_net, "ip_vs_app", 0, &ip_vs_app_fops);
1da177e4 LT	615	return 0;
	616	}
	617
	618
	619	void ip_vs_app_cleanup(void)
	620	{
457c4cbc	621	proc_net_remove(&init_net, "ip_vs_app");
1da177e4	622	}