discnodc.c

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

DISCNODE *p, *q;
WORD addrlen;

    addrlen = NodeLen(type);

    if (*lexlist == NULL)
    {
        *lexlist = disc;
        disc->LexPrev = NULL;
        disc->LexNext = NULL;
        return TRUE;
    }

    for (p = *lexlist, q = NULL; p != NULL; q = p, p = p->LexNext)
    {
        if (memcmp(p->Address, disc->Address, addrlen) >= 0)
            break;
    }

    if (q != NULL)
        q->LexNext = disc;
    else
        *lexlist = disc;

    if (p != NULL)
        p->LexPrev = disc;

    disc->LexPrev = q;
    disc->LexNext = p;

    return TRUE;
}


DISCNODE *DiscNodeAddLRUList(DISCNODE_CONTROL *discnodecontrol, DISCNODE *disc)
{
    if (discnodecontrol->LRUList == NULL)
    {
        discnodecontrol->LRUList = disc;
        discnodecontrol->LRULast = disc;       
        disc->LRUPrev = NULL;
        disc->LRUNext = NULL;
                                                           
        return NULL;
    }

    disc->LRUNext = discnodecontrol->LRUList;
    disc->LRUPrev = NULL;
    discnodecontrol->LRUList->LRUPrev = disc;
    discnodecontrol->LRUList = disc;

    return discnodecontrol->LRULast;
}      


BOOLEAN DiscNodeUpdateLRUList(DISCNODE_CONTROL *discnodecontrol, DISCNODE *disc)
{
    if (discnodecontrol->TableSize > 1 && discnodecontrol->LRUList != disc)
    {
        DiscNodeRemoveLRUList(discnodecontrol, disc);
        DiscNodeAddLRUList(discnodecontrol, disc);
    }
    
    return TRUE;
}


BOOLEAN DiscNodeRemoveLexList(DISCNODE **lexlist, DISCNODE *disc)
{
    if (disc->LexPrev != NULL)
        disc->LexPrev->LexNext = disc->LexNext;
    else
        *lexlist = disc->LexNext;
    if (disc->LexNext != NULL)
        disc->LexNext->LexPrev = disc->LexPrev;

    disc->LexPrev = NULL;
    disc->LexNext = NULL;
    
    return TRUE;
}


BOOLEAN DiscNodeRemoveLRUList(DISCNODE_CONTROL *discnodecontrol, DISCNODE *disc)
{
    if (disc->LRUPrev != NULL)
        disc->LRUPrev->LRUNext = disc->LRUNext;
    else
        discnodecontrol->LRUList = disc->LRUNext;
    if (disc->LRUNext != NULL)
        disc->LRUNext->LRUPrev = disc->LRUPrev;
    else
        discnodecontrol->LRULast = disc->LRUPrev;

    disc->LRUPrev = NULL;
    disc->LRUNext = NULL;
        
    return TRUE;
}


BOOLEAN DiscNodeAddTimeList(DISCNODE_CONTROL *discnodecontrol, INT type, DISCNODE **timelist, DISCNODE **timelast, DISCNODE *disc)
{
    if (*timelist == NULL)
    {
        *timelist = disc;
        *timelast = disc;
        disc->TimePrev = NULL;
        disc->TimeNext = NULL;
    }
    else
    {
        disc->TimePrev = *timelast;
        disc->TimeNext = NULL;
        (*timelast)->TimeNext = disc;
        *timelast = disc;
    }
    
    switch (type)
    {
    case DISC_TYPE_ETH:
        discnodecontrol->EthTimeListUpdated = TRUE;
        break;
    case DISC_TYPE_IP:
        discnodecontrol->IPTimeListUpdated = TRUE;
        break;
    case DISC_TYPE_UDP:
        discnodecontrol->UDPTimeListUpdated = TRUE;
        break;
    case DISC_TYPE_TCP:
        discnodecontrol->TCPTimeListUpdated = TRUE;
        break;
    default:
        DnpapMessage(DMC_FATAL, DISC_TYPE, "discnodecontrol: unknown type");
        DnpapExit(DISC_TYPE);
    }
        
    return TRUE;
}


BOOLEAN DiscNodeRemoveTimeList(DISCNODE_CONTROL *discnodecontrol, INT type, DISCNODE **timelist, DISCNODE **timelast, DISCNODE *disc)
{
    if (disc->TimePrev != NULL)
        disc->TimePrev->TimeNext = disc->TimeNext;
    else
        *timelist = disc->TimeNext;
    if (disc->TimeNext != NULL)
        disc->TimeNext->TimePrev = disc->TimePrev;
    else
        *timelast = disc->TimePrev;

    disc->TimePrev = NULL;
    disc->TimeNext = NULL;

    switch (type)
    {
    case DISC_TYPE_ETH:
        discnodecontrol->EthTimeListUpdated = TRUE;
        break;
    case DISC_TYPE_IP:
        discnodecontrol->IPTimeListUpdated = TRUE;
        break;
    case DISC_TYPE_UDP:
        discnodecontrol->UDPTimeListUpdated = TRUE;
        break;
    case DISC_TYPE_TCP:
        discnodecontrol->TCPTimeListUpdated = TRUE;
        break;
    default:
        DnpapMessage(DMC_FATAL, DISC_TYPE, "discnodecontrol: unknown type");
        DnpapExit(DISC_TYPE);
    }
        
    return TRUE;
}


BOOLEAN DiscNodeUpdateTimeTables(DISCNODE_CONTROL *discnodecontrol)
{
BOOLEAN rc = TRUE;

    if (discnodecontrol->EthTimeListUpdated == TRUE)
    {
        if (DiscNodeUpdateSpecificTimeTable(discnodecontrol->EthTimeList, discnodecontrol->EthTimeTable, discnodecontrol->EthTableSize) == TRUE)
            discnodecontrol->EthTimeListUpdated = FALSE;
        else
            rc = FALSE;
    }
    if (discnodecontrol->IPTimeListUpdated == TRUE)
    {
        if (DiscNodeUpdateSpecificTimeTable(discnodecontrol->IPTimeList, discnodecontrol->IPTimeTable, discnodecontrol->IPTableSize) == TRUE)
            discnodecontrol->EthTimeListUpdated = FALSE;
        else
            rc = FALSE;
    }
    if (discnodecontrol->UDPTimeListUpdated == TRUE)
    {
        if (DiscNodeUpdateSpecificTimeTable(discnodecontrol->UDPTimeList, discnodecontrol->UDPTimeTable, discnodecontrol->UDPTableSize) == TRUE)
            discnodecontrol->EthTimeListUpdated = FALSE;
        else
            rc = FALSE;
    }
    if (discnodecontrol->TCPTimeListUpdated == TRUE)
    {
        if (DiscNodeUpdateSpecificTimeTable(discnodecontrol->TCPTimeList, discnodecontrol->TCPTimeTable, discnodecontrol->TCPTableSize) == TRUE)
            discnodecontrol->EthTimeListUpdated = FALSE;
        else
            rc = FALSE;
    }
    
    return rc;
}


BOOLEAN DiscNodeUpdateSpecificTimeTable(DISCNODE *timelist, DISCNODE **timetable, LONG size)
{
LONG i;
DISCNODE *p;

	for (p = timelist, i = 0; p != NULL; p = p->TimeNext, i++)
	{
		timetable[i] = p;
		p->TimeListPtr = timetable+i;
	}
	
	if (i != size)
	{
		DnpapMessage(DMC_FATAL, DISC_UPDTIME, "discnodecontrol: internal error in time list and table");
		DnpapExit(DISC_UPDTIME);
	}
	
	return TRUE;
}


VOID LRUTimerCallback(TIMER_DESCR *timer, ULONG now, VOID *param)
{
DISCNODE_CONTROL *discnodecontrol = (DISCNODE_CONTROL *) param;
                                            
    if (discnodecontrol->LRULast != NULL && discnodecontrol->LRULast == discnodecontrol->LastLRUEntry)
        DiscNodeRemoveEntry(discnodecontrol, discnodecontrol->LRULast);
    discnodecontrol->LastLRUEntry = discnodecontrol->LRULast;
}


VOID DelDiscNodes(DISCNODE_CONTROL *discnodecontrol, DISCNODE **lexlist)
{
DISCNODE *disc1, *disc2;

    for (disc2 = *lexlist; disc2 != NULL; disc2 = disc1)
    {
        disc1 = disc2->LexNext;
        DnpapFree(disc2);
        discnodecontrol->TableSize--;
    }
    *lexlist = NULL;
}


DISCNODE *DiscNodeSearchNext(DISCNODE_CONTROL *discnodecontrol, INT type, DISCNODE *disc, WORD len)
{
DISCNODE *p, *lexlist = NULL;

    switch (type)
    {
    case DISC_TYPE_ETH:
        if (len == DISC_SIZE_ETHADDR &&
            (p = HashSearch(discnodecontrol->Table, disc->Address, DISC_SIZE_ETHADDR)) != NULL)
            return p->LexNext;
        lexlist = discnodecontrol->EthLexList;
        break;
    case DISC_TYPE_IP:
        if (len == DISC_SIZE_TOIPADDR &&
            (p = HashSearch(discnodecontrol->Table, disc->Address, DISC_SIZE_TOIPADDR)) != NULL)
            return p->LexNext;
        lexlist = discnodecontrol->IPLexList;
        break;
    case DISC_TYPE_UDP:
        if (len == DISC_SIZE_TOUDPADDR &&
            (p = HashSearch(discnodecontrol->Table, disc->Address, DISC_SIZE_TOUDPADDR)) != NULL)
            return p->LexNext;
        lexlist = discnodecontrol->UDPLexList;
        break;
    case DISC_TYPE_TCP:
        if (len == DISC_SIZE_TOTCPADDR &&
            (p = HashSearch(discnodecontrol->Table, disc->Address, DISC_SIZE_TOTCPADDR)) != NULL)
            return p->LexNext;
        lexlist = discnodecontrol->TCPLexList;
        break;
    default:
        DnpapMessage(DMC_FATAL, DISC_TYPE, "discnodecontrol: unknown type");
        DnpapExit(DISC_TYPE);
    }

    for (p = lexlist; p != NULL; p = p->LexNext)
    {
        if (memcmp(p->Address, disc->Address, len) >= 0)
            break;
    }
    return p;
}


DISCNODE *DiscNodeSearchHash(DISCNODE_CONTROL *discnodecontrol, INT type, SNMP_OBJECT *obj, WORD idlen)
{
WORD len;
BYTE address[DISC_SIZE_NODE];

    len = NodeLen(type);

    Id2Node(type, obj->Id, idlen+1, obj->IdLen, address);
    return HashSearch(discnodecontrol->Table, address, len);
}


DISCNODE* DiscNodeTimeSearch(DISCNODE_CONTROL *discnodecontrol, INT type, SNMP_OBJECT *obj, WORD idlen)
{
	DiscNodeUpdateTimeTables(discnodecontrol);
    
    switch (type)
    {
    case DISC_TYPE_ETHTIME:
        return discnodecontrol->EthTimeTable[obj->Id[idlen+1]-1];
    case DISC_TYPE_IPTIME:
        return discnodecontrol->IPTimeTable[obj->Id[idlen+1]-1];
    case DISC_TYPE_UDPTIME:
        return discnodecontrol->UDPTimeTable[obj->Id[idlen+1]-1];
    case DISC_TYPE_TCPTIME:
        return discnodecontrol->TCPTimeTable[obj->Id[idlen+1]-1];
    default:
        DnpapMessage(DMC_FATAL, DISC_TYPE, "discnodecontrol: unknown type");
        DnpapExit(DISC_TYPE);
    }
        
    return NULL;
}


LONG DiscNodeSearchCreationOrder(DISCNODE_CONTROL *discnodecontrol, INT type, DISCNODE *disc)
{
	DiscNodeUpdateTimeTables(discnodecontrol);
    
    switch (type)
    {
    case DISC_TYPE_ETH:
    case DISC_TYPE_ETHTIME:
        return disc->TimeListPtr - discnodecontrol->EthTimeTable + 1;
    case DISC_TYPE_IP:
    case DISC_TYPE_IPTIME:
        return disc->TimeListPtr - discnodecontrol->IPTimeTable + 1;
    case DISC_TYPE_UDP:
    case DISC_TYPE_UDPTIME:
        return disc->TimeListPtr - discnodecontrol->UDPTimeTable + 1;
    case DISC_TYPE_TCP:
    case DISC_TYPE_TCPTIME:
        return disc->TimeListPtr - discnodecontrol->TCPTimeTable + 1;
    default:
        DnpapMessage(DMC_FATAL, DISC_TYPE, "discnodecontrol: unknown type");
        DnpapExit(DISC_TYPE);
    }        
    
    return 0;
}


INT Node2Id(INT type, BYTE *node, INT len, LONG *id, INT match)
{
INT i, addrstart, addrend;
             
    switch (type)
    {
    case DISC_TYPE_UDP:
    case DISC_TYPE_TCP:
        addrstart = NodeLen(DISC_TYPE_IP);
        addrend = NodeLen(DISC_TYPE_UDP);
        if (addrstart < len)
            id[match+addrstart] = 256*(LONG)node[addrstart] + node[addrstart+1];
    case DISC_TYPE_IP:
        addrstart = NodeLen(DISC_TYPE_ETH);
        addrend = NodeLen(DISC_TYPE_IP);
        for (i = addrstart; i < IntMin(len, addrend); i++)
            id[match+i] = node[i];
    case DISC_TYPE_ETH:
        addrstart = 0;
        addrend = NodeLen(DISC_TYPE_ETH);
        for (i = addrstart; i < IntMin(len, addrend); i++)
            id[match+i] = node[i];
        break;
    default:
        i = 0;
        break;
    }
    
    if (i > 0)
    {
        if (type == DISC_TYPE_UDP || type == DISC_TYPE_TCP)
            return match+len-1;
        else
            return match+len;
    }
    
    return i;
}


INT Id2Node(INT type, LONG *id, INT match, INT len, BYTE *node)
{
INT i, addrstart, addrend, sublen;
             
    if ((sublen = len-match) < 0)
        return 0;

    switch (type)
    {
    case DISC_TYPE_UDP:
    case DISC_TYPE_TCP:
        addrstart = NodeLen(DISC_TYPE_IP);
        addrend = NodeLen(DISC_TYPE_UDP);
        if (addrstart < sublen)
        {
            node[addrstart] = (BYTE)(id[match+addrstart] >> 8);
            node[addrstart+1] = (BYTE)(id[match+addrstart] & 0x00ff);
        }
    case DISC_TYPE_IP:
        addrstart = NodeLen(DISC_TYPE_ETH);
        addrend = NodeLen(DISC_TYPE_IP);
        for (i = addrstart; i < IntMin(sublen, addrend); i++)
            node[i] = (BYTE)id[match+i];
    case DISC_TYPE_ETH:
        addrstart = 0;
        addrend = NodeLen(DISC_TYPE_ETH);
        for (i = addrstart; i < IntMin(sublen, addrend); i++)
            node[i] = (BYTE)id[match+i];
        break;
    default:
        i = 0;
        break;
    }
    
    if (i > 0)
    {
        if (type == DISC_TYPE_UDP || type == DISC_TYPE_TCP)
            return sublen+1;
        else
            return sublen;
    }
    
    return i;
}


INT NodeLen(INT type)
{
    switch (type)
    {
    case DISC_TYPE_ETH:
        return DISC_SIZE_ETHADDR;
    case DISC_TYPE_IP:
        return DISC_SIZE_TOIPADDR;
    case DISC_TYPE_UDP:
        return DISC_SIZE_TOUDPADDR;
    case DISC_TYPE_TCP:
        return DISC_SIZE_TOTCPADDR;
    default:
        return 0;
    }
}