⭐ 欢迎来到虫虫下载站！ | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站
📤 上传资源

📄 funcs.c

📁 这是一个在在Dynamic C环境下实现的设备web服务器的建立
💻 C
📖 第 1 页 / 共 3 页
字号:
🔍
123 
/*** BeginHeader */
#ifndef _FUNCS_FUNC_
#define _FUNCS_FUNC_
/*** EndHeader */

/*** BeginHeader Longdelay */
 nodebug xmem void Longdelay(void);
/*** EndHeader */
 nodebug xmem void Longdelay()
{
	int i;
 	for(i=0;i<0x2000;i++)
   	;
}

/*** BeginHeader DefParaInit */
xmem void DefParaInit(unsigned char ucIndx,unsigned char unCtrl);
/*** EndHeader */
xmem void DefParaInit(unsigned char ucIndx,unsigned char unCtrl)
{
	int					i,j;

	UserIndx = ucIndx;

	if(unCtrl==0)
	{
		for(i=0;i<MAX_OEM_USER;++i)
		{
			g_AddrInfo[i].ucMacAddr[0]		= 0x00;
			g_AddrInfo[i].ucMacAddr[1]		= 0x09;
			g_AddrInfo[i].ucMacAddr[2]		= 0x45;
			g_AddrInfo[i].ucMacAddr[3]		= 0x80;
			g_AddrInfo[i].ucMacAddr[4]		= 0x00;
			g_AddrInfo[i].ucMacAddr[5]		= 0x00;
		}
	}

	g_AddrInfo[0].ulIpAddr			= DEF_LOCAL_IPADDR;
	g_AddrInfo[0].ulIpMask			= DEF_LOCAL_IPMASK;
	g_AddrInfo[0].ulGateway		    = DEF_GATEWAY_ADDR;

	g_AddrInfo[1].ulIpAddr			= RC_LOCAL_IPADDR;
	g_AddrInfo[1].ulIpMask			= RC_LOCAL_IPMASK;
	g_AddrInfo[1].ulGateway		    = RC_GATEWAY_ADDR;

	g_AddrInfo[2].ulIpAddr			= RC_LOCAL_IPADDR;
	g_AddrInfo[2].ulIpMask			= RC_LOCAL_IPMASK;
	g_AddrInfo[2].ulGateway		    = RC_GATEWAY_ADDR;

	g_AddrInfo[3].ulIpAddr			= OT_LOCAL_IPADDR;
	g_AddrInfo[3].ulIpMask			= OT_LOCAL_IPMASK;
	g_AddrInfo[3].ulGateway		    = OT_GATEWAY_ADDR;

	g_AddrInfo[0].uiFrmType			= DEF_HARD_TYPE;
	g_AddrInfo[1].uiFrmType			= RC_HARD_TYPE;
	g_AddrInfo[2].uiFrmType			= RC_HARD_TYPE;
	g_AddrInfo[3].uiFrmType			= OT_HARD_TYPE;

	g_AddrInfo[0].uiUDPPort			= DEF_SRC_UDP_PORT;
	g_AddrInfo[1].uiUDPPort			= RC_SRC_UDP_PORT;
	g_AddrInfo[2].uiUDPPort			= RC_SRC_UDP_PORT;
	g_AddrInfo[3].uiUDPPort			= OT_SRC_UDP_PORT;

	g_AddrInfo[0].TirdE1Para.Filter = DEF_FILTER;
	g_AddrInfo[1].TirdE1Para.Filter = RC_FILTER;
	g_AddrInfo[2].TirdE1Para.Filter = RC_FILTER;
	g_AddrInfo[3].TirdE1Para.Filter = OT_FILTER;

	g_AddrInfo[0].TirdE1Para.Tos    = DEF_TOS;
	g_AddrInfo[1].TirdE1Para.Tos    = RC_TOS;
	g_AddrInfo[2].TirdE1Para.Tos    = RC_TOS;
	g_AddrInfo[3].TirdE1Para.Tos    = OT_TOS;

	for(i=0;i<MAX_OEM_USER;++i)
    {
		for(j=0;j<MAX_CHANNEL;++j)
	      {
			g_AddrInfo[i].FirE1Para[j].Enable=1;
			g_AddrInfo[i].FirE1Para[j].Port =j;
			g_AddrInfo[i].FirE1Para[j].DstIp=g_AddrInfo[i].ulIpAddr+1;

			memset(g_AddrInfo[i].FirE1Para[j].DstMac,0,6);//for arp test

			g_AddrInfo[0].FirE1Para[j].DstUDPPort= DEF_DST_UDP_PORT;
			g_AddrInfo[1].FirE1Para[j].DstUDPPort= RC_DST_UDP_PORT;
			g_AddrInfo[2].FirE1Para[j].DstUDPPort= RC_DST_UDP_PORT;
			g_AddrInfo[3].FirE1Para[j].DstUDPPort= OT_DST_UDP_PORT;

			g_AddrInfo[i].FirE1Para[j].Proto     = DEF_PROTO;
            g_AddrInfo[i].SecdE1Para[j].SegFlag  = DEF_SEG_FLAG;
			g_AddrInfo[i].SecdE1Para[j].VlanId   = DEF_VLAN_ID;
			g_AddrInfo[i].SecdE1Para[j].CacheLen = DEF_JITTER_BUF;
            g_AddrInfo[i].SecdE1Para[j].Ttl      = DEF_MAX_TTL;
			g_AddrInfo[i].SecdE1Para[j].EnVlan   = 0;
			g_AddrInfo[i].SecdE1Para[j].ClkMod   = 1;//Adptive
		 }

		//g_AddrInfo[i].TirdE1Para.AppMod=1;//slave
		g_AddrInfo[i].TirdE1Para.E1orT1=0;
		//g_AddrInfo[i].TirdE1Para.ClkMod=0x0F;
		g_AddrInfo[i].TirdE1Para.EnIp=0;

		g_AddrInfo[i].TirdE1Para.EnLev=DEF_ENCAP_LEVEL;
	    g_AddrInfo[i].TirdE1Para.Upwidth=DEF_UP_BAND;
	    ///////////////////////////////////////////////////////////////////////

	 }

	 for(i=0;i<MAX_LOGIN_USER;++i)
	 {
		User[i].Group=ADMIN_GROUP;
		Getstring(UserName, i, User[i].Name, MAX_USER_NAME);
		Getstring(Password, i, User[i].Password, MAX_USER_PWD);
	 }

}



/*** BeginHeader DefVarsInit */
xmem void DefVarsInit(void);
/*** EndHeader */
xmem void DefVarsInit(void)
{
	int					i,j;

	/////////////////////////////////////////////////////////////////////////////////////////
	 DefParaInit(0,0) ;

     //StoreData();
	 Restore( );

	for(i=0;i<MAX_OEM_USER;++i)
	{
		for(j=0;j<MAX_CHANNEL;++j)
		{
			 g_AddrInfo[i].FirE1Para[j].EnArp  =1;
		}
	}


	if(UserIndx<(MAX_OEM_USER-1))
	{
	    Getstring(LogoStr, UserIndx, LogoPic, sizeof(LogoPic));
    }

	//Getstring(NameStr, UserIndx, g_HardwareVer, sizeof(g_HardwareVer));
	//SetHardwareVer();
	Getstring(SoftVersion, UserIndx, g_SoftVer, sizeof(g_SoftVer));

	FormDispIP( );
	inet_ethtoa(g_DispAddrInfo.macaddress,g_AddrInfo[UserIndx].ucMacAddr);

	for(i=0;i<MAX_CHANNEL;++i)
    {
		memcpy(E1State[i].CtrlL,"\0",8);
		memcpy(E1State[i].CtrlR,"\0",8);

    }
/////////////////////////////////////////////////////////////////////////////////////////
     QInit( );
     InitRmtUp( );
     WrPortE(CHAN_ENABLE,NULL,0x00);
 /////////////////////////////////////////////////////////////////////////////////////////
     remain.mlong = 0;

     DefaultIp    = 0;		//(BitRdPortI(PADR,DEFAULT_IP)==0) ? 0:0x7E;

     g_EnSend     = 0;

     Arp_En       = 0;
     g_CgiProcess = 0;
     g_WaitLedTimer     = MS_TIMER;
      g_PktosTimer      = MS_TIMER;
     g_ArpTimer         = MS_TIMER;
	 //g_WaitStoreTimer   = SEC_TIMER;
     g_WaitLedTimer     = SEC_TIMER;
     g_DispTimer        = SEC_TIMER;

}


/*** BeginHeader SetHardwareVer */
xmem void SetHardwareVer(void);
/*** EndHeader */
xmem void SetHardwareVer(void)
{
	int i;
	
	int Tmp[3];

	//RdPortE(FPGA_VER_ID_START);

	for (i = 0; i < 3; i++)
	{
	  Tmp[i]=RdPortE(FPGA_VER_ID_START+i);	  
	  sprintf(g_HardwareVer+i*3, "%02X%s", Tmp[i], i < 2 ? "." : "");
	}
}

/*** BeginHeader InitRmtUp */
xmem void InitRmtUp(void);
/*** EndHeader */
xmem void InitRmtUp(void)
{
	int i,j;
	unsigned char ucTmp;
	
	//unsigned char Disp[20];
	
	ucTmp=1;
	
	RemoteUp.Cnt=0;
	memset(RemoteUp.IsArp,1,MAX_CHANNEL);
	memset(RemoteUp.ArpIP,0,MAX_CHANNEL);
	
	
	RemoteUp.Cnt=1;
	//RemoteUp.IsArp[0]=1;
	RemoteUp.ArpIP[0]=g_AddrInfo[UserIndx].FirE1Para[0].DstIp;
	
	for(i=RemoteUp.Cnt;i<MAX_CHANNEL;++i)
	{
		for(j=0;j<RemoteUp.Cnt;++j)
		{
			if(g_AddrInfo[UserIndx].FirE1Para[i].DstIp==RemoteUp.ArpIP[j])
			{
				ucTmp=0;
				break;
			}
		}
		if(ucTmp==1)
		{
			//RemoteUp.IsArp[RemoteUp.Cnt]=1;
			RemoteUp.ArpIP[RemoteUp.Cnt]=g_AddrInfo[UserIndx].FirE1Para[i].DstIp;
			RemoteUp.Cnt++;
		}
		else
		{
			ucTmp=1;
		}
	}

    //printf("cnt:%02x\r\n",RemoteUp.Cnt);

    //for(j=0;j<RemoteUp.Cnt;++j)
    //{
    //	 inet_ntoa(Disp,RemoteUp.ArpIP[j]);
    ///	 printf("Indx=%d  IP=%s\r\n",j,Disp);
    //}
}
/*** BeginHeader InitAdCfg */
xmem void InitAdCfg(void);
/*** EndHeader */
xmem void InitAdCfg(void)
{
	int   i;

	for(i=0;i<MAX_OEM_USER;++i)
	{
		memcpy(&AdvanPara.OemUser[i][0],"\0",9);
	}

	if(UserIndx>MAX_OEM_USER)
	{
		UserIndx=0;
	}

	memcpy(&AdvanPara.OemUser[UserIndx][0],"selected\0",9);
	inet_ethtoa(AdvanPara.EqMac,g_AddrInfo[UserIndx].ucMacAddr);
	AdvanPara.EthFrmType=g_AddrInfo[UserIndx].uiFrmType;
	AdvanPara.EnpFlg=g_AddrInfo[UserIndx].SecdE1Para[0].SegFlag;

	AdvanPara.Protocol=g_AddrInfo[UserIndx].FirE1Para[0].Proto ;

	AdvanPara.SrcPort=g_AddrInfo[UserIndx].uiUDPPort;
	AdvanPara.DstPort=g_AddrInfo[UserIndx].FirE1Para[0].DstUDPPort;

    AdvanPara.SetTtl = g_AddrInfo[UserIndx].SecdE1Para[0].Ttl;
	AdvanPara.Filter =g_AddrInfo[UserIndx].TirdE1Para.Filter;

}

/*** BeginHeader InitPurview */
xmem void InitPurview(void);
/*** EndHeader */
xmem void InitPurview()
{
	int i;
	sspec_addrule("/SetEthinfo.htm", "Administrator",
	ADMIN_GROUP, 0, SERVER_HTTP,SERVER_AUTH_BASIC, NULL);
	sspec_addrule("/SetE1Lb.htm", "Administrator",
	ADMIN_GROUP, 0, SERVER_HTTP,SERVER_AUTH_BASIC, NULL);
	sspec_addrule("/SetE1info.htm", "Administrator",
	ADMIN_GROUP, 0, SERVER_HTTP,SERVER_AUTH_BASIC, NULL);
	sspec_addrule("/Password.htm", "Administrator",
	ADMIN_GROUP, 0, SERVER_HTTP,SERVER_AUTH_BASIC, NULL);
	sspec_addrule("/Defpara.htm", "Administrator",
	ADMIN_GROUP, 0, SERVER_HTTP,SERVER_AUTH_BASIC, NULL);
	sspec_addrule("/Reboot.htm", "Administrator",
	ADMIN_GROUP, 0, SERVER_HTTP,SERVER_AUTH_BASIC, NULL);

	for(i=0;i<MAX_LOGIN_USER;++i)
	{
		sauth_setusermask(sauth_adduser(User[i].Name, User[i].Password,
		SERVER_ANY), User[i].Group, NULL);
	}
}

/*** BeginHeader FormDispIP */
xmem void FormDispIP(void);
/*** EndHeader */
xmem void FormDispIP(void)
{
       unsigned long       ulTmp1,ulTmp2,ulTmp3;
       int 					i;

       ulTmp1=g_AddrInfo[UserIndx].ulIpAddr;
       ulTmp2=g_AddrInfo[UserIndx].ulIpMask;
       ulTmp3=g_AddrInfo[UserIndx].ulGateway;

		inet_ntoa(g_DispAddrInfo.ip,g_AddrInfo[UserIndx].ulIpAddr);
		inet_ntoa(g_DispAddrInfo.netmask,g_AddrInfo[UserIndx].ulIpMask);
		inet_ntoa(g_DispAddrInfo.gateway,g_AddrInfo[UserIndx].ulGateway);
		//inet_ethtoa(g_DispAddrInfo.macaddress,g_AddrInfo[UserIndx].ucMacAddr);

		for(i=0;i<4;++i)
		{
			NetworkCfg.DstIp[3-i] = (unsigned int)(ulTmp1&0x000000FF);
			NetworkCfg.Mask[3-i] = (unsigned int)(ulTmp2&0x000000FF);
			NetworkCfg.Gateway[3-i] = (unsigned int)(ulTmp3&0x000000FF);
			ulTmp1>>=8;
			ulTmp2>>=8;
			ulTmp3>>=8;
		}
}


/*** BeginHeader ConvertDisp */
void ConvertDisp(void);
/*** EndHeader */
void ConvertDisp()
{
	int i,j;

	unsigned long ulTmp;

	if(UserIndx>3)
	{
		return;
	}


	for(i=0;i<MAX_CHANNEL;++i)
	{
		if(g_AddrInfo[UserIndx].FirE1Para[i].Enable)
		{
			memcpy(&DispE1Para1[i].Enable,"checked\0",8);
		}
		else
		{
			memcpy(&DispE1Para1[i].Enable,"\0",8);
		}

		for(j=0;j<4;++j)
		{
			memcpy(&DispE1Para1[i].Port[j][0],"\0",9);
		}

		if((g_AddrInfo[UserIndx].FirE1Para[i].Port>=0)&&(g_AddrInfo[UserIndx].FirE1Para[i].Port<4))
		{

			memcpy(&DispE1Para1[i].Port[g_AddrInfo[UserIndx].FirE1Para[i].Port][0],"selected\0",9);
		}


        ulTmp=g_AddrInfo[UserIndx].FirE1Para[i].DstIp;

		for(j=0;j<4;++j)
		{
			DispE1Para1[i].DstIp[3-j] = (unsigned int)(ulTmp&0x000000FF);
			ulTmp>>=8;
		}

        if(g_AddrInfo[UserIndx].SecdE1Para[i].ClkMod==0x01)
		{
			memcpy(&DispE1Para2[i].ClkMod[1][0],"selected\0",9);
			memcpy(&DispE1Para2[i].ClkMod[0][0],"\0",9);
		}
		else
		{
			memcpy(&DispE1Para2[i].ClkMod[0][0],"selected\0",9);
			memcpy(&DispE1Para2[i].ClkMod[1][0],"\0",9);
		}

        DispE1Para2[i].JitBuf =g_AddrInfo[UserIndx].SecdE1Para[i].CacheLen;
        DispE1Para2[i].V_ID   =g_AddrInfo[UserIndx].SecdE1Para[i].VlanId;

		if(g_AddrInfo[UserIndx].SecdE1Para[i].EnVlan)
		{
			memcpy(&DispE1Para2[i].Vlan,"checked\0",8);
		}
		else
		{
			memcpy(&DispE1Para2[i].Vlan,"\0",8);
		}
      }



		if(g_AddrInfo[UserIndx].TirdE1Para.E1orT1)
		{
			memcpy(&DispE1Para3.E1orT1[1][0],"selected\0",9);
			memcpy(&DispE1Para3.E1orT1[0][0],"\0",9);
		}
		else
		{
			memcpy(&DispE1Para3.E1orT1[0][0],"selected\0",9);
			memcpy(&DispE1Para3.E1orT1[1][0],"\0",9);
		}

		for(i=0;i<5;++i)
		{
			memcpy(&DispE1Para3.EnLev[i][0],"\0",9);
		}

		if((g_AddrInfo[UserIndx].TirdE1Para.EnLev>0)&&(g_AddrInfo[UserIndx].TirdE1Para.EnLev<6))
		{
			memcpy(&DispE1Para3.EnLev[g_AddrInfo[UserIndx].TirdE1Para.EnLev-1][0],"selected\0",9);
		}


        if(g_AddrInfo[UserIndx].TirdE1Para.EnIp)
		{
			memcpy(&DispE1Para3.EnIp[1][0],"selected\0",9);
			memcpy(&DispE1Para3.EnIp[0][0],"\0",9);
		}
		else
		{
			memcpy(&DispE1Para3.EnIp[0][0],"selected\0",9);
			memcpy(&DispE1Para3.EnIp[1][0],"\0",9);
		}

		DispE1Para3.uiTos = g_AddrInfo[UserIndx].TirdE1Para.Tos;
		DispE1Para3.uiUp  = g_AddrInfo[UserIndx].TirdE1Para.Upwidth;

        InitAdCfg();

}


/*** BeginHeader CalIpLen */
xmem unsigned int CalIpLen(unsigned char index);
/*** EndHeader */
xmem unsigned int CalIpLen(unsigned char index)
{
	unsigned char ucTmp1,ucTmp2,ucTmp3;
	unsigned int  uiTmp;


   Status.Los=RdPortE(CHAN_ALARM);

   switch(index)
   {
   	case 0x01:
   	 ucTmp3=(Status.Los&0x30);
   	 ucTmp3>>=4;
   	break;
   	case 0x02:
   	 ucTmp3=(Status.Los&0x0C);
   	 ucTmp3>>=2;
   	break;
   	case 0x03:
   	  ucTmp3=(Status.Los&0x03);
   	break;
   	default:
   	   ucTmp3=(Status.Los&0xC0);
   	   ucTmp3>>=6;
   	break;
   }

   //printf("ucTmp3:%02x\r\n",ucTmp3);

		if((ucTmp3==0x00)||(ucTmp3==0x03))
		{

		    WrPortE(A_CHAN_IP_LEN_START+(index*CHAN_OFFSET),NULL,0x00);
		    WrPortE(A_CHAN_IP_LEN_START+1+(index*CHAN_OFFSET),NULL,0x2E);// 46Bytes

		    return 0x002E;
		}
		else
		{
			 if(g_AddrInfo[UserIndx].TirdE1Para.E1orT1==0)
			 {
			 	uiTmp=(unsigned int)(40+256*(g_AddrInfo[UserIndx].TirdE1Para.EnLev& 0x07));
			 }
             else
             {
             	uiTmp=(unsigned int)(40+208*(g_AddrInfo[UserIndx].TirdE1Para.EnLev& 0x07));
             }

            ucTmp1=(unsigned char)(uiTmp&0x00FF);
			ucTmp2=(unsigned char)((uiTmp>>8)&0x00FF);

		    WrPortE(A_CHAN_IP_LEN_START+(index*CHAN_OFFSET),NULL,ucTmp2);
		    WrPortE(A_CHAN_IP_LEN_START+1+(index*CHAN_OFFSET),NULL,ucTmp1);

		    return uiTmp;
		}
}

/*** BeginHeader RmtUpLed */
xmem void RmtUpLed(void);
/*** EndHeader */
xmem void RmtUpLed(void)
{
	unsigned char ucTmp;
	int i;

	ucTmp = 0x0F;
123

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -