iproute.c

嵌入式RMON,RMON为Remote monitor的缩写,基于SNMP为网络提供主动监控及错误告警,智能交换路由必备协议

/* Beholder RMON ethernet network monitor,Copyright (C) 1993 DNPAP group */
/* See file COPYING 'GNU General Public Licence' for copyright details   */
#include <sys/types.h>
#include <netdb.h>   
#include <sys/time.h> 
#include <netinet/in.h>  
#include <arpa/inet.h>  
#include <sys/socket.h>  
#if defined(SUNOS) || defined(SOLARIS)
#include <unistd.h>
#include <stropts.h>
#endif
#include <errno.h> 

#include <memory.h>
#include <arp.h>

#include "ip.h"
#include "ipiface.h"
#include "iproute.h"



#ifdef UNIX

DWORD IpRouteFindSrc(DWORD dst)
{          
    struct sockaddr_in sa;
    int s,n;
    
    s=socket(AF_INET, SOCK_DGRAM, 0);
    if (s<0)
    {
        DnpapMessage(DMC_ERROR, IP_ERROR, "IpRouteFindSrc: socket error"); 
        return -1;
    }
     
    sa.sin_family=AF_INET;
    sa.sin_addr.s_addr=htonl(dst);
    sa.sin_port=7;        
    if (connect(s, (struct sockaddr *)&sa, sizeof(sa))<0)
    {
        DnpapMessage(DMC_ERROR, IP_ERROR, "IpRouteFindSrc: connect error"); 
        return -1;
    }
    
    n=sizeof(sa);
    if (getsockname(s, (struct sockaddr *)&sa, &n)<0)
    {
        DnpapMessage(DMC_ERROR, IP_ERROR, "IpRouteFindSrc: getsockname error"); 
        return -1;
    }
      
    close(s);
    
    return (DWORD)ntohl(sa.sin_addr.s_addr);
}



#else

static WORD Ones(DWORD mask);

IP_ROUTE_ENTRY *ipRouteList = 0;



BOOLEAN IpRouteAdd( DWORD           addr,
                    DWORD           mask,
                    DWORD           addrNextHop,
                    MAC_IFACE       *iface,
                    WORD            metric)
{
    
    IP_ROUTE_ENTRY **p, *e;
    IP_IFACE *i;
    BOOLEAN found = FALSE;

    for (i=ipIfaceList; i!=0; i=i->next)
    {
        if (i->iface == iface)
            break;
    }
    
    if (i == 0)
        return FALSE;


    for (p = &ipRouteList; *p!=0; p=&(*p)->next)
    {
        if ((*p)->addr == addr)
        {
            found = TRUE;
            break;
        }
        if (Ones((*p)->mask < Ones(mask)))
            break;
    }
    
    if (found)
    {
        e = *p;
    }
    else
    {
        e = DnpapMalloc(sizeof(IP_ROUTE_ENTRY));
        if (e==0)
            return FALSE;
        e->next = *p;
        *p = e;
    }

    
    e->iface            = i;
    e->addr             = addr;
    e->addrNextHop      = addrNextHop;
    e->mask             = mask;
    e->metric           = metric;
    e->routingProto     = IP_ROUTE_PROTO_LOCAL;
    e->type             = IP_ROUTE_TYPE_REMOTE;

    return TRUE;
}



BOOLEAN IpRouteIsBroadcast(DWORD addr)
{
    return (addr == 0xffffffff || addr == 0);
}
                                                   


BOOLEAN IpRouteFind(DWORD addr, IP_ROUTE_ROUTE *route)
{
    IP_IFACE *i;
    IP_ROUTE_ENTRY *e;

    /* check interfaces */
    
    for (i=ipIfaceList; i!=0; i=i->next)
    {
        if(i->up)
        {
            if((addr & i->mask) == i->addrNet && addr != i->addr)
            {
                route->iface        = i;
                route->addr         = addr;
                route->metric       = 16;
                route->broadcast    = (addr == i->addrBroadcast) ||
                                      (addr == i->addrNet);
                return TRUE;
            }
        }
    }

    /* check routing table */

    for (e=ipRouteList; e!=0; e=e->next)
    {
        if(e->iface->up)
        {
            if((addr & e->mask) == e->addr)
            {
                route->iface        = e->iface;
                route->addr         = e->addrNextHop;
                route->metric       = e->metric;
                route->broadcast    = FALSE;
                return TRUE;
            }
        }
    }

    return FALSE;
}

DWORD IpRouteFindSrc(DWORD dst)
{
    IP_ROUTE_ROUTE r;
    DWORD          src;
    
    if (!IpRouteFind(dst, &r))
        src = 0L;
    else
        src = r.iface->addr;

    return src;
}



static WORD Ones(DWORD mask)
{
    WORD    c=0;
    DWORD   i=0x00000001;

    while(mask!=0)
    {
        if (mask & i)
            c++;
        mask>>=1;
    }
    return c;
}


#endif