sys/contrib/ipfilter/netinet/ip_fil.c

   1 /*
   2  * Copyright (C) 1993-2001 by Darren Reed.
   3  *
   4  * See the IPFILTER.LICENCE file for details on licencing.
   5  *
   6  * @(#)ip_fil.c     2.41 6/5/96 (C) 1993-2000 Darren Reed
   7  * @(#)$Id: ip_fil.c,v 2.42.2.60 2002/08/28 12:40:39 darrenr Exp $
   8  * $FreeBSD: src/sys/contrib/ipfilter/netinet/ip_fil.c,v 1.25.2.6 2003/03/01 03:55:54 darrenr Exp $
   9  * $DragonFly: src/sys/contrib/ipfilter/netinet/ip_fil.c,v 1.2 2003/06/17 04:28:20 dillon Exp $
  10  */
  11 #ifndef SOLARIS
  12 #define SOLARIS (defined(sun) && (defined(__svr4__) || defined(__SVR4)))
  13 #endif
  14
  15 #if defined(KERNEL) && !defined(_KERNEL)
  16 # define        _KERNEL
  17 #endif
  18 #if defined(_KERNEL) && defined(__FreeBSD_version) && \
  19     (__FreeBSD_version >= 400000) && !defined(KLD_MODULE)
  20 #include "opt_inet6.h"
  21 #endif
  22 #include <sys/param.h>
  23 #if defined(__NetBSD__) && (NetBSD >= 199905) && !defined(IPFILTER_LKM) && \
  24     defined(_KERNEL)  && !defined(_LKM)
  25 # include "opt_ipfilter_log.h"
  26 #endif
  27 #if defined(__FreeBSD__) && !defined(__FreeBSD_version)
  28 # if !defined(_KERNEL) || defined(IPFILTER_LKM)
  29 #  include <osreldate.h>
  30 # endif
  31 #endif
  32 #if defined(__sgi) && (IRIX > 602)
  33 # define _KMEMUSER
  34 # include <sys/ptimers.h>
  35 #endif
  36 #ifndef _KERNEL
  37 # include <stdio.h>
  38 # include <string.h>
  39 # include <stdlib.h>
  40 # include <ctype.h>
  41 # include <fcntl.h>
  42 #endif
  43 #include <sys/errno.h>
  44 #include <sys/types.h>
  45 #include <sys/file.h>
  46 #if __FreeBSD_version >= 220000 && defined(_KERNEL)
  47 # include <sys/fcntl.h>
  48 # include <sys/filio.h>
  49 #else
  50 # include <sys/ioctl.h>
  51 #endif
  52 #include <sys/time.h>
  53 #ifdef  _KERNEL
  54 # include <sys/systm.h>
  55 #endif
  56 #if !SOLARIS
  57 # if (NetBSD > 199609) || (OpenBSD > 199603) || (__FreeBSD_version >= 300000)
  58 #  include <sys/dirent.h>
  59 # else
  60 #  include <sys/dir.h>
  61 # endif
  62 # include <sys/mbuf.h>
  63 #else
  64 # include <sys/filio.h>
  65 #endif
  66 #include <sys/protosw.h>
  67 #include <sys/socket.h>
  68
  69 #include <net/if.h>
  70 #ifdef sun
  71 # include <net/af.h>
  72 #endif
  73 #if __FreeBSD_version >= 300000
  74 # include <net/if_var.h>
  75 # if defined(_KERNEL) && !defined(IPFILTER_LKM)
  76 #  include "opt_ipfilter.h"
  77 # endif
  78 #endif
  79 #ifdef __sgi
  80 #include <sys/debug.h>
  81 # ifdef IFF_DRVRLOCK /* IRIX6 */
  82 #include <sys/hashing.h>
  83 # endif
  84 #endif
  85 #include <net/route.h>
  86 #include <netinet/in.h>
  87 #if !(defined(__sgi) && !defined(IFF_DRVRLOCK)) /* IRIX < 6 */
  88 # include <netinet/in_var.h>
  89 #endif
  90 #include <netinet/in_systm.h>
  91 #include <netinet/ip.h>
  92 #include <netinet/ip_var.h>
  93 #include <netinet/tcp.h>
  94 #include <netinet/udp.h>
  95 #include <netinet/tcpip.h>
  96 #include <netinet/ip_icmp.h>
  97 #ifndef _KERNEL
  98 # include <unistd.h>
  99 # include <syslog.h>
 100 #endif
 101 #include "netinet/ip_compat.h"
 102 #ifdef USE_INET6
 103 # include <netinet/icmp6.h>
 104 # if !SOLARIS
 105 #  include <netinet6/ip6protosw.h>
 106 #  include <netinet6/nd6.h>
 107 # endif
 108 #endif
 109 #include "netinet/ip_fil.h"
 110 #include "netinet/ip_nat.h"
 111 #include "netinet/ip_frag.h"
 112 #include "netinet/ip_state.h"
 113 #include "netinet/ip_proxy.h"
 114 #include "netinet/ip_auth.h"
 115 #if defined(__FreeBSD_version) && (__FreeBSD_version >= 300000)
 116 # include <sys/malloc.h>
 117 #endif
 118 #ifndef MIN
 119 # define        MIN(a,b)        (((a)<(b))?(a):(b))
 120 #endif
 121 #if !SOLARIS && defined(_KERNEL) && !defined(__sgi)
 122 # include <sys/kernel.h>
 123 extern  int     ip_optcopy __P((struct ip *, struct ip *));
 124 #endif
 125 #if defined(OpenBSD) && (OpenBSD >= 200211) && defined(_KERNEL)
 126 extern  int     ip6_getpmtu(struct route_in6 *, struct route_in6 *,
 127                             struct ifnet *, struct in6_addr *, u_long *);
 128 #endif
 129
 130 #include <machine/in_cksum.h>
 131
 132 static const char sccsid[] = "@(#)ip_fil.c     2.41 6/5/96 (C) 1993-2000 Darren Reed";
 133
 134 extern  struct  protosw inetsw[];
 135
 136 #ifndef _KERNEL
 137 # include "ipt.h"
 138 static  struct  ifnet **ifneta = NULL;
 139 static  int     nifs = 0;
 140 #else
 141 # if    (BSD < 199306) || defined(__sgi)
 142 extern  int     tcp_ttl;
 143 # endif
 144 #endif
 145
 146 #ifdef  ICMP_UNREACH_FILTER_PROHIB
 147 int     ipl_unreach = ICMP_UNREACH_FILTER_PROHIB;
 148 #else
 149 int     ipl_unreach = ICMP_UNREACH_FILTER;
 150 #endif
 151 u_long  ipl_frouteok[2] = {0, 0};
 152
 153 static  int     frzerostats __P((caddr_t));
 154 #if defined(__NetBSD__) || defined(__OpenBSD__) || (__FreeBSD_version >= 300003)
 155 static  int     frrequest __P((int, u_long, caddr_t, int));
 156 #else
 157 static  int     frrequest __P((int, int, caddr_t, int));
 158 #endif
 159 #ifdef  _KERNEL
 160 static  int     (*fr_savep) __P((ip_t *, int, void *, int, struct mbuf **));
 161 static  int     send_ip __P((ip_t *, fr_info_t *, struct mbuf **));
 162 # ifdef USE_INET6
 163 static  int     ipfr_fastroute6 __P((struct mbuf *, struct mbuf **,
 164                                      fr_info_t *, frdest_t *));
 165 # endif
 166 # ifdef __sgi
 167 extern  int             tcp_mtudisc;
 168 extern  kmutex_t        ipf_rw;
 169 extern  KRWLOCK_T       ipf_mutex;
 170 # endif
 171 #else
 172 void    init_ifp __P((void));
 173 # if defined(__sgi) && (IRIX < 605)
 174 static int      no_output __P((struct ifnet *, struct mbuf *,
 175                                struct sockaddr *));
 176 static int      write_output __P((struct ifnet *, struct mbuf *,
 177                                   struct sockaddr *));
 178 # else
 179 static int      no_output __P((struct ifnet *, struct mbuf *,
 180                                struct sockaddr *, struct rtentry *));
 181 static int      write_output __P((struct ifnet *, struct mbuf *,
 182                                   struct sockaddr *, struct rtentry *));
 183 # endif
 184 #endif
 185 int     fr_running = 0;
 186
 187 #if (__FreeBSD_version >= 300000) && defined(_KERNEL)
 188 struct callout_handle ipfr_slowtimer_ch;
 189 #endif
 190 #if defined(__NetBSD__) && (__NetBSD_Version__ >= 104230000)
 191 # include <sys/callout.h>
 192 struct callout ipfr_slowtimer_ch;
 193 #endif
 194 #if defined(__OpenBSD__)
 195 # include <sys/timeout.h>
 196 struct timeout ipfr_slowtimer_ch;
 197 #endif
 198 #if defined(__sgi) && defined(_KERNEL)
 199 toid_t ipfr_slowtimer_ch;
 200 #endif
 201
 202 #if defined(__NetBSD__) && (__NetBSD_Version__ >= 106080000) && \
 203     defined(_KERNEL)
 204 # include <sys/conf.h>
 205 const struct cdevsw ipl_cdevsw = {
 206         iplopen, iplclose, iplread, nowrite, iplioctl,
 207         nostop, notty, nopoll, nommap,
 208 };
 209 #endif
 210
 211 #if (_BSDI_VERSION >= 199510) && defined(_KERNEL)
 212 # include <sys/device.h>
 213 # include <sys/conf.h>
 214
 215 struct cfdriver iplcd = {
 216         NULL, "ipl", NULL, NULL, DV_DULL, 0
 217 };
 218
 219 struct devsw iplsw = {
 220         &iplcd,
 221         iplopen, iplclose, iplread, nowrite, iplioctl, noselect, nommap,
 222         nostrat, nodump, nopsize, 0,
 223         nostop
 224 };
 225 #endif /* _BSDI_VERSION >= 199510  && _KERNEL */
 226
 227 #if defined(__NetBSD__) || defined(__OpenBSD__)  || (_BSDI_VERSION >= 199701)
 228 # include <sys/conf.h>
 229 # if defined(NETBSD_PF)
 230 #  include <net/pfil.h>
 231 /*
 232  * We provide the fr_checkp name just to minimize changes later.
 233  */
 234 int (*fr_checkp) __P((ip_t *ip, int hlen, void *ifp, int out, mb_t **mp));
 235 # endif /* NETBSD_PF */
 236 #endif /* __NetBSD__ */
 237
 238
 239 #if defined(__NetBSD_Version__) && (__NetBSD_Version__ >= 105110000) && \
 240     defined(_KERNEL)
 241 # include <net/pfil.h>
 242
 243 static int fr_check_wrapper(void *, struct mbuf **, struct ifnet *, int );
 244
 245 static int fr_check_wrapper(arg, mp, ifp, dir)
 246 void *arg;
 247 struct mbuf **mp;
 248 struct ifnet *ifp;
 249 int dir;
 250 {
 251         struct ip *ip = mtod(*mp, struct ip *);
 252         int rv, hlen = ip->ip_hl << 2;
 253
 254 #if defined(M_CSUM_TCPv4)
 255         /*
 256          * If the packet is out-bound, we can't delay checksums
 257          * here.  For in-bound, the checksum has already been
 258          * validated.
 259          */
 260         if (dir == PFIL_OUT) {
 261                 if ((*mp)->m_pkthdr.csum_flags & (M_CSUM_TCPv4|M_CSUM_UDPv4)) {
 262                         in_delayed_cksum(*mp);
 263                         (*mp)->m_pkthdr.csum_flags &=
 264                             ~(M_CSUM_TCPv4|M_CSUM_UDPv4);
 265                 }
 266         }
 267 #endif /* M_CSUM_TCPv4 */
 268
 269         /*
 270          * We get the packet with all fields in network byte
 271          * order.  We expect ip_len and ip_off to be in host
 272          * order.  We frob them, call the filter, then frob
 273          * them back.
 274          *
 275          * Note, we don't need to update the checksum, because
 276          * it has already been verified.
 277          */
 278         NTOHS(ip->ip_len);
 279         NTOHS(ip->ip_off);
 280
 281         rv = fr_check(ip, hlen, ifp, (dir == PFIL_OUT), mp);
 282
 283         if (rv == 0 && *mp != NULL) {
 284                 ip = mtod(*mp, struct ip *);
 285                 HTONS(ip->ip_len);
 286                 HTONS(ip->ip_off);
 287         }
 288
 289         return (rv);
 290 }
 291
 292 # ifdef USE_INET6
 293 #  include <netinet/ip6.h>
 294
 295 static int fr_check_wrapper6(void *, struct mbuf **, struct ifnet *, int );
 296
 297 static int fr_check_wrapper6(arg, mp, ifp, dir)
 298 void *arg;
 299 struct mbuf **mp;
 300 struct ifnet *ifp;
 301 int dir;
 302 {
 303
 304         return (fr_check(mtod(*mp, struct ip *), sizeof(struct ip6_hdr),
 305             ifp, (dir == PFIL_OUT), mp));
 306 }
 307 # endif
 308 #endif /* __NetBSD_Version >= 105110000 && _KERNEL */
 309 #ifdef  _KERNEL
 310 # if    defined(IPFILTER_LKM) && !defined(__sgi)
 311 int iplidentify(s)
 312 char *s;
 313 {
 314         if (strcmp(s, "ipl") == 0)
 315                 return 1;
 316         return 0;
 317 }
 318 # endif /* IPFILTER_LKM */
 319
 320
 321 /*
 322  * Try to detect the case when compiling for NetBSD with pseudo-device
 323  */
 324 # if defined(__NetBSD__) && defined(PFIL_HOOKS)
 325 void
 326 ipfilterattach(count)
 327 int count;
 328 {
 329
 330         /*
 331          * Do nothing here, really.  The filter will be enabled
 332          * by the SIOCFRENB ioctl.
 333          */
 334 }
 335 # endif
 336
 337
 338 # if defined(__NetBSD__) || defined(__OpenBSD__)
 339 int ipl_enable()
 340 # else
 341 int iplattach()
 342 # endif
 343 {
 344         char *defpass;
 345         int s;
 346 # if defined(__sgi) || (defined(NETBSD_PF) && (__NetBSD_Version__ >= 104200000))
 347         int error = 0;
 348 # endif
 349 #if defined(__NetBSD_Version__) && (__NetBSD_Version__ >= 105110000)
 350         struct pfil_head *ph_inet;
 351 # ifdef USE_INET6
 352         struct pfil_head *ph_inet6;
 353 # endif
 354 #endif
 355
 356         SPL_NET(s);
 357         if (fr_running || (fr_checkp == fr_check)) {
 358                 printf("IP Filter: already initialized\n");
 359                 SPL_X(s);
 360                 return EBUSY;
 361         }
 362
 363 # ifdef IPFILTER_LOG
 364         ipflog_init();
 365 # endif
 366         if (nat_init() == -1) {
 367                 SPL_X(s);
 368                 return EIO;
 369         }
 370         if (fr_stateinit() == -1) {
 371                 SPL_X(s);
 372                 return EIO;
 373         }
 374         if (appr_init() == -1) {
 375                 SPL_X(s);
 376                 return EIO;
 377         }
 378
 379 # ifdef NETBSD_PF
 380 #  if (__NetBSD_Version__ >= 104200000) || (__FreeBSD_version >= 500011)
 381 #   if __NetBSD_Version__ >= 105110000
 382         ph_inet = pfil_head_get(PFIL_TYPE_AF, AF_INET);
 383 #    ifdef USE_INET6
 384         ph_inet6 = pfil_head_get(PFIL_TYPE_AF, AF_INET6);
 385 #    endif
 386         if (ph_inet == NULL
 387 #    ifdef USE_INET6
 388             && ph_inet6 == NULL
 389 #    endif
 390            )
 391                 return ENODEV;
 392
 393         if (ph_inet != NULL)
 394                 error = pfil_add_hook((void *)fr_check_wrapper, NULL,
 395                                       PFIL_IN|PFIL_OUT, ph_inet);
 396         else
 397                 error = 0;
 398 #  else
 399         error = pfil_add_hook((void *)fr_check, PFIL_IN|PFIL_OUT,
 400                               &inetsw[ip_protox[IPPROTO_IP]].pr_pfh);
 401 #  endif
 402         if (error) {
 403 #   ifdef USE_INET6
 404                 goto pfil_error;
 405 #   else
 406                 SPL_X(s);
 407                 appr_unload();
 408                 ip_natunload();
 409                 fr_stateunload();
 410                 return error;
 411 #   endif
 412         }
 413 #  else
 414         pfil_add_hook((void *)fr_check, PFIL_IN|PFIL_OUT);
 415 #  endif
 416 #  ifdef USE_INET6
 417 #   if __NetBSD_Version__ >= 105110000
 418         if (ph_inet6 != NULL)
 419                 error = pfil_add_hook((void *)fr_check_wrapper6, NULL,
 420                                       PFIL_IN|PFIL_OUT, ph_inet6);
 421         else
 422                 error = 0;
 423         if (error) {
 424                 pfil_remove_hook((void *)fr_check_wrapper6, NULL,
 425                                  PFIL_IN|PFIL_OUT, ph_inet6);
 426 #   else
 427         error = pfil_add_hook((void *)fr_check, PFIL_IN|PFIL_OUT,
 428                               &inet6sw[ip6_protox[IPPROTO_IPV6]].pr_pfh);
 429         if (error) {
 430                 pfil_remove_hook((void *)fr_check, PFIL_IN|PFIL_OUT,
 431                                  &inetsw[ip_protox[IPPROTO_IP]].pr_pfh);
 432 #   endif
 433 pfil_error:
 434                 SPL_X(s);
 435                 appr_unload();
 436                 ip_natunload();
 437                 fr_stateunload();
 438                 return error;
 439         }
 440 #  endif
 441 # endif
 442
 443 # ifdef __sgi
 444         error = ipfilter_sgi_attach();
 445         if (error) {
 446                 SPL_X(s);
 447                 appr_unload();
 448                 ip_natunload();
 449                 fr_stateunload();
 450                 return error;
 451         }
 452 # endif
 453
 454         bzero((char *)frcache, sizeof(frcache));
 455         fr_savep = fr_checkp;
 456         fr_checkp = fr_check;
 457         fr_running = 1;
 458
 459         SPL_X(s);
 460         if (fr_pass & FR_PASS)
 461                 defpass = "pass";
 462         else if (fr_pass & FR_BLOCK)
 463                 defpass = "block";
 464         else
 465                 defpass = "no-match -> block";
 466
 467         printf("%s initialized.  Default = %s all, Logging = %s\n",
 468                 ipfilter_version, defpass,
 469 # ifdef IPFILTER_LOG
 470                 "enabled");
 471 # else
 472                 "disabled");
 473 # endif
 474 #ifdef  _KERNEL
 475 # if defined(__NetBSD__) && (__NetBSD_Version__ >= 104230000)
 476         callout_init(&ipfr_slowtimer_ch);
 477         callout_reset(&ipfr_slowtimer_ch, hz / 2, ipfr_slowtimer, NULL);
 478 # else
 479 #  if defined(__OpenBSD__)
 480         timeout_set(&ipfr_slowtimer_ch, ipfr_slowtimer, NULL);
 481         timeout_add(&ipfr_slowtimer_ch, hz/2);
 482 #  else
 483 #   if (__FreeBSD_version >= 300000) || defined(__sgi)
 484         ipfr_slowtimer_ch = timeout(ipfr_slowtimer, NULL, hz/2);
 485 #   else
 486         timeout(ipfr_slowtimer, NULL, hz/2);
 487 #   endif
 488 #  endif
 489 # endif
 490 #endif
 491         return 0;
 492 }
 493
 494
 495 /*
 496  * Disable the filter by removing the hooks from the IP input/output
 497  * stream.
 498  */
 499 # if defined(__NetBSD__)
 500 int ipl_disable()
 501 # else
 502 int ipldetach()
 503 # endif
 504 {
 505         int s, i;
 506 #if defined(NETBSD_PF) && \
 507     ((__NetBSD_Version__ >= 104200000) || (__FreeBSD_version >= 500011))
 508         int error = 0;
 509 # if __NetBSD_Version__ >= 105150000
 510         struct pfil_head *ph_inet = pfil_head_get(PFIL_TYPE_AF, AF_INET);
 511 #  ifdef USE_INET6
 512         struct pfil_head *ph_inet6 = pfil_head_get(PFIL_TYPE_AF, AF_INET6);
 513 #  endif
 514 # endif
 515 #endif
 516
 517 #ifdef  _KERNEL
 518 # if defined(__NetBSD__) && (__NetBSD_Version__ >= 104230000)
 519         callout_stop(&ipfr_slowtimer_ch);
 520 # else
 521 #  if (__FreeBSD_version >= 300000)
 522         untimeout(ipfr_slowtimer, NULL, ipfr_slowtimer_ch);
 523 #  else
 524 #  ifdef __sgi
 525         untimeout(ipfr_slowtimer_ch);
 526 #   else
 527 #    if defined(__OpenBSD__)
 528         timeout_del(&ipfr_slowtimer_ch);
 529 #    else
 530         untimeout(ipfr_slowtimer, NULL);
 531 #    endif /* OpenBSD */
 532 #   endif /* __sgi */
 533 #  endif /* FreeBSD */
 534 # endif /* NetBSD */
 535 #endif
 536         SPL_NET(s);
 537         if (!fr_running)
 538         {
 539                 printf("IP Filter: not initialized\n");
 540                 SPL_X(s);
 541                 return 0;
 542         }
 543
 544         printf("%s unloaded\n", ipfilter_version);
 545
 546         fr_checkp = fr_savep;
 547         i = frflush(IPL_LOGIPF, 0, FR_INQUE|FR_OUTQUE|FR_INACTIVE);
 548         i += frflush(IPL_LOGIPF, 0, FR_INQUE|FR_OUTQUE);
 549         fr_running = 0;
 550
 551 # ifdef NETBSD_PF
 552 #  if ((__NetBSD_Version__ >= 104200000) || (__FreeBSD_version >= 500011))
 553 #   if __NetBSD_Version__ >= 105110000
 554         if (ph_inet != NULL)
 555                 error = pfil_remove_hook((void *)fr_check_wrapper, NULL,
 556                                          PFIL_IN|PFIL_OUT, ph_inet);
 557         else
 558                 error = 0;
 559 #   else
 560         error = pfil_remove_hook((void *)fr_check, PFIL_IN|PFIL_OUT,
 561                                  &inetsw[ip_protox[IPPROTO_IP]].pr_pfh);
 562 #   endif
 563         if (error) {
 564                 SPL_X(s);
 565                 return error;
 566         }
 567 #  else
 568         pfil_remove_hook((void *)fr_check, PFIL_IN|PFIL_OUT);
 569 #  endif
 570 #  ifdef USE_INET6
 571 #   if __NetBSD_Version__ >= 105110000
 572         if (ph_inet6 != NULL)
 573                 error = pfil_remove_hook((void *)fr_check_wrapper6, NULL,
 574                                          PFIL_IN|PFIL_OUT, ph_inet6);
 575         else
 576                 error = 0;
 577 #   else
 578         error = pfil_remove_hook((void *)fr_check, PFIL_IN|PFIL_OUT,
 579                                  &inet6sw[ip6_protox[IPPROTO_IPV6]].pr_pfh);
 580 #   endif
 581         if (error) {
 582                 SPL_X(s);
 583                 return error;
 584         }
 585 #  endif
 586 # endif
 587
 588 # ifdef __sgi
 589         ipfilter_sgi_detach();
 590 # endif
 591
 592         appr_unload();
 593         ipfr_unload();
 594         ip_natunload();
 595         fr_stateunload();
 596         fr_authunload();
 597
 598         SPL_X(s);
 599         return 0;
 600 }
 601 #endif /* _KERNEL */
 602
 603
 604 static  int     frzerostats(data)
 605 caddr_t data;
 606 {
 607         friostat_t fio;
 608         int error;
 609
 610         fr_getstat(&fio);
 611         error = IWCOPYPTR((caddr_t)&fio, data, sizeof(fio));
 612         if (error)
 613                 return EFAULT;
 614
 615         bzero((char *)frstats, sizeof(*frstats) * 2);
 616
 617         return 0;
 618 }
 619
 620
 621 /*
 622  * Filter ioctl interface.
 623  */
 624 #ifdef __sgi
 625 int IPL_EXTERN(ioctl)(dev_t dev, int cmd, caddr_t data, int mode
 626 # ifdef _KERNEL
 627         , cred_t *cp, int *rp
 628 # endif
 629 )
 630 #else
 631 int IPL_EXTERN(ioctl)(dev, cmd, data, mode
 632 # if (defined(_KERNEL) && ((_BSDI_VERSION >= 199510) || (BSD >= 199506) || \
 633        (NetBSD >= 199511) || (__FreeBSD_version >= 220000) || \
 634        defined(__OpenBSD__)))
 635 , p)
 636 struct proc *p;
 637 # else
 638 )
 639 # endif
 640 dev_t dev;
 641 # if defined(__NetBSD__) || defined(__OpenBSD__) || \
 642         (_BSDI_VERSION >= 199701) || (__FreeBSD_version >= 300000)
 643 u_long cmd;
 644 # else
 645 int cmd;
 646 # endif
 647 caddr_t data;
 648 int mode;
 649 #endif /* __sgi */
 650 {
 651 #if defined(_KERNEL) && !SOLARIS
 652         int s;
 653 #endif
 654         int error = 0, unit = 0, tmp;
 655
 656 #if (BSD >= 199306) && defined(_KERNEL)
 657         if ((securelevel >= 3) && (mode & FWRITE))
 658                 return EPERM;
 659 #endif
 660 #ifdef  _KERNEL
 661         unit = GET_MINOR(dev);
 662         if ((IPL_LOGMAX < unit) || (unit < 0))
 663                 return ENXIO;
 664 #else
 665         unit = dev;
 666 #endif
 667
 668         if (fr_running == 0 && (cmd != SIOCFRENB || unit != IPL_LOGIPF))
 669                 return ENODEV;
 670
 671         SPL_NET(s);
 672
 673         if (unit == IPL_LOGNAT) {
 674                 if (fr_running)
 675                         error = nat_ioctl(data, cmd, mode);
 676                 else
 677                         error = EIO;
 678                 SPL_X(s);
 679                 return error;
 680         }
 681         if (unit == IPL_LOGSTATE) {
 682                 if (fr_running)
 683                         error = fr_state_ioctl(data, cmd, mode);
 684                 else
 685                         error = EIO;
 686                 SPL_X(s);
 687                 return error;
 688         }
 689         if (unit == IPL_LOGAUTH) {
 690                 if (!fr_running)
 691                         error = EIO;
 692                 else
 693                         if ((cmd == SIOCADAFR) || (cmd == SIOCRMAFR)) {
 694                                 if (!(mode & FWRITE))  {
 695                                         error = EPERM;
 696                                 } else {
 697                                         error = frrequest(unit, cmd, data,
 698                                                           fr_active);
 699                                 }
 700                         } else {
 701                                 error = fr_auth_ioctl(data, mode, cmd);
 702                         }
 703                 SPL_X(s);
 704                 return error;
 705         }
 706
 707         switch (cmd) {
 708         case FIONREAD :
 709 #ifdef IPFILTER_LOG
 710                 error = IWCOPY((caddr_t)&iplused[IPL_LOGIPF], (caddr_t)data,
 711                                sizeof(iplused[IPL_LOGIPF]));
 712 #endif
 713                 break;
 714 #if (!defined(IPFILTER_LKM) || defined(__NetBSD__)) && defined(_KERNEL)
 715         case SIOCFRENB :
 716         {
 717                 u_int   enable;
 718
 719                 if (!(mode & FWRITE))
 720                         error = EPERM;
 721                 else {
 722                         error = IRCOPY(data, (caddr_t)&enable, sizeof(enable));
 723                         if (error)
 724                                 break;
 725                         if (enable)
 726 # if defined(__NetBSD__) || defined(__OpenBSD__)
 727                                 error = ipl_enable();
 728 # else
 729                                 error = iplattach();
 730 # endif
 731                         else
 732 # if defined(__NetBSD__)
 733                                 error = ipl_disable();
 734 # else
 735                                 error = ipldetach();
 736 # endif
 737                 }
 738                 break;
 739         }
 740 #endif
 741         case SIOCSETFF :
 742                 if (!(mode & FWRITE))
 743                         error = EPERM;
 744                 else
 745                         error = IRCOPY(data, (caddr_t)&fr_flags,
 746                                        sizeof(fr_flags));
 747                 break;
 748         case SIOCGETFF :
 749                 error = IWCOPY((caddr_t)&fr_flags, data, sizeof(fr_flags));
 750                 break;
 751         case SIOCINAFR :
 752         case SIOCRMAFR :
 753         case SIOCADAFR :
 754         case SIOCZRLST :
 755                 if (!(mode & FWRITE))
 756                         error = EPERM;
 757                 else
 758                         error = frrequest(unit, cmd, data, fr_active);
 759                 break;
 760         case SIOCINIFR :
 761         case SIOCRMIFR :
 762         case SIOCADIFR :
 763                 if (!(mode & FWRITE))
 764                         error = EPERM;
 765                 else
 766                         error = frrequest(unit, cmd, data, 1 - fr_active);
 767                 break;
 768         case SIOCSWAPA :
 769                 if (!(mode & FWRITE))
 770                         error = EPERM;
 771                 else {
 772                         bzero((char *)frcache, sizeof(frcache[0]) * 2);
 773                         *(u_int *)data = fr_active;
 774                         fr_active = 1 - fr_active;
 775                 }
 776                 break;
 777         case SIOCGETFS :
 778         {
 779                 friostat_t      fio;
 780
 781                 fr_getstat(&fio);
 782                 error = IWCOPYPTR((caddr_t)&fio, data, sizeof(fio));
 783                 if (error)
 784                         error = EFAULT;
 785                 break;
 786         }
 787         case    SIOCFRZST :
 788                 if (!(mode & FWRITE))
 789                         error = EPERM;
 790                 else
 791                         error = frzerostats(data);
 792                 break;
 793         case    SIOCIPFFL :
 794                 if (!(mode & FWRITE))
 795                         error = EPERM;
 796                 else {
 797                         error = IRCOPY(data, (caddr_t)&tmp, sizeof(tmp));
 798                         if (!error) {
 799                                 tmp = frflush(unit, 4, tmp);
 800                                 error = IWCOPY((caddr_t)&tmp, data,
 801                                                sizeof(tmp));
 802                         }
 803                 }
 804                 break;
 805 #ifdef  USE_INET6
 806         case    SIOCIPFL6 :
 807                 if (!(mode & FWRITE))
 808                         error = EPERM;
 809                 else {
 810                         error = IRCOPY(data, (caddr_t)&tmp, sizeof(tmp));
 811                         if (!error) {
 812                                 tmp = frflush(unit, 6, tmp);
 813                                 error = IWCOPY((caddr_t)&tmp, data,
 814                                                sizeof(tmp));
 815                         }
 816                 }
 817                 break;
 818 #endif
 819         case SIOCSTLCK :
 820                 error = IRCOPY(data, (caddr_t)&tmp, sizeof(tmp));
 821                 if (!error) {
 822                         fr_state_lock = tmp;
 823                         fr_nat_lock = tmp;
 824                         fr_frag_lock = tmp;
 825                         fr_auth_lock = tmp;
 826                 } else
 827                         error = EFAULT;
 828                 break;
 829 #ifdef  IPFILTER_LOG
 830         case    SIOCIPFFB :
 831                 if (!(mode & FWRITE))
 832                         error = EPERM;
 833                 else
 834                         *(int *)data = ipflog_clear(unit);
 835                 break;
 836 #endif /* IPFILTER_LOG */
 837         case SIOCGFRST :
 838                 error = IWCOPYPTR((caddr_t)ipfr_fragstats(), data,
 839                                   sizeof(ipfrstat_t));
 840                 if (error)
 841                         error = EFAULT;
 842                 break;
 843         case SIOCFRSYN :
 844                 if (!(mode & FWRITE))
 845                         error = EPERM;
 846                 else {
 847 #if defined(_KERNEL) && defined(__sgi)
 848                         ipfsync();
 849 #endif
 850                         frsync();
 851                 }
 852                 break;
 853         default :
 854                 error = EINVAL;
 855                 break;
 856         }
 857         SPL_X(s);
 858         return error;
 859 }
 860
 861
 862 void fr_forgetifp(ifp)
 863 void *ifp;
 864 {
 865         register frentry_t *f;
 866
 867         WRITE_ENTER(&ipf_mutex);
 868         for (f = ipacct[0][fr_active]; (f != NULL); f = f->fr_next)
 869                 if (f->fr_ifa == ifp)
 870                         f->fr_ifa = (void *)-1;
 871         for (f = ipacct[1][fr_active]; (f != NULL); f = f->fr_next)
 872                 if (f->fr_ifa == ifp)
 873                         f->fr_ifa = (void *)-1;
 874         for (f = ipfilter[0][fr_active]; (f != NULL); f = f->fr_next)
 875                 if (f->fr_ifa == ifp)
 876                         f->fr_ifa = (void *)-1;
 877         for (f = ipfilter[1][fr_active]; (f != NULL); f = f->fr_next)
 878                 if (f->fr_ifa == ifp)
 879                         f->fr_ifa = (void *)-1;
 880 #ifdef  USE_INET6
 881         for (f = ipacct6[0][fr_active]; (f != NULL); f = f->fr_next)
 882                 if (f->fr_ifa == ifp)
 883                         f->fr_ifa = (void *)-1;
 884         for (f = ipacct6[1][fr_active]; (f != NULL); f = f->fr_next)
 885                 if (f->fr_ifa == ifp)
 886                         f->fr_ifa = (void *)-1;
 887         for (f = ipfilter6[0][fr_active]; (f != NULL); f = f->fr_next)
 888                 if (f->fr_ifa == ifp)
 889                         f->fr_ifa = (void *)-1;
 890         for (f = ipfilter6[1][fr_active]; (f != NULL); f = f->fr_next)
 891                 if (f->fr_ifa == ifp)
 892                         f->fr_ifa = (void *)-1;
 893 #endif
 894         RWLOCK_EXIT(&ipf_mutex);
 895         ip_natsync(ifp);
 896 }
 897
 898
 899 static int frrequest(unit, req, data, set)
 900 int unit;
 901 #if defined(__NetBSD__) || defined(__OpenBSD__) || (__FreeBSD_version >= 300003)
 902 u_long req;
 903 #else
 904 int req;
 905 #endif
 906 int set;
 907 caddr_t data;
 908 {
 909         register frentry_t *fp, *f, **fprev;
 910         register frentry_t **ftail;
 911         frgroup_t *fg = NULL;
 912         int error = 0, in, i;
 913         u_int   *p, *pp;
 914         frentry_t frd;
 915         frdest_t *fdp;
 916         u_int group;
 917
 918         fp = &frd;
 919         error = IRCOPYPTR(data, (caddr_t)fp, sizeof(*fp));
 920         if (error)
 921                 return EFAULT;
 922         fp->fr_ref = 0;
 923 #if (BSD >= 199306) && defined(_KERNEL)
 924         if ((securelevel > 0) && (fp->fr_func != NULL))
 925                 return EPERM;
 926 #endif
 927
 928         /*
 929          * Check that the group number does exist and that if a head group
 930          * has been specified, doesn't exist.
 931          */
 932         if ((req != SIOCZRLST) && ((req == SIOCINAFR) || (req == SIOCINIFR) ||
 933              (req == SIOCADAFR) || (req == SIOCADIFR)) && fp->fr_grhead &&
 934             fr_findgroup((u_int)fp->fr_grhead, fp->fr_flags, unit, set, NULL))
 935                 return EEXIST;
 936         if ((req != SIOCZRLST) && fp->fr_group &&
 937             !fr_findgroup((u_int)fp->fr_group, fp->fr_flags, unit, set, NULL))
 938                 return ESRCH;
 939
 940         in = (fp->fr_flags & FR_INQUE) ? 0 : 1;
 941
 942         if (unit == IPL_LOGAUTH)
 943                 ftail = fprev = &ipauth;
 944         else if ((fp->fr_flags & FR_ACCOUNT) && (fp->fr_v == 4))
 945                 ftail = fprev = &ipacct[in][set];
 946         else if ((fp->fr_flags & (FR_OUTQUE|FR_INQUE)) && (fp->fr_v == 4))
 947                 ftail = fprev = &ipfilter[in][set];
 948 #ifdef  USE_INET6
 949         else if ((fp->fr_flags & FR_ACCOUNT) && (fp->fr_v == 6))
 950                 ftail = fprev = &ipacct6[in][set];
 951         else if ((fp->fr_flags & (FR_OUTQUE|FR_INQUE)) && (fp->fr_v == 6))
 952                 ftail = fprev = &ipfilter6[in][set];
 953 #endif
 954         else
 955                 return ESRCH;
 956
 957         if ((group = fp->fr_group)) {
 958                 if (!(fg = fr_findgroup(group, fp->fr_flags, unit, set, NULL)))
 959                         return ESRCH;
 960                 ftail = fprev = fg->fg_start;
 961         }
 962
 963         bzero((char *)frcache, sizeof(frcache[0]) * 2);
 964
 965         for (i = 0; i < 4; i++) {
 966                 if ((fp->fr_ifnames[i][1] == '\0') &&
 967                     ((fp->fr_ifnames[i][0] == '-') ||
 968                      (fp->fr_ifnames[i][0] == '*'))) {
 969                         fp->fr_ifas[i] = NULL;
 970                 } else if (*fp->fr_ifnames[i]) {
 971                         fp->fr_ifas[i] = GETUNIT(fp->fr_ifnames[i], fp->fr_v);
 972                         if (!fp->fr_ifas[i])
 973                                 fp->fr_ifas[i] = (void *)-1;
 974                 }
 975         }
 976
 977         fdp = &fp->fr_dif;
 978         fp->fr_flags &= ~FR_DUP;
 979         if (*fdp->fd_ifname) {
 980                 fdp->fd_ifp = GETUNIT(fdp->fd_ifname, fp->fr_v);
 981                 if (!fdp->fd_ifp)
 982                         fdp->fd_ifp = (struct ifnet *)-1;
 983                 else
 984                         fp->fr_flags |= FR_DUP;
 985         }
 986
 987         fdp = &fp->fr_tif;
 988         if (*fdp->fd_ifname) {
 989                 fdp->fd_ifp = GETUNIT(fdp->fd_ifname, fp->fr_v);
 990                 if (!fdp->fd_ifp)
 991                         fdp->fd_ifp = (struct ifnet *)-1;
 992         }
 993
 994         /*
 995          * Look for a matching filter rule, but don't include the next or
 996          * interface pointer in the comparison (fr_next, fr_ifa).
 997          */
 998         for (fp->fr_cksum = 0, p = (u_int *)&fp->fr_ip, pp = &fp->fr_cksum;
 999              p < pp; p++)
1000                 fp->fr_cksum += *p;
1001
1002         for (; (f = *ftail); ftail = &f->fr_next)
1003                 if ((fp->fr_cksum == f->fr_cksum) &&
1004                     !bcmp((char *)&f->fr_ip, (char *)&fp->fr_ip, FR_CMPSIZ))
1005                         break;
1006
1007         /*
1008          * If zero'ing statistics, copy current to caller and zero.
1009          */
1010         if (req == SIOCZRLST) {
1011                 if (!f)
1012                         return ESRCH;
1013                 error = IWCOPYPTR((caddr_t)f, data, sizeof(*f));
1014                 if (error)
1015                         return EFAULT;
1016                 f->fr_hits = 0;
1017                 f->fr_bytes = 0;
1018                 return 0;
1019         }
1020
1021         if (!f) {
1022                 if (req != SIOCINAFR && req != SIOCINIFR)
1023                         while ((f = *ftail))
1024                                 ftail = &f->fr_next;
1025                 else {
1026                         if (fp->fr_hits) {
1027                                 ftail = fprev;
1028                                 while (--fp->fr_hits && (f = *ftail))
1029                                         ftail = &f->fr_next;
1030                         }
1031                         f = NULL;
1032                 }
1033         }
1034
1035         if (req == SIOCRMAFR || req == SIOCRMIFR) {
1036                 if (!f)
1037                         error = ESRCH;
1038                 else {
1039                         /*
1040                          * Only return EBUSY if there is a group list, else
1041                          * it's probably just state information referencing
1042                          * the rule.
1043                          */
1044                         if ((f->fr_ref > 1) && f->fr_grp)
1045                                 return EBUSY;
1046                         if (fg && fg->fg_head)
1047                                 fg->fg_head->fr_ref--;
1048                         if (unit == IPL_LOGAUTH) {
1049                                 return fr_preauthcmd(req, f, ftail);
1050                         }
1051                         if (f->fr_grhead)
1052                                 fr_delgroup((u_int)f->fr_grhead, fp->fr_flags,
1053                                             unit, set);
1054                         fixskip(fprev, f, -1);
1055                         *ftail = f->fr_next;
1056                         f->fr_next = NULL;
1057                         f->fr_ref--;
1058                         if (f->fr_ref == 0)
1059                                 KFREE(f);
1060                 }
1061         } else {
1062                 if (f)
1063                         error = EEXIST;
1064                 else {
1065                         if (unit == IPL_LOGAUTH) {
1066                                 return fr_preauthcmd(req, fp, ftail);
1067                         }
1068                         KMALLOC(f, frentry_t *);
1069                         if (f != NULL) {
1070                                 if (fg && fg->fg_head)
1071                                         fg->fg_head->fr_ref++;
1072                                 bcopy((char *)fp, (char *)f, sizeof(*f));
1073                                 f->fr_ref = 1;
1074                                 f->fr_hits = 0;
1075                                 f->fr_next = *ftail;
1076                                 *ftail = f;
1077                                 if (req == SIOCINIFR || req == SIOCINAFR)
1078                                         fixskip(fprev, f, 1);
1079                                 f->fr_grp = NULL;
1080                                 if ((group = f->fr_grhead))
1081                                         fg = fr_addgroup(group, f, unit, set);
1082                         } else
1083                                 error = ENOMEM;
1084                 }
1085         }
1086         return (error);
1087 }
1088
1089
1090 #ifdef  _KERNEL
1091 /*
1092  * routines below for saving IP headers to buffer
1093  */
1094 # ifdef __sgi
1095 #  ifdef _KERNEL
1096 int IPL_EXTERN(open)(dev_t *pdev, int flags, int devtype, cred_t *cp)
1097 #  else
1098 int IPL_EXTERN(open)(dev_t dev, int flags)
1099 #  endif
1100 # else
1101 int IPL_EXTERN(open)(dev, flags
1102 #  if ((_BSDI_VERSION >= 199510) || (BSD >= 199506) || (NetBSD >= 199511) || \
1103      (__FreeBSD_version >= 220000) || defined(__OpenBSD__)) && defined(_KERNEL)
1104 , devtype, p)
1105 int devtype;
1106 struct proc *p;
1107 #  else
1108 )
1109 #  endif
1110 dev_t dev;
1111 int flags;
1112 # endif /* __sgi */
1113 {
1114 # if defined(__sgi) && defined(_KERNEL)
1115         u_int min = geteminor(*pdev);
1116 # else
1117         u_int min = GET_MINOR(dev);
1118 # endif
1119
1120         if (IPL_LOGMAX < min)
1121                 min = ENXIO;
1122         else
1123                 min = 0;
1124         return min;
1125 }
1126
1127
1128 # ifdef __sgi
1129 int IPL_EXTERN(close)(dev_t dev, int flags, int devtype, cred_t *cp)
1130 #else
1131 int IPL_EXTERN(close)(dev, flags
1132 #  if ((_BSDI_VERSION >= 199510) || (BSD >= 199506) || (NetBSD >= 199511) || \
1133      (__FreeBSD_version >= 220000) || defined(__OpenBSD__)) && defined(_KERNEL)
1134 , devtype, p)
1135 int devtype;
1136 struct proc *p;
1137 #  else
1138 )
1139 #  endif
1140 dev_t dev;
1141 int flags;
1142 # endif /* __sgi */
1143 {
1144         u_int   min = GET_MINOR(dev);
1145
1146         if (IPL_LOGMAX < min)
1147                 min = ENXIO;
1148         else
1149                 min = 0;
1150         return min;
1151 }
1152
1153 /*
1154  * iplread/ipllog
1155  * both of these must operate with at least splnet() lest they be
1156  * called during packet processing and cause an inconsistancy to appear in
1157  * the filter lists.
1158  */
1159 # ifdef __sgi
1160 int IPL_EXTERN(read)(dev_t dev, uio_t *uio, cred_t *crp)
1161 # else
1162 #  if BSD >= 199306
1163 int IPL_EXTERN(read)(dev, uio, ioflag)
1164 int ioflag;
1165 #  else
1166 int IPL_EXTERN(read)(dev, uio)
1167 #  endif
1168 dev_t dev;
1169 register struct uio *uio;
1170 # endif /* __sgi */
1171 {
1172 # ifdef IPFILTER_LOG
1173         return ipflog_read(GET_MINOR(dev), uio);
1174 # else
1175         return ENXIO;
1176 # endif
1177 }
1178
1179
1180 /*
1181  * send_reset - this could conceivably be a call to tcp_respond(), but that
1182  * requires a large amount of setting up and isn't any more efficient.
1183  */
1184 int send_reset(oip, fin)
1185 struct ip *oip;
1186 fr_info_t *fin;
1187 {
1188         struct tcphdr *tcp, *tcp2;
1189         int tlen = 0, hlen;
1190         struct mbuf *m;
1191 #ifdef  USE_INET6
1192         ip6_t *ip6, *oip6 = (ip6_t *)oip;
1193 #endif
1194         ip_t *ip;
1195
1196         tcp = (struct tcphdr *)fin->fin_dp;
1197         if (tcp->th_flags & TH_RST)
1198                 return -1;              /* feedback loop */
1199 # if    (BSD < 199306) || defined(__sgi)
1200         m = m_get(M_DONTWAIT, MT_HEADER);
1201 # else
1202         m = m_gethdr(M_DONTWAIT, MT_HEADER);
1203 # endif
1204         if (m == NULL)
1205                 return ENOBUFS;
1206         if (m == NULL)
1207                 return -1;
1208
1209         tlen = fin->fin_dlen - (tcp->th_off << 2) +
1210                         ((tcp->th_flags & TH_SYN) ? 1 : 0) +
1211                         ((tcp->th_flags & TH_FIN) ? 1 : 0);
1212
1213 #ifdef  USE_INET6
1214         hlen = (fin->fin_v == 6) ? sizeof(ip6_t) : sizeof(ip_t);
1215 #else
1216         hlen = sizeof(ip_t);
1217 #endif
1218         m->m_len = sizeof(*tcp2) + hlen;
1219 # if    BSD >= 199306
1220         m->m_data += max_linkhdr;
1221         m->m_pkthdr.len = m->m_len;
1222         m->m_pkthdr.rcvif = (struct ifnet *)0;
1223 # endif
1224         ip = mtod(m, struct ip *);
1225 # ifdef USE_INET6
1226         ip6 = (ip6_t *)ip;
1227 # endif
1228         bzero((char *)ip, sizeof(*tcp2) + hlen);
1229         tcp2 = (struct tcphdr *)((char *)ip + hlen);
1230
1231         tcp2->th_sport = tcp->th_dport;
1232         tcp2->th_dport = tcp->th_sport;
1233         if (tcp->th_flags & TH_ACK) {
1234                 tcp2->th_seq = tcp->th_ack;
1235                 tcp2->th_flags = TH_RST;
1236         } else {
1237                 tcp2->th_ack = ntohl(tcp->th_seq);
1238                 tcp2->th_ack += tlen;
1239                 tcp2->th_ack = htonl(tcp2->th_ack);
1240                 tcp2->th_flags = TH_RST|TH_ACK;
1241         }
1242         tcp2->th_off = sizeof(*tcp2) >> 2;
1243 # ifdef USE_INET6
1244         if (fin->fin_v == 6) {
1245                 ip6->ip6_plen = htons(sizeof(struct tcphdr));
1246                 ip6->ip6_nxt = IPPROTO_TCP;
1247                 ip6->ip6_src = oip6->ip6_dst;
1248                 ip6->ip6_dst = oip6->ip6_src;
1249                 tcp2->th_sum = in6_cksum(m, IPPROTO_TCP,
1250                                          sizeof(*ip6), sizeof(*tcp2));
1251                 return send_ip(oip, fin, &m);
1252         }
1253 # endif
1254         ip->ip_p = IPPROTO_TCP;
1255         ip->ip_len = htons(sizeof(struct tcphdr));
1256         ip->ip_src.s_addr = oip->ip_dst.s_addr;
1257         ip->ip_dst.s_addr = oip->ip_src.s_addr;
1258         tcp2->th_sum = in_cksum(m, hlen + sizeof(*tcp2));
1259         ip->ip_len = hlen + sizeof(*tcp2);
1260         return send_ip(oip, fin, &m);
1261 }
1262
1263
1264 /*
1265  * Send an IP(v4/v6) datagram out into the network
1266  */
1267 static int send_ip(oip, fin, mp)
1268 ip_t *oip;
1269 fr_info_t *fin;
1270 struct mbuf **mp;
1271 {
1272         struct mbuf *m = *mp;
1273         int error, hlen;
1274         fr_info_t frn;
1275         ip_t *ip;
1276
1277         bzero((char *)&frn, sizeof(frn));
1278         frn.fin_ifp = fin->fin_ifp;
1279         frn.fin_v = fin->fin_v;
1280         frn.fin_out = fin->fin_out;
1281         frn.fin_mp = fin->fin_mp;
1282
1283         ip = mtod(m, ip_t *);
1284         hlen = sizeof(*ip);
1285
1286         ip->ip_v = fin->fin_v;
1287         if (ip->ip_v == 4) {
1288                 ip->ip_hl = (sizeof(*oip) >> 2);
1289                 ip->ip_v = IPVERSION;
1290                 ip->ip_tos = oip->ip_tos;
1291                 ip->ip_id = oip->ip_id;
1292
1293 # if defined(__NetBSD__) || \
1294      (defined(__OpenBSD__) && (OpenBSD >= 200012))
1295                 if (ip_mtudisc != 0)
1296                         ip->ip_off = IP_DF;
1297 # else
1298 #  if defined(__sgi)
1299                 if (ip->ip_p == IPPROTO_TCP && tcp_mtudisc != 0)
1300                         ip->ip_off = IP_DF;
1301 #  endif
1302 # endif
1303
1304 # if (BSD < 199306) || defined(__sgi)
1305                 ip->ip_ttl = tcp_ttl;
1306 # else
1307                 ip->ip_ttl = ip_defttl;
1308 # endif
1309                 ip->ip_sum = 0;
1310                 frn.fin_dp = (char *)(ip + 1);
1311         }
1312 # ifdef USE_INET6
1313         else if (ip->ip_v == 6) {
1314                 ip6_t *ip6 = (ip6_t *)ip;
1315
1316                 hlen = sizeof(*ip6);
1317                 ip6->ip6_hlim = 127;
1318                 frn.fin_dp = (char *)(ip6 + 1);
1319         }
1320 # endif
1321 # ifdef IPSEC
1322         m->m_pkthdr.rcvif = NULL;
1323 # endif
1324
1325         fr_makefrip(hlen, ip, &frn);
1326
1327         error = ipfr_fastroute(m, mp, &frn, NULL);
1328         return error;
1329 }
1330
1331
1332 int send_icmp_err(oip, type, fin, dst)
1333 ip_t *oip;
1334 int type;
1335 fr_info_t *fin;
1336 int dst;
1337 {
1338         int err, hlen = 0, xtra = 0, iclen, ohlen = 0, avail, code;
1339         u_short shlen, slen = 0, soff = 0;
1340         struct in_addr dst4;
1341         struct icmp *icmp;
1342         struct mbuf *m;
1343         void *ifp;
1344 #ifdef USE_INET6
1345         ip6_t *ip6, *oip6 = (ip6_t *)oip;
1346         struct in6_addr dst6;
1347 #endif
1348         ip_t *ip;
1349
1350         if ((type < 0) || (type > ICMP_MAXTYPE))
1351                 return -1;
1352
1353         code = fin->fin_icode;
1354 #ifdef USE_INET6
1355         if ((code < 0) || (code > sizeof(icmptoicmp6unreach)/sizeof(int)))
1356                 return -1;
1357 #endif
1358
1359         avail = 0;
1360         m = NULL;
1361         ifp = fin->fin_ifp;
1362         if (fin->fin_v == 4) {
1363                 if ((oip->ip_p == IPPROTO_ICMP) &&
1364                     !(fin->fin_fi.fi_fl & FI_SHORT))
1365                         switch (ntohs(fin->fin_data[0]) >> 8)
1366                         {
1367                         case ICMP_ECHO :
1368                         case ICMP_TSTAMP :
1369                         case ICMP_IREQ :
1370                         case ICMP_MASKREQ :
1371                                 break;
1372                         default :
1373                                 return 0;
1374                         }
1375
1376 # if    (BSD < 199306) || defined(__sgi)
1377                 avail = MLEN;
1378                 m = m_get(M_DONTWAIT, MT_HEADER);
1379 # else
1380                 avail = MHLEN;
1381                 m = m_gethdr(M_DONTWAIT, MT_HEADER);
1382 # endif
1383                 if (m == NULL)
1384                         return ENOBUFS;
1385
1386                 if (dst == 0) {
1387                         if (fr_ifpaddr(4, ifp, &dst4) == -1)
1388                                 return -1;
1389                 } else
1390                         dst4.s_addr = oip->ip_dst.s_addr;
1391
1392                 hlen = sizeof(ip_t);
1393                 ohlen = oip->ip_hl << 2;
1394                 xtra = 8;
1395         }
1396
1397 #ifdef  USE_INET6
1398         else if (fin->fin_v == 6) {
1399                 hlen = sizeof(ip6_t);
1400                 ohlen = sizeof(ip6_t);
1401                 type = icmptoicmp6types[type];
1402                 if (type == ICMP6_DST_UNREACH)
1403                         code = icmptoicmp6unreach[code];
1404
1405                 MGETHDR(m, M_DONTWAIT, MT_HEADER);
1406                 if (!m)
1407                         return ENOBUFS;
1408
1409                 MCLGET(m, M_DONTWAIT);
1410                 if ((m->m_flags & M_EXT) == 0) {
1411                         m_freem(m);
1412                         return ENOBUFS;
1413                 }
1414 # ifdef M_TRAILINGSPACE
1415                 m->m_len = 0;
1416                 avail = M_TRAILINGSPACE(m);
1417 # else
1418                 avail = (m->m_flags & M_EXT) ? MCLBYTES : MHLEN;
1419 # endif
1420                 xtra = MIN(ntohs(oip6->ip6_plen) + sizeof(ip6_t),
1421                            avail - hlen - sizeof(*icmp) - max_linkhdr);
1422                 if (dst == 0) {
1423                         if (fr_ifpaddr(6, ifp, (struct in_addr *)&dst6) == -1)
1424                                 return -1;
1425                 } else
1426                         dst6 = oip6->ip6_dst;
1427         }
1428 #endif
1429
1430         iclen = hlen + sizeof(*icmp);
1431 # if    BSD >= 199306
1432         avail -= (max_linkhdr + iclen);
1433         m->m_data += max_linkhdr;
1434         m->m_pkthdr.rcvif = (struct ifnet *)0;
1435         if (xtra > avail)
1436                 xtra = avail;
1437         iclen += xtra;
1438         m->m_pkthdr.len = iclen;
1439 #else
1440         avail -= (m->m_off + iclen);
1441         if (xtra > avail)
1442                 xtra = avail;
1443         iclen += xtra;
1444 #endif
1445         m->m_len = iclen;
1446         ip = mtod(m, ip_t *);
1447         icmp = (struct icmp *)((char *)ip + hlen);
1448         bzero((char *)ip, iclen);
1449
1450         icmp->icmp_type = type;
1451         icmp->icmp_code = fin->fin_icode;
1452         icmp->icmp_cksum = 0;
1453 #ifdef  icmp_nextmtu
1454         if (type == ICMP_UNREACH &&
1455             fin->fin_icode == ICMP_UNREACH_NEEDFRAG && ifp)
1456                 icmp->icmp_nextmtu = htons(((struct ifnet *) ifp)->if_mtu);
1457 #endif
1458
1459         if (avail) {
1460                 bcopy((char *)oip, (char *)&icmp->icmp_ip, MIN(ohlen, avail));
1461                 avail -= MIN(ohlen, avail);
1462         }
1463
1464 #ifdef  USE_INET6
1465         ip6 = (ip6_t *)ip;
1466         if (fin->fin_v == 6) {
1467                 ip6->ip6_flow = 0;
1468                 ip6->ip6_plen = htons(iclen - hlen);
1469                 ip6->ip6_nxt = IPPROTO_ICMPV6;
1470                 ip6->ip6_hlim = 0;
1471                 ip6->ip6_src = dst6;
1472                 ip6->ip6_dst = oip6->ip6_src;
1473                 if (avail)
1474                         bcopy((char *)oip + ohlen,
1475                               (char *)&icmp->icmp_ip + ohlen, avail);
1476                 icmp->icmp_cksum = in6_cksum(m, IPPROTO_ICMPV6,
1477                                              sizeof(*ip6), iclen - hlen);
1478         } else
1479 #endif
1480         {
1481                 slen = oip->ip_len;
1482                 oip->ip_len = htons(oip->ip_len);
1483                 soff = oip->ip_off;
1484                 oip->ip_off = htons(ip->ip_off);
1485
1486                 ip->ip_src.s_addr = dst4.s_addr;
1487                 ip->ip_dst.s_addr = oip->ip_src.s_addr;
1488
1489                 if (avail > 8)
1490                         avail = 8;
1491                 if (avail)
1492                         bcopy((char *)oip + ohlen,
1493                               (char *)&icmp->icmp_ip + ohlen, avail);
1494                 icmp->icmp_cksum = ipf_cksum((u_short *)icmp,
1495                                              sizeof(*icmp) + 8);
1496                 ip->ip_len = iclen;
1497                 ip->ip_p = IPPROTO_ICMP;
1498         }
1499
1500         shlen = fin->fin_hlen;
1501         fin->fin_hlen = hlen;
1502         err = send_ip(oip, fin, &m);
1503         fin->fin_hlen = shlen;
1504 #ifdef  USE_INET6
1505         if (fin->fin_v == 4)
1506 #endif
1507         {
1508                 oip->ip_len = slen;
1509                 oip->ip_off = soff;
1510         }
1511         return err;
1512 }
1513
1514
1515 # if !defined(IPFILTER_LKM) && !defined(__sgi) && \
1516      (!defined(__FreeBSD_version) || (__FreeBSD_version < 300000))
1517 #  if   (BSD < 199306)
1518 int iplinit __P((void));
1519
1520 int
1521 #  else
1522 void iplinit __P((void));
1523
1524 void
1525 #  endif
1526 iplinit()
1527 {
1528
1529 #  if defined(__NetBSD__) || defined(__OpenBSD__)
1530         if (ipl_enable() != 0)
1531 #  else
1532         if (iplattach() != 0)
1533 #  endif
1534         {
1535                 printf("IP Filter failed to attach\n");
1536         }
1537         ip_init();
1538 }
1539 # endif /* ! __NetBSD__ */
1540
1541
1542 /*
1543  * Return the length of the entire mbuf.
1544  */
1545 size_t mbufchainlen(m0)
1546 register struct mbuf *m0;
1547 {
1548 #if BSD >= 199306
1549         return m0->m_pkthdr.len;
1550 #else
1551         register size_t len = 0;
1552
1553         for (; m0; m0 = m0->m_next)
1554                 len += m0->m_len;
1555         return len;
1556 #endif
1557 }
1558
1559
1560 int ipfr_fastroute(m0, mpp, fin, fdp)
1561 struct mbuf *m0, **mpp;
1562 fr_info_t *fin;
1563 frdest_t *fdp;
1564 {
1565         register struct ip *ip, *mhip;
1566         register struct mbuf *m = m0;
1567         register struct route *ro;
1568         int len, off, error = 0, hlen, code;
1569         struct ifnet *ifp, *sifp;
1570         struct sockaddr_in *dst;
1571         struct route iproute;
1572         frentry_t *fr;
1573
1574         ip = NULL;
1575         ro = NULL;
1576         ifp = NULL;
1577         ro = &iproute;
1578         ro->ro_rt = NULL;
1579
1580 #ifdef  USE_INET6
1581         if (fin->fin_v == 6) {
1582                 error = ipfr_fastroute6(m0, mpp, fin, fdp);
1583                 if (error != 0)
1584                         goto bad;
1585                 goto done;
1586         }
1587 #else
1588         if (fin->fin_v == 6)
1589                 goto bad;
1590 #endif
1591
1592 #ifdef  M_WRITABLE
1593         /*
1594          * HOT FIX/KLUDGE:
1595          *
1596          * If the mbuf we're about to send is not writable (because of
1597          * a cluster reference, for example) we'll need to make a copy
1598          * of it since this routine modifies the contents.
1599          *
1600          * If you have non-crappy network hardware that can transmit data
1601          * from the mbuf, rather than making a copy, this is gonna be a
1602          * problem.
1603          */
1604         if (M_WRITABLE(m) == 0) {
1605                 if ((m0 = m_dup(m, M_DONTWAIT)) != NULL) {
1606                         m_freem(*mpp);
1607                         *mpp = m0;
1608                         m = m0;
1609                 } else {
1610                         error = ENOBUFS;
1611                         m_freem(*mpp);
1612                         goto done;
1613                 }
1614         }
1615 #endif
1616
1617         hlen = fin->fin_hlen;
1618         ip = mtod(m0, struct ip *);
1619
1620 #if defined(__NetBSD__) && defined(M_CSUM_IPv4)
1621         /*
1622          * Clear any in-bound checksum flags for this packet.
1623          */
1624 # if (__NetBSD_Version__ > 105009999)
1625         m0->m_pkthdr.csum_flags = 0;
1626 # else
1627         m0->m_pkthdr.csuminfo = 0;
1628 # endif
1629 #endif /* __NetBSD__ && M_CSUM_IPv4 */
1630
1631         /*
1632          * Route packet.
1633          */
1634 #if defined(__sgi) && (IRIX >= 605)
1635         ROUTE_RDLOCK();
1636 #endif
1637         bzero((caddr_t)ro, sizeof (*ro));
1638         dst = (struct sockaddr_in *)&ro->ro_dst;
1639         dst->sin_family = AF_INET;
1640         dst->sin_addr = ip->ip_dst;
1641
1642         fr = fin->fin_fr;
1643         if (fdp != NULL)
1644                 ifp = fdp->fd_ifp;
1645         else
1646                 ifp = fin->fin_ifp;
1647
1648         /*
1649          * In case we're here due to "to <if>" being used with "keep state",
1650          * check that we're going in the correct direction.
1651          */
1652         if ((fr != NULL) && (fin->fin_rev != 0)) {
1653                 if ((ifp != NULL) && (fdp == &fr->fr_tif))
1654                         return 0;
1655         } else if (fdp != NULL) {
1656                 if (fdp->fd_ip.s_addr != 0)
1657                         dst->sin_addr = fdp->fd_ip;
1658         }
1659
1660 # if BSD >= 199306
1661         dst->sin_len = sizeof(*dst);
1662 # endif
1663 # if    (BSD >= 199306) && !defined(__NetBSD__) && !defined(__bsdi__) && \
1664         !defined(__OpenBSD__)
1665 #  ifdef        RTF_CLONING
1666         rtalloc_ign(ro, RTF_CLONING);
1667 #  else
1668         rtalloc_ign(ro, RTF_PRCLONING);
1669 #  endif
1670 # else
1671         rtalloc(ro);
1672 # endif
1673
1674 #if defined(__sgi) && (IRIX > 602)
1675         ROUTE_UNLOCK();
1676 #endif
1677
1678         if (!ifp) {
1679                 if (!fr || !(fr->fr_flags & FR_FASTROUTE)) {
1680                         error = -2;
1681                         goto bad;
1682                 }
1683         }
1684
1685         if ((ifp == NULL) && (ro->ro_rt != NULL))
1686                 ifp = ro->ro_rt->rt_ifp;
1687
1688         if ((ro->ro_rt == NULL) || (ifp == NULL)) {
1689                 if (in_localaddr(ip->ip_dst))
1690                         error = EHOSTUNREACH;
1691                 else
1692                         error = ENETUNREACH;
1693                 goto bad;
1694         }
1695
1696         if (ro->ro_rt->rt_flags & RTF_GATEWAY) {
1697 #if BSD >= 199306
1698                 dst = (struct sockaddr_in *)ro->ro_rt->rt_gateway;
1699 #else
1700                 dst = (struct sockaddr_in *)&ro->ro_rt->rt_gateway;
1701 #endif
1702         }
1703         ro->ro_rt->rt_use++;
1704
1705         /*
1706          * For input packets which are being "fastrouted", they won't
1707          * go back through output filtering and miss their chance to get
1708          * NAT'd and counted.
1709          */
1710         if (fin->fin_out == 0) {
1711                 sifp = fin->fin_ifp;
1712                 fin->fin_ifp = ifp;
1713                 fin->fin_out = 1;
1714                 if ((fin->fin_fr = ipacct[1][fr_active]) &&
1715                     (fr_scanlist(FR_NOMATCH, ip, fin, m) & FR_ACCOUNT)) {
1716                         ATOMIC_INCL(frstats[1].fr_acct);
1717                 }
1718                 fin->fin_fr = NULL;
1719                 if (!fr || !(fr->fr_flags & FR_RETMASK))
1720                         (void) fr_checkstate(ip, fin);
1721                 (void) ip_natout(ip, fin);
1722                 fin->fin_ifp = sifp;
1723         } else
1724                 ip->ip_sum = 0;
1725         /*
1726          * If small enough for interface, can just send directly.
1727          */
1728         if (ip->ip_len <= ifp->if_mtu) {
1729 # ifndef sparc
1730 #  if (!defined(__FreeBSD__) && !(_BSDI_VERSION >= 199510)) && \
1731       !(__NetBSD_Version__ >= 105110000)
1732                 ip->ip_id = htons(ip->ip_id);
1733 #  endif
1734                 ip->ip_len = htons(ip->ip_len);
1735                 ip->ip_off = htons(ip->ip_off);
1736 # endif
1737 # if defined(__NetBSD__) && defined(M_CSUM_IPv4)
1738 #  if (__NetBSD_Version__ > 105009999)
1739                 if (ifp->if_csum_flags_tx & IFCAP_CSUM_IPv4)
1740                         m->m_pkthdr.csum_flags |= M_CSUM_IPv4;
1741                 else if (ip->ip_sum == 0)
1742                         ip->ip_sum = in_cksum(m, hlen);
1743 #  else
1744                 if (ifp->if_capabilities & IFCAP_CSUM_IPv4)
1745                         m->m_pkthdr.csuminfo |= M_CSUM_IPv4;
1746                 else if (ip->ip_sum == 0)
1747                         ip->ip_sum = in_cksum(m, hlen);
1748 #  endif
1749 # else
1750                 if (!ip->ip_sum)
1751                         ip->ip_sum = in_cksum(m, hlen);
1752 # endif /* __NetBSD__ && M_CSUM_IPv4 */
1753 # if    (BSD >= 199306) || (defined(IRIX) && (IRIX >= 605))
1754                 error = (*ifp->if_output)(ifp, m, (struct sockaddr *)dst,
1755                                           ro->ro_rt);
1756 # else
1757                 error = (*ifp->if_output)(ifp, m, (struct sockaddr *)dst);
1758 # endif
1759                 goto done;
1760         }
1761
1762         /*
1763          * Too large for interface; fragment if possible.
1764          * Must be able to put at least 8 bytes per fragment.
1765          */
1766         if (ip->ip_off & IP_DF) {
1767                 error = EMSGSIZE;
1768                 goto bad;
1769         }
1770         len = (ifp->if_mtu - hlen) &~ 7;
1771         if (len < 8) {
1772                 error = EMSGSIZE;
1773                 goto bad;
1774         }
1775
1776     {
1777         int mhlen, firstlen = len;
1778         struct mbuf **mnext = &m->m_act;
1779
1780         /*
1781          * Loop through length of segment after first fragment,
1782          * make new header and copy data of each part and link onto chain.
1783          */
1784         m0 = m;
1785         mhlen = sizeof (struct ip);
1786         for (off = hlen + len; off < ip->ip_len; off += len) {
1787 # ifdef MGETHDR
1788                 MGETHDR(m, M_DONTWAIT, MT_HEADER);
1789 # else
1790                 MGET(m, M_DONTWAIT, MT_HEADER);
1791 # endif
1792                 if (m == 0) {
1793                         error = ENOBUFS;
1794                         goto bad;
1795                 }
1796 # if BSD >= 199306
1797                 m->m_data += max_linkhdr;
1798 # else
1799                 m->m_off = MMAXOFF - hlen;
1800 # endif
1801                 mhip = mtod(m, struct ip *);
1802                 bcopy((char *)ip, (char *)mhip, sizeof(*ip));
1803                 if (hlen > sizeof (struct ip)) {
1804                         mhlen = ip_optcopy(ip, mhip) + sizeof (struct ip);
1805                         mhip->ip_hl = mhlen >> 2;
1806                 }
1807                 m->m_len = mhlen;
1808                 mhip->ip_off = ((off - hlen) >> 3) + (ip->ip_off & ~IP_MF);
1809                 if (ip->ip_off & IP_MF)
1810                         mhip->ip_off |= IP_MF;
1811                 if (off + len >= ip->ip_len)
1812                         len = ip->ip_len - off;
1813                 else
1814                         mhip->ip_off |= IP_MF;
1815                 mhip->ip_len = htons((u_short)(len + mhlen));
1816                 m->m_next = m_copy(m0, off, len);
1817                 if (m->m_next == 0) {
1818                         error = ENOBUFS;        /* ??? */
1819                         goto sendorfree;
1820                 }
1821 # if BSD >= 199306
1822                 m->m_pkthdr.len = mhlen + len;
1823                 m->m_pkthdr.rcvif = NULL;
1824 # endif
1825                 mhip->ip_off = htons((u_short)mhip->ip_off);
1826                 mhip->ip_sum = 0;
1827                 mhip->ip_sum = in_cksum(m, mhlen);
1828                 *mnext = m;
1829                 mnext = &m->m_act;
1830         }
1831         /*
1832          * Update first fragment by trimming what's been copied out
1833          * and updating header, then send each fragment (in order).
1834          */
1835         m_adj(m0, hlen + firstlen - ip->ip_len);
1836         ip->ip_len = htons((u_short)(hlen + firstlen));
1837         ip->ip_off = htons((u_short)(ip->ip_off | IP_MF));
1838         ip->ip_sum = 0;
1839         ip->ip_sum = in_cksum(m0, hlen);
1840 sendorfree:
1841         for (m = m0; m; m = m0) {
1842                 m0 = m->m_act;
1843                 m->m_act = 0;
1844                 if (error == 0)
1845 # if (BSD >= 199306) || (defined(IRIX) && (IRIX >= 605))
1846                         error = (*ifp->if_output)(ifp, m,
1847                             (struct sockaddr *)dst, ro->ro_rt);
1848 # else
1849                         error = (*ifp->if_output)(ifp, m,
1850                             (struct sockaddr *)dst);
1851 # endif
1852                 else
1853                         m_freem(m);
1854         }
1855     }
1856 done:
1857         if (!error)
1858                 ipl_frouteok[0]++;
1859         else
1860                 ipl_frouteok[1]++;
1861
1862         if (ro->ro_rt != NULL) {
1863                 RTFREE(ro->ro_rt);
1864         }
1865         *mpp = NULL;
1866         return error;
1867 bad:
1868         if ((error == EMSGSIZE) && (fin->fin_v == 4)) {
1869                 sifp = fin->fin_ifp;
1870                 code = fin->fin_icode;
1871                 fin->fin_icode = ICMP_UNREACH_NEEDFRAG;
1872                 fin->fin_ifp = ifp;
1873                 (void) send_icmp_err(ip, ICMP_UNREACH, fin, 1);
1874                 fin->fin_ifp = sifp;
1875                 fin->fin_icode = code;
1876         }
1877         m_freem(m);
1878         goto done;
1879 }
1880
1881
1882 /*
1883  * Return true or false depending on whether the route to the
1884  * given IP address uses the same interface as the one passed.
1885  */
1886 int fr_verifysrc(ipa, ifp)
1887 struct in_addr ipa;
1888 void *ifp;
1889 {
1890         struct sockaddr_in *dst;
1891         struct route iproute;
1892
1893         bzero((char *)&iproute, sizeof(iproute));
1894         dst = (struct sockaddr_in *)&iproute.ro_dst;
1895 # if    (BSD >= 199306)
1896         dst->sin_len = sizeof(*dst);
1897 # endif
1898         dst->sin_family = AF_INET;
1899         dst->sin_addr = ipa;
1900 # if    (BSD >= 199306) && !defined(__NetBSD__) && !defined(__bsdi__) && \
1901         !defined(__OpenBSD__)
1902 #  ifdef        RTF_CLONING
1903         rtalloc_ign(&iproute, RTF_CLONING);
1904 #  else
1905         rtalloc_ign(&iproute, RTF_PRCLONING);
1906 #  endif
1907 # else
1908         rtalloc(&iproute);
1909 # endif
1910         if (iproute.ro_rt == NULL)
1911                 return 0;
1912         return (ifp == iproute.ro_rt->rt_ifp);
1913 }
1914
1915
1916 # ifdef USE_GETIFNAME
1917 char *
1918 get_ifname(ifp)
1919 struct ifnet *ifp;
1920 {
1921         static char workbuf[64];
1922
1923         sprintf(workbuf, "%s%d", ifp->if_name, ifp->if_unit);
1924         return workbuf;
1925 }
1926 # endif
1927
1928
1929 # if defined(USE_INET6)
1930 /*
1931  * This is the IPv6 specific fastroute code.  It doesn't clean up the mbuf's
1932  * or ensure that it is an IPv6 packet that is being forwarded, those are
1933  * expected to be done by the called (ipfr_fastroute).
1934  */
1935 static int ipfr_fastroute6(m0, mpp, fin, fdp)
1936 struct mbuf *m0, **mpp;
1937 fr_info_t *fin;
1938 frdest_t *fdp;
1939 {
1940         struct route_in6 ip6route;
1941         struct sockaddr_in6 *dst6;
1942         struct route_in6 *ro;
1943         struct ifnet *ifp;
1944         frentry_t *fr;
1945 #if defined(OpenBSD) && (OpenBSD >= 200211)
1946         struct route_in6 *ro_pmtu = NULL;
1947         struct in6_addr finaldst;
1948         ip6_t *ip6;
1949 #endif
1950         u_long mtu;
1951         int error;
1952
1953         ifp = NULL;
1954         ro = &ip6route;
1955         fr = fin->fin_fr;
1956         bzero((caddr_t)ro, sizeof(*ro));
1957         dst6 = (struct sockaddr_in6 *)&ro->ro_dst;
1958         dst6->sin6_family = AF_INET6;
1959         dst6->sin6_len = sizeof(struct sockaddr_in6);
1960         dst6->sin6_addr = fin->fin_fi.fi_src.in6;
1961
1962         if (fdp != NULL)
1963                 ifp = fdp->fd_ifp;
1964
1965         if ((fr != NULL) && (fin->fin_rev != 0)) {
1966                 if ((ifp != NULL) && (fdp == &fr->fr_tif))
1967                         return 0;
1968         } else if (fdp != NULL) {
1969                 if (IP6_NOTZERO(&fdp->fd_ip6))
1970                         dst6->sin6_addr = fdp->fd_ip6.in6;
1971         }
1972         if ((ifp == NULL) && ((fr == NULL) || !(fr->fr_flags & FR_FASTROUTE)))
1973                 return -2;
1974
1975         rtalloc((struct route *)ro);
1976
1977         if ((ifp == NULL) && (ro->ro_rt != NULL))
1978                 ifp = ro->ro_rt->rt_ifp;
1979
1980         if ((ro->ro_rt == NULL) || (ifp == NULL) ||
1981             (ifp != ro->ro_rt->rt_ifp)) {
1982                 error = EHOSTUNREACH;
1983         } else {
1984                 if (ro->ro_rt->rt_flags & RTF_GATEWAY)
1985                         dst6 = (struct sockaddr_in6 *)ro->ro_rt->rt_gateway;
1986                 ro->ro_rt->rt_use++;
1987
1988 #if defined(OpenBSD) && (OpenBSD >= 200211)
1989                 ip6 = mtod(m0, ip6_t *);
1990                 ro_pmtu = ro;
1991                 finaldst = ip6->ip6_dst;
1992                 error = ip6_getpmtu(ro_pmtu, ro, ifp, &finaldst, &mtu);
1993                 if (error == 0) {
1994 #else
1995                         mtu = nd_ifinfo[ifp->if_index].linkmtu;
1996 #endif
1997                         if (m0->m_pkthdr.len <= mtu)
1998                                 error = nd6_output(ifp, fin->fin_ifp, m0,
1999                                                    dst6, ro->ro_rt);
2000                         else
2001                                 error = EMSGSIZE;
2002 #if defined(OpenBSD) && (OpenBSD >= 200211)
2003                 }
2004 #endif
2005         }
2006
2007         if (ro->ro_rt != NULL) {
2008                 RTFREE(ro->ro_rt);
2009         }
2010         return error;
2011 }
2012 # endif
2013 #else /* #ifdef _KERNEL */
2014
2015
2016 # if defined(__sgi) && (IRIX < 605)
2017 static int no_output __P((struct ifnet *ifp, struct mbuf *m,
2018                            struct sockaddr *s))
2019 # else
2020 static int no_output __P((struct ifnet *ifp, struct mbuf *m,
2021                            struct sockaddr *s, struct rtentry *rt))
2022 # endif
2023 {
2024         return 0;
2025 }
2026
2027
2028 # ifdef __STDC__
2029 #  if defined(__sgi) && (IRIX < 605)
2030 static int write_output __P((struct ifnet *ifp, struct mbuf *m,
2031                              struct sockaddr *s))
2032 #  else
2033 static int write_output __P((struct ifnet *ifp, struct mbuf *m,
2034                              struct sockaddr *s, struct rtentry *rt))
2035 #  endif
2036 {
2037         ip_t *ip = (ip_t *)m;
2038 # else
2039 static int write_output(ifp, ip)
2040 struct ifnet *ifp;
2041 ip_t *ip;
2042 {
2043 # endif
2044         char fname[32];
2045         int fd;
2046
2047 # if (defined(NetBSD) && (NetBSD <= 1991011) && (NetBSD >= 199606)) || \
2048         (defined(OpenBSD) && (OpenBSD >= 199603))
2049         sprintf(fname, "%s", ifp->if_xname);
2050 # else
2051         sprintf(fname, "%s%d", ifp->if_name, ifp->if_unit);
2052 # endif
2053         fd = open(fname, O_WRONLY|O_APPEND);
2054         if (fd == -1) {
2055                 perror("open");
2056                 return -1;
2057         }
2058         write(fd, (char *)ip, ntohs(ip->ip_len));
2059         close(fd);
2060         return 0;
2061 }
2062
2063
2064 char *get_ifname(ifp)
2065 struct ifnet *ifp;
2066 {
2067 # if (defined(NetBSD) && (NetBSD <= 1991011) && (NetBSD >= 199606)) || \
2068      (defined(OpenBSD) && (OpenBSD >= 199603))
2069         return ifp->if_xname;
2070 # else
2071         static char fullifname[LIFNAMSIZ];
2072
2073         sprintf(fullifname, "%s%d", ifp->if_name, ifp->if_unit);
2074         return fullifname;
2075 # endif
2076 }
2077
2078
2079 struct ifnet *get_unit(ifname, v)
2080 char *ifname;
2081 int v;
2082 {
2083         struct ifnet *ifp, **ifa, **old_ifneta;
2084
2085         for (ifa = ifneta; ifa && (ifp = *ifa); ifa++) {
2086 # if (defined(NetBSD) && (NetBSD <= 1991011) && (NetBSD >= 199606)) || \
2087      (defined(OpenBSD) && (OpenBSD >= 199603))
2088                 if (!strncmp(ifname, ifp->if_xname, sizeof(ifp->if_xname)))
2089 # else
2090                 char fullname[LIFNAMSIZ];
2091
2092                 sprintf(fullname, "%s%d", ifp->if_name, ifp->if_unit);
2093                 if (!strcmp(ifname, fullname))
2094 # endif
2095                         return ifp;
2096         }
2097
2098         if (!ifneta) {
2099                 ifneta = (struct ifnet **)malloc(sizeof(ifp) * 2);
2100                 if (!ifneta)
2101                         return NULL;
2102                 ifneta[1] = NULL;
2103                 ifneta[0] = (struct ifnet *)calloc(1, sizeof(*ifp));
2104                 if (!ifneta[0]) {
2105                         free(ifneta);
2106                         return NULL;
2107                 }
2108                 nifs = 1;
2109         } else {
2110                 old_ifneta = ifneta;
2111                 nifs++;
2112                 ifneta = (struct ifnet **)realloc(ifneta,
2113                                                   (nifs + 1) * sizeof(*ifa));
2114                 if (!ifneta) {
2115                         free(old_ifneta);
2116                         nifs = 0;
2117                         return NULL;
2118                 }
2119                 ifneta[nifs] = NULL;
2120                 ifneta[nifs - 1] = (struct ifnet *)malloc(sizeof(*ifp));
2121                 if (!ifneta[nifs - 1]) {
2122                         nifs--;
2123                         return NULL;
2124                 }
2125         }
2126         ifp = ifneta[nifs - 1];
2127
2128 # if (defined(NetBSD) && (NetBSD <= 1991011) && (NetBSD >= 199606)) || \
2129      (defined(OpenBSD) && (OpenBSD >= 199603))
2130         strncpy(ifp->if_xname, ifname, sizeof(ifp->if_xname));
2131 # else
2132         ifp->if_name = strdup(ifname);
2133
2134         ifname = ifp->if_name;
2135         while (*ifname && !isdigit(*ifname))
2136                 ifname++;
2137         if (*ifname && isdigit(*ifname)) {
2138                 ifp->if_unit = atoi(ifname);
2139                 *ifname = '\0';
2140         } else
2141                 ifp->if_unit = -1;
2142 # endif
2143         ifp->if_output = no_output;
2144         return ifp;
2145 }
2146
2147
2148
2149 void init_ifp()
2150 {
2151         struct ifnet *ifp, **ifa;
2152         char fname[32];
2153         int fd;
2154
2155 # if (defined(NetBSD) && (NetBSD <= 1991011) && (NetBSD >= 199606)) || \
2156         (defined(OpenBSD) && (OpenBSD >= 199603))
2157         for (ifa = ifneta; ifa && (ifp = *ifa); ifa++) {
2158                 ifp->if_output = write_output;
2159                 sprintf(fname, "/tmp/%s", ifp->if_xname);
2160                 fd = open(fname, O_WRONLY|O_CREAT|O_EXCL|O_TRUNC, 0600);
2161                 if (fd == -1)
2162                         perror("open");
2163                 else
2164                         close(fd);
2165         }
2166 # else
2167
2168         for (ifa = ifneta; ifa && (ifp = *ifa); ifa++) {
2169                 ifp->if_output = write_output;
2170                 sprintf(fname, "/tmp/%s%d", ifp->if_name, ifp->if_unit);
2171                 fd = open(fname, O_WRONLY|O_CREAT|O_EXCL|O_TRUNC, 0600);
2172                 if (fd == -1)
2173                         perror("open");
2174                 else
2175                         close(fd);
2176         }
2177 # endif
2178 }
2179
2180
2181 int send_reset(ip, fin)
2182 ip_t *ip;
2183 fr_info_t *fin;
2184 {
2185         verbose("- TCP RST sent\n");
2186         return 0;
2187 }
2188
2189
2190 int send_icmp_err(ip, code, fin, dst)
2191 ip_t *ip;
2192 int code;
2193 fr_info_t *fin;
2194 int dst;
2195 {
2196         verbose("- ICMP UNREACHABLE sent\n");
2197         return 0;
2198 }
2199
2200
2201 void frsync()
2202 {
2203         return;
2204 }
2205
2206 void m_copydata(m, off, len, cp)
2207 mb_t *m;
2208 int off, len;
2209 caddr_t cp;
2210 {
2211         bcopy((char *)m + off, cp, len);
2212 }
2213
2214
2215 int ipfuiomove(buf, len, rwflag, uio)
2216 caddr_t buf;
2217 int len, rwflag;
2218 struct uio *uio;
2219 {
2220         int left, ioc, num, offset;
2221         struct iovec *io;
2222         char *start;
2223
2224         if (rwflag == UIO_READ) {
2225                 left = len;
2226                 ioc = 0;
2227
2228                 offset = uio->uio_offset;
2229
2230                 while ((left > 0) && (ioc < uio->uio_iovcnt)) {
2231                         io = uio->uio_iov + ioc;
2232                         num = io->iov_len;
2233                         if (num > left)
2234                                 num = left;
2235                         start = (char *)io->iov_base + offset;
2236                         if (start > (char *)io->iov_base + io->iov_len) {
2237                                 offset -= io->iov_len;
2238                                 ioc++;
2239                                 continue;
2240                         }
2241                         bcopy(buf, start, num);
2242                         uio->uio_resid -= num;
2243                         uio->uio_offset += num;
2244                         left -= num;
2245                         if (left > 0)
2246                                 ioc++;
2247                 }
2248                 if (left > 0)
2249                         return EFAULT;
2250         }
2251         return 0;
2252 }
2253 #endif /* _KERNEL */