pf.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 <dkvm.h>
#include <mac.h>
#include <chain.h>
#include <net/pfilt.h>

#include "pf.h"
 

extern Kvm *kvm;


PF_DESCR *pfDescrList = 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 GetIfnetOffset(CHAR *name, ULONG *offset);
static BOOLEAN GetIfnet(ULONG offset, IFNET *ifnet);



void PfExit(void)
{
    PF_DESCR      *pf;
    
    while (pfDescrList!=0)
    {
        pf = pfDescrList;
        pfDescrList = pfDescrList->next;
                    
        MacIfaceRemove(pf->mac);
        NwDgClose(pf->nw);
        DnpapFree(pf);
    }
}


BOOLEAN PfInit(void)
{
    BYTE            name[255];
    BYTE            addr[255];
    CHAR            *descr;
    MAC_IFACE       *mac;
    PF_DESCR        *pf; 
    WORD            i;
    ULONG			offset = 0;
	IFNET			ifnet;
	NW_IFCONFIG		ifconfig;
    static BOOLEAN  init = FALSE;
    
    if (!init)
    {
        i = 1;
        sprintf(name, "pf.iface.name.%d", i);
        while (ConfigGetString(name, &descr))
        {
            mac = DnpapMalloc(sizeof(MAC_IFACE));
            if (mac!=0)
            {                        
                pf=DnpapMalloc(sizeof(PF_DESCR)); 
                memset(pf, 0, sizeof(PF_DESCR));
                if (pf!=0)
                {
                    pf->mac=mac;
                    
                    sprintf(addr,"pf:%s:8192:0", descr);
                    pf->nw=NwDgAccept(addr, Rcve, pf);  
                    if (pf->nw != NULL && NwDgIfConfig(pf->nw, &ifconfig) == TRUE)
                    {
						if (GetIfnetOffset(descr, &offset) == FALSE || GetIfnet(offset, &ifnet) == FALSE)
							DnpapMessage(DMC_FATAL, PF_ERROR, "pf: interface not found in kernel memory");

						pf->offset        = offset;

                        mac->specific      = pf;
                        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); 
                    }
                    
                    pf->next=pfDescrList;
                    pfDescrList=pf;
                }
            }    
            
            i++;
            sprintf(name, "pf.iface.name.%d", i);
        }
        
        DnpapAtExit(PfExit);

        init = TRUE;
    }

    return init;
}



static void Rcve(NW_DG *nw, char *addr, BYTE *frame, int length, void *parm)
{
    PF_DESCR           *pf;
    CHAIN               chain;
    MAC_INFO            info; 
    BYTE                *p;
	struct enstamp      *pfHdr;
    struct timeval      *pfTime;
    u_short             *pfDrops;
    u_short             *pfLen;
    u_long              *pfOverflows;
        
    pf=(PF_DESCR *)parm;
    
    pfHdr = (struct enstamp *) frame;

    pfTime = &pfHdr->ens_tstamp;
    pfDrops = &pfHdr->ens_dropped;
    pfLen = &pfHdr->ens_count;
	pfOverflows = &pfHdr->ens_ifoverflows;

	p = frame + pfHdr->ens_stamplen;
    
    info.copied      = length; 
    info.length      = *pfLen;
    info.time        = pfTime->tv_sec*1000000UL + pfTime->tv_usec;
    info.promiscuous = ((p[0] & (BYTE)0x01)!=(BYTE)0x01 &&
                            memcmp(p, pf->mac->addr, pf->mac->addrLength)!=0);
    pf->Pkts++;
    pf->Octets += length;
    pf->DiscardedPkts = *pfDrops;
    pf->IfOverflows = *pfOverflows;
        
    if (info.length > info.copied)
        pf->TruncatedPkts++;
    if (!info.promiscuous)
        pf->StackedPkts++;
    if (memcmp(p,"\xff\xff\xff\xff\xff\xff",pf->mac->addrLength)==0)
        pf->BroadcastPkts++;
    else if(p[0] & (BYTE)0x01)
        pf->MulticastPkts++;
    if (length < 60)
        pf->UndersizePkts++;           
    if (length > 1514)
        pf->OversizePkts++;           

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


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

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

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

    return TRUE;
}


static BOOLEAN Stat(MAC_IFACE *iface, MAC_STAT *stats)
{
IFNET ifnet;

    PF_DESCR *pf;
    
    pf=(PF_DESCR *)iface->specific;

	if (pf->offset != 0)
	{
		if (GetIfnet(pf->offset, &ifnet) == FALSE)
			DnpapMessage(DMC_FATAL, PF_ERROR, "pf: failed to get interface data");
		else
		{
			pf->OutQLen    = ifnet.if_snd.ifq_len;
			pf->InErrors   = ifnet.if_ierrors;
			pf->OutErrors  = ifnet.if_oerrors;
			pf->Collisions = ifnet.if_collisions;
		}
	}
	
    stats->LostPkts         = pf->LostPkts      ;
    stats->Octets           = pf->Octets        ;
    stats->Pkts             = pf->Pkts          ;
    stats->BroadcastPkts    = pf->BroadcastPkts ;
    stats->MulticastPkts    = pf->MulticastPkts ;
    stats->CRCAlignErrors   = pf->CRCAlignErrors;         
    stats->UndersizePkts    = pf->UndersizePkts ;            
    stats->OversizePkts     = pf->OversizePkts  ;             
    stats->Fragments        = pf->Fragments     ;
    stats->Jabbers          = pf->Jabbers       ;         
    stats->BufferedPkts     = pf->BufferedPkts  ;
    stats->StackedPkts      = pf->StackedPkts   ;
    stats->DiscardedPkts    = pf->DiscardedPkts ;
    stats->TruncatedPkts    = pf->TruncatedPkts ;

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

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

    stats->outQLen          = pf->OutQLen       ;
    stats->inErrors         = pf->InErrors      ;
    stats->outErrors        = pf->OutErrors     ;
    stats->Collisions       = pf->Collisions    ;

    stats->ifOverflows      = pf->IfOverflows   ;

    return TRUE;
}


BOOLEAN GetIfnetOffset(CHAR *name, ULONG *offset)
{
IFNET ifnet, *ifnetaddr;
CHAR ifnetname[16];
CHAR tmpname[32];

	if (KvmReadSym(kvm, "_ifnet", &ifnetaddr, sizeof(IFNET *)) < 0)
		return FALSE;
	
	while (ifnetaddr != NULL)
	{
		if (KvmRead(kvm, (ULONG) ifnetaddr, &ifnet, sizeof(IFNET)) < 0)
			return FALSE;
		if (KvmRead(kvm, (ULONG) ifnet.if_name, (BYTE *) ifnetname, 16) < 0)
			return FALSE;

		sprintf(tmpname, "%.16s%d", ifnetname, ifnet.if_unit);
		if (strcmp(tmpname, name) == 0)
		{
			*offset = (ULONG) ifnetaddr;
			return TRUE;
		}

		ifnetaddr = ifnet.if_next;
	}

	*offset = 0;

	return FALSE;
}


BOOLEAN GetIfnet(ULONG offset, IFNET *ifnet)
{
	if (KvmRead(kvm, offset, ifnet, sizeof(IFNET)) < 0)
		return FALSE;
	return TRUE;
}