1 /* SIP extension for IP connection tracking.
3 * (C) 2005 by Christian Hentschel <chentschel@arnet.com.ar>
4 * based on RR's ip_conntrack_ftp.c and other modules.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
11 #include <linux/module.h>
12 #include <linux/ctype.h>
13 #include <linux/skbuff.h>
16 #include <linux/udp.h>
18 #include <linux/netfilter.h>
19 #include <linux/netfilter_ipv4.h>
20 #include <linux/netfilter_ipv4/ip_conntrack_helper.h>
21 #include <linux/netfilter_ipv4/ip_conntrack_sip.h>
26 #define DEBUGP(format, args...)
29 MODULE_LICENSE("GPL");
30 MODULE_AUTHOR("Christian Hentschel <chentschel@arnet.com.ar>");
31 MODULE_DESCRIPTION("SIP connection tracking helper");
34 static unsigned short ports[MAX_PORTS];
36 module_param_array(ports, ushort, &ports_c, 0400);
37 MODULE_PARM_DESC(ports, "port numbers of sip servers");
39 static unsigned int sip_timeout = SIP_TIMEOUT;
40 module_param(sip_timeout, uint, 0600);
41 MODULE_PARM_DESC(sip_timeout, "timeout for the master SIP session");
43 unsigned int (*ip_nat_sip_hook)(struct sk_buff **pskb,
44 enum ip_conntrack_info ctinfo,
45 struct ip_conntrack *ct,
47 EXPORT_SYMBOL_GPL(ip_nat_sip_hook);
49 unsigned int (*ip_nat_sdp_hook)(struct sk_buff **pskb,
50 enum ip_conntrack_info ctinfo,
51 struct ip_conntrack_expect *exp,
53 EXPORT_SYMBOL_GPL(ip_nat_sdp_hook);
55 static int digits_len(const char *dptr, const char *limit, int *shift);
56 static int epaddr_len(const char *dptr, const char *limit, int *shift);
57 static int skp_digits_len(const char *dptr, const char *limit, int *shift);
58 static int skp_epaddr_len(const char *dptr, const char *limit, int *shift);
60 struct sip_header_nfo {
68 int (*match_len)(const char *, const char *, int *);
71 static struct sip_header_nfo ct_sip_hdrs[] = {
72 [POS_REQ_HEADER] = { /* SIP Requests headers */
74 .lnlen = sizeof("sip:") - 1,
76 .snlen = sizeof("sip:") - 1, /* yes, i know.. ;) */
78 .ln_strlen = sizeof("@") - 1,
79 .match_len = epaddr_len
81 [POS_VIA] = { /* SIP Via header */
83 .lnlen = sizeof("Via:") - 1,
85 .snlen = sizeof("\r\nv:") - 1, /* rfc3261 "\r\n" */
87 .ln_strlen = sizeof("UDP ") - 1,
88 .match_len = epaddr_len,
90 [POS_CONTACT] = { /* SIP Contact header */
92 .lnlen = sizeof("Contact:") - 1,
94 .snlen = sizeof("\r\nm:") - 1,
96 .ln_strlen = sizeof("sip:") - 1,
97 .match_len = skp_epaddr_len
99 [POS_CONTENT] = { /* SIP Content length header */
100 .lname = "Content-Length:",
101 .lnlen = sizeof("Content-Length:") - 1,
103 .snlen = sizeof("\r\nl:") - 1,
105 .ln_strlen = sizeof(":") - 1,
106 .match_len = skp_digits_len
108 [POS_MEDIA] = { /* SDP media info */
111 .lnlen = sizeof("\nm=") - 1,
113 .snlen = sizeof("\rm=") - 1,
115 .ln_strlen = sizeof("audio ") - 1,
116 .match_len = digits_len
118 [POS_OWNER] = { /* SDP owner address*/
121 .lnlen = sizeof("\no=") - 1,
123 .snlen = sizeof("\ro=") - 1,
125 .ln_strlen = sizeof("IN IP4 ") - 1,
126 .match_len = epaddr_len
128 [POS_CONNECTION] = { /* SDP connection info */
131 .lnlen = sizeof("\nc=") - 1,
133 .snlen = sizeof("\rc=") - 1,
135 .ln_strlen = sizeof("IN IP4 ") - 1,
136 .match_len = epaddr_len
138 [POS_SDP_HEADER] = { /* SDP version header */
141 .lnlen = sizeof("\nv=") - 1,
143 .snlen = sizeof("\rv=") - 1,
145 .ln_strlen = sizeof("=") - 1,
146 .match_len = digits_len
150 /* get line lenght until first CR or LF seen. */
151 int ct_sip_lnlen(const char *line, const char *limit)
153 const char *k = line;
155 while ((line <= limit) && (*line == '\r' || *line == '\n'))
158 while (line <= limit) {
159 if (*line == '\r' || *line == '\n')
165 EXPORT_SYMBOL_GPL(ct_sip_lnlen);
167 /* Linear string search, case sensitive. */
168 const char *ct_sip_search(const char *needle, const char *haystack,
169 size_t needle_len, size_t haystack_len,
172 const char *limit = haystack + (haystack_len - needle_len);
174 while (haystack <= limit) {
175 if (case_sensitive) {
176 if (strncmp(haystack, needle, needle_len) == 0)
179 if (strnicmp(haystack, needle, needle_len) == 0)
186 EXPORT_SYMBOL_GPL(ct_sip_search);
188 static int digits_len(const char *dptr, const char *limit, int *shift)
191 while (dptr <= limit && isdigit(*dptr)) {
198 /* get digits lenght, skiping blank spaces. */
199 static int skp_digits_len(const char *dptr, const char *limit, int *shift)
201 for (; dptr <= limit && *dptr == ' '; dptr++)
204 return digits_len(dptr, limit, shift);
207 /* Simple ipaddr parser.. */
208 static int parse_ipaddr(const char *cp, const char **endp,
209 __be32 *ipaddr, const char *limit)
211 unsigned long int val;
214 for (i = 0, *ipaddr = 0; cp <= limit && i < 4; i++) {
219 val = simple_strtoul(cp, (char **)&cp, 10);
223 ((u_int8_t *)ipaddr)[i] = val;
239 /* skip ip address. returns it lenght. */
240 static int epaddr_len(const char *dptr, const char *limit, int *shift)
242 const char *aux = dptr;
245 if (parse_ipaddr(dptr, &dptr, &ip, limit) < 0) {
246 DEBUGP("ip: %s parse failed.!\n", dptr);
253 dptr += digits_len(dptr, limit, shift);
258 /* get address length, skiping user info. */
259 static int skp_epaddr_len(const char *dptr, const char *limit, int *shift)
263 for (; dptr <= limit && *dptr != '@'; dptr++)
272 return epaddr_len(dptr, limit, shift);
275 /* Returns 0 if not found, -1 error parsing. */
276 int ct_sip_get_info(const char *dptr, size_t dlen,
277 unsigned int *matchoff,
278 unsigned int *matchlen,
279 enum sip_header_pos pos)
281 struct sip_header_nfo *hnfo = &ct_sip_hdrs[pos];
282 const char *limit, *aux, *k = dptr;
285 limit = dptr + (dlen - hnfo->lnlen);
287 while (dptr <= limit) {
288 if ((strncmp(dptr, hnfo->lname, hnfo->lnlen) != 0) &&
289 (strncmp(dptr, hnfo->sname, hnfo->snlen) != 0)) {
293 aux = ct_sip_search(hnfo->ln_str, dptr, hnfo->ln_strlen,
294 ct_sip_lnlen(dptr, limit),
295 hnfo->case_sensitive);
297 DEBUGP("'%s' not found in '%s'.\n", hnfo->ln_str,
301 aux += hnfo->ln_strlen;
303 *matchlen = hnfo->match_len(aux, limit, &shift);
307 *matchoff = (aux - k) + shift;
309 DEBUGP("%s match succeeded! - len: %u\n", hnfo->lname,
313 DEBUGP("%s header not found.\n", hnfo->lname);
316 EXPORT_SYMBOL_GPL(ct_sip_get_info);
318 static int set_expected_rtp(struct sk_buff **pskb,
319 struct ip_conntrack *ct,
320 enum ip_conntrack_info ctinfo,
321 __be32 ipaddr, u_int16_t port,
324 struct ip_conntrack_expect *exp;
325 enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
327 typeof(ip_nat_sdp_hook) ip_nat_sdp;
329 exp = ip_conntrack_expect_alloc(ct);
333 exp->tuple.src.ip = ct->tuplehash[!dir].tuple.src.ip;
334 exp->tuple.src.u.udp.port = 0;
335 exp->tuple.dst.ip = ipaddr;
336 exp->tuple.dst.u.udp.port = htons(port);
337 exp->tuple.dst.protonum = IPPROTO_UDP;
339 exp->mask.src.ip = htonl(0xFFFFFFFF);
340 exp->mask.src.u.udp.port = 0;
341 exp->mask.dst.ip = htonl(0xFFFFFFFF);
342 exp->mask.dst.u.udp.port = htons(0xFFFF);
343 exp->mask.dst.protonum = 0xFF;
345 exp->expectfn = NULL;
348 ip_nat_sdp = rcu_dereference(ip_nat_sdp_hook);
350 ret = ip_nat_sdp(pskb, ctinfo, exp, dptr);
352 if (ip_conntrack_expect_related(exp) != 0)
357 ip_conntrack_expect_put(exp);
362 static int sip_help(struct sk_buff **pskb,
363 struct ip_conntrack *ct,
364 enum ip_conntrack_info ctinfo)
366 unsigned int dataoff, datalen;
369 int matchoff, matchlen;
372 typeof(ip_nat_sip_hook) ip_nat_sip;
375 dataoff = (*pskb)->nh.iph->ihl*4 + sizeof(struct udphdr);
376 if (dataoff >= (*pskb)->len) {
377 DEBUGP("skb->len = %u\n", (*pskb)->len);
381 ip_ct_refresh(ct, *pskb, sip_timeout * HZ);
383 if (!skb_is_nonlinear(*pskb))
384 dptr = (*pskb)->data + dataoff;
386 DEBUGP("Copy of skbuff not supported yet.\n");
390 ip_nat_sip = rcu_dereference(ip_nat_sip_hook);
392 if (!ip_nat_sip(pskb, ctinfo, ct, &dptr)) {
398 /* After this point NAT, could have mangled skb, so
399 we need to recalculate payload lenght. */
400 datalen = (*pskb)->len - dataoff;
402 if (datalen < (sizeof("SIP/2.0 200") - 1))
405 /* RTP info only in some SDP pkts */
406 if (memcmp(dptr, "INVITE", sizeof("INVITE") - 1) != 0 &&
407 memcmp(dptr, "SIP/2.0 200", sizeof("SIP/2.0 200") - 1) != 0) {
410 /* Get ip and port address from SDP packet. */
411 if (ct_sip_get_info(dptr, datalen, &matchoff, &matchlen,
412 POS_CONNECTION) > 0) {
414 /* We'll drop only if there are parse problems. */
415 if (parse_ipaddr(dptr + matchoff, NULL, &ipaddr,
416 dptr + datalen) < 0) {
420 if (ct_sip_get_info(dptr, datalen, &matchoff, &matchlen,
423 port = simple_strtoul(dptr + matchoff, NULL, 10);
428 ret = set_expected_rtp(pskb, ct, ctinfo,
436 static struct ip_conntrack_helper sip[MAX_PORTS];
437 static char sip_names[MAX_PORTS][10];
439 static void fini(void)
442 for (i = 0; i < ports_c; i++) {
443 DEBUGP("unregistering helper for port %d\n", ports[i]);
444 ip_conntrack_helper_unregister(&sip[i]);
448 static int __init init(void)
454 ports[ports_c++] = SIP_PORT;
456 for (i = 0; i < ports_c; i++) {
457 /* Create helper structure */
458 memset(&sip[i], 0, sizeof(struct ip_conntrack_helper));
460 sip[i].tuple.dst.protonum = IPPROTO_UDP;
461 sip[i].tuple.src.u.udp.port = htons(ports[i]);
462 sip[i].mask.src.u.udp.port = htons(0xFFFF);
463 sip[i].mask.dst.protonum = 0xFF;
464 sip[i].max_expected = 2;
465 sip[i].timeout = 3 * 60; /* 3 minutes */
466 sip[i].me = THIS_MODULE;
467 sip[i].help = sip_help;
469 tmpname = &sip_names[i][0];
470 if (ports[i] == SIP_PORT)
471 sprintf(tmpname, "sip");
473 sprintf(tmpname, "sip-%d", i);
474 sip[i].name = tmpname;
476 DEBUGP("port #%d: %d\n", i, ports[i]);
478 ret = ip_conntrack_helper_register(&sip[i]);
480 printk("ERROR registering helper for port %d\n",