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 <[email protected]>
39 * <[email protected]>
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 <[email protected]>
64 * Junichi SATOH <[email protected]>
65 * <[email protected]>
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
fingerprint(struct libalias * la,struct alias_data * ah)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
protohandler(struct libalias * la,struct ip * pip,struct alias_data * ah)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
mod_handler(module_t mod,int type,void * data)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
search_string(char * data,int dlen,const char * search_str)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
alias_rtsp_out(struct libalias * la,struct ip * pip,struct alias_link * lnk,char * data,const char * port_str)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
316 links_created = 1;
317 /*
318 * Find an even numbered port
319 * number base that satisfies the
320 * contiguous number of ports we
321 * need
322 */
323 null_addr.s_addr = 0;
324 if (0 == (salias = FindNewPortGroup(la, null_addr,
325 FindAliasAddress(la, pip->ip_src),
326 sport, 0,
327 RTSP_PORT_GROUP,
328 IPPROTO_UDP, 1))) {
329 #ifdef LIBALIAS_DEBUG
330 fprintf(stderr,
331 "PacketAlias/RTSP: Cannot find contiguous RTSP data ports\n");
332 #endif
333 } else {
334
335 base_alias = ntohs(salias);
336 for (j = 0; j < RTSP_PORT_GROUP; j++) {
337 /*
338 * Establish link
339 * to port found in
340 * RTSP packet
341 */
342 rtsp_lnk = FindRtspOut(la, GetOriginalAddress(lnk), null_addr,
343 htons(base_port + j), htons(base_alias + j),
344 IPPROTO_UDP);
345 if (rtsp_lnk != NULL) {
346 #ifndef NO_FW_PUNCH
347 /*
348 * Punch
349 * hole in
350 * firewall
351 */
352 PunchFWHole(rtsp_lnk);
353 #endif
354 } else {
355 #ifdef LIBALIAS_DEBUG
356 fprintf(stderr,
357 "PacketAlias/RTSP: Cannot allocate RTSP data ports\n");
358 #endif
359 break;
360 }
361 }
362 }
363 ealias = htons(base_alias + (RTSP_PORT_GROUP - 1));
364 }
365 if (salias && rtsp_lnk) {
366
367 pkt_updated = 1;
368
369 /* Copy into IP packet */
370 sprintf(stemp, "%d", ntohs(salias));
371 memcpy(port_newdata, stemp, strlen(stemp));
372 port_newdata += strlen(stemp);
373
374 if (eport != 0) {
375 *port_newdata = '-';
376 port_newdata++;
377
378 /* Copy into IP packet */
379 sprintf(stemp, "%d", ntohs(ealias));
380 memcpy(port_newdata, stemp, strlen(stemp));
381 port_newdata += strlen(stemp);
382 }
383 *port_newdata = ';';
384 port_newdata++;
385 }
386 state++;
387 break;
388 }
389 if (state > 3) {
390 break;
391 }
392 }
393 port_data += i;
394 port_dlen -= i;
395 }
396
397 if (!pkt_updated)
398 return (-1);
399
400 memcpy(port_newdata, port_data, port_dlen);
401 port_newdata += port_dlen;
402 *port_newdata = '\0';
403
404 /* Create new packet */
405 new_dlen = port_newdata - newdata;
406 memcpy(data, newdata, new_dlen);
407
408 SetAckModified(lnk);
409 tc = (struct tcphdr *)ip_next(pip);
410 delta = GetDeltaSeqOut(tc->th_seq, lnk);
411 AddSeq(lnk, delta + new_dlen - dlen, pip->ip_hl, pip->ip_len,
412 tc->th_seq, tc->th_off);
413
414 new_len = htons(hlen + new_dlen);
415 DifferentialChecksum(&pip->ip_sum,
416 &new_len,
417 &pip->ip_len,
418 1);
419 pip->ip_len = new_len;
420
421 tc->th_sum = 0;
422 #ifdef _KERNEL
423 tc->th_x2 = 1;
424 #else
425 tc->th_sum = TcpChecksum(pip);
426 #endif
427 return (0);
428 }
429
430 /* Support the protocol used by early versions of RealPlayer */
431
432 static int
alias_pna_out(struct libalias * la,struct ip * pip,struct alias_link * lnk,char * data,int dlen)433 alias_pna_out(struct libalias *la, struct ip *pip,
434 struct alias_link *lnk,
435 char *data,
436 int dlen)
437 {
438 struct alias_link *pna_links;
439 u_short msg_id, msg_len;
440 char *work;
441 u_short alias_port, port;
442 struct tcphdr *tc;
443
444 work = data;
445 work += 5;
446 while (work + 4 < data + dlen) {
447 memcpy(&msg_id, work, 2);
448 work += 2;
449 memcpy(&msg_len, work, 2);
450 work += 2;
451 if (ntohs(msg_id) == 0) {
452 /* end of options */
453 return (0);
454 }
455 if ((ntohs(msg_id) == 1) || (ntohs(msg_id) == 7)) {
456 memcpy(&port, work, 2);
457 pna_links = FindUdpTcpOut(la, pip->ip_src, GetDestAddress(lnk),
458 port, 0, IPPROTO_UDP, 1);
459 if (pna_links != NULL) {
460 #ifndef NO_FW_PUNCH
461 /* Punch hole in firewall */
462 PunchFWHole(pna_links);
463 #endif
464 tc = (struct tcphdr *)ip_next(pip);
465 alias_port = GetAliasPort(pna_links);
466 memcpy(work, &alias_port, 2);
467
468 /* Compute TCP checksum for revised packet */
469 tc->th_sum = 0;
470 #ifdef _KERNEL
471 tc->th_x2 = 1;
472 #else
473 tc->th_sum = TcpChecksum(pip);
474 #endif
475 }
476 }
477 work += ntohs(msg_len);
478 }
479
480 return (0);
481 }
482
483 static void
AliasHandleRtspOut(struct libalias * la,struct ip * pip,struct alias_link * lnk,int maxpacketsize)484 AliasHandleRtspOut(struct libalias *la, struct ip *pip, struct alias_link *lnk, int maxpacketsize)
485 {
486 int hlen, tlen, dlen;
487 struct tcphdr *tc;
488 char *data;
489 const char *setup = "SETUP", *pna = "PNA", *str200 = "200";
490 const char *okstr = "OK", *client_port_str = "client_port";
491 const char *server_port_str = "server_port";
492 int i, parseOk;
493
494 (void)maxpacketsize;
495
496 tc = (struct tcphdr *)ip_next(pip);
497 hlen = (pip->ip_hl + tc->th_off) << 2;
498 tlen = ntohs(pip->ip_len);
499 dlen = tlen - hlen;
500
501 data = (char *)pip;
502 data += hlen;
503
504 /* When aliasing a client, check for the SETUP request */
505 if ((ntohs(tc->th_dport) == RTSP_CONTROL_PORT_NUMBER_1) ||
506 (ntohs(tc->th_dport) == RTSP_CONTROL_PORT_NUMBER_2)) {
507
508 if (dlen >= (int)strlen(setup)) {
509 if (memcmp(data, setup, strlen(setup)) == 0) {
510 alias_rtsp_out(la, pip, lnk, data, client_port_str);
511 return;
512 }
513 }
514 if (dlen >= (int)strlen(pna)) {
515 if (memcmp(data, pna, strlen(pna)) == 0) {
516 alias_pna_out(la, pip, lnk, data, dlen);
517 }
518 }
519 } else {
520
521 /*
522 * When aliasing a server, check for the 200 reply
523 * Accommodate varying number of blanks between 200 & OK
524 */
525
526 if (dlen >= (int)strlen(str200)) {
527
528 for (parseOk = 0, i = 0;
529 i <= dlen - (int)strlen(str200);
530 i++) {
531 if (memcmp(&data[i], str200, strlen(str200)) == 0) {
532 parseOk = 1;
533 break;
534 }
535 }
536 if (parseOk) {
537
538 i += strlen(str200); /* skip string found */
539 while (data[i] == ' ') /* skip blank(s) */
540 i++;
541
542 if ((dlen - i) >= (int)strlen(okstr)) {
543
544 if (memcmp(&data[i], okstr, strlen(okstr)) == 0)
545 alias_rtsp_out(la, pip, lnk, data, server_port_str);
546
547 }
548 }
549 }
550 }
551 }
552