netshow.c

VXWORKS源代码

/****************************************************************************
*
* routeNodeShow - print all route entries attached to a node in the tree
*
* This routine displays every route entry with a particular destination
* and netmask. Only the initial entry attached to the tree is visible to
* the IP forwarding process. The remaining entries are duplicates.
*
* The return value of 0 continues the tree traversal to access the next
* element.
*
* RETURNS: OK on success and ERROR on failure
*/

LOCAL int routeNodeShow
    (
    struct radix_node * pRoute,
    void* w
    )
    {
    ROUTE_ENTRY * pHead;    /* Start of route list for a protocol. */
    ROUTE_ENTRY * pNext;

    BOOL printFlag;    /* Available route actually displayed? */

    struct sockaddr * pAddress;
    char   addressString [INET_ADDR_LEN];
    int    len;

    pHead = (ROUTE_ENTRY *)pRoute;

    /* Print the route entry which is visible to IP. */

    printFlag = routeEntryPrint ( (struct rtentry *)pHead, w, TRUE);

    if (printFlag == FALSE)
        {
        /*
         * The primary route entry did not match the requested type. Ignore
         * any duplicate routes, which also will not meet the criteria.
         */

        return (OK);
        }

    /* Get the next entry to display, if any. */

    pNext = pHead->sameNode.pFrwd;
    if (pNext == NULL)
        {
        pHead = pNext = pHead->diffNode.pFrwd;
        }

    if (pNext != NULL)
        {
        /* Additional entries exist. Print the appropriate subheading. */

        pAddress = rt_key ( (struct rtentry *)pRoute);
        inet_ntoa_b ( ((struct sockaddr_in *)pAddress)->sin_addr,
                     addressString);

	if (!bufferedRtShow)
            printf ("  Additional routes to %s:\n", addressString);
	else
	    {
	    len = sprintf (routeBuf + bufIndex, "  Additional routes to %s:\n", 
			   addressString);
	    bufIndex += len;
	    }
        }

    /* Print any duplicate routes for the visible node. */

    while (pHead)
        {
        while (pNext)
            {
	    /* check for buffer space */

            if (bufferedRtShow && (rtMem - bufIndex < RT_ENTRY_LEN))
	        return (ERROR);
            routeEntryPrint ( (struct rtentry *)pNext, w, FALSE);

            pNext = pNext->sameNode.pFrwd;
            }
        pHead = pNext = pHead->diffNode.pFrwd;
        }

    /* check for buffer space */

    if (bufferedRtShow && (rtMem - bufIndex < RT_ENTRY_LEN))
	return (ERROR);

    return OK;
    }

/*******************************************************************************
*
* routeEntryPrint - print one route entry
*
* This function executes (when walking the route tree) for each route entry,
* including duplicate routes not visible to the IP forwarding process.
* The public routines set the <type> argument to RT_NET, RT_HST, or RT_ARP
* to select categories of route information from the routing table. The
* RT_NET value only displays IP routes which can reach multiple hosts.
* The RT_HST value only displays IP routes which can reach a specific host,
* and the RT_ARP value displays host-specific routes which contain link-level
* information in the gateway field.
*
* Older show routines only select one of the available route types. The
* newer alternative sets both RT_NET and RT_HST to display all IP routes.
* That routine supports classless routing, so it includes the netmask value
* in the output. It also prints the new type-of-service field and the
* protocol number which indicates the route's creator.
*
* RETURNS: TRUE if entry printed, or FALSE for mismatched type
*/

LOCAL BOOL routeEntryPrint
    (
    struct rtentry *	pRt,		/* pointer to the route entry */
    void *		pRtType, 	/* pointer to the route type */
    BOOL 		ipRouteFlag 	/* visible to IP forwarding? */
    )
    {
    FAST struct sockaddr *	destAddr = NULL;
    FAST struct sockaddr *	gateAddr;
    FAST UCHAR * 		pChr;
    FAST int			rtType; 
    char 			aStr [INET_ADDR_LEN];
    ULONG 			mask;
    char                        buf [RT_ENTRY_LEN];
    int                         index = 0;
    int                         len;

    rtType = *((int *)pRtType); 
    
    /*
     * Ignore host routes (including ARP entries) if only
     * network routes should be printed.
     */

    if ( (rtType == RT_NET) && (pRt->rt_flags & RTF_HOST))
	return (FALSE); 

    destAddr = rt_key(pRt);		/* get the destination address */
    gateAddr = pRt->rt_gateway;		/* get the gateway address */


    /* if what we want is a host route and not an arp entry then return */

    if ((rtType & RT_HST) && (gateAddr->sa_family == AF_LINK) &&
                              (pRt->rt_flags & RTF_HOST))
	return (FALSE);

    /* If only host routes are desired, skip any network route. */

    if ((rtType == RT_HST) && (!(pRt->rt_flags & RTF_HOST)))
	return (FALSE); 

    /* if what we want is an arp entry and if it is not then return */

    if ((rtType & RT_ARP) && ((gateAddr->sa_family != AF_LINK) ||
			      (((struct sockaddr_dl *)gateAddr)->sdl_alen == 0)
			      ))
	return (FALSE); 

    /* if what we want is a network route and the gateway family is AF_LINK */

    if ((rtType & RT_NET) && (gateAddr->sa_family == AF_LINK))
	gateAddr = pRt->rt_ifa->ifa_addr; 

    /*
     * Print destination address for visible entries and whitespace
     * for duplicate routes.
     */

    if (ipRouteFlag)
        {
        inet_ntoa_b (((struct sockaddr_in *)destAddr)->sin_addr, aStr);

	if (!bufferedRtShow)
            printf ("%-16s ", (destAddr->sa_family == AF_INET) ?
		              aStr : "not AF_INET");
	else
	    {
	    len = sprintf (buf, "%-16s ", (destAddr->sa_family == AF_INET) ? 
					   aStr : "not AF_INET");
	    index += len;
	    }
        }
    else
        {
	if (!bufferedRtShow)
            printf ("                 ");
	else
	    {
	    len = sprintf (buf, "                 ");
	    index += len;
	    }
        }

    /*
     * When displaying all IP routes, print the netmask for the visible
     * route entry. Show the new TOS values and the value of the routing
     * protocol which created the entry for the primary routes and any
     * duplicates. Only one of these type flags is set when using the
     * older class-based show routines.
     */

    if ( (rtType & RT_NET) && (rtType & RT_HST))
        {
        /* Print the (common) netmask value with the primary route entry. */

        if (ipRouteFlag)
            {
            if (rt_mask (pRt) == NULL)
                {
                mask = 0;
                }
            else
                {
                mask = ((struct sockaddr_in *) rt_mask (pRt))->sin_addr.s_addr;
                mask = ntohl (mask);
                }
        
	    if (!bufferedRtShow)
                printf ("%#-10lx ", mask);
	    else
		{
		len = sprintf (buf + index, "%#-10lx ", mask);
		index += len;
		}
            }
        else
            {
            /* Print whitespace when displaying duplicate routes. */

	    if (!bufferedRtShow)
                printf ("           ");    /* 11 spaces: empty netmask field */
	    else
		{
		len = sprintf (buf + index, "           ");
		index += len;
		}
            }

	if (!bufferedRtShow)
	    {
            /* print routing protocol value */

            printf ("%-4d  ", RT_PROTO_GET (destAddr));

            /* print type of service */

            printf ("%#-4x ", TOS_GET (destAddr));
            }
        else
	    {
	    len = sprintf (buf + index, "%-4d  %#-4x ", RT_PROTO_GET (destAddr),
	                   TOS_GET (destAddr));
	    index += len;
	    }
        }

    /* print the gateway address which internet or linklevel */

    if (gateAddr->sa_family == AF_LINK)
	{
	pChr = (UCHAR *)(LLADDR((struct sockaddr_dl *)gateAddr));

	if (!bufferedRtShow)
	    printf ("%02x:%02x:%02x:%02x:%02x:%02x ",
		    pChr[0], pChr[1], pChr[2], pChr[3], pChr[4], pChr[5]); 
	else
	    {
	    len = sprintf (buf + index, "%02x:%02x:%02x:%02x:%02x:%02x ",
			   pChr[0], pChr[1], pChr[2], pChr[3], pChr[4], pChr[5]);
            index += len;
	    }
	}
    else
	{
	inet_ntoa_b (((struct sockaddr_in *)gateAddr)->sin_addr, aStr);

	if (!bufferedRtShow)
	    printf ("%-16s ", (gateAddr->sa_family == AF_INET) ?
		    aStr :"not AF_INET"); 
	else
	    {
	    len = sprintf (buf + index, "%-16s ", 
			   (gateAddr->sa_family == AF_INET) ? aStr :
			   "not AF_INET");
	    index += len;
	    }
	}

    if (!bufferedRtShow)
	{
        printf ("%#-6hx ",	pRt->rt_flags);
        printf ("%-5d  ",	pRt->rt_refcnt);
        printf ("%-10ld ",	pRt->rt_use);
        printf ("%s%d\n",  pRt->rt_ifp->if_name, pRt->rt_ifp->if_unit);
	}
    else
	{
	len = sprintf (buf + index, "%#-6hx %-5d  %-10ld %s%d\n", pRt->rt_flags,
		       pRt->rt_refcnt, pRt->rt_use, pRt->rt_ifp->if_name,
		       pRt->rt_ifp->if_unit);
        index += len;

	bcopy (buf, (char *) (routeBuf + bufIndex), index);
	bufIndex += index;
	}

    return (TRUE); 
    }

/*******************************************************************************
*
* routeTableShow - print a subset of entries in the routing table
*
* This routine uses internal interfaces to walk the internal tree which
* contains all route information and display particular types of route
* entries. It provides a common entry point for three individual routines
* which print the ARP information, route entries assuming class-based
* netmasks (further separated into network and host categories), and routes
* which can use arbitrary netmasks.
*
* RETURNS: N/A
*/

LOCAL void routeTableShow
    (
    int 	rtType		/* route type network, host or arp */
    )
    {
    int                         s;
    struct radix_node_head *	rnh;
    int				type;

    type = rtType;
    rnh = rt_tables[AF_INET];

    if (rnh)
        {
	if (bufferedRtShow)
	    {
	    if (routeBuf == NULL)
		return;

	    bufIndex = 0;
            }

	s = splnet ();
	rn_walktree(rnh, routeNodeShow, &type);
        splx (s);

	if (bufferedRtShow)
	    {
	    routeBuf [bufIndex] = '\0';
	    printf ("%s", routeBuf);
	    }
        }

    return;
    }

/*******************************************************************************
*
* hostShow - display the host table
*
* This routine prints a list of remote hosts, along with their Internet
* addresses and aliases.
*
* RETURNS: N/A
*
* SEE ALSO: hostAdd()
*
* INTERNAL
* When using the Tornado shell, this routine is only available if an
* "@" sign is prepended to the routine name. Otherwise, it is preempted
* by a built-in version.
*
* This just calls arpShow.  It is provided for compatablity.
* Migrating to arpShow to be more compliant with WRS naming.
*/

void hostShow (void)
    {
    char inetBuf [INET_ADDR_LEN];
    FAST HOSTNAME *pHostName;
    FAST HOSTENTRY *pHostEntry;

#ifdef VIRTUAL_STACK
    virtualStackIdCheck();
    printf("stack number %d\n", myStackNum);
#endif /* VIRTUAL_STACK */

    printf ("hostname         inet address       aliases\n");
    printf ("--------         ------------       -------\n");

    semTake (hostListSem, WAIT_FOREVER);

    for (pHostEntry = (HOSTENTRY *)lstFirst (&hostList);
	 pHostEntry != NULL;
	 pHostEntry = (HOSTENTRY *)lstNext (&pHostEntry->node))
	{
	inet_ntoa_b (pHostEntry->netAddr, inetBuf);
	printf ("%-16s %-18s", pHostEntry->hostName.name, inetBuf);

	for (pHostName = pHostEntry->hostName.link;
	     pHostName != NULL;
	     pHostName = pHostName->link)
	    {
	    printf ("%s ", pHostName->name);
	    }

	printf ("\n");
	}

    semGive (hostListSem);
    }

/*******************************************************************************
*
* mRouteShow - display all IP routes (verbose information)
*
* This routine displays the list of destinations in the routing table
* along with the next-hop gateway and associated interface. It also
* displays the netmask for a route (to handle classless routes which
* use arbitrary values for that field) and the value which indicates
* the route's creator, as well as any type-of-service information.
*
* When multiple routes exist to the same destination with the same netmask,
* the IP forwarding process only uses the first route entry with the lowest
* administrative weight. The remaining entries (listed as additional routes)
* use the same address and netmask. One of those entries will replace the
* primary route if it is deleted.
*
* Some configuration is required when this routine is to be used remotely over
* the network eg. through a telnet session or through the host shell using 
* WDB_COMM_NETWORK. If more than 5 routes are expected in the table the 
* parameter RT_BUFFERED_DISPLAY should be set to TRUE to prevent a possible
* deadlock. This requires a buffer whose size can be set with RT_DISPLAY_MEMORY.
* It will limit the number of routes that can be displayed (each route requires
* approx. 90 bytes).
*
* RETURNS: N/A
*/

void mRouteShow (void)
    {
    int type = RT_HST | RT_NET;    /* print all IP route entries */

#ifdef VIRTUAL_STACK
    virtualStackIdCheck();
    printf("stack number %d\n", myStackNum);
#endif /* VIRTUAL_STACK */

    printf ("%-16s %-10s %-6s%-4s", "Destination", "Mask", "Proto", "TOS");
    printf ("%-16s %-6s %-7s%-11s", "Gateway", "Flags", "RefCnt", "Use");
    printf ("%s\n", "Interface");

    printf ("-------------------------------------------------------------");
    printf ("----------------------------\n");

    routeTableShow (type);
    }