sys/netinet/ip_icmp.c

   1 /*
   2  * Copyright (c) 1982, 1986, 1988, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  *      @(#)ip_icmp.c   8.2 (Berkeley) 1/4/94
  30  * $FreeBSD: src/sys/netinet/ip_icmp.c,v 1.39.2.19 2003/01/24 05:11:34 sam Exp $
  31  */
  32
  33 #include "opt_ipsec.h"
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/mbuf.h>
  38 #include <sys/protosw.h>
  39 #include <sys/socket.h>
  40 #include <sys/socketops.h>
  41 #include <sys/time.h>
  42 #include <sys/kernel.h>
  43 #include <sys/sysctl.h>
  44 #include <sys/in_cksum.h>
  45
  46 #include <machine/stdarg.h>
  47
  48 #include <net/if.h>
  49 #include <net/if_types.h>
  50 #include <net/netisr2.h>
  51 #include <net/netmsg2.h>
  52 #include <net/route.h>
  53
  54 #define _IP_VHL
  55 #include <netinet/in.h>
  56 #include <netinet/in_systm.h>
  57 #include <netinet/in_var.h>
  58 #include <netinet/ip.h>
  59 #include <netinet/ip_icmp.h>
  60 #include <netinet/ip_var.h>
  61 #include <netinet/icmp_var.h>
  62
  63 #ifdef IPSEC
  64 #include <netinet6/ipsec.h>
  65 #include <netproto/key/key.h>
  66 #endif
  67
  68 #ifdef FAST_IPSEC
  69 #include <netproto/ipsec/ipsec.h>
  70 #include <netproto/ipsec/key.h>
  71 #define IPSEC
  72 #endif
  73
  74 /*
  75  * ICMP routines: error generation, receive packet processing, and
  76  * routines to turnaround packets back to the originator, and
  77  * host table maintenance routines.
  78  */
  79
  80 struct icmpstat icmpstat;
  81 SYSCTL_STRUCT(_net_inet_icmp, ICMPCTL_STATS, stats, CTLFLAG_RW,
  82         &icmpstat, icmpstat, "ICMP statistics");
  83
  84 static int      icmpmaskrepl = 0;
  85 SYSCTL_INT(_net_inet_icmp, ICMPCTL_MASKREPL, maskrepl, CTLFLAG_RW,
  86         &icmpmaskrepl, 0, "Allow replies to netmask requests");
  87
  88 static int      drop_redirect = 0;
  89 SYSCTL_INT(_net_inet_icmp, OID_AUTO, drop_redirect, CTLFLAG_RW,
  90         &drop_redirect, 0, "Ignore ICMP redirects");
  91
  92 static int      log_redirect = 0;
  93 SYSCTL_INT(_net_inet_icmp, OID_AUTO, log_redirect, CTLFLAG_RW,
  94         &log_redirect, 0, "Enable output about ICMP redirects");
  95
  96 static int      discard_sourcequench = 1;
  97 SYSCTL_INT(_net_inet_icmp, OID_AUTO, discard_sourcequench, CTLFLAG_RW,
  98         &discard_sourcequench, 0, "Discard ICMP Source Quench");
  99
 100 #ifdef ICMP_BANDLIM
 101
 102 /*
 103  * ICMP error-response bandwidth limiting sysctl.  If not enabled, sysctl
 104  *      variable content is -1 and read-only.
 105  */
 106
 107 static int      icmplim = 200;
 108 SYSCTL_INT(_net_inet_icmp, ICMPCTL_ICMPLIM, icmplim, CTLFLAG_RW,
 109         &icmplim, 0, "ICMP bandwidth limit");
 110 #else
 111
 112 static int      icmplim = -1;
 113 SYSCTL_INT(_net_inet_icmp, ICMPCTL_ICMPLIM, icmplim, CTLFLAG_RD,
 114         &icmplim, 0, "ICMP bandwidth limit");
 115
 116 #endif
 117
 118 static int      icmplim_output = 0;
 119 SYSCTL_INT(_net_inet_icmp, OID_AUTO, icmplim_output, CTLFLAG_RW,
 120         &icmplim_output, 0, "Enable output about ICMP bandwidth limits");
 121
 122 /*
 123  * ICMP broadcast echo sysctl
 124  */
 125
 126 static int      icmpbmcastecho = 0;
 127 SYSCTL_INT(_net_inet_icmp, OID_AUTO, bmcastecho, CTLFLAG_RW,
 128     &icmpbmcastecho, 0, "");
 129
 130 static char     icmp_reply_src[IFNAMSIZ];
 131 SYSCTL_STRING(_net_inet_icmp, OID_AUTO, reply_src, CTLFLAG_RW,
 132         icmp_reply_src, IFNAMSIZ, "icmp reply source for non-local packets.");
 133
 134 static int      icmp_rfi;
 135 SYSCTL_INT(_net_inet_icmp, OID_AUTO, reply_from_interface, CTLFLAG_RW,
 136         &icmp_rfi, 0, "ICMP reply from incoming interface for "
 137         "non-local packets");
 138
 139 #ifdef ICMPPRINTFS
 140 static int      icmpprintfs = 0;
 141 SYSCTL_INT(_net_inet_icmp, OID_AUTO, debug_prints, CTLFLAG_RW,
 142         &icmpprintfs, 0, "extra ICMP debug prints");
 143 #endif
 144
 145 static void     icmp_reflect (struct mbuf *);
 146 static void     icmp_send (struct mbuf *, struct mbuf *, struct route *);
 147
 148 extern  struct protosw inetsw[];
 149
 150 /*
 151  * Generate an error packet of type error
 152  * in response to bad packet ip.
 153  */
 154 void
 155 icmp_error(struct mbuf *n, int type, int code, n_long dest, int destmtu)
 156 {
 157         struct ip *oip = mtod(n, struct ip *), *nip;
 158         unsigned oiplen = IP_VHL_HL(oip->ip_vhl) << 2;
 159         struct icmp *icp;
 160         struct mbuf *m;
 161         unsigned icmplen;
 162
 163 #ifdef ICMPPRINTFS
 164         if (icmpprintfs)
 165                 kprintf("icmp_error(%p, %d, %d)\n", oip, type, code);
 166 #endif
 167         if (type != ICMP_REDIRECT)
 168                 icmpstat.icps_error++;
 169         /*
 170          * Don't send error if the original packet was encrypted.
 171          * Don't send error if not the first fragment of message.
 172          * Don't error if the old packet protocol was ICMP
 173          * error message, only known informational types.
 174          */
 175         if (n->m_flags & M_DECRYPTED)
 176                 goto freeit;
 177         if (oip->ip_off &~ (IP_MF|IP_DF))
 178                 goto freeit;
 179         if (oip->ip_p == IPPROTO_ICMP && type != ICMP_REDIRECT &&
 180           n->m_len >= oiplen + ICMP_MINLEN &&
 181           !ICMP_INFOTYPE(((struct icmp *)((caddr_t)oip + oiplen))->icmp_type)) {
 182                 icmpstat.icps_oldicmp++;
 183                 goto freeit;
 184         }
 185         /* Don't send error in response to a multicast or broadcast packet */
 186         if (n->m_flags & (M_BCAST|M_MCAST))
 187                 goto freeit;
 188         /*
 189          * First, formulate icmp message
 190          */
 191         m = m_gethdr(MB_DONTWAIT, MT_HEADER);
 192         if (m == NULL)
 193                 goto freeit;
 194         icmplen = min(oiplen + 8, oip->ip_len);
 195         if (icmplen < sizeof(struct ip))
 196                 panic("icmp_error: bad length");
 197         m->m_len = icmplen + ICMP_MINLEN;
 198         MH_ALIGN(m, m->m_len);
 199         icp = mtod(m, struct icmp *);
 200         if ((u_int)type > ICMP_MAXTYPE)
 201                 panic("icmp_error");
 202         icmpstat.icps_outhist[type]++;
 203         icp->icmp_type = type;
 204         if (type == ICMP_REDIRECT)
 205                 icp->icmp_gwaddr.s_addr = dest;
 206         else {
 207                 icp->icmp_void = 0;
 208                 /*
 209                  * The following assignments assume an overlay with the
 210                  * zeroed icmp_void field.
 211                  */
 212                 if (type == ICMP_PARAMPROB) {
 213                         icp->icmp_pptr = code;
 214                         code = 0;
 215                 } else if (type == ICMP_UNREACH &&
 216                         code == ICMP_UNREACH_NEEDFRAG && destmtu) {
 217                         icp->icmp_nextmtu = htons(destmtu);
 218                 }
 219         }
 220
 221         icp->icmp_code = code;
 222         m_copydata(n, 0, icmplen, (caddr_t)&icp->icmp_ip);
 223         nip = &icp->icmp_ip;
 224
 225         /*
 226          * Convert fields to network representation.
 227          */
 228         nip->ip_len = htons(nip->ip_len);
 229         nip->ip_off = htons(nip->ip_off);
 230
 231         /*
 232          * Now, copy old ip header (without options)
 233          * in front of icmp message.
 234          */
 235         if (m->m_data - sizeof(struct ip) < m->m_pktdat)
 236                 panic("icmp len");
 237         m->m_data -= sizeof(struct ip);
 238         m->m_len += sizeof(struct ip);
 239         m->m_pkthdr.len = m->m_len;
 240         m->m_pkthdr.rcvif = n->m_pkthdr.rcvif;
 241         nip = mtod(m, struct ip *);
 242         bcopy(oip, nip, sizeof(struct ip));
 243         nip->ip_len = m->m_len;
 244         nip->ip_vhl = IP_VHL_BORING;
 245         nip->ip_p = IPPROTO_ICMP;
 246         nip->ip_tos = 0;
 247         m->m_pkthdr.fw_flags |= n->m_pkthdr.fw_flags & FW_MBUF_GENERATED;
 248         icmp_reflect(m);
 249
 250 freeit:
 251         m_freem(n);
 252 }
 253
 254 static void
 255 icmp_ctlinput_done_handler(netmsg_t nmsg)
 256 {
 257         struct netmsg_ctlinput *msg = (struct netmsg_ctlinput *)nmsg;
 258         struct mbuf *m = msg->m;
 259         int hlen = msg->hlen;
 260
 261         rip_input(&m, &hlen, msg->proto);
 262 }
 263
 264 static void
 265 icmp_ctlinput_done(struct mbuf *m)
 266 {
 267         struct netmsg_ctlinput *msg = &m->m_hdr.mh_ctlmsg;
 268
 269         netmsg_init(&msg->base, NULL, &netisr_apanic_rport, 0,
 270             icmp_ctlinput_done_handler);
 271         lwkt_sendmsg(netisr_cpuport(0), &msg->base.lmsg);
 272 }
 273
 274 static void
 275 icmp_mtudisc(struct mbuf *m, int hlen)
 276 {
 277         struct sockaddr_in icmpsrc = { sizeof(struct sockaddr_in), AF_INET };
 278         struct rtentry *rt;
 279         struct icmp *icp;
 280
 281         KASSERT(curthread->td_type == TD_TYPE_NETISR, ("not in netisr"));
 282
 283         icp = mtodoff(m, struct icmp *, hlen);
 284         icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
 285
 286         /*
 287          * MTU discovery:
 288          * If we got a needfrag and there is a host route to the original
 289          * destination, and the MTU is not locked, then set the MTU in the
 290          * route to the suggested new value (if given) and then notify as
 291          * usual.  The ULPs will notice that the MTU has changed and adapt
 292          * accordingly.  If no new MTU was suggested, then we guess a new
 293          * one less than the current value.  If the new MTU is unreasonably
 294          * small (arbitrarily set at 296), then we reset the MTU to the
 295          * interface value and enable the lock bit, indicating that we are
 296          * no longer doing MTU discovery.
 297          */
 298         rt = rtpurelookup((struct sockaddr *)&icmpsrc);
 299         if (rt != NULL && (rt->rt_flags & RTF_HOST) &&
 300             !(rt->rt_rmx.rmx_locks & RTV_MTU)) {
 301 #ifdef DEBUG_MTUDISC
 302                 char src_buf[INET_ADDRSTRLEN];
 303 #endif
 304                 int mtu;
 305
 306                 mtu = ntohs(icp->icmp_nextmtu);
 307                 if (!mtu)
 308                         mtu = ip_next_mtu(rt->rt_rmx.rmx_mtu, 1);
 309 #ifdef DEBUG_MTUDISC
 310                 kprintf("MTU for %s reduced to %d\n",
 311                     inet_ntop(AF_INET, &icmpsrc.sin_addr,
 312                         src_buf, INET_ADDRSTRLEN), mtu);
 313 #endif
 314                 if (mtu < 296) {
 315                         /* rt->rt_rmx.rmx_mtu = rt->rt_ifp->if_mtu; */
 316                         rt->rt_rmx.rmx_locks |= RTV_MTU;
 317                 } else if (rt->rt_rmx.rmx_mtu > mtu) {
 318                         rt->rt_rmx.rmx_mtu = mtu;
 319                 }
 320         }
 321         if (rt != NULL)
 322                 --rt->rt_refcnt;
 323
 324         /*
 325          * XXX if the packet contains [IPv4 AH TCP], we can't make a
 326          * notification to TCP layer.
 327          */
 328         so_pr_ctlinput_direct(&inetsw[ip_protox[icp->icmp_ip.ip_p]],
 329             PRC_MSGSIZE, (struct sockaddr *)&icmpsrc, &icp->icmp_ip);
 330 }
 331
 332 static void
 333 icmp_mtudisc_handler(netmsg_t nmsg)
 334 {
 335         struct netmsg_ctlinput *msg = (struct netmsg_ctlinput *)nmsg;
 336         int nextcpu;
 337
 338         icmp_mtudisc(msg->m, msg->hlen);
 339
 340         nextcpu = mycpuid + 1;
 341         if (nextcpu < ncpus)
 342                 lwkt_forwardmsg(netisr_cpuport(nextcpu), &msg->base.lmsg);
 343         else
 344                 icmp_ctlinput_done(msg->m);
 345 }
 346
 347 static boolean_t
 348 icmp_mtudisc_start(struct mbuf *m, int hlen, int proto)
 349 {
 350         struct netmsg_ctlinput *msg;
 351
 352         KASSERT(&curthread->td_msgport == netisr_cpuport(0),
 353             ("not in netisr0"));
 354
 355         icmp_mtudisc(m, hlen);
 356
 357         if (ncpus == 1) {
 358                 /* There is only one netisr; done */
 359                 return FALSE;
 360         }
 361
 362         msg = &m->m_hdr.mh_ctlmsg;
 363         netmsg_init(&msg->base, NULL, &netisr_apanic_rport, 0,
 364             icmp_mtudisc_handler);
 365         msg->m = m;
 366         msg->cmd = PRC_MSGSIZE;
 367         msg->hlen = hlen;
 368         msg->proto = proto;
 369
 370         lwkt_sendmsg(netisr_cpuport(1), &msg->base.lmsg);
 371         return TRUE;
 372 }
 373
 374 static void
 375 icmp_ctlinput(struct mbuf *m, int cmd, int hlen)
 376 {
 377         struct sockaddr_in icmpsrc = { sizeof(struct sockaddr_in), AF_INET };
 378         struct icmp *icp;
 379
 380         KASSERT(curthread->td_type == TD_TYPE_NETISR, ("not in netisr"));
 381
 382         icp = mtodoff(m, struct icmp *, hlen);
 383         icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
 384
 385         /*
 386          * XXX if the packet contains [IPv4 AH TCP], we can't make a
 387          * notification to TCP layer.
 388          */
 389         so_pr_ctlinput_direct(&inetsw[ip_protox[icp->icmp_ip.ip_p]],
 390             cmd, (struct sockaddr *)&icmpsrc, &icp->icmp_ip);
 391 }
 392
 393 static void
 394 icmp_ctlinput_handler(netmsg_t nmsg)
 395 {
 396         struct netmsg_ctlinput *msg = (struct netmsg_ctlinput *)nmsg;
 397
 398         icmp_ctlinput(msg->m, msg->cmd, msg->hlen);
 399         icmp_ctlinput_done(msg->m);
 400 }
 401
 402 static void
 403 icmp_ctlinput_start(struct mbuf *m, struct lwkt_port *port,
 404     int cmd, int hlen, int proto)
 405 {
 406         struct netmsg_ctlinput *msg;
 407
 408         KASSERT(&curthread->td_msgport != port,
 409             ("send icmp ctlinput to the current netisr"));
 410
 411         msg = &m->m_hdr.mh_ctlmsg;
 412         netmsg_init(&msg->base, NULL, &netisr_apanic_rport, 0,
 413             icmp_ctlinput_handler);
 414         msg->m = m;
 415         msg->cmd = cmd;
 416         msg->hlen = hlen;
 417         msg->proto = proto;
 418
 419         lwkt_sendmsg(port, &msg->base.lmsg);
 420 }
 421
 422 static void
 423 icmp_ctlinput_global_handler(netmsg_t nmsg)
 424 {
 425         struct netmsg_ctlinput *msg = (struct netmsg_ctlinput *)nmsg;
 426         int nextcpu;
 427
 428         icmp_ctlinput(msg->m, msg->cmd, msg->hlen);
 429
 430         nextcpu = mycpuid + 1;
 431         if (nextcpu < ncpus)
 432                 lwkt_forwardmsg(netisr_cpuport(nextcpu), &msg->base.lmsg);
 433         else
 434                 icmp_ctlinput_done(msg->m);
 435 }
 436
 437 static void
 438 icmp_ctlinput_global_start(struct mbuf *m, int cmd, int hlen, int proto)
 439 {
 440         struct netmsg_ctlinput *msg;
 441
 442         KASSERT(&curthread->td_msgport == netisr_cpuport(0),
 443             ("not in netisr0"));
 444         KASSERT(ncpus > 1, ("there is only 1 cpu"));
 445
 446         icmp_ctlinput(m, cmd, hlen);
 447
 448         msg = &m->m_hdr.mh_ctlmsg;
 449         netmsg_init(&msg->base, NULL, &netisr_apanic_rport, 0,
 450             icmp_ctlinput_global_handler);
 451         msg->m = m;
 452         msg->cmd = cmd;
 453         msg->hlen = hlen;
 454         msg->proto = proto;
 455
 456         lwkt_sendmsg(netisr_cpuport(1), &msg->base.lmsg);
 457 }
 458
 459 #define ICMP_RTREDIRECT_FLAGS   (RTF_GATEWAY | RTF_HOST)
 460
 461 static void
 462 icmp_redirect(struct mbuf *m, int hlen, boolean_t prt)
 463 {
 464         struct sockaddr_in icmpsrc = { sizeof(struct sockaddr_in), AF_INET };
 465         struct sockaddr_in icmpdst = { sizeof(struct sockaddr_in), AF_INET };
 466         struct sockaddr_in icmpgw = { sizeof(struct sockaddr_in), AF_INET };
 467         struct icmp *icp;
 468         struct ip *ip;
 469
 470         KASSERT(curthread->td_type == TD_TYPE_NETISR, ("not in netisr"));
 471
 472         ip = mtod(m, struct ip *);
 473         icp = mtodoff(m, struct icmp *, hlen);
 474
 475         /*
 476          * Short circuit routing redirects to force immediate change
 477          * in the kernel's routing tables.  The message is also handed
 478          * to anyone listening on a raw socket (e.g. the routing daemon
 479          * for use in updating its tables).
 480          */
 481 #ifdef ICMPPRINTFS
 482         if (icmpprintfs && prt) {
 483                 char dst_buf[INET_ADDRSTRLEN], gw_buf[INET_ADDRSTRLEN];
 484
 485                 kprintf("redirect dst %s to %s\n",
 486                     inet_ntop(AF_INET, &icp->icmp_ip.ip_dst,
 487                         dst_buf, INET_ADDRSTRLEN),
 488                     inet_ntop(AF_INET, &icp->icmp_gwaddr,
 489                         gw_buf, INET_ADDRSTRLEN));
 490         }
 491 #endif
 492         icmpgw.sin_addr = ip->ip_src;
 493         icmpdst.sin_addr = icp->icmp_gwaddr;
 494         icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
 495         rtredirect_oncpu((struct sockaddr *)&icmpsrc,
 496             (struct sockaddr *)&icmpdst, NULL, ICMP_RTREDIRECT_FLAGS,
 497             (struct sockaddr *)&icmpgw);
 498         kpfctlinput_direct(PRC_REDIRECT_HOST, (struct sockaddr *)&icmpsrc);
 499 }
 500
 501 static void
 502 icmp_redirect_done_handler(netmsg_t nmsg)
 503 {
 504         struct netmsg_ctlinput *msg = (struct netmsg_ctlinput *)nmsg;
 505         struct mbuf *m = msg->m;
 506         int hlen = msg->hlen;
 507 #ifdef IPSEC
 508         struct sockaddr_in icmpsrc = { sizeof(struct sockaddr_in), AF_INET };
 509         struct icmp *icp = mtodoff(m, struct icmp *, hlen);;
 510
 511         icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
 512         key_sa_routechange((struct sockaddr *)&icmpsrc);
 513 #endif
 514         rip_input(&m, &hlen, msg->proto);
 515 }
 516
 517 static void
 518 icmp_redirect_done(struct mbuf *m, int hlen, boolean_t dispatch_rip)
 519 {
 520         struct rt_addrinfo rtinfo;
 521         struct sockaddr_in icmpsrc = { sizeof(struct sockaddr_in), AF_INET };
 522         struct sockaddr_in icmpdst = { sizeof(struct sockaddr_in), AF_INET };
 523         struct sockaddr_in icmpgw = { sizeof(struct sockaddr_in), AF_INET };
 524         struct icmp *icp;
 525         struct ip *ip;
 526
 527         ip = mtod(m, struct ip *);
 528         icp = mtodoff(m, struct icmp *, hlen);
 529
 530         icmpgw.sin_addr = ip->ip_src;
 531         icmpdst.sin_addr = icp->icmp_gwaddr;
 532         icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
 533
 534         bzero(&rtinfo, sizeof(struct rt_addrinfo));
 535         rtinfo.rti_info[RTAX_DST] = (struct sockaddr *)&icmpsrc;
 536         rtinfo.rti_info[RTAX_GATEWAY] = (struct sockaddr *)&icmpdst;
 537         rtinfo.rti_info[RTAX_NETMASK] = NULL;
 538         rtinfo.rti_info[RTAX_AUTHOR] = (struct sockaddr *)&icmpgw;
 539         rt_missmsg(RTM_REDIRECT, &rtinfo, ICMP_RTREDIRECT_FLAGS, 0);
 540
 541         if (dispatch_rip) {
 542                 struct netmsg_ctlinput *msg = &m->m_hdr.mh_ctlmsg;
 543
 544                 netmsg_init(&msg->base, NULL, &netisr_apanic_rport, 0,
 545                     icmp_redirect_done_handler);
 546                 lwkt_sendmsg(netisr_cpuport(0), &msg->base.lmsg);
 547         }
 548 }
 549
 550 static void
 551 icmp_redirect_handler(netmsg_t nmsg)
 552 {
 553         struct netmsg_ctlinput *msg = (struct netmsg_ctlinput *)nmsg;
 554         int nextcpu;
 555
 556         icmp_redirect(msg->m, msg->hlen, FALSE);
 557
 558         nextcpu = mycpuid + 1;
 559         if (nextcpu < ncpus)
 560                 lwkt_forwardmsg(netisr_cpuport(nextcpu), &msg->base.lmsg);
 561         else
 562                 icmp_redirect_done(msg->m, msg->hlen, TRUE);
 563 }
 564
 565 static boolean_t
 566 icmp_redirect_start(struct mbuf *m, int hlen, int proto)
 567 {
 568         struct netmsg_ctlinput *msg;
 569
 570         KASSERT(&curthread->td_msgport == netisr_cpuport(0),
 571             ("not in netisr0"));
 572
 573         icmp_redirect(m, hlen, TRUE);
 574
 575         if (ncpus == 1) {
 576                 /* There is only one netisr; done */
 577                 icmp_redirect_done(m, hlen, FALSE);
 578                 return FALSE;
 579         }
 580
 581         msg = &m->m_hdr.mh_ctlmsg;
 582         netmsg_init(&msg->base, NULL, &netisr_apanic_rport, 0,
 583             icmp_redirect_handler);
 584         msg->m = m;
 585         msg->cmd = PRC_REDIRECT_HOST;
 586         msg->hlen = hlen;
 587         msg->proto = proto;
 588
 589         lwkt_sendmsg(netisr_cpuport(1), &msg->base.lmsg);
 590         return TRUE;
 591 }
 592
 593 /*
 594  * Process a received ICMP message.
 595  */
 596 int
 597 icmp_input(struct mbuf **mp, int *offp, int proto)
 598 {
 599         struct sockaddr_in icmpsrc = { sizeof(struct sockaddr_in), AF_INET };
 600         struct sockaddr_in icmpdst = { sizeof(struct sockaddr_in), AF_INET };
 601         struct icmp *icp;
 602         struct in_ifaddr *ia;
 603         struct mbuf *m = *mp;
 604         struct ip *ip = mtod(m, struct ip *);
 605         int icmplen = ip->ip_len;
 606         int i, hlen;
 607         int code;
 608
 609         KASSERT(&curthread->td_msgport == netisr_cpuport(0),
 610             ("not in netisr0"));
 611
 612         *mp = NULL;
 613         hlen = *offp;
 614
 615         /*
 616          * Locate icmp structure in mbuf, and check
 617          * that not corrupted and of at least minimum length.
 618          */
 619 #ifdef ICMPPRINTFS
 620         if (icmpprintfs) {
 621                 char src_buf[INET_ADDRSTRLEN], dst_buf[INET_ADDRSTRLEN];
 622
 623                 kprintf("icmp_input from %s to %s, len %d\n",
 624                     inet_ntop(AF_INET, &ip->ip_src, src_buf, INET_ADDRSTRLEN),
 625                     inet_ntop(AF_INET, &ip->ip_dst, dst_buf, INET_ADDRSTRLEN),
 626                     icmplen);
 627         }
 628 #endif
 629         if (icmplen < ICMP_MINLEN) {
 630                 icmpstat.icps_tooshort++;
 631                 goto freeit;
 632         }
 633         i = hlen + min(icmplen, ICMP_ADVLENMIN);
 634         if (m->m_len < i && (m = m_pullup(m, i)) == NULL)  {
 635                 icmpstat.icps_tooshort++;
 636                 return(IPPROTO_DONE);
 637         }
 638         ip = mtod(m, struct ip *);
 639
 640         if (in_cksum_skip(m, hlen + icmplen, hlen)) {
 641                 icmpstat.icps_checksum++;
 642                 goto freeit;
 643         }
 644         icp = (struct icmp *)((caddr_t)ip + hlen);
 645
 646         if (m->m_pkthdr.rcvif && m->m_pkthdr.rcvif->if_type == IFT_FAITH) {
 647                 /*
 648                  * Deliver very specific ICMP type only.
 649                  */
 650                 switch (icp->icmp_type) {
 651                 case ICMP_UNREACH:
 652                 case ICMP_TIMXCEED:
 653                         break;
 654                 default:
 655                         goto freeit;
 656                 }
 657         }
 658
 659 #ifdef ICMPPRINTFS
 660         if (icmpprintfs)
 661                 kprintf("icmp_input, type %d code %d\n", icp->icmp_type,
 662                     icp->icmp_code);
 663 #endif
 664
 665         /*
 666          * Message type specific processing.
 667          */
 668         if (icp->icmp_type > ICMP_MAXTYPE)
 669                 goto raw;
 670         icmpstat.icps_inhist[icp->icmp_type]++;
 671         code = icp->icmp_code;
 672         switch (icp->icmp_type) {
 673
 674         case ICMP_UNREACH:
 675                 switch (code) {
 676                         case ICMP_UNREACH_NET:
 677                         case ICMP_UNREACH_HOST:
 678                         case ICMP_UNREACH_SRCFAIL:
 679                         case ICMP_UNREACH_NET_UNKNOWN:
 680                         case ICMP_UNREACH_HOST_UNKNOWN:
 681                         case ICMP_UNREACH_ISOLATED:
 682                         case ICMP_UNREACH_TOSNET:
 683                         case ICMP_UNREACH_TOSHOST:
 684                         case ICMP_UNREACH_HOST_PRECEDENCE:
 685                         case ICMP_UNREACH_PRECEDENCE_CUTOFF:
 686                                 code = PRC_UNREACH_NET;
 687                                 break;
 688
 689                         case ICMP_UNREACH_NEEDFRAG:
 690                                 code = PRC_MSGSIZE;
 691                                 break;
 692
 693                         /*
 694                          * RFC 1122, Sections 3.2.2.1 and 4.2.3.9.
 695                          * Treat subcodes 2,3 as immediate RST
 696                          */
 697                         case ICMP_UNREACH_PROTOCOL:
 698                         case ICMP_UNREACH_PORT:
 699                                 code = PRC_UNREACH_PORT;
 700                                 break;
 701
 702                         case ICMP_UNREACH_NET_PROHIB:
 703                         case ICMP_UNREACH_HOST_PROHIB:
 704                         case ICMP_UNREACH_FILTER_PROHIB:
 705                                 code = PRC_UNREACH_ADMIN_PROHIB;
 706                                 break;
 707
 708                         default:
 709                                 goto badcode;
 710                 }
 711                 goto deliver;
 712
 713         case ICMP_TIMXCEED:
 714                 if (code > 1)
 715                         goto badcode;
 716                 code += PRC_TIMXCEED_INTRANS;
 717                 goto deliver;
 718
 719         case ICMP_PARAMPROB:
 720                 if (code > 1)
 721                         goto badcode;
 722                 code = PRC_PARAMPROB;
 723                 goto deliver;
 724
 725         case ICMP_SOURCEQUENCH:
 726                 if (code)
 727                         goto badcode;
 728                 if (discard_sourcequench)
 729                         break;
 730                 code = PRC_QUENCH;
 731 deliver:
 732                 /*
 733                  * Problem with datagram; advise higher level routines.
 734                  */
 735                 if (icmplen < ICMP_ADVLENMIN || icmplen < ICMP_ADVLEN(icp) ||
 736                     IP_VHL_HL(icp->icmp_ip.ip_vhl) < (sizeof(struct ip) >> 2)) {
 737                         icmpstat.icps_badlen++;
 738                         goto freeit;
 739                 }
 740                 /* Discard ICMP's in response to multicast packets */
 741                 if (IN_MULTICAST(ntohl(icp->icmp_ip.ip_dst.s_addr)))
 742                         goto badcode;
 743 #ifdef ICMPPRINTFS
 744                 if (icmpprintfs)
 745                         kprintf("deliver to protocol %d\n", icp->icmp_ip.ip_p);
 746 #endif
 747                 icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
 748
 749                 /*
 750                  * MTU discovery
 751                  */
 752                 if (code == PRC_MSGSIZE) {
 753                         /* Run MTU discovery in all netisrs */
 754                         if (icmp_mtudisc_start(m, hlen, proto)) {
 755                                 /* Forwarded; done */
 756                                 return IPPROTO_DONE;
 757                         }
 758                         /* Move on; run rip_input() directly */
 759                 } else {
 760                         struct protosw *pr;
 761                         struct lwkt_port *port;
 762                         int cpu;
 763
 764                         pr = &inetsw[ip_protox[icp->icmp_ip.ip_p]];
 765                         port = so_pr_ctlport(pr, code,
 766                             (struct sockaddr *)&icmpsrc, &icp->icmp_ip, &cpu);
 767                         if (port != NULL) {
 768                                 if (cpu == ncpus) {
 769                                         if (ncpus > 1) {
 770                                                 /*
 771                                                  * Run pr_ctlinput in all
 772                                                  * netisrs
 773                                                  */
 774                                                 icmp_ctlinput_global_start(m,
 775                                                     code, hlen, proto);
 776                                                 return IPPROTO_DONE;
 777                                         }
 778                                         /*
 779                                          * There is only one netisr; run
 780                                          * pr_ctlinput directly.
 781                                          */
 782                                 } else if (cpu != mycpuid) {
 783                                         /*
 784                                          * Send to the target netisr to run
 785                                          * pr_ctlinput.
 786                                          */
 787                                         icmp_ctlinput_start(m, port,
 788                                             code, hlen, proto);
 789                                         return IPPROTO_DONE;
 790                                 }
 791
 792                                 /*
 793                                  * The target netisr is this netisr.
 794                                  *
 795                                  * XXX if the packet contains [IPv4 AH TCP],
 796                                  * we can't make a notification to TCP layer.
 797                                  */
 798                                 so_pr_ctlinput_direct(pr, code,
 799                                     (struct sockaddr *)&icmpsrc, &icp->icmp_ip);
 800                         }
 801                         /* Move on; run rip_input() directly */
 802                 }
 803                 break;
 804 badcode:
 805                 icmpstat.icps_badcode++;
 806                 break;
 807
 808         case ICMP_ECHO:
 809                 if (!icmpbmcastecho
 810                     && (m->m_flags & (M_MCAST | M_BCAST)) != 0) {
 811                         icmpstat.icps_bmcastecho++;
 812                         break;
 813                 }
 814                 icp->icmp_type = ICMP_ECHOREPLY;
 815 #ifdef ICMP_BANDLIM
 816                 if (badport_bandlim(BANDLIM_ICMP_ECHO) < 0)
 817                         goto freeit;
 818                 else
 819 #endif
 820                         goto reflect;
 821
 822         case ICMP_TSTAMP:
 823                 if (!icmpbmcastecho
 824                     && (m->m_flags & (M_MCAST | M_BCAST)) != 0) {
 825                         icmpstat.icps_bmcasttstamp++;
 826                         break;
 827                 }
 828                 if (icmplen < ICMP_TSLEN) {
 829                         icmpstat.icps_badlen++;
 830                         break;
 831                 }
 832                 icp->icmp_type = ICMP_TSTAMPREPLY;
 833                 icp->icmp_rtime = iptime();
 834                 icp->icmp_ttime = icp->icmp_rtime;      /* bogus, do later! */
 835 #ifdef ICMP_BANDLIM
 836                 if (badport_bandlim(BANDLIM_ICMP_TSTAMP) < 0)
 837                         goto freeit;
 838                 else
 839 #endif
 840                         goto reflect;
 841
 842         case ICMP_MASKREQ:
 843                 if (icmpmaskrepl == 0)
 844                         break;
 845                 /*
 846                  * We are not able to respond with all ones broadcast
 847                  * unless we receive it over a point-to-point interface.
 848                  */
 849                 if (icmplen < ICMP_MASKLEN)
 850                         break;
 851                 switch (ip->ip_dst.s_addr) {
 852
 853                 case INADDR_BROADCAST:
 854                 case INADDR_ANY:
 855                         icmpdst.sin_addr = ip->ip_src;
 856                         break;
 857
 858                 default:
 859                         icmpdst.sin_addr = ip->ip_dst;
 860                 }
 861                 ia = (struct in_ifaddr *)ifaof_ifpforaddr(
 862                             (struct sockaddr *)&icmpdst, m->m_pkthdr.rcvif);
 863                 if (ia == NULL)
 864                         break;
 865                 if (ia->ia_ifp == 0)
 866                         break;
 867                 icp->icmp_type = ICMP_MASKREPLY;
 868                 icp->icmp_mask = ia->ia_sockmask.sin_addr.s_addr;
 869                 if (ip->ip_src.s_addr == 0) {
 870                         if (ia->ia_ifp->if_flags & IFF_BROADCAST)
 871                             ip->ip_src = satosin(&ia->ia_broadaddr)->sin_addr;
 872                         else if (ia->ia_ifp->if_flags & IFF_POINTOPOINT)
 873                             ip->ip_src = satosin(&ia->ia_dstaddr)->sin_addr;
 874                 }
 875 reflect:
 876                 ip->ip_len += hlen;     /* since ip_input deducts this */
 877                 icmpstat.icps_reflect++;
 878                 icmpstat.icps_outhist[icp->icmp_type]++;
 879                 icmp_reflect(m);
 880                 return(IPPROTO_DONE);
 881
 882         case ICMP_REDIRECT:
 883                 if (log_redirect) {
 884                         char src_buf[INET_ADDRSTRLEN];
 885                         char dst_buf[INET_ADDRSTRLEN];
 886                         char gwy_buf[INET_ADDRSTRLEN];
 887
 888                         kprintf("icmp redirect from %s: %s => %s\n",
 889                             inet_ntop(AF_INET, &ip->ip_src,
 890                                 src_buf, INET_ADDRSTRLEN),
 891                             inet_ntop(AF_INET, &icp->icmp_ip.ip_dst,
 892                                 dst_buf, INET_ADDRSTRLEN),
 893                             inet_ntop(AF_INET, &icp->icmp_gwaddr,
 894                                 gwy_buf, INET_ADDRSTRLEN));
 895                 }
 896                 if (drop_redirect)
 897                         break;
 898                 if (code > 3)
 899                         goto badcode;
 900                 if (icmplen < ICMP_ADVLENMIN || icmplen < ICMP_ADVLEN(icp) ||
 901                     IP_VHL_HL(icp->icmp_ip.ip_vhl) < (sizeof(struct ip) >> 2)) {
 902                         icmpstat.icps_badlen++;
 903                         break;
 904                 }
 905 #ifdef ICMPPRINTFS
 906                 if (icmpprintfs) {
 907                         char dst_buf[INET_ADDRSTRLEN], gw_buf[INET_ADDRSTRLEN];
 908
 909                         kprintf("redirect dst %s to %s\n",
 910                             inet_ntop(AF_INET, &icp->icmp_ip.ip_dst,
 911                                 dst_buf, INET_ADDRSTRLEN),
 912                             inet_ntop(AF_INET, &icp->icmp_gwaddr,
 913                                 gw_buf, INET_ADDRSTRLEN));
 914                 }
 915 #endif
 916                 icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
 917
 918                 /* Run redirect in all netisrs */
 919                 if (icmp_redirect_start(m, hlen, proto)) {
 920                         /* Forwarded; done */
 921                         return IPPROTO_DONE;
 922                 }
 923                 /* Move on; run rip_input() directly */
 924 #ifdef IPSEC
 925                 key_sa_routechange((struct sockaddr *)&icmpsrc);
 926 #endif
 927                 break;
 928
 929         /*
 930          * No kernel processing for the following;
 931          * just fall through to send to raw listener.
 932          */
 933         case ICMP_ECHOREPLY:
 934         case ICMP_ROUTERADVERT:
 935         case ICMP_ROUTERSOLICIT:
 936         case ICMP_TSTAMPREPLY:
 937         case ICMP_IREQREPLY:
 938         case ICMP_MASKREPLY:
 939         default:
 940                 break;
 941         }
 942
 943 raw:
 944         *mp = m;
 945         rip_input(mp, offp, proto);
 946         return(IPPROTO_DONE);
 947
 948 freeit:
 949         m_freem(m);
 950         return(IPPROTO_DONE);
 951 }
 952
 953 /*
 954  * Reflect the ip packet back to the source
 955  */
 956 static void
 957 icmp_reflect(struct mbuf *m)
 958 {
 959         struct ip *ip = mtod(m, struct ip *);
 960         struct in_ifaddr *ia;
 961         struct in_ifaddr_container *iac;
 962         struct ifaddr_container *ifac;
 963         struct ifnet *ifp;
 964         struct in_addr t;
 965         struct mbuf *opts = NULL;
 966         int optlen = (IP_VHL_HL(ip->ip_vhl) << 2) - sizeof(struct ip);
 967         struct route *ro = NULL, rt;
 968
 969         if (!in_canforward(ip->ip_src) &&
 970             ((ntohl(ip->ip_src.s_addr) & IN_CLASSA_NET) !=
 971              (IN_LOOPBACKNET << IN_CLASSA_NSHIFT))) {
 972                 m_freem(m);     /* Bad return address */
 973                 icmpstat.icps_badaddr++;
 974                 goto done;      /* Ip_output() will check for broadcast */
 975         }
 976         t = ip->ip_dst;
 977         ip->ip_dst = ip->ip_src;
 978
 979         ro = &rt;
 980         bzero(ro, sizeof *ro);
 981
 982         /*
 983          * If the incoming packet was addressed directly to us,
 984          * use dst as the src for the reply.  Otherwise (broadcast
 985          * or anonymous), use the address which corresponds
 986          * to the incoming interface.
 987          */
 988         ia = NULL;
 989         LIST_FOREACH(iac, INADDR_HASH(t.s_addr), ia_hash) {
 990                 if (t.s_addr == IA_SIN(iac->ia)->sin_addr.s_addr) {
 991                         ia = iac->ia;
 992                         goto match;
 993                 }
 994         }
 995         ifp = m->m_pkthdr.rcvif;
 996         if (ifp != NULL && (ifp->if_flags & IFF_BROADCAST)) {
 997                 TAILQ_FOREACH(ifac, &ifp->if_addrheads[mycpuid], ifa_link) {
 998                         struct ifaddr *ifa = ifac->ifa;
 999
1000                         if (ifa->ifa_addr->sa_family != AF_INET)
1001                                 continue;
1002                         ia = ifatoia(ifa);
1003                         if (satosin(&ia->ia_broadaddr)->sin_addr.s_addr ==
1004                             t.s_addr)
1005                                 goto match;
1006                 }
1007         }
1008         /*
1009          * If the packet was transiting through us, use the address of
1010          * the interface the packet came through in.  If that interface
1011          * doesn't have a suitable IP address, the normal selection
1012          * criteria apply.
1013          */
1014         if (icmp_rfi && ifp != NULL) {
1015                 TAILQ_FOREACH(ifac, &ifp->if_addrheads[mycpuid], ifa_link) {
1016                         struct ifaddr *ifa = ifac->ifa;
1017
1018                         if (ifa->ifa_addr->sa_family != AF_INET)
1019                                 continue;
1020                         ia = ifatoia(ifa);
1021                         goto match;
1022                 }
1023         }
1024         /*
1025          * If the incoming packet was not addressed directly to us, use
1026          * designated interface for icmp replies specified by sysctl
1027          * net.inet.icmp.reply_src (default not set). Otherwise continue
1028          * with normal source selection.
1029          */
1030         if (icmp_reply_src[0] != '\0' &&
1031             (ifp = ifunit_netisr(icmp_reply_src))) {
1032                 TAILQ_FOREACH(ifac, &ifp->if_addrheads[mycpuid], ifa_link) {
1033                         struct ifaddr *ifa = ifac->ifa;
1034
1035                         if (ifa->ifa_addr->sa_family != AF_INET)
1036                                 continue;
1037                         ia = ifatoia(ifa);
1038                         goto match;
1039                 }
1040         }
1041         /*
1042          * If the packet was transiting through us, use the address of
1043          * the interface that is the closest to the packet source.
1044          * When we don't have a route back to the packet source, stop here
1045          * and drop the packet.
1046          */
1047         ia = ip_rtaddr(ip->ip_dst, ro);
1048         if (ia == NULL) {
1049                 m_freem(m);
1050                 icmpstat.icps_noroute++;
1051                 goto done;
1052         }
1053 match:
1054         t = IA_SIN(ia)->sin_addr;
1055         ip->ip_src = t;
1056         ip->ip_ttl = ip_defttl;
1057
1058         if (optlen > 0) {
1059                 u_char *cp;
1060                 int opt, cnt;
1061                 u_int len;
1062
1063                 /*
1064                  * Retrieve any source routing from the incoming packet;
1065                  * add on any record-route or timestamp options.
1066                  */
1067                 cp = (u_char *) (ip + 1);
1068                 if ((opts = ip_srcroute(m)) == NULL &&
1069                     (opts = m_gethdr(MB_DONTWAIT, MT_HEADER))) {
1070                         opts->m_len = sizeof(struct in_addr);
1071                         mtod(opts, struct in_addr *)->s_addr = 0;
1072                 }
1073                 if (opts) {
1074 #ifdef ICMPPRINTFS
1075                         if (icmpprintfs)
1076                                 kprintf("icmp_reflect optlen %d rt %d => ",
1077                                        optlen, opts->m_len);
1078 #endif
1079                         for (cnt = optlen; cnt > 0; cnt -= len, cp += len) {
1080                                 opt = cp[IPOPT_OPTVAL];
1081                                 if (opt == IPOPT_EOL)
1082                                         break;
1083                                 if (opt == IPOPT_NOP)
1084                                         len = 1;
1085                                 else {
1086                                         if (cnt < IPOPT_OLEN + sizeof *cp)
1087                                                 break;
1088                                         len = cp[IPOPT_OLEN];
1089                                         if (len < IPOPT_OLEN + sizeof *cp ||
1090                                             len > cnt)
1091                                         break;
1092                                 }
1093                                 /*
1094                                  * Should check for overflow, but it
1095                                  * "can't happen".
1096                                  */
1097                                 if (opt == IPOPT_RR || opt == IPOPT_TS ||
1098                                     opt == IPOPT_SECURITY) {
1099                                         bcopy(cp,
1100                                               mtod(opts, caddr_t) + opts->m_len,
1101                                               len);
1102                                         opts->m_len += len;
1103                                 }
1104                         }
1105                         /* Terminate & pad, if necessary */
1106                         cnt = opts->m_len % 4;
1107                         if (cnt) {
1108                                 for (; cnt < 4; cnt++) {
1109                                         *(mtod(opts, caddr_t) + opts->m_len) =
1110                                             IPOPT_EOL;
1111                                         opts->m_len++;
1112                                 }
1113                         }
1114 #ifdef ICMPPRINTFS
1115                         if (icmpprintfs)
1116                                 kprintf("%d\n", opts->m_len);
1117 #endif
1118                 }
1119                 /*
1120                  * Now strip out original options by copying rest of first
1121                  * mbuf's data back, and adjust the IP length.
1122                  */
1123                 ip->ip_len -= optlen;
1124                 ip->ip_vhl = IP_VHL_BORING;
1125                 m->m_len -= optlen;
1126                 if (m->m_flags & M_PKTHDR)
1127                         m->m_pkthdr.len -= optlen;
1128                 optlen += sizeof(struct ip);
1129                 bcopy((caddr_t)ip + optlen, ip + 1,
1130                       m->m_len - sizeof(struct ip));
1131         }
1132         m->m_pkthdr.fw_flags &= FW_MBUF_GENERATED;
1133         m->m_flags &= ~(M_BCAST|M_MCAST);
1134         icmp_send(m, opts, ro);
1135 done:
1136         if (opts)
1137                 m_free(opts);
1138         if (ro && ro->ro_rt)
1139                 RTFREE(ro->ro_rt);
1140 }
1141
1142 /*
1143  * Send an icmp packet back to the ip level,
1144  * after supplying a checksum.
1145  */
1146 static void
1147 icmp_send(struct mbuf *m, struct mbuf *opts, struct route *rt)
1148 {
1149         struct ip *ip = mtod(m, struct ip *);
1150         struct icmp *icp;
1151         int hlen;
1152
1153         hlen = IP_VHL_HL(ip->ip_vhl) << 2;
1154         m->m_data += hlen;
1155         m->m_len -= hlen;
1156         icp = mtod(m, struct icmp *);
1157         icp->icmp_cksum = 0;
1158         icp->icmp_cksum = in_cksum(m, ip->ip_len - hlen);
1159         m->m_data -= hlen;
1160         m->m_len += hlen;
1161         m->m_pkthdr.rcvif = NULL;
1162 #ifdef ICMPPRINTFS
1163         if (icmpprintfs) {
1164                 char dst_buf[INET_ADDRSTRLEN], src_buf[INET_ADDRSTRLEN];
1165
1166                 kprintf("icmp_send dst %s src %s\n",
1167                     inet_ntop(AF_INET, &ip->ip_dst, dst_buf, INET_ADDRSTRLEN),
1168                     inet_ntop(AF_INET, &ip->ip_src, src_buf, INET_ADDRSTRLEN));
1169         }
1170 #endif
1171         ip_output(m, opts, rt, 0, NULL, NULL);
1172 }
1173
1174 n_time
1175 iptime(void)
1176 {
1177         struct timeval atv;
1178         u_long t;
1179
1180         getmicrotime(&atv);
1181         t = (atv.tv_sec % (24*60*60)) * 1000 + atv.tv_usec / 1000;
1182         return (htonl(t));
1183 }
1184
1185 #if 1
1186 /*
1187  * Return the next larger or smaller MTU plateau (table from RFC 1191)
1188  * given current value MTU.  If DIR is less than zero, a larger plateau
1189  * is returned; otherwise, a smaller value is returned.
1190  */
1191 int
1192 ip_next_mtu(int mtu, int dir)
1193 {
1194         static int mtutab[] = {
1195                 65535, 32000, 17914, 8166, 4352, 2002, 1492, 1006, 508, 296,
1196                 68, 0
1197         };
1198         int i;
1199
1200         for (i = 0; i < (sizeof mtutab) / (sizeof mtutab[0]); i++) {
1201                 if (mtu >= mtutab[i])
1202                         break;
1203         }
1204
1205         if (dir < 0) {
1206                 if (i == 0) {
1207                         return 0;
1208                 } else {
1209                         return mtutab[i - 1];
1210                 }
1211         } else {
1212                 if (mtutab[i] == 0) {
1213                         return 0;
1214                 } else if(mtu > mtutab[i]) {
1215                         return mtutab[i];
1216                 } else {
1217                         return mtutab[i + 1];
1218                 }
1219         }
1220 }
1221 #endif
1222
1223 #ifdef ICMP_BANDLIM
1224 /*
1225  * badport_bandlim() - check for ICMP bandwidth limit
1226  *
1227  *      Return 0 if it is ok to send an ICMP error response, -1 if we have
1228  *      hit our bandwidth limit and it is not ok.
1229  *
1230  *      If icmplim is <= 0, the feature is disabled and 0 is returned.
1231  *
1232  *      For now we separate the TCP and UDP subsystems w/ different 'which'
1233  *      values.  We may eventually remove this separation (and simplify the
1234  *      code further).
1235  *
1236  *      Note that the printing of the error message is delayed so we can
1237  *      properly print the icmp error rate that the system was trying to do
1238  *      (i.e. 22000/100 pps, etc...).  This can cause long delays in printing
1239  *      the 'final' error, but it doesn't make sense to solve the printing
1240  *      delay with more complex code.
1241  */
1242 int
1243 badport_bandlim(int which)
1244 {
1245         static int lticks[BANDLIM_MAX + 1];
1246         static int lpackets[BANDLIM_MAX + 1];
1247         int dticks;
1248         const char *bandlimittype[] = {
1249                 "Limiting icmp unreach response",
1250                 "Limiting icmp ping response",
1251                 "Limiting icmp tstamp response",
1252                 "Limiting closed port RST response",
1253                 "Limiting open port RST response"
1254                 };
1255
1256         /*
1257          * Return ok status if feature disabled or argument out of
1258          * ranage.
1259          */
1260
1261         if (icmplim <= 0 || which > BANDLIM_MAX || which < 0)
1262                 return(0);
1263         dticks = ticks - lticks[which];
1264
1265         /*
1266          * reset stats when cumulative dt exceeds one second.
1267          */
1268
1269         if ((unsigned int)dticks > hz) {
1270                 if (lpackets[which] > icmplim && icmplim_output) {
1271                         kprintf("%s from %d to %d packets per second\n",
1272                                 bandlimittype[which],
1273                                 lpackets[which],
1274                                 icmplim
1275                         );
1276                 }
1277                 lticks[which] = ticks;
1278                 lpackets[which] = 0;
1279         }
1280
1281         /*
1282          * bump packet count
1283          */
1284
1285         if (++lpackets[which] > icmplim) {
1286                 return(-1);
1287         }
1288         return(0);
1289 }
1290 #endif