rt->rt_subnets_cnt - 1, TRUE,                         rt->rt_ifp->int_subnetmask);            }        }    free ((char *)rt);        return (OK);    }void rtdeleteall (void)    {    register struct rthash *rh;    register struct rt_entry *rt;    struct rthash *base = hosthash;    int doinghost = 1;        char address[32];    struct sockaddr_in *pDsin;    struct sockaddr_in *pGsin;    struct sockaddr_in *pNsin;    again:    for (rh = base; rh < &base[ROUTEHASHSIZ]; rh++)        {        rt = rh->rt_forw;	for (; rt != (struct rt_entry *)rh;                  rt = ( (struct rt_entry *)rh)->rt_forw)            {            /* Remove the entry from the kernel routing table if present. */            if ( (rt->rt_state & (RTS_INTERNAL|RTS_EXTERNAL|RTS_OTHER)) == 0)                {                ripRouteToAddrs (rt, &pDsin, &pGsin, &pNsin);                inet_ntoa_b (pDsin->sin_addr, (char *)&address);                /*                 * Expired route entries were already removed from the kernel                 * routing table, but may remain in the RIP routing table                 * if the garbage collection interval has not passed.                  * These entries are usually detectable by their infinite                  * metric, but all metrics are infinite in this case.                 * However, the pointer to the kernel route will be                 * NULL, so the following call will not attempt to                 * delete a (non-existent) expired entry.                 */                if (rt->inKernel)                    {                    if (ripSystemRouteDelete (pDsin->sin_addr.s_addr,                                               pGsin->sin_addr.s_addr,                                               pNsin->sin_addr.s_addr,                                               0) == ERROR)                        {                        if (routedDebug)                             logMsg ("Error %x removing route from kernel table.\n",                                     errno, 0, 0, 0, 0, 0);                        }                    else                        {                        rt->inKernel = FALSE;                        ripState.ripGlobal.rip2GlobalRouteChanges++;                        }                    }                }            /* Remove the entry from the RIP routing table. */            ((struct rt_entry *)rh)->rt_forw = rt->rt_forw;            free ((char *)rt);            }        }    if (doinghost)        {        doinghost = 0;        base = nethash;        goto again;        }    return;    }/* * If we have an interface to the wide, wide world, * add an entry for an Internet default route (wildcard) to the internal * tables and advertise it.  This route is not added to the kernel routes, * but this entry prevents us from listening to other people's defaults * and installing them in the kernel here. */void rtdefault (void)    {    rtadd ( (struct sockaddr *)&inet_default, (struct sockaddr *)&inet_default,            1, RTS_CHANGED | RTS_PASSIVE | RTS_INTERNAL, NULL,            M2_ipRouteProto_rip, 0, 0, NULL);    }void routedTableInit (void)    {    register struct rthash *rh;        for (rh = nethash; rh < &nethash[ROUTEHASHSIZ]; rh++)        rh->rt_forw = rh->rt_back = (struct rt_entry *)rh;    for (rh = hosthash; rh < &hosthash[ROUTEHASHSIZ]; rh++)        rh->rt_forw = rh->rt_back = (struct rt_entry *)rh;    }/******************************************************************************** ripSystemRouteAdd - add a RIP route to the system routing database** This routine adds the route to the system routing database using the* method which the particular product supports.** RETURNS: ERROR or OK (return value from selected add method)** ERRNO: N/A** NOMANUAL*/LOCAL STATUS ripSystemRouteAdd     (    long             dstIp,    	/* destination address, network order */    long             gateIp,    	/* gateway address, network order */    long             mask,      	/* mask for destination, network order */    int              flags      	/* route flags */     )    {#ifdef ROUTER_STACK    ROUTE_DESC		routeDesc;    struct sockaddr_in	dstAddr;    struct sockaddr_in	netmask;    struct sockaddr_in	gateway;    /* Initialize the routeDesc structure and the sockaddr structures */    bzero ((char *)&routeDesc, sizeof (routeDesc));    routeDesc.pDstAddr = (struct sockaddr *)&dstAddr;    routeDesc.pNetmask = (struct sockaddr *)&netmask;    routeDesc.pGateway = (struct sockaddr *)&gateway;    bzero ((char *)&dstAddr, sizeof (struct sockaddr_in));    bzero ((char *)&netmask, sizeof (struct sockaddr_in));    bzero ((char *)&gateway, sizeof (struct sockaddr_in));    dstAddr.sin_len = sizeof (struct sockaddr_in);    netmask.sin_len = sizeof (struct sockaddr_in);    gateway.sin_len = sizeof (struct sockaddr_in);    dstAddr.sin_family = AF_INET;    netmask.sin_family = AF_INET;    gateway.sin_family = AF_INET;    dstAddr.sin_addr.s_addr = dstIp;    netmask.sin_addr.s_addr = mask;    gateway.sin_addr.s_addr = gateIp;    routeDesc.flags = flags;    routeDesc.protoId = M2_ipRouteProto_rip;    /*      * If it is a host route, set netmask to NULL. RIP internally     * assigns a host route the netmask of the interface. But the system     * expect a NULL or all zero's netmask.     */    if (flags & RTF_HOST)        routeDesc.pNetmask = NULL;    /* Now add the route */    return (routeEntryAdd (&routeDesc));#else    /*      * If it is a host route, set netmask to NULL. RIP internally     * assigns a host route the netmask of the interface. But the system     * expect a NULL netmask     */    if (flags & RTF_HOST)        mask = 0;    return (mRouteEntryAdd (dstIp, gateIp, mask, 0, flags,                             M2_ipRouteProto_rip));#endif /* ROUTER_STACK */    }/******************************************************************************** ripSystemRouteDelete - delete a RIP route from the system routing database** This routine deletes a route from the system routing database using the* method which the particular product supports.** RETURNS: ERROR or OK (return value from selected delete method)** ERRNO: N/A** NOMANUAL*/LOCAL STATUS ripSystemRouteDelete     (    long		dstIp,    	/* destination address, network order */    long		gateIp,    	/* gateway address, network order */    long		mask,      	/* mask for destination, network order */    int		flags      	/* route flags */     )    {#ifdef ROUTER_STACK    ROUTE_DESC		routeDesc;    struct sockaddr_in	dstAddr;    struct sockaddr_in	netmask;    struct sockaddr_in	gateway;    /* Initialize the routeDesc structure and the sockaddr structures */    bzero ((char *)&routeDesc, sizeof (routeDesc));    routeDesc.pDstAddr = (struct sockaddr *)&dstAddr;    routeDesc.pNetmask = (struct sockaddr *)&netmask;    routeDesc.pGateway = (struct sockaddr *)&gateway;    bzero ((char *)&dstAddr, sizeof (struct sockaddr_in));    bzero ((char *)&netmask, sizeof (struct sockaddr_in));    bzero ((char *)&gateway, sizeof (struct sockaddr_in));    dstAddr.sin_len = sizeof (struct sockaddr_in);    netmask.sin_len = sizeof (struct sockaddr_in);    gateway.sin_len = sizeof (struct sockaddr_in);    dstAddr.sin_family = AF_INET;    netmask.sin_family = AF_INET;    gateway.sin_family = AF_INET;    dstAddr.sin_addr.s_addr = dstIp;    netmask.sin_addr.s_addr = mask;    gateway.sin_addr.s_addr = gateIp;    routeDesc.flags = flags;    routeDesc.protoId = M2_ipRouteProto_rip;    /*      * If it is a host route, set netmask to NULL. RIP internally     * assigns a host route the netmask of the interface. But the system     * expect a NULL or all zero's netmask.     */    if (flags & RTF_HOST)        routeDesc.pNetmask = NULL;    /* Now delete the route */    return (routeEntryDelete (&routeDesc));#else    /*      * If it is a host route, set netmask to NULL. RIP internally     * assigns a host route the netmask of the interface. But the system     * expect a NULL or all zero's netmask.     */    if (flags & RTF_HOST)        mask = 0;    return (mRouteEntryDelete (dstIp, gateIp, mask, 0, flags,                                M2_ipRouteProto_rip));#endif /* ROUTER_STACK */    }/******************************************************************************** ripRouteMetricSet - Set the metric for the RIP route** This routine changes the metric 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. It also contains the metric value that is to be set.** This routine calls the routing extensions function routeMetricSet() * to set the metric** RETURNS: N/A** ERRNO: N/A** NOMANUAL*/void ripRouteMetricSet     (    struct rt_entry *	pRtEntry	/* Route entry describing the */    					/* Kernel 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 ("ripRouteMetricSet: setting new metric = %d for\n",                 pRtEntry->rt_metric , 0, 0, 0, 0, 0);        ripSockaddrPrint ((struct sockaddr *)pDsin);        ripSockaddrPrint ((struct sockaddr *)pNsin);        ripSockaddrPrint ((struct sockaddr *)pGsin);        }    /* Now set the route metric */    if (routeMetricSet ((struct sockaddr *)pDsin, (struct sockaddr *)pNsin,                        M2_ipRouteProto_rip, pRtEntry->rt_metric) == ERROR)         {        if (routedDebug)             logMsg ("Couldn't set metric for rtEntry = %x.\n", (int)pRtEntry, 0,                     0, 0, 0, 0);        }    }/******************************************************************************* ripInsque - insert node in list after specified node.** Portable version of _insque ().** NOMANUAL*/ LOCAL void ripInsque    (    NODE *pNode,    NODE *pPrev    )    {    NODE *pNext;     pNext = pPrev->next;    pPrev->next = pNode;    pNext->previous = pNode;    pNode->next = pNext;    pNode->previous = pPrev;    } /******************************************************************************* ripRemque - remove specified node in list.** Portable version of _remque ().** NOMANUAL*/ LOCAL void ripRemque     (    NODE *	pNode	/* Node to remove */    )    {    pNode->previous->next = pNode->next;    pNode->next->previous = pNode->previous;    }