igmpcon_main.c

igmp for switch in vxworks

	char *p;
	int i;
	int slotnew;
	PortRecord *ptmp;
	char *temp;
	char st[5000];
	int j = 0;
	struct in_addr gip;
	char ip[20];
	int semlog;

	temp = (char *) malloc (80000);
	if (NULL == temp)
	{
		printf ("Error!,malloc upload record buff failed!\r\n");
		return 0;
	}
	memset (temp, 0, 80000);
	semlog = semTake (semConLog, 1);
	if (ERROR == semlog)
	{
		printf ("Take semConLog error!\r\n");
		semtakeerror++;
		free (temp);
		return 0;
	}
	if (!recordcount)
	{
		semGive (semConLog);
		free (temp);
		return 0;
	}
	count = recordcount;
	ptmp = recordlist;
	p = temp;
	len = 0;
	while (count)
	{
		memset (st, 0, sizeof (st));
		gip.s_addr = ptmp->groupaddress;
		j++;
		slotnew = ptmp->slot;
		inet_ntoa_b (gip, ip);
		if (slotnew > 8)
		{
			slotnew = slotnew + 2;
		}
		/*加入 */
		if (ptmp->cmd == 1)
		{
			if (ptmp->preview == 2)
			{
				if (ptmp->state == success)
				{
					sprintf (st,
						"%d.%s, port(%2d:%2d:%1d)(p) joins  group(%s) successfully.\n",
						j, ptmp->time, slotnew, ptmp->onu, ptmp->onuPort, ip);
				}
				else if (ptmp->state == failpreview)
				{
					sprintf (st,
						"%d.%s, port(%2d:%2d:%1d)(p) fails to join  group(%s): not has preview right this moment.\n",
						j, ptmp->time, slotnew, ptmp->onu, ptmp->onuPort, ip);
				}
				else if (ptmp->state == failmaxgroup)
				{
					sprintf (st,
						"%d.%s, port(%2d:%2d:%1d)(p) fails to join  group(%s): reachs the groups limit.\n",
						j, ptmp->time, slotnew, ptmp->onu, ptmp->onuPort, ip);
				}
				else if (ptmp->state == failvlan)
				{
					sprintf (st,
						"%d.%s, port(%2d:%2d:%1d)(p) fails to join  group(%s): vlan mismatched.\n",
						j, ptmp->time, slotnew, ptmp->onu, ptmp->onuPort, ip);
				}
				else if (ptmp->state == failupbd)
				{
					sprintf (st,
						"%d.%s, port(%2d:%2d:%1d)(p) fails to join  group(%s): reachs the bandwidth limit.\n",
						j, ptmp->time, slotnew, ptmp->onu, ptmp->onuPort, ip);
				}
				else
				{
					sprintf (st,
						"%d.%s, port(%2d:%2d:%1d)(p) fails to join  group(%s).\n",
						j, ptmp->time, slotnew, ptmp->onu, ptmp->onuPort, ip);
				}

			}
			else
			{
				if (ptmp->state == success)
				{
					sprintf (st,
						"%d.%s, port(%2d:%2d:%1d) joins  group(%s) successfully.\n",
						j, ptmp->time, slotnew, ptmp->onu, ptmp->onuPort, ip);
				}
				else if (ptmp->state == failauth)
				{
					sprintf (st,
						"%d.%s, port(%2d:%2d:%1d) fails to join  group(%s): not passed  authentication.\n",
						j, ptmp->time, slotnew, ptmp->onu, ptmp->onuPort, ip);
				}
				else if (ptmp->state == failmaxgroup)
				{
					sprintf (st,
						"%d.%s, port(%2d:%2d:%1d) fails to join  group(%s): reachs the groups limit.\n",
						j, ptmp->time, slotnew, ptmp->onu, ptmp->onuPort, ip);
				}
				else if (ptmp->state == failvlan)
				{
					sprintf (st,
						"%d.%s, port(%2d:%2d:%1d) fails to join  group(%s): vlan mismatched.\n",
						j, ptmp->time, slotnew, ptmp->onu, ptmp->onuPort, ip);
				}
				else if (ptmp->state == failupbd)
				{
					sprintf (st,
						"%d.%s, port(%2d:%2d:%1d) fails to join  group(%s): reachs the bandwidth limit.\n",
						j, ptmp->time, slotnew, ptmp->onu, ptmp->onuPort, ip);
				}
				else
				{
					sprintf (st,
						"%d.%s, port(%2d:%2d:%1d) fails to join  group(%s).\n",
						j, ptmp->time, slotnew, ptmp->onu, ptmp->onuPort, ip);
				}
			}
		}

		/*离开 */
		if (ptmp->cmd == 0)
		{
			if (ptmp->preview == 2)
			{
				if (ptmp->state == leavenormal)
				{
					sprintf (st,
						"%d.%s, port(%2d:%2d:%1d)(p) leaves group(%s).\n", j, j,
						ptmp->time, slotnew, ptmp->onu, ptmp->onuPort, ip);
				}
				else
				{
					sprintf (st,
						"%d.%s, port(%2d:%2d:%1d)(p) forced to leave group(%s).\n",
						j, ptmp->time, slotnew, ptmp->onu, ptmp->onuPort, ip);
				}
			}
			else
			{
				if (ptmp->state == leavenormal)
				{
					sprintf (st, "%d.%s, port(%2d:%2d:%1d) leaves group(%s).\n",
						j, ptmp->time, slotnew, ptmp->onu, ptmp->onuPort, ip);
				}
				else
				{
					sprintf (st,
						"%d.%s, port(%2d:%2d:%1d) forced to leave group(%s).\n",
						j, ptmp->time, slotnew, ptmp->onu, ptmp->onuPort, ip);
				}
			}
		}
		if (ptmp->cmd == 2)
		{
			if (ptmp->preview == 2)
			{
				sprintf (st,
					"%d.%s, port(%2d:%2d:%1d)(p) staying in group(%s) %d minutes.\n",
					j, ptmp->time, slotnew, ptmp->onu, ptmp->onuPort, ip,
					ptmp->staying);
			}
			else
			{
				sprintf (st,
					"%d.%s, port(%2d:%2d:%1d) staying in group(%s) %d minutes.\n",
					j, ptmp->time, slotnew, ptmp->onu, ptmp->onuPort, ip,
					ptmp->staying);
			}
		}

		i = strlen (st);
		strncpy (p, st, i);
		p = p + i;
		len = len + i;
		count--;
		ptmp = ptmp->pNext;
		if (len >= 80000 - 100)
		{
			semGive (semConLog);
			free (temp);
			return len;
		}
	}
	semGive (semConLog);
	memcpy (buf, temp, 80000);
	free (temp);
	return len;
}

void tplogbuf (void)
{
	char buf[5000];
	int len;

	memset (buf, 0, sizeof (buf));
	len = UpRecordBuf (buf);
	printf ("buf length = %d\n", len);
	printf ("%s\n", buf);
}

/*************************************************
  Function:       DelRecord
  Description:   delete a log node by generate time
  Input:         	 time
  Output:         无
  Return:          n/a
  Others:         // 其它说明
*************************************************/
void DelRecord (UINT time)
{
	PortRecord *ptmp, *ptmp2;
	int count;
	int semlog;

	semlog = semTake (semConLog, 1);
	if (ERROR == semlog)
	{
		printf ("Take semConLog error!\r\n");
		semtakeerror++;
		return;
	}
	count = recordcount;
	ptmp = recordlist;
	if (NULL == recordlist)
	{
		semGive (semConLog);
		return;
	}

	if (time == ptmp->ctime)
	{
		if (recordcount == 1)
		{
			recordcount--;
			free (ptmp);
			recordlist = NULL;
			semGive (semConLog);
			return;
		}
		if (recordcount == 2)
		{
			recordcount--;
			recordlist = recordlist->pNext;
			free (ptmp);
			recordlist->pNext = NULL;
			recordlist->pPrv = NULL;
			semGive (semConLog);
			return;
		}
		if (recordcount >= 3)
		{
			recordcount--;
			ptmp->pPrv->pNext = ptmp->pNext;
			ptmp->pNext->pPrv = ptmp->pPrv;
			recordlist = recordlist->pNext;
			free (ptmp);
			semGive (semConLog);
			return;
		}
	}

	while (count && ptmp->pNext)
	{
		if (time == ptmp->ctime)
		{
			if (recordcount == 2)
			{
				ptmp->pPrv->pNext = NULL;
				recordcount--;
				free (ptmp);
			}
			else
			{
				recordcount--;
				ptmp->pPrv->pNext = ptmp->pNext;
				ptmp->pNext->pPrv = ptmp->pPrv;
				free (ptmp);
			}
			semGive (semConLog);
			return;
		}
		count--;
		ptmp = ptmp->pNext;
	}
	semGive (semConLog);
}

/*************************************************
  Function:       DelRecord
  Description:   日志定时器处理函数，每隔一定时间检查用户是否在线
  		        定时器也处理老化计时，超过老化时间的删除
  Input:         	 time
  Output:         无
  Return:          n/a
  Others:         // 其它说明
*************************************************/
void ProcessRecordTimerout (void)
{
	GroupInfo *ptmp;
	ConMsg msg;
	groupMember *pMember, *pMember1;
	int i, j;
	int prestate;
	int sem;

	if (typedebug)
		printf ("\r\ntimerout\r\n");

	StartRecordTimer ();
	sem = semTake (semConinfo, 1);
	if (ERROR == sem)
	{
		semtakeerror++;
		return;
	}

	ptmp = infolist;
	if (NULL == ptmp)
	{
		semGive (semConinfo);
		return;
	}
	pMember1 = ptmp->member;

	while (typedebug && pMember1)
	{
		printf ("---%x<-%x->%x(%d:%d)", pMember1->pPrv, pMember1,
			pMember1->pNext, pMember1->slot, pMember1->onu);
		pMember1 = pMember1->pNext;
	}

	while (ptmp)
	{
		pMember = ptmp->member;
		while (pMember)
		{
			pMember->old += 2;
			pMember->onlinetime += 2;

			/*超过老化时间 */
			if (pMember->old >= gConOld)
			{
				sendInfoMsgbyCmd (pMember->slot, pMember->onu, pMember->onuPort,
					0, leavenormal, pMember->state, ptmp->groupaddress);
				SendForceLeaveMsg (pMember->slot, pMember->onu,
					pMember->onuPort, 0, ptmp->groupaddress);
				/*msg.cmd = 0;
				   msg.group = ptmp->groupaddress;
				   msg.onu = pMember->onu;
				   msg.slot = pMember->slot;
				   msg.onuPort = pMember->onuPort;
				   msg.state = leavenormal;
				   msg.preview = MEMBER_NORMAL;
				   msg.type = infomsg;
				   processLeaveMsg(msg); */

				/*SendCfgPkt(forceleavemsg, pMember->slot, pMember->onu, pMember->onuPort, 0); */
			}

			/*到达在线时间 */
			if (pMember->onlinetime >= RecordHolding * 60)
			{
				msg.cmd = 2;
				msg.group = ptmp->groupaddress;
				msg.onu = pMember->onu;
				msg.onuPort = pMember->onuPort;
				msg.preview = pMember->state;
				msg.slot = pMember->slot;
				msg.state = 0;
				msg.type = infomsg;
				AddRecord (msg);
				pMember->onlinetime = 0;
			}
			pMember = pMember->pNext;
		}
		ptmp = ptmp->pNext;
	}

	sem = semGive (semConinfo);
	if (ERROR == sem)
	{
		printf ("\r\ngive error ProcessRecordTimerout\r\n");
	}
}

/*************************************************
  Function:       StartRecordTimer
  Description:   start igmp record timer
  Input:         	 none
  Output:         无
  Return:          n/a
  Others:         // 其它说明
*************************************************/
void StartRecordTimer (void)
{
	tConRecordTmer =
		(int) nos_timerout (2000, (long) ProcessRecordTimerout, NULL);
}

/*************************************************
  Function:       AddStatistic
  Description:   calculate igmp statistics by port and group
  Input:         	 msg
  Output:         无
  Return:          n/a
  Others:         // 其它说明
*************************************************/
int AddStatistic (ConMsg msg)
{
	UINT cur_time;
	UINT dur_time;
	UINT jointime, leavetime;
	PortRecord *pRecord, *pJoin;
	GroupStat *ptmp;
	int find = 0;
	int count;
	int timetmp;
	int failed = 0;
	int pre = 0;
	int semlog, semstat;

	/*先在 日志表中找到之前的加入消息得到用户观看时间 */
	count = recordcount;
	cur_time = tickGet ();

	semlog = semTake (semConLog, 1);
	if (ERROR == semlog)
	{
		printf ("Take semConLog error!\r\n");
		semtakeerror++;
		return ERROR;
	}
	pRecord = recordlist;
	leavetime = recordlist->ctime;
	while (count)
	{
		/*如果发现之前的离开报文，返回 */
		if (pRecord->groupaddress == msg.group && pRecord->onu == msg.onu &&
			pRecord->onuPort == msg.onuPort && pRecord->slot == msg.slot &&
			pRecord->cmd == 0 && pRecord->ctime != leavetime)
		{
			semGive (semConLog);
			return ERROR;
		}

		if (pRecord->onu == msg.onu && pRecord->onuPort == msg.onuPort &&
			pRecord->slot == msg.slot && pRecord->cmd == 1 &&
			pRecord->state == success && pRecord->groupaddress == msg.group)
		{
			find = 1;
			jointime = pRecord->ctime;
			dur_time = cur_time - pRecord->ctime;
			dur_time = dur_time / 100;
			pre = pRecord->preview;
			/*printf("pre = %d, %x\r\n", pre, pRecord->groupaddress); */
			break;
		}
		pRecord = pRecord->pNext;
		count--;
	}
	semGive (semConLog);

	if (find == 0)
	{
		return ERROR;
	}

	/*用户观看时间少于5秒则表明观看失败,不予统计 */
	if (dur_time <= RecordIgnore)
	{
		DelRecord (leavetime);
		DelRecord (jointime);
		/*AddStatFail (groupaddress, slot, port); */
		return OK;
	}

	portstatlist[msg.slot][msg.onu][msg.onuPort].totalcount++;
	timetmp = portstatlist[msg.slot][msg.onu][msg.onuPort].totaltime;
	portstatlist[msg.slot][msg.onu][msg.onuPort].totaltime = timetmp + dur_time;
	timetmp = portstatlist[msg.slot][msg.onu][msg.onuPort].maxtime;

	if (dur_time > timetmp)
	{
		portstatlist[msg.slot][msg.onu][msg.onuPort].maxtime = dur_time;
	}

	/*增加到组统计表中 */
	semstat = semTake (semConStat, 1);
	if (ERROR == semstat)
	{
		printf ("Take semstat error!\r\n");
		semtakeerror++;
		return ERROR;
	}
	ptmp = groupstatlist;
	count = groupstatcount;
	while (count)
	{
		if (ptmp->groupaddress == msg.group)
		{
			if (msg.preview == 2)
			{
				ptmp->previewcount++;
				ptmp->previewtime += dur_time;
			}
			ptmp->totalcount++;
			ptmp->totaltime = ptmp->totaltime + dur_time;

			if (ptmp->maxtime < dur_time)
			{
				ptmp->maxtime = dur_time;
			}
			semGive (semConStat);
			return OK;
		}
		ptmp = ptmp->pNext;
		count--;
	}

	/*已经到达记录项目的最大值，删除最老的一条记录 */
	if (groupstatcount == MaxGroupStat)
	{
		groupstatlist->pPrv->groupaddress = msg.group;
		groupstatlist->pPrv->totalcount = 1;
		groupstatlist->pPrv->totaltime = dur_time;
		groupstatlist->pPrv->maxtime = dur_time;
		groupstatlist->pPrv->failcount = 0;
		if (msg.preview == 2)
		{
			groupstatlist->pPrv->previewcount = 1;
			groupstatlist->pPrv->previewtime = dur_time;
		}
		else
		{
			groupstatlist->pPrv->previewcount = 0;
			groupstatlist->pPrv->previewtime = 0;
		}
		groupstatlist = groupstatlist->pPrv;
		semGive (semConStat);
		return OK;
	}

	/*需要增加新的统计项 */
	ptmp = (GroupStat *) malloc (sizeof (GroupStat));
	if (NULL == ptmp)
	{
		if (bConDebug)
		{
			printf ("\r\ncan't add a new groupstat record\r\n");
		}
		semGive (semConStat);
		return ERROR;
	}
	memset (ptmp, 0, sizeof (GroupStat));
	ptmp->groupaddress = msg.group;
	ptmp->failcount = 0;
	ptmp->maxtime = dur_time;
	ptmp->totalcount = 1;
	ptmp->totaltime = dur_time;
	if (msg.preview == 2)
	{
		ptmp->previewcount = 1;
		ptmp->previewtime = dur_time;
	}
	groupstatcount++;
	/*第一条 */
	if (groupstatcount == 1)
	{
		ptmp->pNext = NULL;
		ptmp->pPrv = NULL;
		groupstatlist = ptmp;
	}

	/*第二条 */
	if (groupstatcount == 2)