igmpcon_snmp.c

igmp for switch in vxworks

	return 0;
}

int auto_upload_igmplog_get (char *buf, short *len)
{
	char *p;

	p = buf;
	*(unsigned int *)p = SNMP_SUCCESS;
	p += 4;

	*p = auto_upload_igmplog_flag;
	p++;
	*(short *)p = auto_upload_period;
	p += 2;
	*(unsigned int *)p = inet_addr ((char *)auto_upload_igmplog_ftpip);
	p += 4;
	strcpy (p, auto_upload_igmplog_ftpuser);
	p += 20;
	strcpy (p, auto_upload_igmplog_ftppass);
	p += 20;

	*len = p-buf;
	if (type_snmp)
	typePkt (buf, *len);	
	
	return 0;
}

int snmp_upload_igmplog (char *buf, int len, STRUCT_ERROR_INFO *err)
{
	int ip, ret;
	char host[21], user[21], pass[21], name[21];
	short interval;
	struct vty *vty = NULL;
	struct in_addr gip; 

	if (type_snmp)
	typePkt (buf, len);	

	set_error_code(err, SNMP_SUCCESS, 0,0);

	gip.s_addr = *(unsigned int *)(buf);
	inet_ntoa_b (gip, host);
	strncpy (user, buf+4, 20);
	strncpy (pass, buf+24, 20);
	strncpy (name, buf+44, 20);

	ret = gtuploadbyftp(0, host, user, pass, name, 11/*UPLOAD_IGMP_LOG*/);
	if (ret != 0)
	set_error_code(err, SNMP_ERROR, 0,0);

	return 0;
}

int snmp_igmp_proxy_group_get (char *buf, unsigned short *len)
{
	GroupEntity *ptmp;
	int groupcount, slotcount;
	char *p;
	char *pgcount;
	char *pslotcount;
	int slot = 0;

	semTake (semIgmpDelete, 100);
	ptmp = pGroupEntityList;

	p = buf;
	*(unsigned int *)p = SNMP_SUCCESS;
	p += 4;

	p += 32;        /*reserve*/

	pgcount = p;
	p += 4;
	groupcount = 0;
	while (ptmp)
	{
		groupcount++;
		slotcount = 0;
		*(unsigned int *)p = ptmp->unGroupAddress;
		p += 4;

		pslotcount = p;
		p += 4;          /*slot count*/
		
		for (slot = 1; slot <= MAX_UPLINK_PORT; slot++)
		{
			if (ptmp->eGroupPortStatus[slot] != NoMembersPresent)
			{
				slotcount++;
				*p = slot;
				p++;
			}
		}
		p += 32;
		
		*(int *)pslotcount = slotcount;

		ptmp = ptmp->pNext;
	}
	*(int *)pgcount = groupcount;

	*len = p-buf;
	semGive (semIgmpDelete);

	if (type_snmp)
	typePkt (buf, *len);	

	return 0;
}


int snmp_igmp_parameters_set (char *buf, unsigned short len, STRUCT_ERROR_INFO *err)
{
	char *p = buf;
	int i;
	
	set_error_code(err, SNMP_SUCCESS, 0,0);

	p += 32; /*reserve*/
	ucRobustness = *p;
	p++;
	usQueryResponseInterval = *p;
	p++;
	usLastMemberQueryInterval = *p;
	p++;
	ucLastMemberQueryCount = *p;
	p++;
	usQueryInterval =*p;
	p++;
	usGroupMembershipInterval = *(short *)p;
	p += 2;
	p += 32; /*reserve*/

	for(i = 1; i <= MAX_DOWN_SLOT; i++)
	SendCfgPkt(igmpparametersmsg, i, 1,1,0);

	if (type_snmp)
	typePkt (buf, len);	

	return 0;
}

int snmp_igmp_parameters_get (char *buf, unsigned short *len)
{
	char *p = buf;
	
	p = buf;
	*(unsigned int *)p = SNMP_SUCCESS;
	p += 4;

	p += 32;     /*reserve*/

	*p = ucRobustness;
	p++;
	*p = usQueryResponseInterval;
	p++;
	*p = usLastMemberQueryInterval ;
	p++;
	*p = ucLastMemberQueryCount;
	p++;
	*p = usQueryInterval;
	p++;
	*(short *)p = usGroupMembershipInterval;
	p += 2;
	p += 32;
	
	*len = p-buf;

	if (type_snmp)
	typePkt (buf, *len); 
	return 0;
}

/*配置onu离开模式，0正常离开，1快速离开*/
int igmp_onu_fast_leave (char *buf, int len, STRUCT_ERROR_INFO *err)
{
	int count;
	char *p, *start;
	char tmpno, slot, onu, onuPort;
	char err_value[50];

	if (type_snmp)
	typePkt(buf,len);
	
	p = buf;
	p += 32;
	count = *(short *)p;
	p += 2;

	if (count >= MaxOnu*MAX_DOWN_SLOT)
	{
		set_error_code(err, SNMP_ERROR, 0x002effff,  err_value);
		return -1;
	}
	
	while (count)
	{
		start = p;
		slot = *(short *)p;
		slot = translateslot_in(slot);
		p += 2;
		onu = *(short *)p;
		p += 2;
		if (!is_valid_igmp_port(slot, onu, 1))
		{
			memset (err_value, 0, sizeof (err_value));
			err_value[0] = translateslot_out(slot);
			err_value[1] = onu;
			err_value[2] = 1;
			set_error_code(err, SNMP_ERROR, 0x002efffd,  err_value);
			printf ("invalid onu : %d %d\r\n", slot, onu);
			p = start+37;
			count--;
			continue;
		}
		
		portstatlist[slot][onu][1].fast_leave_state = *p;
		p++;

		p += 32;         /*reserve*/
		
		SendCfgPkt (portcfgmsg, slot, onu, 1, 0);

		if (!is_port_default_config( slot, onu, onuPort))
		onulist[slot][onu].used = 1;
		count--;
	}
	return OK;
}


int get_onu_fast_leave_buf (char *buf, unsigned short *len)
{
	char *p = buf;
	short count = 0;
	char *p_count = NULL;
	int i, j;
	
	p = buf;
	*(unsigned int *)p = SNMP_SUCCESS;
	p += 4;
	p += 32;	 /*reserve*/
	p_count = p;
	
	PASS_ONU(i, j)
	{
		if (onulist[i][j].used)
		{
			if (portstatlist[i][j][1].fast_leave_state != 1)		/*正常离开才获取 */
			{
				*(short *)p = i;
				p += 2;
				*(short *)p = j;
				p += 2;
				
				*p = 0;
				p++;
				p += 32;
				count++;	
			}
		}
	}
	END_PASS_ONU

	p += 32;
	*(short *)p_count = count;
	*len = p - buf;

	if (type_snmp)
	typePkt(buf, *len);
}



#if 0
#endif

void test_snmp_get (int (*func)(char *, short * ))
{
	char buf[1000] = {0};
	short len = 0;

	func (buf, &len);
	typePkt (buf, len);	
}

void test_snmp_igmp_parameters_set (void)
{
	char buf[100] = {0};
	char err[100] = {0};
	short len;
	char *p = buf;

	p += 32;
	*p = 1;
	p++;
	*p = 2;
	p++;
	*p = 3;
	p++;
	*p = 4;
	p++;
	*p = 5;
	p++;
	*(short *)p = 300;
	p += 2;
	p += 32;

	len = p-buf;
	typePkt (buf, len);	

	snmp_igmp_parameters_set (buf, len, err);
}

void test_igmp_onu_fast_leave(void)
{
	char buf[500] = {0};
	char err[500] = {0};
	short len;
	char *p = buf;

	p += 32;
	*(short *)p = 3;
	p += 2;

	*(short *)p = 3;
	p += 2;
	*(short *)p = 1;
	p += 2;
	*p = 0;
	p++;
	p += 32;

	*(short *)p = 3;
	p += 2;
	*(short *)p = 2;
	p += 2;
	*p = 0;
	p++;
	p += 32;

	*(short *)p = 3;
	p += 2;
	*(short *)p = 3;
	p += 2;
	*p = 0;
	p++;	
	p += 32;

	p += 32;
	len = p-buf;
	typePkt (buf, len);	

	igmp_onu_fast_leave (buf, len, err);
}

void test_get_proxy_group(void)
{
	char buf[2000];
	short len;

	memset (buf, 0, sizeof (buf ));
	
	snmp_igmp_proxy_group_get(buf, &len);
	typePkt (buf, len);	
}

void showigmponu(char slot, char onu)
{
	printf ("onu : %d:%d\r\n", slot, onu);
	printf ("used: %d\r\n", onulist[slot][onu].used);
	printf ("type: %d, ftth(%d)\r\n", onulist[slot][onu].type, onulist[slot][onu].flag_ftth);
	printf ("igmp port :%d\r\n", onulist[slot][onu].igmp_port);
	printf ("total port: %d\r\n", onulist[slot][onu].total_port);
}
int port_set_config_all (char *buf, int len, STRUCT_ERROR_INFO *err)
{
	int count;
	char *p, *start;
	char tmpno, slot, onu, onuPort;
	char err_value[50];

	if (type_snmp)
	typePkt(buf,len);
	
	p = buf;
	count = *(short *)p;
	p += 2;
	
	while (count)
	{
		start = p;
		slot = *p;
		slot = translateslot_in(slot);
		p++;
		onu = *p;
		p++;
		onuPort = *p;
		if (!is_valid_igmp_port(slot, onu, onuPort))
		{
			memset (err_value, 0, sizeof (err_value));
			err_value[0] = translateslot_out(slot);
			err_value[1] = onu;
			err_value[2] = onuPort;
			set_error_code(err, SNMP_ERROR, 0x002efffd,  err_value);
			printf ("invalid onu port: %d %d %d\r\n", slot, onu, onuPort);
			p = start+32;
			count--;
			continue;
		}
		p++;
		
		portstatlist[slot][onu][onuPort].control = *p;
		p++;
		if (strcmp (p, "Detach") == 0)
		{
			tmpno = 0;
		}
		else
		{
			tmpno = GetProfliebyName (p);
			/*if port is already bind to a profile and new profile is invalid, add a error*/
			if (!tmpno && (portstatlist[slot][onu][onuPort].tmpno != 0))
			{
				memset (err_value, 0, sizeof (err_value));
				memcpy (err_value, p, 20);
				set_error_code(err, SNMP_ERROR, 0x002effff,  err_value);
				printf ("profile error: %s\r\n", err_value);
				count--;
				p = start+32;
				continue;
				
			}
		}
		portstatlist[slot][onu][onuPort].tmpno = tmpno;
		p += 20;
		portstatlist[slot][onu][onuPort].gouplimit = *(short *) p;
		p += 2;
		portstatlist[slot][onu][onuPort].bandwidth = *(int *) p;
		p += 4;
		portstatlist[slot][onu][onuPort].vlanpeer = *p;
		p += 1;
		portstatlist[slot][onu][onuPort].fast_leave_state = *p;
		p += 1;

		SendCfgPkt (portcfgmsg, slot, onu, onuPort, 0);

		SendCfgPkt (port2groupmsg, slot, onu, onuPort, 0);

		if (!is_port_default_config( slot, onu, onuPort))
		onulist[slot][onu].used = 1;
		
		count--;
	}
	return OK;
}
	
void clear_port_config (void)
{
	int i, j, k;
	
	memset (portstatlist, 0, sizeof (portstatlist));
	for (i = 1; i <= MAX_DOWN_SLOT; i++)
	{
		for (j = 1; j <= MaxOnu; j++)
		{
			for (k = 1; k <= MaxOnuPort; k++)
			{
				portstatlist[i][j][k].gouplimit = 32;
				portstatlist[i][j][k].fast_leave_state= 1;
			}
		}
	}
}

void test_port_value_set_new(void)
{
	char buf[1000];
	char *p;
	int len;
	int index = 1;
	STRUCT_ERROR_INFO *erro;

	memset (buf, 0, sizeof (buf));
	p = buf;
	*(short *)p = 3;
	
	p += 2;
	*p = 1;
	p++;
	*p = 1;
	p++;
	*p = 1;
	p++;
	p++;
	strcpy (p, "aaa");
	p += 22;
	*(int *)p = 2000;
	p += 5;
	*p = 1;
	p++;
	
	*p = 1;
	p++;
	*p = 1;
	p++;
	*p = 2;
	p++;
	p++;
	strcpy (p, "bbb");
	p += 22;
	*(int *)p = 32000;
	p += 5;
	*p = 1;
	p++;

	*p = 1;
	p++;
	*p = 1;
	p++;
	*p = 3;
	p++;
	p++;
	strcpy (p, "ccc");
	p += 22;
	*(int *)p = 4000;
	p += 5;
	p++;

	len = p-buf;

	typePkt(buf, len);

	while (len > SNMP_MAX_PACKET_LENGTH)
	{
		port_value_set_new (index, buf+(index-1)*SNMP_MAX_PACKET_LENGTH, SNMP_MAX_PACKET_LENGTH, erro);
		len -= SNMP_MAX_PACKET_LENGTH;
		index++;
	}
		
	port_value_set_new (index, buf+(index-1)*SNMP_MAX_PACKET_LENGTH, len, erro);	

	len = 6+58*erro->errnum;
	printf ("\r\nerr:");
	typePkt((char *)erro, len);
	printf ("\r\nerr2:");
	typePkt1(erro, len, 6,60);
}


int test_port_value_set (char slot, char onu, char onuPort)
{
	char buf[2000];
	char *p;

	memset (buf, 0, sizeof (buf));
	p = buf;
	*p = slot;
	p++;
	*p = onu;
	p++;
	*p = onuPort;
	p++;
	*p = 0;
	p++;

	p += 20;
	*(short *) p = 20;
	p += 2;
	*(int *) p = 200;
	p += 4;
	*p = 1;
	p++;

	if (bConDebug)
	{
		typePkt (buf, 32);
	}
	port_value_set (buf, 32);

}

int get_snmp_buf (short item, char *buf, short *len)
{
	char *p;
	
	if (!t_len)
	{
		*len = 0;
		return -1;
	}

	if (item > ((t_len/SNMP_MAX_PACKET_LENGTH)+1))
	{
		*len = 0;
		return 0;
	}

	if (t_len <= SNMP_MAX_PACKET_LENGTH)
	{
		memcpy (buf, tempbuf, t_len);
		*len = t_len;
		if (type_snmp)
		typePkt (tempbuf, *len);
		t_len = 0;
		memset (tempbuf, 0, sizeof (tempbuf));
		return 0;
	}
	else
	{
		if (NULL == totalbuf)
		{
			*len = 0;
			return -1;
		}
		if (item <= t_len/SNMP_MAX_PACKET_LENGTH)
		{
			memcpy (buf, totalbuf+(item-1)*SNMP_MAX_PACKET_LENGTH, SNMP_MAX_PACKET_LENGTH);
			*len = SNMP_MAX_PACKET_LENGTH;
			if (type_snmp)
			typePkt (tempbuf, *len);
			return 0;
		}
		else
		{
			memcpy (buf, totalbuf+(item-1)*SNMP_MAX_PACKET_LENGTH, t_len%SNMP_MAX_PACKET_LENGTH);
			*len = t_len%SNMP_MAX_PACKET_LENGTH;
			free (totalbuf);
			if (type_snmp)
			typePkt (tempbuf, *len);
			totalbuf = NULL;
			t_len = 0;
			return 0;
		}
	}
}

void pfsnmpbuf(void)
{
	printf ("t_len : %d\r\n", t_len);
	printf ("tempbuf:\r\n");
	typePkt(tempbuf, t_len);
	printf ("totalbuf:\r\n");
	typePkt(totalbuf, t_len);
}

void clearsnmpbuf(void)
{
	t_len = 0;
	memset (tempbuf, 0, sizeof (tempbuf));
	if (NULL != totalbuf)
	free(totalbuf);
	totalbuf = NULL;
}

void test_get_snmp_buf(void)
{
	int count;
	int i;
	short len = 0;
	char temp[SNMP_MAX_PACKET_LENGTH+1];

	count = t_len/SNMP_MAX_PACKET_LENGTH +1;
	for (i = 1; i <= count; ++i)
	{
		memset (temp, 0, sizeof (temp));
		get_snmp_buf(i, temp, &len);
		printf ("len = %d\r\n", len);
		typePkt(temp, len);
	}
}


int test_port_value_get (UCHAR slot, UCHAR onu, UCHAR onuPort)
{
	char buf[2000];
	char *p;
	short len;

	memset (buf, 0, sizeof (buf));
	p = buf;

	port_value_get (slot, onu, onuPort, buf, &len);
	typePkt (buf, len);
	return len;
}

void test_pack_onu_port_info (char slot, char onu, char onuPort)
{
	char buf[2000];
	char *p;
	short len;


}

int createProfilebyName (char *name)
{
	int i;

	i = 1;
	while (i <= MaxTemp)
	{
		if (!profile[i].used)
		{
			profile[i].used = 1;
			memcpy (profile[i].name, name, 20);
			return i;
		}
		i++;
	}
	return ERROR;
}

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

	ptmp = authgroup;
	if (!ptmp->vlanid)
	{
		return OK;
	}

	prevlan = ptmp->vlanid;
	ptmp->vlanid = 0;

	/*when in uncross vlan mode. just return now */