#include #include //#include #include //#include #include //#include "nwcfg.h" #include "Util.h" #include "main.h" #include "Api.h" #include "Util.h" #include "com_IPMI_LANConfig.h" #include "com_IPMI_DeviceConfig.h" #include /* Reserved bit macro definitions */ #define RESERVED_BITS_SUSPENDBMCARPS 0xF0 //(BIT7 | BIT6 | BIT5 | BIT4) #define RESERVED_BITS_GETIPUDPRMCPSTATS_CH 0xF0 //(BIT7 | BIT6 | BIT5 | BIT4) #define RESERVED_BITS_GETIPUDPRMCPSTATS_CLRSTATE 0xFE //(BIT7 | BIT6 | BIT5 | BIT4 | BIT3 | BIT2 | BIT1) /*** Local definitions ***/ #define CHANNEL_ID_MASK 0x0f #define SET_IN_PROGRESS_MASK 0x03 #define PARAMETER_REVISION_MASK 0x0f #define DEST_ADDR_DATA2_ADDR_FORMAT_MASK 0xf0 #define PARAMETER_REVISION_FORMAT 0x11 #define GET_PARAMETER_REVISION_MASK 0x80 #define LAN_CALLBACK_AUTH_SUPPORT 0x17 /* MD2 & MD5 supported */ #define LAN_USER_AUTH_SUPPORT 0x17 /* MD2 & MD5 supported */ #define LAN_OPERATOR_AUTH_SUPPORT 0x17 /* MD2 & MD5 supported */ #define LAN_ADMIN_AUTH_SUPPORT 0x17 /* MD2 & MD5 supported */ #define BRD_CAST_BIT_MASK 0xFF #define LOOP_BACK_BIT_MASK 0x7F #define SUBNET_MASK_BIT_CHECK 0x80 #define LAN_CONFIGURATION_SET_IN_PROGRESS 0x01 #define LAN_CONFIGURATION_SET_COMPLETE 0x00 #define GRATIUTOUS_ENABLE_MASK 1 #define ENABLE_ARP_RESPONSES 2 #define SUSPEND_ARP_RSVD_BIT_MASK 0xFC #define ENABLE_ARPS 0x03 #define SUSPEND_GRAT_ARP 0x01 #define SUSPEND_ARP 0x02 #define ARP_IGNORE_ON 8 #define ARP_IGNORE_OFF 0 /* Reserved Bits */ #define RESERVED_VALUE_70 0x70 #define RESERVED_VALUE_F0 0xF0 // /** // *@fn NwInterfacePresenceCheck // *@brief This function is invoked to check network interface presence // *@param Interface - Char Pointer to buffer for which interface to check // */ // static int NwInterfacePresenceCheck (char * Interface); // /*** Module Variables ***/ // // uint8_t m_ArpSuspendReq; // char **explode(char separator, char *string); // int IPAddrCheck(uint8_t *Addr,int params); // extern int GetLanAMIParamValue (uint8_t* ParamSelect, uint8_t* ImpType); // extern IfcName_T Ifcnametable[MAX_LAN_CHANNELS]; #define MAX_LAN_PARAMS_DATA 20 typedef struct { uint8_t Params; uint8_t ReservedBits [MAX_LAN_PARAMS_DATA]; uint8_t DataLen; } LANCfgRsvdBits_T; static LANCfgRsvdBits_T m_RsvdBitsCheck [] = { /* Param Reserved Bits Data Size */ { 0, { 0xFC }, 0x1 }, /* Set In progress */ { 1, { 0xC8 }, 0x1 }, /* Authenication type */ { 2, { 0xC8,0xC8,0xC8,0xC8,0xC8 }, 0x5}, /* Authenication Support Enable */ { 4, { 0xF0 }, 0x1 }, /* l */ { 7, { 0x0,0x1F,0x01 }, 0x3 }, /* l */ { 0xA, { 0xFC }, 0x1 }, /* l */ { 0x11, { 0xF0 }, 0x1 }, /* l */ { 0x12, { 0xF0,0x78,0x0,0xF8 }, 0x4 }, { 0x13, { 0xF0,0x0F, 0xFE }, 0x3 }, { 0x14, { 0x0,0x70}, 0x2 }, { 0x15, { 0xF8 }, 0x1 }, { 0x16, { 0xE0 }, 0x1 }, { 0x17, { 0xFF }, 0x1 }, { 0x18, { 0xFF }, 0x1 }, { 0x19, { 0xF0,0x0F }, 0x2 }, { 0x1A, { 0xFE }, 0x1 } }; typedef struct { uint8_t OEMParam; uint8_t Length; }OEMParameterLength_T; static OEMParameterLength_T m_OEMParamLen [] = { // {LAN_PARAMS_AMI_OEM_IPV6_ENABLE, 1 }, // {LAN_PARAMS_AMI_OEM_IPV6_IP_ADDR_SOURCE, 1 }, // {LAN_PARAMS_AMI_OEM_IPV6_IP_ADDR, 17 }, // {LAN_PARAMS_AMI_OEM_IPV6_PREFIX_LENGTH, 2}, // {LAN_PARAMS_AMI_OEM_IPV6_GATEWAY_IP, 16} }; /** * @brief LAN configuration request parameter lengths **/ static const uint8_t LanconfigParameterLength [] = { 1, /* Set in progress */ 1, /* Authentication type support */ 5, /* Authentication type enables */ 4, /* IP address */ 1, /* IP address source */ 6, /* MAC address */ 4, /* Subnet mask */ 3, /* IPv4 header parameters */ 2, /* Primary RMCP port number */ 2, /* Secondary RMCP port number */ 1, /* BMC generated ARP control */ 1, /* Gratuitous ARP */ 4, /* Default Gateway address */ 6, /* Default Gateway MAC address */ 4, /* Backup Gateway address */ 6, /* Backup Gateway MAC address */ 18, /* Community string */ 1, /* Number of destinations */ 4, /* Destination type */ 13, /* Destination address */ 2, /* VLAN ID */ 1, /* VLAN Priority */ 1, /* Cipher suite entry support */ 17, /* Cipher suite entries */ 9, /* Cipher suite Privilege levels */ 4, /* VLAN tags destination address */ 6, /* Bad Password Threshold */ (9+16) /* IPv6 Destination address */ }; /* A copy of ip_tos2prio with numeric format in "linux/net/ipv4/route.c" */ static const uint8_t IP_TOS2PRIO[16] = { 0, /* TC_PRIO_BESTEFFORT, */ 1, /* ECN_OR_COST(FILLER), */ 0, /* TC_PRIO_BESTEFFORT, */ 0, /* ECN_OR_COST(BESTEFFORT), */ 2, /* TC_PRIO_BULK, */ 2, /* ECN_OR_COST(BULK), */ 2, /* TC_PRIO_BULK, */ 2, /* ECN_OR_COST(BULK), */ 6, /* TC_PRIO_INTERACTIVE, */ 6, /* ECN_OR_COST(INTERACTIVE), */ 6, /* TC_PRIO_INTERACTIVE, */ 6, /* ECN_OR_COST(INTERACTIVE), */ 4, /* TC_PRIO_INTERACTIVE_BULK, */ 4, /* ECN_OR_COST(INTERACTIVE_BULK),*/ 4, /* TC_PRIO_INTERACTIVE_BULK, */ 4 /* ECN_OR_COST(INTERACTIVE_BULK) */ }; static uint8_t enableSetMACAddr = TRUE; //jimbo notice /*------------------------------------------------------- * SetLanConfigParam *-------------------------------------------------------*/ int SetLanConfigParam ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes) { SetLanConfigReq_T* pSetLanReq = ( SetLanConfigReq_T*) pReq; SetLanConfigRes_T* pSetLanRes = ( SetLanConfigRes_T*) pRes; MsgPkt_T m_MsgPkt; int i,j=0; uint8_t index; int retValue=0,NIC_Count = 0; // uint16_t PriorityLevel[MAX_LAN_CHANNELS]= {0}; uint8_t m_Lan_SetInProgress; /**< Contains setting LAN configuration status */ uint8_t InvalidMac[MAC_ADDR_LEN] = {0,0,0,0,0,0}; char old_mac[18]; char macStr[18] = {0}; char old_ip[16]; char ipStr[16] = {0}; char old_netmask[18]; char netmaskStr[18] = {0}; if ( ReqLen >= 2 ) { ReqLen -= 2; } else { *pRes = CC_REQ_INV_LEN; return 1; } //自定义 // if((pSetLanReq->ParameterSelect >= MIN_LAN_OEM_CONF_PARAM) && // (pSetLanReq->ParameterSelect <= MAX_LAN_OEM_CONF_PARAM) ) // { // /* Converts OEM parameter value to equivalent AMI parameter value */ // if (0 != GetLanAMIParamValue (&pSetLanReq->ParameterSelect, &IsOemDefined) ) // { // pSetLanRes->CompletionCode = CC_PARAM_NOT_SUPPORTED; // return sizeof(uint8_t); // } // /* Hook for OEM to handle this parameter */ // if ( (IsOemDefined) && (g_PDKHandle[PDK_SETLANOEMPARAM] != NULL) ) // { // return ((int(*)(uint8_t *, uint8_t, uint8_t *,int))(g_PDKHandle[PDK_SETLANOEMPARAM]))(pReq, ReqLen, pRes, BMCInst); // } // } if(0x1b >pSetLanReq->ParameterSelect ) //Max known Lan paramter { if (ReqLen != LanconfigParameterLength [pSetLanReq->ParameterSelect ]) { *pRes = CC_REQ_INV_LEN; return sizeof (uint8_t); } } // /*Check the Request length for OEM parameter*/ // for(i=0;iParameterSelect) // { // if(ReqLen != m_OEMParamLen[i].Length) // { // *pRes = CC_REQ_INV_LEN; // return sizeof(uint8_t); // } // } // } if(pSetLanReq->ChannelNum & RESERVED_VALUE_F0) { /* Alarm !!! Somebody is trying to set Reseved Bits */ *pRes = CC_INV_DATA_FIELD; return sizeof (*pRes); } if(pSetLanReq->ChannelNum == LAN_RMCP_CHANNEL) index = 0; else { *pRes = CC_INV_DATA_FIELD; return sizeof (*pRes); } /* Check for Reserved Bits */ for (i = 0; i < sizeof (m_RsvdBitsCheck)/ sizeof (m_RsvdBitsCheck[0]); i++) { /* Check if this Parameter Selector needs Reserved bit checking !! */ if (m_RsvdBitsCheck[i].Params == pSetLanReq->ParameterSelect) { //IPMI_DBG_PRINT_2 ("Param - %x, DataLen - %x\n", pSetLanReq->ParameterSelect, m_RsvdBitsCheck[i].DataLen); for (j = 0; j < m_RsvdBitsCheck[i].DataLen; j++) { // IPMI_DBG_PRINT_2 ("Cmp %x, %x\n", pReq[2+j], m_RsvdBitsCheck[i].ReservedBits[j]); if ( 0 != (pReq[2+j] & m_RsvdBitsCheck[i].ReservedBits[j])) { /* Alarm !!! Somebody is trying to set Reseved Bits */ *pRes = CC_INV_DATA_FIELD; return sizeof (*pRes); } } } } // ptrChannelInfo = getChannelInfo (pSetLanReq->ChannelNum & 0x0F, BMCInst); // if(NULL == ptrChannelInfo) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(*pRes); // } printf ("Parameter = %X\n", pSetLanReq->ParameterSelect); switch (pSetLanReq->ParameterSelect) { case LAN_PARAM_SET_IN_PROGRESS: m_Lan_SetInProgress = g_BMCInfo.m_Lan_SetInProgress; /* Commit Write is optional and supported * only if rollback is supported */ if ( (GetBits(pSetLanReq->ConfigData.SetInProgress, SET_IN_PROGRESS_MASK) != LAN_CONFIGURATION_SET_COMPLETE) && (GetBits(pSetLanReq->ConfigData.SetInProgress, SET_IN_PROGRESS_MASK) != LAN_CONFIGURATION_SET_IN_PROGRESS) ) { pSetLanRes->CompletionCode = CC_PARAM_NOT_SUPPORTED; return sizeof(*pSetLanRes); } else if ((GetBits(m_Lan_SetInProgress, SET_IN_PROGRESS_MASK) == LAN_CONFIGURATION_SET_IN_PROGRESS) && (GetBits(pSetLanReq->ConfigData.SetInProgress, SET_IN_PROGRESS_MASK) == LAN_CONFIGURATION_SET_IN_PROGRESS)) { pSetLanRes->CompletionCode = CC_SET_IN_PROGRESS; return sizeof(*pSetLanRes); } g_BMCInfo.m_Lan_SetInProgress = pSetLanReq->ConfigData.SetInProgress; break; case LAN_PARAM_AUTH_TYPE_SUPPORT: pSetLanRes->CompletionCode = CC_ATTEMPT_TO_SET_RO_PARAM; return sizeof(*pRes); case LAN_PARAM_AUTH_TYPE_ENABLES: printf("---> Not implement!\n"); // for(i=0;i<5;i++) // { // /* Check for Unsupported AuthType */ // if (pBMCInfo->LANCfs[EthIndex].AuthTypeSupport != (pBMCInfo->LANCfs[EthIndex].AuthTypeSupport |pReq[2+i])) // { // IPMI_DBG_PRINT_2("\n Alarm !!! Somebody is trying to Unsupported Bit :%d \t%d\n",pReq[2+i],i); // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // } // LOCK_BMC_SHARED_MEM(BMCInst); // _fmemcpy (&pBMCInfo->LANCfs[EthIndex].AuthTypeEnables, // &(pSetLanReq->ConfigData.AuthTypeEnables), sizeof(AuthTypeEnables_T)); // _fmemcpy (ptrChannelInfo->AuthType, // &(pSetLanReq->ConfigData.AuthTypeEnables), sizeof(AuthTypeEnables_T)); // UNLOCK_BMC_SHARED_MEM(BMCInst); break; case LAN_PARAM_IP_ADDRESS: //post cmd to chassisTimerTask if(IPAddrCheck(pSetLanReq->ConfigData.IPAddr,LAN_PARAM_IP_ADDRESS)) { *pRes = CC_INV_DATA_FIELD; return sizeof (uint8_t); } getip(old_ip); sprintf(ipStr, "%d.%d.%d.%d", pSetLanReq->ConfigData.IPAddr[0], pSetLanReq->ConfigData.IPAddr[1], pSetLanReq->ConfigData.IPAddr[2], pSetLanReq->ConfigData.IPAddr[3]); if(strcmp(ipStr, old_ip) == 0) { printf("The same ip %s, do nothing\n", ipStr ); *pRes = CC_NORMAL; return 1; } m_MsgPkt.Param = PARAM_LAN; m_MsgPkt.NetFnLUN = NETFNLUN_IPMI_TRANSPORT; m_MsgPkt.Cmd = CMD_SET_LAN_CONFIGURATION_PARAMETERS; m_MsgPkt.Size = sizeof(SetLanConfigReq_T)+2; m_MsgPkt.Data[0] = 0;//eth0 m_MsgPkt.Data[1] = 0;//掉电不保存 memcpy(&m_MsgPkt.Data[2], pSetLanReq, sizeof(SetLanConfigReq_T)); PostMsg(gPendActionIfc, &m_MsgPkt); //Update memcpy(g_BMCInfo.IpmiConfig.LanInfo[index].IPAddr, pSetLanReq->ConfigData.IPAddr, 4); FlushIpmiConfig(); printf("---> old_ip: %s, new_ip: %s\n", old_ip, ipStr); printf("---> send data: %#x %#x %#x %#x %#x\n", m_MsgPkt.Data[0], m_MsgPkt.Data[1] , m_MsgPkt.Data[2], m_MsgPkt.Data[3], m_MsgPkt.Data[4]); break; case LAN_PARAM_IP_ADDRESS_SOURCE: printf("---> Not implement!\n"); break; case LAN_PARAM_MAC_ADDRESS: /* According to IPMI 2.0 Specification Revision 3, the MAC address can be read only parameter*/ //*pRes = CC_ATTEMPT_TO_SET_RO_PARAM; //return sizeof (*pRes); if((pSetLanReq->ConfigData.MACAddr[0]& BIT0)|| (memcmp(&InvalidMac,&pSetLanReq->ConfigData.MACAddr,MAC_ADDR_LEN) == 0)) { pSetLanRes->CompletionCode = CC_INV_DATA_FIELD; return 1; } getmac(old_mac); sprintf(macStr, "%02x:%02x:%02x:%02x:%02x:%02x", pSetLanReq->ConfigData.MACAddr[0], pSetLanReq->ConfigData.MACAddr[1], pSetLanReq->ConfigData.MACAddr[2], pSetLanReq->ConfigData.MACAddr[3], pSetLanReq->ConfigData.MACAddr[4], pSetLanReq->ConfigData.MACAddr[5]); if(strcmp(macStr, old_mac) == 0) { printf("The same mac %s, do nothing\n", macStr ); *pRes = CC_NORMAL; return 1; } if (!enableSetMACAddr) pSetLanRes->CompletionCode = CC_ATTEMPT_TO_SET_RO_PARAM; else { m_MsgPkt.Param = PARAM_LAN; m_MsgPkt.NetFnLUN = NETFNLUN_IPMI_TRANSPORT; m_MsgPkt.Cmd = CMD_SET_LAN_CONFIGURATION_PARAMETERS; m_MsgPkt.Size = sizeof(SetLanConfigReq_T)+2; m_MsgPkt.Data[0] = 0;//eth0 m_MsgPkt.Data[1] = 0;//掉电不保存 memcpy(&m_MsgPkt.Data[2], pSetLanReq, sizeof(SetLanConfigReq_T)); PostMsg(gPendActionIfc, &m_MsgPkt); //Update memcpy(g_BMCInfo.IpmiConfig.LanInfo[index].MACAddr, pSetLanReq->ConfigData.MACAddr, 6); printf("---> old_mac: %s, new_mac: %s\n", old_mac, macStr); pSetLanRes->CompletionCode = CC_NORMAL; } break; case LAN_PARAM_SUBNET_MASK: getnetmask(old_netmask); sprintf(netmaskStr, "%d.%d.%d.%d", pSetLanReq->ConfigData.SubNetMask[0], pSetLanReq->ConfigData.SubNetMask[1], pSetLanReq->ConfigData.SubNetMask[2], pSetLanReq->ConfigData.SubNetMask[3]); if(strcmp(netmaskStr, old_netmask) == 0) { printf("The same netmask %s, do nothing\n", netmaskStr ); *pRes = CC_NORMAL; return 1; } if(IPAddrCheck(pSetLanReq->ConfigData.SubNetMask,LAN_PARAM_SUBNET_MASK)) { *pRes = CC_INV_DATA_FIELD; return sizeof (uint8_t); } m_MsgPkt.Param = PARAM_LAN; m_MsgPkt.NetFnLUN = NETFNLUN_IPMI_TRANSPORT; m_MsgPkt.Cmd = CMD_SET_LAN_CONFIGURATION_PARAMETERS; m_MsgPkt.Size = sizeof(SetLanConfigReq_T)+2; m_MsgPkt.Data[0] = 0;//eth0 m_MsgPkt.Data[1] = 0;//掉电不保存 memcpy(&m_MsgPkt.Data[2], pSetLanReq, sizeof(SetLanConfigReq_T)); PostMsg(gPendActionIfc, &m_MsgPkt); //Update memcpy(g_BMCInfo.IpmiConfig.LanInfo[index].NetMask, pSetLanReq->ConfigData.SubNetMask, 4); pSetLanRes->CompletionCode = CC_NORMAL; break; case LAN_PARAM_IPv4_HEADER: printf("Not implement\n"); break; case LAN_PARAM_PRI_RMCP_PORT: printf("Not implement\n"); //需要重启网络线程 break; case LAN_PARAM_SEC_RMCP_PORT: /* Returning Invalid error message */ *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof (uint8_t); /*pPMConfig->LANConfig[EthIndex].SecondaryPort = ipmitoh_u16 (pSetLanReq->ConfigData.SecondaryPort);*/ break; case LAN_PARAM_BMC_GENERATED_ARP_CONTROL: printf("Not implement\n"); break; case LAN_PARAM_GRATITIOUS_ARP_INTERVAL: printf("Not implement\n"); break; case LAN_PARAM_DEFAULT_GATEWAY_IP: if(IPAddrCheck(pSetLanReq->ConfigData.DefaultGatewayIPAddr,LAN_PARAM_DEFAULT_GATEWAY_IP)) { *pRes = CC_INV_DATA_FIELD; return sizeof (uint8_t); } m_MsgPkt.Param = PARAM_LAN; m_MsgPkt.NetFnLUN = NETFNLUN_IPMI_TRANSPORT; m_MsgPkt.Cmd = CMD_SET_LAN_CONFIGURATION_PARAMETERS; m_MsgPkt.Size = sizeof(SetLanConfigReq_T)+2; m_MsgPkt.Data[0] = 0;//eth0 m_MsgPkt.Data[1] = 0;//掉电不保存 memcpy(&m_MsgPkt.Data[2], pSetLanReq, sizeof(SetLanConfigReq_T)); PostMsg(gPendActionIfc, &m_MsgPkt); //Update memcpy(g_BMCInfo.IpmiConfig.LanInfo[index].DefaultGW, pSetLanReq->ConfigData.DefaultGatewayIPAddr, 4); pSetLanRes->CompletionCode = CC_NORMAL; break; case LAN_PARAM_DEFAULT_GATEWAY_MAC: pSetLanRes->CompletionCode = CC_ATTEMPT_TO_SET_RO_PARAM; return sizeof(*pRes); break; case LAN_PARAM_BACKUP_GATEWAY_IP: printf("Not implement\n"); break; case LAN_PARAM_BACKUP_GATEWAY_MAC: printf("Not implement\n"); break; case LAN_PARAM_COMMUNITY_STRING: printf("Not implement\n"); break; case LAN_PARAM_DEST_NUM: pSetLanRes->CompletionCode = CC_ATTEMPT_TO_SET_RO_PARAM; return sizeof(uint8_t); case LAN_PARAM_SELECT_DEST_TYPE: printf("Not implement\n"); break; case LAN_PARAM_SELECT_DEST_ADDR: printf("Not implement\n"); break; case LAN_PARAM_VLAN_ID: printf("Not implement\n"); break; case LAN_PARAM_VLAN_PRIORITY: printf("Not implement\n"); break; case LAN_PARAM_CIPHER_SUITE_ENTRY_SUP: pSetLanRes->CompletionCode = CC_ATTEMPT_TO_SET_RO_PARAM; return sizeof(uint8_t); case LAN_PARAM_CIPHER_SUITE_ENTRIES: pSetLanRes->CompletionCode = CC_ATTEMPT_TO_SET_RO_PARAM; return sizeof(uint8_t); break; case LAN_PARAM_CIPHER_SUITE_PRIV_LEVELS: printf("Not implement\n"); break; case LAN_PARAM_VLAN_TAGS: printf("Not implement\n"); break; case LAN_PARAMS_BAD_PASSWORD_THRESHOLD: printf("Not implement\n"); break; default: pSetLanRes->CompletionCode = CC_PARAM_NOT_SUPPORTED; return sizeof(uint8_t); } pSetLanRes->CompletionCode = CC_NORMAL; FlushIpmiConfig(); return sizeof(*pSetLanRes); } /* *@fn IPAddrCheck function *@brief It will validate the IP Address and net Mask *@param Addr - IP Address or net Mask *@param params - parameter data to validate */ int IPAddrCheck(uint8_t *Addr,int params) { int i,maskcount=0,bitmask =0,j,bitcheck=0; for(i=0;i< IP_ADDR_LEN;i++) { if(Addr[i] == BRD_CAST_BIT_MASK) { maskcount++; } } if(maskcount == IP_ADDR_LEN) { return 1; } if(params == LAN_PARAM_SUBNET_MASK) { if(Addr[0] == BRD_CAST_BIT_MASK) { for(i=1;i< IP_ADDR_LEN;i++) { if(Addr[i-1] == 0) { bitmask = 1; } if(Addr[i] != 0) { for(j=0;j<8;j++) { if((Addr[i]< 0 && bitmask == 1)) { return 1; } } } return 0; } return 1; } if(Addr[0] == LOOP_BACK_BIT_MASK || Addr[0] == BRD_CAST_BIT_MASK) { return 1; } return 0; } // /*---------------------------------------------- // * GratuitousARPTask // *----------------------------------------------*/ // void* GratuitousARPTask (uint8_t *Addr) // { // uint8_t IntervalInSec; // uint8_t Status; // int nRet; // NWCFG_STRUCT NWConfig; // NWCFG6_STRUCT NWConfig6; // uint8_t EthIndex,netindex= 0xFF; // int BMCInst,i; // char IfcName[16]; // BMCArg *GratArpArgs = (BMCArg *)Addr; // BMCInst = GratArpArgs->BMCInst; // BMCInfo_t *pBMCInfo = &g_BMCInfo[BMCInst]; // prctl(PR_SET_NAME,__FUNCTION__,0,0,0); // memcpy(&EthIndex,GratArpArgs->Argument,GratArpArgs->Len); // memset(IfcName,0,sizeof(IfcName)); // /*Get the EthIndex*/ // if(GetIfcName(EthIndex,IfcName, BMCInst) == -1) // { // TCRIT("Error in Getting Ifcname\n"); // return 0; // } // for(i=0;iArgument); // free(Addr); // } // TDBG ("Gratuitous ARP thread starts for ethindex : %x\n",EthIndex); // while (1) // { // /*Is Gratiutous Arp Enabled */ // if (0 == (pBMCInfo->LANCfs[EthIndex].BMCGeneratedARPControl & GRATIUTOUS_ENABLE_MASK)) // { // TDBG("Gratuitous ARP thread exits : Disable BMC-generated Gratuitous ARPs invoked\n"); // break; // } // /*Is Gratiutous Arp Suspended */ // Status = BMC_GET_SHARED_MEM(BMCInst)->ArpSuspendStatus[EthIndex]; // if ((0 != (Status & GRATIUTOUS_ENABLE_MASK)) && // (BMC_GET_SHARED_MEM(BMCInst)->IsWDTRunning == TRUE)) // { // // Gratuitous ARP Suspended. // // sleep requested to access Shared memory for two different threads. // usleep (20); // continue; // } // nwReadNWCfg_v4_v6( &NWConfig,&NWConfig6, netindex,g_corefeatures.global_ipv6); // if(GetIfcName(EthIndex, IfcName,BMCInst) != 0) // { // TCRIT("Error in getting Interface Name for the Lan Index :%d\n",EthIndex); // } // if (NWConfig.IFName[0] == 0) // sprintf((char *)&NWConfig.IFName, "%s",IfcName); // TDBG ( "MAC is %2x:%2x:%2x:%2x:%2x:%2x \n", NWConfig.MAC [0], NWConfig.MAC [1], // NWConfig.MAC [2], NWConfig.MAC [3], NWConfig.MAC [4], NWConfig.MAC [5] ); // TDBG ( "IP is %d.%d.%d.%d\n", NWConfig.IPAddr[0], NWConfig.IPAddr[1], // NWConfig.IPAddr[2], NWConfig.IPAddr[3]); // TDBG ( "Device Name : %s\n", (char *)&NWConfig.IFName); // nRet = SendGratuitousARPPacket((char *)&NWConfig.IFName, NWConfig.IPAddr, NWConfig.MAC); // if (0 != nRet) // { // TCRIT("Gratuitous ARP thread exits : Unable to Send Gratuitous ARP packet\n"); // break; // } // TDBG ("Send Gratuitous Packet\n"); // if (0 == pBMCInfo->LANCfs[EthIndex].GratitousARPInterval) // { // IntervalInSec = 2; //Default 2 secs // } else { // // Gratuitous ARP interval in 500 millisecond increments. // IntervalInSec = (pBMCInfo->LANCfs[EthIndex].GratitousARPInterval * 500)/1000; // } // usleep( IntervalInSec * 1000 * 1000 ); // } // return 0; // } /*--------------------------------------------------- * GetLanConfigParam *---------------------------------------------------*/ int GetLanConfigParam ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes) { GetLanConfigReq_T* pGetLanReq = ( GetLanConfigReq_T*) pReq; GetLanConfigRes_T* pGetLanRes = ( GetLanConfigRes_T*) pRes; uint8_t EthIndex; char IfcName[16]; /* Eth interface name */ pGetLanRes->CCParamRev.CompletionCode = CC_NORMAL; pGetLanRes->CCParamRev.ParamRevision = PARAMETER_REVISION_FORMAT; // printf("---> channel: %d, parameter: %#x, setslect: %#x, blockselect: %#x\n", pGetLanReq->ChannelNum, pGetLanReq->ParameterSelect, pGetLanReq->SetSelect, pGetLanReq->BlockSelect); if(pGetLanReq->ChannelNum & RESERVED_VALUE_70) { /* Alarm !!! Somebody is trying to set Reseved Bits */ *pRes = CC_INV_DATA_FIELD; return sizeof (*pRes); } //! Validate the SetSelector value. if (0x00 != pGetLanReq->SetSelect) { printf("---> SetSelector not support!\n"); *pRes = CC_INV_DATA_FIELD; return sizeof (*pRes); } //! Validate the BlockSelector value. if (0x00 != pGetLanReq->BlockSelect) { printf("---> BlockSelector not support!\n"); *pRes = CC_INV_DATA_FIELD; return sizeof (*pRes); } EthIndex= 0; sprintf(IfcName, "eth%d", EthIndex); if ((pGetLanReq->ChannelNum & GET_PARAMETER_REVISION_MASK) != 0) { if(MAX_LAN_CONF_PARAM >= pGetLanReq->ParameterSelect) { return sizeof(GetLanCCRev_T); } else { *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof (*pRes); } } else { printf("GetLanConfigParam log4\n"); switch(pGetLanReq->ParameterSelect) { case LAN_PARAM_SET_IN_PROGRESS: pGetLanRes->ConfigData.SetInProgress = 0; break; case LAN_PARAM_AUTH_TYPE_SUPPORT: pGetLanRes->ConfigData.AuthTypeSupport = 0x04; //only support MD5 break; case LAN_PARAM_AUTH_TYPE_ENABLES: pGetLanRes->ConfigData.AuthTypeEnables.AuthTypeCallBack = 0x04; //MD5 pGetLanRes->ConfigData.AuthTypeEnables.AuthTypeUser = 0x04; pGetLanRes->ConfigData.AuthTypeEnables.AuthTypeOperator = 0x04; pGetLanRes->ConfigData.AuthTypeEnables.AuthTypeAdmin = 0x04; pGetLanRes->ConfigData.AuthTypeEnables.AuthTypeOem = 0x04; break; case LAN_PARAM_IP_ADDRESS: pGetLanRes->ConfigData.IPAddr[0] = g_BMCInfo.IpmiConfig.LanInfo[EthIndex].IPAddr[0]; pGetLanRes->ConfigData.IPAddr[1] = g_BMCInfo.IpmiConfig.LanInfo[EthIndex].IPAddr[1]; pGetLanRes->ConfigData.IPAddr[2] = g_BMCInfo.IpmiConfig.LanInfo[EthIndex].IPAddr[2]; pGetLanRes->ConfigData.IPAddr[3] = g_BMCInfo.IpmiConfig.LanInfo[EthIndex].IPAddr[3]; break; case LAN_PARAM_IP_ADDRESS_SOURCE: pGetLanRes->ConfigData.IPAddrSrc = 1; //static break; case LAN_PARAM_MAC_ADDRESS: pGetLanRes->ConfigData.MACAddr[0] = g_BMCInfo.IpmiConfig.LanInfo[EthIndex].MACAddr[0]; pGetLanRes->ConfigData.MACAddr[1] = g_BMCInfo.IpmiConfig.LanInfo[EthIndex].MACAddr[1]; pGetLanRes->ConfigData.MACAddr[2] = g_BMCInfo.IpmiConfig.LanInfo[EthIndex].MACAddr[2]; pGetLanRes->ConfigData.MACAddr[3] = g_BMCInfo.IpmiConfig.LanInfo[EthIndex].MACAddr[3]; pGetLanRes->ConfigData.MACAddr[4] = g_BMCInfo.IpmiConfig.LanInfo[EthIndex].MACAddr[4]; pGetLanRes->ConfigData.MACAddr[5] = g_BMCInfo.IpmiConfig.LanInfo[EthIndex].MACAddr[5]; break; case LAN_PARAM_SUBNET_MASK: pGetLanRes->ConfigData.SubNetMask[0] = g_BMCInfo.IpmiConfig.LanInfo[EthIndex].NetMask[0]; pGetLanRes->ConfigData.SubNetMask[1] = g_BMCInfo.IpmiConfig.LanInfo[EthIndex].NetMask[1]; pGetLanRes->ConfigData.SubNetMask[2] = g_BMCInfo.IpmiConfig.LanInfo[EthIndex].NetMask[2]; pGetLanRes->ConfigData.SubNetMask[3] = g_BMCInfo.IpmiConfig.LanInfo[EthIndex].NetMask[3]; break; case LAN_PARAM_IPv4_HEADER: //下面这些参数是多少不知道，参考LanIfc.c的SetIPv4Header函数。 pGetLanRes->ConfigData.Ipv4HdrParam.TimeToLive = 64; pGetLanRes->ConfigData.Ipv4HdrParam.IpHeaderFlags = 0; pGetLanRes->ConfigData.Ipv4HdrParam.TypeOfService = 0x10; //default break; case LAN_PARAM_PRI_RMCP_PORT: pGetLanRes->ConfigData.PrimaryRMCPPort = LAN_RMCP_PORT; //LSB first break; case LAN_PARAM_SEC_RMCP_PORT: *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof (uint8_t); break; case LAN_PARAM_BMC_GENERATED_ARP_CONTROL: pGetLanRes->ConfigData.BMCGeneratedARPControl = 0; break; case LAN_PARAM_GRATITIOUS_ARP_INTERVAL: pGetLanRes->ConfigData.GratitousARPInterval = 4; //4*500ms break; case LAN_PARAM_DEFAULT_GATEWAY_IP: pGetLanRes->ConfigData.DefaultGatewayIPAddr[0] = g_BMCInfo.IpmiConfig.LanInfo[EthIndex].DefaultGW[0]; pGetLanRes->ConfigData.DefaultGatewayIPAddr[1] = g_BMCInfo.IpmiConfig.LanInfo[EthIndex].DefaultGW[1]; pGetLanRes->ConfigData.DefaultGatewayIPAddr[2] = g_BMCInfo.IpmiConfig.LanInfo[EthIndex].DefaultGW[2]; pGetLanRes->ConfigData.DefaultGatewayIPAddr[3] = g_BMCInfo.IpmiConfig.LanInfo[EthIndex].DefaultGW[3]; break; case LAN_PARAM_DEFAULT_GATEWAY_MAC: //这个参数提供不了。 *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof (uint8_t); break; case LAN_PARAM_BACKUP_GATEWAY_IP: *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof (uint8_t); break; case LAN_PARAM_BACKUP_GATEWAY_MAC: *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof (uint8_t); break; case LAN_PARAM_COMMUNITY_STRING: sprintf(pGetLanRes->ConfigData.CommunityStr,"public"); break; case LAN_PARAM_DEST_NUM: pGetLanRes->ConfigData.NumDest = 0; break; case LAN_PARAM_SELECT_DEST_TYPE: *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof (uint8_t); break; case LAN_PARAM_SELECT_DEST_ADDR: *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof (uint8_t); break; case LAN_PARAM_VLAN_ID: *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof (uint8_t); break; case LAN_PARAM_VLAN_PRIORITY: *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof (uint8_t); break; case LAN_PARAM_CIPHER_SUITE_ENTRY_SUP: *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof (uint8_t); break; case LAN_PARAM_CIPHER_SUITE_ENTRIES: *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof (uint8_t); break; case LAN_PARAM_CIPHER_SUITE_PRIV_LEVELS: *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof (uint8_t); break; case LAN_PARAM_VLAN_TAGS: *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof (uint8_t); break; default: *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof(uint8_t); break; } } return sizeof(GetLanCCRev_T) + LanconfigParameterLength[pGetLanReq->ParameterSelect]; } // /*--------------------------------------------------- // * SuspendBMCArps // *---------------------------------------------------*/ // int // SuspendBMCArps ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes, int BMCInst) // { // SuspendBMCArpsReq_T* pArpReq = ( SuspendBMCArpsReq_T*) pReq; // SuspendBMCArpsRes_T* pArpRes = ( SuspendBMCArpsRes_T*) pRes; // uint8_t EthIndex; // /* Verify Channel ID */ // pArpRes->CompletionCode = CC_INV_DATA_FIELD; // if(pArpReq->ChannelNo & RESERVED_BITS_SUSPENDBMCARPS) return sizeof(*pRes); // if (!IsLANChannel(pArpReq->ChannelNo & CHANNEL_ID_MASK, BMCInst) ) // { // return sizeof (*pRes); // } // EthIndex= GetEthIndex(pArpReq->ChannelNo & 0x0F,BMCInst); // if(0xff == EthIndex) // { // return sizeof (*pRes); // } // /* Reserved Bits Validation */ // if (0 != (SUSPEND_ARP_RSVD_BIT_MASK & pArpReq->ArpSuspend)) // { // return sizeof (*pRes); // } // if (BMC_GET_SHARED_MEM(BMCInst)->IsWDTRunning == TRUE) // BMC_GET_SHARED_MEM(BMCInst)->ArpSuspendStatus[EthIndex] = pArpReq->ArpSuspend; // /* Update Response */ // pArpRes->CompletionCode = CC_NORMAL; // pArpRes->ArpSuspendStatus = UpdateArpStatus(EthIndex, BMC_GET_SHARED_MEM(BMCInst)->IsWDTRunning, BMCInst); // return sizeof (SuspendBMCArpsRes_T); // } // /*--------------------------------------------------- // * GetIPUDPRMCPStats // *---------------------------------------------------*/ // int // GetIPUDPRMCPStats ( uint8_t* pReq, uint8_t ReqLen, uint8_t* pRes, int BMCInst) // { // GetIPUDPRMCPStatsReq_T* pGetIPUDPRMCPStatsReq = ( GetIPUDPRMCPStatsReq_T*) pReq; // GetIPUDPRMCPStatsRes_T* pGetIPUDPRMCPStatsRes = ( GetIPUDPRMCPStatsRes_T*) pRes; // BMCSharedMem_T* pSharedMem = BMC_GET_SHARED_MEM (BMCInst); // FILE *fptr; // char FDRead[512], FSRead[512]; // char *result = NULL; // char **StrArray; // int count = 0; // int cStrings =0; // if(pGetIPUDPRMCPStatsReq->ChannelNo & RESERVED_BITS_GETIPUDPRMCPSTATS_CH) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(*pRes); // } // if(pGetIPUDPRMCPStatsReq->ClearStatus & RESERVED_BITS_GETIPUDPRMCPSTATS_CLRSTATE) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(*pRes); // } // //Channel number [3:0] is valid. // if ( !IsLANChannel(pGetIPUDPRMCPStatsReq->ChannelNo & CHANNEL_ID_MASK, BMCInst) ) // { // pGetIPUDPRMCPStatsRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // //Clear the statistics if 1 is given in request. // if ( pGetIPUDPRMCPStatsReq->ClearStatus & 0x01 ) // { // /* // * Have to clear the already stored statistics when clear req is 1. // */ // pGetIPUDPRMCPStatsRes->CompletionCode = CC_NORMAL; // return sizeof (uint8_t); // } // //All Statistics values are initialised to 0. // memset (pGetIPUDPRMCPStatsRes, 0, sizeof(GetIPUDPRMCPStatsRes_T) ); // //All the datas are taken from /proc/net/snmp file // fptr = fopen ("/proc/net/snmp","r+"); // if (fptr == NULL) // { // pGetIPUDPRMCPStatsRes->CompletionCode = CC_COULD_NOT_PROVIDE_RESP; // return sizeof (uint8_t); // } // while( NULL != fgets(FDRead,512,fptr) ) // { // if ( NULL != strstr (FDRead, "Ip: ") ) // { // count++; // if (count == 2) // { // //To find the no. of valid strings in a line. // strcpy (FSRead, FDRead); // result = strtok( FSRead, " " ); // while( result != NULL ) // { // cStrings++; // result = strtok( NULL, " " ); // } // //Condition to check so that explode doesnt try to read the strings from unknown location. // if ( cStrings == 20) // { // StrArray = explode (' ', FDRead); // } // else // { // pGetIPUDPRMCPStatsRes->CompletionCode = CC_NORMAL; // return sizeof (uint8_t); // } // //All Statistics stops acumulating at FFFFh unless otherwise noted. // //IP packets received. // if ( atol((char *)StrArray[3]) > 0xffff) // pGetIPUDPRMCPStatsRes->IPPacketsRecv = ( ( atol((char *)StrArray[3]) ) % 65535); // else // pGetIPUDPRMCPStatsRes->IPPacketsRecv = atoi((char *)StrArray[3]); // //IP Header Error. // pGetIPUDPRMCPStatsRes->IPHeaderErr = atoi((char *)StrArray[4]); // //IP Address Error. // if ( atol((char *)StrArray[5]) > 0xffff) // pGetIPUDPRMCPStatsRes->IPAddrErr = ( ( atol((char *)StrArray[5]) ) % 65535); // else // pGetIPUDPRMCPStatsRes->IPAddrErr = atoi((char *)StrArray[5]); // //Fragmented IP Packets received. // if ( atol((char *)StrArray[17]) > 0xffff) // pGetIPUDPRMCPStatsRes->FragIPPacketsRecv = ( ( atol((char *)StrArray[17]) ) % 65535); // else // pGetIPUDPRMCPStatsRes->FragIPPacketsRecv = atoi((char *)StrArray[17]); // //IP packets Transmitted. // if ( atol((char *)StrArray[10]) > 0xffff) // pGetIPUDPRMCPStatsRes->IPPacketsTrans = ( ( atol((char *)StrArray[10]) ) % 65535); // else // pGetIPUDPRMCPStatsRes->IPPacketsTrans = atoi((char *)StrArray[10]); // count = 0; // } // } // if ( NULL != strstr (FDRead, "Udp: ") ) // { // count++; // if (count == 2) // { // //To find the no. of valid strings in a line. // cStrings = 0; // strcpy (FSRead, FDRead); // result = strtok( FSRead, " " ); // while( result != NULL ) // { // cStrings++; // result = strtok( NULL, " " ); // } // //Condition to check so that explode doesnt try to read the strings beyond the valid location. // if ( cStrings == 5) // { // StrArray = explode (' ', FDRead); // } // else // { // pGetIPUDPRMCPStatsRes->CompletionCode = CC_NORMAL; // return sizeof (uint8_t); // } // //UDP packets received. // if ( atol((char *)StrArray[1]) > 0xffff) // pGetIPUDPRMCPStatsRes->UDPPacketsRecv = ( ( atol((char *)StrArray[1]) ) % 65535); // else // pGetIPUDPRMCPStatsRes->UDPPacketsRecv = atoi((char *)StrArray[1]); // count = 0; // } // } // } // fclose(fptr); // //Valid RMCP packets received. // pGetIPUDPRMCPStatsRes->ValidRMCPPackets = pSharedMem->gIPUDPRMCPStats; // //To store the statistics across the system reset and power cycles // pGetIPUDPRMCPStatsRes->CompletionCode = CC_NORMAL; // return sizeof (GetIPUDPRMCPStatsRes_T); // } // /*----------------------------------------------------- // * explode // * Funntion to split the strings and store in an array // *-----------------------------------------------------*/ // char **explode(char separator, char *string) // { // int start = 0, i, k = 1, count = 2; // char **strarr; // for (i = 0; string[i] != '\0'; i++) // /* how many rows do we need for our array? */ // if (string[i] == separator) // count++; // /* count is at least 2 to make room for the entire string // * * and the ending NULL */ // strarr = malloc(count * sizeof(char*)); // i = 0; // while (*string++ != '\0') // { // if (*string == separator) // { // strarr[i] = malloc(k - start + 2); // strncpy(strarr[i], string - k + start, k - start + 1); // strarr[i][k - start + 1] = '\0'; /* guarantee null termination */ // start = k; // i++; // } // k++; // } // /* copy the last part of the string after the last separator */ // strarr[i] = malloc(k - start); // strncpy(strarr[i], string - k + start, k - start - 1); // strarr[i][k - start - 1] = '\0'; /* guarantee null termination */ // strarr[++i] = NULL; // return strarr; // } // /*---------------------------------------------- // * UpdateArpStatus // *----------------------------------------------*/ // uint8_t // UpdateArpStatus (uint8_t EthIndex,BOOL IsTimerRunning, int BMCInst) // { // uint8_t GratArpSuspend; // uint8_t ArpSuspend; // uint8_t Status; // BMCInfo_t *pBMCInfo = &g_BMCInfo[BMCInst]; // char Cmds[50]={0}; // command string to perform BMC-generated ARP // char IfcName[16]; // IPMI_DBG_PRINT_1 ("Timer - %x", IsTimerRunning); // GratArpSuspend = ArpSuspend = 1; // // Check Gratuitous ARP is Enabled // if (0 == (pBMCInfo->LANCfs[EthIndex].BMCGeneratedARPControl & GRATIUTOUS_ENABLE_MASK)) // { // GratArpSuspend = 0; // } // // Check ARP Response is Enabled // if (0 == (pBMCInfo->LANCfs[EthIndex].BMCGeneratedARPControl & ENABLE_ARP_RESPONSES)) // { // ArpSuspend = 0; // } // /*Disable ARP */ // if (TRUE == IsTimerRunning) // { // /* WDT is running, check and suspend ARP if necessary */ // if( (0 != (BMC_GET_SHARED_MEM(BMCInst)->ArpSuspendStatus[EthIndex] & SUSPEND_GRAT_ARP)) && // (0 < GratArpSuspend) ) // { // GratArpSuspend--; // } // if( (0 != (BMC_GET_SHARED_MEM(BMCInst)->ArpSuspendStatus[EthIndex] & SUSPEND_ARP)) && // (0 < ArpSuspend) ) // { // ArpSuspend--; // } // } // memset(IfcName,0,sizeof(IfcName)); // if(GetIfcName(EthIndex, IfcName, BMCInst) != 0) // { // TCRIT("Error in getting Interface Name for the Lan Index :%d\n", EthIndex); // } // else // { // /* Perform commands for BMC-generated Arp */ // memset(Cmds, 0, sizeof(Cmds)); // sprintf(Cmds, "/usr/local/bin/ArpSwitch.sh %s %d", IfcName, (!ArpSuspend) ? ARP_IGNORE_ON : ARP_IGNORE_OFF); // safe_system (Cmds); // /* Perform commands for BMC-generated Arp ends */ // } // /* Update Status */ // Status = ArpSuspend << 1; // Status = Status | GratArpSuspend; // return Status; // } // /** // *@fn NwInterfacePresenceCheck // *@brief This function is invoked to check network interface presence // *@param Interface - Char Pointer to Interface for which interface to check // *@return Returns 0 on success // */ // static int // NwInterfacePresenceCheck (char * Interface) // { // int r; // int sockdes; // struct ifreq Ifreq; // unsigned char MAC[MAC_ADDR_LEN]; // IPMI_DBG_PRINT_1 ("Checking the presence of %s\n", Interface); // sockdes = socket(PF_INET, SOCK_DGRAM, 0 ); // if ( sockdes < 0 ) // { // IPMI_ERROR("can't open socket: %s\n",strerror(errno)); // return -1; // } // /* Get MAC address */ // memset(&Ifreq,0,sizeof(struct ifreq)); // memset(MAC, 0, MAC_ADDR_LEN); // strcpy(Ifreq.ifr_name, Interface); // Ifreq.ifr_hwaddr.sa_family = AF_INET; // r = ioctl(sockdes, SIOCGIFHWADDR, &Ifreq); // close (sockdes); // if ( r < 0 ) // { // //IPMI_ERROR("IOCTL to get MAC failed: %d\n",r); // return -1; // } // IPMI_DBG_PRINT_1 (" %s Interface is present\n", Interface); // return 0; // }