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