if (pErrorIfp->authHook(pErrorIfp->ifConf.                                                       rip2IfConfAuthKey,                                            rip) != OK)                        {                        pErrorIfp->ifStat.rip2IfStatRcvBadPackets++;                        return;                        }                    }                else                    {                    if (routedDebug)                        logMsg("Discarding unvalidated RIP version %d message.\n",                               rip->rip_vers, 0, 0, 0, 0, 0);                    pErrorIfp->ifStat.rip2IfStatRcvBadPackets++;                    return;                    }                }            }        else /* unknown auth type */            {            if (routedDebug)                logMsg("Discarding unvalidated RIP version %d message (Unknown auth type).\n",                       rip->rip_vers, 0, 0, 0, 0, 0);            pErrorIfp->ifStat.rip2IfStatRcvBadPackets++;            return;            }        /* Skip the first rip entry which was used for authentication */        pFirst = n = rip->rip_nets + 1;        }    if (size > RIP_MAX_PACKET)        {        if (routedDebug)            logMsg ("Packet too large from %s. (cmd %d)\n",                     (int)(*afswitch[from->sa_family].af_format)(from),                     rip->rip_cmd, 0, 0, 0, 0);        pErrorIfp->ifStat.rip2IfStatRcvBadPackets++;        return;        }    if (((size - 4) % 20) != 0)        {        if (routedDebug)            logMsg("Badly formed packet from %s. (cmd %d)\n",                    (int)(*afswitch[from->sa_family].af_format)(from),                    rip->rip_cmd, 0, 0, 0, 0);        pErrorIfp->ifStat.rip2IfStatRcvBadPackets++;        return;        }        /* Check that the unused RIP header field contains 0 if required. */    if (rip->rip_vers == 1)        {        if (rip->rip_domain[0] != 0 || rip->rip_domain[1] != 0)            {            pErrorIfp->ifStat.rip2IfStatRcvBadPackets++;            return ;            }        }    /*     * Process the received message. RIP responses will exit the switch     * statement so that triggered updates will be scheduled if necessary.     * All other commands must execute return statements within the switch     * to prevent that activity.     */    switch (rip->rip_cmd)        {        case RIPCMD_REQUEST:            /*             * Preserve port number before converting source address to             * canonical form for testing against local interface addresses.             */            ((struct sockaddr_in *)&gateway)->sin_port =                 ((struct sockaddr_in *)from)->sin_port;                        /* Ignore requests reflected from a local interface. */            (*afp->af_canon) (from);            ifp = ripIfWithAddr (from);            if (ifp)                return;            /* Restore the port number for requests from valid interfaces. */            ((struct sockaddr_in *)from)->sin_port =                 ((struct sockaddr_in *)&gateway)->sin_port;            /*             * Determine number of entries in message. If there are no             * entries, no response is given.             */            count = size - ((char *)n - (char *)rip);            if (count < sizeof (struct netinfo))                return;            for (; count > 0; n++)                {                if (count < sizeof (struct netinfo))                    break;                count -= sizeof (struct netinfo);                if (rip->rip_vers == 1)                    {                    if ( ((RIP2PKT *)n)->tag != 0)                        {                        pErrorIfp->ifStat.rip2IfStatRcvBadRoutes++;                        continue;                        }                    if ( ((RIP2PKT *)n)->subnet != 0)                        {                        pErrorIfp->ifStat.rip2IfStatRcvBadRoutes++;                        continue;                        }                    if ( ((RIP2PKT *)n)->gateway != 0)                        {                        pErrorIfp->ifStat.rip2IfStatRcvBadRoutes++;                        continue;                        }                    }                                n->rip_dst.sa_family = ntohs (osa (n->rip_dst)->sa_family);                n->rip_dst.sa_len = sizeof (n->rip_dst);                n->rip_metric = ntohl (n->rip_metric);                /*                  * Check for special case: the entire routing table is                 * sent if the message contains a single entry with a                  * family identifier of 0 (meaning unspecified: AF_UNSPEC)                  * and an infinite metric.                 */                if (n->rip_dst.sa_family == AF_UNSPEC &&                    (count != 0 || n != pFirst))                    {                    /*                     * Ignore entry with family of 0 if the message                      * contains multiple route entries.                     */                    pErrorIfp->ifStat.rip2IfStatRcvBadRoutes++;                    continue;                    }                if (n->rip_dst.sa_family == AF_UNSPEC &&                    n->rip_metric != HOPCNT_INFINITY)                    {                    /*                      * Ignore message with single entry and family of 0                      * if metric is finite.                      */                    pErrorIfp->ifStat.rip2IfStatRcvBadRoutes++;                    return;                    }                if (n->rip_dst.sa_family == AF_UNSPEC)                    {                    /*                      * Send the entire routing table, except for entries                     * learned from the interface which received the request.                     * Silent RIP processes will only respond to a query which                     * used a non-standard port. (RFC 1058, section 3.4.1).                     */                    if (ripState.supplier ||                        (*afp->af_portmatch)(from) == 0)                        {                        supply (from, 0, pErrorIfp, 0, rip->rip_vers);                        ripState.ripGlobal.rip2GlobalQueries++;                        }                    return;                    }                /*                  * Ignore entries with unsupported address families.                 * Currently, only entries with a family of AF_INET                  * are accepted.                 */                if (n->rip_dst.sa_family != AF_INET)                    {                    pErrorIfp->ifStat.rip2IfStatRcvBadRoutes++;                    continue;                    }                if (n->rip_dst.sa_family < AF_MAX &&                    afswitch[n->rip_dst.sa_family].af_hash)                    {                    rt = rtlookup(&n->rip_dst);                    /*                     * If the interface for the route is down, the                     * route is not reachable.                     */                    if (rt->rt_ifp && (rt->rt_ifp->int_flags & IFF_UP) == 0)                        rt = 0;                    }                else                    rt = 0;                n->rip_metric = rt == 0 ? HOPCNT_INFINITY :                    min(rt->rt_metric + 1, HOPCNT_INFINITY);                osa(n->rip_dst)->sa_family =                    htons(n->rip_dst.sa_family);                n->rip_metric = htonl(n->rip_metric);                changes++;                }            /*              * The RFC specification does not clearly define the desired             * behavior for the case where all entries in a request use              * an unknown family. Although the individual entries must             * be ignored, it seems as if a response containing unchanged              * metrics should be returned, but that behavior causes ANVL              * test 6.5 to fail. The following test avoids that problem.             */            if (changes)                {                /* Send a reply if at least one entry was recognized. */                rip->rip_cmd = RIPCMD_RESPONSE;                memmove(ripState.packet, rip, size);                (*afp->af_output)(ripState.s, 0, from, size);                ripState.ripGlobal.rip2GlobalQueries++;                }            return;                    case RIPCMD_TRACEON:        case RIPCMD_TRACEOFF:            /* Obsolete commands ignored by RIP. (RFC 1058, section 3.1) */            if (routedDebug)                logMsg ("Ignoring obsolete trace command from router %s.\n",                        (int)(*afswitch[from->sa_family].af_format)(from),                        0, 0, 0, 0, 0);            pErrorIfp->ifStat.rip2IfStatRcvBadPackets++;            return;                    case RIPCMD_RESPONSE:            /* Verify that the message used the required port. */            if ((*afp->af_portmatch)(from) == 0)                {                pErrorIfp->ifStat.rip2IfStatRcvBadPackets++;                return;                }            /*              * Check for reflected updates from the router's own interface.             * The test also eliminates updates from a directed broadcast             * address which is one of the illegal source addresses forbidden             * by the router requirements RFC.             */            (*afp->af_canon) (from);            ifp = ripIfWithAddr (from);            if (ifp)                {                /*                 * When a router receives an invalid update, it uses it to                  * track the status of a directly connected interface, but                  * the message is otherwise ignored.                 */                if (ifp->int_flags & IFF_PASSIVE)                    {                    if (routedDebug)                        logMsg ("bogus input (from passive interface, %s)\n",                             (int)(*afswitch[from->sa_family].af_format)(from),                                0, 0, 0, 0, 0);                    ifp->ifStat.rip2IfStatRcvBadPackets++;                    return;                    }                /*                  * Search for a route entry to the directly connected network                 * and reset the expiration timer if found. If no such route                 * is present or a non-interface route is detected, the                  * receiving interface was either recently added or restarted.                  * The addrouteforif routine will create a permanent interface                  * route and remove any overlapping (learned) route.                 */                rt = rtfind(from);                if (rt == 0 || (((rt->rt_state & RTS_INTERFACE) == 0) &&                    rt->rt_metric >= ifp->int_metric))                    addrouteforif(ifp);                else                    {                    rt->rt_timer = 0;                    /* Update age for IP group MIB. */                    if (rt->inKernel)                         ripRouteAgeUpdate (rt);