{                    /*                      * If the metric changed then we should change our                      * route. Also if this is a valid update with                      * metric of 15 and we have already deleted the                      * route from the routing database we should                      * revalidate the route in our table and add it                      * back to the system database                      */                    if ((n->rip_metric != rt->rt_metric) ||                         (n->rip_metric == HOPCNT_INFINITY))                         {                        /*                          * If this is a repeat advertisement of an                          * unreachable destination, ignore it.                          * Ignore it also if we have already expired                          * this route and are being informed that it                          * has expired. We have acted on it once already.                          */                        if ((origMetric == HOPCNT_INFINITY) &&                             (rt->rt_metric == HOPCNT_INFINITY) &&                             !rt->inKernel &&                             (rt->rt_timer >= ripState.expire))                             break;			/*			 * If the advertised metric is (HOPCNT_INFINITY -1),			 * a valid metric, check to see what we should			 * do with it. If we already have the route			 * in the system table, reset the timer,			 * else trick rtchange() into adding the route back			 */			if (origMetric == (HOPCNT_INFINITY - 1))			    {			    if (rt->inKernel)                                 {                                rt->rt_timer = 0;                                 /* Update age for IP group MIB. */                                 ripRouteAgeUpdate (rt);                                break;                                }                             else                                 n->rip_metric++;                            }                        if (rip->rip_vers > 1)                            {                            rtchange(rt, &gateway, n->rip_metric,                                     &netmask, tag, 0, NULL);                            }                        else                            {                            rtchange(rt, from, n->rip_metric, NULL, 0, 0,                                      NULL);                            }                        changes++;                        rt->rt_timer = 0;                        if (origMetric == HOPCNT_INFINITY)                            rt->rt_timer = ripState.expire;                        else if (rt->inKernel)                             {                            /* Update age for IP group MIB. */                             ripRouteAgeUpdate (rt);                            }                        }                    else if (rt->rt_metric < HOPCNT_INFINITY)                        {                        rt->rt_timer = 0;                        /* Update age for IP group MIB. */                        if (rt->inKernel)                             ripRouteAgeUpdate (rt);                         /*                         * Metric is same. Check if either the next hop                         * or the tag changed, for a V2 packet. If it did,                         * we need to record the change                         */                        if ((rip->rip_vers > 1) &&                             ((((RIP2PKT *)n)->tag != rt->rt_tag) ||                              (memcmp(&gateway, &(rt->rt_router),                                      sizeof(gateway)) != 0)))                             {                            rtchange(rt, &gateway, n->rip_metric,                                     &netmask, tag, 0, NULL);                            }                        }                    }                else if ((unsigned) n->rip_metric < rt->rt_metric ||                         (rt->rt_metric == n->rip_metric &&                          rt->rt_timer > (ripState.expire/2) &&                          (unsigned) origMetric < HOPCNT_INFINITY))                    {                    if (rip->rip_vers > 1)                        {                        rtchange(rt, &gateway, n->rip_metric,                                 &netmask, tag,                                  ((struct sockaddr_in *)from)->                                 sin_addr.s_addr, NULL);                        }                    else                        {                        rtchange(rt, from, n->rip_metric, NULL, 0,                                 ((struct sockaddr_in *)from)->                                 sin_addr.s_addr, NULL);                        }                    changes++;                    rt->rt_timer = 0;                    /* Update age for IP group MIB. */                    if (rt->inKernel)                         ripRouteAgeUpdate (rt);                     }                }            break;        default:            /*              * Ignore any unrecognized commands. Return from the routine             * to prevent any possibility of scheduling a triggered update.             */            pErrorIfp->ifStat.rip2IfStatRcvBadPackets++;            return;          }        /*     * This section of code schedules triggered updates whenever entries in     * the routing table change. No updates are sent for silent RIP     * configurations and are also suppressed if a regular update will     * occur within the next MAX_WAITTIME seconds.     */    if (changes && ripState.supplier &&        ripState.now.tv_sec - ripState.lastfullupdate.tv_sec <             ripState.supplyInterval - MAX_WAITTIME)        {        /*         * No regular update is imminent. Check the elapsed time since         * the previous (regular or triggered) update and the time limit         * of the "nextbcast" quiet period which restricts the update         * frequency.          */        if (ripState.now.tv_sec - ripState.lastbcast.tv_sec >= MIN_WAITTIME            && (ripState.nextbcast.tv_sec < ripState.now.tv_sec))            {            /*             * All conditions have been met. Send a triggered update over the              * interfaces which did not receive the RIP response. The message              * sent over each interface only includes routes which changed              * since the last message sent.             */            if (routedDebug)                logMsg ("send dynamic update\n", 0, 0, 0, 0, 0, 0);            ifp->ifStat.rip2IfStatSentUpdates++;            toall (supply, RTS_CHANGED, ifp);            ripState.lastbcast = ripState.now;            ripState.needupdate = 0;            ripState.nextbcast.tv_sec = 0;            }        else            {            /*             * The triggered update can't be sent because of frequency              * limitations imposed to prevent excessive network traffic.             * Set the delayed update indicator so that the update will             * be sent when possible.             */            ripState.needupdate++;            }                if (ripState.nextbcast.tv_sec == 0)            {            /*             * Select the earliest possible time for the next triggered              * update. A random value is used to avoid periodic network             * congestion from synchronized routers.             */            u_long delay = RANDOMDELAY();            ripState.nextbcast.tv_sec = delay / 1000000;            ripState.nextbcast.tv_usec = delay % 100000;            timevaladd (&ripState.nextbcast, &ripState.now);            /*             * If the earliest allowable update occurs within MIN_WAITTIME              * seconds before the next regular update, force the delay past              * that point to avoid a redundant triggered update.             */            if (ripState.nextbcast.tv_sec >                ripState.lastfullupdate.tv_sec +                ripState.supplyInterval - MIN_WAITTIME)                {                ripState.nextbcast.tv_sec =                    ripState.lastfullupdate.tv_sec +                    ripState.supplyInterval + 1;                }            }        }    }/*  * This pseudo-random number generator restricts the frequency of triggered * updates. It was plagiarized shamelessly from FreeBSD 2.1.7 where it was  * used for the same purpose by routed. */LOCAL u_long ripRandTime (void)    {    register long x, hi, lo, t;    /*     * Compute x[n + 1] = (7^5 * x[n]) mod (2^31 - 1).    * From "Random number generators: good ones are hard to find",     * Park and Miller, Communications of the ACM, vol. 31, no. 10,     * October 1988, p. 1195.     */    x = ripRandTimeSeed;    hi = x / 127773;    lo = x % 127773;    t = 16807 * lo - 2836 * hi;    if (t <= 0)        t += 0x7fffffff;    ripRandTimeSeed = t;    return (t);    }/****************************************************************************** ripRouteAgeUpdate - update the age for the RIP route** This routine updates the age of the RIP route that is kept in the* system Routing database.* The parameter <pRtEntry> describes the RIP route that is kept in RIP's* private database.** This routine constructs a ROUTE DESCRIPTOR structure from the supplied* parameter <pRtEntry> that describes the route whose age is to be updated* and calls the routing extensions function routeAgeSet() to set the new* age. tickGet() is used to get the current tick count and is used as the* new age.** RETURNS: N/A** ERRNO: N/A** NOMANUAL*/LOCAL void ripRouteAgeUpdate     (    struct rt_entry *	pRtEntry	/* Route entry describing the */    					/* RIP route to update */    )    {    struct sockaddr_in *	pDsin;    struct sockaddr_in * pGsin;    struct sockaddr_in * pNsin;        /*     * Retrieve the destination and netmask values from the     * corresponding fields in the RIP route entry structure     */    ripRouteToAddrs (pRtEntry, &pDsin, &pGsin, &pNsin);    /*      * If it is a host route, set netmask to NULL. RIP internally     * assigns a host route the netmask of the interface. But the system     * overrides that and stores the route as a host route with a NULL mask.     * (which is the right thing to do). So we set the netmask field to     * NULL so that the route lookup happens fine.     */    if (pRtEntry->rt_flags & RTF_HOST)        pNsin = NULL;    if (routedDebug > 2)        {        logMsg ("ripRouteAgeUpdate: setting new age = %d for\n",                 tickGet (), 0, 0, 0, 0, 0);        ripSockaddrPrint ((struct sockaddr *)pDsin);        ripSockaddrPrint ((struct sockaddr *)pNsin);        ripSockaddrPrint ((struct sockaddr *)pGsin);        }    /* Now set the route age */    if (routeAgeSet ((struct sockaddr *)pDsin, (struct sockaddr *)pNsin,                      M2_ipRouteProto_rip, tickGet ()) == ERROR)         {        if (routedDebug)             logMsg ("Couldn't set age for rtEntry = %x.\n", (int)pRtEntry, 0,                     0, 0, 0, 0);        }    }