sys/contrib/ipfilter/netinet/ip_proxy.c

   1 /*      $FreeBSD$       */
   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.16 2006/03/29 11:19:56 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 },
 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 },
 160         { NULL, "h245", (char)IPPROTO_TCP, 0, 0, NULL, NULL,
 161           ippr_h245_new, NULL, NULL, ippr_h245_out, 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 }
 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  */
 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->apr_p; 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  */
 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  */
 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  */
 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
 292 int appr_ioctl(data, cmd, mode)
 293 caddr_t data;
 294 ioctlcmd_t cmd;
 295 int mode;
 296 {
 297         ap_ctl_t ctl;
 298         caddr_t ptr;
 299         int error;
 300
 301         mode = mode;    /* LINT */
 302
 303         switch (cmd)
 304         {
 305         case SIOCPROXY :
 306                 BCOPYIN(data, &ctl, sizeof(ctl));
 307                 ptr = NULL;
 308
 309                 if (ctl.apc_dsize > 0) {
 310                         KMALLOCS(ptr, caddr_t, ctl.apc_dsize);
 311                         if (ptr == NULL)
 312                                 error = ENOMEM;
 313                         else {
 314                                 error = copyinptr(ctl.apc_data, ptr,
 315                                                   ctl.apc_dsize);
 316                                 if (error == 0)
 317                                         ctl.apc_data = ptr;
 318                         }
 319                 } else {
 320                         ctl.apc_data = NULL;
 321                         error = 0;
 322                 }
 323
 324                 if (error == 0)
 325                         error = appr_ctl(&ctl);
 326
 327                 if (ptr != NULL) {
 328                         KFREES(ptr, ctl.apc_dsize);
 329                 }
 330                 break;
 331
 332         default :
 333                 error = EINVAL;
 334         }
 335         return error;
 336 }
 337
 338
 339 /*
 340  * If a proxy has a match function, call that to do extended packet
 341  * matching.
 342  */
 343 int appr_match(fin, nat)
 344 fr_info_t *fin;
 345 nat_t *nat;
 346 {
 347         aproxy_t *apr;
 348         ipnat_t *ipn;
 349         int result;
 350
 351         ipn = nat->nat_ptr;
 352         if (ipf_proxy_debug > 8)
 353                 printf("appr_match(%lx,%lx) aps %lx ptr %lx\n",
 354                         (u_long)fin, (u_long)nat, (u_long)nat->nat_aps,
 355                         (u_long)ipn);
 356
 357         if ((fin->fin_flx & (FI_SHORT|FI_BAD)) != 0) {
 358                 if (ipf_proxy_debug > 0)
 359                         printf("appr_match: flx 0x%x (BAD|SHORT)\n",
 360                                 fin->fin_flx);
 361                 return -1;
 362         }
 363
 364         apr = ipn->in_apr;
 365         if ((apr == NULL) || (apr->apr_flags & APR_DELETE)) {
 366                 if (ipf_proxy_debug > 0)
 367                         printf("appr_match:apr %lx apr_flags 0x%x\n",
 368                                 (u_long)apr, apr ? apr->apr_flags : 0);
 369                 return -1;
 370         }
 371
 372         if (apr->apr_match != NULL) {
 373                 result = (*apr->apr_match)(fin, nat->nat_aps, nat);
 374                 if (result != 0) {
 375                         if (ipf_proxy_debug > 4)
 376                                 printf("appr_match: result %d\n", result);
 377                         return -1;
 378                 }
 379         }
 380         return 0;
 381 }
 382
 383
 384 /*
 385  * Allocate a new application proxy structure and fill it in with the
 386  * relevant details.  call the init function once complete, prior to
 387  * returning.
 388  */
 389 int appr_new(fin, nat)
 390 fr_info_t *fin;
 391 nat_t *nat;
 392 {
 393         register ap_session_t *aps;
 394         aproxy_t *apr;
 395
 396         if (ipf_proxy_debug > 8)
 397                 printf("appr_new(%lx,%lx) \n", (u_long)fin, (u_long)nat);
 398
 399         if ((nat->nat_ptr == NULL) || (nat->nat_aps != NULL)) {
 400                 if (ipf_proxy_debug > 0)
 401                         printf("appr_new: nat_ptr %lx nat_aps %lx\n",
 402                                 (u_long)nat->nat_ptr, (u_long)nat->nat_aps);
 403                 return -1;
 404         }
 405
 406         apr = nat->nat_ptr->in_apr;
 407
 408         if ((apr->apr_flags & APR_DELETE) ||
 409             (fin->fin_p != apr->apr_p)) {
 410                 if (ipf_proxy_debug > 2)
 411                         printf("appr_new: apr_flags 0x%x p %d/%d\n",
 412                                 apr->apr_flags, fin->fin_p, apr->apr_p);
 413                 return -1;
 414         }
 415
 416         KMALLOC(aps, ap_session_t *);
 417         if (!aps) {
 418                 if (ipf_proxy_debug > 0)
 419                         printf("appr_new: malloc failed (%lu)\n",
 420                                 (u_long)sizeof(ap_session_t));
 421                 return -1;
 422         }
 423
 424         bzero((char *)aps, sizeof(*aps));
 425         aps->aps_p = fin->fin_p;
 426         aps->aps_data = NULL;
 427         aps->aps_apr = apr;
 428         aps->aps_psiz = 0;
 429         if (apr->apr_new != NULL)
 430                 if ((*apr->apr_new)(fin, aps, nat) == -1) {
 431                         if ((aps->aps_data != NULL) && (aps->aps_psiz != 0)) {
 432                                 KFREES(aps->aps_data, aps->aps_psiz);
 433                         }
 434                         KFREE(aps);
 435                         if (ipf_proxy_debug > 2)
 436                                 printf("appr_new: new(%lx) failed\n",
 437                                         (u_long)apr->apr_new);
 438                         return -1;
 439                 }
 440         aps->aps_nat = nat;
 441         aps->aps_next = ap_sess_list;
 442         ap_sess_list = aps;
 443         nat->nat_aps = aps;
 444
 445         return 0;
 446 }
 447
 448
 449 /*
 450  * Check to see if a packet should be passed through an active proxy routine
 451  * if one has been setup for it.  We don't need to check the checksum here if
 452  * IPFILTER_CKSUM is defined because if it is, a failed check causes FI_BAD
 453  * to be set.
 454  */
 455 int appr_check(fin, nat)
 456 fr_info_t *fin;
 457 nat_t *nat;
 458 {
 459 #if SOLARIS && defined(_KERNEL) && (SOLARIS2 >= 6)
 460 # if defined(ICK_VALID)
 461         mb_t *m;
 462 # endif
 463         int dosum = 1;
 464 #endif
 465         tcphdr_t *tcp = NULL;
 466         udphdr_t *udp = NULL;
 467         ap_session_t *aps;
 468         aproxy_t *apr;
 469         ip_t *ip;
 470         short rv;
 471         int err;
 472 #if !defined(_KERNEL) || defined(MENTAT) || defined(__sgi)
 473         u_32_t s1, s2, sd;
 474 #endif
 475
 476         if (fin->fin_flx & FI_BAD) {
 477                 if (ipf_proxy_debug > 0)
 478                         printf("appr_check: flx 0x%x (BAD)\n", fin->fin_flx);
 479                 return -1;
 480         }
 481
 482 #ifndef IPFILTER_CKSUM
 483         if ((fin->fin_out == 0) && (fr_checkl4sum(fin) == -1)) {
 484                 if (ipf_proxy_debug > 0)
 485                         printf("appr_check: l4 checksum failure %d\n",
 486                                 fin->fin_p);
 487                 if (fin->fin_p == IPPROTO_TCP)
 488                         frstats[fin->fin_out].fr_tcpbad++;
 489                 return -1;
 490         }
 491 #endif
 492
 493         aps = nat->nat_aps;
 494         if ((aps != NULL) && (aps->aps_p == fin->fin_p)) {
 495                 /*
 496                  * If there is data in this packet to be proxied then try and
 497                  * get it all into the one buffer, else drop it.
 498                  */
 499 #if defined(MENTAT) || defined(HAVE_M_PULLDOWN)
 500                 if ((fin->fin_dlen > 0) && !(fin->fin_flx & FI_COALESCE))
 501                         if (fr_coalesce(fin) == -1) {
 502                                 if (ipf_proxy_debug > 0)
 503                                         printf("appr_check: fr_coalesce failed %x\n", fin->fin_flx);
 504                                 return -1;
 505                         }
 506 #endif
 507                 ip = fin->fin_ip;
 508
 509                 switch (fin->fin_p)
 510                 {
 511                 case IPPROTO_TCP :
 512                         tcp = (tcphdr_t *)fin->fin_dp;
 513
 514 #if SOLARIS && defined(_KERNEL) && (SOLARIS2 >= 6) && defined(ICK_VALID)
 515                         m = fin->fin_qfm;
 516                         if (dohwcksum && (m->b_ick_flag == ICK_VALID))
 517                                 dosum = 0;
 518 #endif
 519                         /*
 520                          * Don't bother the proxy with these...or in fact,
 521                          * should we free up proxy stuff when seen?
 522                          */
 523                         if ((fin->fin_tcpf & TH_RST) != 0)
 524                                 break;
 525                         /*FALLTHROUGH*/
 526                 case IPPROTO_UDP :
 527                         udp = (udphdr_t *)fin->fin_dp;
 528                         break;
 529                 default :
 530                         break;
 531                 }
 532
 533                 apr = aps->aps_apr;
 534                 err = 0;
 535                 if (fin->fin_out != 0) {
 536                         if (apr->apr_outpkt != NULL)
 537                                 err = (*apr->apr_outpkt)(fin, aps, nat);
 538                 } else {
 539                         if (apr->apr_inpkt != NULL)
 540                                 err = (*apr->apr_inpkt)(fin, aps, nat);
 541                 }
 542
 543                 rv = APR_EXIT(err);
 544                 if (((ipf_proxy_debug > 0) && (rv != 0)) ||
 545                     (ipf_proxy_debug > 8))
 546                         printf("appr_check: out %d err %x rv %d\n",
 547                                 fin->fin_out, err, rv);
 548                 if (rv == 1)
 549                         return -1;
 550
 551                 if (rv == 2) {
 552                         appr_free(apr);
 553                         nat->nat_aps = NULL;
 554                         return -1;
 555                 }
 556
 557                 /*
 558                  * If err != 0 then the data size of the packet has changed
 559                  * so we need to recalculate the header checksums for the
 560                  * packet.
 561                  */
 562 #if !defined(_KERNEL) || defined(MENTAT) || defined(__sgi)
 563                 if (err != 0) {
 564                         short adjlen = err & 0xffff;
 565
 566                         s1 = LONG_SUM(fin->fin_plen - adjlen);
 567                         s2 = LONG_SUM(fin->fin_plen);
 568                         CALC_SUMD(s1, s2, sd);
 569                         fix_outcksum(fin, &ip->ip_sum, sd);
 570                 }
 571 #endif
 572
 573                 /*
 574                  * For TCP packets, we may need to adjust the sequence and
 575                  * acknowledgement numbers to reflect changes in size of the
 576                  * data stream.
 577                  *
 578                  * For both TCP and UDP, recalculate the layer 4 checksum,
 579                  * regardless, as we can't tell (here) if data has been
 580                  * changed or not.
 581                  */
 582                 if (tcp != NULL) {
 583                         err = appr_fixseqack(fin, ip, aps, APR_INC(err));
 584 #if SOLARIS && defined(_KERNEL) && (SOLARIS2 >= 6)
 585                         if (dosum)
 586                                 tcp->th_sum = fr_cksum(fin->fin_qfm, ip,
 587                                                        IPPROTO_TCP, tcp,
 588                                                        fin->fin_plen);
 589 #else
 590                         tcp->th_sum = fr_cksum(fin->fin_m, ip,
 591                                                IPPROTO_TCP, tcp,
 592                                                fin->fin_plen);
 593 #endif
 594                 } else if ((udp != NULL) && (udp->uh_sum != 0)) {
 595 #if SOLARIS && defined(_KERNEL) && (SOLARIS2 >= 6)
 596                         if (dosum)
 597                                 udp->uh_sum = fr_cksum(fin->fin_qfm, ip,
 598                                                        IPPROTO_UDP, udp,
 599                                                        fin->fin_plen);
 600 #else
 601                         udp->uh_sum = fr_cksum(fin->fin_m, ip,
 602                                                IPPROTO_UDP, udp,
 603                                                fin->fin_plen);
 604 #endif
 605                 }
 606                 aps->aps_bytes += fin->fin_plen;
 607                 aps->aps_pkts++;
 608                 return 1;
 609         }
 610         return 0;
 611 }
 612
 613
 614 /*
 615  * Search for an proxy by the protocol it is being used with and its name.
 616  */
 617 aproxy_t *appr_lookup(pr, name)
 618 u_int pr;
 619 char *name;
 620 {
 621         aproxy_t *ap;
 622
 623         if (ipf_proxy_debug > 8)
 624                 printf("appr_lookup(%d,%s)\n", pr, name);
 625
 626         for (ap = ap_proxies; ap->apr_p; ap++)
 627                 if ((ap->apr_p == pr) &&
 628                     !strncmp(name, ap->apr_label, sizeof(ap->apr_label))) {
 629                         ap->apr_ref++;
 630                         return ap;
 631                 }
 632
 633         for (ap = ap_proxylist; ap; ap = ap->apr_next)
 634                 if ((ap->apr_p == pr) &&
 635                     !strncmp(name, ap->apr_label, sizeof(ap->apr_label))) {
 636                         ap->apr_ref++;
 637                         return ap;
 638                 }
 639         if (ipf_proxy_debug > 2)
 640                 printf("appr_lookup: failed for %d/%s\n", pr, name);
 641         return NULL;
 642 }
 643
 644
 645 void appr_free(ap)
 646 aproxy_t *ap;
 647 {
 648         ap->apr_ref--;
 649 }
 650
 651
 652 void aps_free(aps)
 653 ap_session_t *aps;
 654 {
 655         ap_session_t *a, **ap;
 656         aproxy_t *apr;
 657
 658         if (!aps)
 659                 return;
 660
 661         for (ap = &ap_sess_list; ((a = *ap) != NULL); ap = &a->aps_next)
 662                 if (a == aps) {
 663                         *ap = a->aps_next;
 664                         break;
 665                 }
 666
 667         apr = aps->aps_apr;
 668         if ((apr != NULL) && (apr->apr_del != NULL))
 669                 (*apr->apr_del)(aps);
 670
 671         if ((aps->aps_data != NULL) && (aps->aps_psiz != 0))
 672                 KFREES(aps->aps_data, aps->aps_psiz);
 673         KFREE(aps);
 674 }
 675
 676
 677 /*
 678  * returns 2 if ack or seq number in TCP header is changed, returns 0 otherwise
 679  */
 680 static int appr_fixseqack(fin, ip, aps, inc)
 681 fr_info_t *fin;
 682 ip_t *ip;
 683 ap_session_t *aps;
 684 int inc;
 685 {
 686         int sel, ch = 0, out, nlen;
 687         u_32_t seq1, seq2;
 688         tcphdr_t *tcp;
 689         short inc2;
 690
 691         tcp = (tcphdr_t *)fin->fin_dp;
 692         out = fin->fin_out;
 693         /*
 694          * fin->fin_plen has already been adjusted by 'inc'.
 695          */
 696         nlen = fin->fin_plen;
 697         nlen -= (IP_HL(ip) << 2) + (TCP_OFF(tcp) << 2);
 698
 699         inc2 = inc;
 700         inc = (int)inc2;
 701
 702         if (out != 0) {
 703                 seq1 = (u_32_t)ntohl(tcp->th_seq);
 704                 sel = aps->aps_sel[out];
 705
 706                 /* switch to other set ? */
 707                 if ((aps->aps_seqmin[!sel] > aps->aps_seqmin[sel]) &&
 708                     (seq1 > aps->aps_seqmin[!sel])) {
 709                         if (ipf_proxy_debug > 7)
 710                                 printf("proxy out switch set seq %d -> %d %x > %x\n",
 711                                         sel, !sel, seq1,
 712                                         aps->aps_seqmin[!sel]);
 713                         sel = aps->aps_sel[out] = !sel;
 714                 }
 715
 716                 if (aps->aps_seqoff[sel]) {
 717                         seq2 = aps->aps_seqmin[sel] - aps->aps_seqoff[sel];
 718                         if (seq1 > seq2) {
 719                                 seq2 = aps->aps_seqoff[sel];
 720                                 seq1 += seq2;
 721                                 tcp->th_seq = htonl(seq1);
 722                                 ch = 1;
 723                         }
 724                 }
 725
 726                 if (inc && (seq1 > aps->aps_seqmin[!sel])) {
 727                         aps->aps_seqmin[sel] = seq1 + nlen - 1;
 728                         aps->aps_seqoff[sel] = aps->aps_seqoff[sel] + inc;
 729                         if (ipf_proxy_debug > 7)
 730                                 printf("proxy seq set %d at %x to %d + %d\n",
 731                                         sel, aps->aps_seqmin[sel],
 732                                         aps->aps_seqoff[sel], inc);
 733                 }
 734
 735                 /***/
 736
 737                 seq1 = ntohl(tcp->th_ack);
 738                 sel = aps->aps_sel[1 - out];
 739
 740                 /* switch to other set ? */
 741                 if ((aps->aps_ackmin[!sel] > aps->aps_ackmin[sel]) &&
 742                     (seq1 > aps->aps_ackmin[!sel])) {
 743                         if (ipf_proxy_debug > 7)
 744                                 printf("proxy out switch set ack %d -> %d %x > %x\n",
 745                                         sel, !sel, seq1,
 746                                         aps->aps_ackmin[!sel]);
 747                         sel = aps->aps_sel[1 - out] = !sel;
 748                 }
 749
 750                 if (aps->aps_ackoff[sel] && (seq1 > aps->aps_ackmin[sel])) {
 751                         seq2 = aps->aps_ackoff[sel];
 752                         tcp->th_ack = htonl(seq1 - seq2);
 753                         ch = 1;
 754                 }
 755         } else {
 756                 seq1 = ntohl(tcp->th_seq);
 757                 sel = aps->aps_sel[out];
 758
 759                 /* switch to other set ? */
 760                 if ((aps->aps_ackmin[!sel] > aps->aps_ackmin[sel]) &&
 761                     (seq1 > aps->aps_ackmin[!sel])) {
 762                         if (ipf_proxy_debug > 7)
 763                                 printf("proxy in switch set ack %d -> %d %x > %x\n",
 764                                         sel, !sel, seq1, aps->aps_ackmin[!sel]);
 765                         sel = aps->aps_sel[out] = !sel;
 766                 }
 767
 768                 if (aps->aps_ackoff[sel]) {
 769                         seq2 = aps->aps_ackmin[sel] - aps->aps_ackoff[sel];
 770                         if (seq1 > seq2) {
 771                                 seq2 = aps->aps_ackoff[sel];
 772                                 seq1 += seq2;
 773                                 tcp->th_seq = htonl(seq1);
 774                                 ch = 1;
 775                         }
 776                 }
 777
 778                 if (inc && (seq1 > aps->aps_ackmin[!sel])) {
 779                         aps->aps_ackmin[!sel] = seq1 + nlen - 1;
 780                         aps->aps_ackoff[!sel] = aps->aps_ackoff[sel] + inc;
 781
 782                         if (ipf_proxy_debug > 7)
 783                                 printf("proxy ack set %d at %x to %d + %d\n",
 784                                         !sel, aps->aps_seqmin[!sel],
 785                                         aps->aps_seqoff[sel], inc);
 786                 }
 787
 788                 /***/
 789
 790                 seq1 = ntohl(tcp->th_ack);
 791                 sel = aps->aps_sel[1 - out];
 792
 793                 /* switch to other set ? */
 794                 if ((aps->aps_seqmin[!sel] > aps->aps_seqmin[sel]) &&
 795                     (seq1 > aps->aps_seqmin[!sel])) {
 796                         if (ipf_proxy_debug > 7)
 797                                 printf("proxy in switch set seq %d -> %d %x > %x\n",
 798                                         sel, !sel, seq1, aps->aps_seqmin[!sel]);
 799                         sel = aps->aps_sel[1 - out] = !sel;
 800                 }
 801
 802                 if (aps->aps_seqoff[sel] != 0) {
 803                         if (ipf_proxy_debug > 7)
 804                                 printf("sel %d seqoff %d seq1 %x seqmin %x\n",
 805                                         sel, aps->aps_seqoff[sel], seq1,
 806                                         aps->aps_seqmin[sel]);
 807                         if (seq1 > aps->aps_seqmin[sel]) {
 808                                 seq2 = aps->aps_seqoff[sel];
 809                                 tcp->th_ack = htonl(seq1 - seq2);
 810                                 ch = 1;
 811                         }
 812                 }
 813         }
 814
 815         if (ipf_proxy_debug > 8)
 816                 printf("appr_fixseqack: seq %x ack %x\n",
 817                         ntohl(tcp->th_seq), ntohl(tcp->th_ack));
 818         return ch ? 2 : 0;
 819 }
 820
 821
 822 /*
 823  * Initialise hook for kernel application proxies.
 824  * Call the initialise routine for all the compiled in kernel proxies.
 825  */
 826 int appr_init()
 827 {
 828         aproxy_t *ap;
 829         int err = 0;
 830
 831         for (ap = ap_proxies; ap->apr_p; ap++) {
 832                 if (ap->apr_init != NULL) {
 833                         err = (*ap->apr_init)();
 834                         if (err != 0)
 835                                 break;
 836                 }
 837         }
 838         return err;
 839 }
 840
 841
 842 /*
 843  * Unload hook for kernel application proxies.
 844  * Call the finialise routine for all the compiled in kernel proxies.
 845  */
 846 void appr_unload()
 847 {
 848         aproxy_t *ap;
 849
 850         for (ap = ap_proxies; ap->apr_p; ap++)
 851                 if (ap->apr_fini != NULL)
 852                         (*ap->apr_fini)();
 853         for (ap = ap_proxylist; ap; ap = ap->apr_next)
 854                 if (ap->apr_fini != NULL)
 855                         (*ap->apr_fini)();
 856 }