dmatrixc.c

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

    
	return;
}

LRUEntry *MatrixAddLRUList(DNPAP_MATRIX_CONTROL * matrixcontrol, LRUEntry * entry)
{
	if (matrixcontrol->LRUList == NULL)
	{
		matrixcontrol->LRUList = entry;
		matrixcontrol->LRULast = entry;
		entry->LRUPrev = NULL;
		entry->LRUNext = NULL;

		return NULL;
	}

	entry->LRUNext = matrixcontrol->LRUList;
	entry->LRUPrev = NULL;
	matrixcontrol->LRUList->LRUPrev = entry;
	matrixcontrol->LRUList = entry;

	return matrixcontrol->LRULast;
}

BOOLEAN MatrixRemoveLRUList(DNPAP_MATRIX_CONTROL * matrixcontrol, LRUEntry * entry)
{
	if (entry->LRUPrev != NULL)
		entry->LRUPrev->LRUNext = entry->LRUNext;
	else
		matrixcontrol->LRUList = entry->LRUNext;
	if (entry->LRUNext != NULL)
		entry->LRUNext->LRUPrev = entry->LRUPrev;
	else
		matrixcontrol->LRULast = entry->LRUPrev;

	return TRUE;
}

BOOLEAN MatrixUpdateLRUList(DNPAP_MATRIX_CONTROL * matrixcontrol, LRUEntry * entry)
{
	if (matrixcontrol->TableSize > 1 && entry != NULL)
	{
		MatrixRemoveLRUList(matrixcontrol, entry);
		MatrixAddLRUList(matrixcontrol, entry);
	}
	return TRUE;
}

BOOLEAN MatrixDelConns(DNPAP_MATRIX_CONTROL * matrixcontrol)
{
	LRUEntry *t;

    /*  take the first entry each time  */
	for (t = matrixcontrol->LRUList; t != NULL; t = matrixcontrol->LRUList)
	{
		MatrixRemoveLRUList(matrixcontrol, t);
		MatrixDelConn(matrixcontrol, t);
		DnpapFree(t);
	}

	return TRUE;
}

BOOLEAN MatrixDelConn(DNPAP_MATRIX_CONTROL * matrixcontrol, LRUEntry * entry)
{
	Host *srchost, *dsthost;
	ConnInfo *connsrc, *conndst;

	connsrc = entry->ConnSrc;
	conndst = entry->ConnDst;

	srchost = connsrc->ConnHost;
	dsthost = conndst->ConnHost;

	if (conndst->Stats != connsrc->Stats)
	{
		DnpapMessage(DMC_FATAL, DMATRIX_STATSERR, "dmatrix: error in internal tables");
		DnpapExit(DMATRIX_STATSERR);
	}

	DnpapFree(connsrc->Stats);

	ListDelConn(srchost, conndst);
	ListDelConn(dsthost, connsrc);

	if (srchost->LexList == 0)
		MatrixDelHost(matrixcontrol, srchost, TRUE);
	if (dsthost->LexList == 0)
		MatrixDelHost(matrixcontrol, dsthost, FALSE);

	return TRUE;
}

VOID ListDelConn(Host * host, ConnInfo * conn)
{
	if (conn->LexPrev == NULL)
		host->LexList = conn->LexNext;
	else
		conn->LexPrev->LexNext = conn->LexNext;
	if (conn->LexNext != NULL)
		conn->LexNext->LexPrev = conn->LexPrev;

	if (conn->TopPrev == NULL)
		host->TopList = conn->TopNext;
	else
		conn->TopPrev->TopNext = conn->TopNext;
	if (conn->TopNext != NULL)
		conn->TopNext->TopPrev = conn->TopPrev;
	else
		host->TopLast = conn->TopPrev;

	DnpapFree(conn);

	host->NumberConnect--;
    
    if (host->NumberConnect == 0 && 
        (host->LexList != NULL || host->TopList != NULL))
    {
		DnpapMessage(DMC_FATAL, DMATRIX_CONNERR, "dmatrix: error in internal tables");
		DnpapExit(DMATRIX_CONNERR);
    }
}

VOID MatrixDelHost(DNPAP_MATRIX_CONTROL * matrixcontrol, Host * host, BOOLEAN source)
{
	Host **list;
	HashTable *table;

	if (source == TRUE)
	{
		list = &matrixcontrol->SrcList;
		table = matrixcontrol->SrcTable;
	}
	else
	{
		list = &matrixcontrol->DstList;
		table = matrixcontrol->DstTable;
	}

	if (host->Prev == NULL)
		*list = host->Next;
	else
		host->Prev->Next = host->Next;
	if (host->Next != NULL)
		host->Next->Prev = host->Prev;

	HashRemove(table, host->Addr, matrixcontrol->AddressLen);

	DnpapFree(host);
}

BOOLEAN MatrixAddHost(DNPAP_MATRIX_CONTROL * matrixcontrol, Host * host, BOOLEAN source)
{
	Host *h, *p, **list;

	if (source == TRUE)
		list = &matrixcontrol->SrcList;
	else
		list = &matrixcontrol->DstList;

	if (*list == NULL)
	{
		*list = host;
		host->Prev = NULL;
		host->Next = NULL;
		return TRUE;
	}

	for (h = *list, p = NULL; h != NULL; p = h, h = h->Next)
		if (memcmp(h->Addr, host->Addr, matrixcontrol->AddressLen) >= 0)
			break;

	host->Prev = p;
	host->Next = h;

	if (h != NULL)
		h->Prev = host;
	if (p != NULL)
		p->Next = host;
	else
		*list = host;

	return TRUE;
}

BOOLEAN ListAddLex(Host * host, ConnInfo * conn, WORD addrlen)
{
	ConnInfo *s, *t;

	if (host->LexList == NULL)
	{
		host->LexList = conn;
		conn->LexNext = NULL;
		conn->LexPrev = NULL;
		return TRUE;
	}

	for (s = host->LexList, t = NULL; s != NULL; t = s, s = s->LexNext)
		if (memcmp(s->ConnHost->Addr, conn->ConnHost->Addr, addrlen) >= 0)
			break;

	conn->LexPrev = t;
	conn->LexNext = s;

	if (s != NULL)
		s->LexPrev = conn;
	if (t != NULL)
		t->LexNext = conn;
	else
		host->LexList = conn;

	return TRUE;
}

BOOLEAN ListAddTop(Host * host, ConnInfo * conn)
{
	if (host->TopLast == NULL)
	{
		host->TopList = conn;
		host->TopLast = conn;
		conn->TopNext = NULL;
		conn->TopPrev = NULL;
		return TRUE;
	}

	conn->TopPrev = host->TopLast;
	conn->TopNext = NULL;
	host->TopLast->TopNext = conn;
	host->TopLast = conn;

	return TRUE;
}

BOOLEAN ListUpdateTop(Host * host, ConnInfo * conn)
{
	ConnInfo *a;

	if (host->TopList == conn)
		return TRUE;

	for (a = conn->TopPrev; a != NULL && a->Stats->Pkts <= conn->Stats->Pkts; a = a->TopPrev)
		;

	if (a == conn->TopPrev)
		return TRUE;

	conn->TopPrev->TopNext = conn->TopNext;
	if (conn->TopNext != NULL)
		conn->TopNext->TopPrev = conn->TopPrev;
	else
		host->TopLast = conn->TopPrev;

	conn->TopPrev = a;
	if (a == NULL)
	{
		conn->TopNext = host->TopList;
		host->TopList->TopPrev = conn;
		host->TopList = conn;
	}
	else
	{
		conn->TopNext = a->TopNext;
		a->TopNext->TopPrev = conn;
		a->TopNext = conn;
	}

	return TRUE;
}

Host *DnpapMatrixSearchHost(DNPAP_MATRIX_CONTROL * matrixcontrol, BYTE * addr, WORD len, BOOLEAN source)
{
	Host *a;

	if (source == TRUE)
		a = matrixcontrol->SrcList;
	else
		a = matrixcontrol->DstList;

	for (; a != NULL; a = a->Next)
	{
		if (memcmp(a->Addr, addr, len) >= 0)
			break;
	}

	return a;
}

ConnInfo *DnpapMatrixSearchHostObj(DNPAP_MATRIX_CONTROL * matrixcontrol, SNMP_OBJECT * obj, WORD idlen, BOOLEAN source, Host ** host, INT * rank)
{
	HashTable *table;
	BYTE addr[HOST_SIZE_ADDR], other[HOST_SIZE_ADDR];
	INT i, len;
	ConnInfo *conn;
	WORD addrlen = matrixcontrol->AddressLen;

	len = obj->IdLen - idlen - 3;

	if (len < 0)
		len = 0;
                                 
    if (len != 2 * addrlen)
        return NULL;

	if (obj->Id[idlen+1] != addrlen || obj->Id[idlen+1+addrlen+1] != addrlen)
        return NULL;
        
	for (i = 0; i < addrlen; i++)
	{
		addr[i] = obj->Id[idlen + 2 + i];
		other[i] = obj->Id[idlen + 3 + addrlen + i];
	}

	if (source == TRUE)
		table = matrixcontrol->SrcTable;
	else
		table = matrixcontrol->DstTable;

	if ((*host = HashSearch(table, addr, addrlen)) == NULL)
        return NULL;

	*rank = DMatrixListSearchRank(*host, other, &conn, matrixcontrol->AddressLen);
	/* conn == NULL als niet gevonden */

	return conn;
}

ConnInfo *DnpapMatrixSearchTopObj(DNPAP_MATRIX_CONTROL * matrixcontrol, SNMP_OBJECT * obj, WORD idlen, BOOLEAN source, Host ** host, INT * rank)
{
	HashTable *table;
	BYTE addr[HOST_SIZE_ADDR];
	INT i, len;
	WORD addrlen = matrixcontrol->AddressLen;

	len = obj->IdLen - idlen - 2;

	if (len < 0)
		len = 0;
                                 
    if (len != addrlen + 1)
        return NULL;
        
	if (obj->Id[idlen+1] != addrlen)
        return NULL;
        
	for (i = 0; i < addrlen; i++)
		addr[i] = obj->Id[idlen + 2 + i];
	*rank = obj->Id[idlen + 2 + addrlen];

	if (source == TRUE)
		table = matrixcontrol->SrcTable;
	else
		table = matrixcontrol->DstTable;

	if ((*host = HashSearch(table, addr, addrlen)) == NULL)
        return NULL;
        
	return DMatrixListSearchTop(*host, *rank);
}

ConnInfo *DMatrixListSearchAddr(Host * host, BYTE * addr, WORD len)
{
	ConnInfo *b;

	for (b = host->LexList; b != NULL; b = b->LexNext)
	{
		if (memcmp(b->ConnHost->Addr, addr, len) >= 0)
			break;
	}

	return b;
}

ConnInfo *DMatrixListSearchTop(Host * host, INT rank)
{
	ConnInfo *a;
	INT i = 1;

	for (a = host->TopList; a != NULL; a = a->TopNext, i++)
		if (i == rank)
			return a;

	return NULL;
}

ConnInfo *ListConnSearch(Host * host, BYTE * addr, WORD addrlen)
{
	ConnInfo *a;

	for (a = host->LexList; a != NULL; a = a->LexNext)
		if (memcmp(a->ConnHost->Addr, addr, addrlen) == 0)
			break;

	return a;
}

INT DMatrixListSearchRank(Host * host, BYTE * addr, ConnInfo ** conn, WORD addrlen)
{
	INT rank = 1;

	for (*conn = host->TopList; *conn != NULL; *conn = (*conn)->TopNext)
	{
		if (memcmp((*conn)->ConnHost->Addr, addr, addrlen) == 0)
			return rank;
		rank++;
	}

	return 0;
}
 

#ifdef DEBUG

static VOID ListCheckConns(Host * host)
{
INT n;
ConnInfo *c;

    for (c = host->LexList, n = 0; c != NULL; c = c->LexNext)
        n++;                     
    if (n != host->NumberConnect)
        DnpapMessage(DMC_ERROR, DMATRIX_CONSIST, "dmatrix: inconsistent list");

    for (c = host->TopList, n = 0; c != NULL; c = c->TopNext)
        n++;                     
    if (n != host->NumberConnect)
        DnpapMessage(DMC_ERROR, DMATRIX_CONSIST, "dmatrix: inconsistent list");
}

#endif