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.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  */
 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  */
 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, 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  */
 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  */
 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  */
 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  */
 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
 648 void appr_free(ap)
 649 aproxy_t *ap;
 650 {
 651         ap->apr_ref--;
 652 }
 653
 654
 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  */
 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  */
 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  */
 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 }