discconc.c

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

    {
        if (memcmp(p->SrcDst, srcdst->SrcDst, 2*addrlen) >= 0)
            break;
    }

    if (q != NULL)
        q->SrcDstNext = srcdst;
    else
        *sdlexlist = srcdst;

    if (p != NULL)
        p->SrcDstPrev = srcdst;

    srcdst->SrcDstPrev = q;
    srcdst->SrcDstNext = p;


    /*  update DstSrcList  */
    for (p = *dslexlist, q = NULL; p != NULL; q = p, p = p->DstSrcNext)
    {
        if (connrcmp(p->SrcDst, srcdst->SrcDst, addrlen, 2*addrlen) >= 0)
            break;
    }

    if (q != NULL)
        q->DstSrcNext = srcdst;
    else
        *dslexlist = srcdst;

    if (p != NULL)
        p->DstSrcPrev = srcdst;

    srcdst->DstSrcPrev = q;
    srcdst->DstSrcNext = p;
        

    return TRUE;
}


DISCCONN* DiscConnAddLRUList(DISCCONN_CONTROL *discconncontrol, DISCCONN *srcdst)
{
    if (discconncontrol->LRUList == NULL)
    {
        discconncontrol->LRUList = srcdst;
        discconncontrol->LRULast = srcdst;
        srcdst->LRUPrev = NULL;
        srcdst->LRUNext = NULL;
        
        return NULL;
    }

    srcdst->LRUNext = discconncontrol->LRUList;
    srcdst->LRUPrev = NULL;
    discconncontrol->LRUList->LRUPrev = srcdst;
    discconncontrol->LRUList = srcdst;

    return discconncontrol->LRULast;
}


BOOLEAN DiscConnUpdateLRUList(DISCCONN_CONTROL *discconncontrol, DISCCONN *srcdst)
{
    if (discconncontrol->TableSize > 1 && discconncontrol->LRUList != srcdst)
    {          
        DiscConnRemoveLRUList(discconncontrol, srcdst);
        DiscConnAddLRUList(discconncontrol, srcdst);
    }
    
    return TRUE;
}


BOOLEAN DiscConnRemoveConnList(DISCCONN **sdlexlist, DISCCONN **dslexlist, DISCCONN *srcdst)
{
    if (srcdst->SrcDstPrev != NULL)
        srcdst->SrcDstPrev->SrcDstNext = srcdst->SrcDstNext;
    else
        *sdlexlist = srcdst->SrcDstNext;
    if (srcdst->SrcDstNext != NULL)
        srcdst->SrcDstNext->SrcDstPrev = srcdst->SrcDstPrev;

    if (srcdst->DstSrcPrev != NULL)
        srcdst->DstSrcPrev->DstSrcNext = srcdst->DstSrcNext;
    else
        *dslexlist = srcdst->DstSrcNext;
    if (srcdst->DstSrcNext != NULL)
        srcdst->DstSrcNext->DstSrcPrev = srcdst->DstSrcPrev;

    return TRUE;
}


BOOLEAN DiscConnRemoveLRUList(DISCCONN_CONTROL *discconncontrol, DISCCONN *srcdst)
{
    if (srcdst->LRUPrev != NULL)
        srcdst->LRUPrev->LRUNext = srcdst->LRUNext;
    else
        discconncontrol->LRUList = srcdst->LRUNext;
    if (srcdst->LRUNext != NULL)
        srcdst->LRUNext->LRUPrev = srcdst->LRUPrev;
    else                              
        discconncontrol->LRULast = srcdst->LRUPrev;

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


VOID LRUTimerCallback(TIMER_DESCR *timer, ULONG now, VOID *param)
{
DISCCONN_CONTROL *discconncontrol = (DISCCONN_CONTROL *) param;
                                            
    if (discconncontrol->LRULast != NULL && discconncontrol->LRULast == discconncontrol->LastLRUEntry)
        DiscConnRemoveEntry(discconncontrol, discconncontrol->LRULast);
    discconncontrol->LastLRUEntry = discconncontrol->LRULast;
}


VOID DelConns(DISCCONN_CONTROL *discconncontrol, DISCCONN **sdlexlist, DISCCONN **dslexlist)
{
DISCCONN *srcdst1, *srcdst2;

    for (srcdst2 = *sdlexlist; srcdst2 != NULL; srcdst2 = srcdst1)
    {
        srcdst1 = srcdst2->SrcDstNext;
        DnpapFree(srcdst2);
        discconncontrol->TableSize--;
    }
    *sdlexlist = NULL;
    *dslexlist = NULL;
}


DISCCONN* DiscConnSearchNext(DISCCONN_CONTROL *discconncontrol, INT type, BYTE *srcdst, WORD len, BOOLEAN SDorder)
{
DISCCONN* p, *lexlist = NULL;
BYTE srcdst2[DISC_SIZE_CONN];
WORD addrlen;

	if (SDorder == TRUE)
	{
        switch (type)
        {
        case DISC_TYPE_ETH:
	        if (len == 2*DISC_SIZE_ETHADDR &&
	            (p = HashSearch(discconncontrol->Table, srcdst, 2*DISC_SIZE_ETHADDR)) != NULL)
	            return p->SrcDstNext;
            lexlist = discconncontrol->EthSrcDstList;
            break;
        case DISC_TYPE_IP:
	        if (len == 2*DISC_SIZE_TOIPADDR &&
	            (p = HashSearch(discconncontrol->Table, srcdst, 2*DISC_SIZE_TOIPADDR)) != NULL)
	            return p->SrcDstNext;
            lexlist = discconncontrol->IPSrcDstList;
            break;
        case DISC_TYPE_UDP:
	        if (len == 2*DISC_SIZE_TOUDPADDR &&
	            (p = HashSearch(discconncontrol->Table, srcdst, 2*DISC_SIZE_TOUDPADDR)) != NULL)
	            return p->SrcDstNext;
            lexlist = discconncontrol->UDPSrcDstList;
            break;
        case DISC_TYPE_TCP:
	        if (len == 2*DISC_SIZE_TOTCPADDR &&
	            (p = HashSearch(discconncontrol->Table, srcdst, 2*DISC_SIZE_TOTCPADDR)) != NULL)
	            return p->SrcDstNext;
            lexlist = discconncontrol->TCPSrcDstList;
            break;
        }

        for (p = lexlist; p != NULL; p = p->SrcDstNext)
	    {
	        if (memcmp(p->SrcDst, srcdst, len) >= 0)
	            break;
	    }
	    return p;
    }
    else
    {   
        addrlen = ConnLen(type);
        
        switch (type)
        {
        case DISC_TYPE_ETH:
            lexlist = discconncontrol->EthDstSrcList;
            break;
        case DISC_TYPE_IP:
            lexlist = discconncontrol->IPDstSrcList;
            break;
        case DISC_TYPE_UDP:
            lexlist = discconncontrol->UDPDstSrcList;
            break;
        case DISC_TYPE_TCP:
            lexlist = discconncontrol->TCPDstSrcList;
            break;
        }

        /*  srcdst contains destination and source in that order, so switch them  */
	    memcpy(srcdst2, srcdst+addrlen, addrlen);
	    memcpy(srcdst2+addrlen, srcdst, addrlen);
	    if (len == 2U*addrlen)
		{
	        if ((p = HashSearch(discconncontrol->Table, srcdst2, 2*addrlen)) != NULL)
	            return p->DstSrcNext;
		}

	    for (p = lexlist; p != NULL; p = p->DstSrcNext)
	    {
	        if (connrcmp(p->SrcDst, srcdst2, addrlen, len) >= 0)
	            break;
	    }
        return p;
	}
}


DISCCONN* DiscConnSearchHash(DISCCONN_CONTROL *discconncontrol, INT type, SNMP_OBJECT *obj, WORD idlen, BOOLEAN SDorder)
{
WORD addrlen;
BYTE srcdst[DISC_SIZE_CONN], srcdst2[DISC_SIZE_CONN];
                 
    addrlen = ConnLen(type);

	if (SDorder == TRUE)
	{
        Id2Conn(type, obj->Id, idlen+1, obj->IdLen, srcdst);
	    return HashSearch(discconncontrol->Table, srcdst, 2*addrlen);
    }
    else
    {
        Id2Conn(type, obj->Id, idlen+1, obj->IdLen, srcdst);
        /*  srcdst contains destination and source in that order, so switch them  */
	    memcpy(srcdst2, srcdst+addrlen, addrlen);
	    memcpy(srcdst2+addrlen, srcdst, addrlen);
	    return HashSearch(discconncontrol->Table, srcdst2, 2*addrlen);
    }
}


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


INT Id2Conn(INT type, LONG *id, INT match, INT len, BYTE *conn)
{
INT i, addrstart, addrend, sublen, coffset, ioffset, connlen;
         
    if ((sublen = len-match) < 0)
        return 0;
	
	connlen = ConnLen(type);
	if (sublen > 2*connlen)
		sublen = 2*connlen;
		
    coffset = connlen;
    if (type == DISC_TYPE_UDP || type == DISC_TYPE_TCP)
        ioffset = coffset-1;
    else
        ioffset = coffset;
    
    switch (type)
    {
    case DISC_TYPE_UDP:
    case DISC_TYPE_TCP:
        addrstart = ConnLen(DISC_TYPE_IP);
        addrend = ConnLen(DISC_TYPE_UDP);
        if (ioffset+addrstart < sublen)
        {
            conn[coffset+addrstart] = (BYTE)(id[ioffset+match+addrstart] >> 8);
            conn[coffset+addrstart+1] = (BYTE)(id[ioffset+match+addrstart] & 0x00ff);
        }
        if (addrstart < sublen)
        {
            conn[addrstart] = (BYTE)(id[match+addrstart] >> 8);
            conn[addrstart+1] = (BYTE)(id[match+addrstart] & 0x00ff);
        }
    case DISC_TYPE_IP:
        addrstart = ConnLen(DISC_TYPE_ETH);
        addrend = ConnLen(DISC_TYPE_IP);
        for (i = addrstart; i < IntMin(sublen-ioffset, addrend); i++)
            conn[coffset+i] = (BYTE)id[ioffset+match+i];
        for (i = addrstart; i < IntMin(sublen, addrend); i++)
            conn[i] = (BYTE)id[match+i];
    case DISC_TYPE_ETH:
        addrstart = 0;
        addrend = ConnLen(DISC_TYPE_ETH);
        for (i = addrstart; i < IntMin(sublen-ioffset, addrend); i++)
            conn[coffset+i] = (BYTE)id[ioffset+match+i];
        for (i = addrstart; i < IntMin(sublen, addrend); i++)
            conn[i] = (BYTE)id[match+i];
        break;
    default:
        i = 0;
        break;
    }
    
    if (i > 0)
    {
        if (type == DISC_TYPE_UDP || type == DISC_TYPE_TCP)
            if (sublen < ioffset)
                return sublen+1;
            else
                return sublen+2;
        else
            return sublen;
    }
    
    return i;
}


INT ConnLen(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;
    }
}


int connrcmp(BYTE *srcdst1, BYTE *srcdst2, WORD addrlen, WORD len)
{
INT i1, i2;

	if (len > 2*addrlen)
		len = 2*addrlen;

	for (i1 = addrlen, i2 = addrlen; len > 0; i1++, i2++, len--)
	{
		if (i1 >= 2*addrlen)
			i1 = i2 = 0;
		
		if (srcdst1[i1] < srcdst2[i2])
			return -1;
		else
		if (srcdst1[i1] > srcdst2[i2])
			return 1;
	}

	return 0;
}