riplib.c

VXWORKS源代码

    FD_ZERO (&ibits);
    nfd = max (ripState.s, ripState.routeSocket) + 1;	/* 1 + max (fd's) */
    for (;;)
        {
        FD_SET (ripState.s, &ibits);
        FD_SET (ripState.routeSocket, &ibits);

        if (ripState.needupdate)
            {
            /*
             * Changes to the routing table entries occurred within the
             * mandatory (random) quiet period following an earlier
             * triggered update. Set the selection interval for incoming 
             * messages to the remaining delay so that the pending 
             * (cumulative) triggered update will be sent on schedule.
             */

            pTimeout = &waittime;

            waittime = ripState.nextbcast;
            timevalsub (&waittime, &ripState.now);
            if (waittime.tv_sec < 0)
                {
                /* 
                 * The scheduled update time has passed. Just poll the
                 * interface before sending the triggered update.
                 */

                waittime.tv_sec = 0;
                waittime.tv_usec = 0;
                }
            if (routedDebug)
                logMsg ("Pending dynamic update scheduled in %d/%d sec/usec\n",
                        waittime.tv_sec, waittime.tv_usec, 0, 0, 0, 0);
            }
        else
            {
            /* 
             * No triggered updates are pending. Wait for 
             * messages indefinitely. 
             */

            pTimeout = (struct timeval *)NULL;
            }


        n = select (nfd, &ibits, 0, 0, pTimeout);
        if (n <= 0)
            {
            /*
             * No input received during specified interval: generate 
             * (delayed) triggered update if needed. Ignore all other 
             * errors (e.g. EINTR).
             */

            if (n < 0)
                {
                if (errno == EINTR)
                    continue;
                if (routedDebug)
                    logMsg ("Error %d (%x) from select call", 
                            n, errno, 0, 0, 0, 0);
                }

            /* Block timer task to prevent overlapping updates. */

            semTake (ripLockSem, WAIT_FOREVER);
            if (n == 0 && ripState.needupdate)
                {
                /* 
                 * The pending triggered update was not subsumed by a
                 * regular update during the selection interval. Send it
                 * and reset the update flag and timers.
                 */

                if (routedDebug)
                    logMsg ("send delayed dynamic update\n", 0, 0, 0, 0, 0, 0);

                ripTimeSet (&ripState.now);

                toall (supply, RTS_CHANGED, (struct interface *)NULL);

                ripState.lastbcast = ripState.now;
                ripState.needupdate = 0;
                ripState.nextbcast.tv_sec = 0;
                }
            semGive (ripLockSem);

            continue;
            }

        ripTimeSet (&ripState.now);

        /* 
         * Block the timer task to prevent overlapping updates or
         * route addition/deletion during 
         * processing of RIP and route messages.
         */

        semTake  (ripLockSem, WAIT_FOREVER);

        /* If RIP messages have arrived, process them */

        if (FD_ISSET (ripState.s, &ibits))
            process (ripState.s);

        semGive (ripLockSem);

#ifdef ROUTER_STACK
        /* If there are any routing messages, process them */

        if (FD_ISSET (ripState.routeSocket, &ibits))
            ripRouteMsgProcess ();
#endif /* ROUTER_STACK */
	}
    }

void timevaladd (t1, t2)
	struct timeval *t1, *t2;
{

	t1->tv_sec += t2->tv_sec;
	if ((t1->tv_usec += t2->tv_usec) > 100000) {
		t1->tv_sec++;
		t1->tv_usec -= 1000000;
	}
}

void timevalsub (t1, t2)
	struct timeval *t1, *t2;
{

	t1->tv_sec -= t2->tv_sec;
	if ((t1->tv_usec -= t2->tv_usec) < 0) {
		t1->tv_sec--;
		t1->tv_usec += 1000000;
	}
}

/******************************************************************************
*
* ripTimeSet - update a RIP timer
*
* This routine sets the various RIP timers used to track periodic updates
* to the elapsed time since startup. Because all events use relative
* times, the actual (calendar) time is not necessary.
*
* RETURNS: N/A
*
* ERRNO: N/A
*
* NOMANUAL
*/

void ripTimeSet
    (
    struct timeval * 	pTimer 		/* destination for timestamp */
    ) 
    {
    int clockrate;
    ULONG tickcount;

    tickcount = tickGet ();
    clockrate = sysClkRateGet ();

    pTimer->tv_sec = tickcount / clockrate;
    pTimer->tv_usec = (1000000 * tickcount % clockrate) / clockrate;

    return;
    }

void process (fd)
	int fd;
{
	struct sockaddr from;
	int fromlen, cc;
	union {
		char	buf[MAXPACKETSIZE+1];
		RIP_PKT rip;
	} inbuf;

        bzero ((char *)&from, sizeof (from));
	for (;;) {
		fromlen = sizeof (from);
		cc = recvfrom (fd, (char *)&inbuf, sizeof (inbuf), 0, 
                               &from, &fromlen);
		if (cc <= 0) {
			if (cc < 0 && errno != EWOULDBLOCK)
                            {
                            if (routedDebug)
				logMsg ("Error %d (%x) reading RIP message.\n",
                                        cc, errno, 0, 0, 0, 0);
                            }
			break;
		}
		if (fromlen != sizeof (struct sockaddr_in))
			break;
		routedInput (&from, &inbuf.rip, cc);
	}
}

/******************************************************************************
*
* _ripAddrsXtract - extract socket addresses
*
* This routine is a copy of the rt_xaddrs() routine in rtsock.c
* Copied here so that RIP can access it from a non-kernel domain
* it basicaly fills in the rti_info array with pointers to the
* sockaddr structures denoted by the rti_addrs field.
* The sockaddr structures themselves start at <cp> and end at <cpLim>.
*
* RETURNS: N/A
*
* ERRNO: N/A
*
* NOMANUAL
*/

void _ripAddrsXtract
    (
    caddr_t		cp,
    caddr_t		cpLim, 
    struct rt_addrinfo *	pRtInfo
    ) 
    {
    register struct sockaddr *	pSockAddr; 
    register int 			i;
 
    bzero ((char *)pRtInfo->rti_info, sizeof (pRtInfo->rti_info));
    for (i = 0; (i < RTAX_MAX) && (cp < cpLim); i++) 
        {
        if ((pRtInfo->rti_addrs & (1 << i)) == 0)
            continue;
        pRtInfo->rti_info[i] = pSockAddr = (struct sockaddr *)cp;
        if (pSockAddr->sa_len == 0)
            pRtInfo->rti_info[i] = NULL;
        ADVANCE (cp, pSockAddr);
        }
    }

/******************************************************************************
*
* ripAddrsXtract - extract socket address pointers from the route message
*
* This routine extracts the socket addresses from the route message in 
* <pRtInfo> and uses the other parameters to return pointers to the 
* extracted messages.
* \is
* \i <pRtInfo>
* Passes in a pointer to a route information message. 
* \i <pDstAddr>    
* Returns a pointer to the destination address.
* \i <pNetmask>    
* Returns a pointer to the netmask.
* \i <pGateway>    
* Returns a pointer to the gateway address.
* \i <pOldGateway>  
* Returns a pointer to the OLD gateway address if it exists.
* \ie
*              
* If the route message doesn't specify an address, the corresponding
* address pointer is set to NULL
*
* RETURNS: N/A
*
* ERRNO: N/A
*/

void ripAddrsXtract
    (
    ROUTE_INFO *	pRtInfo,	/* Route information message */
    struct sockaddr **	pDstAddr,	/* Where to store the Destination addr
                                           pointer */
    struct sockaddr **	pNetmask,	/* Where to store the netmask pointer*/
    struct sockaddr **	pGateway,	/* Where to store the Gateway addr
                                           pointer */
    struct sockaddr **	pOldGateway	/* Where to store the Old gateway addr
                                           (if any) pointer */
    ) 
    {
    struct rt_addrinfo		rtInfo; 

    /* First extract pointers to the addresses into the info structure */

    rtInfo.rti_addrs = pRtInfo->rtm.rtm_addrs;
    _ripAddrsXtract ((caddr_t)pRtInfo->addrs, 
                     (caddr_t)&pRtInfo->addrs[RTAX_MAX], 
                     &rtInfo);
 
    /* Now set the users's pointers to point to the addresses */

    *pDstAddr = INFO_DST (&rtInfo);
    *pNetmask = INFO_MASK (&rtInfo);
    *pGateway = INFO_GATE (&rtInfo);
    *pOldGateway = INFO_AUTHOR (&rtInfo);
    }


/******************************************************************************
*
* ripSockaddrPrint - print a sockaddr structure
*
* This routine is a copy of the db_print_sa() routine in if_ether.c
* Copied here so that RIP can access it from a non-kernel domain.
* It prints out the sockaddr structure pointed to by <pSockAddr>
*
* RETURNS: N/A
*
* ERRNO: N/A
*
* NOMANUAL
*/

void ripSockaddrPrint
    (
    struct sockaddr *	pSockAddr	/* Sockaddr to be printed */
    )
    {
    int 		len;
    u_char *	p;

    if (pSockAddr == 0) 
        {
        printf ("[NULL]\n");
        return;
        }

    p = (u_char *)pSockAddr;
    len = pSockAddr->sa_len;
    printf ("[");
    while (len > 0) 
        {
        printf ("%d", *p);
        p++; len--;
        if (len) 
            printf (",");
        }
    printf ("]\n");
    }

#ifdef ROUTER_STACK

/***************************************************************************
*
* ripRouteMsgProcess - Process the routing socket messages
*
* This function retrieves the messages from the routing sockets 
* and processes them. It handles the following messages:
*
* RTM_IFINFO:
*       This message indicates if an interface has been brought up or down.
*       If the interface is brought up, this routine does the following:
*         For all interfaces that match the name, it marks the interface UP
*         and adds the interface route.
*         Then it calls the routedIfInit() call to pick up any addresses that
*         were added to the interface when the interface was down
*       If the interface is brought down, this routine does the following:
*         For all interfaces that match the name, it marks the interface DOWN.
*         Routes passing through the interface are deleted except the
*         routes we learned through the Routing socket messages. Those routes