1 /* $FreeBSD: stable/9/sys/contrib/ipfilter/netinet/ip_proxy.c 172776 2007-10-18 21:52:14Z darrenr $ */
2
3 /*
4 * Copyright (C) 1997-2003 by Darren Reed.
5 *
6 * See the IPFILTER.LICENCE file for details on licencing.
7 */
8 #if defined(KERNEL) || defined(_KERNEL)
9 # undef KERNEL
10 # undef _KERNEL
11 # define KERNEL 1
12 # define _KERNEL 1
13 #endif
14 #include <sys/errno.h>
15 #include <sys/types.h>
16 #include <sys/param.h>
17 #include <sys/time.h>
18 #include <sys/file.h>
19 #if !defined(AIX)
20 # include <sys/fcntl.h>
21 #endif
22 #if !defined(_KERNEL) && !defined(__KERNEL__)
23 # include <stdio.h>
24 # include <string.h>
25 # include <stdlib.h>
26 # include <ctype.h>
27 # define _KERNEL
28 # ifdef __OpenBSD__
29 struct file;
30 # endif
31 # include <sys/uio.h>
32 # undef _KERNEL
33 #endif
34 #if !defined(linux)
35 # include <sys/protosw.h>
36 #endif
37 #include <sys/socket.h>
38 #if defined(_KERNEL)
39 # if !defined(__NetBSD__) && !defined(sun) && !defined(__osf__) && \
40 !defined(__OpenBSD__) && !defined(__hpux) && !defined(__sgi) && \
41 !defined(AIX)
42 # include <sys/ctype.h>
43 # endif
44 # include <sys/systm.h>
45 # if !defined(__SVR4) && !defined(__svr4__)
46 # include <sys/mbuf.h>
47 # endif
48 #endif
49 #if defined(_KERNEL) && (__FreeBSD_version >= 220000)
50 # include <sys/filio.h>
51 # include <sys/fcntl.h>
52 # if (__FreeBSD_version >= 300000) && !defined(IPFILTER_LKM)
53 # include "opt_ipfilter.h"
54 # endif
55 #else
56 # include <sys/ioctl.h>
57 #endif
58 #if defined(__SVR4) || defined(__svr4__)
59 # include <sys/byteorder.h>
60 # ifdef _KERNEL
61 # include <sys/dditypes.h>
62 # endif
63 # include <sys/stream.h>
64 # include <sys/kmem.h>
65 #endif
66 #if __FreeBSD__ > 2
67 # include <sys/queue.h>
68 #endif
69 #include <net/if.h>
70 #ifdef sun
71 # include <net/af.h>
72 #endif
73 #include <net/route.h>
74 #include <netinet/in.h>
75 #include <netinet/in_systm.h>
76 #include <netinet/ip.h>
77 #ifndef linux
78 # include <netinet/ip_var.h>
79 #endif
80 #include <netinet/tcp.h>
81 #include <netinet/udp.h>
82 #include <netinet/ip_icmp.h>
83 #include "netinet/ip_compat.h"
84 #include <netinet/tcpip.h>
85 #include "netinet/ip_fil.h"
86 #include "netinet/ip_nat.h"
87 #include "netinet/ip_state.h"
88 #include "netinet/ip_proxy.h"
89 #if (__FreeBSD_version >= 300000)
90 # include <sys/malloc.h>
91 #endif
92
93 #include "netinet/ip_ftp_pxy.c"
94 #include "netinet/ip_rcmd_pxy.c"
95 # include "netinet/ip_pptp_pxy.c"
96 #if defined(_KERNEL)
97 # include "netinet/ip_irc_pxy.c"
98 # include "netinet/ip_raudio_pxy.c"
99 # include "netinet/ip_netbios_pxy.c"
100 #endif
101 #include "netinet/ip_ipsec_pxy.c"
102 #include "netinet/ip_rpcb_pxy.c"
103
104 /* END OF INCLUDES */
105
106 #if !defined(lint)
107 static const char rcsid[] = "@(#)$Id: ip_proxy.c,v 2.62.2.21 2007/06/02 21:22:28 darrenr Exp $";
108 #endif
109
110 static int appr_fixseqack __P((fr_info_t *, ip_t *, ap_session_t *, int ));
111
112 #define AP_SESS_SIZE 53
113
114 #if defined(_KERNEL)
115 int ipf_proxy_debug = 0;
116 #else
117 int ipf_proxy_debug = 2;
118 #endif
119 ap_session_t *ap_sess_tab[AP_SESS_SIZE];
120 ap_session_t *ap_sess_list = NULL;
121 aproxy_t *ap_proxylist = NULL;
122 aproxy_t ap_proxies[] = {
123 #ifdef IPF_FTP_PROXY
124 { NULL, "ftp", (char)IPPROTO_TCP, 0, 0, ippr_ftp_init, ippr_ftp_fini,
125 ippr_ftp_new, NULL, ippr_ftp_in, ippr_ftp_out, NULL, NULL },
126 #endif
127 #ifdef IPF_IRC_PROXY
128 { NULL, "irc", (char)IPPROTO_TCP, 0, 0, ippr_irc_init, ippr_irc_fini,
129 ippr_irc_new, NULL, NULL, ippr_irc_out, NULL, NULL },
130 #endif
131 #ifdef IPF_RCMD_PROXY
132 { NULL, "rcmd", (char)IPPROTO_TCP, 0, 0, ippr_rcmd_init, ippr_rcmd_fini,
133 ippr_rcmd_new, NULL, ippr_rcmd_in, ippr_rcmd_out, NULL, NULL },
134 #endif
135 #ifdef IPF_RAUDIO_PROXY
136 { NULL, "raudio", (char)IPPROTO_TCP, 0, 0, ippr_raudio_init, ippr_raudio_fini,
137 ippr_raudio_new, NULL, ippr_raudio_in, ippr_raudio_out, NULL, NULL },
138 #endif
139 #ifdef IPF_MSNRPC_PROXY
140 { NULL, "msnrpc", (char)IPPROTO_TCP, 0, 0, ippr_msnrpc_init, ippr_msnrpc_fini,
141 ippr_msnrpc_new, NULL, ippr_msnrpc_in, ippr_msnrpc_out, NULL, NULL },
142 #endif
143 #ifdef IPF_NETBIOS_PROXY
144 { NULL, "netbios", (char)IPPROTO_UDP, 0, 0, ippr_netbios_init, ippr_netbios_fini,
145 NULL, NULL, NULL, ippr_netbios_out, NULL, NULL },
146 #endif
147 #ifdef IPF_IPSEC_PROXY
148 { NULL, "ipsec", (char)IPPROTO_UDP, 0, 0,
149 ippr_ipsec_init, ippr_ipsec_fini, ippr_ipsec_new, ippr_ipsec_del,
150 ippr_ipsec_inout, ippr_ipsec_inout, ippr_ipsec_match, NULL },
151 #endif
152 #ifdef IPF_PPTP_PROXY
153 { NULL, "pptp", (char)IPPROTO_TCP, 0, 0,
154 ippr_pptp_init, ippr_pptp_fini, ippr_pptp_new, ippr_pptp_del,
155 ippr_pptp_inout, ippr_pptp_inout, NULL, NULL },
156 #endif
157 #ifdef IPF_H323_PROXY
158 { NULL, "h323", (char)IPPROTO_TCP, 0, 0, ippr_h323_init, ippr_h323_fini,
159 ippr_h323_new, ippr_h323_del, ippr_h323_in, NULL, NULL, NULL },
160 { NULL, "h245", (char)IPPROTO_TCP, 0, 0, NULL, NULL,
161 ippr_h245_new, NULL, NULL, ippr_h245_out, NULL, NULL },
162 #endif
163 #ifdef IPF_RPCB_PROXY
164 # if 0
165 { NULL, "rpcbt", (char)IPPROTO_TCP, 0, 0,
166 ippr_rpcb_init, ippr_rpcb_fini, ippr_rpcb_new, ippr_rpcb_del,
167 ippr_rpcb_in, ippr_rpcb_out, NULL, NULL },
168 # endif
169 { NULL, "rpcbu", (char)IPPROTO_UDP, 0, 0,
170 ippr_rpcb_init, ippr_rpcb_fini, ippr_rpcb_new, ippr_rpcb_del,
171 ippr_rpcb_in, ippr_rpcb_out, NULL, NULL },
172 #endif
173 { NULL, "", '\0', 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
174 };
175
176 /*
177 * Dynamically add a new kernel proxy. Ensure that it is unique in the
178 * collection compiled in and dynamically added.
179 */
appr_add(ap)180 int appr_add(ap)
181 aproxy_t *ap;
182 {
183 aproxy_t *a;
184
185 for (a = ap_proxies; a->apr_p; a++)
186 if ((a->apr_p == ap->apr_p) &&
187 !strncmp(a->apr_label, ap->apr_label,
188 sizeof(ap->apr_label))) {
189 if (ipf_proxy_debug > 1)
190 printf("appr_add: %s/%d already present (B)\n",
191 a->apr_label, a->apr_p);
192 return -1;
193 }
194
195 for (a = ap_proxylist; (a != NULL); a = a->apr_next)
196 if ((a->apr_p == ap->apr_p) &&
197 !strncmp(a->apr_label, ap->apr_label,
198 sizeof(ap->apr_label))) {
199 if (ipf_proxy_debug > 1)
200 printf("appr_add: %s/%d already present (D)\n",
201 a->apr_label, a->apr_p);
202 return -1;
203 }
204 ap->apr_next = ap_proxylist;
205 ap_proxylist = ap;
206 if (ap->apr_init != NULL)
207 return (*ap->apr_init)();
208 return 0;
209 }
210
211
212 /*
213 * Check to see if the proxy this control request has come through for
214 * exists, and if it does and it has a control function then invoke that
215 * control function.
216 */
appr_ctl(ctl)217 int appr_ctl(ctl)
218 ap_ctl_t *ctl;
219 {
220 aproxy_t *a;
221 int error;
222
223 a = appr_lookup(ctl->apc_p, ctl->apc_label);
224 if (a == NULL) {
225 if (ipf_proxy_debug > 1)
226 printf("appr_ctl: can't find %s/%d\n",
227 ctl->apc_label, ctl->apc_p);
228 error = ESRCH;
229 } else if (a->apr_ctl == NULL) {
230 if (ipf_proxy_debug > 1)
231 printf("appr_ctl: no ctl function for %s/%d\n",
232 ctl->apc_label, ctl->apc_p);
233 error = ENXIO;
234 } else {
235 error = (*a->apr_ctl)(a, ctl);
236 if ((error != 0) && (ipf_proxy_debug > 1))
237 printf("appr_ctl: %s/%d ctl error %d\n",
238 a->apr_label, a->apr_p, error);
239 }
240 return error;
241 }
242
243
244 /*
245 * Delete a proxy that has been added dynamically from those available.
246 * If it is in use, return 1 (do not destroy NOW), not in use 0 or -1
247 * if it cannot be matched.
248 */
appr_del(ap)249 int appr_del(ap)
250 aproxy_t *ap;
251 {
252 aproxy_t *a, **app;
253
254 for (app = &ap_proxylist; ((a = *app) != NULL); app = &a->apr_next)
255 if (a == ap) {
256 a->apr_flags |= APR_DELETE;
257 *app = a->apr_next;
258 if (ap->apr_ref != 0) {
259 if (ipf_proxy_debug > 2)
260 printf("appr_del: orphaning %s/%d\n",
261 ap->apr_label, ap->apr_p);
262 return 1;
263 }
264 return 0;
265 }
266 if (ipf_proxy_debug > 1)
267 printf("appr_del: proxy %lx not found\n", (u_long)ap);
268 return -1;
269 }
270
271
272 /*
273 * Return 1 if the packet is a good match against a proxy, else 0.
274 */
appr_ok(fin,tcp,nat)275 int appr_ok(fin, tcp, nat)
276 fr_info_t *fin;
277 tcphdr_t *tcp;
278 ipnat_t *nat;
279 {
280 aproxy_t *apr = nat->in_apr;
281 u_short dport = nat->in_dport;
282
283 if ((apr == NULL) || (apr->apr_flags & APR_DELETE) ||
284 (fin->fin_p != apr->apr_p))
285 return 0;
286 if ((tcp == NULL) && dport)
287 return 0;
288 return 1;
289 }
290
291
appr_ioctl(data,cmd,mode,ctx)292 int appr_ioctl(data, cmd, mode, ctx)
293 caddr_t data;
294 ioctlcmd_t cmd;
295 int mode;
296 void *ctx;
297 {
298 ap_ctl_t ctl;
299 u_char *ptr;
300 int error;
301
302 mode = mode; /* LINT */
303
304 switch (cmd)
305 {
306 case SIOCPROXY :
307 error = BCOPYIN(data, &ctl, sizeof(ctl));
308 if (error != 0)
309 return EFAULT;
310 ptr = NULL;
311
312 if (ctl.apc_dsize > 0) {
313 KMALLOCS(ptr, u_char *, ctl.apc_dsize);
314 if (ptr == NULL)
315 error = ENOMEM;
316 else {
317 error = copyinptr(ctl.apc_data, ptr,
318 ctl.apc_dsize);
319 if (error == 0)
320 ctl.apc_data = ptr;
321 }
322 } else {
323 ctl.apc_data = NULL;
324 error = 0;
325 }
326
327 if (error == 0)
328 error = appr_ctl(&ctl);
329
330 if (ptr != NULL) {
331 KFREES(ptr, ctl.apc_dsize);
332 }
333 break;
334
335 default :
336 error = EINVAL;
337 }
338 return error;
339 }
340
341
342 /*
343 * If a proxy has a match function, call that to do extended packet
344 * matching.
345 */
appr_match(fin,nat)346 int appr_match(fin, nat)
347 fr_info_t *fin;
348 nat_t *nat;
349 {
350 aproxy_t *apr;
351 ipnat_t *ipn;
352 int result;
353
354 ipn = nat->nat_ptr;
355 if (ipf_proxy_debug > 8)
356 printf("appr_match(%lx,%lx) aps %lx ptr %lx\n",
357 (u_long)fin, (u_long)nat, (u_long)nat->nat_aps,
358 (u_long)ipn);
359
360 if ((fin->fin_flx & (FI_SHORT|FI_BAD)) != 0) {
361 if (ipf_proxy_debug > 0)
362 printf("appr_match: flx 0x%x (BAD|SHORT)\n",
363 fin->fin_flx);
364 return -1;
365 }
366
367 apr = ipn->in_apr;
368 if ((apr == NULL) || (apr->apr_flags & APR_DELETE)) {
369 if (ipf_proxy_debug > 0)
370 printf("appr_match:apr %lx apr_flags 0x%x\n",
371 (u_long)apr, apr ? apr->apr_flags : 0);
372 return -1;
373 }
374
375 if (apr->apr_match != NULL) {
376 result = (*apr->apr_match)(fin, nat->nat_aps, nat);
377 if (result != 0) {
378 if (ipf_proxy_debug > 4)
379 printf("appr_match: result %d\n", result);
380 return -1;
381 }
382 }
383 return 0;
384 }
385
386
387 /*
388 * Allocate a new application proxy structure and fill it in with the
389 * relevant details. call the init function once complete, prior to
390 * returning.
391 */
appr_new(fin,nat)392 int appr_new(fin, nat)
393 fr_info_t *fin;
394 nat_t *nat;
395 {
396 register ap_session_t *aps;
397 aproxy_t *apr;
398
399 if (ipf_proxy_debug > 8)
400 printf("appr_new(%lx,%lx) \n", (u_long)fin, (u_long)nat);
401
402 if ((nat->nat_ptr == NULL) || (nat->nat_aps != NULL)) {
403 if (ipf_proxy_debug > 0)
404 printf("appr_new: nat_ptr %lx nat_aps %lx\n",
405 (u_long)nat->nat_ptr, (u_long)nat->nat_aps);
406 return -1;
407 }
408
409 apr = nat->nat_ptr->in_apr;
410
411 if ((apr->apr_flags & APR_DELETE) ||
412 (fin->fin_p != apr->apr_p)) {
413 if (ipf_proxy_debug > 2)
414 printf("appr_new: apr_flags 0x%x p %d/%d\n",
415 apr->apr_flags, fin->fin_p, apr->apr_p);
416 return -1;
417 }
418
419 KMALLOC(aps, ap_session_t *);
420 if (!aps) {
421 if (ipf_proxy_debug > 0)
422 printf("appr_new: malloc failed (%lu)\n",
423 (u_long)sizeof(ap_session_t));
424 return -1;
425 }
426
427 bzero((char *)aps, sizeof(*aps));
428 aps->aps_p = fin->fin_p;
429 aps->aps_data = NULL;
430 aps->aps_apr = apr;
431 aps->aps_psiz = 0;
432 if (apr->apr_new != NULL)
433 if ((*apr->apr_new)(fin, aps, nat) == -1) {
434 if ((aps->aps_data != NULL) && (aps->aps_psiz != 0)) {
435 KFREES(aps->aps_data, aps->aps_psiz);
436 }
437 KFREE(aps);
438 if (ipf_proxy_debug > 2)
439 printf("appr_new: new(%lx) failed\n",
440 (u_long)apr->apr_new);
441 return -1;
442 }
443 aps->aps_nat = nat;
444 aps->aps_next = ap_sess_list;
445 ap_sess_list = aps;
446 nat->nat_aps = aps;
447
448 return 0;
449 }
450
451
452 /*
453 * Check to see if a packet should be passed through an active proxy routine
454 * if one has been setup for it. We don't need to check the checksum here if
455 * IPFILTER_CKSUM is defined because if it is, a failed check causes FI_BAD
456 * to be set.
457 */
appr_check(fin,nat)458 int appr_check(fin, nat)
459 fr_info_t *fin;
460 nat_t *nat;
461 {
462 #if SOLARIS && defined(_KERNEL) && (SOLARIS2 >= 6)
463 # if defined(ICK_VALID)
464 mb_t *m;
465 # endif
466 int dosum = 1;
467 #endif
468 tcphdr_t *tcp = NULL;
469 udphdr_t *udp = NULL;
470 ap_session_t *aps;
471 aproxy_t *apr;
472 ip_t *ip;
473 short rv;
474 int err;
475 #if !defined(_KERNEL) || defined(MENTAT) || defined(__sgi)
476 u_32_t s1, s2, sd;
477 #endif
478
479 if (fin->fin_flx & FI_BAD) {
480 if (ipf_proxy_debug > 0)
481 printf("appr_check: flx 0x%x (BAD)\n", fin->fin_flx);
482 return -1;
483 }
484
485 #ifndef IPFILTER_CKSUM
486 if ((fin->fin_out == 0) && (fr_checkl4sum(fin) == -1)) {
487 if (ipf_proxy_debug > 0)
488 printf("appr_check: l4 checksum failure %d\n",
489 fin->fin_p);
490 if (fin->fin_p == IPPROTO_TCP)
491 frstats[fin->fin_out].fr_tcpbad++;
492 return -1;
493 }
494 #endif
495
496 aps = nat->nat_aps;
497 if ((aps != NULL) && (aps->aps_p == fin->fin_p)) {
498 /*
499 * If there is data in this packet to be proxied then try and
500 * get it all into the one buffer, else drop it.
501 */
502 #if defined(MENTAT) || defined(HAVE_M_PULLDOWN)
503 if ((fin->fin_dlen > 0) && !(fin->fin_flx & FI_COALESCE))
504 if (fr_coalesce(fin) == -1) {
505 if (ipf_proxy_debug > 0)
506 printf("appr_check: fr_coalesce failed %x\n", fin->fin_flx);
507 return -1;
508 }
509 #endif
510 ip = fin->fin_ip;
511
512 switch (fin->fin_p)
513 {
514 case IPPROTO_TCP :
515 tcp = (tcphdr_t *)fin->fin_dp;
516
517 #if SOLARIS && defined(_KERNEL) && (SOLARIS2 >= 6) && defined(ICK_VALID)
518 m = fin->fin_qfm;
519 if (dohwcksum && (m->b_ick_flag == ICK_VALID))
520 dosum = 0;
521 #endif
522 /*
523 * Don't bother the proxy with these...or in fact,
524 * should we free up proxy stuff when seen?
525 */
526 if ((fin->fin_tcpf & TH_RST) != 0)
527 break;
528 /*FALLTHROUGH*/
529 case IPPROTO_UDP :
530 udp = (udphdr_t *)fin->fin_dp;
531 break;
532 default :
533 break;
534 }
535
536 apr = aps->aps_apr;
537 err = 0;
538 if (fin->fin_out != 0) {
539 if (apr->apr_outpkt != NULL)
540 err = (*apr->apr_outpkt)(fin, aps, nat);
541 } else {
542 if (apr->apr_inpkt != NULL)
543 err = (*apr->apr_inpkt)(fin, aps, nat);
544 }
545
546 rv = APR_EXIT(err);
547 if (((ipf_proxy_debug > 0) && (rv != 0)) ||
548 (ipf_proxy_debug > 8))
549 printf("appr_check: out %d err %x rv %d\n",
550 fin->fin_out, err, rv);
551 if (rv == 1)
552 return -1;
553
554 if (rv == 2) {
555 appr_free(apr);
556 nat->nat_aps = NULL;
557 return -1;
558 }
559
560 /*
561 * If err != 0 then the data size of the packet has changed
562 * so we need to recalculate the header checksums for the
563 * packet.
564 */
565 #if !defined(_KERNEL) || defined(MENTAT) || defined(__sgi)
566 if (err != 0) {
567 short adjlen = err & 0xffff;
568
569 s1 = LONG_SUM(fin->fin_plen - adjlen);
570 s2 = LONG_SUM(fin->fin_plen);
571 CALC_SUMD(s1, s2, sd);
572 fix_outcksum(fin, &ip->ip_sum, sd);
573 }
574 #endif
575
576 /*
577 * For TCP packets, we may need to adjust the sequence and
578 * acknowledgement numbers to reflect changes in size of the
579 * data stream.
580 *
581 * For both TCP and UDP, recalculate the layer 4 checksum,
582 * regardless, as we can't tell (here) if data has been
583 * changed or not.
584 */
585 if (tcp != NULL) {
586 err = appr_fixseqack(fin, ip, aps, APR_INC(err));
587 #if SOLARIS && defined(_KERNEL) && (SOLARIS2 >= 6)
588 if (dosum)
589 tcp->th_sum = fr_cksum(fin->fin_qfm, ip,
590 IPPROTO_TCP, tcp,
591 fin->fin_plen);
592 #else
593 tcp->th_sum = fr_cksum(fin->fin_m, ip,
594 IPPROTO_TCP, tcp,
595 fin->fin_plen);
596 #endif
597 } else if ((udp != NULL) && (udp->uh_sum != 0)) {
598 #if SOLARIS && defined(_KERNEL) && (SOLARIS2 >= 6)
599 if (dosum)
600 udp->uh_sum = fr_cksum(fin->fin_qfm, ip,
601 IPPROTO_UDP, udp,
602 fin->fin_plen);
603 #else
604 udp->uh_sum = fr_cksum(fin->fin_m, ip,
605 IPPROTO_UDP, udp,
606 fin->fin_plen);
607 #endif
608 }
609 aps->aps_bytes += fin->fin_plen;
610 aps->aps_pkts++;
611 return 1;
612 }
613 return 0;
614 }
615
616
617 /*
618 * Search for an proxy by the protocol it is being used with and its name.
619 */
appr_lookup(pr,name)620 aproxy_t *appr_lookup(pr, name)
621 u_int pr;
622 char *name;
623 {
624 aproxy_t *ap;
625
626 if (ipf_proxy_debug > 8)
627 printf("appr_lookup(%d,%s)\n", pr, name);
628
629 for (ap = ap_proxies; ap->apr_p; ap++)
630 if ((ap->apr_p == pr) &&
631 !strncmp(name, ap->apr_label, sizeof(ap->apr_label))) {
632 ap->apr_ref++;
633 return ap;
634 }
635
636 for (ap = ap_proxylist; ap; ap = ap->apr_next)
637 if ((ap->apr_p == pr) &&
638 !strncmp(name, ap->apr_label, sizeof(ap->apr_label))) {
639 ap->apr_ref++;
640 return ap;
641 }
642 if (ipf_proxy_debug > 2)
643 printf("appr_lookup: failed for %d/%s\n", pr, name);
644 return NULL;
645 }
646
647
appr_free(ap)648 void appr_free(ap)
649 aproxy_t *ap;
650 {
651 ap->apr_ref--;
652 }
653
654
aps_free(aps)655 void aps_free(aps)
656 ap_session_t *aps;
657 {
658 ap_session_t *a, **ap;
659 aproxy_t *apr;
660
661 if (!aps)
662 return;
663
664 for (ap = &ap_sess_list; ((a = *ap) != NULL); ap = &a->aps_next)
665 if (a == aps) {
666 *ap = a->aps_next;
667 break;
668 }
669
670 apr = aps->aps_apr;
671 if ((apr != NULL) && (apr->apr_del != NULL))
672 (*apr->apr_del)(aps);
673
674 if ((aps->aps_data != NULL) && (aps->aps_psiz != 0))
675 KFREES(aps->aps_data, aps->aps_psiz);
676 KFREE(aps);
677 }
678
679
680 /*
681 * returns 2 if ack or seq number in TCP header is changed, returns 0 otherwise
682 */
appr_fixseqack(fin,ip,aps,inc)683 static int appr_fixseqack(fin, ip, aps, inc)
684 fr_info_t *fin;
685 ip_t *ip;
686 ap_session_t *aps;
687 int inc;
688 {
689 int sel, ch = 0, out, nlen;
690 u_32_t seq1, seq2;
691 tcphdr_t *tcp;
692 short inc2;
693
694 tcp = (tcphdr_t *)fin->fin_dp;
695 out = fin->fin_out;
696 /*
697 * fin->fin_plen has already been adjusted by 'inc'.
698 */
699 nlen = fin->fin_plen;
700 nlen -= (IP_HL(ip) << 2) + (TCP_OFF(tcp) << 2);
701
702 inc2 = inc;
703 inc = (int)inc2;
704
705 if (out != 0) {
706 seq1 = (u_32_t)ntohl(tcp->th_seq);
707 sel = aps->aps_sel[out];
708
709 /* switch to other set ? */
710 if ((aps->aps_seqmin[!sel] > aps->aps_seqmin[sel]) &&
711 (seq1 > aps->aps_seqmin[!sel])) {
712 if (ipf_proxy_debug > 7)
713 printf("proxy out switch set seq %d -> %d %x > %x\n",
714 sel, !sel, seq1,
715 aps->aps_seqmin[!sel]);
716 sel = aps->aps_sel[out] = !sel;
717 }
718
719 if (aps->aps_seqoff[sel]) {
720 seq2 = aps->aps_seqmin[sel] - aps->aps_seqoff[sel];
721 if (seq1 > seq2) {
722 seq2 = aps->aps_seqoff[sel];
723 seq1 += seq2;
724 tcp->th_seq = htonl(seq1);
725 ch = 1;
726 }
727 }
728
729 if (inc && (seq1 > aps->aps_seqmin[!sel])) {
730 aps->aps_seqmin[sel] = seq1 + nlen - 1;
731 aps->aps_seqoff[sel] = aps->aps_seqoff[sel] + inc;
732 if (ipf_proxy_debug > 7)
733 printf("proxy seq set %d at %x to %d + %d\n",
734 sel, aps->aps_seqmin[sel],
735 aps->aps_seqoff[sel], inc);
736 }
737
738 /***/
739
740 seq1 = ntohl(tcp->th_ack);
741 sel = aps->aps_sel[1 - out];
742
743 /* switch to other set ? */
744 if ((aps->aps_ackmin[!sel] > aps->aps_ackmin[sel]) &&
745 (seq1 > aps->aps_ackmin[!sel])) {
746 if (ipf_proxy_debug > 7)
747 printf("proxy out switch set ack %d -> %d %x > %x\n",
748 sel, !sel, seq1,
749 aps->aps_ackmin[!sel]);
750 sel = aps->aps_sel[1 - out] = !sel;
751 }
752
753 if (aps->aps_ackoff[sel] && (seq1 > aps->aps_ackmin[sel])) {
754 seq2 = aps->aps_ackoff[sel];
755 tcp->th_ack = htonl(seq1 - seq2);
756 ch = 1;
757 }
758 } else {
759 seq1 = ntohl(tcp->th_seq);
760 sel = aps->aps_sel[out];
761
762 /* switch to other set ? */
763 if ((aps->aps_ackmin[!sel] > aps->aps_ackmin[sel]) &&
764 (seq1 > aps->aps_ackmin[!sel])) {
765 if (ipf_proxy_debug > 7)
766 printf("proxy in switch set ack %d -> %d %x > %x\n",
767 sel, !sel, seq1, aps->aps_ackmin[!sel]);
768 sel = aps->aps_sel[out] = !sel;
769 }
770
771 if (aps->aps_ackoff[sel]) {
772 seq2 = aps->aps_ackmin[sel] - aps->aps_ackoff[sel];
773 if (seq1 > seq2) {
774 seq2 = aps->aps_ackoff[sel];
775 seq1 += seq2;
776 tcp->th_seq = htonl(seq1);
777 ch = 1;
778 }
779 }
780
781 if (inc && (seq1 > aps->aps_ackmin[!sel])) {
782 aps->aps_ackmin[!sel] = seq1 + nlen - 1;
783 aps->aps_ackoff[!sel] = aps->aps_ackoff[sel] + inc;
784
785 if (ipf_proxy_debug > 7)
786 printf("proxy ack set %d at %x to %d + %d\n",
787 !sel, aps->aps_seqmin[!sel],
788 aps->aps_seqoff[sel], inc);
789 }
790
791 /***/
792
793 seq1 = ntohl(tcp->th_ack);
794 sel = aps->aps_sel[1 - out];
795
796 /* switch to other set ? */
797 if ((aps->aps_seqmin[!sel] > aps->aps_seqmin[sel]) &&
798 (seq1 > aps->aps_seqmin[!sel])) {
799 if (ipf_proxy_debug > 7)
800 printf("proxy in switch set seq %d -> %d %x > %x\n",
801 sel, !sel, seq1, aps->aps_seqmin[!sel]);
802 sel = aps->aps_sel[1 - out] = !sel;
803 }
804
805 if (aps->aps_seqoff[sel] != 0) {
806 if (ipf_proxy_debug > 7)
807 printf("sel %d seqoff %d seq1 %x seqmin %x\n",
808 sel, aps->aps_seqoff[sel], seq1,
809 aps->aps_seqmin[sel]);
810 if (seq1 > aps->aps_seqmin[sel]) {
811 seq2 = aps->aps_seqoff[sel];
812 tcp->th_ack = htonl(seq1 - seq2);
813 ch = 1;
814 }
815 }
816 }
817
818 if (ipf_proxy_debug > 8)
819 printf("appr_fixseqack: seq %x ack %x\n",
820 (u_32_t)ntohl(tcp->th_seq), (u_32_t)ntohl(tcp->th_ack));
821 return ch ? 2 : 0;
822 }
823
824
825 /*
826 * Initialise hook for kernel application proxies.
827 * Call the initialise routine for all the compiled in kernel proxies.
828 */
appr_init()829 int appr_init()
830 {
831 aproxy_t *ap;
832 int err = 0;
833
834 for (ap = ap_proxies; ap->apr_p; ap++) {
835 if (ap->apr_init != NULL) {
836 err = (*ap->apr_init)();
837 if (err != 0)
838 break;
839 }
840 }
841 return err;
842 }
843
844
845 /*
846 * Unload hook for kernel application proxies.
847 * Call the finialise routine for all the compiled in kernel proxies.
848 */
appr_unload()849 void appr_unload()
850 {
851 aproxy_t *ap;
852
853 for (ap = ap_proxies; ap->apr_p; ap++)
854 if (ap->apr_fini != NULL)
855 (*ap->apr_fini)();
856 for (ap = ap_proxylist; ap; ap = ap->apr_next)
857 if (ap->apr_fini != NULL)
858 (*ap->apr_fini)();
859 }
860