eth.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 <string.h>
#include <stdio.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <memory.h>
#include <config.h>   
#include <dtime.h>
#include <mac.h>
#include <chain.h>

#include "eth.h"
 


ETH_DESCR *ethDescrList = 0;


static VOID Rcve(NW_DG *nw, char *addr, BYTE *frame, int length, VOID *parm);
static BOOLEAN      Stat(MAC_IFACE *iface, MAC_STAT *stats);
static BOOLEAN      Send(MAC_IFACE *iface, CHAIN *chain);

static BOOLEAN GetIfStats(CHAR *interface, CHAR *stats);


VOID EthExit(VOID)
{
    ETH_DESCR      *eth;
    
    while (ethDescrList!=0)
    {
        eth = ethDescrList;
        ethDescrList = ethDescrList->next;
                    
        MacIfaceRemove(eth->mac);
        NwDgClose(eth->nw);
        DnpapFree(eth);
    }
}


BOOLEAN EthInit(VOID)
{
    BYTE            name[255];
    BYTE            addr[255];
    CHAR            *descr;
    MAC_IFACE       *mac;
    ETH_DESCR       *eth; 
    WORD            i;
	CHAR			line[256];
	NW_IFCONFIG		ifconfig;
    static BOOLEAN  init = FALSE;
    
    if (!init)
    {
        i = 1;
        sprintf(name, "eth.iface.name.%d", i);
        while (ConfigGetString(name, &descr))
        {
            mac = DnpapMalloc(sizeof(MAC_IFACE));
            if (mac!=0)
            {                        
                eth=DnpapMalloc(sizeof(ETH_DESCR)); 
                memset(eth, 0, sizeof(ETH_DESCR));
                if (eth!=0)
                {
                    eth->mac=mac;
                    
                    sprintf(addr,"eth:%s", descr);
                    eth->nw=NwDgAccept(addr, Rcve, eth);  
                    if (eth->nw != NULL && NwDgIfConfig(eth->nw, &ifconfig) == TRUE)
                    {
						if (GetIfStats(descr, line) == FALSE)
							DnpapMessage(DMC_FATAL, ETH_ERROR, "eth: interface not found in system");

                        mac->specific      = eth;
                        strcpy(mac->descr, descr);
                        mac->Send          = Send;
                        mac->Stat          = Stat;
                        mac->type          = ifconfig.type;
                        mac->speed         = ifconfig.speed;
                        mac->mtu           = ifconfig.mtu;
                        mac->statusOper    = TRUE;
                        mac->statusAdmin   = TRUE;
                        mac->arp           = MAC_ARP_NONE;
                        memcpy(mac->addr, ifconfig.address, ifconfig.addrlen);
                        memcpy(mac->addrBroadcast, ifconfig.broadcast, ifconfig.addrlen);
						mac->addrLength    = ifconfig.addrlen;
						mac->frameId       = 0;
                        MacIfaceRegister(mac); 
                    }
                    
                    eth->next=ethDescrList;
                    ethDescrList=eth;
                }
            }    
            
            i++;
            sprintf(name, "eth.iface.name.%d", i);
        }
        
        DnpapAtExit(EthExit);

        init = TRUE;
    }

    return init;
}



static VOID Rcve(NW_DG *nw, char *addr, BYTE *frame, int length, VOID *parm)
{
    ETH_DESCR           *eth;
    CHAIN               chain;
    MAC_INFO            info; 
    BYTE                *p;
        
    eth=(ETH_DESCR *)parm;
    
	p = frame;
    
    info.copied      = length; 
    info.length      = length;
    info.time        = TimeUsec();
    info.promiscuous = ((p[0] & (BYTE)0x01)!=(BYTE)0x01 &&
                            memcmp(p, eth->mac->addr, 6)!=0);
    eth->Pkts++;
    eth->Octets += length;
    eth->DiscardedPkts = 0;
        
    if (info.length > info.copied)
        eth->TruncatedPkts++;
    if (!info.promiscuous)
        eth->StackedPkts++;
    if (memcmp(p,"\xff\xff\xff\xff\xff\xff",6)==0)
        eth->BroadcastPkts++;
    else if(p[0] & (BYTE)0x01)
        eth->MulticastPkts++;
    if (length < 60)
        eth->UndersizePkts++;           
    if (length > 1514)
        eth->OversizePkts++;           

    if (ChainAlloc(&chain, p, length, length, 0, 0)==0)
        return;
  
    MacRcve(eth->mac, &chain, &info);
}        


static BOOLEAN Send(MAC_IFACE *iface, CHAIN *chain)
{
    ETH_DESCR  *eth;
    BYTE       frame[ETH_MTU];
    WORD       length;
    BYTE       addr[32];
    
    eth=(ETH_DESCR *)iface->specific;

    length = ChainLength(chain);
    if (!ChainCopy(chain, frame, length))
        return FALSE;
                   
    sprintf(addr,"eth:%s", iface->descr);
              
    eth->OutPkts++;
    if (memcmp(frame, "\xff\xff\xff\xff\xff\xff", iface->addrLength) == 0)
        eth->OutBroadcastPkts++;
    else if(frame[0] & (BYTE)0x01)
        eth->OutMulticastPkts++;

    if (!NwDgSendTo(0, addr, frame, length))
	{
		eth->OutDiscards++;
        return FALSE;
	}
	eth->OutOctets += length;

    return TRUE;
}


static BOOLEAN Stat(MAC_IFACE *iface, MAC_STAT *stats)
{
CHAR line[256];
ULONG dummy;

    ETH_DESCR *eth;
    
    eth=(ETH_DESCR *)iface->specific;

	if (GetIfStats(iface->descr, line) == FALSE)
		DnpapMessage(DMC_FATAL, ETH_ERROR, "eth: failed to get interface data");
	else
	{
		if (sscanf(line, ETH_STATS_FORMAT,
					&dummy, &eth->InErrors, 
					&eth->InDrops, &dummy, &dummy,
					&dummy, &eth->OutErrors, 
					&eth->OutDrops, &dummy, &eth->Collisions, &dummy) != ETH_STATS_SIZE)
			DnpapMessage(DMC_FATAL, ETH_ERROR, "eth: error in statistics");
	}
	
    stats->LostPkts         = eth->InDrops       ;
    stats->Octets           = eth->Octets        ;
    stats->Pkts             = eth->Pkts          ;
    stats->BroadcastPkts    = eth->BroadcastPkts ;
    stats->MulticastPkts    = eth->MulticastPkts ;
    stats->CRCAlignErrors   = eth->CRCAlignErrors;         
    stats->UndersizePkts    = eth->UndersizePkts ;            
    stats->OversizePkts     = eth->OversizePkts  ;             
    stats->Fragments        = eth->Fragments     ;
    stats->Jabbers          = eth->Jabbers       ;         
    stats->BufferedPkts     = eth->BufferedPkts  ;
    stats->StackedPkts      = eth->StackedPkts   ;
    stats->DiscardedPkts    = eth->DiscardedPkts ;
    stats->TruncatedPkts    = eth->TruncatedPkts ;

    stats->inPkts           = eth->Pkts          ;
	stats->inOctets         = eth->Octets        ;
    stats->inDiscards       = eth->DiscardedPkts + eth->InDrops;
    stats->inNUcastPkts     = eth->BroadcastPkts + eth->MulticastPkts;
    stats->inUcastPkts      = eth->Pkts - stats->inNUcastPkts;

    stats->outPkts          = eth->OutPkts       ;
    stats->outDiscards      = eth->OutDiscards + eth->OutDrops;
	stats->outOctets        = eth->OutOctets     ;
    stats->outNUcastPkts    = eth->OutBroadcastPkts + eth->OutMulticastPkts;
    stats->outUcastPkts     = eth->OutPkts - stats->outNUcastPkts;

    stats->inErrors         = eth->InErrors      ;
    stats->outErrors        = eth->OutErrors     ;
    stats->Collisions       = eth->Collisions    ;

    return TRUE;
}


BOOLEAN GetIfStats(CHAR *interface, CHAR *stats)
{
INT fd;
INT i, n, m = strlen(interface);
CHAR buf[1024];

	if ((fd = open(ETH_STATS, O_RDONLY)) < 0)
		return FALSE;

	if ((n = read(fd, buf, sizeof(buf)-1)) < 0)
		return FALSE;

	close (fd);

	buf[n] = '\0';
	for (i = 0; i < n; i++)
	{
		/* check first letter of the interface's name and the colon for speed */
		if (buf[i] == interface[0] && (i+m < n && buf[i+m] == ':') &&
			strncmp(buf+i+1, interface+1, m-1) == 0)
			break;
		i++;
	}

	if (i + m + 1 > n)
		return FALSE;

	for (i += m + 1; i < n && buf[i] != '\n' && buf[i] != '\0'; i++)
		*stats++ = buf[i];
	*stats = '\0';

	return TRUE;
}