4.4BSD snapshot (revision 8.1); add 1993 to copyright

[unix-history] / usr / src / sys / netinet / ip_icmp.c

diff --git a/usr/src/sys/netinet/ip_icmp.c b/usr/src/sys/netinet/ip_icmp.c
index 8c832aa..33f4c25 100644 (file)
--- a/usr/src/sys/netinet/ip_icmp.c
+++ b/usr/src/sys/netinet/ip_icmp.c
@@ -1,59 +1,59 @@
 /*
 /*

- * Copyright (c) 1982, 1986 Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1982, 1986, 1988, 1993
+ *     The Regents of the University of California.  All rights reserved.

  *
  *

- * Redistribution and use in source and binary forms are permitted
- * provided that this notice is preserved and that due credit is given
- * to the University of California at Berkeley. The name of the University
- * may not be used to endorse or promote products derived from this
- * software without specific prior written permission. This software
- * is provided ``as is'' without express or implied warranty.
+ * %sccs.include.redist.c%

  *
  *

- *     @(#)ip_icmp.c   7.7 (Berkeley) %G%
+ *     @(#)ip_icmp.c   8.1 (Berkeley) %G%

  */
 
  */
 

-#include "param.h"
-#include "systm.h"
-#include "mbuf.h"
-#include "protosw.h"
-#include "socket.h"
-#include "time.h"
-#include "kernel.h"
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/malloc.h>
+#include <sys/mbuf.h>
+#include <sys/protosw.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/kernel.h>
+
+#include <net/if.h>
+#include <net/route.h>
+
+#include <netinet/in.h>
+#include <netinet/in_systm.h>
+#include <netinet/in_var.h>
+#include <netinet/ip.h>
+#include <netinet/ip_icmp.h>
+#include <netinet/icmp_var.h>

 
 

-#include "../net/route.h"
-#include "../net/if.h"
-
-#include "in.h"
-#include "in_systm.h"
-#include "in_var.h"
-#include "ip.h"
-#include "ip_icmp.h"
-#include "icmp_var.h"
-
-#ifdef ICMPPRINTFS

 /*
  * ICMP routines: error generation, receive packet processing, and
  * routines to turnaround packets back to the originator, and
  * host table maintenance routines.
  */
 /*
  * ICMP routines: error generation, receive packet processing, and
  * routines to turnaround packets back to the originator, and
  * host table maintenance routines.
  */

+
+int    icmpmaskrepl = 0;
+#ifdef ICMPPRINTFS

 int    icmpprintfs = 0;
 #endif
 
 int    icmpprintfs = 0;
 #endif
 

+extern struct protosw inetsw[];
+

 /*
  * Generate an error packet of type error
  * in response to bad packet ip.
  */
 /*
  * Generate an error packet of type error
  * in response to bad packet ip.
  */

-/*VARARGS4*/
-icmp_error(oip, type, code, ifp, dest)
-       struct ip *oip;
+void
+icmp_error(n, type, code, dest, destifp)
+       struct mbuf *n;

        int type, code;
        int type, code;

-       struct ifnet *ifp;
-       struct in_addr dest;
+       n_long dest;
+       struct ifnet *destifp;

 {
 {

+       register struct ip *oip = mtod(n, struct ip *), *nip;

        register unsigned oiplen = oip->ip_hl << 2;
        register struct icmp *icp;
        register unsigned oiplen = oip->ip_hl << 2;
        register struct icmp *icp;

-       struct mbuf *m;
-       struct ip *nip;
+       register struct mbuf *m;

        unsigned icmplen;
 
 #ifdef ICMPPRINTFS
        unsigned icmplen;
 
 #ifdef ICMPPRINTFS


@@ -68,81 +68,98 @@ icmp_error(oip, type, code, ifp, dest)
         * error message, only known informational types.
         */
        if (oip->ip_off &~ (IP_MF|IP_DF))
         * error message, only known informational types.
         */
        if (oip->ip_off &~ (IP_MF|IP_DF))

-               goto free;
+               goto freeit;

        if (oip->ip_p == IPPROTO_ICMP && type != ICMP_REDIRECT &&
        if (oip->ip_p == IPPROTO_ICMP && type != ICMP_REDIRECT &&

+         dtom(oip)->m_len >= oiplen + ICMP_MINLEN &&
+         n->m_len >= oiplen + ICMP_MINLEN &&

          !ICMP_INFOTYPE(((struct icmp *)((caddr_t)oip + oiplen))->icmp_type)) {
                icmpstat.icps_oldicmp++;
          !ICMP_INFOTYPE(((struct icmp *)((caddr_t)oip + oiplen))->icmp_type)) {
                icmpstat.icps_oldicmp++;

-               goto free;
+               goto freeit;

        }
        }

-
+       /* Don't send error in response to a multicast or broadcast packet */
+       if (n->m_flags & (M_BCAST|M_MCAST))
+               goto freeit;

        /*
         * First, formulate icmp message
         */
        /*
         * First, formulate icmp message
         */

-       m = m_get(M_DONTWAIT, MT_HEADER);
+       m = m_gethdr(M_DONTWAIT, MT_HEADER);

        if (m == NULL)
        if (m == NULL)

-               goto free;
-       icmplen = oiplen + MIN(8, oip->ip_len);
+               goto freeit;
+       icmplen = oiplen + min(8, oip->ip_len);

        m->m_len = icmplen + ICMP_MINLEN;
        m->m_len = icmplen + ICMP_MINLEN;

-       m->m_off = MMAXOFF - m->m_len;
+       MH_ALIGN(m, m->m_len);

        icp = mtod(m, struct icmp *);
        if ((u_int)type > ICMP_MAXTYPE)
                panic("icmp_error");
        icmpstat.icps_outhist[type]++;
        icp->icmp_type = type;
        if (type == ICMP_REDIRECT)
        icp = mtod(m, struct icmp *);
        if ((u_int)type > ICMP_MAXTYPE)
                panic("icmp_error");
        icmpstat.icps_outhist[type]++;
        icp->icmp_type = type;
        if (type == ICMP_REDIRECT)

-               icp->icmp_gwaddr = dest;
-       else
+               icp->icmp_gwaddr.s_addr = dest;
+       else {

                icp->icmp_void = 0;
                icp->icmp_void = 0;

-       if (type == ICMP_PARAMPROB) {
-               icp->icmp_pptr = code;
-               code = 0;
+               /* 
+                * The following assignments assume an overlay with the
+                * zeroed icmp_void field.
+                */
+               if (type == ICMP_PARAMPROB) {
+                       icp->icmp_pptr = code;
+                       code = 0;
+               } else if (type == ICMP_UNREACH &&
+                       code == ICMP_UNREACH_NEEDFRAG && destifp) {
+                       icp->icmp_nextmtu = htons(destifp->if_mtu);
+               }

        }
        }

+

        icp->icmp_code = code;
        bcopy((caddr_t)oip, (caddr_t)&icp->icmp_ip, icmplen);
        nip = &icp->icmp_ip;
        icp->icmp_code = code;
        bcopy((caddr_t)oip, (caddr_t)&icp->icmp_ip, icmplen);
        nip = &icp->icmp_ip;

-       nip->ip_len += oiplen;
-       nip->ip_len = htons((u_short)nip->ip_len);
+       nip->ip_len = htons((u_short)(nip->ip_len + oiplen));

 
        /*
 
        /*

-        * Now, copy old ip header in front of icmp message.
+        * Now, copy old ip header (without options)
+        * in front of icmp message.

         */
         */

-       if (m->m_len + oiplen > MLEN)
-               oiplen = sizeof(struct ip);
-       if (m->m_len + oiplen > MLEN)
+       if (m->m_data - sizeof(struct ip) < m->m_pktdat)

                panic("icmp len");
                panic("icmp len");

-       m->m_off -= oiplen;
-       m->m_len += oiplen;
+       m->m_data -= sizeof(struct ip);
+       m->m_len += sizeof(struct ip);
+       m->m_pkthdr.len = m->m_len;
+       m->m_pkthdr.rcvif = n->m_pkthdr.rcvif;

        nip = mtod(m, struct ip *);
        nip = mtod(m, struct ip *);

-       bcopy((caddr_t)oip, (caddr_t)nip, oiplen);
+       bcopy((caddr_t)oip, (caddr_t)nip, sizeof(struct ip));

        nip->ip_len = m->m_len;
        nip->ip_len = m->m_len;

+       nip->ip_hl = sizeof(struct ip) >> 2;
+       nip->ip_hl = sizeof(struct ip) >> 2;

        nip->ip_p = IPPROTO_ICMP;
        nip->ip_p = IPPROTO_ICMP;

-       icmp_reflect(nip, ifp);
+       nip->ip_tos = 0;
+       icmp_reflect(m);

 
 

-free:
-       m_freem(dtom(oip));
+freeit:
+       m_freem(n);

 }
 
 static struct sockproto icmproto = { AF_INET, IPPROTO_ICMP };
 }
 
 static struct sockproto icmproto = { AF_INET, IPPROTO_ICMP };

-static struct sockaddr_in icmpsrc = { AF_INET };
-static struct sockaddr_in icmpdst = { AF_INET };
-static struct sockaddr_in icmpgw = { AF_INET };
-struct in_ifaddr *ifptoia();
+static struct sockaddr_in icmpsrc = { sizeof (struct sockaddr_in), AF_INET };
+static struct sockaddr_in icmpdst = { sizeof (struct sockaddr_in), AF_INET };
+static struct sockaddr_in icmpgw = { sizeof (struct sockaddr_in), AF_INET };
+struct sockaddr_in icmpmask = { 8, 0 };

 
 /*
  * Process a received ICMP message.
  */
 
 /*
  * Process a received ICMP message.
  */

-icmp_input(m, ifp)
+void
+icmp_input(m, hlen)

        register struct mbuf *m;
        register struct mbuf *m;

-       struct ifnet *ifp;
+       int hlen;

 {
        register struct icmp *icp;
        register struct ip *ip = mtod(m, struct ip *);
 {
        register struct icmp *icp;
        register struct ip *ip = mtod(m, struct ip *);

-       int icmplen = ip->ip_len, hlen = ip->ip_hl << 2;
+       int icmplen = ip->ip_len;

        register int i;
        struct in_ifaddr *ia;
        register int i;
        struct in_ifaddr *ia;

-       int (*ctlfunc)(), code;
+       void (*ctlfunc) __P((int, struct sockaddr *, struct ip *));
+       int code;

        extern u_char ip_protox[];
        extern u_char ip_protox[];

-       extern struct in_addr in_makeaddr();

 
        /*
         * Locate icmp structure in mbuf, and check
 
        /*
         * Locate icmp structure in mbuf, and check


@@ -150,28 +167,29 @@ icmp_input(m, ifp)
         */
 #ifdef ICMPPRINTFS
        if (icmpprintfs)
         */
 #ifdef ICMPPRINTFS
        if (icmpprintfs)

-               printf("icmp_input from %x, len %d\n", ip->ip_src, icmplen);
+               printf("icmp_input from %x to %x, len %d\n",
+                       ntohl(ip->ip_src.s_addr), ntohl(ip->ip_dst.s_addr),
+                       icmplen);

 #endif
        if (icmplen < ICMP_MINLEN) {
                icmpstat.icps_tooshort++;
 #endif
        if (icmplen < ICMP_MINLEN) {
                icmpstat.icps_tooshort++;

-               goto free;
+               goto freeit;

        }
        }

-       i = hlen + MIN(icmplen, ICMP_ADVLENMIN);
-       if ((m->m_off > MMAXOFF || m->m_len < i) &&
-               (m = m_pullup(m, i)) == 0)  {
+       i = hlen + min(icmplen, ICMP_ADVLENMIN);
+       if (m->m_len < i && (m = m_pullup(m, i)) == 0)  {

                icmpstat.icps_tooshort++;
                return;
        }
                icmpstat.icps_tooshort++;
                return;
        }

-       ip = mtod(m, struct ip *);
+       ip = mtod(m, struct ip *);

        m->m_len -= hlen;
        m->m_len -= hlen;

-       m->m_off += hlen;
+       m->m_data += hlen;

        icp = mtod(m, struct icmp *);
        if (in_cksum(m, icmplen)) {
                icmpstat.icps_checksum++;
        icp = mtod(m, struct icmp *);
        if (in_cksum(m, icmplen)) {
                icmpstat.icps_checksum++;

-               goto free;
+               goto freeit;

        }
        m->m_len += hlen;
        }
        m->m_len += hlen;

-       m->m_off -= hlen;
+       m->m_data -= hlen;

 
 #ifdef ICMPPRINTFS
        /*
 
 #ifdef ICMPPRINTFS
        /*


@@ -188,9 +206,35 @@ icmp_input(m, ifp)
        switch (icp->icmp_type) {
 
        case ICMP_UNREACH:
        switch (icp->icmp_type) {
 
        case ICMP_UNREACH:

-               if (code > 5)
-                       goto badcode;
-               code += PRC_UNREACH_NET;
+               switch (code) {
+                       case ICMP_UNREACH_NET:
+                       case ICMP_UNREACH_HOST:
+                       case ICMP_UNREACH_PROTOCOL:
+                       case ICMP_UNREACH_PORT:
+                       case ICMP_UNREACH_SRCFAIL:
+                               code += PRC_UNREACH_NET;
+                               break;
+
+                       case ICMP_UNREACH_NEEDFRAG:
+                               code = PRC_MSGSIZE;
+                               break;
+                               
+                       case ICMP_UNREACH_NET_UNKNOWN:
+                       case ICMP_UNREACH_NET_PROHIB:
+                       case ICMP_UNREACH_TOSNET:
+                               code = PRC_UNREACH_NET;
+                               break;
+
+                       case ICMP_UNREACH_HOST_UNKNOWN:
+                       case ICMP_UNREACH_ISOLATED:
+                       case ICMP_UNREACH_HOST_PROHIB:
+                       case ICMP_UNREACH_TOSHOST:
+                               code = PRC_UNREACH_HOST;
+                               break;
+
+                       default:
+                               goto badcode;
+               }

                goto deliver;
 
        case ICMP_TIMXCEED:
                goto deliver;
 
        case ICMP_TIMXCEED:


@@ -200,7 +244,7 @@ icmp_input(m, ifp)
                goto deliver;
 
        case ICMP_PARAMPROB:
                goto deliver;
 
        case ICMP_PARAMPROB:

-               if (code)
+               if (code > 1)

                        goto badcode;
                code = PRC_PARAMPROB;
                goto deliver;
                        goto badcode;
                code = PRC_PARAMPROB;
                goto deliver;


@@ -213,18 +257,20 @@ icmp_input(m, ifp)
                /*
                 * Problem with datagram; advise higher level routines.
                 */
                /*
                 * Problem with datagram; advise higher level routines.
                 */

-               icp->icmp_ip.ip_len = ntohs((u_short)icp->icmp_ip.ip_len);
-               if (icmplen < ICMP_ADVLENMIN || icmplen < ICMP_ADVLEN(icp)) {
+               if (icmplen < ICMP_ADVLENMIN || icmplen < ICMP_ADVLEN(icp) ||
+                   icp->icmp_ip.ip_hl < (sizeof(struct ip) >> 2)) {

                        icmpstat.icps_badlen++;
                        icmpstat.icps_badlen++;

-                       goto free;
+                       goto freeit;

                }
                }

+               NTOHS(icp->icmp_ip.ip_len);

 #ifdef ICMPPRINTFS
                if (icmpprintfs)
                        printf("deliver to protocol %d\n", icp->icmp_ip.ip_p);
 #endif
                icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
                if (ctlfunc = inetsw[ip_protox[icp->icmp_ip.ip_p]].pr_ctlinput)
 #ifdef ICMPPRINTFS
                if (icmpprintfs)
                        printf("deliver to protocol %d\n", icp->icmp_ip.ip_p);
 #endif
                icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
                if (ctlfunc = inetsw[ip_protox[icp->icmp_ip.ip_p]].pr_ctlinput)

-                       (*ctlfunc)(code, (struct sockaddr *)&icmpsrc);
+                       (*ctlfunc)(code, (struct sockaddr *)&icmpsrc,
+                           &icp->icmp_ip);

                break;
 
        badcode:
                break;
 
        badcode:


@@ -245,19 +291,32 @@ icmp_input(m, ifp)
                icp->icmp_ttime = icp->icmp_rtime;      /* bogus, do later! */
                goto reflect;
                
                icp->icmp_ttime = icp->icmp_rtime;      /* bogus, do later! */
                goto reflect;
                

-       case ICMP_IREQ:
+       case ICMP_MASKREQ:

 #define        satosin(sa)     ((struct sockaddr_in *)(sa))
 #define        satosin(sa)     ((struct sockaddr_in *)(sa))

-               if (in_netof(ip->ip_src) == 0 && (ia = ifptoia(ifp)))
-                       ip->ip_src = in_makeaddr(in_netof(IA_SIN(ia)->sin_addr),
-                           in_lnaof(ip->ip_src));
-               icp->icmp_type = ICMP_IREQREPLY;
-               goto reflect;
+               if (icmpmaskrepl == 0)
+                       break;
+               /*
+                * We are not able to respond with all ones broadcast
+                * unless we receive it over a point-to-point interface.
+                */
+               if (icmplen < ICMP_MASKLEN)
+                       break;
+               switch (ip->ip_dst.s_addr) {

 
 

-       case ICMP_MASKREQ:
-               if (icmplen < ICMP_MASKLEN || (ia = ifptoia(ifp)) == 0)
+               case INADDR_BROADCAST:
+               case INADDR_ANY:
+                       icmpdst.sin_addr = ip->ip_src;
+                       break;
+
+               default:
+                       icmpdst.sin_addr = ip->ip_dst;
+               }
+               ia = (struct in_ifaddr *)ifaof_ifpforaddr(
+                           (struct sockaddr *)&icmpdst, m->m_pkthdr.rcvif);
+               if (ia == 0)

                        break;
                icp->icmp_type = ICMP_MASKREPLY;
                        break;
                icp->icmp_type = ICMP_MASKREPLY;

-               icp->icmp_mask = htonl(ia->ia_subnetmask);
+               icp->icmp_mask = ia->ia_sockmask.sin_addr.s_addr;

                if (ip->ip_src.s_addr == 0) {
                        if (ia->ia_ifp->if_flags & IFF_BROADCAST)
                            ip->ip_src = satosin(&ia->ia_broadaddr)->sin_addr;
                if (ip->ip_src.s_addr == 0) {
                        if (ia->ia_ifp->if_flags & IFF_BROADCAST)
                            ip->ip_src = satosin(&ia->ia_broadaddr)->sin_addr;


@@ -268,11 +327,14 @@ reflect:
                ip->ip_len += hlen;     /* since ip_input deducts this */
                icmpstat.icps_reflect++;
                icmpstat.icps_outhist[icp->icmp_type]++;
                ip->ip_len += hlen;     /* since ip_input deducts this */
                icmpstat.icps_reflect++;
                icmpstat.icps_outhist[icp->icmp_type]++;

-               icmp_reflect(ip, ifp);
+               icmp_reflect(m);

                return;
 
        case ICMP_REDIRECT:
                return;
 
        case ICMP_REDIRECT:

-               if (icmplen < ICMP_ADVLENMIN || icmplen < ICMP_ADVLEN(icp)) {
+               if (code > 3)
+                       goto badcode;
+               if (icmplen < ICMP_ADVLENMIN || icmplen < ICMP_ADVLEN(icp) ||
+                   icp->icmp_ip.ip_hl < (sizeof(struct ip) >> 2)) {

                        icmpstat.icps_badlen++;
                        break;
                }
                        icmpstat.icps_badlen++;
                        break;
                }


@@ -290,23 +352,12 @@ reflect:
                        printf("redirect dst %x to %x\n", icp->icmp_ip.ip_dst,
                                icp->icmp_gwaddr);
 #endif
                        printf("redirect dst %x to %x\n", icp->icmp_ip.ip_dst,
                                icp->icmp_gwaddr);
 #endif

-               if (code == ICMP_REDIRECT_NET || code == ICMP_REDIRECT_TOSNET) {
-                       icmpsrc.sin_addr =
-                        in_makeaddr(in_netof(icp->icmp_ip.ip_dst), INADDR_ANY);
-                       rtredirect((struct sockaddr *)&icmpsrc,
-                         (struct sockaddr *)&icmpdst, RTF_GATEWAY,
-                         (struct sockaddr *)&icmpgw);
-                       icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
-                       pfctlinput(PRC_REDIRECT_NET,
-                         (struct sockaddr *)&icmpsrc);
-               } else {
-                       icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
-                       rtredirect((struct sockaddr *)&icmpsrc,
-                         (struct sockaddr *)&icmpdst, RTF_GATEWAY | RTF_HOST,
-                         (struct sockaddr *)&icmpgw);
-                       pfctlinput(PRC_REDIRECT_HOST,
-                         (struct sockaddr *)&icmpsrc);
-               }
+               icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
+               rtredirect((struct sockaddr *)&icmpsrc,
+                 (struct sockaddr *)&icmpdst,
+                 (struct sockaddr *)0, RTF_GATEWAY | RTF_HOST,
+                 (struct sockaddr *)&icmpgw, (struct rtentry **)0);
+               pfctlinput(PRC_REDIRECT_HOST, (struct sockaddr *)&icmpsrc);

                break;
 
        /*
                break;
 
        /*


@@ -314,6 +365,8 @@ reflect:
         * just fall through to send to raw listener.
         */
        case ICMP_ECHOREPLY:
         * just fall through to send to raw listener.
         */
        case ICMP_ECHOREPLY:

+       case ICMP_ROUTERADVERT:
+       case ICMP_ROUTERSOLICIT:

        case ICMP_TSTAMPREPLY:
        case ICMP_IREQREPLY:
        case ICMP_MASKREPLY:
        case ICMP_TSTAMPREPLY:
        case ICMP_IREQREPLY:
        case ICMP_MASKREPLY:


@@ -322,28 +375,32 @@ reflect:
        }
 
 raw:
        }
 
 raw:

-       icmpsrc.sin_addr = ip->ip_src;
-       icmpdst.sin_addr = ip->ip_dst;
-       raw_input(m, &icmproto, (struct sockaddr *)&icmpsrc,
-           (struct sockaddr *)&icmpdst);
+       rip_input(m);

        return;
 
        return;
 

-free:
+freeit:

        m_freem(m);
 }
 
 /*
  * Reflect the ip packet back to the source
  */
        m_freem(m);
 }
 
 /*
  * Reflect the ip packet back to the source
  */

-icmp_reflect(ip, ifp)
-       register struct ip *ip;
-       struct ifnet *ifp;
+void
+icmp_reflect(m)
+       struct mbuf *m;

 {
 {

+       register struct ip *ip = mtod(m, struct ip *);

        register struct in_ifaddr *ia;
        struct in_addr t;
        struct mbuf *opts = 0, *ip_srcroute();
        int optlen = (ip->ip_hl << 2) - sizeof(struct ip);
 
        register struct in_ifaddr *ia;
        struct in_addr t;
        struct mbuf *opts = 0, *ip_srcroute();
        int optlen = (ip->ip_hl << 2) - sizeof(struct ip);
 

+       if (!in_canforward(ip->ip_src) &&
+           ((ntohl(ip->ip_src.s_addr) & IN_CLASSA_NET) !=
+            (IN_LOOPBACKNET << IN_CLASSA_NSHIFT))) {
+               m_freem(m);     /* Bad return address */
+               goto done;      /* Ip_output() will check for broadcast */
+       }

        t = ip->ip_dst;
        ip->ip_dst = ip->ip_src;
        /*
        t = ip->ip_dst;
        ip->ip_dst = ip->ip_src;
        /*


@@ -359,8 +416,14 @@ icmp_reflect(ip, ifp)
                    t.s_addr == satosin(&ia->ia_broadaddr)->sin_addr.s_addr)
                        break;
        }
                    t.s_addr == satosin(&ia->ia_broadaddr)->sin_addr.s_addr)
                        break;
        }

+       icmpdst.sin_addr = t;

        if (ia == (struct in_ifaddr *)0)
        if (ia == (struct in_ifaddr *)0)

-               ia = ifptoia(ifp);
+               ia = (struct in_ifaddr *)ifaof_ifpforaddr(
+                       (struct sockaddr *)&icmpdst, m->m_pkthdr.rcvif);
+       /*
+        * The following happens if the packet was not addressed to us,
+        * and was received on an interface with no IP address.
+        */

        if (ia == (struct in_ifaddr *)0)
                ia = in_ifaddr;
        t = IA_SIN(ia)->sin_addr;
        if (ia == (struct in_ifaddr *)0)
                ia = in_ifaddr;
        t = IA_SIN(ia)->sin_addr;


@@ -368,57 +431,112 @@ icmp_reflect(ip, ifp)
        ip->ip_ttl = MAXTTL;
 
        if (optlen > 0) {
        ip->ip_ttl = MAXTTL;
 
        if (optlen > 0) {

+               register u_char *cp;
+               struct mbuf *m = dtom(ip);
+               int opt, cnt, off;
+               u_int len;
+
+               register u_char *cp;
+               int opt, cnt;
+               u_int len;
+

                /*
                /*

-                * Retrieve any source routing from the incoming packet
-                * and strip out other options.  Adjust the IP length.
+                * Retrieve any source routing from the incoming packet;
+                * add on any record-route or timestamp options.
+                */
+               cp = (u_char *) (ip + 1);
+               if ((opts = ip_srcroute()) == 0 &&
+                   (opts = m_gethdr(M_DONTWAIT, MT_HEADER))) {
+                       opts->m_len = sizeof(struct in_addr);
+                       mtod(opts, struct in_addr *)->s_addr = 0;
+               }
+               if (opts) {
+#ifdef ICMPPRINTFS
+                   if (icmpprintfs)
+                           printf("icmp_reflect optlen %d rt %d => ",
+                               optlen, opts->m_len);
+#endif
+                   for (cnt = optlen; cnt > 0; cnt -= len, cp += len) {
+                           opt = cp[IPOPT_OPTVAL];
+                           if (opt == IPOPT_EOL)
+                                   break;
+                           if (opt == IPOPT_NOP)
+                                   len = 1;
+                           else {
+                                   len = cp[IPOPT_OLEN];
+                                   if (len <= 0 || len > cnt)
+                                           break;
+                           }
+                           /*
+                            * Should check for overflow, but it "can't happen"
+                            */
+                           if (opt == IPOPT_RR || opt == IPOPT_TS || 
+                               opt == IPOPT_SECURITY) {
+                                   bcopy((caddr_t)cp,
+                                       mtod(opts, caddr_t) + opts->m_len, len);
+                                   opts->m_len += len;
+                           }
+                   }
+                   /* Terminate & pad, if necessary */
+                   if (cnt = opts->m_len % 4) {
+                           for (; cnt < 4; cnt++) {
+                                   *(mtod(opts, caddr_t) + opts->m_len) =
+                                       IPOPT_EOL;
+                                   opts->m_len++;
+                           }
+                   }
+#ifdef ICMPPRINTFS
+                   if (icmpprintfs)
+                           printf("%d\n", opts->m_len);
+#endif
+               }
+               /*
+                * Now strip out original options by copying rest of first
+                * mbuf's data back, and adjust the IP length.

                 */
                 */

-               opts = ip_srcroute();

                ip->ip_len -= optlen;
                ip->ip_len -= optlen;

-               ip_stripoptions(ip, (struct mbuf *)0);
+               ip->ip_hl = sizeof(struct ip) >> 2;
+               m->m_len -= optlen;
+               if (m->m_flags & M_PKTHDR)
+                       m->m_pkthdr.len -= optlen;
+               optlen += sizeof(struct ip);
+               bcopy((caddr_t)ip + optlen, (caddr_t)(ip + 1),
+                        (unsigned)(m->m_len - sizeof(struct ip)));

        }
        }

-       icmp_send(ip, opts);
+       m->m_flags &= ~(M_BCAST|M_MCAST);
+
+       icmp_send(m, opts);
+done:

        if (opts)
                (void)m_free(opts);
 }
 
        if (opts)
                (void)m_free(opts);
 }
 

-struct in_ifaddr *
-ifptoia(ifp)
-       struct ifnet *ifp;
-{
-       register struct in_ifaddr *ia;
-
-       for (ia = in_ifaddr; ia; ia = ia->ia_next)
-               if (ia->ia_ifp == ifp)
-                       return (ia);
-       return ((struct in_ifaddr *)0);
-}
-

 /*
  * Send an icmp packet back to the ip level,
  * after supplying a checksum.
  */
 /*
  * Send an icmp packet back to the ip level,
  * after supplying a checksum.
  */

-icmp_send(ip, opts)
-       register struct ip *ip;
+void
+icmp_send(m, opts)
+       register struct mbuf *m;

        struct mbuf *opts;
 {
        struct mbuf *opts;
 {

+       register struct ip *ip = mtod(m, struct ip *);

        register int hlen;
        register struct icmp *icp;
        register int hlen;
        register struct icmp *icp;

-       register struct mbuf *m;

 
 

-       m = dtom(ip);

        hlen = ip->ip_hl << 2;
        hlen = ip->ip_hl << 2;

-       m->m_off += hlen;
+       m->m_data += hlen;

        m->m_len -= hlen;
        icp = mtod(m, struct icmp *);
        icp->icmp_cksum = 0;
        icp->icmp_cksum = in_cksum(m, ip->ip_len - hlen);
        m->m_len -= hlen;
        icp = mtod(m, struct icmp *);
        icp->icmp_cksum = 0;
        icp->icmp_cksum = in_cksum(m, ip->ip_len - hlen);

-       m->m_off -= hlen;
+       m->m_data -= hlen;

        m->m_len += hlen;
 #ifdef ICMPPRINTFS
        if (icmpprintfs)
                printf("icmp_send dst %x src %x\n", ip->ip_dst, ip->ip_src);
 #endif
        m->m_len += hlen;
 #ifdef ICMPPRINTFS
        if (icmpprintfs)
                printf("icmp_send dst %x src %x\n", ip->ip_dst, ip->ip_src);
 #endif

-       (void) ip_output(m, opts, (struct route *)0, 0);
+       (void) ip_output(m, opts, NULL, 0, NULL);

 }
 
 n_time
 }
 
 n_time


@@ -431,3 +549,27 @@ iptime()
        t = (atv.tv_sec % (24*60*60)) * 1000 + atv.tv_usec / 1000;
        return (htonl(t));
 }
        t = (atv.tv_sec % (24*60*60)) * 1000 + atv.tv_usec / 1000;
        return (htonl(t));
 }

+
+int
+icmp_sysctl(name, namelen, oldp, oldlenp, newp, newlen)
+       int *name;
+       u_int namelen;
+       void *oldp;
+       size_t *oldlenp;
+       void *newp;
+       size_t newlen;
+{
+       extern int ip_ttl;
+
+       /* all sysctl names at this level are terminal */
+       if (namelen != 1)
+               return (ENOTDIR);
+
+       switch (name[0]) {
+       case ICMPCTL_MASKREPL:
+               return (sysctl_int(oldp, oldlenp, newp, newlen, &icmpmaskrepl));
+       default:
+               return (ENOPROTOOPT);
+       }
+       /* NOTREACHED */
+}