[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / netfilter / ipvs / ip_vs_pe_sip.c

#define KMSG_COMPONENT "IPVS"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

#include <linux/module.h>
#include <linux/kernel.h>

#include <net/ip_vs.h>
#include <net/netfilter/nf_conntrack.h>
#include <linux/netfilter/nf_conntrack_sip.h>

#ifdef CONFIG_IP_VS_DEBUG
static const char *ip_vs_dbg_callid(char *buf, size_t buf_len,
				    const char *callid, size_t callid_len,
				    int *idx)
{
	size_t max_len = 64;
	size_t len = min3(max_len, callid_len, buf_len - *idx - 1);
	memcpy(buf + *idx, callid, len);
	buf[*idx+len] = '\0';
	*idx += len + 1;
	return buf + *idx - len;
}

#define IP_VS_DEBUG_CALLID(callid, len)					\
	ip_vs_dbg_callid(ip_vs_dbg_buf, sizeof(ip_vs_dbg_buf),		\
			 callid, len, &ip_vs_dbg_idx)
#endif

static int get_callid(const char *dptr, unsigned int dataoff,
		      unsigned int datalen,
		      unsigned int *matchoff, unsigned int *matchlen)
{
	/* Find callid */
	while (1) {
		int ret = ct_sip_get_header(NULL, dptr, dataoff, datalen,
					    SIP_HDR_CALL_ID, matchoff,
					    matchlen);
		if (ret > 0)
			break;
		if (!ret)
			return -EINVAL;
		dataoff += *matchoff;
	}

	/* Too large is useless */
	if (*matchlen > IP_VS_PEDATA_MAXLEN)
		return -EINVAL;

	/* SIP headers are always followed by a line terminator */
	if (*matchoff + *matchlen == datalen)
		return -EINVAL;

	/* RFC 2543 allows lines to be terminated with CR, LF or CRLF,
	 * RFC 3261 allows only CRLF, we support both. */
	if (*(dptr + *matchoff + *matchlen) != '\r' &&
	    *(dptr + *matchoff + *matchlen) != '\n')
		return -EINVAL;

	IP_VS_DBG_BUF(9, "SIP callid %s (%d bytes)\n",
		      IP_VS_DEBUG_CALLID(dptr + *matchoff, *matchlen),
		      *matchlen);
	return 0;
}

static int
ip_vs_sip_fill_param(struct ip_vs_conn_param *p, struct sk_buff *skb)
{
	struct ip_vs_iphdr iph;
	unsigned int dataoff, datalen, matchoff, matchlen;
	const char *dptr;
	int retc;

	ip_vs_fill_iph_skb(p->af, skb, &iph);

	/* Only useful with UDP */
	if (iph.protocol != IPPROTO_UDP)
		return -EINVAL;
	/* todo: IPv6 fragments:
	 *       I think this only should be done for the first fragment. /HS
	 */
	dataoff = iph.len + sizeof(struct udphdr);

	if (dataoff >= skb->len)
		return -EINVAL;
	retc = skb_linearize(skb);
	if (retc < 0)
		return retc;
	dptr = skb->data + dataoff;
	datalen = skb->len - dataoff;

	if (get_callid(dptr, 0, datalen, &matchoff, &matchlen))
		return -EINVAL;

	/* N.B: pe_data is only set on success,
	 * this allows fallback to the default persistence logic on failure
	 */
	p->pe_data = kmemdup(dptr + matchoff, matchlen, GFP_ATOMIC);
	if (!p->pe_data)
		return -ENOMEM;

	p->pe_data_len = matchlen;

	return 0;
}

static bool ip_vs_sip_ct_match(const struct ip_vs_conn_param *p,
				  struct ip_vs_conn *ct)

{
	bool ret = false;

	if (ct->af == p->af &&
	    ip_vs_addr_equal(p->af, p->caddr, &ct->caddr) &&
	    /* protocol should only be IPPROTO_IP if
	     * d_addr is a fwmark */
	    ip_vs_addr_equal(p->protocol == IPPROTO_IP ? AF_UNSPEC : p->af,
			     p->vaddr, &ct->vaddr) &&
	    ct->vport == p->vport &&
	    ct->flags & IP_VS_CONN_F_TEMPLATE &&
	    ct->protocol == p->protocol &&
	    ct->pe_data && ct->pe_data_len == p->pe_data_len &&
	    !memcmp(ct->pe_data, p->pe_data, p->pe_data_len))
		ret = true;

	IP_VS_DBG_BUF(9, "SIP template match %s %s->%s:%d %s\n",
		      ip_vs_proto_name(p->protocol),
		      IP_VS_DEBUG_CALLID(p->pe_data, p->pe_data_len),
		      IP_VS_DBG_ADDR(p->af, p->vaddr), ntohs(p->vport),
		      ret ? "hit" : "not hit");

	return ret;
}

static u32 ip_vs_sip_hashkey_raw(const struct ip_vs_conn_param *p,
				 u32 initval, bool inverse)
{
	return jhash(p->pe_data, p->pe_data_len, initval);
}

static int ip_vs_sip_show_pe_data(const struct ip_vs_conn *cp, char *buf)
{
	memcpy(buf, cp->pe_data, cp->pe_data_len);
	return cp->pe_data_len;
}

static struct ip_vs_pe ip_vs_sip_pe =
{
	.name =			"sip",
	.refcnt =		ATOMIC_INIT(0),
	.module =		THIS_MODULE,
	.n_list =		LIST_HEAD_INIT(ip_vs_sip_pe.n_list),
	.fill_param =		ip_vs_sip_fill_param,
	.ct_match =		ip_vs_sip_ct_match,
	.hashkey_raw =		ip_vs_sip_hashkey_raw,
	.show_pe_data =		ip_vs_sip_show_pe_data,
};

static int __init ip_vs_sip_init(void)
{
	return register_ip_vs_pe(&ip_vs_sip_pe);
}

static void __exit ip_vs_sip_cleanup(void)
{
	unregister_ip_vs_pe(&ip_vs_sip_pe);
	synchronize_rcu();
}

module_init(ip_vs_sip_init);
module_exit(ip_vs_sip_cleanup);
MODULE_LICENSE("GPL");
Commit	Line	Data
758ff033 SH	1	#define KMSG_COMPONENT "IPVS"
	2	#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
	3
	4	#include <linux/module.h>
	5	#include <linux/kernel.h>
	6
	7	#include <net/ip_vs.h>
	8	#include <net/netfilter/nf_conntrack.h>
	9	#include <linux/netfilter/nf_conntrack_sip.h>
	10
a91fd267	11	#ifdef CONFIG_IP_VS_DEBUG
758ff033 SH	12	static const char ip_vs_dbg_callid(char buf, size_t buf_len,
	13	const char *callid, size_t callid_len,
	14	int *idx)
	15	{
9c37510b SH	16	size_t max_len = 64;
9c37510b SH	17	size_t len = min3(max_len, callid_len, buf_len - *idx - 1);
758ff033 SH	18	memcpy(buf + *idx, callid, len);
	19	buf[*idx+len] = '\0';
	20	*idx += len + 1;
	21	return buf + *idx - len;
	22	}
	23
	24	#define IP_VS_DEBUG_CALLID(callid, len) \
	25	ip_vs_dbg_callid(ip_vs_dbg_buf, sizeof(ip_vs_dbg_buf), \
	26	callid, len, &ip_vs_dbg_idx)
a91fd267	27	#endif
758ff033 SH	28
	29	static int get_callid(const char *dptr, unsigned int dataoff,
	30	unsigned int datalen,
	31	unsigned int matchoff, unsigned int matchlen)
	32	{
	33	/* Find callid */
	34	while (1) {
	35	int ret = ct_sip_get_header(NULL, dptr, dataoff, datalen,
	36	SIP_HDR_CALL_ID, matchoff,
	37	matchlen);
	38	if (ret > 0)
	39	break;
	40	if (!ret)
f7a1dd6e	41	return -EINVAL;
758ff033 SH	42	dataoff += *matchoff;
	43	}
	44
758ff033 SH	45	/* Too large is useless */
	46	if (*matchlen > IP_VS_PEDATA_MAXLEN)
	47	return -EINVAL;
	48
	49	/* SIP headers are always followed by a line terminator */
	50	if (matchoff + matchlen == datalen)
	51	return -EINVAL;
	52
	53	/* RFC 2543 allows lines to be terminated with CR, LF or CRLF,
	54	* RFC 3261 allows only CRLF, we support both. */
	55	if ((dptr + matchoff + *matchlen) != '\r' &&
	56	(dptr + matchoff + *matchlen) != '\n')
	57	return -EINVAL;
	58
	59	IP_VS_DBG_BUF(9, "SIP callid %s (%d bytes)\n",
	60	IP_VS_DEBUG_CALLID(dptr + matchoff, matchlen),
	61	*matchlen);
	62	return 0;
	63	}
	64
	65	static int
	66	ip_vs_sip_fill_param(struct ip_vs_conn_param p, struct sk_buff skb)
	67	{
	68	struct ip_vs_iphdr iph;
	69	unsigned int dataoff, datalen, matchoff, matchlen;
	70	const char *dptr;
37165226	71	int retc;
758ff033	72
63dca2c0	73	ip_vs_fill_iph_skb(p->af, skb, &iph);
758ff033 SH	74
	75	/* Only useful with UDP */
	76	if (iph.protocol != IPPROTO_UDP)
	77	return -EINVAL;
92eec78d JDB	78	/* todo: IPv6 fragments:
	79	* I think this only should be done for the first fragment. /HS
	80	*/
fddd8b50	81	dataoff = iph.len + sizeof(struct udphdr);
758ff033	82
758ff033 SH	83	if (dataoff >= skb->len)
758ff033 SH	84	return -EINVAL;
92eec78d JDB	85	retc = skb_linearize(skb);
92eec78d JDB	86	if (retc < 0)
37165226	87	return retc;
758ff033 SH	88	dptr = skb->data + dataoff;
	89	datalen = skb->len - dataoff;
	90
049c18da	91	if (get_callid(dptr, 0, datalen, &matchoff, &matchlen))
758ff033 SH	92	return -EINVAL;
758ff033 SH	93
758ff033 SH	94	/* N.B: pe_data is only set on success,
	95	* this allows fallback to the default persistence logic on failure
	96	*/
6060c74a SW	97	p->pe_data = kmemdup(dptr + matchoff, matchlen, GFP_ATOMIC);
	98	if (!p->pe_data)
	99	return -ENOMEM;
	100
758ff033 SH	101	p->pe_data_len = matchlen;
	102
	103	return 0;
	104	}
	105
	106	static bool ip_vs_sip_ct_match(const struct ip_vs_conn_param *p,
	107	struct ip_vs_conn *ct)
	108
	109	{
3db1cd5c	110	bool ret = false;
758ff033 SH	111
	112	if (ct->af == p->af &&
	113	ip_vs_addr_equal(p->af, p->caddr, &ct->caddr) &&
	114	/* protocol should only be IPPROTO_IP if
	115	* d_addr is a fwmark */
	116	ip_vs_addr_equal(p->protocol == IPPROTO_IP ? AF_UNSPEC : p->af,
	117	p->vaddr, &ct->vaddr) &&
	118	ct->vport == p->vport &&
	119	ct->flags & IP_VS_CONN_F_TEMPLATE &&
	120	ct->protocol == p->protocol &&
	121	ct->pe_data && ct->pe_data_len == p->pe_data_len &&
	122	!memcmp(ct->pe_data, p->pe_data, p->pe_data_len))
3db1cd5c	123	ret = true;
758ff033 SH	124
	125	IP_VS_DBG_BUF(9, "SIP template match %s %s->%s:%d %s\n",
	126	ip_vs_proto_name(p->protocol),
	127	IP_VS_DEBUG_CALLID(p->pe_data, p->pe_data_len),
	128	IP_VS_DBG_ADDR(p->af, p->vaddr), ntohs(p->vport),
	129	ret ? "hit" : "not hit");
	130
	131	return ret;
	132	}
	133
	134	static u32 ip_vs_sip_hashkey_raw(const struct ip_vs_conn_param *p,
	135	u32 initval, bool inverse)
	136	{
	137	return jhash(p->pe_data, p->pe_data_len, initval);
	138	}
	139
	140	static int ip_vs_sip_show_pe_data(const struct ip_vs_conn cp, char buf)
	141	{
	142	memcpy(buf, cp->pe_data, cp->pe_data_len);
	143	return cp->pe_data_len;
	144	}
	145
	146	static struct ip_vs_pe ip_vs_sip_pe =
	147	{
	148	.name = "sip",
	149	.refcnt = ATOMIC_INIT(0),
	150	.module = THIS_MODULE,
	151	.n_list = LIST_HEAD_INIT(ip_vs_sip_pe.n_list),
	152	.fill_param = ip_vs_sip_fill_param,
	153	.ct_match = ip_vs_sip_ct_match,
	154	.hashkey_raw = ip_vs_sip_hashkey_raw,
	155	.show_pe_data = ip_vs_sip_show_pe_data,
	156	};
	157
	158	static int __init ip_vs_sip_init(void)
	159	{
	160	return register_ip_vs_pe(&ip_vs_sip_pe);
	161	}
	162
	163	static void __exit ip_vs_sip_cleanup(void)
	164	{
	165	unregister_ip_vs_pe(&ip_vs_sip_pe);
60b6aa3b	166	synchronize_rcu();
758ff033 SH	167	}
	168
	169	module_init(ip_vs_sip_init);
	170	module_exit(ip_vs_sip_cleanup);
	171	MODULE_LICENSE("GPL");