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.
5 * (C) 2007 United Security Providers
6 * (C) 2007, 2008 Patrick McHardy <kaber@trash.net>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 #include <linux/module.h>
16 #include <linux/ctype.h>
17 #include <linux/skbuff.h>
18 #include <linux/inet.h>
20 #include <linux/udp.h>
21 #include <linux/tcp.h>
22 #include <linux/netfilter.h>
24 #include <net/netfilter/nf_conntrack.h>
25 #include <net/netfilter/nf_conntrack_core.h>
26 #include <net/netfilter/nf_conntrack_expect.h>
27 #include <net/netfilter/nf_conntrack_helper.h>
28 #include <net/netfilter/nf_conntrack_zones.h>
29 #include <linux/netfilter/nf_conntrack_sip.h>
31 MODULE_LICENSE("GPL");
32 MODULE_AUTHOR("Christian Hentschel <chentschel@arnet.com.ar>");
33 MODULE_DESCRIPTION("SIP connection tracking helper");
34 MODULE_ALIAS("ip_conntrack_sip");
35 MODULE_ALIAS_NFCT_HELPER("sip");
38 static unsigned short ports[MAX_PORTS];
39 static unsigned int ports_c;
40 module_param_array(ports, ushort, &ports_c, 0400);
41 MODULE_PARM_DESC(ports, "port numbers of SIP servers");
43 static unsigned int sip_timeout __read_mostly = SIP_TIMEOUT;
44 module_param(sip_timeout, uint, 0600);
45 MODULE_PARM_DESC(sip_timeout, "timeout for the master SIP session");
47 static int sip_direct_signalling __read_mostly = 1;
48 module_param(sip_direct_signalling, int, 0600);
49 MODULE_PARM_DESC(sip_direct_signalling, "expect incoming calls from registrar "
52 static int sip_direct_media __read_mostly = 1;
53 module_param(sip_direct_media, int, 0600);
54 MODULE_PARM_DESC(sip_direct_media, "Expect Media streams between signalling "
55 "endpoints only (default 1)");
57 const struct nf_nat_sip_hooks *nf_nat_sip_hooks;
58 EXPORT_SYMBOL_GPL(nf_nat_sip_hooks);
60 static int string_len(const struct nf_conn *ct, const char *dptr,
61 const char *limit, int *shift)
65 while (dptr < limit && isalpha(*dptr)) {
72 static int digits_len(const struct nf_conn *ct, const char *dptr,
73 const char *limit, int *shift)
76 while (dptr < limit && isdigit(*dptr)) {
83 static int iswordc(const char c)
85 if (isalnum(c) || c == '!' || c == '"' || c == '%' ||
86 (c >= '(' && c <= '+') || c == ':' || c == '<' || c == '>' ||
87 c == '?' || (c >= '[' && c <= ']') || c == '_' || c == '`' ||
88 c == '{' || c == '}' || c == '~' || (c >= '-' && c <= '/') ||
94 static int word_len(const char *dptr, const char *limit)
97 while (dptr < limit && iswordc(*dptr)) {
104 static int callid_len(const struct nf_conn *ct, const char *dptr,
105 const char *limit, int *shift)
109 len = word_len(dptr, limit);
111 if (!len || dptr == limit || *dptr != '@')
116 domain_len = word_len(dptr, limit);
119 return len + domain_len;
122 /* get media type + port length */
123 static int media_len(const struct nf_conn *ct, const char *dptr,
124 const char *limit, int *shift)
126 int len = string_len(ct, dptr, limit, shift);
129 if (dptr >= limit || *dptr != ' ')
134 return len + digits_len(ct, dptr, limit, shift);
137 static int sip_parse_addr(const struct nf_conn *ct, const char *cp,
138 const char **endp, union nf_inet_addr *addr,
139 const char *limit, bool delim)
147 memset(addr, 0, sizeof(*addr));
148 switch (nf_ct_l3num(ct)) {
150 ret = in4_pton(cp, limit - cp, (u8 *)&addr->ip, -1, &end);
155 if (cp < limit && *cp == '[')
160 ret = in6_pton(cp, limit - cp, (u8 *)&addr->ip6, -1, &end);
164 if (end < limit && *end == ']')
178 /* skip ip address. returns its length. */
179 static int epaddr_len(const struct nf_conn *ct, const char *dptr,
180 const char *limit, int *shift)
182 union nf_inet_addr addr;
183 const char *aux = dptr;
185 if (!sip_parse_addr(ct, dptr, &dptr, &addr, limit, true)) {
186 pr_debug("ip: %s parse failed.!\n", dptr);
193 dptr += digits_len(ct, dptr, limit, shift);
198 /* get address length, skiping user info. */
199 static int skp_epaddr_len(const struct nf_conn *ct, const char *dptr,
200 const char *limit, int *shift)
202 const char *start = dptr;
205 /* Search for @, but stop at the end of the line.
206 * We are inside a sip: URI, so we don't need to worry about
207 * continuation lines. */
208 while (dptr < limit &&
209 *dptr != '@' && *dptr != '\r' && *dptr != '\n') {
214 if (dptr < limit && *dptr == '@') {
222 return epaddr_len(ct, dptr, limit, shift);
225 /* Parse a SIP request line of the form:
227 * Request-Line = Method SP Request-URI SP SIP-Version CRLF
229 * and return the offset and length of the address contained in the Request-URI.
231 int ct_sip_parse_request(const struct nf_conn *ct,
232 const char *dptr, unsigned int datalen,
233 unsigned int *matchoff, unsigned int *matchlen,
234 union nf_inet_addr *addr, __be16 *port)
236 const char *start = dptr, *limit = dptr + datalen, *end;
241 /* Skip method and following whitespace */
242 mlen = string_len(ct, dptr, limit, NULL);
250 for (; dptr < limit - strlen("sip:"); dptr++) {
251 if (*dptr == '\r' || *dptr == '\n')
253 if (strncasecmp(dptr, "sip:", strlen("sip:")) == 0) {
254 dptr += strlen("sip:");
258 if (!skp_epaddr_len(ct, dptr, limit, &shift))
262 if (!sip_parse_addr(ct, dptr, &end, addr, limit, true))
264 if (end < limit && *end == ':') {
266 p = simple_strtoul(end, (char **)&end, 10);
267 if (p < 1024 || p > 65535)
271 *port = htons(SIP_PORT);
275 *matchoff = dptr - start;
276 *matchlen = end - dptr;
279 EXPORT_SYMBOL_GPL(ct_sip_parse_request);
281 /* SIP header parsing: SIP headers are located at the beginning of a line, but
282 * may span several lines, in which case the continuation lines begin with a
283 * whitespace character. RFC 2543 allows lines to be terminated with CR, LF or
284 * CRLF, RFC 3261 allows only CRLF, we support both.
286 * Headers are followed by (optionally) whitespace, a colon, again (optionally)
287 * whitespace and the values. Whitespace in this context means any amount of
288 * tabs, spaces and continuation lines, which are treated as a single whitespace
291 * Some headers may appear multiple times. A comma separated list of values is
292 * equivalent to multiple headers.
294 static const struct sip_header ct_sip_hdrs[] = {
295 [SIP_HDR_CSEQ] = SIP_HDR("CSeq", NULL, NULL, digits_len),
296 [SIP_HDR_FROM] = SIP_HDR("From", "f", "sip:", skp_epaddr_len),
297 [SIP_HDR_TO] = SIP_HDR("To", "t", "sip:", skp_epaddr_len),
298 [SIP_HDR_CONTACT] = SIP_HDR("Contact", "m", "sip:", skp_epaddr_len),
299 [SIP_HDR_VIA_UDP] = SIP_HDR("Via", "v", "UDP ", epaddr_len),
300 [SIP_HDR_VIA_TCP] = SIP_HDR("Via", "v", "TCP ", epaddr_len),
301 [SIP_HDR_EXPIRES] = SIP_HDR("Expires", NULL, NULL, digits_len),
302 [SIP_HDR_CONTENT_LENGTH] = SIP_HDR("Content-Length", "l", NULL, digits_len),
303 [SIP_HDR_CALL_ID] = SIP_HDR("Call-Id", "i", NULL, callid_len),
306 static const char *sip_follow_continuation(const char *dptr, const char *limit)
308 /* Walk past newline */
312 /* Skip '\n' in CR LF */
313 if (*(dptr - 1) == '\r' && *dptr == '\n') {
318 /* Continuation line? */
319 if (*dptr != ' ' && *dptr != '\t')
322 /* skip leading whitespace */
323 for (; dptr < limit; dptr++) {
324 if (*dptr != ' ' && *dptr != '\t')
330 static const char *sip_skip_whitespace(const char *dptr, const char *limit)
332 for (; dptr < limit; dptr++) {
333 if (*dptr == ' ' || *dptr == '\t')
335 if (*dptr != '\r' && *dptr != '\n')
337 dptr = sip_follow_continuation(dptr, limit);
343 /* Search within a SIP header value, dealing with continuation lines */
344 static const char *ct_sip_header_search(const char *dptr, const char *limit,
345 const char *needle, unsigned int len)
347 for (limit -= len; dptr < limit; dptr++) {
348 if (*dptr == '\r' || *dptr == '\n') {
349 dptr = sip_follow_continuation(dptr, limit);
355 if (strncasecmp(dptr, needle, len) == 0)
361 int ct_sip_get_header(const struct nf_conn *ct, const char *dptr,
362 unsigned int dataoff, unsigned int datalen,
363 enum sip_header_types type,
364 unsigned int *matchoff, unsigned int *matchlen)
366 const struct sip_header *hdr = &ct_sip_hdrs[type];
367 const char *start = dptr, *limit = dptr + datalen;
370 for (dptr += dataoff; dptr < limit; dptr++) {
371 /* Find beginning of line */
372 if (*dptr != '\r' && *dptr != '\n')
376 if (*(dptr - 1) == '\r' && *dptr == '\n') {
381 /* Skip continuation lines */
382 if (*dptr == ' ' || *dptr == '\t')
385 /* Find header. Compact headers must be followed by a
386 * non-alphabetic character to avoid mismatches. */
387 if (limit - dptr >= hdr->len &&
388 strncasecmp(dptr, hdr->name, hdr->len) == 0)
390 else if (hdr->cname && limit - dptr >= hdr->clen + 1 &&
391 strncasecmp(dptr, hdr->cname, hdr->clen) == 0 &&
392 !isalpha(*(dptr + hdr->clen)))
397 /* Find and skip colon */
398 dptr = sip_skip_whitespace(dptr, limit);
401 if (*dptr != ':' || ++dptr >= limit)
404 /* Skip whitespace after colon */
405 dptr = sip_skip_whitespace(dptr, limit);
409 *matchoff = dptr - start;
411 dptr = ct_sip_header_search(dptr, limit, hdr->search,
418 *matchlen = hdr->match_len(ct, dptr, limit, &shift);
421 *matchoff = dptr - start + shift;
426 EXPORT_SYMBOL_GPL(ct_sip_get_header);
428 /* Get next header field in a list of comma separated values */
429 static int ct_sip_next_header(const struct nf_conn *ct, const char *dptr,
430 unsigned int dataoff, unsigned int datalen,
431 enum sip_header_types type,
432 unsigned int *matchoff, unsigned int *matchlen)
434 const struct sip_header *hdr = &ct_sip_hdrs[type];
435 const char *start = dptr, *limit = dptr + datalen;
440 dptr = ct_sip_header_search(dptr, limit, ",", strlen(","));
444 dptr = ct_sip_header_search(dptr, limit, hdr->search, hdr->slen);
449 *matchoff = dptr - start;
450 *matchlen = hdr->match_len(ct, dptr, limit, &shift);
457 /* Walk through headers until a parsable one is found or no header of the
458 * given type is left. */
459 static int ct_sip_walk_headers(const struct nf_conn *ct, const char *dptr,
460 unsigned int dataoff, unsigned int datalen,
461 enum sip_header_types type, int *in_header,
462 unsigned int *matchoff, unsigned int *matchlen)
466 if (in_header && *in_header) {
468 ret = ct_sip_next_header(ct, dptr, dataoff, datalen,
469 type, matchoff, matchlen);
474 dataoff += *matchoff;
480 ret = ct_sip_get_header(ct, dptr, dataoff, datalen,
481 type, matchoff, matchlen);
486 dataoff += *matchoff;
494 /* Locate a SIP header, parse the URI and return the offset and length of
495 * the address as well as the address and port themselves. A stream of
496 * headers can be parsed by handing in a non-NULL datalen and in_header
499 int ct_sip_parse_header_uri(const struct nf_conn *ct, const char *dptr,
500 unsigned int *dataoff, unsigned int datalen,
501 enum sip_header_types type, int *in_header,
502 unsigned int *matchoff, unsigned int *matchlen,
503 union nf_inet_addr *addr, __be16 *port)
505 const char *c, *limit = dptr + datalen;
509 ret = ct_sip_walk_headers(ct, dptr, dataoff ? *dataoff : 0, datalen,
510 type, in_header, matchoff, matchlen);
515 if (!sip_parse_addr(ct, dptr + *matchoff, &c, addr, limit, true))
519 p = simple_strtoul(c, (char **)&c, 10);
520 if (p < 1024 || p > 65535)
524 *port = htons(SIP_PORT);
530 EXPORT_SYMBOL_GPL(ct_sip_parse_header_uri);
532 static int ct_sip_parse_param(const struct nf_conn *ct, const char *dptr,
533 unsigned int dataoff, unsigned int datalen,
535 unsigned int *matchoff, unsigned int *matchlen)
537 const char *limit = dptr + datalen;
541 limit = ct_sip_header_search(dptr + dataoff, limit, ",", strlen(","));
543 limit = dptr + datalen;
545 start = ct_sip_header_search(dptr + dataoff, limit, name, strlen(name));
548 start += strlen(name);
550 end = ct_sip_header_search(start, limit, ";", strlen(";"));
554 *matchoff = start - dptr;
555 *matchlen = end - start;
559 /* Parse address from header parameter and return address, offset and length */
560 int ct_sip_parse_address_param(const struct nf_conn *ct, const char *dptr,
561 unsigned int dataoff, unsigned int datalen,
563 unsigned int *matchoff, unsigned int *matchlen,
564 union nf_inet_addr *addr, bool delim)
566 const char *limit = dptr + datalen;
567 const char *start, *end;
569 limit = ct_sip_header_search(dptr + dataoff, limit, ",", strlen(","));
571 limit = dptr + datalen;
573 start = ct_sip_header_search(dptr + dataoff, limit, name, strlen(name));
577 start += strlen(name);
578 if (!sip_parse_addr(ct, start, &end, addr, limit, delim))
580 *matchoff = start - dptr;
581 *matchlen = end - start;
584 EXPORT_SYMBOL_GPL(ct_sip_parse_address_param);
586 /* Parse numerical header parameter and return value, offset and length */
587 int ct_sip_parse_numerical_param(const struct nf_conn *ct, const char *dptr,
588 unsigned int dataoff, unsigned int datalen,
590 unsigned int *matchoff, unsigned int *matchlen,
593 const char *limit = dptr + datalen;
597 limit = ct_sip_header_search(dptr + dataoff, limit, ",", strlen(","));
599 limit = dptr + datalen;
601 start = ct_sip_header_search(dptr + dataoff, limit, name, strlen(name));
605 start += strlen(name);
606 *val = simple_strtoul(start, &end, 0);
609 if (matchoff && matchlen) {
610 *matchoff = start - dptr;
611 *matchlen = end - start;
615 EXPORT_SYMBOL_GPL(ct_sip_parse_numerical_param);
617 static int ct_sip_parse_transport(struct nf_conn *ct, const char *dptr,
618 unsigned int dataoff, unsigned int datalen,
621 unsigned int matchoff, matchlen;
623 if (ct_sip_parse_param(ct, dptr, dataoff, datalen, "transport=",
624 &matchoff, &matchlen)) {
625 if (!strncasecmp(dptr + matchoff, "TCP", strlen("TCP")))
626 *proto = IPPROTO_TCP;
627 else if (!strncasecmp(dptr + matchoff, "UDP", strlen("UDP")))
628 *proto = IPPROTO_UDP;
632 if (*proto != nf_ct_protonum(ct))
635 *proto = nf_ct_protonum(ct);
640 static int sdp_parse_addr(const struct nf_conn *ct, const char *cp,
641 const char **endp, union nf_inet_addr *addr,
647 memset(addr, 0, sizeof(*addr));
648 switch (nf_ct_l3num(ct)) {
650 ret = in4_pton(cp, limit - cp, (u8 *)&addr->ip, -1, &end);
653 ret = in6_pton(cp, limit - cp, (u8 *)&addr->ip6, -1, &end);
666 /* skip ip address. returns its length. */
667 static int sdp_addr_len(const struct nf_conn *ct, const char *dptr,
668 const char *limit, int *shift)
670 union nf_inet_addr addr;
671 const char *aux = dptr;
673 if (!sdp_parse_addr(ct, dptr, &dptr, &addr, limit)) {
674 pr_debug("ip: %s parse failed.!\n", dptr);
681 /* SDP header parsing: a SDP session description contains an ordered set of
682 * headers, starting with a section containing general session parameters,
683 * optionally followed by multiple media descriptions.
685 * SDP headers always start at the beginning of a line. According to RFC 2327:
686 * "The sequence CRLF (0x0d0a) is used to end a record, although parsers should
687 * be tolerant and also accept records terminated with a single newline
688 * character". We handle both cases.
690 static const struct sip_header ct_sdp_hdrs_v4[] = {
691 [SDP_HDR_VERSION] = SDP_HDR("v=", NULL, digits_len),
692 [SDP_HDR_OWNER] = SDP_HDR("o=", "IN IP4 ", sdp_addr_len),
693 [SDP_HDR_CONNECTION] = SDP_HDR("c=", "IN IP4 ", sdp_addr_len),
694 [SDP_HDR_MEDIA] = SDP_HDR("m=", NULL, media_len),
697 static const struct sip_header ct_sdp_hdrs_v6[] = {
698 [SDP_HDR_VERSION] = SDP_HDR("v=", NULL, digits_len),
699 [SDP_HDR_OWNER] = SDP_HDR("o=", "IN IP6 ", sdp_addr_len),
700 [SDP_HDR_CONNECTION] = SDP_HDR("c=", "IN IP6 ", sdp_addr_len),
701 [SDP_HDR_MEDIA] = SDP_HDR("m=", NULL, media_len),
704 /* Linear string search within SDP header values */
705 static const char *ct_sdp_header_search(const char *dptr, const char *limit,
706 const char *needle, unsigned int len)
708 for (limit -= len; dptr < limit; dptr++) {
709 if (*dptr == '\r' || *dptr == '\n')
711 if (strncmp(dptr, needle, len) == 0)
717 /* Locate a SDP header (optionally a substring within the header value),
718 * optionally stopping at the first occurrence of the term header, parse
719 * it and return the offset and length of the data we're interested in.
721 int ct_sip_get_sdp_header(const struct nf_conn *ct, const char *dptr,
722 unsigned int dataoff, unsigned int datalen,
723 enum sdp_header_types type,
724 enum sdp_header_types term,
725 unsigned int *matchoff, unsigned int *matchlen)
727 const struct sip_header *hdrs, *hdr, *thdr;
728 const char *start = dptr, *limit = dptr + datalen;
731 hdrs = nf_ct_l3num(ct) == NFPROTO_IPV4 ? ct_sdp_hdrs_v4 : ct_sdp_hdrs_v6;
735 for (dptr += dataoff; dptr < limit; dptr++) {
736 /* Find beginning of line */
737 if (*dptr != '\r' && *dptr != '\n')
741 if (*(dptr - 1) == '\r' && *dptr == '\n') {
746 if (term != SDP_HDR_UNSPEC &&
747 limit - dptr >= thdr->len &&
748 strncasecmp(dptr, thdr->name, thdr->len) == 0)
750 else if (limit - dptr >= hdr->len &&
751 strncasecmp(dptr, hdr->name, hdr->len) == 0)
756 *matchoff = dptr - start;
758 dptr = ct_sdp_header_search(dptr, limit, hdr->search,
765 *matchlen = hdr->match_len(ct, dptr, limit, &shift);
768 *matchoff = dptr - start + shift;
773 EXPORT_SYMBOL_GPL(ct_sip_get_sdp_header);
775 static int ct_sip_parse_sdp_addr(const struct nf_conn *ct, const char *dptr,
776 unsigned int dataoff, unsigned int datalen,
777 enum sdp_header_types type,
778 enum sdp_header_types term,
779 unsigned int *matchoff, unsigned int *matchlen,
780 union nf_inet_addr *addr)
784 ret = ct_sip_get_sdp_header(ct, dptr, dataoff, datalen, type, term,
789 if (!sdp_parse_addr(ct, dptr + *matchoff, NULL, addr,
790 dptr + *matchoff + *matchlen))
795 static int refresh_signalling_expectation(struct nf_conn *ct,
796 union nf_inet_addr *addr,
797 u8 proto, __be16 port,
798 unsigned int expires)
800 struct nf_conn_help *help = nfct_help(ct);
801 struct nf_conntrack_expect *exp;
802 struct hlist_node *next;
805 spin_lock_bh(&nf_conntrack_expect_lock);
806 hlist_for_each_entry_safe(exp, next, &help->expectations, lnode) {
807 if (exp->class != SIP_EXPECT_SIGNALLING ||
808 !nf_inet_addr_cmp(&exp->tuple.dst.u3, addr) ||
809 exp->tuple.dst.protonum != proto ||
810 exp->tuple.dst.u.udp.port != port)
812 if (mod_timer_pending(&exp->timeout, jiffies + expires * HZ)) {
813 exp->flags &= ~NF_CT_EXPECT_INACTIVE;
818 spin_unlock_bh(&nf_conntrack_expect_lock);
822 static void flush_expectations(struct nf_conn *ct, bool media)
824 struct nf_conn_help *help = nfct_help(ct);
825 struct nf_conntrack_expect *exp;
826 struct hlist_node *next;
828 spin_lock_bh(&nf_conntrack_expect_lock);
829 hlist_for_each_entry_safe(exp, next, &help->expectations, lnode) {
830 if ((exp->class != SIP_EXPECT_SIGNALLING) ^ media)
832 if (!nf_ct_remove_expect(exp))
837 spin_unlock_bh(&nf_conntrack_expect_lock);
840 static int set_expected_rtp_rtcp(struct sk_buff *skb, unsigned int protoff,
841 unsigned int dataoff,
842 const char **dptr, unsigned int *datalen,
843 union nf_inet_addr *daddr, __be16 port,
844 enum sip_expectation_classes class,
845 unsigned int mediaoff, unsigned int medialen)
847 struct nf_conntrack_expect *exp, *rtp_exp, *rtcp_exp;
848 enum ip_conntrack_info ctinfo;
849 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
850 struct net *net = nf_ct_net(ct);
851 enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
852 union nf_inet_addr *saddr;
853 struct nf_conntrack_tuple tuple;
854 int direct_rtp = 0, skip_expect = 0, ret = NF_DROP;
856 __be16 rtp_port, rtcp_port;
857 const struct nf_nat_sip_hooks *hooks;
860 if (sip_direct_media) {
861 if (!nf_inet_addr_cmp(daddr, &ct->tuplehash[dir].tuple.src.u3))
863 saddr = &ct->tuplehash[!dir].tuple.src.u3;
866 /* We need to check whether the registration exists before attempting
867 * to register it since we can see the same media description multiple
868 * times on different connections in case multiple endpoints receive
871 * RTP optimization: if we find a matching media channel expectation
872 * and both the expectation and this connection are SNATed, we assume
873 * both sides can reach each other directly and use the final
874 * destination address from the expectation. We still need to keep
875 * the NATed expectations for media that might arrive from the
876 * outside, and additionally need to expect the direct RTP stream
877 * in case it passes through us even without NAT.
879 memset(&tuple, 0, sizeof(tuple));
881 tuple.src.u3 = *saddr;
882 tuple.src.l3num = nf_ct_l3num(ct);
883 tuple.dst.protonum = IPPROTO_UDP;
884 tuple.dst.u3 = *daddr;
885 tuple.dst.u.udp.port = port;
889 exp = __nf_ct_expect_find(net, nf_ct_zone(ct), &tuple);
891 if (!exp || exp->master == ct ||
892 nfct_help(exp->master)->helper != nfct_help(ct)->helper ||
895 #ifdef CONFIG_NF_NAT_NEEDED
897 (!nf_inet_addr_cmp(&exp->saved_addr, &exp->tuple.dst.u3) ||
898 exp->saved_proto.udp.port != exp->tuple.dst.u.udp.port) &&
899 ct->status & IPS_NAT_MASK) {
900 *daddr = exp->saved_addr;
901 tuple.dst.u3 = exp->saved_addr;
902 tuple.dst.u.udp.port = exp->saved_proto.udp.port;
907 } while (!skip_expect);
909 base_port = ntohs(tuple.dst.u.udp.port) & ~1;
910 rtp_port = htons(base_port);
911 rtcp_port = htons(base_port + 1);
914 hooks = rcu_dereference(nf_nat_sip_hooks);
916 !hooks->sdp_port(skb, protoff, dataoff, dptr, datalen,
917 mediaoff, medialen, ntohs(rtp_port)))
926 rtp_exp = nf_ct_expect_alloc(ct);
929 nf_ct_expect_init(rtp_exp, class, nf_ct_l3num(ct), saddr, daddr,
930 IPPROTO_UDP, NULL, &rtp_port);
932 rtcp_exp = nf_ct_expect_alloc(ct);
933 if (rtcp_exp == NULL)
935 nf_ct_expect_init(rtcp_exp, class, nf_ct_l3num(ct), saddr, daddr,
936 IPPROTO_UDP, NULL, &rtcp_port);
938 hooks = rcu_dereference(nf_nat_sip_hooks);
939 if (hooks && ct->status & IPS_NAT_MASK && !direct_rtp)
940 ret = hooks->sdp_media(skb, protoff, dataoff, dptr,
941 datalen, rtp_exp, rtcp_exp,
942 mediaoff, medialen, daddr);
944 if (nf_ct_expect_related(rtp_exp) == 0) {
945 if (nf_ct_expect_related(rtcp_exp) != 0)
946 nf_ct_unexpect_related(rtp_exp);
951 nf_ct_expect_put(rtcp_exp);
953 nf_ct_expect_put(rtp_exp);
959 static const struct sdp_media_type sdp_media_types[] = {
960 SDP_MEDIA_TYPE("audio ", SIP_EXPECT_AUDIO),
961 SDP_MEDIA_TYPE("video ", SIP_EXPECT_VIDEO),
962 SDP_MEDIA_TYPE("image ", SIP_EXPECT_IMAGE),
965 static const struct sdp_media_type *sdp_media_type(const char *dptr,
966 unsigned int matchoff,
967 unsigned int matchlen)
969 const struct sdp_media_type *t;
972 for (i = 0; i < ARRAY_SIZE(sdp_media_types); i++) {
973 t = &sdp_media_types[i];
974 if (matchlen < t->len ||
975 strncmp(dptr + matchoff, t->name, t->len))
982 static int process_sdp(struct sk_buff *skb, unsigned int protoff,
983 unsigned int dataoff,
984 const char **dptr, unsigned int *datalen,
987 enum ip_conntrack_info ctinfo;
988 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
989 unsigned int matchoff, matchlen;
990 unsigned int mediaoff, medialen;
992 unsigned int caddr_len, maddr_len;
994 union nf_inet_addr caddr, maddr, rtp_addr;
995 const struct nf_nat_sip_hooks *hooks;
997 const struct sdp_media_type *t;
1000 hooks = rcu_dereference(nf_nat_sip_hooks);
1002 /* Find beginning of session description */
1003 if (ct_sip_get_sdp_header(ct, *dptr, 0, *datalen,
1004 SDP_HDR_VERSION, SDP_HDR_UNSPEC,
1005 &matchoff, &matchlen) <= 0)
1009 /* The connection information is contained in the session description
1010 * and/or once per media description. The first media description marks
1011 * the end of the session description. */
1013 if (ct_sip_parse_sdp_addr(ct, *dptr, sdpoff, *datalen,
1014 SDP_HDR_CONNECTION, SDP_HDR_MEDIA,
1015 &matchoff, &matchlen, &caddr) > 0)
1016 caddr_len = matchlen;
1019 for (i = 0; i < ARRAY_SIZE(sdp_media_types); ) {
1020 if (ct_sip_get_sdp_header(ct, *dptr, mediaoff, *datalen,
1021 SDP_HDR_MEDIA, SDP_HDR_UNSPEC,
1022 &mediaoff, &medialen) <= 0)
1025 /* Get media type and port number. A media port value of zero
1026 * indicates an inactive stream. */
1027 t = sdp_media_type(*dptr, mediaoff, medialen);
1029 mediaoff += medialen;
1035 port = simple_strtoul(*dptr + mediaoff, NULL, 10);
1038 if (port < 1024 || port > 65535) {
1039 nf_ct_helper_log(skb, ct, "wrong port %u", port);
1043 /* The media description overrides the session description. */
1045 if (ct_sip_parse_sdp_addr(ct, *dptr, mediaoff, *datalen,
1046 SDP_HDR_CONNECTION, SDP_HDR_MEDIA,
1047 &matchoff, &matchlen, &maddr) > 0) {
1048 maddr_len = matchlen;
1049 memcpy(&rtp_addr, &maddr, sizeof(rtp_addr));
1050 } else if (caddr_len)
1051 memcpy(&rtp_addr, &caddr, sizeof(rtp_addr));
1053 nf_ct_helper_log(skb, ct, "cannot parse SDP message");
1057 ret = set_expected_rtp_rtcp(skb, protoff, dataoff,
1059 &rtp_addr, htons(port), t->class,
1060 mediaoff, medialen);
1061 if (ret != NF_ACCEPT) {
1062 nf_ct_helper_log(skb, ct,
1063 "cannot add expectation for voice");
1067 /* Update media connection address if present */
1068 if (maddr_len && hooks && ct->status & IPS_NAT_MASK) {
1069 ret = hooks->sdp_addr(skb, protoff, dataoff,
1070 dptr, datalen, mediaoff,
1074 if (ret != NF_ACCEPT) {
1075 nf_ct_helper_log(skb, ct, "cannot mangle SDP");
1082 /* Update session connection and owner addresses */
1083 hooks = rcu_dereference(nf_nat_sip_hooks);
1084 if (hooks && ct->status & IPS_NAT_MASK)
1085 ret = hooks->sdp_session(skb, protoff, dataoff,
1086 dptr, datalen, sdpoff,
1091 static int process_invite_response(struct sk_buff *skb, unsigned int protoff,
1092 unsigned int dataoff,
1093 const char **dptr, unsigned int *datalen,
1094 unsigned int cseq, unsigned int code)
1096 enum ip_conntrack_info ctinfo;
1097 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1098 struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1100 if ((code >= 100 && code <= 199) ||
1101 (code >= 200 && code <= 299))
1102 return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq);
1103 else if (ct_sip_info->invite_cseq == cseq)
1104 flush_expectations(ct, true);
1108 static int process_update_response(struct sk_buff *skb, unsigned int protoff,
1109 unsigned int dataoff,
1110 const char **dptr, unsigned int *datalen,
1111 unsigned int cseq, unsigned int code)
1113 enum ip_conntrack_info ctinfo;
1114 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1115 struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1117 if ((code >= 100 && code <= 199) ||
1118 (code >= 200 && code <= 299))
1119 return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq);
1120 else if (ct_sip_info->invite_cseq == cseq)
1121 flush_expectations(ct, true);
1125 static int process_prack_response(struct sk_buff *skb, unsigned int protoff,
1126 unsigned int dataoff,
1127 const char **dptr, unsigned int *datalen,
1128 unsigned int cseq, unsigned int code)
1130 enum ip_conntrack_info ctinfo;
1131 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1132 struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1134 if ((code >= 100 && code <= 199) ||
1135 (code >= 200 && code <= 299))
1136 return process_sdp(skb, protoff, dataoff, dptr, datalen, cseq);
1137 else if (ct_sip_info->invite_cseq == cseq)
1138 flush_expectations(ct, true);
1142 static int process_invite_request(struct sk_buff *skb, unsigned int protoff,
1143 unsigned int dataoff,
1144 const char **dptr, unsigned int *datalen,
1147 enum ip_conntrack_info ctinfo;
1148 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1149 struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1152 flush_expectations(ct, true);
1153 ret = process_sdp(skb, protoff, dataoff, dptr, datalen, cseq);
1154 if (ret == NF_ACCEPT)
1155 ct_sip_info->invite_cseq = cseq;
1159 static int process_bye_request(struct sk_buff *skb, unsigned int protoff,
1160 unsigned int dataoff,
1161 const char **dptr, unsigned int *datalen,
1164 enum ip_conntrack_info ctinfo;
1165 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1167 flush_expectations(ct, true);
1171 /* Parse a REGISTER request and create a permanent expectation for incoming
1172 * signalling connections. The expectation is marked inactive and is activated
1173 * when receiving a response indicating success from the registrar.
1175 static int process_register_request(struct sk_buff *skb, unsigned int protoff,
1176 unsigned int dataoff,
1177 const char **dptr, unsigned int *datalen,
1180 enum ip_conntrack_info ctinfo;
1181 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1182 struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1183 enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
1184 unsigned int matchoff, matchlen;
1185 struct nf_conntrack_expect *exp;
1186 union nf_inet_addr *saddr, daddr;
1187 const struct nf_nat_sip_hooks *hooks;
1190 unsigned int expires = 0;
1193 /* Expected connections can not register again. */
1194 if (ct->status & IPS_EXPECTED)
1197 /* We must check the expiration time: a value of zero signals the
1198 * registrar to release the binding. We'll remove our expectation
1199 * when receiving the new bindings in the response, but we don't
1200 * want to create new ones.
1202 * The expiration time may be contained in Expires: header, the
1203 * Contact: header parameters or the URI parameters.
1205 if (ct_sip_get_header(ct, *dptr, 0, *datalen, SIP_HDR_EXPIRES,
1206 &matchoff, &matchlen) > 0)
1207 expires = simple_strtoul(*dptr + matchoff, NULL, 10);
1209 ret = ct_sip_parse_header_uri(ct, *dptr, NULL, *datalen,
1210 SIP_HDR_CONTACT, NULL,
1211 &matchoff, &matchlen, &daddr, &port);
1213 nf_ct_helper_log(skb, ct, "cannot parse contact");
1215 } else if (ret == 0)
1218 /* We don't support third-party registrations */
1219 if (!nf_inet_addr_cmp(&ct->tuplehash[dir].tuple.src.u3, &daddr))
1222 if (ct_sip_parse_transport(ct, *dptr, matchoff + matchlen, *datalen,
1226 if (ct_sip_parse_numerical_param(ct, *dptr,
1227 matchoff + matchlen, *datalen,
1228 "expires=", NULL, NULL, &expires) < 0) {
1229 nf_ct_helper_log(skb, ct, "cannot parse expires");
1238 exp = nf_ct_expect_alloc(ct);
1240 nf_ct_helper_log(skb, ct, "cannot alloc expectation");
1245 if (sip_direct_signalling)
1246 saddr = &ct->tuplehash[!dir].tuple.src.u3;
1248 nf_ct_expect_init(exp, SIP_EXPECT_SIGNALLING, nf_ct_l3num(ct),
1249 saddr, &daddr, proto, NULL, &port);
1250 exp->timeout.expires = sip_timeout * HZ;
1251 exp->helper = nfct_help(ct)->helper;
1252 exp->flags = NF_CT_EXPECT_PERMANENT | NF_CT_EXPECT_INACTIVE;
1254 hooks = rcu_dereference(nf_nat_sip_hooks);
1255 if (hooks && ct->status & IPS_NAT_MASK)
1256 ret = hooks->expect(skb, protoff, dataoff, dptr, datalen,
1257 exp, matchoff, matchlen);
1259 if (nf_ct_expect_related(exp) != 0) {
1260 nf_ct_helper_log(skb, ct, "cannot add expectation");
1265 nf_ct_expect_put(exp);
1268 if (ret == NF_ACCEPT)
1269 ct_sip_info->register_cseq = cseq;
1273 static int process_register_response(struct sk_buff *skb, unsigned int protoff,
1274 unsigned int dataoff,
1275 const char **dptr, unsigned int *datalen,
1276 unsigned int cseq, unsigned int code)
1278 enum ip_conntrack_info ctinfo;
1279 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1280 struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1281 enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
1282 union nf_inet_addr addr;
1285 unsigned int matchoff, matchlen, coff = 0;
1286 unsigned int expires = 0;
1287 int in_contact = 0, ret;
1289 /* According to RFC 3261, "UAs MUST NOT send a new registration until
1290 * they have received a final response from the registrar for the
1291 * previous one or the previous REGISTER request has timed out".
1293 * However, some servers fail to detect retransmissions and send late
1294 * responses, so we store the sequence number of the last valid
1295 * request and compare it here.
1297 if (ct_sip_info->register_cseq != cseq)
1300 if (code >= 100 && code <= 199)
1302 if (code < 200 || code > 299)
1305 if (ct_sip_get_header(ct, *dptr, 0, *datalen, SIP_HDR_EXPIRES,
1306 &matchoff, &matchlen) > 0)
1307 expires = simple_strtoul(*dptr + matchoff, NULL, 10);
1310 unsigned int c_expires = expires;
1312 ret = ct_sip_parse_header_uri(ct, *dptr, &coff, *datalen,
1313 SIP_HDR_CONTACT, &in_contact,
1314 &matchoff, &matchlen,
1317 nf_ct_helper_log(skb, ct, "cannot parse contact");
1319 } else if (ret == 0)
1322 /* We don't support third-party registrations */
1323 if (!nf_inet_addr_cmp(&ct->tuplehash[dir].tuple.dst.u3, &addr))
1326 if (ct_sip_parse_transport(ct, *dptr, matchoff + matchlen,
1327 *datalen, &proto) == 0)
1330 ret = ct_sip_parse_numerical_param(ct, *dptr,
1331 matchoff + matchlen,
1332 *datalen, "expires=",
1333 NULL, NULL, &c_expires);
1335 nf_ct_helper_log(skb, ct, "cannot parse expires");
1340 if (refresh_signalling_expectation(ct, &addr, proto, port,
1346 flush_expectations(ct, false);
1350 static const struct sip_handler sip_handlers[] = {
1351 SIP_HANDLER("INVITE", process_invite_request, process_invite_response),
1352 SIP_HANDLER("UPDATE", process_sdp, process_update_response),
1353 SIP_HANDLER("ACK", process_sdp, NULL),
1354 SIP_HANDLER("PRACK", process_sdp, process_prack_response),
1355 SIP_HANDLER("BYE", process_bye_request, NULL),
1356 SIP_HANDLER("REGISTER", process_register_request, process_register_response),
1359 static int process_sip_response(struct sk_buff *skb, unsigned int protoff,
1360 unsigned int dataoff,
1361 const char **dptr, unsigned int *datalen)
1363 enum ip_conntrack_info ctinfo;
1364 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1365 unsigned int matchoff, matchlen, matchend;
1366 unsigned int code, cseq, i;
1368 if (*datalen < strlen("SIP/2.0 200"))
1370 code = simple_strtoul(*dptr + strlen("SIP/2.0 "), NULL, 10);
1372 nf_ct_helper_log(skb, ct, "cannot get code");
1376 if (ct_sip_get_header(ct, *dptr, 0, *datalen, SIP_HDR_CSEQ,
1377 &matchoff, &matchlen) <= 0) {
1378 nf_ct_helper_log(skb, ct, "cannot parse cseq");
1381 cseq = simple_strtoul(*dptr + matchoff, NULL, 10);
1382 if (!cseq && *(*dptr + matchoff) != '0') {
1383 nf_ct_helper_log(skb, ct, "cannot get cseq");
1386 matchend = matchoff + matchlen + 1;
1388 for (i = 0; i < ARRAY_SIZE(sip_handlers); i++) {
1389 const struct sip_handler *handler;
1391 handler = &sip_handlers[i];
1392 if (handler->response == NULL)
1394 if (*datalen < matchend + handler->len ||
1395 strncasecmp(*dptr + matchend, handler->method, handler->len))
1397 return handler->response(skb, protoff, dataoff, dptr, datalen,
1403 static int process_sip_request(struct sk_buff *skb, unsigned int protoff,
1404 unsigned int dataoff,
1405 const char **dptr, unsigned int *datalen)
1407 enum ip_conntrack_info ctinfo;
1408 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1409 struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1410 enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
1411 unsigned int matchoff, matchlen;
1412 unsigned int cseq, i;
1413 union nf_inet_addr addr;
1416 /* Many Cisco IP phones use a high source port for SIP requests, but
1417 * listen for the response on port 5060. If we are the local
1418 * router for one of these phones, save the port number from the
1419 * Via: header so that nf_nat_sip can redirect the responses to
1422 if (ct_sip_parse_header_uri(ct, *dptr, NULL, *datalen,
1423 SIP_HDR_VIA_UDP, NULL, &matchoff,
1424 &matchlen, &addr, &port) > 0 &&
1425 port != ct->tuplehash[dir].tuple.src.u.udp.port &&
1426 nf_inet_addr_cmp(&addr, &ct->tuplehash[dir].tuple.src.u3))
1427 ct_sip_info->forced_dport = port;
1429 for (i = 0; i < ARRAY_SIZE(sip_handlers); i++) {
1430 const struct sip_handler *handler;
1432 handler = &sip_handlers[i];
1433 if (handler->request == NULL)
1435 if (*datalen < handler->len + 2 ||
1436 strncasecmp(*dptr, handler->method, handler->len))
1438 if ((*dptr)[handler->len] != ' ' ||
1439 !isalpha((*dptr)[handler->len+1]))
1442 if (ct_sip_get_header(ct, *dptr, 0, *datalen, SIP_HDR_CSEQ,
1443 &matchoff, &matchlen) <= 0) {
1444 nf_ct_helper_log(skb, ct, "cannot parse cseq");
1447 cseq = simple_strtoul(*dptr + matchoff, NULL, 10);
1448 if (!cseq && *(*dptr + matchoff) != '0') {
1449 nf_ct_helper_log(skb, ct, "cannot get cseq");
1453 return handler->request(skb, protoff, dataoff, dptr, datalen,
1459 static int process_sip_msg(struct sk_buff *skb, struct nf_conn *ct,
1460 unsigned int protoff, unsigned int dataoff,
1461 const char **dptr, unsigned int *datalen)
1463 const struct nf_nat_sip_hooks *hooks;
1466 if (strncasecmp(*dptr, "SIP/2.0 ", strlen("SIP/2.0 ")) != 0)
1467 ret = process_sip_request(skb, protoff, dataoff, dptr, datalen);
1469 ret = process_sip_response(skb, protoff, dataoff, dptr, datalen);
1471 if (ret == NF_ACCEPT && ct->status & IPS_NAT_MASK) {
1472 hooks = rcu_dereference(nf_nat_sip_hooks);
1473 if (hooks && !hooks->msg(skb, protoff, dataoff,
1475 nf_ct_helper_log(skb, ct, "cannot NAT SIP message");
1483 static int sip_help_tcp(struct sk_buff *skb, unsigned int protoff,
1484 struct nf_conn *ct, enum ip_conntrack_info ctinfo)
1486 struct tcphdr *th, _tcph;
1487 unsigned int dataoff, datalen;
1488 unsigned int matchoff, matchlen, clen;
1489 unsigned int msglen, origlen;
1490 const char *dptr, *end;
1491 s16 diff, tdiff = 0;
1492 int ret = NF_ACCEPT;
1495 if (ctinfo != IP_CT_ESTABLISHED &&
1496 ctinfo != IP_CT_ESTABLISHED_REPLY)
1500 th = skb_header_pointer(skb, protoff, sizeof(_tcph), &_tcph);
1503 dataoff = protoff + th->doff * 4;
1504 if (dataoff >= skb->len)
1507 nf_ct_refresh(ct, skb, sip_timeout * HZ);
1509 if (unlikely(skb_linearize(skb)))
1512 dptr = skb->data + dataoff;
1513 datalen = skb->len - dataoff;
1514 if (datalen < strlen("SIP/2.0 200"))
1518 if (ct_sip_get_header(ct, dptr, 0, datalen,
1519 SIP_HDR_CONTENT_LENGTH,
1520 &matchoff, &matchlen) <= 0)
1523 clen = simple_strtoul(dptr + matchoff, (char **)&end, 10);
1524 if (dptr + matchoff == end)
1528 for (; end + strlen("\r\n\r\n") <= dptr + datalen; end++) {
1529 if (end[0] == '\r' && end[1] == '\n' &&
1530 end[2] == '\r' && end[3] == '\n') {
1537 end += strlen("\r\n\r\n") + clen;
1539 msglen = origlen = end - dptr;
1540 if (msglen > datalen)
1543 ret = process_sip_msg(skb, ct, protoff, dataoff,
1545 /* process_sip_* functions report why this packet is dropped */
1546 if (ret != NF_ACCEPT)
1548 diff = msglen - origlen;
1553 datalen = datalen + diff - msglen;
1556 if (ret == NF_ACCEPT && ct->status & IPS_NAT_MASK) {
1557 const struct nf_nat_sip_hooks *hooks;
1559 hooks = rcu_dereference(nf_nat_sip_hooks);
1561 hooks->seq_adjust(skb, protoff, tdiff);
1567 static int sip_help_udp(struct sk_buff *skb, unsigned int protoff,
1568 struct nf_conn *ct, enum ip_conntrack_info ctinfo)
1570 unsigned int dataoff, datalen;
1574 dataoff = protoff + sizeof(struct udphdr);
1575 if (dataoff >= skb->len)
1578 nf_ct_refresh(ct, skb, sip_timeout * HZ);
1580 if (unlikely(skb_linearize(skb)))
1583 dptr = skb->data + dataoff;
1584 datalen = skb->len - dataoff;
1585 if (datalen < strlen("SIP/2.0 200"))
1588 return process_sip_msg(skb, ct, protoff, dataoff, &dptr, &datalen);
1591 static struct nf_conntrack_helper sip[MAX_PORTS * 4] __read_mostly;
1593 static const struct nf_conntrack_expect_policy sip_exp_policy[SIP_EXPECT_MAX + 1] = {
1594 [SIP_EXPECT_SIGNALLING] = {
1595 .name = "signalling",
1599 [SIP_EXPECT_AUDIO] = {
1601 .max_expected = 2 * IP_CT_DIR_MAX,
1604 [SIP_EXPECT_VIDEO] = {
1606 .max_expected = 2 * IP_CT_DIR_MAX,
1609 [SIP_EXPECT_IMAGE] = {
1611 .max_expected = IP_CT_DIR_MAX,
1616 static void nf_conntrack_sip_fini(void)
1618 nf_conntrack_helpers_unregister(sip, ports_c * 4);
1621 static int __init nf_conntrack_sip_init(void)
1625 NF_CT_HELPER_BUILD_BUG_ON(sizeof(struct nf_ct_sip_master));
1628 ports[ports_c++] = SIP_PORT;
1630 for (i = 0; i < ports_c; i++) {
1631 nf_ct_helper_init(&sip[4 * i], AF_INET, IPPROTO_UDP, "sip",
1632 SIP_PORT, ports[i], i, sip_exp_policy,
1633 SIP_EXPECT_MAX, sip_help_udp,
1635 nf_ct_helper_init(&sip[4 * i + 1], AF_INET, IPPROTO_TCP, "sip",
1636 SIP_PORT, ports[i], i, sip_exp_policy,
1637 SIP_EXPECT_MAX, sip_help_tcp,
1639 nf_ct_helper_init(&sip[4 * i + 2], AF_INET6, IPPROTO_UDP, "sip",
1640 SIP_PORT, ports[i], i, sip_exp_policy,
1641 SIP_EXPECT_MAX, sip_help_udp,
1643 nf_ct_helper_init(&sip[4 * i + 3], AF_INET6, IPPROTO_TCP, "sip",
1644 SIP_PORT, ports[i], i, sip_exp_policy,
1645 SIP_EXPECT_MAX, sip_help_tcp,
1649 ret = nf_conntrack_helpers_register(sip, ports_c * 4);
1651 pr_err("failed to register helpers\n");
1657 module_init(nf_conntrack_sip_init);
1658 module_exit(nf_conntrack_sip_fini);