igmpcon_main.c

igmp for switch in vxworks

	{
		ptmp->pNext = groupstatlist;
		ptmp->pPrv = groupstatlist;
		groupstatlist->pNext = ptmp;
		groupstatlist->pPrv = ptmp;
		groupstatlist = ptmp;
	}

	/*第三条记录 */
	if (groupstatcount >= 3)
	{
		ptmp->pNext = groupstatlist;
		ptmp->pPrv = groupstatlist->pPrv;
		groupstatlist->pPrv->pNext = ptmp;
		groupstatlist->pPrv = ptmp;
		groupstatlist = ptmp;
	}
	semGive (semConStat);
	return OK;
}

/*************************************************
  Function:       ClearRecordList
  Description:   clear record list
  Input:         	 msg
  Output:         无
  Return:          n/a
  Others:         // 其它说明
*************************************************/
void ClearRecordList (void)
{
	int count;
	PortRecord *ptmp, *del;
	int i;
	int semlog;

	if (!recordcount || NULL == recordlist)
		return;

	count = recordcount;
	semlog = semTake (semConLog, 10);
	if (ERROR == semlog)
	{
		semtakeerror++;
		printf (" Take semConLog error !ClearRecordList\r\n");
		return;
	}
	ptmp = recordlist;
	if (ptmp->pPrv)
	{
		ptmp->pPrv->pNext = NULL;
		ptmp->pPrv = NULL;
	}
	while (ptmp && recordcount)
	{
		del = ptmp;
		ptmp = ptmp->pNext;
		del->pNext = NULL;
		del->pPrv = NULL;
		free (del);
		del = NULL;
		count--;
		recordcount--;
	}
	recordcount = 0;
	recordlist = NULL;
	semGive (semConLog);
}

int GetBitState (char *buf, char no)
{
	char *p;
	int a, at;

	p = buf;
	if (no <= 16)
	{
		a = *(int *) p;
		at = 0x8000;
		at = at >> (no - 1);
		if (at & a)
		{
			return 1;
		}
		return 0;
	}
	return -1;
}

int SetBitState (char *buf, char no, char state)
{
	char *p;
	int a, at;

	p = buf;
	if (no <= 16)
	{
		a = 0x8000;
		a = a >> (no - 1);
		if (state == 1)
		{
			*(int *) buf = (*(int *) buf) | at;
			return OK;
		}
		else
		{
			at = ~a;
			*(int *) buf = (*(int *) buf) & at;
			return OK;
		}
	}
	return -1;
}

int bit = 0;

int setbit (char no, char state)
{
	int i;
	char *p;

	p = (char *) &bit;
	SetBitState (p, no, state);

	for (i = 1; i <= 16; i++)
	{
		p = (char *) &bit;
		printf ("%", GetBitState (p, i));
	}
	printf ("%x", bit);
}

void TimeConvert (int time, char *ptime)
{
	int hour, min, sec;

	hour = time / 3600;
	min = (time - 3600 * hour) / 60;
	sec = time - 3600 * hour - 60 * min;
	sprintf (ptime, "%03d:%02d:%02d", hour, min, sec);
}

void getTime (char *time)
{
	int yy, mm, dd, hh, min, sec;
	char ptime[20];

	memset (ptime, 0, sizeof (ptime));
	comm_getTime (ptime);
	sscanf (ptime, "%4d%2d%2d%2d%2d%2d", &yy, &mm, &dd, &hh, &min, &sec);
	sprintf (time, "%4d-%02d-%02d %02d:%02d:%02d", yy, mm, dd, hh, min, sec);
}

/*************************************************
  Function:       AddGroupVlan
  Description:   
  Input:         	 UINT groupaddress, short vlan
  Output:         无
  Return:         success 0, error -1;
  Others:         if group is online and vlan have to change, kick the group offline and change it vlan edit by aibin 20080320
*************************************************/
int AddGroupVlan (UINT groupaddress, short vlan)
{
	GroupAuth *ptmp, *ptmp2;
	short prevlan;
	int exist;

	if (vlan > 4085 || vlan < 1 || vlan == global_vlan)
	{
		printf ("\r\nInvalid VLAN tag or this is default vlan!\r\n");
		return ERROR;
	}
	/*exist = GroupVlanExist (vlan); */

	/*当前组如果存在，就不能进行设置 */
	ptmp = (GroupAuth *) GetAuthGroup (groupaddress);
	if (NULL == ptmp)
	{
		printf ("\r\nAdd this group to profile first!\r\n");
		return ERROR;
	}

	/*if (ptmp->active)
	   {
	   printf ("\r\nSuch group is ative, can't be setted now!\r\n");
	   return ERROR;
	   } */

	if (exist && vlan == ptmp->vlanid)
	{
		printf ("\r\nSuch VLAN is already exist!\r\n");
		return ERROR;
	}

	/*in uncross vlan mode, it must exist an unicast vlan */
	if (gEnableCrossVlan == FALSE)
	{
		if (!is_vlan_exist (vlan))
		{
			printf ("\r\nCreate an unicast vlan fisrt!\r\n");
			return ERROR;
		}
		ptmp->vlanid = vlan;
		return OK;
	}

	/*in crossvlan mode */
	else
	{
		/*this vlan exist in another group */
		if (exist && vlan != ptmp->vlanid)
		{
			prevlan = ptmp->vlanid;
			ptmp->vlanid = vlan;
			/*之前的VLAN不存在了，删除 */
			if (prevlan && !GroupVlanExist (prevlan))
			{
				if (delete_igmp_vlan (prevlan) < 0)
				{
					printf ("\r\nVLAN %d can't be removed!\r\n", prevlan);
					return ERROR;
				}
			}
			return OK;
		}

		/*确保VLAN不在单播VLAN中 */
		if (is_vlan_exist (vlan))
		{
			printf ("\r\nSuch VLAN is already used for unicast!\r\n");
			return ERROR;
		}

		prevlan = ptmp->vlanid;
		ptmp->vlanid = 0;
		/*之前的VLAN不存在了，删除 */
		if (prevlan && !GroupVlanExist (prevlan))
		{
			if (delete_igmp_vlan (prevlan) < 0)
			{
				printf ("\r\nVLAN %d can't be removed!\r\n", prevlan);
				return ERROR;
			}
		}

		/*新的VLAN还未建立，则创建新VLAN */
		if (!GroupVlanExist (vlan))
		{
			if (create_igmp_vlan (vlan) < 0)
			{
				printf ("\r\nCreat VLAN %d failed!\r\n", vlan);
				return ERROR;
			}
		}
		ptmp->vlanid = vlan;
		return OK;
	}
}

/*in crossvlan mode when crossvlan = 1, else crossvlan = 0*/
int DelGroupVlan (UINT groupaddress)
{
	GroupAuth *ptmp, *ptmp2;
	short vlan, prevlan;

	ptmp = (GroupAuth *) GetAuthGroup (groupaddress);
	if (NULL == ptmp)
	{
		printf ("\r\nNot a valid group!\r\n");
		return ERROR;
	}
	prevlan = ptmp->vlanid;
	ptmp->vlanid = 0;

	/*when in uncross vlan mode. just return now */
	if (!gEnableCrossVlan)
	{
		return OK;
	}

	/*when in cross vlan mode, if this igmp vlan no group use,delete the group vlan in vlan table */
	else
	{
		if (prevlan && !GroupVlanExist (prevlan))
		{
			if (delete_igmp_vlan (prevlan) < 0)
			{
				printf ("\r\nVLAN %d can't be removed!\r\n", prevlan);
				return ERROR;
			}
		}

		return OK;
	}
}

/*************************************************
  Function:       GetGroupVlan
  Description:   get group specific vlan
  Input:         	groupaddress
  Output:         无
  Return:         groupvlan
  Others:         if group not set a vlan , return global_vlan;
*************************************************/
int GetGroupVlan (UINT groupaddress)
{
	GroupAuth *ptmp;

	ptmp = (GroupAuth *) GetAuthGroup (groupaddress);
	if (NULL == ptmp)
	{
		return global_vlan;
	}
	if (!ptmp->vlanid)
	{
		return global_vlan;
	}
	return ptmp->vlanid;
}

/*************************************************
  Function:       GetGroupUplinkVlan
  Description:   get group uplink protocol signal  vlan
  Input:         	groupaddress
  Output:         无
  Return:         groupvlan
  Others:         if group not set a vlan , return global_vlan;
*************************************************/
int GetGroupUplinkVlan (UINT groupaddress)
{
	GroupAuth *ptmp;

	ptmp = (GroupAuth *) GetAuthGroup (groupaddress);
	if (NULL == ptmp)
	{
		return global_vlan;
	}
	if (!ptmp->uplink_vlan)
	{
		if (!ptmp->vlanid)
			return global_vlan;
		else
			return ptmp->vlanid;
	}
	return ptmp->uplink_vlan;
}

/*返回1表示存在，0表示不存在了*/

/*************************************************
  Function:       GroupVlanExist
  Description:   check such group vlan whether exist?
  Input:         	vlanid
  Output:         无
  Return:         1 exits, 0 not exist
  Others:        
*************************************************/
int GroupVlanExist (USHORT vlanid)
{
	GroupAuth *ptmp;
	int exist;

	if (!gEnableCrossVlan)
		return 0;

	exist = 0;
	if (vlanid == global_vlan)
	{
		return 1;
	}

	ptmp = authlist;
	while (ptmp)
	{
		if (ptmp->vlanid == vlanid)
		{
			exist = 1;
			return exist;
		}
		ptmp = ptmp->pNext;
	}
	return 0;
}

/*设置组播源带宽*/

/*************************************************
  Function:       AddGroupBd
  Description:   
  Input:           UINT groupaddress, short bandwidth
  Output:         无
  Return:         
  Others:         
*************************************************/
int AddGroupBd (UINT groupaddress, short bandwidth)
{
	GroupAuth *ptemp;
	GroupInfo *curr;
	int semauth;
	int i;

/*	if (infolist)
	return ERROR; why can't set online group aibin 20080321*/

	ptemp = (GroupAuth *) GetAuthGroup (groupaddress);
	curr = (GroupInfo *) GetCurGroup (groupaddress);
	if (NULL == ptemp)
	{
		printf ("\r\n Add this group to profile first!\r\n");
		return ERROR;
	}
	else
	{
		if (curr)
		{
			semauth = semTake (semConauth, 1);
			if (ERROR == semauth)
			{
				printf ("Take semConauth error!\r\n");
				semtakeerror++;
				return ERROR;
			}

			CurrentUpBandwidth =
				CurrentUpBandwidth - ptemp->bandwidth + bandwidth;
			semGive (semConauth);
		}
		ptemp->bandwidth = bandwidth;
		return OK;
	}
}

int DelGroupBd (UINT groupaddress)
{
	GroupAuth *ptemp;
	int semauth;
	int i;

	ptemp = (GroupAuth *) GetAuthGroup (groupaddress);
	if (NULL == ptemp)
	{
		if (NULL == ptemp)
			return ERROR;
	}
	else
	{
		if (ptemp->active)
		{
			semauth = semTake (semConauth, 1);
			if (ERROR == semauth)
			{
				printf ("Take semConauth error!\r\n");
				semtakeerror++;
				return ERROR;
			}
			if (CurrentUpBandwidth > ptemp->bandwidth)
				CurrentUpBandwidth -= ptemp->bandwidth;
			else
				CurrentUpBandwidth = 0;
			semGive (semConauth);
		}
		ptemp->bandwidth = 0;
		return OK;
	}
}

/*************************************************
  Function:       CheckUpBandwidth
  Description:   判断上行带宽是否到达上限，超过上限返回-1, 否则返回0;
			先要判断是否是一个新加入的组
  Input:         	groupaddress
  Output:         无
  Return:         pass check 0, check failed -1;
  Others:        
*************************************************/
int CheckUpBandwidth (UINT groupaddress)
{
	GroupInfo *ptmp;
	GroupAuth *authgroup;
	int bandwidth;
	int semauth;

	semauth = semTake (semConauth, 1);
	if (ERROR == semauth)
	{
		printf ("Take semConauth error!\r\n");
		semtakeerror++;
		return ERROR;
	}
	if (!MaxUpBandwidth)
	{
		semGive (semConauth);
		return 0;
	}

	authgroup = (GroupAuth *) GetAuthGroup (groupaddress);
	if (!authgroup)
	{
		semGive (semConauth);
		return 0;
	}
	if (authgroup->active)
	{
		semGive (semConauth);
		return 0;
	}

	bandwidth = authgroup->bandwidth;

	if (!MaxUpBandwidth || (CurrentUpBandwidth + bandwidth) <= MaxUpBandwidth)
	{
		semGive (semConauth);
		return OK;
	}
	else
	{
		semGive (semConauth);
		return ERROR;
	}
}

void SetMaxUpBandwidth (short max)
{
	MaxUpBandwidth = max;
}

void isname (char *str)
{
	char *p;
	int count;

	p = str;
	count = 20;
	while (*p != 0 && count)
	{
		if (*p == 58)			/* p = ':', 说明<portlist>里面是一串端口号，而不是一个VLAN的名字 */
		{
			printf (" input a portlist\r\n");
			return;
		}
		p++;
		count--;
	}
	printf (" input a vlanname\r\n");
}

int GetPortState (UCHAR slot, UCHAR onu, UCHAR onuPort, UINT groupaddress)
{
	GroupAuth *ptmp;

	if (!portstatlist[slot][onu][onuPort].control)
		return MEMBER_NORMAL;

	ptmp = (GroupAuth *) GetAuthGroup (groupaddress);
	if (NULL == ptmp || !portstatlist[slot][onu][onuPort].tmpno)
		return MEMBER_NONE;
	else
		return ptmp->profile[portstatlist[slot][onu][onuPort].tmpno];
}

GroupAuth *GetAuthGroup (UINT groupaddress)
{
	GroupAuth *ptmp;

	ptmp = authlist;
	while (ptmp)
	{
		if (ptmp->groupaddress == groupaddress)
			return ptmp;
		ptmp = ptmp->pNext;
	}
	return NULL;
}

GroupInfo *GetCurGroup (UINT groupaddress)
{
	GroupInfo *ptmp;

	ptmp = infolist;
	while (ptmp)
	{
		if (ptmp->groupaddress == groupaddress)
			return ptmp;
		ptmp = ptmp->pNext;
	}