?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
serial/8250: Limit the omap workarounds to omap1
[linux-2.6.git] / net / netfilter / nf_conntrack_sip.c
blob5c0a112aeee6adc580f0303b50e6821d12e8839e
1 /* SIP extension for IP connection tracking.
2 *
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>
7 *
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.
11 */
12
13 #include <linux/module.h>
14 #include <linux/ctype.h>
15 #include <linux/skbuff.h>
16 #include <linux/inet.h>
17 #include <linux/in.h>
18 #include <linux/udp.h>
19 #include <linux/tcp.h>
20 #include <linux/netfilter.h>
21
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>
28
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");
34
35 #define MAX_PORTS 8
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");
40
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");
44
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 "
48 "only (default 1)");
49
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)");
54
55 unsigned int (*nf_nat_sip_hook)(struct sk_buff *skb, unsigned int dataoff,
56 const char **dptr,
57 unsigned int *datalen) __read_mostly;
58 EXPORT_SYMBOL_GPL(nf_nat_sip_hook);
59
60 void (*nf_nat_sip_seq_adjust_hook)(struct sk_buff *skb, s16 off) __read_mostly;
61 EXPORT_SYMBOL_GPL(nf_nat_sip_seq_adjust_hook);
62
63 unsigned int (*nf_nat_sip_expect_hook)(struct sk_buff *skb,
64 unsigned int dataoff,
65 const char **dptr,
66 unsigned int *datalen,
67 struct nf_conntrack_expect *exp,
68 unsigned int matchoff,
69 unsigned int matchlen) __read_mostly;
70 EXPORT_SYMBOL_GPL(nf_nat_sip_expect_hook);
71
72 unsigned int (*nf_nat_sdp_addr_hook)(struct sk_buff *skb, unsigned int dataoff,
73 const char **dptr,
74 unsigned int *datalen,
75 unsigned int sdpoff,
76 enum sdp_header_types type,
77 enum sdp_header_types term,
78 const union nf_inet_addr *addr)
79 __read_mostly;
80 EXPORT_SYMBOL_GPL(nf_nat_sdp_addr_hook);
81
82 unsigned int (*nf_nat_sdp_port_hook)(struct sk_buff *skb, unsigned int dataoff,
83 const char **dptr,
84 unsigned int *datalen,
85 unsigned int matchoff,
86 unsigned int matchlen,
87 u_int16_t port) __read_mostly;
88 EXPORT_SYMBOL_GPL(nf_nat_sdp_port_hook);
89
90 unsigned int (*nf_nat_sdp_session_hook)(struct sk_buff *skb,
91 unsigned int dataoff,
92 const char **dptr,
93 unsigned int *datalen,
94 unsigned int sdpoff,
95 const union nf_inet_addr *addr)
96 __read_mostly;
97 EXPORT_SYMBOL_GPL(nf_nat_sdp_session_hook);
98
99 unsigned int (*nf_nat_sdp_media_hook)(struct sk_buff *skb, unsigned int dataoff,
100 const char **dptr,
101 unsigned int *datalen,
102 struct nf_conntrack_expect *rtp_exp,
103 struct nf_conntrack_expect *rtcp_exp,
104 unsigned int mediaoff,
105 unsigned int medialen,
106 union nf_inet_addr *rtp_addr)
107 __read_mostly;
108 EXPORT_SYMBOL_GPL(nf_nat_sdp_media_hook);
109
110 static int string_len(const struct nf_conn *ct, const char *dptr,
111 const char *limit, int *shift)
112 {
113 int len = 0;
114
115 while (dptr < limit && isalpha(*dptr)) {
116 dptr++;
117 len++;
118 }
119 return len;
120 }
121
122 static int digits_len(const struct nf_conn *ct, const char *dptr,
123 const char *limit, int *shift)
124 {
125 int len = 0;
126 while (dptr < limit && isdigit(*dptr)) {
127 dptr++;
128 len++;
129 }
130 return len;
131 }
132
133 static int iswordc(const char c)
134 {
135 if (isalnum(c) || c == '!' || c == '"' || c == '%' ||
136 (c >= '(' && c <= '/') || c == ':' || c == '<' || c == '>' ||
137 c == '?' || (c >= '[' && c <= ']') || c == '_' || c == '`' ||
138 c == '{' || c == '}' || c == '~')
139 return 1;
140 return 0;
141 }
142
143 static int word_len(const char *dptr, const char *limit)
144 {
145 int len = 0;
146 while (dptr < limit && iswordc(*dptr)) {
147 dptr++;
148 len++;
149 }
150 return len;
151 }
152
153 static int callid_len(const struct nf_conn *ct, const char *dptr,
154 const char *limit, int *shift)
155 {
156 int len, domain_len;
157
158 len = word_len(dptr, limit);
159 dptr += len;
160 if (!len || dptr == limit || *dptr != '@')
161 return len;
162 dptr++;
163 len++;
164
165 domain_len = word_len(dptr, limit);
166 if (!domain_len)
167 return 0;
168 return len + domain_len;
169 }
170
171 /* get media type + port length */
172 static int media_len(const struct nf_conn *ct, const char *dptr,
173 const char *limit, int *shift)
174 {
175 int len = string_len(ct, dptr, limit, shift);
176
177 dptr += len;
178 if (dptr >= limit || *dptr != ' ')
179 return 0;
180 len++;
181 dptr++;
182
183 return len + digits_len(ct, dptr, limit, shift);
184 }
185
186 static int sip_parse_addr(const struct nf_conn *ct, const char *cp,
187 const char **endp, union nf_inet_addr *addr,
188 const char *limit, bool delim)
189 {
190 const char *end;
191 int ret;
192
193 if (!ct)
194 return 0;
195
196 memset(addr, 0, sizeof(*addr));
197 switch (nf_ct_l3num(ct)) {
198 case AF_INET:
199 ret = in4_pton(cp, limit - cp, (u8 *)&addr->ip, -1, &end);
200 if (ret == 0)
201 return 0;
202 break;
203 case AF_INET6:
204 if (cp < limit && *cp == '[')
205 cp++;
206 else if (delim)
207 return 0;
208
209 ret = in6_pton(cp, limit - cp, (u8 *)&addr->ip6, -1, &end);
210 if (ret == 0)
211 return 0;
212
213 if (end < limit && *end == ']')
214 end++;
215 else if (delim)
216 return 0;
217 break;
218 default:
219 BUG();
220 }
221
222 if (endp)
223 *endp = end;
224 return 1;
225 }
226
227 /* skip ip address. returns its length. */
228 static int epaddr_len(const struct nf_conn *ct, const char *dptr,
229 const char *limit, int *shift)
230 {
231 union nf_inet_addr addr;
232 const char *aux = dptr;
233
234 if (!sip_parse_addr(ct, dptr, &dptr, &addr, limit, true)) {
235 pr_debug("ip: %s parse failed.!\n", dptr);
236 return 0;
237 }
238
239 /* Port number */
240 if (*dptr == ':') {
241 dptr++;
242 dptr += digits_len(ct, dptr, limit, shift);
243 }
244 return dptr - aux;
245 }
246
247 /* get address length, skiping user info. */
248 static int skp_epaddr_len(const struct nf_conn *ct, const char *dptr,
249 const char *limit, int *shift)
250 {
251 const char *start = dptr;
252 int s = *shift;
253
254 /* Search for @, but stop at the end of the line.
255 * We are inside a sip: URI, so we don't need to worry about
256 * continuation lines. */
257 while (dptr < limit &&
258 *dptr != '@' && *dptr != '\r' && *dptr != '\n') {
259 (*shift)++;
260 dptr++;
261 }
262
263 if (dptr < limit && *dptr == '@') {
264 dptr++;
265 (*shift)++;
266 } else {
267 dptr = start;
268 *shift = s;
269 }
270
271 return epaddr_len(ct, dptr, limit, shift);
272 }
273
274 /* Parse a SIP request line of the form:
275 *
276 * Request-Line = Method SP Request-URI SP SIP-Version CRLF
277 *
278 * and return the offset and length of the address contained in the Request-URI.
279 */
280 int ct_sip_parse_request(const struct nf_conn *ct,
281 const char *dptr, unsigned int datalen,
282 unsigned int *matchoff, unsigned int *matchlen,
283 union nf_inet_addr *addr, __be16 *port)
284 {
285 const char *start = dptr, *limit = dptr + datalen, *end;
286 unsigned int mlen;
287 unsigned int p;
288 int shift = 0;
289
290 /* Skip method and following whitespace */
291 mlen = string_len(ct, dptr, limit, NULL);
292 if (!mlen)
293 return 0;
294 dptr += mlen;
295 if (++dptr >= limit)
296 return 0;
297
298 /* Find SIP URI */
299 for (; dptr < limit - strlen("sip:"); dptr++) {
300 if (*dptr == '\r' || *dptr == '\n')
301 return -1;
302 if (strnicmp(dptr, "sip:", strlen("sip:")) == 0) {
303 dptr += strlen("sip:");
304 break;
305 }
306 }
307 if (!skp_epaddr_len(ct, dptr, limit, &shift))
308 return 0;
309 dptr += shift;
310
311 if (!sip_parse_addr(ct, dptr, &end, addr, limit, true))
312 return -1;
313 if (end < limit && *end == ':') {
314 end++;
315 p = simple_strtoul(end, (char **)&end, 10);
316 if (p < 1024 || p > 65535)
317 return -1;
318 *port = htons(p);
319 } else
320 *port = htons(SIP_PORT);
321
322 if (end == dptr)
323 return 0;
324 *matchoff = dptr - start;
325 *matchlen = end - dptr;
326 return 1;
327 }
328 EXPORT_SYMBOL_GPL(ct_sip_parse_request);
329
330 /* SIP header parsing: SIP headers are located at the beginning of a line, but
331 * may span several lines, in which case the continuation lines begin with a
332 * whitespace character. RFC 2543 allows lines to be terminated with CR, LF or
333 * CRLF, RFC 3261 allows only CRLF, we support both.
334 *
335 * Headers are followed by (optionally) whitespace, a colon, again (optionally)
336 * whitespace and the values. Whitespace in this context means any amount of
337 * tabs, spaces and continuation lines, which are treated as a single whitespace
338 * character.
339 *
340 * Some headers may appear multiple times. A comma separated list of values is
341 * equivalent to multiple headers.
342 */
343 static const struct sip_header ct_sip_hdrs[] = {
344 [SIP_HDR_CSEQ] = SIP_HDR("CSeq", NULL, NULL, digits_len),
345 [SIP_HDR_FROM] = SIP_HDR("From", "f", "sip:", skp_epaddr_len),
346 [SIP_HDR_TO] = SIP_HDR("To", "t", "sip:", skp_epaddr_len),
347 [SIP_HDR_CONTACT] = SIP_HDR("Contact", "m", "sip:", skp_epaddr_len),
348 [SIP_HDR_VIA_UDP] = SIP_HDR("Via", "v", "UDP ", epaddr_len),
349 [SIP_HDR_VIA_TCP] = SIP_HDR("Via", "v", "TCP ", epaddr_len),
350 [SIP_HDR_EXPIRES] = SIP_HDR("Expires", NULL, NULL, digits_len),
351 [SIP_HDR_CONTENT_LENGTH] = SIP_HDR("Content-Length", "l", NULL, digits_len),
352 [SIP_HDR_CALL_ID] = SIP_HDR("Call-Id", "i", NULL, callid_len),
353 };
354
355 static const char *sip_follow_continuation(const char *dptr, const char *limit)
356 {
357 /* Walk past newline */
358 if (++dptr >= limit)
359 return NULL;
360
361 /* Skip '\n' in CR LF */
362 if (*(dptr - 1) == '\r' && *dptr == '\n') {
363 if (++dptr >= limit)
364 return NULL;
365 }
366
367 /* Continuation line? */
368 if (*dptr != ' ' && *dptr != '\t')
369 return NULL;
370
371 /* skip leading whitespace */
372 for (; dptr < limit; dptr++) {
373 if (*dptr != ' ' && *dptr != '\t')
374 break;
375 }
376 return dptr;
377 }
378
379 static const char *sip_skip_whitespace(const char *dptr, const char *limit)
380 {
381 for (; dptr < limit; dptr++) {
382 if (*dptr == ' ')
383 continue;
384 if (*dptr != '\r' && *dptr != '\n')
385 break;
386 dptr = sip_follow_continuation(dptr, limit);
387 if (dptr == NULL)
388 return NULL;
389 }
390 return dptr;
391 }
392
393 /* Search within a SIP header value, dealing with continuation lines */
394 static const char *ct_sip_header_search(const char *dptr, const char *limit,
395 const char *needle, unsigned int len)
396 {
397 for (limit -= len; dptr < limit; dptr++) {
398 if (*dptr == '\r' || *dptr == '\n') {
399 dptr = sip_follow_continuation(dptr, limit);
400 if (dptr == NULL)
401 break;
402 continue;
403 }
404
405 if (strnicmp(dptr, needle, len) == 0)
406 return dptr;
407 }
408 return NULL;
409 }
410
411 int ct_sip_get_header(const struct nf_conn *ct, const char *dptr,
412 unsigned int dataoff, unsigned int datalen,
413 enum sip_header_types type,
414 unsigned int *matchoff, unsigned int *matchlen)
415 {
416 const struct sip_header *hdr = &ct_sip_hdrs[type];
417 const char *start = dptr, *limit = dptr + datalen;
418 int shift = 0;
419
420 for (dptr += dataoff; dptr < limit; dptr++) {
421 /* Find beginning of line */
422 if (*dptr != '\r' && *dptr != '\n')
423 continue;
424 if (++dptr >= limit)
425 break;
426 if (*(dptr - 1) == '\r' && *dptr == '\n') {
427 if (++dptr >= limit)
428 break;
429 }
430
431 /* Skip continuation lines */
432 if (*dptr == ' ' || *dptr == '\t')
433 continue;
434
435 /* Find header. Compact headers must be followed by a
436 * non-alphabetic character to avoid mismatches. */
437 if (limit - dptr >= hdr->len &&
438 strnicmp(dptr, hdr->name, hdr->len) == 0)
439 dptr += hdr->len;
440 else if (hdr->cname && limit - dptr >= hdr->clen + 1 &&
441 strnicmp(dptr, hdr->cname, hdr->clen) == 0 &&
442 !isalpha(*(dptr + hdr->clen)))
443 dptr += hdr->clen;
444 else
445 continue;
446
447 /* Find and skip colon */
448 dptr = sip_skip_whitespace(dptr, limit);
449 if (dptr == NULL)
450 break;
451 if (*dptr != ':' || ++dptr >= limit)
452 break;
453
454 /* Skip whitespace after colon */
455 dptr = sip_skip_whitespace(dptr, limit);
456 if (dptr == NULL)
457 break;
458
459 *matchoff = dptr - start;
460 if (hdr->search) {
461 dptr = ct_sip_header_search(dptr, limit, hdr->search,
462 hdr->slen);
463 if (!dptr)
464 return -1;
465 dptr += hdr->slen;
466 }
467
468 *matchlen = hdr->match_len(ct, dptr, limit, &shift);
469 if (!*matchlen)
470 return -1;
471 *matchoff = dptr - start + shift;
472 return 1;
473 }
474 return 0;
475 }
476 EXPORT_SYMBOL_GPL(ct_sip_get_header);
477
478 /* Get next header field in a list of comma separated values */
479 static int ct_sip_next_header(const struct nf_conn *ct, const char *dptr,
480 unsigned int dataoff, unsigned int datalen,
481 enum sip_header_types type,
482 unsigned int *matchoff, unsigned int *matchlen)
483 {
484 const struct sip_header *hdr = &ct_sip_hdrs[type];
485 const char *start = dptr, *limit = dptr + datalen;
486 int shift = 0;
487
488 dptr += dataoff;
489
490 dptr = ct_sip_header_search(dptr, limit, ",", strlen(","));
491 if (!dptr)
492 return 0;
493
494 dptr = ct_sip_header_search(dptr, limit, hdr->search, hdr->slen);
495 if (!dptr)
496 return 0;
497 dptr += hdr->slen;
498
499 *matchoff = dptr - start;
500 *matchlen = hdr->match_len(ct, dptr, limit, &shift);
501 if (!*matchlen)
502 return -1;
503 *matchoff += shift;
504 return 1;
505 }
506
507 /* Walk through headers until a parsable one is found or no header of the
508 * given type is left. */
509 static int ct_sip_walk_headers(const struct nf_conn *ct, const char *dptr,
510 unsigned int dataoff, unsigned int datalen,
511 enum sip_header_types type, int *in_header,
512 unsigned int *matchoff, unsigned int *matchlen)
513 {
514 int ret;
515
516 if (in_header && *in_header) {
517 while (1) {
518 ret = ct_sip_next_header(ct, dptr, dataoff, datalen,
519 type, matchoff, matchlen);
520 if (ret > 0)
521 return ret;
522 if (ret == 0)
523 break;
524 dataoff += *matchoff;
525 }
526 *in_header = 0;
527 }
528
529 while (1) {
530 ret = ct_sip_get_header(ct, dptr, dataoff, datalen,
531 type, matchoff, matchlen);
532 if (ret > 0)
533 break;
534 if (ret == 0)
535 return ret;
536 dataoff += *matchoff;
537 }
538
539 if (in_header)
540 *in_header = 1;
541 return 1;
542 }
543
544 /* Locate a SIP header, parse the URI and return the offset and length of
545 * the address as well as the address and port themselves. A stream of
546 * headers can be parsed by handing in a non-NULL datalen and in_header
547 * pointer.
548 */
549 int ct_sip_parse_header_uri(const struct nf_conn *ct, const char *dptr,
550 unsigned int *dataoff, unsigned int datalen,
551 enum sip_header_types type, int *in_header,
552 unsigned int *matchoff, unsigned int *matchlen,
553 union nf_inet_addr *addr, __be16 *port)
554 {
555 const char *c, *limit = dptr + datalen;
556 unsigned int p;
557 int ret;
558
559 ret = ct_sip_walk_headers(ct, dptr, dataoff ? *dataoff : 0, datalen,
560 type, in_header, matchoff, matchlen);
561 WARN_ON(ret < 0);
562 if (ret == 0)
563 return ret;
564
565 if (!sip_parse_addr(ct, dptr + *matchoff, &c, addr, limit, true))
566 return -1;
567 if (*c == ':') {
568 c++;
569 p = simple_strtoul(c, (char **)&c, 10);
570 if (p < 1024 || p > 65535)
571 return -1;
572 *port = htons(p);
573 } else
574 *port = htons(SIP_PORT);
575
576 if (dataoff)
577 *dataoff = c - dptr;
578 return 1;
579 }
580 EXPORT_SYMBOL_GPL(ct_sip_parse_header_uri);
581
582 static int ct_sip_parse_param(const struct nf_conn *ct, const char *dptr,
583 unsigned int dataoff, unsigned int datalen,
584 const char *name,
585 unsigned int *matchoff, unsigned int *matchlen)
586 {
587 const char *limit = dptr + datalen;
588 const char *start;
589 const char *end;
590
591 limit = ct_sip_header_search(dptr + dataoff, limit, ",", strlen(","));
592 if (!limit)
593 limit = dptr + datalen;
594
595 start = ct_sip_header_search(dptr + dataoff, limit, name, strlen(name));
596 if (!start)
597 return 0;
598 start += strlen(name);
599
600 end = ct_sip_header_search(start, limit, ";", strlen(";"));
601 if (!end)
602 end = limit;
603
604 *matchoff = start - dptr;
605 *matchlen = end - start;
606 return 1;
607 }
608
609 /* Parse address from header parameter and return address, offset and length */
610 int ct_sip_parse_address_param(const struct nf_conn *ct, const char *dptr,
611 unsigned int dataoff, unsigned int datalen,
612 const char *name,
613 unsigned int *matchoff, unsigned int *matchlen,
614 union nf_inet_addr *addr, bool delim)
615 {
616 const char *limit = dptr + datalen;
617 const char *start, *end;
618
619 limit = ct_sip_header_search(dptr + dataoff, limit, ",", strlen(","));
620 if (!limit)
621 limit = dptr + datalen;
622
623 start = ct_sip_header_search(dptr + dataoff, limit, name, strlen(name));
624 if (!start)
625 return 0;
626
627 start += strlen(name);
628 if (!sip_parse_addr(ct, start, &end, addr, limit, delim))
629 return 0;
630 *matchoff = start - dptr;
631 *matchlen = end - start;
632 return 1;
633 }
634 EXPORT_SYMBOL_GPL(ct_sip_parse_address_param);
635
636 /* Parse numerical header parameter and return value, offset and length */
637 int ct_sip_parse_numerical_param(const struct nf_conn *ct, const char *dptr,
638 unsigned int dataoff, unsigned int datalen,
639 const char *name,
640 unsigned int *matchoff, unsigned int *matchlen,
641 unsigned int *val)
642 {
643 const char *limit = dptr + datalen;
644 const char *start;
645 char *end;
646
647 limit = ct_sip_header_search(dptr + dataoff, limit, ",", strlen(","));
648 if (!limit)
649 limit = dptr + datalen;
650
651 start = ct_sip_header_search(dptr + dataoff, limit, name, strlen(name));
652 if (!start)
653 return 0;
654
655 start += strlen(name);
656 *val = simple_strtoul(start, &end, 0);
657 if (start == end)
658 return 0;
659 if (matchoff && matchlen) {
660 *matchoff = start - dptr;
661 *matchlen = end - start;
662 }
663 return 1;
664 }
665 EXPORT_SYMBOL_GPL(ct_sip_parse_numerical_param);
666
667 static int ct_sip_parse_transport(struct nf_conn *ct, const char *dptr,
668 unsigned int dataoff, unsigned int datalen,
669 u8 *proto)
670 {
671 unsigned int matchoff, matchlen;
672
673 if (ct_sip_parse_param(ct, dptr, dataoff, datalen, "transport=",
674 &matchoff, &matchlen)) {
675 if (!strnicmp(dptr + matchoff, "TCP", strlen("TCP")))
676 *proto = IPPROTO_TCP;
677 else if (!strnicmp(dptr + matchoff, "UDP", strlen("UDP")))
678 *proto = IPPROTO_UDP;
679 else
680 return 0;
681
682 if (*proto != nf_ct_protonum(ct))
683 return 0;
684 } else
685 *proto = nf_ct_protonum(ct);
686
687 return 1;
688 }
689
690 static int sdp_parse_addr(const struct nf_conn *ct, const char *cp,
691 const char **endp, union nf_inet_addr *addr,
692 const char *limit)
693 {
694 const char *end;
695 int ret;
696
697 memset(addr, 0, sizeof(*addr));
698 switch (nf_ct_l3num(ct)) {
699 case AF_INET:
700 ret = in4_pton(cp, limit - cp, (u8 *)&addr->ip, -1, &end);
701 break;
702 case AF_INET6:
703 ret = in6_pton(cp, limit - cp, (u8 *)&addr->ip6, -1, &end);
704 break;
705 default:
706 BUG();
707 }
708
709 if (ret == 0)
710 return 0;
711 if (endp)
712 *endp = end;
713 return 1;
714 }
715
716 /* skip ip address. returns its length. */
717 static int sdp_addr_len(const struct nf_conn *ct, const char *dptr,
718 const char *limit, int *shift)
719 {
720 union nf_inet_addr addr;
721 const char *aux = dptr;
722
723 if (!sdp_parse_addr(ct, dptr, &dptr, &addr, limit)) {
724 pr_debug("ip: %s parse failed.!\n", dptr);
725 return 0;
726 }
727
728 return dptr - aux;
729 }
730
731 /* SDP header parsing: a SDP session description contains an ordered set of
732 * headers, starting with a section containing general session parameters,
733 * optionally followed by multiple media descriptions.
734 *
735 * SDP headers always start at the beginning of a line. According to RFC 2327:
736 * "The sequence CRLF (0x0d0a) is used to end a record, although parsers should
737 * be tolerant and also accept records terminated with a single newline
738 * character". We handle both cases.
739 */
740 static const struct sip_header ct_sdp_hdrs[] = {
741 [SDP_HDR_VERSION] = SDP_HDR("v=", NULL, digits_len),
742 [SDP_HDR_OWNER_IP4] = SDP_HDR("o=", "IN IP4 ", sdp_addr_len),
743 [SDP_HDR_CONNECTION_IP4] = SDP_HDR("c=", "IN IP4 ", sdp_addr_len),
744 [SDP_HDR_OWNER_IP6] = SDP_HDR("o=", "IN IP6 ", sdp_addr_len),
745 [SDP_HDR_CONNECTION_IP6] = SDP_HDR("c=", "IN IP6 ", sdp_addr_len),
746 [SDP_HDR_MEDIA] = SDP_HDR("m=", NULL, media_len),
747 };
748
749 /* Linear string search within SDP header values */
750 static const char *ct_sdp_header_search(const char *dptr, const char *limit,
751 const char *needle, unsigned int len)
752 {
753 for (limit -= len; dptr < limit; dptr++) {
754 if (*dptr == '\r' || *dptr == '\n')
755 break;
756 if (strncmp(dptr, needle, len) == 0)
757 return dptr;
758 }
759 return NULL;
760 }
761
762 /* Locate a SDP header (optionally a substring within the header value),
763 * optionally stopping at the first occurrence of the term header, parse
764 * it and return the offset and length of the data we're interested in.
765 */
766 int ct_sip_get_sdp_header(const struct nf_conn *ct, const char *dptr,
767 unsigned int dataoff, unsigned int datalen,
768 enum sdp_header_types type,
769 enum sdp_header_types term,
770 unsigned int *matchoff, unsigned int *matchlen)
771 {
772 const struct sip_header *hdr = &ct_sdp_hdrs[type];
773 const struct sip_header *thdr = &ct_sdp_hdrs[term];
774 const char *start = dptr, *limit = dptr + datalen;
775 int shift = 0;
776
777 for (dptr += dataoff; dptr < limit; dptr++) {
778 /* Find beginning of line */
779 if (*dptr != '\r' && *dptr != '\n')
780 continue;
781 if (++dptr >= limit)
782 break;
783 if (*(dptr - 1) == '\r' && *dptr == '\n') {
784 if (++dptr >= limit)
785 break;
786 }
787
788 if (term != SDP_HDR_UNSPEC &&
789 limit - dptr >= thdr->len &&
790 strnicmp(dptr, thdr->name, thdr->len) == 0)
791 break;
792 else if (limit - dptr >= hdr->len &&
793 strnicmp(dptr, hdr->name, hdr->len) == 0)
794 dptr += hdr->len;
795 else
796 continue;
797
798 *matchoff = dptr - start;
799 if (hdr->search) {
800 dptr = ct_sdp_header_search(dptr, limit, hdr->search,
801 hdr->slen);
802 if (!dptr)
803 return -1;
804 dptr += hdr->slen;
805 }
806
807 *matchlen = hdr->match_len(ct, dptr, limit, &shift);
808 if (!*matchlen)
809 return -1;
810 *matchoff = dptr - start + shift;
811 return 1;
812 }
813 return 0;
814 }
815 EXPORT_SYMBOL_GPL(ct_sip_get_sdp_header);
816
817 static int ct_sip_parse_sdp_addr(const struct nf_conn *ct, const char *dptr,
818 unsigned int dataoff, unsigned int datalen,
819 enum sdp_header_types type,
820 enum sdp_header_types term,
821 unsigned int *matchoff, unsigned int *matchlen,
822 union nf_inet_addr *addr)
823 {
824 int ret;
825
826 ret = ct_sip_get_sdp_header(ct, dptr, dataoff, datalen, type, term,
827 matchoff, matchlen);
828 if (ret <= 0)
829 return ret;
830
831 if (!sdp_parse_addr(ct, dptr + *matchoff, NULL, addr,
832 dptr + *matchoff + *matchlen))
833 return -1;
834 return 1;
835 }
836
837 static int refresh_signalling_expectation(struct nf_conn *ct,
838 union nf_inet_addr *addr,
839 u8 proto, __be16 port,
840 unsigned int expires)
841 {
842 struct nf_conn_help *help = nfct_help(ct);
843 struct nf_conntrack_expect *exp;
844 struct hlist_node *n, *next;
845 int found = 0;
846
847 spin_lock_bh(&nf_conntrack_lock);
848 hlist_for_each_entry_safe(exp, n, next, &help->expectations, lnode) {
849 if (exp->class != SIP_EXPECT_SIGNALLING ||
850 !nf_inet_addr_cmp(&exp->tuple.dst.u3, addr) ||
851 exp->tuple.dst.protonum != proto ||
852 exp->tuple.dst.u.udp.port != port)
853 continue;
854 if (!del_timer(&exp->timeout))
855 continue;
856 exp->flags &= ~NF_CT_EXPECT_INACTIVE;
857 exp->timeout.expires = jiffies + expires * HZ;
858 add_timer(&exp->timeout);
859 found = 1;
860 break;
861 }
862 spin_unlock_bh(&nf_conntrack_lock);
863 return found;
864 }
865
866 static void flush_expectations(struct nf_conn *ct, bool media)
867 {
868 struct nf_conn_help *help = nfct_help(ct);
869 struct nf_conntrack_expect *exp;
870 struct hlist_node *n, *next;
871
872 spin_lock_bh(&nf_conntrack_lock);
873 hlist_for_each_entry_safe(exp, n, next, &help->expectations, lnode) {
874 if ((exp->class != SIP_EXPECT_SIGNALLING) ^ media)
875 continue;
876 if (!del_timer(&exp->timeout))
877 continue;
878 nf_ct_unlink_expect(exp);
879 nf_ct_expect_put(exp);
880 if (!media)
881 break;
882 }
883 spin_unlock_bh(&nf_conntrack_lock);
884 }
885
886 static int set_expected_rtp_rtcp(struct sk_buff *skb, unsigned int dataoff,
887 const char **dptr, unsigned int *datalen,
888 union nf_inet_addr *daddr, __be16 port,
889 enum sip_expectation_classes class,
890 unsigned int mediaoff, unsigned int medialen)
891 {
892 struct nf_conntrack_expect *exp, *rtp_exp, *rtcp_exp;
893 enum ip_conntrack_info ctinfo;
894 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
895 struct net *net = nf_ct_net(ct);
896 enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
897 union nf_inet_addr *saddr;
898 struct nf_conntrack_tuple tuple;
899 int direct_rtp = 0, skip_expect = 0, ret = NF_DROP;
900 u_int16_t base_port;
901 __be16 rtp_port, rtcp_port;
902 typeof(nf_nat_sdp_port_hook) nf_nat_sdp_port;
903 typeof(nf_nat_sdp_media_hook) nf_nat_sdp_media;
904
905 saddr = NULL;
906 if (sip_direct_media) {
907 if (!nf_inet_addr_cmp(daddr, &ct->tuplehash[dir].tuple.src.u3))
908 return NF_ACCEPT;
909 saddr = &ct->tuplehash[!dir].tuple.src.u3;
910 }
911
912 /* We need to check whether the registration exists before attempting
913 * to register it since we can see the same media description multiple
914 * times on different connections in case multiple endpoints receive
915 * the same call.
916 *
917 * RTP optimization: if we find a matching media channel expectation
918 * and both the expectation and this connection are SNATed, we assume
919 * both sides can reach each other directly and use the final
920 * destination address from the expectation. We still need to keep
921 * the NATed expectations for media that might arrive from the
922 * outside, and additionally need to expect the direct RTP stream
923 * in case it passes through us even without NAT.
924 */
925 memset(&tuple, 0, sizeof(tuple));
926 if (saddr)
927 tuple.src.u3 = *saddr;
928 tuple.src.l3num = nf_ct_l3num(ct);
929 tuple.dst.protonum = IPPROTO_UDP;
930 tuple.dst.u3 = *daddr;
931 tuple.dst.u.udp.port = port;
932
933 rcu_read_lock();
934 do {
935 exp = __nf_ct_expect_find(net, nf_ct_zone(ct), &tuple);
936
937 if (!exp || exp->master == ct ||
938 nfct_help(exp->master)->helper != nfct_help(ct)->helper ||
939 exp->class != class)
940 break;
941 #ifdef CONFIG_NF_NAT_NEEDED
942 if (exp->tuple.src.l3num == AF_INET && !direct_rtp &&
943 (exp->saved_ip != exp->tuple.dst.u3.ip ||
944 exp->saved_proto.udp.port != exp->tuple.dst.u.udp.port) &&
945 ct->status & IPS_NAT_MASK) {
946 daddr->ip = exp->saved_ip;
947 tuple.dst.u3.ip = exp->saved_ip;
948 tuple.dst.u.udp.port = exp->saved_proto.udp.port;
949 direct_rtp = 1;
950 } else
951 #endif
952 skip_expect = 1;
953 } while (!skip_expect);
954 rcu_read_unlock();
955
956 base_port = ntohs(tuple.dst.u.udp.port) & ~1;
957 rtp_port = htons(base_port);
958 rtcp_port = htons(base_port + 1);
959
960 if (direct_rtp) {
961 nf_nat_sdp_port = rcu_dereference(nf_nat_sdp_port_hook);
962 if (nf_nat_sdp_port &&
963 !nf_nat_sdp_port(skb, dataoff, dptr, datalen,
964 mediaoff, medialen, ntohs(rtp_port)))
965 goto err1;
966 }
967
968 if (skip_expect)
969 return NF_ACCEPT;
970
971 rtp_exp = nf_ct_expect_alloc(ct);
972 if (rtp_exp == NULL)
973 goto err1;
974 nf_ct_expect_init(rtp_exp, class, nf_ct_l3num(ct), saddr, daddr,
975 IPPROTO_UDP, NULL, &rtp_port);
976
977 rtcp_exp = nf_ct_expect_alloc(ct);
978 if (rtcp_exp == NULL)
979 goto err2;
980 nf_ct_expect_init(rtcp_exp, class, nf_ct_l3num(ct), saddr, daddr,
981 IPPROTO_UDP, NULL, &rtcp_port);
982
983 nf_nat_sdp_media = rcu_dereference(nf_nat_sdp_media_hook);
984 if (nf_nat_sdp_media && ct->status & IPS_NAT_MASK && !direct_rtp)
985 ret = nf_nat_sdp_media(skb, dataoff, dptr, datalen,
986 rtp_exp, rtcp_exp,
987 mediaoff, medialen, daddr);
988 else {
989 if (nf_ct_expect_related(rtp_exp) == 0) {
990 if (nf_ct_expect_related(rtcp_exp) != 0)
991 nf_ct_unexpect_related(rtp_exp);
992 else
993 ret = NF_ACCEPT;
994 }
995 }
996 nf_ct_expect_put(rtcp_exp);
997 err2:
998 nf_ct_expect_put(rtp_exp);
999 err1:
1000 return ret;
1001 }
1002
1003 static const struct sdp_media_type sdp_media_types[] = {
1004 SDP_MEDIA_TYPE("audio ", SIP_EXPECT_AUDIO),
1005 SDP_MEDIA_TYPE("video ", SIP_EXPECT_VIDEO),
1006 SDP_MEDIA_TYPE("image ", SIP_EXPECT_IMAGE),
1007 };
1008
1009 static const struct sdp_media_type *sdp_media_type(const char *dptr,
1010 unsigned int matchoff,
1011 unsigned int matchlen)
1012 {
1013 const struct sdp_media_type *t;
1014 unsigned int i;
1015
1016 for (i = 0; i < ARRAY_SIZE(sdp_media_types); i++) {
1017 t = &sdp_media_types[i];
1018 if (matchlen < t->len ||
1019 strncmp(dptr + matchoff, t->name, t->len))
1020 continue;
1021 return t;
1022 }
1023 return NULL;
1024 }
1025
1026 static int process_sdp(struct sk_buff *skb, unsigned int dataoff,
1027 const char **dptr, unsigned int *datalen,
1028 unsigned int cseq)
1029 {
1030 enum ip_conntrack_info ctinfo;
1031 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1032 unsigned int matchoff, matchlen;
1033 unsigned int mediaoff, medialen;
1034 unsigned int sdpoff;
1035 unsigned int caddr_len, maddr_len;
1036 unsigned int i;
1037 union nf_inet_addr caddr, maddr, rtp_addr;
1038 unsigned int port;
1039 enum sdp_header_types c_hdr;
1040 const struct sdp_media_type *t;
1041 int ret = NF_ACCEPT;
1042 typeof(nf_nat_sdp_addr_hook) nf_nat_sdp_addr;
1043 typeof(nf_nat_sdp_session_hook) nf_nat_sdp_session;
1044
1045 nf_nat_sdp_addr = rcu_dereference(nf_nat_sdp_addr_hook);
1046 c_hdr = nf_ct_l3num(ct) == AF_INET ? SDP_HDR_CONNECTION_IP4 :
1047 SDP_HDR_CONNECTION_IP6;
1048
1049 /* Find beginning of session description */
1050 if (ct_sip_get_sdp_header(ct, *dptr, 0, *datalen,
1051 SDP_HDR_VERSION, SDP_HDR_UNSPEC,
1052 &matchoff, &matchlen) <= 0)
1053 return NF_ACCEPT;
1054 sdpoff = matchoff;
1055
1056 /* The connection information is contained in the session description
1057 * and/or once per media description. The first media description marks
1058 * the end of the session description. */
1059 caddr_len = 0;
1060 if (ct_sip_parse_sdp_addr(ct, *dptr, sdpoff, *datalen,
1061 c_hdr, SDP_HDR_MEDIA,
1062 &matchoff, &matchlen, &caddr) > 0)
1063 caddr_len = matchlen;
1064
1065 mediaoff = sdpoff;
1066 for (i = 0; i < ARRAY_SIZE(sdp_media_types); ) {
1067 if (ct_sip_get_sdp_header(ct, *dptr, mediaoff, *datalen,
1068 SDP_HDR_MEDIA, SDP_HDR_UNSPEC,
1069 &mediaoff, &medialen) <= 0)
1070 break;
1071
1072 /* Get media type and port number. A media port value of zero
1073 * indicates an inactive stream. */
1074 t = sdp_media_type(*dptr, mediaoff, medialen);
1075 if (!t) {
1076 mediaoff += medialen;
1077 continue;
1078 }
1079 mediaoff += t->len;
1080 medialen -= t->len;
1081
1082 port = simple_strtoul(*dptr + mediaoff, NULL, 10);
1083 if (port == 0)
1084 continue;
1085 if (port < 1024 || port > 65535)
1086 return NF_DROP;
1087
1088 /* The media description overrides the session description. */
1089 maddr_len = 0;
1090 if (ct_sip_parse_sdp_addr(ct, *dptr, mediaoff, *datalen,
1091 c_hdr, SDP_HDR_MEDIA,
1092 &matchoff, &matchlen, &maddr) > 0) {
1093 maddr_len = matchlen;
1094 memcpy(&rtp_addr, &maddr, sizeof(rtp_addr));
1095 } else if (caddr_len)
1096 memcpy(&rtp_addr, &caddr, sizeof(rtp_addr));
1097 else
1098 return NF_DROP;
1099
1100 ret = set_expected_rtp_rtcp(skb, dataoff, dptr, datalen,
1101 &rtp_addr, htons(port), t->class,
1102 mediaoff, medialen);
1103 if (ret != NF_ACCEPT)
1104 return ret;
1105
1106 /* Update media connection address if present */
1107 if (maddr_len && nf_nat_sdp_addr && ct->status & IPS_NAT_MASK) {
1108 ret = nf_nat_sdp_addr(skb, dataoff, dptr, datalen,
1109 mediaoff, c_hdr, SDP_HDR_MEDIA,
1110 &rtp_addr);
1111 if (ret != NF_ACCEPT)
1112 return ret;
1113 }
1114 i++;
1115 }
1116
1117 /* Update session connection and owner addresses */
1118 nf_nat_sdp_session = rcu_dereference(nf_nat_sdp_session_hook);
1119 if (nf_nat_sdp_session && ct->status & IPS_NAT_MASK)
1120 ret = nf_nat_sdp_session(skb, dataoff, dptr, datalen, sdpoff,
1121 &rtp_addr);
1122
1123 return ret;
1124 }
1125 static int process_invite_response(struct sk_buff *skb, unsigned int dataoff,
1126 const char **dptr, unsigned int *datalen,
1127 unsigned int cseq, unsigned int code)
1128 {
1129 enum ip_conntrack_info ctinfo;
1130 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1131 struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1132
1133 if ((code >= 100 && code <= 199) ||
1134 (code >= 200 && code <= 299))
1135 return process_sdp(skb, dataoff, dptr, datalen, cseq);
1136 else if (ct_sip_info->invite_cseq == cseq)
1137 flush_expectations(ct, true);
1138 return NF_ACCEPT;
1139 }
1140
1141 static int process_update_response(struct sk_buff *skb, unsigned int dataoff,
1142 const char **dptr, unsigned int *datalen,
1143 unsigned int cseq, unsigned int code)
1144 {
1145 enum ip_conntrack_info ctinfo;
1146 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1147 struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1148
1149 if ((code >= 100 && code <= 199) ||
1150 (code >= 200 && code <= 299))
1151 return process_sdp(skb, dataoff, dptr, datalen, cseq);
1152 else if (ct_sip_info->invite_cseq == cseq)
1153 flush_expectations(ct, true);
1154 return NF_ACCEPT;
1155 }
1156
1157 static int process_prack_response(struct sk_buff *skb, unsigned int dataoff,
1158 const char **dptr, unsigned int *datalen,
1159 unsigned int cseq, unsigned int code)
1160 {
1161 enum ip_conntrack_info ctinfo;
1162 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1163 struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1164
1165 if ((code >= 100 && code <= 199) ||
1166 (code >= 200 && code <= 299))
1167 return process_sdp(skb, dataoff, dptr, datalen, cseq);
1168 else if (ct_sip_info->invite_cseq == cseq)
1169 flush_expectations(ct, true);
1170 return NF_ACCEPT;
1171 }
1172
1173 static int process_invite_request(struct sk_buff *skb, unsigned int dataoff,
1174 const char **dptr, unsigned int *datalen,
1175 unsigned int cseq)
1176 {
1177 enum ip_conntrack_info ctinfo;
1178 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1179 struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1180 unsigned int ret;
1181
1182 flush_expectations(ct, true);
1183 ret = process_sdp(skb, dataoff, dptr, datalen, cseq);
1184 if (ret == NF_ACCEPT)
1185 ct_sip_info->invite_cseq = cseq;
1186 return ret;
1187 }
1188
1189 static int process_bye_request(struct sk_buff *skb, unsigned int dataoff,
1190 const char **dptr, unsigned int *datalen,
1191 unsigned int cseq)
1192 {
1193 enum ip_conntrack_info ctinfo;
1194 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1195
1196 flush_expectations(ct, true);
1197 return NF_ACCEPT;
1198 }
1199
1200 /* Parse a REGISTER request and create a permanent expectation for incoming
1201 * signalling connections. The expectation is marked inactive and is activated
1202 * when receiving a response indicating success from the registrar.
1203 */
1204 static int process_register_request(struct sk_buff *skb, unsigned int dataoff,
1205 const char **dptr, unsigned int *datalen,
1206 unsigned int cseq)
1207 {
1208 enum ip_conntrack_info ctinfo;
1209 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1210 struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1211 enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
1212 unsigned int matchoff, matchlen;
1213 struct nf_conntrack_expect *exp;
1214 union nf_inet_addr *saddr, daddr;
1215 __be16 port;
1216 u8 proto;
1217 unsigned int expires = 0;
1218 int ret;
1219 typeof(nf_nat_sip_expect_hook) nf_nat_sip_expect;
1220
1221 /* Expected connections can not register again. */
1222 if (ct->status & IPS_EXPECTED)
1223 return NF_ACCEPT;
1224
1225 /* We must check the expiration time: a value of zero signals the
1226 * registrar to release the binding. We'll remove our expectation
1227 * when receiving the new bindings in the response, but we don't
1228 * want to create new ones.
1229 *
1230 * The expiration time may be contained in Expires: header, the
1231 * Contact: header parameters or the URI parameters.
1232 */
1233 if (ct_sip_get_header(ct, *dptr, 0, *datalen, SIP_HDR_EXPIRES,
1234 &matchoff, &matchlen) > 0)
1235 expires = simple_strtoul(*dptr + matchoff, NULL, 10);
1236
1237 ret = ct_sip_parse_header_uri(ct, *dptr, NULL, *datalen,
1238 SIP_HDR_CONTACT, NULL,
1239 &matchoff, &matchlen, &daddr, &port);
1240 if (ret < 0)
1241 return NF_DROP;
1242 else if (ret == 0)
1243 return NF_ACCEPT;
1244
1245 /* We don't support third-party registrations */
1246 if (!nf_inet_addr_cmp(&ct->tuplehash[dir].tuple.src.u3, &daddr))
1247 return NF_ACCEPT;
1248
1249 if (ct_sip_parse_transport(ct, *dptr, matchoff + matchlen, *datalen,
1250 &proto) == 0)
1251 return NF_ACCEPT;
1252
1253 if (ct_sip_parse_numerical_param(ct, *dptr,
1254 matchoff + matchlen, *datalen,
1255 "expires=", NULL, NULL, &expires) < 0)
1256 return NF_DROP;
1257
1258 if (expires == 0) {
1259 ret = NF_ACCEPT;
1260 goto store_cseq;
1261 }
1262
1263 exp = nf_ct_expect_alloc(ct);
1264 if (!exp)
1265 return NF_DROP;
1266
1267 saddr = NULL;
1268 if (sip_direct_signalling)
1269 saddr = &ct->tuplehash[!dir].tuple.src.u3;
1270
1271 nf_ct_expect_init(exp, SIP_EXPECT_SIGNALLING, nf_ct_l3num(ct),
1272 saddr, &daddr, proto, NULL, &port);
1273 exp->timeout.expires = sip_timeout * HZ;
1274 exp->helper = nfct_help(ct)->helper;
1275 exp->flags = NF_CT_EXPECT_PERMANENT | NF_CT_EXPECT_INACTIVE;
1276
1277 nf_nat_sip_expect = rcu_dereference(nf_nat_sip_expect_hook);
1278 if (nf_nat_sip_expect && ct->status & IPS_NAT_MASK)
1279 ret = nf_nat_sip_expect(skb, dataoff, dptr, datalen, exp,
1280 matchoff, matchlen);
1281 else {
1282 if (nf_ct_expect_related(exp) != 0)
1283 ret = NF_DROP;
1284 else
1285 ret = NF_ACCEPT;
1286 }
1287 nf_ct_expect_put(exp);
1288
1289 store_cseq:
1290 if (ret == NF_ACCEPT)
1291 ct_sip_info->register_cseq = cseq;
1292 return ret;
1293 }
1294
1295 static int process_register_response(struct sk_buff *skb, unsigned int dataoff,
1296 const char **dptr, unsigned int *datalen,
1297 unsigned int cseq, unsigned int code)
1298 {
1299 enum ip_conntrack_info ctinfo;
1300 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1301 struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct);
1302 enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo);
1303 union nf_inet_addr addr;
1304 __be16 port;
1305 u8 proto;
1306 unsigned int matchoff, matchlen, coff = 0;
1307 unsigned int expires = 0;
1308 int in_contact = 0, ret;
1309
1310 /* According to RFC 3261, "UAs MUST NOT send a new registration until
1311 * they have received a final response from the registrar for the
1312 * previous one or the previous REGISTER request has timed out".
1313 *
1314 * However, some servers fail to detect retransmissions and send late
1315 * responses, so we store the sequence number of the last valid
1316 * request and compare it here.
1317 */
1318 if (ct_sip_info->register_cseq != cseq)
1319 return NF_ACCEPT;
1320
1321 if (code >= 100 && code <= 199)
1322 return NF_ACCEPT;
1323 if (code < 200 || code > 299)
1324 goto flush;
1325
1326 if (ct_sip_get_header(ct, *dptr, 0, *datalen, SIP_HDR_EXPIRES,
1327 &matchoff, &matchlen) > 0)
1328 expires = simple_strtoul(*dptr + matchoff, NULL, 10);
1329
1330 while (1) {
1331 unsigned int c_expires = expires;
1332
1333 ret = ct_sip_parse_header_uri(ct, *dptr, &coff, *datalen,
1334 SIP_HDR_CONTACT, &in_contact,
1335 &matchoff, &matchlen,
1336 &addr, &port);
1337 if (ret < 0)
1338 return NF_DROP;
1339 else if (ret == 0)
1340 break;
1341
1342 /* We don't support third-party registrations */
1343 if (!nf_inet_addr_cmp(&ct->tuplehash[dir].tuple.dst.u3, &addr))
1344 continue;
1345
1346 if (ct_sip_parse_transport(ct, *dptr, matchoff + matchlen,
1347 *datalen, &proto) == 0)
1348 continue;
1349
1350 ret = ct_sip_parse_numerical_param(ct, *dptr,
1351 matchoff + matchlen,
1352 *datalen, "expires=",
1353 NULL, NULL, &c_expires);
1354 if (ret < 0)
1355 return NF_DROP;
1356 if (c_expires == 0)
1357 break;
1358 if (refresh_signalling_expectation(ct, &addr, proto, port,
1359 c_expires))
1360 return NF_ACCEPT;
1361 }
1362
1363 flush:
1364 flush_expectations(ct, false);
1365 return NF_ACCEPT;
1366 }
1367
1368 static const struct sip_handler sip_handlers[] = {
1369 SIP_HANDLER("INVITE", process_invite_request, process_invite_response),
1370 SIP_HANDLER("UPDATE", process_sdp, process_update_response),
1371 SIP_HANDLER("ACK", process_sdp, NULL),
1372 SIP_HANDLER("PRACK", process_sdp, process_prack_response),
1373 SIP_HANDLER("BYE", process_bye_request, NULL),
1374 SIP_HANDLER("REGISTER", process_register_request, process_register_response),
1375 };
1376
1377 static int process_sip_response(struct sk_buff *skb, unsigned int dataoff,
1378 const char **dptr, unsigned int *datalen)
1379 {
1380 enum ip_conntrack_info ctinfo;
1381 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1382 unsigned int matchoff, matchlen, matchend;
1383 unsigned int code, cseq, i;
1384
1385 if (*datalen < strlen("SIP/2.0 200"))
1386 return NF_ACCEPT;
1387 code = simple_strtoul(*dptr + strlen("SIP/2.0 "), NULL, 10);
1388 if (!code)
1389 return NF_DROP;
1390
1391 if (ct_sip_get_header(ct, *dptr, 0, *datalen, SIP_HDR_CSEQ,
1392 &matchoff, &matchlen) <= 0)
1393 return NF_DROP;
1394 cseq = simple_strtoul(*dptr + matchoff, NULL, 10);
1395 if (!cseq)
1396 return NF_DROP;
1397 matchend = matchoff + matchlen + 1;
1398
1399 for (i = 0; i < ARRAY_SIZE(sip_handlers); i++) {
1400 const struct sip_handler *handler;
1401
1402 handler = &sip_handlers[i];
1403 if (handler->response == NULL)
1404 continue;
1405 if (*datalen < matchend + handler->len ||
1406 strnicmp(*dptr + matchend, handler->method, handler->len))
1407 continue;
1408 return handler->response(skb, dataoff, dptr, datalen,
1409 cseq, code);
1410 }
1411 return NF_ACCEPT;
1412 }
1413
1414 static int process_sip_request(struct sk_buff *skb, unsigned int dataoff,
1415 const char **dptr, unsigned int *datalen)
1416 {
1417 enum ip_conntrack_info ctinfo;
1418 struct nf_conn *ct = nf_ct_get(skb, &ctinfo);
1419 unsigned int matchoff, matchlen;
1420 unsigned int cseq, i;
1421
1422 for (i = 0; i < ARRAY_SIZE(sip_handlers); i++) {
1423 const struct sip_handler *handler;
1424
1425 handler = &sip_handlers[i];
1426 if (handler->request == NULL)
1427 continue;
1428 if (*datalen < handler->len ||
1429 strnicmp(*dptr, handler->method, handler->len))
1430 continue;
1431
1432 if (ct_sip_get_header(ct, *dptr, 0, *datalen, SIP_HDR_CSEQ,
1433 &matchoff, &matchlen) <= 0)
1434 return NF_DROP;
1435 cseq = simple_strtoul(*dptr + matchoff, NULL, 10);
1436 if (!cseq)
1437 return NF_DROP;
1438
1439 return handler->request(skb, dataoff, dptr, datalen, cseq);
1440 }
1441 return NF_ACCEPT;
1442 }
1443
1444 static int process_sip_msg(struct sk_buff *skb, struct nf_conn *ct,
1445 unsigned int dataoff, const char **dptr,
1446 unsigned int *datalen)
1447 {
1448 typeof(nf_nat_sip_hook) nf_nat_sip;
1449 int ret;
1450
1451 if (strnicmp(*dptr, "SIP/2.0 ", strlen("SIP/2.0 ")) != 0)
1452 ret = process_sip_request(skb, dataoff, dptr, datalen);
1453 else
1454 ret = process_sip_response(skb, dataoff, dptr, datalen);
1455
1456 if (ret == NF_ACCEPT && ct->status & IPS_NAT_MASK) {
1457 nf_nat_sip = rcu_dereference(nf_nat_sip_hook);
1458 if (nf_nat_sip && !nf_nat_sip(skb, dataoff, dptr, datalen))
1459 ret = NF_DROP;
1460 }
1461
1462 return ret;
1463 }
1464
1465 static int sip_help_tcp(struct sk_buff *skb, unsigned int protoff,
1466 struct nf_conn *ct, enum ip_conntrack_info ctinfo)
1467 {
1468 struct tcphdr *th, _tcph;
1469 unsigned int dataoff, datalen;
1470 unsigned int matchoff, matchlen, clen;
1471 unsigned int msglen, origlen;
1472 const char *dptr, *end;
1473 s16 diff, tdiff = 0;
1474 int ret = NF_ACCEPT;
1475 bool term;
1476 typeof(nf_nat_sip_seq_adjust_hook) nf_nat_sip_seq_adjust;
1477
1478 if (ctinfo != IP_CT_ESTABLISHED &&
1479 ctinfo != IP_CT_ESTABLISHED_REPLY)
1480 return NF_ACCEPT;
1481
1482 /* No Data ? */
1483 th = skb_header_pointer(skb, protoff, sizeof(_tcph), &_tcph);
1484 if (th == NULL)
1485 return NF_ACCEPT;
1486 dataoff = protoff + th->doff * 4;
1487 if (dataoff >= skb->len)
1488 return NF_ACCEPT;
1489
1490 nf_ct_refresh(ct, skb, sip_timeout * HZ);
1491
1492 if (unlikely(skb_linearize(skb)))
1493 return NF_DROP;
1494
1495 dptr = skb->data + dataoff;
1496 datalen = skb->len - dataoff;
1497 if (datalen < strlen("SIP/2.0 200"))
1498 return NF_ACCEPT;
1499
1500 while (1) {
1501 if (ct_sip_get_header(ct, dptr, 0, datalen,
1502 SIP_HDR_CONTENT_LENGTH,
1503 &matchoff, &matchlen) <= 0)
1504 break;
1505
1506 clen = simple_strtoul(dptr + matchoff, (char **)&end, 10);
1507 if (dptr + matchoff == end)
1508 break;
1509
1510 term = false;
1511 for (; end + strlen("\r\n\r\n") <= dptr + datalen; end++) {
1512 if (end[0] == '\r' && end[1] == '\n' &&
1513 end[2] == '\r' && end[3] == '\n') {
1514 term = true;
1515 break;
1516 }
1517 }
1518 if (!term)
1519 break;
1520 end += strlen("\r\n\r\n") + clen;
1521
1522 msglen = origlen = end - dptr;
1523 if (msglen > datalen)
1524 return NF_DROP;
1525
1526 ret = process_sip_msg(skb, ct, dataoff, &dptr, &msglen);
1527 if (ret != NF_ACCEPT)
1528 break;
1529 diff = msglen - origlen;
1530 tdiff += diff;
1531
1532 dataoff += msglen;
1533 dptr += msglen;
1534 datalen = datalen + diff - msglen;
1535 }
1536
1537 if (ret == NF_ACCEPT && ct->status & IPS_NAT_MASK) {
1538 nf_nat_sip_seq_adjust = rcu_dereference(nf_nat_sip_seq_adjust_hook);
1539 if (nf_nat_sip_seq_adjust)
1540 nf_nat_sip_seq_adjust(skb, tdiff);
1541 }
1542
1543 return ret;
1544 }
1545
1546 static int sip_help_udp(struct sk_buff *skb, unsigned int protoff,
1547 struct nf_conn *ct, enum ip_conntrack_info ctinfo)
1548 {
1549 unsigned int dataoff, datalen;
1550 const char *dptr;
1551
1552 /* No Data ? */
1553 dataoff = protoff + sizeof(struct udphdr);
1554 if (dataoff >= skb->len)
1555 return NF_ACCEPT;
1556
1557 nf_ct_refresh(ct, skb, sip_timeout * HZ);
1558
1559 if (unlikely(skb_linearize(skb)))
1560 return NF_DROP;
1561
1562 dptr = skb->data + dataoff;
1563 datalen = skb->len - dataoff;
1564 if (datalen < strlen("SIP/2.0 200"))
1565 return NF_ACCEPT;
1566
1567 return process_sip_msg(skb, ct, dataoff, &dptr, &datalen);
1568 }
1569
1570 static struct nf_conntrack_helper sip[MAX_PORTS][4] __read_mostly;
1571
1572 static const struct nf_conntrack_expect_policy sip_exp_policy[SIP_EXPECT_MAX + 1] = {
1573 [SIP_EXPECT_SIGNALLING] = {
1574 .name = "signalling",
1575 .max_expected = 1,
1576 .timeout = 3 * 60,
1577 },
1578 [SIP_EXPECT_AUDIO] = {
1579 .name = "audio",
1580 .max_expected = 2 * IP_CT_DIR_MAX,
1581 .timeout = 3 * 60,
1582 },
1583 [SIP_EXPECT_VIDEO] = {
1584 .name = "video",
1585 .max_expected = 2 * IP_CT_DIR_MAX,
1586 .timeout = 3 * 60,
1587 },
1588 [SIP_EXPECT_IMAGE] = {
1589 .name = "image",
1590 .max_expected = IP_CT_DIR_MAX,
1591 .timeout = 3 * 60,
1592 },
1593 };
1594
1595 static void nf_conntrack_sip_fini(void)
1596 {
1597 int i, j;
1598
1599 for (i = 0; i < ports_c; i++) {
1600 for (j = 0; j < ARRAY_SIZE(sip[i]); j++) {
1601 if (sip[i][j].me == NULL)
1602 continue;
1603 nf_conntrack_helper_unregister(&sip[i][j]);
1604 }
1605 }
1606 }
1607
1608 static int __init nf_conntrack_sip_init(void)
1609 {
1610 int i, j, ret;
1611
1612 if (ports_c == 0)
1613 ports[ports_c++] = SIP_PORT;
1614
1615 for (i = 0; i < ports_c; i++) {
1616 memset(&sip[i], 0, sizeof(sip[i]));
1617
1618 sip[i][0].tuple.src.l3num = AF_INET;
1619 sip[i][0].tuple.dst.protonum = IPPROTO_UDP;
1620 sip[i][0].help = sip_help_udp;
1621 sip[i][1].tuple.src.l3num = AF_INET;
1622 sip[i][1].tuple.dst.protonum = IPPROTO_TCP;
1623 sip[i][1].help = sip_help_tcp;
1624
1625 sip[i][2].tuple.src.l3num = AF_INET6;
1626 sip[i][2].tuple.dst.protonum = IPPROTO_UDP;
1627 sip[i][2].help = sip_help_udp;
1628 sip[i][3].tuple.src.l3num = AF_INET6;
1629 sip[i][3].tuple.dst.protonum = IPPROTO_TCP;
1630 sip[i][3].help = sip_help_tcp;
1631
1632 for (j = 0; j < ARRAY_SIZE(sip[i]); j++) {
1633 sip[i][j].data_len = sizeof(struct nf_ct_sip_master);
1634 sip[i][j].tuple.src.u.udp.port = htons(ports[i]);
1635 sip[i][j].expect_policy = sip_exp_policy;
1636 sip[i][j].expect_class_max = SIP_EXPECT_MAX;
1637 sip[i][j].me = THIS_MODULE;
1638
1639 if (ports[i] == SIP_PORT)
1640 sprintf(sip[i][j].name, "sip");
1641 else
1642 sprintf(sip[i][j].name, "sip-%u", i);
1643
1644 pr_debug("port #%u: %u\n", i, ports[i]);
1645
1646 ret = nf_conntrack_helper_register(&sip[i][j]);
1647 if (ret) {
1648 printk(KERN_ERR "nf_ct_sip: failed to register"
1649 " helper for pf: %u port: %u\n",
1650 sip[i][j].tuple.src.l3num, ports[i]);
1651 nf_conntrack_sip_fini();
1652 return ret;
1653 }
1654 }
1655 }
1656 return 0;
1657 }
1658
1659 module_init(nf_conntrack_sip_init);
1660 module_exit(nf_conntrack_sip_fini);
Linus' kernel tree