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