Return to ip_icmp.c CVS log

Up to [Net/2] / Net2 / netinet

Annotation of Net2/netinet/ip_icmp.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
        !             3:  * 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. All advertising materials mentioning features or use of this software
        !            14:  *    must display the following acknowledgement:
        !            15:  *     This product includes software developed by the University of
        !            16:  *     California, Berkeley and its contributors.
        !            17:  * 4. Neither the name of the University nor the names of its contributors
        !            18:  *    may be used to endorse or promote products derived from this software
        !            19:  *    without specific prior written permission.
        !            20:  *
        !            21:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
        !            22:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            23:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            24:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
        !            25:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        !            26:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
        !            27:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
        !            28:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
        !            29:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
        !            30:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
        !            31:  * SUCH DAMAGE.
        !            32:  *
        !            33:  *     @(#)ip_icmp.c   7.15 (Berkeley) 4/20/91
        !            34:  */
        !            35: 
        !            36: #include "param.h"
        !            37: #include "systm.h"
        !            38: #include "malloc.h"
        !            39: #include "mbuf.h"
        !            40: #include "protosw.h"
        !            41: #include "socket.h"
        !            42: #include "time.h"
        !            43: #include "kernel.h"
        !            44: 
        !            45: #include "../net/route.h"
        !            46: #include "../net/if.h"
        !            47: 
        !            48: #include "in.h"
        !            49: #include "in_systm.h"
        !            50: #include "in_var.h"
        !            51: #include "ip.h"
        !            52: #include "ip_icmp.h"
        !            53: #include "icmp_var.h"
        !            54: 
        !            55: /*
        !            56:  * ICMP routines: error generation, receive packet processing, and
        !            57:  * routines to turnaround packets back to the originator, and
        !            58:  * host table maintenance routines.
        !            59:  */
        !            60: #ifdef ICMPPRINTFS
        !            61: int    icmpprintfs = 0;
        !            62: #endif
        !            63: 
        !            64: extern struct protosw inetsw[];
        !            65: 
        !            66: /*
        !            67:  * Generate an error packet of type error
        !            68:  * in response to bad packet ip.
        !            69:  */
        !            70: /*VARARGS3*/
        !            71: icmp_error(n, type, code, dest)
        !            72:        struct mbuf *n;
        !            73:        int type, code;
        !            74:        struct in_addr dest;
        !            75: {
        !            76:        register struct ip *oip = mtod(n, struct ip *), *nip;
        !            77:        register unsigned oiplen = oip->ip_hl << 2;
        !            78:        register struct icmp *icp;
        !            79:        register struct mbuf *m;
        !            80:        unsigned icmplen;
        !            81: 
        !            82: #ifdef ICMPPRINTFS
        !            83:        if (icmpprintfs)
        !            84:                printf("icmp_error(%x, %d, %d)\n", oip, type, code);
        !            85: #endif
        !            86:        if (type != ICMP_REDIRECT)
        !            87:                icmpstat.icps_error++;
        !            88:        /*
        !            89:         * Don't send error if not the first fragment of message.
        !            90:         * Don't error if the old packet protocol was ICMP
        !            91:         * error message, only known informational types.
        !            92:         */
        !            93:        if (oip->ip_off &~ (IP_MF|IP_DF))
        !            94:                goto freeit;
        !            95:        if (oip->ip_p == IPPROTO_ICMP && type != ICMP_REDIRECT &&
        !            96:          n->m_len >= oiplen + ICMP_MINLEN &&
        !            97:          !ICMP_INFOTYPE(((struct icmp *)((caddr_t)oip + oiplen))->icmp_type)) {
        !            98:                icmpstat.icps_oldicmp++;
        !            99:                goto freeit;
        !           100:        }
        !           101: 
        !           102:        /*
        !           103:         * First, formulate icmp message
        !           104:         */
        !           105:        m = m_gethdr(M_DONTWAIT, MT_HEADER);
        !           106:        if (m == NULL)
        !           107:                goto freeit;
        !           108:        icmplen = oiplen + min(8, oip->ip_len);
        !           109:        m->m_len = icmplen + ICMP_MINLEN;
        !           110:        MH_ALIGN(m, m->m_len);
        !           111:        icp = mtod(m, struct icmp *);
        !           112:        if ((u_int)type > ICMP_MAXTYPE)
        !           113:                panic("icmp_error");
        !           114:        icmpstat.icps_outhist[type]++;
        !           115:        icp->icmp_type = type;
        !           116:        if (type == ICMP_REDIRECT)
        !           117:                icp->icmp_gwaddr = dest;
        !           118:        else
        !           119:                icp->icmp_void = 0;
        !           120:        if (type == ICMP_PARAMPROB) {
        !           121:                icp->icmp_pptr = code;
        !           122:                code = 0;
        !           123:        }
        !           124:        icp->icmp_code = code;
        !           125:        bcopy((caddr_t)oip, (caddr_t)&icp->icmp_ip, icmplen);
        !           126:        nip = &icp->icmp_ip;
        !           127:        nip->ip_len = htons((u_short)(nip->ip_len + oiplen));
        !           128: 
        !           129:        /*
        !           130:         * Now, copy old ip header (without options)
        !           131:         * in front of icmp message.
        !           132:         */
        !           133:        if (m->m_data - sizeof(struct ip) < m->m_pktdat)
        !           134:                panic("icmp len");
        !           135:        m->m_data -= sizeof(struct ip);
        !           136:        m->m_len += sizeof(struct ip);
        !           137:        m->m_pkthdr.len = m->m_len;
        !           138:        m->m_pkthdr.rcvif = n->m_pkthdr.rcvif;
        !           139:        nip = mtod(m, struct ip *);
        !           140:        bcopy((caddr_t)oip, (caddr_t)nip, oiplen);
        !           141:        nip->ip_len = m->m_len;
        !           142:        nip->ip_hl = sizeof(struct ip) >> 2;
        !           143:        nip->ip_p = IPPROTO_ICMP;
        !           144:        icmp_reflect(m);
        !           145: 
        !           146: freeit:
        !           147:        m_freem(n);
        !           148: }
        !           149: 
        !           150: static struct sockproto icmproto = { AF_INET, IPPROTO_ICMP };
        !           151: static struct sockaddr_in icmpsrc = { sizeof (struct sockaddr_in), AF_INET };
        !           152: static struct sockaddr_in icmpdst = { sizeof (struct sockaddr_in), AF_INET };
        !           153: static struct sockaddr_in icmpgw = { sizeof (struct sockaddr_in), AF_INET };
        !           154: struct sockaddr_in icmpmask = { 8, 0 };
        !           155: struct in_ifaddr *ifptoia();
        !           156: 
        !           157: /*
        !           158:  * Process a received ICMP message.
        !           159:  */
        !           160: icmp_input(m, hlen)
        !           161:        register struct mbuf *m;
        !           162:        int hlen;
        !           163: {
        !           164:        register struct icmp *icp;
        !           165:        register struct ip *ip = mtod(m, struct ip *);
        !           166:        int icmplen = ip->ip_len;
        !           167:        register int i;
        !           168:        struct in_ifaddr *ia;
        !           169:        int (*ctlfunc)(), code;
        !           170:        extern u_char ip_protox[];
        !           171:        extern struct in_addr in_makeaddr();
        !           172: 
        !           173:        /*
        !           174:         * Locate icmp structure in mbuf, and check
        !           175:         * that not corrupted and of at least minimum length.
        !           176:         */
        !           177: #ifdef ICMPPRINTFS
        !           178:        if (icmpprintfs)
        !           179:                printf("icmp_input from %x, len %d\n", ip->ip_src, icmplen);
        !           180: #endif
        !           181:        if (icmplen < ICMP_MINLEN) {
        !           182:                icmpstat.icps_tooshort++;
        !           183:                goto freeit;
        !           184:        }
        !           185:        i = hlen + MIN(icmplen, ICMP_ADVLENMIN);
        !           186:        if (m->m_len < i && (m = m_pullup(m, i)) == 0)  {
        !           187:                icmpstat.icps_tooshort++;
        !           188:                return;
        !           189:        }
        !           190:        ip = mtod(m, struct ip *);
        !           191:        m->m_len -= hlen;
        !           192:        m->m_data += hlen;
        !           193:        icp = mtod(m, struct icmp *);
        !           194:        if (in_cksum(m, icmplen)) {
        !           195:                icmpstat.icps_checksum++;
        !           196:                goto freeit;
        !           197:        }
        !           198:        m->m_len += hlen;
        !           199:        m->m_data -= hlen;
        !           200: 
        !           201: #ifdef ICMPPRINTFS
        !           202:        /*
        !           203:         * Message type specific processing.
        !           204:         */
        !           205:        if (icmpprintfs)
        !           206:                printf("icmp_input, type %d code %d\n", icp->icmp_type,
        !           207:                    icp->icmp_code);
        !           208: #endif
        !           209:        if (icp->icmp_type > ICMP_MAXTYPE)
        !           210:                goto raw;
        !           211:        icmpstat.icps_inhist[icp->icmp_type]++;
        !           212:        code = icp->icmp_code;
        !           213:        switch (icp->icmp_type) {
        !           214: 
        !           215:        case ICMP_UNREACH:
        !           216:                if (code > 5)
        !           217:                        goto badcode;
        !           218:                code += PRC_UNREACH_NET;
        !           219:                goto deliver;
        !           220: 
        !           221:        case ICMP_TIMXCEED:
        !           222:                if (code > 1)
        !           223:                        goto badcode;
        !           224:                code += PRC_TIMXCEED_INTRANS;
        !           225:                goto deliver;
        !           226: 
        !           227:        case ICMP_PARAMPROB:
        !           228:                if (code)
        !           229:                        goto badcode;
        !           230:                code = PRC_PARAMPROB;
        !           231:                goto deliver;
        !           232: 
        !           233:        case ICMP_SOURCEQUENCH:
        !           234:                if (code)
        !           235:                        goto badcode;
        !           236:                code = PRC_QUENCH;
        !           237:        deliver:
        !           238:                /*
        !           239:                 * Problem with datagram; advise higher level routines.
        !           240:                 */
        !           241:                if (icmplen < ICMP_ADVLENMIN || icmplen < ICMP_ADVLEN(icp) ||
        !           242:                    icp->icmp_ip.ip_hl < (sizeof(struct ip) >> 2)) {
        !           243:                        icmpstat.icps_badlen++;
        !           244:                        goto freeit;
        !           245:                }
        !           246:                NTOHS(icp->icmp_ip.ip_len);
        !           247: #ifdef ICMPPRINTFS
        !           248:                if (icmpprintfs)
        !           249:                        printf("deliver to protocol %d\n", icp->icmp_ip.ip_p);
        !           250: #endif
        !           251:                icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
        !           252:                if (ctlfunc = inetsw[ip_protox[icp->icmp_ip.ip_p]].pr_ctlinput)
        !           253:                        (*ctlfunc)(code, (struct sockaddr *)&icmpsrc,
        !           254:                            (caddr_t) &icp->icmp_ip);
        !           255:                break;
        !           256: 
        !           257:        badcode:
        !           258:                icmpstat.icps_badcode++;
        !           259:                break;
        !           260: 
        !           261:        case ICMP_ECHO:
        !           262:                icp->icmp_type = ICMP_ECHOREPLY;
        !           263:                goto reflect;
        !           264: 
        !           265:        case ICMP_TSTAMP:
        !           266:                if (icmplen < ICMP_TSLEN) {
        !           267:                        icmpstat.icps_badlen++;
        !           268:                        break;
        !           269:                }
        !           270:                icp->icmp_type = ICMP_TSTAMPREPLY;
        !           271:                icp->icmp_rtime = iptime();
        !           272:                icp->icmp_ttime = icp->icmp_rtime;      /* bogus, do later! */
        !           273:                goto reflect;
        !           274:                
        !           275:        case ICMP_IREQ:
        !           276: #define        satosin(sa)     ((struct sockaddr_in *)(sa))
        !           277:                if (in_netof(ip->ip_src) == 0 &&
        !           278:                    (ia = ifptoia(m->m_pkthdr.rcvif)))
        !           279:                        ip->ip_src = in_makeaddr(in_netof(IA_SIN(ia)->sin_addr),
        !           280:                            in_lnaof(ip->ip_src));
        !           281:                icp->icmp_type = ICMP_IREQREPLY;
        !           282:                goto reflect;
        !           283: 
        !           284:        case ICMP_MASKREQ:
        !           285:                if (icmplen < ICMP_MASKLEN ||
        !           286:                    (ia = ifptoia(m->m_pkthdr.rcvif)) == 0)
        !           287:                        break;
        !           288:                icp->icmp_type = ICMP_MASKREPLY;
        !           289:                icp->icmp_mask = ia->ia_sockmask.sin_addr.s_addr;
        !           290:                if (ip->ip_src.s_addr == 0) {
        !           291:                        if (ia->ia_ifp->if_flags & IFF_BROADCAST)
        !           292:                            ip->ip_src = satosin(&ia->ia_broadaddr)->sin_addr;
        !           293:                        else if (ia->ia_ifp->if_flags & IFF_POINTOPOINT)
        !           294:                            ip->ip_src = satosin(&ia->ia_dstaddr)->sin_addr;
        !           295:                }
        !           296: reflect:
        !           297:                ip->ip_len += hlen;     /* since ip_input deducts this */
        !           298:                icmpstat.icps_reflect++;
        !           299:                icmpstat.icps_outhist[icp->icmp_type]++;
        !           300:                icmp_reflect(m);
        !           301:                return;
        !           302: 
        !           303:        case ICMP_REDIRECT:
        !           304:                if (icmplen < ICMP_ADVLENMIN || icmplen < ICMP_ADVLEN(icp)) {
        !           305:                        icmpstat.icps_badlen++;
        !           306:                        break;
        !           307:                }
        !           308:                /*
        !           309:                 * Short circuit routing redirects to force
        !           310:                 * immediate change in the kernel's routing
        !           311:                 * tables.  The message is also handed to anyone
        !           312:                 * listening on a raw socket (e.g. the routing
        !           313:                 * daemon for use in updating its tables).
        !           314:                 */
        !           315:                icmpgw.sin_addr = ip->ip_src;
        !           316:                icmpdst.sin_addr = icp->icmp_gwaddr;
        !           317: #ifdef ICMPPRINTFS
        !           318:                if (icmpprintfs)
        !           319:                        printf("redirect dst %x to %x\n", icp->icmp_ip.ip_dst,
        !           320:                                icp->icmp_gwaddr);
        !           321: #endif
        !           322:                if (code == ICMP_REDIRECT_NET || code == ICMP_REDIRECT_TOSNET) {
        !           323:                        u_long in_netof();
        !           324:                        icmpsrc.sin_addr =
        !           325:                         in_makeaddr(in_netof(icp->icmp_ip.ip_dst), INADDR_ANY);
        !           326:                        in_sockmaskof(icp->icmp_ip.ip_dst, &icmpmask);
        !           327:                        rtredirect((struct sockaddr *)&icmpsrc,
        !           328:                          (struct sockaddr *)&icmpdst,
        !           329:                          (struct sockaddr *)&icmpmask, RTF_GATEWAY,
        !           330:                          (struct sockaddr *)&icmpgw, (struct rtentry **)0);
        !           331:                        icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
        !           332:                        pfctlinput(PRC_REDIRECT_NET,
        !           333:                          (struct sockaddr *)&icmpsrc);
        !           334:                } else {
        !           335:                        icmpsrc.sin_addr = icp->icmp_ip.ip_dst;
        !           336:                        rtredirect((struct sockaddr *)&icmpsrc,
        !           337:                          (struct sockaddr *)&icmpdst,
        !           338:                          (struct sockaddr *)0, RTF_GATEWAY | RTF_HOST,
        !           339:                          (struct sockaddr *)&icmpgw, (struct rtentry **)0);
        !           340:                        pfctlinput(PRC_REDIRECT_HOST,
        !           341:                          (struct sockaddr *)&icmpsrc);
        !           342:                }
        !           343:                break;
        !           344: 
        !           345:        /*
        !           346:         * No kernel processing for the following;
        !           347:         * just fall through to send to raw listener.
        !           348:         */
        !           349:        case ICMP_ECHOREPLY:
        !           350:        case ICMP_TSTAMPREPLY:
        !           351:        case ICMP_IREQREPLY:
        !           352:        case ICMP_MASKREPLY:
        !           353:        default:
        !           354:                break;
        !           355:        }
        !           356: 
        !           357: raw:
        !           358:        icmpsrc.sin_addr = ip->ip_src;
        !           359:        icmpdst.sin_addr = ip->ip_dst;
        !           360:        (void) raw_input(m, &icmproto, (struct sockaddr *)&icmpsrc,
        !           361:            (struct sockaddr *)&icmpdst);
        !           362:        return;
        !           363: 
        !           364: freeit:
        !           365:        m_freem(m);
        !           366: }
        !           367: 
        !           368: /*
        !           369:  * Reflect the ip packet back to the source
        !           370:  */
        !           371: icmp_reflect(m)
        !           372:        struct mbuf *m;
        !           373: {
        !           374:        register struct ip *ip = mtod(m, struct ip *);
        !           375:        register struct in_ifaddr *ia;
        !           376:        struct in_addr t;
        !           377:        struct mbuf *opts = 0, *ip_srcroute();
        !           378:        int optlen = (ip->ip_hl << 2) - sizeof(struct ip);
        !           379: 
        !           380:        t = ip->ip_dst;
        !           381:        ip->ip_dst = ip->ip_src;
        !           382:        /*
        !           383:         * If the incoming packet was addressed directly to us,
        !           384:         * use dst as the src for the reply.  Otherwise (broadcast
        !           385:         * or anonymous), use the address which corresponds
        !           386:         * to the incoming interface.
        !           387:         */
        !           388:        for (ia = in_ifaddr; ia; ia = ia->ia_next) {
        !           389:                if (t.s_addr == IA_SIN(ia)->sin_addr.s_addr)
        !           390:                        break;
        !           391:                if ((ia->ia_ifp->if_flags & IFF_BROADCAST) &&
        !           392:                    t.s_addr == satosin(&ia->ia_broadaddr)->sin_addr.s_addr)
        !           393:                        break;
        !           394:        }
        !           395:        if (ia == (struct in_ifaddr *)0)
        !           396:                ia = ifptoia(m->m_pkthdr.rcvif);
        !           397:        if (ia == (struct in_ifaddr *)0)
        !           398:                ia = in_ifaddr;
        !           399:        t = IA_SIN(ia)->sin_addr;
        !           400:        ip->ip_src = t;
        !           401:        ip->ip_ttl = MAXTTL;
        !           402: 
        !           403:        if (optlen > 0) {
        !           404:                register u_char *cp;
        !           405:                int opt, cnt;
        !           406:                u_int len;
        !           407: 
        !           408:                /*
        !           409:                 * Retrieve any source routing from the incoming packet;
        !           410:                 * add on any record-route or timestamp options.
        !           411:                 */
        !           412:                cp = (u_char *) (ip + 1);
        !           413:                if ((opts = ip_srcroute()) == 0 &&
        !           414:                    (opts = m_gethdr(M_DONTWAIT, MT_HEADER))) {
        !           415:                        opts->m_len = sizeof(struct in_addr);
        !           416:                        mtod(opts, struct in_addr *)->s_addr = 0;
        !           417:                }
        !           418:                if (opts) {
        !           419: #ifdef ICMPPRINTFS
        !           420:                    if (icmpprintfs)
        !           421:                            printf("icmp_reflect optlen %d rt %d => ",
        !           422:                                optlen, opts->m_len);
        !           423: #endif
        !           424:                    for (cnt = optlen; cnt > 0; cnt -= len, cp += len) {
        !           425:                            opt = cp[IPOPT_OPTVAL];
        !           426:                            if (opt == IPOPT_EOL)
        !           427:                                    break;
        !           428:                            if (opt == IPOPT_NOP)
        !           429:                                    len = 1;
        !           430:                            else {
        !           431:                                    len = cp[IPOPT_OLEN];
        !           432:                                    if (len <= 0 || len > cnt)
        !           433:                                            break;
        !           434:                            }
        !           435:                            /*
        !           436:                             * should check for overflow, but it "can't happen"
        !           437:                             */
        !           438:                            if (opt == IPOPT_RR || opt == IPOPT_TS) {
        !           439:                                    bcopy((caddr_t)cp,
        !           440:                                        mtod(opts, caddr_t) + opts->m_len, len);
        !           441:                                    opts->m_len += len;
        !           442:                            }
        !           443:                    }
        !           444:                    if (opts->m_len % 4 != 0) {
        !           445:                            *(mtod(opts, caddr_t) + opts->m_len) = IPOPT_EOL;
        !           446:                            opts->m_len++;
        !           447:                    }
        !           448: #ifdef ICMPPRINTFS
        !           449:                    if (icmpprintfs)
        !           450:                            printf("%d\n", opts->m_len);
        !           451: #endif
        !           452:                }
        !           453:                /*
        !           454:                 * Now strip out original options by copying rest of first
        !           455:                 * mbuf's data back, and adjust the IP length.
        !           456:                 */
        !           457:                ip->ip_len -= optlen;
        !           458:                ip->ip_hl = sizeof(struct ip) >> 2;
        !           459:                m->m_len -= optlen;
        !           460:                if (m->m_flags & M_PKTHDR)
        !           461:                        m->m_pkthdr.len -= optlen;
        !           462:                optlen += sizeof(struct ip);
        !           463:                bcopy((caddr_t)ip + optlen, (caddr_t)(ip + 1),
        !           464:                         (unsigned)(m->m_len - sizeof(struct ip)));
        !           465:        }
        !           466:        icmp_send(m, opts);
        !           467:        if (opts)
        !           468:                (void)m_free(opts);
        !           469: }
        !           470: 
        !           471: struct in_ifaddr *
        !           472: ifptoia(ifp)
        !           473:        struct ifnet *ifp;
        !           474: {
        !           475:        register struct in_ifaddr *ia;
        !           476: 
        !           477:        for (ia = in_ifaddr; ia; ia = ia->ia_next)
        !           478:                if (ia->ia_ifp == ifp)
        !           479:                        return (ia);
        !           480:        return ((struct in_ifaddr *)0);
        !           481: }
        !           482: 
        !           483: /*
        !           484:  * Send an icmp packet back to the ip level,
        !           485:  * after supplying a checksum.
        !           486:  */
        !           487: icmp_send(m, opts)
        !           488:        register struct mbuf *m;
        !           489:        struct mbuf *opts;
        !           490: {
        !           491:        register struct ip *ip = mtod(m, struct ip *);
        !           492:        register int hlen;
        !           493:        register struct icmp *icp;
        !           494: 
        !           495:        hlen = ip->ip_hl << 2;
        !           496:        m->m_data += hlen;
        !           497:        m->m_len -= hlen;
        !           498:        icp = mtod(m, struct icmp *);
        !           499:        icp->icmp_cksum = 0;
        !           500:        icp->icmp_cksum = in_cksum(m, ip->ip_len - hlen);
        !           501:        m->m_data -= hlen;
        !           502:        m->m_len += hlen;
        !           503: #ifdef ICMPPRINTFS
        !           504:        if (icmpprintfs)
        !           505:                printf("icmp_send dst %x src %x\n", ip->ip_dst, ip->ip_src);
        !           506: #endif
        !           507:        (void) ip_output(m, opts, (struct route *)0, 0);
        !           508: }
        !           509: 
        !           510: n_time
        !           511: iptime()
        !           512: {
        !           513:        struct timeval atv;
        !           514:        u_long t;
        !           515: 
        !           516:        microtime(&atv);
        !           517:        t = (atv.tv_sec % (24*60*60)) * 1000 + atv.tv_usec / 1000;
        !           518:        return (htonl(t));
        !           519: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.