1 /*- 2 * alias_smedia.c 3 * 4 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD AND BSD-2-Clause 5 * 6 * Copyright (c) 2000 Whistle Communications, Inc. 7 * All rights reserved. 8 * 9 * Subject to the following obligations and disclaimer of warranty, use and 10 * redistribution of this software, in source or object code forms, with or 11 * without modifications are expressly permitted by Whistle Communications; 12 * provided, however, that: 13 * 1. Any and all reproductions of the source or object code must include the 14 * copyright notice above and the following disclaimer of warranties; and 15 * 2. No rights are granted, in any manner or form, to use Whistle 16 * Communications, Inc. trademarks, including the mark "WHISTLE 17 * COMMUNICATIONS" on advertising, endorsements, or otherwise except as 18 * such appears in the above copyright notice or in the software. 19 * 20 * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND 21 * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO 22 * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE, 23 * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF 24 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. 25 * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY 26 * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS 27 * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE. 28 * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES 29 * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING 30 * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, 31 * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR 32 * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY 33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 35 * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY 36 * OF SUCH DAMAGE. 37 * 38 * Copyright (c) 2000 Junichi SATOH <junichi@astec.co.jp> 39 * <junichi@junichi.org> 40 * All rights reserved. 41 * 42 * Redistribution and use in source and binary forms, with or without 43 * modification, are permitted provided that the following conditions 44 * are met: 45 * 1. Redistributions of source code must retain the above copyright 46 * notice, this list of conditions and the following disclaimer. 47 * 2. Redistributions in binary form must reproduce the above copyright 48 * notice, this list of conditions and the following disclaimer in the 49 * documentation and/or other materials provided with the distribution. 50 * 51 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 52 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 53 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 54 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 55 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 56 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 57 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 58 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 59 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 60 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 61 * SUCH DAMAGE. 62 * 63 * Authors: Erik Salander <erik@whistle.com> 64 * Junichi SATOH <junichi@astec.co.jp> 65 * <junichi@junichi.org> 66 */ 67 68 #include <sys/cdefs.h> 69 __FBSDID("$FreeBSD$"); 70 71 /* 72 Alias_smedia.c is meant to contain the aliasing code for streaming media 73 protocols. It performs special processing for RSTP sessions under TCP. 74 Specifically, when a SETUP request is sent by a client, or a 200 reply 75 is sent by a server, it is intercepted and modified. The address is 76 changed to the gateway machine and an aliasing port is used. 77 78 More specifically, the "client_port" configuration parameter is 79 parsed for SETUP requests. The "server_port" configuration parameter is 80 parsed for 200 replies eminating from a server. This is intended to handle 81 the unicast case. 82 83 RTSP also allows a redirection of a stream to another client by using the 84 "destination" configuration parameter. The destination config parm would 85 indicate a different IP address. This function is NOT supported by the 86 RTSP translation code below. 87 88 The RTSP multicast functions without any address translation intervention. 89 90 For this routine to work, the SETUP/200 must fit entirely 91 into a single TCP packet. This is typically the case, but exceptions 92 can easily be envisioned under the actual specifications. 93 94 Probably the most troubling aspect of the approach taken here is 95 that the new SETUP/200 will typically be a different length, and 96 this causes a certain amount of bookkeeping to keep track of the 97 changes of sequence and acknowledgment numbers, since the client 98 machine is totally unaware of the modification to the TCP stream. 99 100 Initial version: May, 2000 (eds) 101 */ 102 103 #ifdef _KERNEL 104 #include <sys/param.h> 105 #include <sys/systm.h> 106 #include <sys/kernel.h> 107 #include <sys/module.h> 108 #else 109 #include <errno.h> 110 #include <sys/types.h> 111 #include <stdio.h> 112 #include <string.h> 113 #endif 114 115 #include <netinet/in_systm.h> 116 #include <netinet/in.h> 117 #include <netinet/ip.h> 118 #include <netinet/tcp.h> 119 120 #ifdef _KERNEL 121 #include <netinet/libalias/alias.h> 122 #include <netinet/libalias/alias_local.h> 123 #include <netinet/libalias/alias_mod.h> 124 #else 125 #include "alias_local.h" 126 #include "alias_mod.h" 127 #endif 128 129 #define RTSP_CONTROL_PORT_NUMBER_1 554 130 #define RTSP_CONTROL_PORT_NUMBER_2 7070 131 #define TFTP_PORT_NUMBER 69 132 133 static void 134 AliasHandleRtspOut(struct libalias *, struct ip *, struct alias_link *, 135 int maxpacketsize); 136 static int 137 fingerprint(struct libalias *la, struct alias_data *ah) 138 { 139 140 if (ah->dport != NULL && ah->aport != NULL && ah->sport != NULL && 141 ntohs(*ah->dport) == TFTP_PORT_NUMBER) 142 return (0); 143 if (ah->dport == NULL || ah->sport == NULL || ah->lnk == NULL || 144 ah->maxpktsize == 0) 145 return (-1); 146 if (ntohs(*ah->dport) == RTSP_CONTROL_PORT_NUMBER_1 147 || ntohs(*ah->sport) == RTSP_CONTROL_PORT_NUMBER_1 148 || ntohs(*ah->dport) == RTSP_CONTROL_PORT_NUMBER_2 149 || ntohs(*ah->sport) == RTSP_CONTROL_PORT_NUMBER_2) 150 return (0); 151 return (-1); 152 } 153 154 static int 155 protohandler(struct libalias *la, struct ip *pip, struct alias_data *ah) 156 { 157 158 if (ntohs(*ah->dport) == TFTP_PORT_NUMBER) 159 FindRtspOut(la, pip->ip_src, pip->ip_dst, 160 *ah->sport, *ah->aport, IPPROTO_UDP); 161 else AliasHandleRtspOut(la, pip, ah->lnk, ah->maxpktsize); 162 return (0); 163 } 164 165 struct proto_handler handlers[] = { 166 { 167 .pri = 100, 168 .dir = OUT, 169 .proto = TCP|UDP, 170 .fingerprint = &fingerprint, 171 .protohandler = &protohandler 172 }, 173 { EOH } 174 }; 175 176 static int 177 mod_handler(module_t mod, int type, void *data) 178 { 179 int error; 180 181 switch (type) { 182 case MOD_LOAD: 183 error = 0; 184 LibAliasAttachHandlers(handlers); 185 break; 186 case MOD_UNLOAD: 187 error = 0; 188 LibAliasDetachHandlers(handlers); 189 break; 190 default: 191 error = EINVAL; 192 } 193 return (error); 194 } 195 196 #ifdef _KERNEL 197 static 198 #endif 199 moduledata_t alias_mod = { 200 "alias_smedia", mod_handler, NULL 201 }; 202 203 #ifdef _KERNEL 204 DECLARE_MODULE(alias_smedia, alias_mod, SI_SUB_DRIVERS, SI_ORDER_SECOND); 205 MODULE_VERSION(alias_smedia, 1); 206 MODULE_DEPEND(alias_smedia, libalias, 1, 1, 1); 207 #endif 208 209 #define RTSP_CONTROL_PORT_NUMBER_1 554 210 #define RTSP_CONTROL_PORT_NUMBER_2 7070 211 #define RTSP_PORT_GROUP 2 212 213 #define ISDIGIT(a) (((a) >= '0') && ((a) <= '9')) 214 215 static int 216 search_string(char *data, int dlen, const char *search_str) 217 { 218 int i, j, k; 219 int search_str_len; 220 221 search_str_len = strlen(search_str); 222 for (i = 0; i < dlen - search_str_len; i++) { 223 for (j = i, k = 0; j < dlen - search_str_len; j++, k++) { 224 if (data[j] != search_str[k] && 225 data[j] != search_str[k] - ('a' - 'A')) { 226 break; 227 } 228 if (k == search_str_len - 1) { 229 return (j + 1); 230 } 231 } 232 } 233 return (-1); 234 } 235 236 static int 237 alias_rtsp_out(struct libalias *la, struct ip *pip, 238 struct alias_link *lnk, 239 char *data, 240 const char *port_str) 241 { 242 int hlen, tlen, dlen; 243 struct tcphdr *tc; 244 int i, j, pos, state, port_dlen, new_dlen, delta; 245 u_short p[2], new_len; 246 u_short sport, eport, base_port; 247 u_short salias = 0, ealias = 0, base_alias = 0; 248 const char *transport_str = "transport:"; 249 char newdata[2048], *port_data, *port_newdata, stemp[80]; 250 int links_created = 0, pkt_updated = 0; 251 struct alias_link *rtsp_lnk = NULL; 252 struct in_addr null_addr; 253 254 /* Calculate data length of TCP packet */ 255 tc = (struct tcphdr *)ip_next(pip); 256 hlen = (pip->ip_hl + tc->th_off) << 2; 257 tlen = ntohs(pip->ip_len); 258 dlen = tlen - hlen; 259 260 /* Find keyword, "Transport: " */ 261 pos = search_string(data, dlen, transport_str); 262 if (pos < 0) { 263 return (-1); 264 } 265 port_data = data + pos; 266 port_dlen = dlen - pos; 267 268 memcpy(newdata, data, pos); 269 port_newdata = newdata + pos; 270 271 while (port_dlen > (int)strlen(port_str)) { 272 /* Find keyword, appropriate port string */ 273 pos = search_string(port_data, port_dlen, port_str); 274 if (pos < 0) { 275 break; 276 } 277 memcpy(port_newdata, port_data, pos + 1); 278 port_newdata += (pos + 1); 279 280 p[0] = p[1] = 0; 281 sport = eport = 0; 282 state = 0; 283 for (i = pos; i < port_dlen; i++) { 284 switch (state) { 285 case 0: 286 if (port_data[i] == '=') { 287 state++; 288 } 289 break; 290 case 1: 291 if (ISDIGIT(port_data[i])) { 292 p[0] = p[0] * 10 + port_data[i] - '0'; 293 } else { 294 if (port_data[i] == ';') { 295 state = 3; 296 } 297 if (port_data[i] == '-') { 298 state++; 299 } 300 } 301 break; 302 case 2: 303 if (ISDIGIT(port_data[i])) { 304 p[1] = p[1] * 10 + port_data[i] - '0'; 305 } else { 306 state++; 307 } 308 break; 309 case 3: 310 base_port = p[0]; 311 sport = htons(p[0]); 312 eport = htons(p[1]); 313 314 if (!links_created) { 315 links_created = 1; 316 /* 317 * Find an even numbered port 318 * number base that satisfies the 319 * contiguous number of ports we 320 * need 321 */ 322 null_addr.s_addr = 0; 323 if (0 == (salias = FindNewPortGroup(la, null_addr, 324 FindAliasAddress(la, pip->ip_src), 325 sport, 0, 326 RTSP_PORT_GROUP, 327 IPPROTO_UDP, 1))) { 328 #ifdef LIBALIAS_DEBUG 329 fprintf(stderr, 330 "PacketAlias/RTSP: Cannot find contiguous RTSP data ports\n"); 331 #endif 332 } else { 333 base_alias = ntohs(salias); 334 for (j = 0; j < RTSP_PORT_GROUP; j++) { 335 /* 336 * Establish link 337 * to port found in 338 * RTSP packet 339 */ 340 rtsp_lnk = FindRtspOut(la, GetOriginalAddress(lnk), null_addr, 341 htons(base_port + j), htons(base_alias + j), 342 IPPROTO_UDP); 343 if (rtsp_lnk != NULL) { 344 #ifndef NO_FW_PUNCH 345 /* 346 * Punch 347 * hole in 348 * firewall 349 */ 350 PunchFWHole(rtsp_lnk); 351 #endif 352 } else { 353 #ifdef LIBALIAS_DEBUG 354 fprintf(stderr, 355 "PacketAlias/RTSP: Cannot allocate RTSP data ports\n"); 356 #endif 357 break; 358 } 359 } 360 } 361 ealias = htons(base_alias + (RTSP_PORT_GROUP - 1)); 362 } 363 if (salias && rtsp_lnk) { 364 pkt_updated = 1; 365 366 /* Copy into IP packet */ 367 sprintf(stemp, "%d", ntohs(salias)); 368 memcpy(port_newdata, stemp, strlen(stemp)); 369 port_newdata += strlen(stemp); 370 371 if (eport != 0) { 372 *port_newdata = '-'; 373 port_newdata++; 374 375 /* Copy into IP packet */ 376 sprintf(stemp, "%d", ntohs(ealias)); 377 memcpy(port_newdata, stemp, strlen(stemp)); 378 port_newdata += strlen(stemp); 379 } 380 *port_newdata = ';'; 381 port_newdata++; 382 } 383 state++; 384 break; 385 } 386 if (state > 3) { 387 break; 388 } 389 } 390 port_data += i; 391 port_dlen -= i; 392 } 393 394 if (!pkt_updated) 395 return (-1); 396 397 memcpy(port_newdata, port_data, port_dlen); 398 port_newdata += port_dlen; 399 *port_newdata = '\0'; 400 401 /* Create new packet */ 402 new_dlen = port_newdata - newdata; 403 memcpy(data, newdata, new_dlen); 404 405 SetAckModified(lnk); 406 tc = (struct tcphdr *)ip_next(pip); 407 delta = GetDeltaSeqOut(tc->th_seq, lnk); 408 AddSeq(lnk, delta + new_dlen - dlen, pip->ip_hl, pip->ip_len, 409 tc->th_seq, tc->th_off); 410 411 new_len = htons(hlen + new_dlen); 412 DifferentialChecksum(&pip->ip_sum, 413 &new_len, 414 &pip->ip_len, 415 1); 416 pip->ip_len = new_len; 417 418 tc->th_sum = 0; 419 #ifdef _KERNEL 420 tc->th_x2 = 1; 421 #else 422 tc->th_sum = TcpChecksum(pip); 423 #endif 424 return (0); 425 } 426 427 /* Support the protocol used by early versions of RealPlayer */ 428 429 static int 430 alias_pna_out(struct libalias *la, struct ip *pip, 431 struct alias_link *lnk, 432 char *data, 433 int dlen) 434 { 435 struct alias_link *pna_links; 436 u_short msg_id, msg_len; 437 char *work; 438 u_short alias_port, port; 439 struct tcphdr *tc; 440 441 work = data; 442 work += 5; 443 while (work + 4 < data + dlen) { 444 memcpy(&msg_id, work, 2); 445 work += 2; 446 memcpy(&msg_len, work, 2); 447 work += 2; 448 if (ntohs(msg_id) == 0) { 449 /* end of options */ 450 return (0); 451 } 452 if ((ntohs(msg_id) == 1) || (ntohs(msg_id) == 7)) { 453 memcpy(&port, work, 2); 454 pna_links = FindUdpTcpOut(la, pip->ip_src, GetDestAddress(lnk), 455 port, 0, IPPROTO_UDP, 1); 456 if (pna_links != NULL) { 457 #ifndef NO_FW_PUNCH 458 /* Punch hole in firewall */ 459 PunchFWHole(pna_links); 460 #endif 461 tc = (struct tcphdr *)ip_next(pip); 462 alias_port = GetAliasPort(pna_links); 463 memcpy(work, &alias_port, 2); 464 465 /* Compute TCP checksum for revised packet */ 466 tc->th_sum = 0; 467 #ifdef _KERNEL 468 tc->th_x2 = 1; 469 #else 470 tc->th_sum = TcpChecksum(pip); 471 #endif 472 } 473 } 474 work += ntohs(msg_len); 475 } 476 477 return (0); 478 } 479 480 static void 481 AliasHandleRtspOut(struct libalias *la, struct ip *pip, struct alias_link *lnk, int maxpacketsize) 482 { 483 int hlen, tlen, dlen; 484 struct tcphdr *tc; 485 char *data; 486 const char *setup = "SETUP", *pna = "PNA", *str200 = "200"; 487 const char *okstr = "OK", *client_port_str = "client_port"; 488 const char *server_port_str = "server_port"; 489 int i, parseOk; 490 491 (void)maxpacketsize; 492 493 tc = (struct tcphdr *)ip_next(pip); 494 hlen = (pip->ip_hl + tc->th_off) << 2; 495 tlen = ntohs(pip->ip_len); 496 dlen = tlen - hlen; 497 498 data = (char *)pip; 499 data += hlen; 500 501 /* When aliasing a client, check for the SETUP request */ 502 if ((ntohs(tc->th_dport) == RTSP_CONTROL_PORT_NUMBER_1) || 503 (ntohs(tc->th_dport) == RTSP_CONTROL_PORT_NUMBER_2)) { 504 if (dlen >= (int)strlen(setup)) { 505 if (memcmp(data, setup, strlen(setup)) == 0) { 506 alias_rtsp_out(la, pip, lnk, data, client_port_str); 507 return; 508 } 509 } 510 if (dlen >= (int)strlen(pna)) { 511 if (memcmp(data, pna, strlen(pna)) == 0) { 512 alias_pna_out(la, pip, lnk, data, dlen); 513 } 514 } 515 } else { 516 /* 517 * When aliasing a server, check for the 200 reply 518 * Accommodate varying number of blanks between 200 & OK 519 */ 520 521 if (dlen >= (int)strlen(str200)) { 522 for (parseOk = 0, i = 0; 523 i <= dlen - (int)strlen(str200); 524 i++) { 525 if (memcmp(&data[i], str200, strlen(str200)) == 0) { 526 parseOk = 1; 527 break; 528 } 529 } 530 if (parseOk) { 531 i += strlen(str200); /* skip string found */ 532 while (data[i] == ' ') /* skip blank(s) */ 533 i++; 534 535 if ((dlen - i) >= (int)strlen(okstr)) { 536 if (memcmp(&data[i], okstr, strlen(okstr)) == 0) 537 alias_rtsp_out(la, pip, lnk, data, server_port_str); 538 } 539 } 540 } 541 } 542 } 543