1 /* SIP extension for NAT alteration. 2 * 3 * (C) 2005 by Christian Hentschel <chentschel@arnet.com.ar> 4 * based on RR's ip_nat_ftp.c and other modules. 5 * (C) 2007 United Security Providers 6 * (C) 2007, 2008, 2011, 2012 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/skbuff.h> 15 #include <linux/inet.h> 16 #include <linux/udp.h> 17 #include <linux/tcp.h> 18 19 #include <net/netfilter/nf_nat.h> 20 #include <net/netfilter/nf_nat_helper.h> 21 #include <net/netfilter/nf_conntrack_helper.h> 22 #include <net/netfilter/nf_conntrack_expect.h> 23 #include <net/netfilter/nf_conntrack_seqadj.h> 24 #include <linux/netfilter/nf_conntrack_sip.h> 25 26 MODULE_LICENSE("GPL"); 27 MODULE_AUTHOR("Christian Hentschel <chentschel@arnet.com.ar>"); 28 MODULE_DESCRIPTION("SIP NAT helper"); 29 MODULE_ALIAS("ip_nat_sip"); 30 31 32 static unsigned int mangle_packet(struct sk_buff *skb, unsigned int protoff, 33 unsigned int dataoff, 34 const char **dptr, unsigned int *datalen, 35 unsigned int matchoff, unsigned int matchlen, 36 const char *buffer, unsigned int buflen) 37 { 38 enum ip_conntrack_info ctinfo; 39 struct nf_conn *ct = nf_ct_get(skb, &ctinfo); 40 struct tcphdr *th; 41 unsigned int baseoff; 42 43 if (nf_ct_protonum(ct) == IPPROTO_TCP) { 44 th = (struct tcphdr *)(skb->data + protoff); 45 baseoff = protoff + th->doff * 4; 46 matchoff += dataoff - baseoff; 47 48 if (!__nf_nat_mangle_tcp_packet(skb, ct, ctinfo, 49 protoff, matchoff, matchlen, 50 buffer, buflen, false)) 51 return 0; 52 } else { 53 baseoff = protoff + sizeof(struct udphdr); 54 matchoff += dataoff - baseoff; 55 56 if (!nf_nat_mangle_udp_packet(skb, ct, ctinfo, 57 protoff, matchoff, matchlen, 58 buffer, buflen)) 59 return 0; 60 } 61 62 /* Reload data pointer and adjust datalen value */ 63 *dptr = skb->data + dataoff; 64 *datalen += buflen - matchlen; 65 return 1; 66 } 67 68 static int sip_sprintf_addr(const struct nf_conn *ct, char *buffer, 69 const union nf_inet_addr *addr, bool delim) 70 { 71 if (nf_ct_l3num(ct) == NFPROTO_IPV4) 72 return sprintf(buffer, "%pI4", &addr->ip); 73 else { 74 if (delim) 75 return sprintf(buffer, "[%pI6c]", &addr->ip6); 76 else 77 return sprintf(buffer, "%pI6c", &addr->ip6); 78 } 79 } 80 81 static int sip_sprintf_addr_port(const struct nf_conn *ct, char *buffer, 82 const union nf_inet_addr *addr, u16 port) 83 { 84 if (nf_ct_l3num(ct) == NFPROTO_IPV4) 85 return sprintf(buffer, "%pI4:%u", &addr->ip, port); 86 else 87 return sprintf(buffer, "[%pI6c]:%u", &addr->ip6, port); 88 } 89 90 static int map_addr(struct sk_buff *skb, unsigned int protoff, 91 unsigned int dataoff, 92 const char **dptr, unsigned int *datalen, 93 unsigned int matchoff, unsigned int matchlen, 94 union nf_inet_addr *addr, __be16 port) 95 { 96 enum ip_conntrack_info ctinfo; 97 struct nf_conn *ct = nf_ct_get(skb, &ctinfo); 98 enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo); 99 struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct); 100 char buffer[INET6_ADDRSTRLEN + sizeof("[]:nnnnn")]; 101 unsigned int buflen; 102 union nf_inet_addr newaddr; 103 __be16 newport; 104 105 if (nf_inet_addr_cmp(&ct->tuplehash[dir].tuple.src.u3, addr) && 106 ct->tuplehash[dir].tuple.src.u.udp.port == port) { 107 newaddr = ct->tuplehash[!dir].tuple.dst.u3; 108 newport = ct->tuplehash[!dir].tuple.dst.u.udp.port; 109 } else if (nf_inet_addr_cmp(&ct->tuplehash[dir].tuple.dst.u3, addr) && 110 ct->tuplehash[dir].tuple.dst.u.udp.port == port) { 111 newaddr = ct->tuplehash[!dir].tuple.src.u3; 112 newport = ct_sip_info->forced_dport ? : 113 ct->tuplehash[!dir].tuple.src.u.udp.port; 114 } else 115 return 1; 116 117 if (nf_inet_addr_cmp(&newaddr, addr) && newport == port) 118 return 1; 119 120 buflen = sip_sprintf_addr_port(ct, buffer, &newaddr, ntohs(newport)); 121 return mangle_packet(skb, protoff, dataoff, dptr, datalen, 122 matchoff, matchlen, buffer, buflen); 123 } 124 125 static int map_sip_addr(struct sk_buff *skb, unsigned int protoff, 126 unsigned int dataoff, 127 const char **dptr, unsigned int *datalen, 128 enum sip_header_types type) 129 { 130 enum ip_conntrack_info ctinfo; 131 struct nf_conn *ct = nf_ct_get(skb, &ctinfo); 132 unsigned int matchlen, matchoff; 133 union nf_inet_addr addr; 134 __be16 port; 135 136 if (ct_sip_parse_header_uri(ct, *dptr, NULL, *datalen, type, NULL, 137 &matchoff, &matchlen, &addr, &port) <= 0) 138 return 1; 139 return map_addr(skb, protoff, dataoff, dptr, datalen, 140 matchoff, matchlen, &addr, port); 141 } 142 143 static unsigned int nf_nat_sip(struct sk_buff *skb, unsigned int protoff, 144 unsigned int dataoff, 145 const char **dptr, unsigned int *datalen) 146 { 147 enum ip_conntrack_info ctinfo; 148 struct nf_conn *ct = nf_ct_get(skb, &ctinfo); 149 enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo); 150 struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct); 151 unsigned int coff, matchoff, matchlen; 152 enum sip_header_types hdr; 153 union nf_inet_addr addr; 154 __be16 port; 155 int request, in_header; 156 157 /* Basic rules: requests and responses. */ 158 if (strncasecmp(*dptr, "SIP/2.0", strlen("SIP/2.0")) != 0) { 159 if (ct_sip_parse_request(ct, *dptr, *datalen, 160 &matchoff, &matchlen, 161 &addr, &port) > 0 && 162 !map_addr(skb, protoff, dataoff, dptr, datalen, 163 matchoff, matchlen, &addr, port)) { 164 nf_ct_helper_log(skb, ct, "cannot mangle SIP message"); 165 return NF_DROP; 166 } 167 request = 1; 168 } else 169 request = 0; 170 171 if (nf_ct_protonum(ct) == IPPROTO_TCP) 172 hdr = SIP_HDR_VIA_TCP; 173 else 174 hdr = SIP_HDR_VIA_UDP; 175 176 /* Translate topmost Via header and parameters */ 177 if (ct_sip_parse_header_uri(ct, *dptr, NULL, *datalen, 178 hdr, NULL, &matchoff, &matchlen, 179 &addr, &port) > 0) { 180 unsigned int olen, matchend, poff, plen, buflen, n; 181 char buffer[INET6_ADDRSTRLEN + sizeof("[]:nnnnn")]; 182 183 /* We're only interested in headers related to this 184 * connection */ 185 if (request) { 186 if (!nf_inet_addr_cmp(&addr, 187 &ct->tuplehash[dir].tuple.src.u3) || 188 port != ct->tuplehash[dir].tuple.src.u.udp.port) 189 goto next; 190 } else { 191 if (!nf_inet_addr_cmp(&addr, 192 &ct->tuplehash[dir].tuple.dst.u3) || 193 port != ct->tuplehash[dir].tuple.dst.u.udp.port) 194 goto next; 195 } 196 197 olen = *datalen; 198 if (!map_addr(skb, protoff, dataoff, dptr, datalen, 199 matchoff, matchlen, &addr, port)) { 200 nf_ct_helper_log(skb, ct, "cannot mangle Via header"); 201 return NF_DROP; 202 } 203 204 matchend = matchoff + matchlen + *datalen - olen; 205 206 /* The maddr= parameter (RFC 2361) specifies where to send 207 * the reply. */ 208 if (ct_sip_parse_address_param(ct, *dptr, matchend, *datalen, 209 "maddr=", &poff, &plen, 210 &addr, true) > 0 && 211 nf_inet_addr_cmp(&addr, &ct->tuplehash[dir].tuple.src.u3) && 212 !nf_inet_addr_cmp(&addr, &ct->tuplehash[!dir].tuple.dst.u3)) { 213 buflen = sip_sprintf_addr(ct, buffer, 214 &ct->tuplehash[!dir].tuple.dst.u3, 215 true); 216 if (!mangle_packet(skb, protoff, dataoff, dptr, datalen, 217 poff, plen, buffer, buflen)) { 218 nf_ct_helper_log(skb, ct, "cannot mangle maddr"); 219 return NF_DROP; 220 } 221 } 222 223 /* The received= parameter (RFC 2361) contains the address 224 * from which the server received the request. */ 225 if (ct_sip_parse_address_param(ct, *dptr, matchend, *datalen, 226 "received=", &poff, &plen, 227 &addr, false) > 0 && 228 nf_inet_addr_cmp(&addr, &ct->tuplehash[dir].tuple.dst.u3) && 229 !nf_inet_addr_cmp(&addr, &ct->tuplehash[!dir].tuple.src.u3)) { 230 buflen = sip_sprintf_addr(ct, buffer, 231 &ct->tuplehash[!dir].tuple.src.u3, 232 false); 233 if (!mangle_packet(skb, protoff, dataoff, dptr, datalen, 234 poff, plen, buffer, buflen)) { 235 nf_ct_helper_log(skb, ct, "cannot mangle received"); 236 return NF_DROP; 237 } 238 } 239 240 /* The rport= parameter (RFC 3581) contains the port number 241 * from which the server received the request. */ 242 if (ct_sip_parse_numerical_param(ct, *dptr, matchend, *datalen, 243 "rport=", &poff, &plen, 244 &n) > 0 && 245 htons(n) == ct->tuplehash[dir].tuple.dst.u.udp.port && 246 htons(n) != ct->tuplehash[!dir].tuple.src.u.udp.port) { 247 __be16 p = ct->tuplehash[!dir].tuple.src.u.udp.port; 248 buflen = sprintf(buffer, "%u", ntohs(p)); 249 if (!mangle_packet(skb, protoff, dataoff, dptr, datalen, 250 poff, plen, buffer, buflen)) { 251 nf_ct_helper_log(skb, ct, "cannot mangle rport"); 252 return NF_DROP; 253 } 254 } 255 } 256 257 next: 258 /* Translate Contact headers */ 259 coff = 0; 260 in_header = 0; 261 while (ct_sip_parse_header_uri(ct, *dptr, &coff, *datalen, 262 SIP_HDR_CONTACT, &in_header, 263 &matchoff, &matchlen, 264 &addr, &port) > 0) { 265 if (!map_addr(skb, protoff, dataoff, dptr, datalen, 266 matchoff, matchlen, 267 &addr, port)) { 268 nf_ct_helper_log(skb, ct, "cannot mangle contact"); 269 return NF_DROP; 270 } 271 } 272 273 if (!map_sip_addr(skb, protoff, dataoff, dptr, datalen, SIP_HDR_FROM) || 274 !map_sip_addr(skb, protoff, dataoff, dptr, datalen, SIP_HDR_TO)) { 275 nf_ct_helper_log(skb, ct, "cannot mangle SIP from/to"); 276 return NF_DROP; 277 } 278 279 /* Mangle destination port for Cisco phones, then fix up checksums */ 280 if (dir == IP_CT_DIR_REPLY && ct_sip_info->forced_dport) { 281 struct udphdr *uh; 282 283 if (!skb_make_writable(skb, skb->len)) { 284 nf_ct_helper_log(skb, ct, "cannot mangle packet"); 285 return NF_DROP; 286 } 287 288 uh = (void *)skb->data + protoff; 289 uh->dest = ct_sip_info->forced_dport; 290 291 if (!nf_nat_mangle_udp_packet(skb, ct, ctinfo, protoff, 292 0, 0, NULL, 0)) { 293 nf_ct_helper_log(skb, ct, "cannot mangle packet"); 294 return NF_DROP; 295 } 296 } 297 298 return NF_ACCEPT; 299 } 300 301 static void nf_nat_sip_seq_adjust(struct sk_buff *skb, unsigned int protoff, 302 s16 off) 303 { 304 enum ip_conntrack_info ctinfo; 305 struct nf_conn *ct = nf_ct_get(skb, &ctinfo); 306 const struct tcphdr *th; 307 308 if (nf_ct_protonum(ct) != IPPROTO_TCP || off == 0) 309 return; 310 311 th = (struct tcphdr *)(skb->data + protoff); 312 nf_ct_seqadj_set(ct, ctinfo, th->seq, off); 313 } 314 315 /* Handles expected signalling connections and media streams */ 316 static void nf_nat_sip_expected(struct nf_conn *ct, 317 struct nf_conntrack_expect *exp) 318 { 319 struct nf_nat_range range; 320 321 /* This must be a fresh one. */ 322 BUG_ON(ct->status & IPS_NAT_DONE_MASK); 323 324 /* For DST manip, map port here to where it's expected. */ 325 range.flags = (NF_NAT_RANGE_MAP_IPS | NF_NAT_RANGE_PROTO_SPECIFIED); 326 range.min_proto = range.max_proto = exp->saved_proto; 327 range.min_addr = range.max_addr = exp->saved_addr; 328 nf_nat_setup_info(ct, &range, NF_NAT_MANIP_DST); 329 330 /* Change src to where master sends to, but only if the connection 331 * actually came from the same source. */ 332 if (nf_inet_addr_cmp(&ct->tuplehash[IP_CT_DIR_ORIGINAL].tuple.src.u3, 333 &ct->master->tuplehash[exp->dir].tuple.src.u3)) { 334 range.flags = NF_NAT_RANGE_MAP_IPS; 335 range.min_addr = range.max_addr 336 = ct->master->tuplehash[!exp->dir].tuple.dst.u3; 337 nf_nat_setup_info(ct, &range, NF_NAT_MANIP_SRC); 338 } 339 } 340 341 static unsigned int nf_nat_sip_expect(struct sk_buff *skb, unsigned int protoff, 342 unsigned int dataoff, 343 const char **dptr, unsigned int *datalen, 344 struct nf_conntrack_expect *exp, 345 unsigned int matchoff, 346 unsigned int matchlen) 347 { 348 enum ip_conntrack_info ctinfo; 349 struct nf_conn *ct = nf_ct_get(skb, &ctinfo); 350 enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo); 351 struct nf_ct_sip_master *ct_sip_info = nfct_help_data(ct); 352 union nf_inet_addr newaddr; 353 u_int16_t port; 354 __be16 srcport; 355 char buffer[INET6_ADDRSTRLEN + sizeof("[]:nnnnn")]; 356 unsigned int buflen; 357 358 /* Connection will come from reply */ 359 if (nf_inet_addr_cmp(&ct->tuplehash[dir].tuple.src.u3, 360 &ct->tuplehash[!dir].tuple.dst.u3)) 361 newaddr = exp->tuple.dst.u3; 362 else 363 newaddr = ct->tuplehash[!dir].tuple.dst.u3; 364 365 /* If the signalling port matches the connection's source port in the 366 * original direction, try to use the destination port in the opposite 367 * direction. */ 368 srcport = ct_sip_info->forced_dport ? : 369 ct->tuplehash[dir].tuple.src.u.udp.port; 370 if (exp->tuple.dst.u.udp.port == srcport) 371 port = ntohs(ct->tuplehash[!dir].tuple.dst.u.udp.port); 372 else 373 port = ntohs(exp->tuple.dst.u.udp.port); 374 375 exp->saved_addr = exp->tuple.dst.u3; 376 exp->tuple.dst.u3 = newaddr; 377 exp->saved_proto.udp.port = exp->tuple.dst.u.udp.port; 378 exp->dir = !dir; 379 exp->expectfn = nf_nat_sip_expected; 380 381 for (; port != 0; port++) { 382 int ret; 383 384 exp->tuple.dst.u.udp.port = htons(port); 385 ret = nf_ct_expect_related(exp); 386 if (ret == 0) 387 break; 388 else if (ret != -EBUSY) { 389 port = 0; 390 break; 391 } 392 } 393 394 if (port == 0) { 395 nf_ct_helper_log(skb, ct, "all ports in use for SIP"); 396 return NF_DROP; 397 } 398 399 if (!nf_inet_addr_cmp(&exp->tuple.dst.u3, &exp->saved_addr) || 400 exp->tuple.dst.u.udp.port != exp->saved_proto.udp.port) { 401 buflen = sip_sprintf_addr_port(ct, buffer, &newaddr, port); 402 if (!mangle_packet(skb, protoff, dataoff, dptr, datalen, 403 matchoff, matchlen, buffer, buflen)) { 404 nf_ct_helper_log(skb, ct, "cannot mangle packet"); 405 goto err; 406 } 407 } 408 return NF_ACCEPT; 409 410 err: 411 nf_ct_unexpect_related(exp); 412 return NF_DROP; 413 } 414 415 static int mangle_content_len(struct sk_buff *skb, unsigned int protoff, 416 unsigned int dataoff, 417 const char **dptr, unsigned int *datalen) 418 { 419 enum ip_conntrack_info ctinfo; 420 struct nf_conn *ct = nf_ct_get(skb, &ctinfo); 421 unsigned int matchoff, matchlen; 422 char buffer[sizeof("65536")]; 423 int buflen, c_len; 424 425 /* Get actual SDP length */ 426 if (ct_sip_get_sdp_header(ct, *dptr, 0, *datalen, 427 SDP_HDR_VERSION, SDP_HDR_UNSPEC, 428 &matchoff, &matchlen) <= 0) 429 return 0; 430 c_len = *datalen - matchoff + strlen("v="); 431 432 /* Now, update SDP length */ 433 if (ct_sip_get_header(ct, *dptr, 0, *datalen, SIP_HDR_CONTENT_LENGTH, 434 &matchoff, &matchlen) <= 0) 435 return 0; 436 437 buflen = sprintf(buffer, "%u", c_len); 438 return mangle_packet(skb, protoff, dataoff, dptr, datalen, 439 matchoff, matchlen, buffer, buflen); 440 } 441 442 static int mangle_sdp_packet(struct sk_buff *skb, unsigned int protoff, 443 unsigned int dataoff, 444 const char **dptr, unsigned int *datalen, 445 unsigned int sdpoff, 446 enum sdp_header_types type, 447 enum sdp_header_types term, 448 char *buffer, int buflen) 449 { 450 enum ip_conntrack_info ctinfo; 451 struct nf_conn *ct = nf_ct_get(skb, &ctinfo); 452 unsigned int matchlen, matchoff; 453 454 if (ct_sip_get_sdp_header(ct, *dptr, sdpoff, *datalen, type, term, 455 &matchoff, &matchlen) <= 0) 456 return -ENOENT; 457 return mangle_packet(skb, protoff, dataoff, dptr, datalen, 458 matchoff, matchlen, buffer, buflen) ? 0 : -EINVAL; 459 } 460 461 static unsigned int nf_nat_sdp_addr(struct sk_buff *skb, unsigned int protoff, 462 unsigned int dataoff, 463 const char **dptr, unsigned int *datalen, 464 unsigned int sdpoff, 465 enum sdp_header_types type, 466 enum sdp_header_types term, 467 const union nf_inet_addr *addr) 468 { 469 enum ip_conntrack_info ctinfo; 470 struct nf_conn *ct = nf_ct_get(skb, &ctinfo); 471 char buffer[INET6_ADDRSTRLEN]; 472 unsigned int buflen; 473 474 buflen = sip_sprintf_addr(ct, buffer, addr, false); 475 if (mangle_sdp_packet(skb, protoff, dataoff, dptr, datalen, 476 sdpoff, type, term, buffer, buflen)) 477 return 0; 478 479 return mangle_content_len(skb, protoff, dataoff, dptr, datalen); 480 } 481 482 static unsigned int nf_nat_sdp_port(struct sk_buff *skb, unsigned int protoff, 483 unsigned int dataoff, 484 const char **dptr, unsigned int *datalen, 485 unsigned int matchoff, 486 unsigned int matchlen, 487 u_int16_t port) 488 { 489 char buffer[sizeof("nnnnn")]; 490 unsigned int buflen; 491 492 buflen = sprintf(buffer, "%u", port); 493 if (!mangle_packet(skb, protoff, dataoff, dptr, datalen, 494 matchoff, matchlen, buffer, buflen)) 495 return 0; 496 497 return mangle_content_len(skb, protoff, dataoff, dptr, datalen); 498 } 499 500 static unsigned int nf_nat_sdp_session(struct sk_buff *skb, unsigned int protoff, 501 unsigned int dataoff, 502 const char **dptr, unsigned int *datalen, 503 unsigned int sdpoff, 504 const union nf_inet_addr *addr) 505 { 506 enum ip_conntrack_info ctinfo; 507 struct nf_conn *ct = nf_ct_get(skb, &ctinfo); 508 char buffer[INET6_ADDRSTRLEN]; 509 unsigned int buflen; 510 511 /* Mangle session description owner and contact addresses */ 512 buflen = sip_sprintf_addr(ct, buffer, addr, false); 513 if (mangle_sdp_packet(skb, protoff, dataoff, dptr, datalen, sdpoff, 514 SDP_HDR_OWNER, SDP_HDR_MEDIA, buffer, buflen)) 515 return 0; 516 517 switch (mangle_sdp_packet(skb, protoff, dataoff, dptr, datalen, sdpoff, 518 SDP_HDR_CONNECTION, SDP_HDR_MEDIA, 519 buffer, buflen)) { 520 case 0: 521 /* 522 * RFC 2327: 523 * 524 * Session description 525 * 526 * c=* (connection information - not required if included in all media) 527 */ 528 case -ENOENT: 529 break; 530 default: 531 return 0; 532 } 533 534 return mangle_content_len(skb, protoff, dataoff, dptr, datalen); 535 } 536 537 /* So, this packet has hit the connection tracking matching code. 538 Mangle it, and change the expectation to match the new version. */ 539 static unsigned int nf_nat_sdp_media(struct sk_buff *skb, unsigned int protoff, 540 unsigned int dataoff, 541 const char **dptr, unsigned int *datalen, 542 struct nf_conntrack_expect *rtp_exp, 543 struct nf_conntrack_expect *rtcp_exp, 544 unsigned int mediaoff, 545 unsigned int medialen, 546 union nf_inet_addr *rtp_addr) 547 { 548 enum ip_conntrack_info ctinfo; 549 struct nf_conn *ct = nf_ct_get(skb, &ctinfo); 550 enum ip_conntrack_dir dir = CTINFO2DIR(ctinfo); 551 u_int16_t port; 552 553 /* Connection will come from reply */ 554 if (nf_inet_addr_cmp(&ct->tuplehash[dir].tuple.src.u3, 555 &ct->tuplehash[!dir].tuple.dst.u3)) 556 *rtp_addr = rtp_exp->tuple.dst.u3; 557 else 558 *rtp_addr = ct->tuplehash[!dir].tuple.dst.u3; 559 560 rtp_exp->saved_addr = rtp_exp->tuple.dst.u3; 561 rtp_exp->tuple.dst.u3 = *rtp_addr; 562 rtp_exp->saved_proto.udp.port = rtp_exp->tuple.dst.u.udp.port; 563 rtp_exp->dir = !dir; 564 rtp_exp->expectfn = nf_nat_sip_expected; 565 566 rtcp_exp->saved_addr = rtcp_exp->tuple.dst.u3; 567 rtcp_exp->tuple.dst.u3 = *rtp_addr; 568 rtcp_exp->saved_proto.udp.port = rtcp_exp->tuple.dst.u.udp.port; 569 rtcp_exp->dir = !dir; 570 rtcp_exp->expectfn = nf_nat_sip_expected; 571 572 /* Try to get same pair of ports: if not, try to change them. */ 573 for (port = ntohs(rtp_exp->tuple.dst.u.udp.port); 574 port != 0; port += 2) { 575 int ret; 576 577 rtp_exp->tuple.dst.u.udp.port = htons(port); 578 ret = nf_ct_expect_related(rtp_exp); 579 if (ret == -EBUSY) 580 continue; 581 else if (ret < 0) { 582 port = 0; 583 break; 584 } 585 rtcp_exp->tuple.dst.u.udp.port = htons(port + 1); 586 ret = nf_ct_expect_related(rtcp_exp); 587 if (ret == 0) 588 break; 589 else if (ret == -EBUSY) { 590 nf_ct_unexpect_related(rtp_exp); 591 continue; 592 } else if (ret < 0) { 593 nf_ct_unexpect_related(rtp_exp); 594 port = 0; 595 break; 596 } 597 } 598 599 if (port == 0) { 600 nf_ct_helper_log(skb, ct, "all ports in use for SDP media"); 601 goto err1; 602 } 603 604 /* Update media port. */ 605 if (rtp_exp->tuple.dst.u.udp.port != rtp_exp->saved_proto.udp.port && 606 !nf_nat_sdp_port(skb, protoff, dataoff, dptr, datalen, 607 mediaoff, medialen, port)) { 608 nf_ct_helper_log(skb, ct, "cannot mangle SDP message"); 609 goto err2; 610 } 611 612 return NF_ACCEPT; 613 614 err2: 615 nf_ct_unexpect_related(rtp_exp); 616 nf_ct_unexpect_related(rtcp_exp); 617 err1: 618 return NF_DROP; 619 } 620 621 static struct nf_ct_helper_expectfn sip_nat = { 622 .name = "sip", 623 .expectfn = nf_nat_sip_expected, 624 }; 625 626 static void __exit nf_nat_sip_fini(void) 627 { 628 RCU_INIT_POINTER(nf_nat_sip_hooks, NULL); 629 630 nf_ct_helper_expectfn_unregister(&sip_nat); 631 synchronize_rcu(); 632 } 633 634 static const struct nf_nat_sip_hooks sip_hooks = { 635 .msg = nf_nat_sip, 636 .seq_adjust = nf_nat_sip_seq_adjust, 637 .expect = nf_nat_sip_expect, 638 .sdp_addr = nf_nat_sdp_addr, 639 .sdp_port = nf_nat_sdp_port, 640 .sdp_session = nf_nat_sdp_session, 641 .sdp_media = nf_nat_sdp_media, 642 }; 643 644 static int __init nf_nat_sip_init(void) 645 { 646 BUG_ON(nf_nat_sip_hooks != NULL); 647 RCU_INIT_POINTER(nf_nat_sip_hooks, &sip_hooks); 648 nf_ct_helper_expectfn_register(&sip_nat); 649 return 0; 650 } 651 652 module_init(nf_nat_sip_init); 653 module_exit(nf_nat_sip_fini); 654