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 #include <linux/module.h>
14 #include <linux/ctype.h>
15 #include <linux/skbuff.h>
16 #include <linux/inet.h>
18 #include <linux/udp.h>
19 #include <linux/tcp.h>
20 #include <linux/netfilter.h>
22 #include <net/netfilter/nf_conntrack.h>
23 #include <net/netfilter/nf_conntrack_core.h>
24 #include <net/netfilter/nf_conntrack_expect.h>
25 #include <net/netfilter/nf_conntrack_helper.h>
26 #include <net/netfilter/nf_conntrack_zones.h>
27 #include <linux/netfilter/nf_conntrack_sip.h>
29 MODULE_LICENSE("GPL");
30 MODULE_AUTHOR("Christian Hentschel <chentschel@arnet.com.ar>");
31 MODULE_DESCRIPTION("SIP connection tracking helper");
32 MODULE_ALIAS("ip_conntrack_sip");
33 MODULE_ALIAS_NFCT_HELPER("sip");
36 static unsigned short ports
[MAX_PORTS
];
37 static unsigned int ports_c
;
38 module_param_array(ports
, ushort
, &ports_c
, 0400);
39 MODULE_PARM_DESC(ports
, "port numbers of SIP servers");
41 static unsigned int sip_timeout __read_mostly
= SIP_TIMEOUT
;
42 module_param(sip_timeout
, uint
, 0600);
43 MODULE_PARM_DESC(sip_timeout
, "timeout for the master SIP session");
45 static int sip_direct_signalling __read_mostly
= 1;
46 module_param(sip_direct_signalling
, int, 0600);
47 MODULE_PARM_DESC(sip_direct_signalling
, "expect incoming calls from registrar "
50 static int sip_direct_media __read_mostly
= 1;
51 module_param(sip_direct_media
, int, 0600);
52 MODULE_PARM_DESC(sip_direct_media
, "Expect Media streams between signalling "
53 "endpoints only (default 1)");
55 const struct nf_nat_sip_hooks
*nf_nat_sip_hooks
;
56 EXPORT_SYMBOL_GPL(nf_nat_sip_hooks
);
58 static int string_len(const struct nf_conn
*ct
, const char *dptr
,
59 const char *limit
, int *shift
)
63 while (dptr
< limit
&& isalpha(*dptr
)) {
70 static int digits_len(const struct nf_conn
*ct
, const char *dptr
,
71 const char *limit
, int *shift
)
74 while (dptr
< limit
&& isdigit(*dptr
)) {
81 static int iswordc(const char c
)
83 if (isalnum(c
) || c
== '!' || c
== '"' || c
== '%' ||
84 (c
>= '(' && c
<= '/') || c
== ':' || c
== '<' || c
== '>' ||
85 c
== '?' || (c
>= '[' && c
<= ']') || c
== '_' || c
== '`' ||
86 c
== '{' || c
== '}' || c
== '~')
91 static int word_len(const char *dptr
, const char *limit
)
94 while (dptr
< limit
&& iswordc(*dptr
)) {
101 static int callid_len(const struct nf_conn
*ct
, const char *dptr
,
102 const char *limit
, int *shift
)
106 len
= word_len(dptr
, limit
);
108 if (!len
|| dptr
== limit
|| *dptr
!= '@')
113 domain_len
= word_len(dptr
, limit
);
116 return len
+ domain_len
;
119 /* get media type + port length */
120 static int media_len(const struct nf_conn
*ct
, const char *dptr
,
121 const char *limit
, int *shift
)
123 int len
= string_len(ct
, dptr
, limit
, shift
);
126 if (dptr
>= limit
|| *dptr
!= ' ')
131 return len
+ digits_len(ct
, dptr
, limit
, shift
);
134 static int sip_parse_addr(const struct nf_conn
*ct
, const char *cp
,
135 const char **endp
, union nf_inet_addr
*addr
,
136 const char *limit
, bool delim
)
144 memset(addr
, 0, sizeof(*addr
));
145 switch (nf_ct_l3num(ct
)) {
147 ret
= in4_pton(cp
, limit
- cp
, (u8
*)&addr
->ip
, -1, &end
);
152 if (cp
< limit
&& *cp
== '[')
157 ret
= in6_pton(cp
, limit
- cp
, (u8
*)&addr
->ip6
, -1, &end
);
161 if (end
< limit
&& *end
== ']')
175 /* skip ip address. returns its length. */
176 static int epaddr_len(const struct nf_conn
*ct
, const char *dptr
,
177 const char *limit
, int *shift
)
179 union nf_inet_addr addr
;
180 const char *aux
= dptr
;
182 if (!sip_parse_addr(ct
, dptr
, &dptr
, &addr
, limit
, true)) {
183 pr_debug("ip: %s parse failed.!\n", dptr
);
190 dptr
+= digits_len(ct
, dptr
, limit
, shift
);
195 /* get address length, skiping user info. */
196 static int skp_epaddr_len(const struct nf_conn
*ct
, const char *dptr
,
197 const char *limit
, int *shift
)
199 const char *start
= dptr
;
202 /* Search for @, but stop at the end of the line.
203 * We are inside a sip: URI, so we don't need to worry about
204 * continuation lines. */
205 while (dptr
< limit
&&
206 *dptr
!= '@' && *dptr
!= '\r' && *dptr
!= '\n') {
211 if (dptr
< limit
&& *dptr
== '@') {
219 return epaddr_len(ct
, dptr
, limit
, shift
);
222 /* Parse a SIP request line of the form:
224 * Request-Line = Method SP Request-URI SP SIP-Version CRLF
226 * and return the offset and length of the address contained in the Request-URI.
228 int ct_sip_parse_request(const struct nf_conn
*ct
,
229 const char *dptr
, unsigned int datalen
,
230 unsigned int *matchoff
, unsigned int *matchlen
,
231 union nf_inet_addr
*addr
, __be16
*port
)
233 const char *start
= dptr
, *limit
= dptr
+ datalen
, *end
;
238 /* Skip method and following whitespace */
239 mlen
= string_len(ct
, dptr
, limit
, NULL
);
247 for (; dptr
< limit
- strlen("sip:"); dptr
++) {
248 if (*dptr
== '\r' || *dptr
== '\n')
250 if (strnicmp(dptr
, "sip:", strlen("sip:")) == 0) {
251 dptr
+= strlen("sip:");
255 if (!skp_epaddr_len(ct
, dptr
, limit
, &shift
))
259 if (!sip_parse_addr(ct
, dptr
, &end
, addr
, limit
, true))
261 if (end
< limit
&& *end
== ':') {
263 p
= simple_strtoul(end
, (char **)&end
, 10);
264 if (p
< 1024 || p
> 65535)
268 *port
= htons(SIP_PORT
);
272 *matchoff
= dptr
- start
;
273 *matchlen
= end
- dptr
;
276 EXPORT_SYMBOL_GPL(ct_sip_parse_request
);
278 /* SIP header parsing: SIP headers are located at the beginning of a line, but
279 * may span several lines, in which case the continuation lines begin with a
280 * whitespace character. RFC 2543 allows lines to be terminated with CR, LF or
281 * CRLF, RFC 3261 allows only CRLF, we support both.
283 * Headers are followed by (optionally) whitespace, a colon, again (optionally)
284 * whitespace and the values. Whitespace in this context means any amount of
285 * tabs, spaces and continuation lines, which are treated as a single whitespace
288 * Some headers may appear multiple times. A comma separated list of values is
289 * equivalent to multiple headers.
291 static const struct sip_header ct_sip_hdrs
[] = {
292 [SIP_HDR_CSEQ
] = SIP_HDR("CSeq", NULL
, NULL
, digits_len
),
293 [SIP_HDR_FROM
] = SIP_HDR("From", "f", "sip:", skp_epaddr_len
),
294 [SIP_HDR_TO
] = SIP_HDR("To", "t", "sip:", skp_epaddr_len
),
295 [SIP_HDR_CONTACT
] = SIP_HDR("Contact", "m", "sip:", skp_epaddr_len
),
296 [SIP_HDR_VIA_UDP
] = SIP_HDR("Via", "v", "UDP ", epaddr_len
),
297 [SIP_HDR_VIA_TCP
] = SIP_HDR("Via", "v", "TCP ", epaddr_len
),
298 [SIP_HDR_EXPIRES
] = SIP_HDR("Expires", NULL
, NULL
, digits_len
),
299 [SIP_HDR_CONTENT_LENGTH
] = SIP_HDR("Content-Length", "l", NULL
, digits_len
),
300 [SIP_HDR_CALL_ID
] = SIP_HDR("Call-Id", "i", NULL
, callid_len
),
303 static const char *sip_follow_continuation(const char *dptr
, const char *limit
)
305 /* Walk past newline */
309 /* Skip '\n' in CR LF */
310 if (*(dptr
- 1) == '\r' && *dptr
== '\n') {
315 /* Continuation line? */
316 if (*dptr
!= ' ' && *dptr
!= '\t')
319 /* skip leading whitespace */
320 for (; dptr
< limit
; dptr
++) {
321 if (*dptr
!= ' ' && *dptr
!= '\t')
327 static const char *sip_skip_whitespace(const char *dptr
, const char *limit
)
329 for (; dptr
< limit
; dptr
++) {
332 if (*dptr
!= '\r' && *dptr
!= '\n')
334 dptr
= sip_follow_continuation(dptr
, limit
);
341 /* Search within a SIP header value, dealing with continuation lines */
342 static const char *ct_sip_header_search(const char *dptr
, const char *limit
,
343 const char *needle
, unsigned int len
)
345 for (limit
-= len
; dptr
< limit
; dptr
++) {
346 if (*dptr
== '\r' || *dptr
== '\n') {
347 dptr
= sip_follow_continuation(dptr
, limit
);
353 if (strnicmp(dptr
, needle
, len
) == 0)
359 int ct_sip_get_header(const struct nf_conn
*ct
, const char *dptr
,
360 unsigned int dataoff
, unsigned int datalen
,
361 enum sip_header_types type
,
362 unsigned int *matchoff
, unsigned int *matchlen
)
364 const struct sip_header
*hdr
= &ct_sip_hdrs
[type
];
365 const char *start
= dptr
, *limit
= dptr
+ datalen
;
368 for (dptr
+= dataoff
; dptr
< limit
; dptr
++) {
369 /* Find beginning of line */
370 if (*dptr
!= '\r' && *dptr
!= '\n')
374 if (*(dptr
- 1) == '\r' && *dptr
== '\n') {
379 /* Skip continuation lines */
380 if (*dptr
== ' ' || *dptr
== '\t')
383 /* Find header. Compact headers must be followed by a
384 * non-alphabetic character to avoid mismatches. */
385 if (limit
- dptr
>= hdr
->len
&&
386 strnicmp(dptr
, hdr
->name
, hdr
->len
) == 0)
388 else if (hdr
->cname
&& limit
- dptr
>= hdr
->clen
+ 1 &&
389 strnicmp(dptr
, hdr
->cname
, hdr
->clen
) == 0 &&
390 !isalpha(*(dptr
+ hdr
->clen
)))
395 /* Find and skip colon */
396 dptr
= sip_skip_whitespace(dptr
, limit
);
399 if (*dptr
!= ':' || ++dptr
>= limit
)
402 /* Skip whitespace after colon */
403 dptr
= sip_skip_whitespace(dptr
, limit
);
407 *matchoff
= dptr
- start
;
409 dptr
= ct_sip_header_search(dptr
, limit
, hdr
->search
,
416 *matchlen
= hdr
->match_len(ct
, dptr
, limit
, &shift
);
419 *matchoff
= dptr
- start
+ shift
;
424 EXPORT_SYMBOL_GPL(ct_sip_get_header
);
426 /* Get next header field in a list of comma separated values */
427 static int ct_sip_next_header(const struct nf_conn
*ct
, const char *dptr
,
428 unsigned int dataoff
, unsigned int datalen
,
429 enum sip_header_types type
,
430 unsigned int *matchoff
, unsigned int *matchlen
)
432 const struct sip_header
*hdr
= &ct_sip_hdrs
[type
];
433 const char *start
= dptr
, *limit
= dptr
+ datalen
;
438 dptr
= ct_sip_header_search(dptr
, limit
, ",", strlen(","));
442 dptr
= ct_sip_header_search(dptr
, limit
, hdr
->search
, hdr
->slen
);
447 *matchoff
= dptr
- start
;
448 *matchlen
= hdr
->match_len(ct
, dptr
, limit
, &shift
);
455 /* Walk through headers until a parsable one is found or no header of the
456 * given type is left. */
457 static int ct_sip_walk_headers(const struct nf_conn
*ct
, const char *dptr
,
458 unsigned int dataoff
, unsigned int datalen
,
459 enum sip_header_types type
, int *in_header
,
460 unsigned int *matchoff
, unsigned int *matchlen
)
464 if (in_header
&& *in_header
) {
466 ret
= ct_sip_next_header(ct
, dptr
, dataoff
, datalen
,
467 type
, matchoff
, matchlen
);
472 dataoff
+= *matchoff
;
478 ret
= ct_sip_get_header(ct
, dptr
, dataoff
, datalen
,
479 type
, matchoff
, matchlen
);
484 dataoff
+= *matchoff
;
492 /* Locate a SIP header, parse the URI and return the offset and length of
493 * the address as well as the address and port themselves. A stream of
494 * headers can be parsed by handing in a non-NULL datalen and in_header
497 int ct_sip_parse_header_uri(const struct nf_conn
*ct
, const char *dptr
,
498 unsigned int *dataoff
, unsigned int datalen
,
499 enum sip_header_types type
, int *in_header
,
500 unsigned int *matchoff
, unsigned int *matchlen
,
501 union nf_inet_addr
*addr
, __be16
*port
)
503 const char *c
, *limit
= dptr
+ datalen
;
507 ret
= ct_sip_walk_headers(ct
, dptr
, dataoff
? *dataoff
: 0, datalen
,
508 type
, in_header
, matchoff
, matchlen
);
513 if (!sip_parse_addr(ct
, dptr
+ *matchoff
, &c
, addr
, limit
, true))
517 p
= simple_strtoul(c
, (char **)&c
, 10);
518 if (p
< 1024 || p
> 65535)
522 *port
= htons(SIP_PORT
);
528 EXPORT_SYMBOL_GPL(ct_sip_parse_header_uri
);
530 static int ct_sip_parse_param(const struct nf_conn
*ct
, const char *dptr
,
531 unsigned int dataoff
, unsigned int datalen
,
533 unsigned int *matchoff
, unsigned int *matchlen
)
535 const char *limit
= dptr
+ datalen
;
539 limit
= ct_sip_header_search(dptr
+ dataoff
, limit
, ",", strlen(","));
541 limit
= dptr
+ datalen
;
543 start
= ct_sip_header_search(dptr
+ dataoff
, limit
, name
, strlen(name
));
546 start
+= strlen(name
);
548 end
= ct_sip_header_search(start
, limit
, ";", strlen(";"));
552 *matchoff
= start
- dptr
;
553 *matchlen
= end
- start
;
557 /* Parse address from header parameter and return address, offset and length */
558 int ct_sip_parse_address_param(const struct nf_conn
*ct
, const char *dptr
,
559 unsigned int dataoff
, unsigned int datalen
,
561 unsigned int *matchoff
, unsigned int *matchlen
,
562 union nf_inet_addr
*addr
, bool delim
)
564 const char *limit
= dptr
+ datalen
;
565 const char *start
, *end
;
567 limit
= ct_sip_header_search(dptr
+ dataoff
, limit
, ",", strlen(","));
569 limit
= dptr
+ datalen
;
571 start
= ct_sip_header_search(dptr
+ dataoff
, limit
, name
, strlen(name
));
575 start
+= strlen(name
);
576 if (!sip_parse_addr(ct
, start
, &end
, addr
, limit
, delim
))
578 *matchoff
= start
- dptr
;
579 *matchlen
= end
- start
;
582 EXPORT_SYMBOL_GPL(ct_sip_parse_address_param
);
584 /* Parse numerical header parameter and return value, offset and length */
585 int ct_sip_parse_numerical_param(const struct nf_conn
*ct
, const char *dptr
,
586 unsigned int dataoff
, unsigned int datalen
,
588 unsigned int *matchoff
, unsigned int *matchlen
,
591 const char *limit
= dptr
+ datalen
;
595 limit
= ct_sip_header_search(dptr
+ dataoff
, limit
, ",", strlen(","));
597 limit
= dptr
+ datalen
;
599 start
= ct_sip_header_search(dptr
+ dataoff
, limit
, name
, strlen(name
));
603 start
+= strlen(name
);
604 *val
= simple_strtoul(start
, &end
, 0);
607 if (matchoff
&& matchlen
) {
608 *matchoff
= start
- dptr
;
609 *matchlen
= end
- start
;
613 EXPORT_SYMBOL_GPL(ct_sip_parse_numerical_param
);
615 static int ct_sip_parse_transport(struct nf_conn
*ct
, const char *dptr
,
616 unsigned int dataoff
, unsigned int datalen
,
619 unsigned int matchoff
, matchlen
;
621 if (ct_sip_parse_param(ct
, dptr
, dataoff
, datalen
, "transport=",
622 &matchoff
, &matchlen
)) {
623 if (!strnicmp(dptr
+ matchoff
, "TCP", strlen("TCP")))
624 *proto
= IPPROTO_TCP
;
625 else if (!strnicmp(dptr
+ matchoff
, "UDP", strlen("UDP")))
626 *proto
= IPPROTO_UDP
;
630 if (*proto
!= nf_ct_protonum(ct
))
633 *proto
= nf_ct_protonum(ct
);
638 static int sdp_parse_addr(const struct nf_conn
*ct
, const char *cp
,
639 const char **endp
, union nf_inet_addr
*addr
,
645 memset(addr
, 0, sizeof(*addr
));
646 switch (nf_ct_l3num(ct
)) {
648 ret
= in4_pton(cp
, limit
- cp
, (u8
*)&addr
->ip
, -1, &end
);
651 ret
= in6_pton(cp
, limit
- cp
, (u8
*)&addr
->ip6
, -1, &end
);
664 /* skip ip address. returns its length. */
665 static int sdp_addr_len(const struct nf_conn
*ct
, const char *dptr
,
666 const char *limit
, int *shift
)
668 union nf_inet_addr addr
;
669 const char *aux
= dptr
;
671 if (!sdp_parse_addr(ct
, dptr
, &dptr
, &addr
, limit
)) {
672 pr_debug("ip: %s parse failed.!\n", dptr
);
679 /* SDP header parsing: a SDP session description contains an ordered set of
680 * headers, starting with a section containing general session parameters,
681 * optionally followed by multiple media descriptions.
683 * SDP headers always start at the beginning of a line. According to RFC 2327:
684 * "The sequence CRLF (0x0d0a) is used to end a record, although parsers should
685 * be tolerant and also accept records terminated with a single newline
686 * character". We handle both cases.
688 static const struct sip_header ct_sdp_hdrs_v4
[] = {
689 [SDP_HDR_VERSION
] = SDP_HDR("v=", NULL
, digits_len
),
690 [SDP_HDR_OWNER
] = SDP_HDR("o=", "IN IP4 ", sdp_addr_len
),
691 [SDP_HDR_CONNECTION
] = SDP_HDR("c=", "IN IP4 ", sdp_addr_len
),
692 [SDP_HDR_MEDIA
] = SDP_HDR("m=", NULL
, media_len
),
695 static const struct sip_header ct_sdp_hdrs_v6
[] = {
696 [SDP_HDR_VERSION
] = SDP_HDR("v=", NULL
, digits_len
),
697 [SDP_HDR_OWNER
] = SDP_HDR("o=", "IN IP6 ", sdp_addr_len
),
698 [SDP_HDR_CONNECTION
] = SDP_HDR("c=", "IN IP6 ", sdp_addr_len
),
699 [SDP_HDR_MEDIA
] = SDP_HDR("m=", NULL
, media_len
),
702 /* Linear string search within SDP header values */
703 static const char *ct_sdp_header_search(const char *dptr
, const char *limit
,
704 const char *needle
, unsigned int len
)
706 for (limit
-= len
; dptr
< limit
; dptr
++) {
707 if (*dptr
== '\r' || *dptr
== '\n')
709 if (strncmp(dptr
, needle
, len
) == 0)
715 /* Locate a SDP header (optionally a substring within the header value),
716 * optionally stopping at the first occurrence of the term header, parse
717 * it and return the offset and length of the data we're interested in.
719 int ct_sip_get_sdp_header(const struct nf_conn
*ct
, const char *dptr
,
720 unsigned int dataoff
, unsigned int datalen
,
721 enum sdp_header_types type
,
722 enum sdp_header_types term
,
723 unsigned int *matchoff
, unsigned int *matchlen
)
725 const struct sip_header
*hdrs
, *hdr
, *thdr
;
726 const char *start
= dptr
, *limit
= dptr
+ datalen
;
729 hdrs
= nf_ct_l3num(ct
) == NFPROTO_IPV4
? ct_sdp_hdrs_v4
: ct_sdp_hdrs_v6
;
733 for (dptr
+= dataoff
; dptr
< limit
; dptr
++) {
734 /* Find beginning of line */
735 if (*dptr
!= '\r' && *dptr
!= '\n')
739 if (*(dptr
- 1) == '\r' && *dptr
== '\n') {
744 if (term
!= SDP_HDR_UNSPEC
&&
745 limit
- dptr
>= thdr
->len
&&
746 strnicmp(dptr
, thdr
->name
, thdr
->len
) == 0)
748 else if (limit
- dptr
>= hdr
->len
&&
749 strnicmp(dptr
, hdr
->name
, hdr
->len
) == 0)
754 *matchoff
= dptr
- start
;
756 dptr
= ct_sdp_header_search(dptr
, limit
, hdr
->search
,
763 *matchlen
= hdr
->match_len(ct
, dptr
, limit
, &shift
);
766 *matchoff
= dptr
- start
+ shift
;
771 EXPORT_SYMBOL_GPL(ct_sip_get_sdp_header
);
773 static int ct_sip_parse_sdp_addr(const struct nf_conn
*ct
, const char *dptr
,
774 unsigned int dataoff
, unsigned int datalen
,
775 enum sdp_header_types type
,
776 enum sdp_header_types term
,
777 unsigned int *matchoff
, unsigned int *matchlen
,
778 union nf_inet_addr
*addr
)
782 ret
= ct_sip_get_sdp_header(ct
, dptr
, dataoff
, datalen
, type
, term
,
787 if (!sdp_parse_addr(ct
, dptr
+ *matchoff
, NULL
, addr
,
788 dptr
+ *matchoff
+ *matchlen
))
793 static int refresh_signalling_expectation(struct nf_conn
*ct
,
794 union nf_inet_addr
*addr
,
795 u8 proto
, __be16 port
,
796 unsigned int expires
)
798 struct nf_conn_help
*help
= nfct_help(ct
);
799 struct nf_conntrack_expect
*exp
;
800 struct hlist_node
*next
;
803 spin_lock_bh(&nf_conntrack_lock
);
804 hlist_for_each_entry_safe(exp
, next
, &help
->expectations
, lnode
) {
805 if (exp
->class != SIP_EXPECT_SIGNALLING
||
806 !nf_inet_addr_cmp(&exp
->tuple
.dst
.u3
, addr
) ||
807 exp
->tuple
.dst
.protonum
!= proto
||
808 exp
->tuple
.dst
.u
.udp
.port
!= port
)
810 if (!del_timer(&exp
->timeout
))
812 exp
->flags
&= ~NF_CT_EXPECT_INACTIVE
;
813 exp
->timeout
.expires
= jiffies
+ expires
* HZ
;
814 add_timer(&exp
->timeout
);
818 spin_unlock_bh(&nf_conntrack_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_lock
);
829 hlist_for_each_entry_safe(exp
, next
, &help
->expectations
, lnode
) {
830 if ((exp
->class != SIP_EXPECT_SIGNALLING
) ^ media
)
832 if (!del_timer(&exp
->timeout
))
834 nf_ct_unlink_expect(exp
);
835 nf_ct_expect_put(exp
);
839 spin_unlock_bh(&nf_conntrack_lock
);
842 static int set_expected_rtp_rtcp(struct sk_buff
*skb
, unsigned int protoff
,
843 unsigned int dataoff
,
844 const char **dptr
, unsigned int *datalen
,
845 union nf_inet_addr
*daddr
, __be16 port
,
846 enum sip_expectation_classes
class,
847 unsigned int mediaoff
, unsigned int medialen
)
849 struct nf_conntrack_expect
*exp
, *rtp_exp
, *rtcp_exp
;
850 enum ip_conntrack_info ctinfo
;
851 struct nf_conn
*ct
= nf_ct_get(skb
, &ctinfo
);
852 struct net
*net
= nf_ct_net(ct
);
853 enum ip_conntrack_dir dir
= CTINFO2DIR(ctinfo
);
854 union nf_inet_addr
*saddr
;
855 struct nf_conntrack_tuple tuple
;
856 int direct_rtp
= 0, skip_expect
= 0, ret
= NF_DROP
;
858 __be16 rtp_port
, rtcp_port
;
859 const struct nf_nat_sip_hooks
*hooks
;
862 if (sip_direct_media
) {
863 if (!nf_inet_addr_cmp(daddr
, &ct
->tuplehash
[dir
].tuple
.src
.u3
))
865 saddr
= &ct
->tuplehash
[!dir
].tuple
.src
.u3
;
868 /* We need to check whether the registration exists before attempting
869 * to register it since we can see the same media description multiple
870 * times on different connections in case multiple endpoints receive
873 * RTP optimization: if we find a matching media channel expectation
874 * and both the expectation and this connection are SNATed, we assume
875 * both sides can reach each other directly and use the final
876 * destination address from the expectation. We still need to keep
877 * the NATed expectations for media that might arrive from the
878 * outside, and additionally need to expect the direct RTP stream
879 * in case it passes through us even without NAT.
881 memset(&tuple
, 0, sizeof(tuple
));
883 tuple
.src
.u3
= *saddr
;
884 tuple
.src
.l3num
= nf_ct_l3num(ct
);
885 tuple
.dst
.protonum
= IPPROTO_UDP
;
886 tuple
.dst
.u3
= *daddr
;
887 tuple
.dst
.u
.udp
.port
= port
;
891 exp
= __nf_ct_expect_find(net
, nf_ct_zone(ct
), &tuple
);
893 if (!exp
|| exp
->master
== ct
||
894 nfct_help(exp
->master
)->helper
!= nfct_help(ct
)->helper
||
897 #ifdef CONFIG_NF_NAT_NEEDED
899 (!nf_inet_addr_cmp(&exp
->saved_addr
, &exp
->tuple
.dst
.u3
) ||
900 exp
->saved_proto
.udp
.port
!= exp
->tuple
.dst
.u
.udp
.port
) &&
901 ct
->status
& IPS_NAT_MASK
) {
902 *daddr
= exp
->saved_addr
;
903 tuple
.dst
.u3
= exp
->saved_addr
;
904 tuple
.dst
.u
.udp
.port
= exp
->saved_proto
.udp
.port
;
909 } while (!skip_expect
);
911 base_port
= ntohs(tuple
.dst
.u
.udp
.port
) & ~1;
912 rtp_port
= htons(base_port
);
913 rtcp_port
= htons(base_port
+ 1);
916 hooks
= rcu_dereference(nf_nat_sip_hooks
);
918 !hooks
->sdp_port(skb
, protoff
, dataoff
, dptr
, datalen
,
919 mediaoff
, medialen
, ntohs(rtp_port
)))
928 rtp_exp
= nf_ct_expect_alloc(ct
);
931 nf_ct_expect_init(rtp_exp
, class, nf_ct_l3num(ct
), saddr
, daddr
,
932 IPPROTO_UDP
, NULL
, &rtp_port
);
934 rtcp_exp
= nf_ct_expect_alloc(ct
);
935 if (rtcp_exp
== NULL
)
937 nf_ct_expect_init(rtcp_exp
, class, nf_ct_l3num(ct
), saddr
, daddr
,
938 IPPROTO_UDP
, NULL
, &rtcp_port
);
940 hooks
= rcu_dereference(nf_nat_sip_hooks
);
941 if (hooks
&& ct
->status
& IPS_NAT_MASK
&& !direct_rtp
)
942 ret
= hooks
->sdp_media(skb
, protoff
, dataoff
, dptr
,
943 datalen
, rtp_exp
, rtcp_exp
,
944 mediaoff
, medialen
, daddr
);
946 if (nf_ct_expect_related(rtp_exp
) == 0) {
947 if (nf_ct_expect_related(rtcp_exp
) != 0)
948 nf_ct_unexpect_related(rtp_exp
);
953 nf_ct_expect_put(rtcp_exp
);
955 nf_ct_expect_put(rtp_exp
);
961 static const struct sdp_media_type sdp_media_types
[] = {
962 SDP_MEDIA_TYPE("audio ", SIP_EXPECT_AUDIO
),
963 SDP_MEDIA_TYPE("video ", SIP_EXPECT_VIDEO
),
964 SDP_MEDIA_TYPE("image ", SIP_EXPECT_IMAGE
),
967 static const struct sdp_media_type
*sdp_media_type(const char *dptr
,
968 unsigned int matchoff
,
969 unsigned int matchlen
)
971 const struct sdp_media_type
*t
;
974 for (i
= 0; i
< ARRAY_SIZE(sdp_media_types
); i
++) {
975 t
= &sdp_media_types
[i
];
976 if (matchlen
< t
->len
||
977 strncmp(dptr
+ matchoff
, t
->name
, t
->len
))
984 static int process_sdp(struct sk_buff
*skb
, unsigned int protoff
,
985 unsigned int dataoff
,
986 const char **dptr
, unsigned int *datalen
,
989 enum ip_conntrack_info ctinfo
;
990 struct nf_conn
*ct
= nf_ct_get(skb
, &ctinfo
);
991 unsigned int matchoff
, matchlen
;
992 unsigned int mediaoff
, medialen
;
994 unsigned int caddr_len
, maddr_len
;
996 union nf_inet_addr caddr
, maddr
, rtp_addr
;
997 const struct nf_nat_sip_hooks
*hooks
;
999 const struct sdp_media_type
*t
;
1000 int ret
= NF_ACCEPT
;
1002 hooks
= rcu_dereference(nf_nat_sip_hooks
);
1004 /* Find beginning of session description */
1005 if (ct_sip_get_sdp_header(ct
, *dptr
, 0, *datalen
,
1006 SDP_HDR_VERSION
, SDP_HDR_UNSPEC
,
1007 &matchoff
, &matchlen
) <= 0)
1011 /* The connection information is contained in the session description
1012 * and/or once per media description. The first media description marks
1013 * the end of the session description. */
1015 if (ct_sip_parse_sdp_addr(ct
, *dptr
, sdpoff
, *datalen
,
1016 SDP_HDR_CONNECTION
, SDP_HDR_MEDIA
,
1017 &matchoff
, &matchlen
, &caddr
) > 0)
1018 caddr_len
= matchlen
;
1021 for (i
= 0; i
< ARRAY_SIZE(sdp_media_types
); ) {
1022 if (ct_sip_get_sdp_header(ct
, *dptr
, mediaoff
, *datalen
,
1023 SDP_HDR_MEDIA
, SDP_HDR_UNSPEC
,
1024 &mediaoff
, &medialen
) <= 0)
1027 /* Get media type and port number. A media port value of zero
1028 * indicates an inactive stream. */
1029 t
= sdp_media_type(*dptr
, mediaoff
, medialen
);
1031 mediaoff
+= medialen
;
1037 port
= simple_strtoul(*dptr
+ mediaoff
, NULL
, 10);
1040 if (port
< 1024 || port
> 65535) {
1041 nf_ct_helper_log(skb
, ct
, "wrong port %u", port
);
1045 /* The media description overrides the session description. */
1047 if (ct_sip_parse_sdp_addr(ct
, *dptr
, mediaoff
, *datalen
,
1048 SDP_HDR_CONNECTION
, SDP_HDR_MEDIA
,
1049 &matchoff
, &matchlen
, &maddr
) > 0) {
1050 maddr_len
= matchlen
;
1051 memcpy(&rtp_addr
, &maddr
, sizeof(rtp_addr
));
1052 } else if (caddr_len
)
1053 memcpy(&rtp_addr
, &caddr
, sizeof(rtp_addr
));
1055 nf_ct_helper_log(skb
, ct
, "cannot parse SDP message");
1059 ret
= set_expected_rtp_rtcp(skb
, protoff
, dataoff
,
1061 &rtp_addr
, htons(port
), t
->class,
1062 mediaoff
, medialen
);
1063 if (ret
!= NF_ACCEPT
) {
1064 nf_ct_helper_log(skb
, ct
,
1065 "cannot add expectation for voice");
1069 /* Update media connection address if present */
1070 if (maddr_len
&& hooks
&& ct
->status
& IPS_NAT_MASK
) {
1071 ret
= hooks
->sdp_addr(skb
, protoff
, dataoff
,
1072 dptr
, datalen
, mediaoff
,
1076 if (ret
!= NF_ACCEPT
) {
1077 nf_ct_helper_log(skb
, ct
, "cannot mangle SDP");
1084 /* Update session connection and owner addresses */
1085 hooks
= rcu_dereference(nf_nat_sip_hooks
);
1086 if (hooks
&& ct
->status
& IPS_NAT_MASK
)
1087 ret
= hooks
->sdp_session(skb
, protoff
, dataoff
,
1088 dptr
, datalen
, sdpoff
,
1093 static int process_invite_response(struct sk_buff
*skb
, unsigned int protoff
,
1094 unsigned int dataoff
,
1095 const char **dptr
, unsigned int *datalen
,
1096 unsigned int cseq
, unsigned int code
)
1098 enum ip_conntrack_info ctinfo
;
1099 struct nf_conn
*ct
= nf_ct_get(skb
, &ctinfo
);
1100 struct nf_ct_sip_master
*ct_sip_info
= nfct_help_data(ct
);
1102 if ((code
>= 100 && code
<= 199) ||
1103 (code
>= 200 && code
<= 299))
1104 return process_sdp(skb
, protoff
, dataoff
, dptr
, datalen
, cseq
);
1105 else if (ct_sip_info
->invite_cseq
== cseq
)
1106 flush_expectations(ct
, true);
1110 static int process_update_response(struct sk_buff
*skb
, unsigned int protoff
,
1111 unsigned int dataoff
,
1112 const char **dptr
, unsigned int *datalen
,
1113 unsigned int cseq
, unsigned int code
)
1115 enum ip_conntrack_info ctinfo
;
1116 struct nf_conn
*ct
= nf_ct_get(skb
, &ctinfo
);
1117 struct nf_ct_sip_master
*ct_sip_info
= nfct_help_data(ct
);
1119 if ((code
>= 100 && code
<= 199) ||
1120 (code
>= 200 && code
<= 299))
1121 return process_sdp(skb
, protoff
, dataoff
, dptr
, datalen
, cseq
);
1122 else if (ct_sip_info
->invite_cseq
== cseq
)
1123 flush_expectations(ct
, true);
1127 static int process_prack_response(struct sk_buff
*skb
, unsigned int protoff
,
1128 unsigned int dataoff
,
1129 const char **dptr
, unsigned int *datalen
,
1130 unsigned int cseq
, unsigned int code
)
1132 enum ip_conntrack_info ctinfo
;
1133 struct nf_conn
*ct
= nf_ct_get(skb
, &ctinfo
);
1134 struct nf_ct_sip_master
*ct_sip_info
= nfct_help_data(ct
);
1136 if ((code
>= 100 && code
<= 199) ||
1137 (code
>= 200 && code
<= 299))
1138 return process_sdp(skb
, protoff
, dataoff
, dptr
, datalen
, cseq
);
1139 else if (ct_sip_info
->invite_cseq
== cseq
)
1140 flush_expectations(ct
, true);
1144 static int process_invite_request(struct sk_buff
*skb
, unsigned int protoff
,
1145 unsigned int dataoff
,
1146 const char **dptr
, unsigned int *datalen
,
1149 enum ip_conntrack_info ctinfo
;
1150 struct nf_conn
*ct
= nf_ct_get(skb
, &ctinfo
);
1151 struct nf_ct_sip_master
*ct_sip_info
= nfct_help_data(ct
);
1154 flush_expectations(ct
, true);
1155 ret
= process_sdp(skb
, protoff
, dataoff
, dptr
, datalen
, cseq
);
1156 if (ret
== NF_ACCEPT
)
1157 ct_sip_info
->invite_cseq
= cseq
;
1161 static int process_bye_request(struct sk_buff
*skb
, unsigned int protoff
,
1162 unsigned int dataoff
,
1163 const char **dptr
, unsigned int *datalen
,
1166 enum ip_conntrack_info ctinfo
;
1167 struct nf_conn
*ct
= nf_ct_get(skb
, &ctinfo
);
1169 flush_expectations(ct
, true);
1173 /* Parse a REGISTER request and create a permanent expectation for incoming
1174 * signalling connections. The expectation is marked inactive and is activated
1175 * when receiving a response indicating success from the registrar.
1177 static int process_register_request(struct sk_buff
*skb
, unsigned int protoff
,
1178 unsigned int dataoff
,
1179 const char **dptr
, unsigned int *datalen
,
1182 enum ip_conntrack_info ctinfo
;
1183 struct nf_conn
*ct
= nf_ct_get(skb
, &ctinfo
);
1184 struct nf_ct_sip_master
*ct_sip_info
= nfct_help_data(ct
);
1185 enum ip_conntrack_dir dir
= CTINFO2DIR(ctinfo
);
1186 unsigned int matchoff
, matchlen
;
1187 struct nf_conntrack_expect
*exp
;
1188 union nf_inet_addr
*saddr
, daddr
;
1189 const struct nf_nat_sip_hooks
*hooks
;
1192 unsigned int expires
= 0;
1195 /* Expected connections can not register again. */
1196 if (ct
->status
& IPS_EXPECTED
)
1199 /* We must check the expiration time: a value of zero signals the
1200 * registrar to release the binding. We'll remove our expectation
1201 * when receiving the new bindings in the response, but we don't
1202 * want to create new ones.
1204 * The expiration time may be contained in Expires: header, the
1205 * Contact: header parameters or the URI parameters.
1207 if (ct_sip_get_header(ct
, *dptr
, 0, *datalen
, SIP_HDR_EXPIRES
,
1208 &matchoff
, &matchlen
) > 0)
1209 expires
= simple_strtoul(*dptr
+ matchoff
, NULL
, 10);
1211 ret
= ct_sip_parse_header_uri(ct
, *dptr
, NULL
, *datalen
,
1212 SIP_HDR_CONTACT
, NULL
,
1213 &matchoff
, &matchlen
, &daddr
, &port
);
1215 nf_ct_helper_log(skb
, ct
, "cannot parse contact");
1217 } else if (ret
== 0)
1220 /* We don't support third-party registrations */
1221 if (!nf_inet_addr_cmp(&ct
->tuplehash
[dir
].tuple
.src
.u3
, &daddr
))
1224 if (ct_sip_parse_transport(ct
, *dptr
, matchoff
+ matchlen
, *datalen
,
1228 if (ct_sip_parse_numerical_param(ct
, *dptr
,
1229 matchoff
+ matchlen
, *datalen
,
1230 "expires=", NULL
, NULL
, &expires
) < 0) {
1231 nf_ct_helper_log(skb
, ct
, "cannot parse expires");
1240 exp
= nf_ct_expect_alloc(ct
);
1242 nf_ct_helper_log(skb
, ct
, "cannot alloc expectation");
1247 if (sip_direct_signalling
)
1248 saddr
= &ct
->tuplehash
[!dir
].tuple
.src
.u3
;
1250 nf_ct_expect_init(exp
, SIP_EXPECT_SIGNALLING
, nf_ct_l3num(ct
),
1251 saddr
, &daddr
, proto
, NULL
, &port
);
1252 exp
->timeout
.expires
= sip_timeout
* HZ
;
1253 exp
->helper
= nfct_help(ct
)->helper
;
1254 exp
->flags
= NF_CT_EXPECT_PERMANENT
| NF_CT_EXPECT_INACTIVE
;
1256 hooks
= rcu_dereference(nf_nat_sip_hooks
);
1257 if (hooks
&& ct
->status
& IPS_NAT_MASK
)
1258 ret
= hooks
->expect(skb
, protoff
, dataoff
, dptr
, datalen
,
1259 exp
, matchoff
, matchlen
);
1261 if (nf_ct_expect_related(exp
) != 0) {
1262 nf_ct_helper_log(skb
, ct
, "cannot add expectation");
1267 nf_ct_expect_put(exp
);
1270 if (ret
== NF_ACCEPT
)
1271 ct_sip_info
->register_cseq
= cseq
;
1275 static int process_register_response(struct sk_buff
*skb
, unsigned int protoff
,
1276 unsigned int dataoff
,
1277 const char **dptr
, unsigned int *datalen
,
1278 unsigned int cseq
, unsigned int code
)
1280 enum ip_conntrack_info ctinfo
;
1281 struct nf_conn
*ct
= nf_ct_get(skb
, &ctinfo
);
1282 struct nf_ct_sip_master
*ct_sip_info
= nfct_help_data(ct
);
1283 enum ip_conntrack_dir dir
= CTINFO2DIR(ctinfo
);
1284 union nf_inet_addr addr
;
1287 unsigned int matchoff
, matchlen
, coff
= 0;
1288 unsigned int expires
= 0;
1289 int in_contact
= 0, ret
;
1291 /* According to RFC 3261, "UAs MUST NOT send a new registration until
1292 * they have received a final response from the registrar for the
1293 * previous one or the previous REGISTER request has timed out".
1295 * However, some servers fail to detect retransmissions and send late
1296 * responses, so we store the sequence number of the last valid
1297 * request and compare it here.
1299 if (ct_sip_info
->register_cseq
!= cseq
)
1302 if (code
>= 100 && code
<= 199)
1304 if (code
< 200 || code
> 299)
1307 if (ct_sip_get_header(ct
, *dptr
, 0, *datalen
, SIP_HDR_EXPIRES
,
1308 &matchoff
, &matchlen
) > 0)
1309 expires
= simple_strtoul(*dptr
+ matchoff
, NULL
, 10);
1312 unsigned int c_expires
= expires
;
1314 ret
= ct_sip_parse_header_uri(ct
, *dptr
, &coff
, *datalen
,
1315 SIP_HDR_CONTACT
, &in_contact
,
1316 &matchoff
, &matchlen
,
1319 nf_ct_helper_log(skb
, ct
, "cannot parse contact");
1321 } else if (ret
== 0)
1324 /* We don't support third-party registrations */
1325 if (!nf_inet_addr_cmp(&ct
->tuplehash
[dir
].tuple
.dst
.u3
, &addr
))
1328 if (ct_sip_parse_transport(ct
, *dptr
, matchoff
+ matchlen
,
1329 *datalen
, &proto
) == 0)
1332 ret
= ct_sip_parse_numerical_param(ct
, *dptr
,
1333 matchoff
+ matchlen
,
1334 *datalen
, "expires=",
1335 NULL
, NULL
, &c_expires
);
1337 nf_ct_helper_log(skb
, ct
, "cannot parse expires");
1342 if (refresh_signalling_expectation(ct
, &addr
, proto
, port
,
1348 flush_expectations(ct
, false);
1352 static const struct sip_handler sip_handlers
[] = {
1353 SIP_HANDLER("INVITE", process_invite_request
, process_invite_response
),
1354 SIP_HANDLER("UPDATE", process_sdp
, process_update_response
),
1355 SIP_HANDLER("ACK", process_sdp
, NULL
),
1356 SIP_HANDLER("PRACK", process_sdp
, process_prack_response
),
1357 SIP_HANDLER("BYE", process_bye_request
, NULL
),
1358 SIP_HANDLER("REGISTER", process_register_request
, process_register_response
),
1361 static int process_sip_response(struct sk_buff
*skb
, unsigned int protoff
,
1362 unsigned int dataoff
,
1363 const char **dptr
, unsigned int *datalen
)
1365 enum ip_conntrack_info ctinfo
;
1366 struct nf_conn
*ct
= nf_ct_get(skb
, &ctinfo
);
1367 unsigned int matchoff
, matchlen
, matchend
;
1368 unsigned int code
, cseq
, i
;
1370 if (*datalen
< strlen("SIP/2.0 200"))
1372 code
= simple_strtoul(*dptr
+ strlen("SIP/2.0 "), NULL
, 10);
1374 nf_ct_helper_log(skb
, ct
, "cannot get code");
1378 if (ct_sip_get_header(ct
, *dptr
, 0, *datalen
, SIP_HDR_CSEQ
,
1379 &matchoff
, &matchlen
) <= 0) {
1380 nf_ct_helper_log(skb
, ct
, "cannot parse cseq");
1383 cseq
= simple_strtoul(*dptr
+ matchoff
, NULL
, 10);
1385 nf_ct_helper_log(skb
, ct
, "cannot get cseq");
1388 matchend
= matchoff
+ matchlen
+ 1;
1390 for (i
= 0; i
< ARRAY_SIZE(sip_handlers
); i
++) {
1391 const struct sip_handler
*handler
;
1393 handler
= &sip_handlers
[i
];
1394 if (handler
->response
== NULL
)
1396 if (*datalen
< matchend
+ handler
->len
||
1397 strnicmp(*dptr
+ matchend
, handler
->method
, handler
->len
))
1399 return handler
->response(skb
, protoff
, dataoff
, dptr
, datalen
,
1405 static int process_sip_request(struct sk_buff
*skb
, unsigned int protoff
,
1406 unsigned int dataoff
,
1407 const char **dptr
, unsigned int *datalen
)
1409 enum ip_conntrack_info ctinfo
;
1410 struct nf_conn
*ct
= nf_ct_get(skb
, &ctinfo
);
1411 struct nf_ct_sip_master
*ct_sip_info
= nfct_help_data(ct
);
1412 enum ip_conntrack_dir dir
= CTINFO2DIR(ctinfo
);
1413 unsigned int matchoff
, matchlen
;
1414 unsigned int cseq
, i
;
1415 union nf_inet_addr addr
;
1418 /* Many Cisco IP phones use a high source port for SIP requests, but
1419 * listen for the response on port 5060. If we are the local
1420 * router for one of these phones, save the port number from the
1421 * Via: header so that nf_nat_sip can redirect the responses to
1424 if (ct_sip_parse_header_uri(ct
, *dptr
, NULL
, *datalen
,
1425 SIP_HDR_VIA_UDP
, NULL
, &matchoff
,
1426 &matchlen
, &addr
, &port
) > 0 &&
1427 port
!= ct
->tuplehash
[dir
].tuple
.src
.u
.udp
.port
&&
1428 nf_inet_addr_cmp(&addr
, &ct
->tuplehash
[dir
].tuple
.src
.u3
))
1429 ct_sip_info
->forced_dport
= port
;
1431 for (i
= 0; i
< ARRAY_SIZE(sip_handlers
); i
++) {
1432 const struct sip_handler
*handler
;
1434 handler
= &sip_handlers
[i
];
1435 if (handler
->request
== NULL
)
1437 if (*datalen
< handler
->len
||
1438 strnicmp(*dptr
, handler
->method
, handler
->len
))
1441 if (ct_sip_get_header(ct
, *dptr
, 0, *datalen
, SIP_HDR_CSEQ
,
1442 &matchoff
, &matchlen
) <= 0) {
1443 nf_ct_helper_log(skb
, ct
, "cannot parse cseq");
1446 cseq
= simple_strtoul(*dptr
+ matchoff
, NULL
, 10);
1448 nf_ct_helper_log(skb
, ct
, "cannot get cseq");
1452 return handler
->request(skb
, protoff
, dataoff
, dptr
, datalen
,
1458 static int process_sip_msg(struct sk_buff
*skb
, struct nf_conn
*ct
,
1459 unsigned int protoff
, unsigned int dataoff
,
1460 const char **dptr
, unsigned int *datalen
)
1462 const struct nf_nat_sip_hooks
*hooks
;
1465 if (strnicmp(*dptr
, "SIP/2.0 ", strlen("SIP/2.0 ")) != 0)
1466 ret
= process_sip_request(skb
, protoff
, dataoff
, dptr
, datalen
);
1468 ret
= process_sip_response(skb
, protoff
, dataoff
, dptr
, datalen
);
1470 if (ret
== NF_ACCEPT
&& ct
->status
& IPS_NAT_MASK
) {
1471 hooks
= rcu_dereference(nf_nat_sip_hooks
);
1472 if (hooks
&& !hooks
->msg(skb
, protoff
, dataoff
,
1474 nf_ct_helper_log(skb
, ct
, "cannot NAT SIP message");
1482 static int sip_help_tcp(struct sk_buff
*skb
, unsigned int protoff
,
1483 struct nf_conn
*ct
, enum ip_conntrack_info ctinfo
)
1485 struct tcphdr
*th
, _tcph
;
1486 unsigned int dataoff
, datalen
;
1487 unsigned int matchoff
, matchlen
, clen
;
1488 unsigned int msglen
, origlen
;
1489 const char *dptr
, *end
;
1490 s16 diff
, tdiff
= 0;
1491 int ret
= NF_ACCEPT
;
1494 if (ctinfo
!= IP_CT_ESTABLISHED
&&
1495 ctinfo
!= IP_CT_ESTABLISHED_REPLY
)
1499 th
= skb_header_pointer(skb
, protoff
, sizeof(_tcph
), &_tcph
);
1502 dataoff
= protoff
+ th
->doff
* 4;
1503 if (dataoff
>= skb
->len
)
1506 nf_ct_refresh(ct
, skb
, sip_timeout
* HZ
);
1508 if (unlikely(skb_linearize(skb
)))
1511 dptr
= skb
->data
+ dataoff
;
1512 datalen
= skb
->len
- dataoff
;
1513 if (datalen
< strlen("SIP/2.0 200"))
1517 if (ct_sip_get_header(ct
, dptr
, 0, datalen
,
1518 SIP_HDR_CONTENT_LENGTH
,
1519 &matchoff
, &matchlen
) <= 0)
1522 clen
= simple_strtoul(dptr
+ matchoff
, (char **)&end
, 10);
1523 if (dptr
+ matchoff
== end
)
1527 for (; end
+ strlen("\r\n\r\n") <= dptr
+ datalen
; end
++) {
1528 if (end
[0] == '\r' && end
[1] == '\n' &&
1529 end
[2] == '\r' && end
[3] == '\n') {
1536 end
+= strlen("\r\n\r\n") + clen
;
1538 msglen
= origlen
= end
- dptr
;
1539 if (msglen
> datalen
)
1542 ret
= process_sip_msg(skb
, ct
, protoff
, dataoff
,
1544 /* process_sip_* functions report why this packet is dropped */
1545 if (ret
!= NF_ACCEPT
)
1547 diff
= msglen
- origlen
;
1552 datalen
= datalen
+ diff
- msglen
;
1555 if (ret
== NF_ACCEPT
&& ct
->status
& IPS_NAT_MASK
) {
1556 const struct nf_nat_sip_hooks
*hooks
;
1558 hooks
= rcu_dereference(nf_nat_sip_hooks
);
1560 hooks
->seq_adjust(skb
, protoff
, tdiff
);
1566 static int sip_help_udp(struct sk_buff
*skb
, unsigned int protoff
,
1567 struct nf_conn
*ct
, enum ip_conntrack_info ctinfo
)
1569 unsigned int dataoff
, datalen
;
1573 dataoff
= protoff
+ sizeof(struct udphdr
);
1574 if (dataoff
>= skb
->len
)
1577 nf_ct_refresh(ct
, skb
, sip_timeout
* HZ
);
1579 if (unlikely(skb_linearize(skb
)))
1582 dptr
= skb
->data
+ dataoff
;
1583 datalen
= skb
->len
- dataoff
;
1584 if (datalen
< strlen("SIP/2.0 200"))
1587 return process_sip_msg(skb
, ct
, protoff
, dataoff
, &dptr
, &datalen
);
1590 static struct nf_conntrack_helper sip
[MAX_PORTS
][4] __read_mostly
;
1592 static const struct nf_conntrack_expect_policy sip_exp_policy
[SIP_EXPECT_MAX
+ 1] = {
1593 [SIP_EXPECT_SIGNALLING
] = {
1594 .name
= "signalling",
1598 [SIP_EXPECT_AUDIO
] = {
1600 .max_expected
= 2 * IP_CT_DIR_MAX
,
1603 [SIP_EXPECT_VIDEO
] = {
1605 .max_expected
= 2 * IP_CT_DIR_MAX
,
1608 [SIP_EXPECT_IMAGE
] = {
1610 .max_expected
= IP_CT_DIR_MAX
,
1615 static void nf_conntrack_sip_fini(void)
1619 for (i
= 0; i
< ports_c
; i
++) {
1620 for (j
= 0; j
< ARRAY_SIZE(sip
[i
]); j
++) {
1621 if (sip
[i
][j
].me
== NULL
)
1623 nf_conntrack_helper_unregister(&sip
[i
][j
]);
1628 static int __init
nf_conntrack_sip_init(void)
1633 ports
[ports_c
++] = SIP_PORT
;
1635 for (i
= 0; i
< ports_c
; i
++) {
1636 memset(&sip
[i
], 0, sizeof(sip
[i
]));
1638 sip
[i
][0].tuple
.src
.l3num
= AF_INET
;
1639 sip
[i
][0].tuple
.dst
.protonum
= IPPROTO_UDP
;
1640 sip
[i
][0].help
= sip_help_udp
;
1641 sip
[i
][1].tuple
.src
.l3num
= AF_INET
;
1642 sip
[i
][1].tuple
.dst
.protonum
= IPPROTO_TCP
;
1643 sip
[i
][1].help
= sip_help_tcp
;
1645 sip
[i
][2].tuple
.src
.l3num
= AF_INET6
;
1646 sip
[i
][2].tuple
.dst
.protonum
= IPPROTO_UDP
;
1647 sip
[i
][2].help
= sip_help_udp
;
1648 sip
[i
][3].tuple
.src
.l3num
= AF_INET6
;
1649 sip
[i
][3].tuple
.dst
.protonum
= IPPROTO_TCP
;
1650 sip
[i
][3].help
= sip_help_tcp
;
1652 for (j
= 0; j
< ARRAY_SIZE(sip
[i
]); j
++) {
1653 sip
[i
][j
].data_len
= sizeof(struct nf_ct_sip_master
);
1654 sip
[i
][j
].tuple
.src
.u
.udp
.port
= htons(ports
[i
]);
1655 sip
[i
][j
].expect_policy
= sip_exp_policy
;
1656 sip
[i
][j
].expect_class_max
= SIP_EXPECT_MAX
;
1657 sip
[i
][j
].me
= THIS_MODULE
;
1659 if (ports
[i
] == SIP_PORT
)
1660 sprintf(sip
[i
][j
].name
, "sip");
1662 sprintf(sip
[i
][j
].name
, "sip-%u", i
);
1664 pr_debug("port #%u: %u\n", i
, ports
[i
]);
1666 ret
= nf_conntrack_helper_register(&sip
[i
][j
]);
1668 printk(KERN_ERR
"nf_ct_sip: failed to register"
1669 " helper for pf: %u port: %u\n",
1670 sip
[i
][j
].tuple
.src
.l3num
, ports
[i
]);
1671 nf_conntrack_sip_fini();
1679 module_init(nf_conntrack_sip_init
);
1680 module_exit(nf_conntrack_sip_fini
);