/***************************************************************** ***************************************************************** *** ** *** (C)Copyright 2005-2006, American Megatrends Inc. ** *** ** *** All Rights Reserved. ** *** ** *** 6145-F, Northbelt Parkway, Norcross, ** *** ** *** Georgia - 30071, USA. Phone-(770)-246-8600. ** *** ** ***************************************************************** ****************************************************************** * * lanconfig.c * Lan Configuration functions. * * Author: Bakka Ravinder Reddy * ******************************************************************/ #define ENABLE_DEBUG_MACROS 0 #include "IPMIConf.h" #include "LANConfig.h" #include "MsgHndlr.h" #include "Debug.h" #include "Support.h" #include "IPMI_LANConfig.h" #include "PMConfig.h" #include "SharedMem.h" #include "IPMIDefs.h" #include "NVRAccess.h" #include "Util.h" #include "Session.h" #include "WDT.h" #include "LANIfc.h" #include "AppDevice.h" #include "RMCP+.h" #include "IPMI_Main.h" #include "IPMI_LANConfig.h" #include "nwcfg.h" #include "PendTask.h" #include "Ciphertable.h" #include "Ethaddr.h" #include "sendarp.h" #include "PDKAccess.h" #include "Message.h" #include #include "Badpasswd.h" #include "libncsiconf.h" #include #include #include #include "featuredef.h" #include #include #include "safesystem.h" #include "bmc_type.h" /* 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 ***/ //_FAR_ INT8U m_ArpSuspendReq; char **explode(char separator, char *string); int IPAddrCheck(INT8U *Addr,int params); extern int GetLanAMIParamValue (INT8U* ParamSelect, INT8U* ImpType); //extern IfcName_T Ifcnametable[MAX_LAN_CHANNELS]; #define MAX_LAN_PARAMS_DATA 20 typedef struct { INT8U Params; INT8U ReservedBits [MAX_LAN_PARAMS_DATA]; INT8U 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 { INT8U OEMParam; INT8U 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 INT8U 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 INT8U 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 BOOL enableSetMACAddr = FALSE; /*------------------------------------------------------- * SetLanConfigParam *-------------------------------------------------------*/ int SetLanConfigParam (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { _NEAR_ SetLanConfigReq_T* pSetLanReq = (_NEAR_ SetLanConfigReq_T*) pReq; _NEAR_ SetLanConfigRes_T* pSetLanRes = (_NEAR_ SetLanConfigRes_T*) pRes; _FAR_ BMCSharedMem_T* pSharedMem = BMC_GET_SHARED_MEM (BMCInst); _FAR_ ChannelInfo_T* ptrChannelInfo; _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; NWCFG_STRUCT NWConfig; NWCFG6_STRUCT NWConfig6; INT32U GWIp,IPAddr; INT32U Subnetmask; int i,j=0; INT8U IsOemDefined = FALSE; INT8U EthIndex,netindex= 0xFF, currBmcGenArpCtrl; BMCArg *pLANArg=NULL; char VLANInterfaceName [32]; INT16U vlanID=0; INT16U InvalidVlanID[3]={0,1,4095}; char cmdSetPriority[32]; int retValue=0,NIC_Count = 0; INT16U PriorityLevel[MAX_LAN_CHANNELS]= {0}; INT8U m_Lan_SetInProgress; /**< Contains setting LAN configuration status */ ETHCFG_STRUCT PHYCfg; static INT8U macEthIndex = 0xFF; INT8U TOS = 0, SkbPriority = 0; /* For VLAN priority parameter */ int pendStatus = PEND_STATUS_COMPLETED; char IfcName[16]; /* Eth interface name */ if ( ReqLen >= 2 ) { ReqLen -= 2; } else { *pRes = CC_REQ_INV_LEN; return sizeof (INT8U); } if(g_corefeatures.dual_image_support == ENABLED) { if(IsCardInFlashMode()) { IPMI_WARNING("Card in Active flash mode, Not safe to set any of LAN configurations...\n"); *pRes = CC_DEV_IN_FIRMWARE_UPDATE_MODE; return sizeof (*pRes); } } EthIndex= GetEthIndex(pSetLanReq->ChannelNum & 0x0F, BMCInst); if(0xff == EthIndex) { *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } memset(IfcName,0,sizeof(IfcName)); /*Get the EthIndex*/ if(GetIfcName(EthIndex,IfcName, BMCInst) == -1) { TCRIT("Error in Getting Ifc name\n"); *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } for(i=0;iParameterSelect >= 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(INT8U); } /* Hook for OEM to handle this parameter */ if ( (IsOemDefined) && (g_PDKHandle[PDK_SETLANOEMPARAM] != NULL) ) { return ((int(*)(INT8U *, INT8U, INT8U *,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 (INT8U); } } /*Check the Request length for OEM parameter*/ for(i=0;iParameterSelect) { if(ReqLen != m_OEMParamLen[i].Length) { *pRes = CC_REQ_INV_LEN; return sizeof(INT8U); } } } if(pSetLanReq->ChannelNum & RESERVED_VALUE_F0) { /* Alarm !!! Somebody is trying to set Reseved Bits */ *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); } IPMI_DBG_PRINT_1 ("Parameter = %X\n", pSetLanReq->ParameterSelect); if (g_PDKHandle[PDK_BEFORESETLANPARM] != NULL ) { retValue = ((int(*)(INT8U *, INT8U, INT8U *,int))(g_PDKHandle[PDK_BEFORESETLANPARM]))(pReq, ReqLen, pRes, BMCInst); if(retValue != 0) { return retValue; } } if((pSetLanReq->ParameterSelect == LAN_PARAM_SELECT_DEST_ADDR) || (pSetLanReq->ParameterSelect == LAN_PARAMS_AMI_OEM_SNMPV6_DEST_ADDR)) { /*Destination Address is allowed to configure only if DestType is LAN_PET_TRAP(SNMP alerts types)*/ if(pBMCInfo->LANCfs[EthIndex].DestType [pSetLanReq->ConfigData.DestAddr.SetSelect - 1].DestType == LAN_OEM1_ALERT) { *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } } switch (pSetLanReq->ParameterSelect) { case LAN_PARAM_SET_IN_PROGRESS: LOCK_BMC_SHARED_MEM(BMCInst); m_Lan_SetInProgress = BMC_GET_SHARED_MEM(BMCInst)->m_Lan_SetInProgress; UNLOCK_BMC_SHARED_MEM(BMCInst); /* 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); } LOCK_BMC_SHARED_MEM(BMCInst); BMC_GET_SHARED_MEM(BMCInst)->m_Lan_SetInProgress = pSetLanReq->ConfigData.SetInProgress; UNLOCK_BMC_SHARED_MEM(BMCInst); break; case LAN_PARAM_AUTH_TYPE_SUPPORT: pSetLanRes->CompletionCode = CC_ATTEMPT_TO_SET_RO_PARAM; return sizeof(*pRes); case LAN_PARAM_AUTH_TYPE_ENABLES: 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: pendStatus = GetPendStatus(PEND_OP_SET_IP); if(pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } //we need to do a read in hte pend task and not here // because if pend task is still working on setting the source for example t- by then we would have got the // next command which is ip address and then we would read back DHCP since nwcfg hasnt done its work yet etc. and all hell will breakloose. //nwReadNWCfg (&NWConfig); if(pBMCInfo->LANCfs[EthIndex].IPAddrSrc == DHCP_IP_SOURCE) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } nwReadNWCfg_v4_v6( &NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); if(memcmp ( NWConfig.IPAddr, pSetLanReq->ConfigData.IPAddr, IP_ADDR_LEN ) == 0) { TCRIT("Same IP address, do nothing\n"); _fmemcpy (pBMCInfo->LANCfs[EthIndex].IPAddr, pSetLanReq->ConfigData.IPAddr, IP_ADDR_LEN); break; } if(IPAddrCheck(pSetLanReq->ConfigData.IPAddr,LAN_PARAM_IP_ADDRESS)) { *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } pendStatus = GetPendStatus(PEND_OP_SET_IP); if(pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } _fmemcpy (NWConfig.IPAddr, pSetLanReq->ConfigData.IPAddr, IP_ADDR_LEN); SetPendStatus(PEND_OP_SET_IP,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_IP,(INT8U*)&NWConfig,sizeof(NWConfig),(pSetLanReq->ChannelNum & 0x0F),BMCInst); _fmemcpy (pBMCInfo->LANCfs[EthIndex].IPAddr, pSetLanReq->ConfigData.IPAddr, IP_ADDR_LEN); //nwWriteNWCfg (&NWConfig); break; case LAN_PARAM_IP_ADDRESS_SOURCE: if ((pSetLanReq->ConfigData.IPAddrSrc > BMC_OTHER_SOURCE) ||(pSetLanReq->ConfigData.IPAddrSrc == UNSPECIFIED_IP_SOURCE)) { *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } if ( pBMCInfo->LANCfs[EthIndex].IPAddrSrc == pSetLanReq->ConfigData.IPAddrSrc ) { TCRIT("LAN or VLAN if current SRC is DHCP/Static and incoming SRC is DHCP/Static, do nothing\n"); break; } if(!((pSetLanReq->ConfigData.IPAddrSrc == STATIC_IP_SOURCE ) || (pSetLanReq->ConfigData.IPAddrSrc == DHCP_IP_SOURCE ))) pBMCInfo->LANCfs[EthIndex].IPAddrSrc = pSetLanReq->ConfigData.IPAddrSrc ; if ( (pSetLanReq->ConfigData.IPAddrSrc == STATIC_IP_SOURCE ) || (pSetLanReq->ConfigData.IPAddrSrc == DHCP_IP_SOURCE ) ) { pendStatus = GetPendStatus(PEND_OP_SET_SOURCE); if(pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } pBMCInfo->LANCfs[EthIndex].IPAddrSrc = pSetLanReq->ConfigData.IPAddrSrc ; NWConfig.CfgMethod = pSetLanReq->ConfigData.IPAddrSrc; SetPendStatus(PEND_OP_SET_SOURCE,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_SOURCE,(INT8U*) &NWConfig,sizeof(NWConfig),(pSetLanReq->ChannelNum & 0x0F), BMCInst ); } else if(pSetLanReq->ConfigData.IPAddrSrc == BIOS_IP_SOURCE) { /*Perform OEM action*/ if(g_PDKHandle[PDK_BIOSIPSOURCE] != NULL) { retValue = ((int(*)(INT8U))g_PDKHandle[PDK_BIOSIPSOURCE]) (pSetLanReq->ChannelNum & CHANNEL_ID_MASK); if(retValue == 1) { *pRes = CC_INV_DATA_FIELD; return sizeof (*pRes); } } else { pendStatus = GetPendStatus(PEND_OP_SET_SOURCE); if(pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } NWConfig.CfgMethod = STATIC_IP_SOURCE; SetPendStatus(PEND_OP_SET_SOURCE,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_SOURCE, (INT8U*) &NWConfig,sizeof(NWConfig), (pSetLanReq->ChannelNum & CHANNEL_ID_MASK), BMCInst ); } } else if(pSetLanReq->ConfigData.IPAddrSrc == BMC_OTHER_SOURCE) { /*Perform OEM action*/ if(g_PDKHandle[PDK_BMCOTHERSOURCEIP] != NULL) { retValue = ((int(*)(INT8U))g_PDKHandle[PDK_BMCOTHERSOURCEIP]) (pSetLanReq->ChannelNum & CHANNEL_ID_MASK); if(retValue == 1) { *pRes = CC_INV_DATA_FIELD; return sizeof (*pRes); } } else { *pRes = CC_INV_DATA_FIELD; return sizeof (*pRes); } } break; case LAN_PARAM_MAC_ADDRESS: #if 0 nwReadNWCfg (&NWConfig); printf ( "The MAC is %x %x %x %x %x %x \n", NWConfig.MAC [0],NWConfig.MAC [1],NWConfig.MAC [2],NWConfig.MAC [3],NWConfig.MAC [4],NWConfig.MAC [5] ); _fmemcpy (NWConfig.MAC, pSetLanReq->ConfigData.MACAddr, MAC_ADDR_LEN); printf ( "The MAC is %x %x %x %x %x %x \n", NWConfig.MAC [0],NWConfig.MAC [1],NWConfig.MAC [2],NWConfig.MAC [3],NWConfig.MAC [4],NWConfig.MAC [5] ); nwWriteNWCfg (&NWConfig); #else /* 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 (!enableSetMACAddr) pSetLanRes->CompletionCode = CC_ATTEMPT_TO_SET_RO_PARAM; else { EnableSetMACAddress_T macAddrEnabled; INT8U InvalidMac[MAC_ADDR_LEN] = {0}; if((pSetLanReq->ConfigData.MACAddr[0]& BIT0)|| (memcmp(&InvalidMac,&pSetLanReq->ConfigData.MACAddr,MAC_ADDR_LEN) == 0)) { pSetLanRes->CompletionCode = CC_INV_DATA_FIELD; return sizeof(INT8U); } memset(&macAddrEnabled, 0, sizeof(EnableSetMACAddress_T)); macAddrEnabled.EthIndex = macEthIndex; memcpy(&macAddrEnabled.MACAddress, &pSetLanReq->ConfigData.MACAddr, MAC_ADDR_LEN); pendStatus = GetPendStatus(PEND_OP_SET_MAC_ADDRESS); if(pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } SetPendStatus(PEND_OP_SET_MAC_ADDRESS, PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_MAC_ADDRESS, (INT8U*)&macAddrEnabled, sizeof(EnableSetMACAddress_T), (pSetLanReq->ChannelNum & 0x0F), BMCInst); enableSetMACAddr = FALSE; macEthIndex = 0xFF; pSetLanRes->CompletionCode = CC_NORMAL; } return sizeof(*pSetLanRes); #endif case LAN_PARAM_SUBNET_MASK: pendStatus = GetPendStatus(PEND_OP_SET_SUBNET); if(pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } /*Returning valid completion code in case of attempt to set netmask in DHCP mode */ if(pBMCInfo->LANCfs[EthIndex].IPAddrSrc == DHCP_IP_SOURCE) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } nwReadNWCfg_v4_v6( &NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); if(memcmp ( NWConfig.Mask, pSetLanReq->ConfigData.SubNetMask, IP_ADDR_LEN ) == 0) { TCRIT("Same Mask, do nothing\n"); _fmemcpy (pBMCInfo->LANCfs[EthIndex].SubNetMask, pSetLanReq->ConfigData.SubNetMask, IP_ADDR_LEN); break; } if(IPAddrCheck(pSetLanReq->ConfigData.SubNetMask,LAN_PARAM_SUBNET_MASK)) { *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } _fmemcpy (NWConfig.Mask, pSetLanReq->ConfigData.SubNetMask, IP_ADDR_LEN); SetPendStatus(PEND_OP_SET_SUBNET,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_SUBNET,(INT8U*)&NWConfig,sizeof(NWConfig),(pSetLanReq->ChannelNum & 0x0F) , BMCInst); _fmemcpy (pBMCInfo->LANCfs[EthIndex].SubNetMask, pSetLanReq->ConfigData.SubNetMask, IP_ADDR_LEN); break; case LAN_PARAM_IPv4_HEADER: pendStatus = GetPendStatus(PEND_OP_SET_IPV4_HEADERS); if(pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } if(!pSetLanReq->ConfigData.Ipv4HdrParam.TimeToLive > 0) { IPMI_DBG_PRINT("The requested IPv4 header(TTL) to set is invalid.\n"); *pRes = CC_PARAM_OUT_OF_RANGE; return sizeof(*pRes); } if(pSetLanReq->ConfigData.Ipv4HdrParam.IpHeaderFlags == 0x60) // Flags can be either of the values: DF(0x40) or MF(0x20) { IPMI_DBG_PRINT("The requested IPv4 header(Flags) to set is invalid.\n"); *pRes = CC_PARAM_OUT_OF_RANGE; return sizeof(*pRes); } LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (&pBMCInfo->LANCfs[EthIndex].Ipv4HdrParam, &pSetLanReq->ConfigData.Ipv4HdrParam, sizeof(IPv4HdrParams_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); SetPendStatus(PEND_OP_SET_IPV4_HEADERS,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_IPV4_HEADERS, (INT8U*)&(pSetLanReq->ConfigData.Ipv4HdrParam), sizeof(pSetLanReq->ConfigData.Ipv4HdrParam),(pSetLanReq->ChannelNum & 0x0F),BMCInst); break; case LAN_PARAM_PRI_RMCP_PORT: pendStatus = GetPendStatus(PEND_RMCP_PORT_CHANGE); if(pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } LOCK_BMC_SHARED_MEM(BMCInst); pBMCInfo->LANCfs[EthIndex].PrimaryRMCPPort = ipmitoh_u16 (pSetLanReq->ConfigData.PrimaryRMCPPort); UNLOCK_BMC_SHARED_MEM(BMCInst); SetPendStatus(PEND_RMCP_PORT_CHANGE,PEND_STATUS_PENDING); PostPendTask(PEND_RMCP_PORT_CHANGE,(INT8U*)&(pSetLanReq->ConfigData.PrimaryRMCPPort), sizeof(pSetLanReq->ConfigData.PrimaryRMCPPort),(pSetLanReq->ChannelNum & 0x0F),BMCInst); break; case LAN_PARAM_SEC_RMCP_PORT: /* Returning Invalid error message */ *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof (INT8U); /*pPMConfig->LANConfig[EthIndex].SecondaryPort = ipmitoh_u16 (pSetLanReq->ConfigData.SecondaryPort);*/ break; case LAN_PARAM_BMC_GENERATED_ARP_CONTROL: currBmcGenArpCtrl = pBMCInfo->LANCfs[EthIndex].BMCGeneratedARPControl; if(currBmcGenArpCtrl != pSetLanReq->ConfigData.BMCGeneratedARPControl) pBMCInfo->LANCfs[EthIndex].BMCGeneratedARPControl = pSetLanReq->ConfigData.BMCGeneratedARPControl; if((ENABLE_ARP_RESPONSES & currBmcGenArpCtrl) != (ENABLE_ARP_RESPONSES & pSetLanReq->ConfigData.BMCGeneratedARPControl)) { UpdateArpStatus(EthIndex, BMC_GET_SHARED_MEM(BMCInst)->IsWDTRunning, BMCInst); } if(!(GRATIUTOUS_ENABLE_MASK & currBmcGenArpCtrl) && (GRATIUTOUS_ENABLE_MASK & pSetLanReq->ConfigData.BMCGeneratedARPControl)) { /* Create a thread to Send Gratuitous ARP Packet */ pLANArg = malloc(sizeof(BMCArg)); pLANArg->BMCInst = BMCInst; pLANArg->Len = strlen((char *)&EthIndex); pLANArg->Argument = malloc(pLANArg->Len); memcpy(pLANArg->Argument,(char *)&EthIndex,pLANArg->Len); OS_CREATE_THREAD ((void *)GratuitousARPTask,(void *)pLANArg, NULL); } break; case LAN_PARAM_GRATITIOUS_ARP_INTERVAL: pBMCInfo->LANCfs[EthIndex].GratitousARPInterval = pSetLanReq->ConfigData.GratitousARPInterval; break; case LAN_PARAM_DEFAULT_GATEWAY_IP: pendStatus = GetPendStatus(PEND_OP_SET_GATEWAY); if(pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } /*Returning valid completion code in case of attempt to set default gateway ip in DHCP mode */ if(pBMCInfo->LANCfs[EthIndex].IPAddrSrc == DHCP_IP_SOURCE) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } nwReadNWCfg_v4_v6( &NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); if(memcmp ( NWConfig.Gateway, pSetLanReq->ConfigData.DefaultGatewayIPAddr, IP_ADDR_LEN ) == 0) { TCRIT("Same Gateway, do nothing\n"); _fmemcpy(pBMCInfo->LANCfs[EthIndex].DefaultGatewayIPAddr, pSetLanReq->ConfigData.DefaultGatewayIPAddr,IP_ADDR_LEN); break; } if(IPAddrCheck(pSetLanReq->ConfigData.DefaultGatewayIPAddr,LAN_PARAM_DEFAULT_GATEWAY_IP)) { *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } _fmemcpy ((INT8U*)&GWIp,pSetLanReq->ConfigData.DefaultGatewayIPAddr, IP_ADDR_LEN); _fmemcpy ((INT8U*)&Subnetmask,&NWConfig.Mask[0],IP_ADDR_LEN); _fmemcpy ((INT8U*)&IPAddr,&NWConfig.IPAddr[0], IP_ADDR_LEN); /* Allowing When the Default Gateway is Zero without validation to clear the Default Gateway */ if(GWIp != 0) { _fmemcpy ((INT8U*)&Subnetmask,pBMCInfo->LANCfs[EthIndex].SubNetMask,IP_ADDR_LEN); _fmemcpy ((INT8U*)&IPAddr,pBMCInfo->LANCfs[EthIndex].IPAddr, IP_ADDR_LEN); if((IPAddr & Subnetmask ) != (GWIp & Subnetmask)) { IPMI_DBG_PRINT("\n Default GatewayIP to set is not valid \n"); *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } } _fmemcpy (NWConfig.Gateway,pSetLanReq->ConfigData.DefaultGatewayIPAddr, IP_ADDR_LEN); LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy(pBMCInfo->LANCfs[EthIndex].DefaultGatewayIPAddr, pSetLanReq->ConfigData.DefaultGatewayIPAddr,IP_ADDR_LEN); UNLOCK_BMC_SHARED_MEM(BMCInst); SetPendStatus(PEND_OP_SET_GATEWAY,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_GATEWAY,(INT8U*)&NWConfig,sizeof(NWConfig),(pSetLanReq->ChannelNum & 0x0F), BMCInst ); 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: nwReadNWCfg_v4_v6( &NWConfig,&NWConfig6, netindex,g_corefeatures.global_ipv6); _fmemcpy ((INT8U*)&GWIp,pSetLanReq->ConfigData.BackupGatewayIPAddr, IP_ADDR_LEN); _fmemcpy ((INT8U*)&Subnetmask,&NWConfig.Mask[0],IP_ADDR_LEN); _fmemcpy ((INT8U*)&IPAddr,&NWConfig.IPAddr[0], IP_ADDR_LEN); if(GWIp != 0) { if((IPAddr & Subnetmask ) != (GWIp & Subnetmask)) { IPMI_DBG_PRINT("\n Backup GatewayIP to set is not valid \n"); *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } } LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (pBMCInfo->LANCfs[EthIndex].BackupGatewayIPAddr, pSetLanReq->ConfigData.BackupGatewayIPAddr, IP_ADDR_LEN); nwSetBkupGWyAddr(pSetLanReq->ConfigData.BackupGatewayIPAddr,netindex); UNLOCK_BMC_SHARED_MEM(BMCInst); break; case LAN_PARAM_BACKUP_GATEWAY_MAC: LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (pBMCInfo->LANCfs[EthIndex].BackupGatewayMACAddr, pSetLanReq->ConfigData.BackupGatewayMACAddr, MAC_ADDR_LEN); UNLOCK_BMC_SHARED_MEM(BMCInst); break; case LAN_PARAM_COMMUNITY_STRING: if (g_PDKHandle[PDK_SETSNMPCOMMUNITYNAME] != NULL ) { if(((int(*)(INT8U *, INT8U,int))(g_PDKHandle[PDK_SETSNMPCOMMUNITYNAME]))(pSetLanReq->ConfigData.CommunityStr,MAX_COMM_STRING_SIZE, BMCInst)==0) break; } OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->PefConfig.PEFSharedMemMutex, WAIT_INFINITE); _fmemcpy (pBMCInfo->LANCfs[EthIndex].CommunityStr, pSetLanReq->ConfigData.CommunityStr, MAX_COMM_STRING_SIZE); OS_THREAD_MUTEX_RELEASE(&pBMCInfo->PefConfig.PEFSharedMemMutex); break; case LAN_PARAM_DEST_NUM: pSetLanRes->CompletionCode = CC_ATTEMPT_TO_SET_RO_PARAM; return sizeof(INT8U); case LAN_PARAM_SELECT_DEST_TYPE: // if (pSetLanReq->ConfigData.DestType.SetSelect > NUM_LAN_DESTINATION) if (pSetLanReq->ConfigData.DestType.SetSelect > pBMCInfo->LANCfs[EthIndex].NumDest ) { *pRes = CC_PARAM_OUT_OF_RANGE; return sizeof (*pRes); } if (0 == pSetLanReq->ConfigData.DestType.SetSelect) { LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (&pSharedMem->VolLANDestType[EthIndex], &pSetLanReq->ConfigData.DestType, sizeof(LANDestType_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); } else { LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (&pBMCInfo->LANCfs[EthIndex].DestType [pSetLanReq->ConfigData.DestType.SetSelect - 1], &pSetLanReq->ConfigData.DestType, sizeof(LANDestType_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); } break; case LAN_PARAM_SELECT_DEST_ADDR: pendStatus = GetPendStatus(PEND_OP_SET_GATEWAY); if(pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } // if (pSetLanReq->ConfigData.DestAddr.SetSelect > NUM_LAN_DESTINATION) if (pSetLanReq->ConfigData.DestType.SetSelect > pBMCInfo->LANCfs[EthIndex].NumDest ) { *pRes = CC_PARAM_OUT_OF_RANGE ; return sizeof (*pRes); } if (0 == pSetLanReq->ConfigData.DestAddr.SetSelect) { LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (&pSharedMem->VolLANDest[EthIndex], &pSetLanReq->ConfigData.DestAddr, sizeof(LANDestAddr_T)); memset(pSharedMem->VolLANv6Dest,0,sizeof(LANDestv6Addr_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); } else { LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (&pBMCInfo->LANCfs[EthIndex].DestAddr [pSetLanReq->ConfigData.DestAddr.SetSelect - 1], &pSetLanReq->ConfigData.DestAddr, sizeof(LANDestAddr_T)); memset( &pBMCInfo->LANCfs[EthIndex].Destv6Addr [pSetLanReq->ConfigData.Destv6Addr.SetSelect -1], 0 , sizeof(LANDestv6Addr_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); } /* Setting BackupGw to DefaultGw as per request to send trap */ if(pSetLanReq->ConfigData.DestAddr.GateWayUse == 1) { IPMI_DBG_PRINT("Setting Backupgw to Defaultgwip as per Request \n"); nwReadNWCfg_v4_v6( &NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy(NWConfig.Gateway,pBMCInfo->LANCfs[EthIndex].BackupGatewayIPAddr,IP_ADDR_LEN); UNLOCK_BMC_SHARED_MEM(BMCInst); SetPendStatus(PEND_OP_SET_GATEWAY,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_GATEWAY,(INT8U*)&NWConfig,sizeof(NWConfig),(pSetLanReq->ChannelNum & 0x0F),BMCInst); } break; case LAN_PARAM_VLAN_ID: if( pBMCInfo->IpmiConfig.VLANIfcSupport == 1) { nwReadNWCfg_v4_v6( &NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); if((pSetLanReq->ConfigData.VLANID & VLAN_MASK_BIT) == VLAN_MASK_BIT) /* checks for VLAN enable bit*/ { pendStatus = GetPendStatus(PEND_OP_SET_VLAN_ID); if(pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } vlanID = (pSetLanReq->ConfigData.VLANID & 0xfff); /* get the vlan d from the data */ for(i=0;iChannelNum & 0x0F), BMCInst ); pBMCInfo->LANCfs[EthIndex].VLANPriority =0; } } NWConfig.VLANID=vlanID; SetPendStatus(PEND_OP_SET_VLAN_ID,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_VLAN_ID,(INT8U*)&NWConfig,sizeof(NWConfig),(pSetLanReq->ChannelNum & 0x0F), BMCInst ); pBMCInfo->LANCfs[EthIndex].VLANID = pSetLanReq->ConfigData.VLANID; } else /* Vlan Bit is Disabled */ { if(NWConfig.VLANID==0) /* Vlan id is disabled */ { if((pSetLanReq->ConfigData.VLANID & 0xfff)!=0) { pBMCInfo->LANCfs[EthIndex].VLANID = pSetLanReq->ConfigData.VLANID; } if((pSetLanReq->ConfigData.VLANID & 0xfff)==0) { if((pBMCInfo->LANCfs[EthIndex].VLANID & 0xfff)!=0) { pBMCInfo->LANCfs[EthIndex].VLANID = pSetLanReq->ConfigData.VLANID; } } } else /* Vlan ID is enable. so deconfigure it */ { memset(IfcName,0,sizeof(IfcName)); if(GetIfcName(EthIndex, IfcName,BMCInst) != 0) { TCRIT("Error in getting Interface Name for the Lan Index :%d\n",EthIndex); *pRes = CC_INV_DATA_FIELD ; return sizeof (*pRes); } sprintf(VLANInterfaceName, "%s.%d", IfcName, (int)(NWConfig.VLANID)); if (0 == NwInterfacePresenceCheck (VLANInterfaceName)) { pendStatus = GetPendStatus(PEND_OP_SET_VLAN_ID); if(pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } SetPendStatus(PEND_OP_DECONFIG_VLAN_IFC,PEND_STATUS_PENDING); PostPendTask(PEND_OP_DECONFIG_VLAN_IFC,(INT8U*)&NWConfig,sizeof(NWConfig),(pSetLanReq->ChannelNum & 0x0F), BMCInst ); pBMCInfo->LANCfs[EthIndex].VLANPriority =0; } pendStatus = GetPendStatus(PEND_OP_SET_SOURCE); if(pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } //NWConfig.VLANID=0; NWConfig.CfgMethod = pBMCInfo->LANCfs[EthIndex].IPAddrSrc; SetPendStatus(PEND_OP_SET_SOURCE,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_SOURCE,(INT8U*) &NWConfig,sizeof(NWConfig),(pSetLanReq->ChannelNum & 0x0F), BMCInst ); pBMCInfo->LANCfs[EthIndex].VLANID = pSetLanReq->ConfigData.VLANID; } } } else { pSetLanRes->CompletionCode = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof(INT8U); } break; case LAN_PARAM_VLAN_PRIORITY: if( pBMCInfo->IpmiConfig.VLANIfcSupport == 1) { if((pBMCInfo->LANCfs[EthIndex].VLANID & VLAN_MASK_BIT) != VLAN_MASK_BIT) /* checks for VLAN enable bit*/ { if(g_corefeatures.vlan_priorityset == ENABLED) { if(pSetLanReq->ConfigData.VLANPriority > 7 ) { TCRIT(" VLAN Priority value should be 0-7 \n"); *pRes = CC_INV_DATA_FIELD ; return sizeof (*pRes); } if(ReadVLANFile(VLAN_PRIORITY_SETTING_STR, PriorityLevel) == -1) { return -1; } if(WriteVLANFile(VLAN_PRIORITY_SETTING_STR, PriorityLevel, netindex,pSetLanReq->ConfigData.VLANPriority) == -1) { return -1; } pBMCInfo->LANCfs[EthIndex].VLANPriority = pSetLanReq->ConfigData.VLANPriority; } else { TCRIT(" VLAN is not Configured \n"); *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (*pRes); } } else { if(pSetLanReq->ConfigData.VLANPriority > 7 ) { TCRIT(" VLAN Priority value should be 0-7 \n"); *pRes = CC_INV_DATA_FIELD ; return sizeof (*pRes); } if(ReadVLANFile(VLAN_PRIORITY_SETTING_STR, PriorityLevel) == -1) { return -1; } if(WriteVLANFile(VLAN_PRIORITY_SETTING_STR, PriorityLevel, netindex,pSetLanReq->ConfigData.VLANPriority) == -1) { return -1; } pBMCInfo->LANCfs[EthIndex].VLANPriority = pSetLanReq->ConfigData.VLANPriority; vlanID = (pBMCInfo->LANCfs[EthIndex].VLANID & 0xfff); memset(IfcName,0,sizeof(IfcName)); if(GetIfcName(EthIndex, IfcName,BMCInst) != 0) { TCRIT("Error in getting Interface Name for the Lan Index :%d\n",EthIndex); *pRes = CC_INV_DATA_FIELD; return sizeof(*pRes); } /*vconfig set_egress_map */ sprintf(cmdSetPriority,"vconfig set_egress_map %s.%d 0 %d",IfcName,vlanID,pSetLanReq->ConfigData.VLANPriority); if(((retValue = safe_system(cmdSetPriority)) < 0)) { TCRIT("ERROR %d: Set VLAN Priority failed\n",retValue); } /* * Set priority of IPMI commands. * The skb->priority value of IPMI command will be modified by TOS option. * So, use the mapping table to get the current value. */ memset(&cmdSetPriority,0,sizeof(cmdSetPriority)); TOS = pBMCInfo->LANCfs[EthIndex].Ipv4HdrParam.TypeOfService; SkbPriority = IP_TOS2PRIO[IPTOS_TOS(TOS)>>1]; sprintf(cmdSetPriority,"vconfig set_egress_map %s.%d %d %d",IfcName,vlanID,SkbPriority,pSetLanReq->ConfigData.VLANPriority); if(((retValue = safe_system(cmdSetPriority)) < 0)) { TCRIT("ERROR %d: Set VLAN IPMI Priority failed\n",retValue); } } } else { pSetLanRes->CompletionCode = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof(INT8U); } break; case LAN_PARAM_CIPHER_SUITE_ENTRY_SUP: pSetLanRes->CompletionCode = CC_ATTEMPT_TO_SET_RO_PARAM; return sizeof(INT8U); case LAN_PARAM_CIPHER_SUITE_ENTRIES: pSetLanRes->CompletionCode = CC_ATTEMPT_TO_SET_RO_PARAM; return sizeof(INT8U); break; case LAN_PARAM_CIPHER_SUITE_PRIV_LEVELS: LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (pBMCInfo->LANCfs[EthIndex].CipherSuitePrivLevels, pSetLanReq->ConfigData.CipherSuitePrivLevels, MAX_NUM_CIPHER_SUITE_PRIV_LEVELS); UNLOCK_BMC_SHARED_MEM(BMCInst); break; case LAN_PARAM_VLAN_TAGS: if (0 == pSetLanReq->ConfigData.DestAddr.SetSelect) { LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy(&pSharedMem->VLANDestTag, ((_NEAR_ INT8U*)&pSetLanReq->ConfigData) + 1, sizeof(VLANDestTags_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); } else { if (pSetLanReq->ConfigData.DestAddr.SetSelect > pBMCInfo->LANCfs[EthIndex].NumDest) { pSetLanRes->CompletionCode = CC_PARAM_OUT_OF_RANGE; return sizeof (INT8U); } LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy(&pBMCInfo->LANCfs[EthIndex].VLANDestTags [pSetLanReq->ConfigData.DestAddr.SetSelect - 1], ((_NEAR_ INT8U*)&pSetLanReq->ConfigData) + 1, sizeof(VLANDestTags_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); } break; case LAN_PARAMS_BAD_PASSWORD_THRESHOLD: ClearUserLockAttempts(LAN_CHANNEL_BADP,BMCInst); LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy(&pBMCInfo->LANCfs[EthIndex].BadPasswd, &pSetLanReq->ConfigData.BadPasswd,sizeof(BadPassword_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); break; case LAN_PARAMS_AMI_OEM_SNMPV6_DEST_ADDR: if (pSetLanReq->ConfigData.DestType.SetSelect > pBMCInfo->LANCfs[EthIndex].NumDest ) { TCRIT("Invalid data for SetSelect"); *pRes = CC_INV_DATA_FIELD ; return sizeof (*pRes); } /*Validate the IPv6 address*/ if(0 != IsValidGlobalIPv6Addr((struct in6_addr*)&pSetLanReq->ConfigData.Destv6Addr.IPAddr)) { TCRIT("Invalid Global IPv6 Address\n"); *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } if (0 == pSetLanReq->ConfigData.Destv6Addr.SetSelect) { LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (&pSharedMem->VolLANv6Dest, &pSetLanReq->ConfigData.Destv6Addr, sizeof(LANDestv6Addr_T)); memset(pSharedMem->VolLANDest,0,sizeof(LANDestAddr_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); } else { LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (&pBMCInfo->LANCfs[EthIndex].Destv6Addr[pSetLanReq->ConfigData.Destv6Addr.SetSelect - 1], &pSetLanReq->ConfigData.Destv6Addr, sizeof(LANDestv6Addr_T)); memset(&pBMCInfo->LANCfs[EthIndex].DestAddr[pSetLanReq->ConfigData.DestAddr.SetSelect - 1],0,sizeof(LANDestAddr_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); } TDBG("\n SetLanconfig: Setting SNMPv6 configuration done..\n"); break; case LAN_PARAMS_AMI_OEM_ENABLE_SET_MAC: NIC_Count = g_coremacros.global_nic_count; if (ReqLen != 1) pSetLanRes->CompletionCode = CC_REQ_INV_LEN; else if (pSetLanReq->ConfigData.EthIndex > ( NIC_Count- 1)) pSetLanRes->CompletionCode = CC_INV_DATA_FIELD; else { enableSetMACAddr = TRUE; macEthIndex = pSetLanReq->ConfigData.EthIndex; pSetLanRes->CompletionCode = CC_NORMAL; } return sizeof(*pSetLanRes); case LAN_PARAMS_AMI_OEM_IPV6_ENABLE: pendStatus = GetPendStatus(PEND_OP_SET_IPV6_ENABLE); if (pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } TDBG("\n Entered in LAN_PARAMS_AMI_OEM_IPV6_ENABLE \n"); if ( pBMCInfo->LANCfs[EthIndex].IPv6_Enable == pSetLanReq->ConfigData.IPv6_Enable) { TCRIT("LAN or VLAN - the current state is the same \n"); break; } pBMCInfo->LANCfs[EthIndex].IPv6_Enable= pSetLanReq->ConfigData.IPv6_Enable; NWConfig6.enable= pSetLanReq->ConfigData.IPv6_Enable; SetPendStatus(PEND_OP_SET_IPV6_ENABLE,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_IPV6_ENABLE,(INT8U*) &NWConfig6,sizeof(NWConfig6),(pSetLanReq->ChannelNum & 0x0F), BMCInst ); break; case LAN_PARAMS_AMI_OEM_IPV6_IP_ADDR_SOURCE: pendStatus = GetPendStatus(PEND_OP_SET_IPV6_IP_ADDR_SOURCE); if (pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } TDBG("\n Entered in LAN_PARAMS_AMI_OEM_IPV6_IP_ADDR_SOURCE \n"); /* check for IPv6 enable state */ if ( pBMCInfo->LANCfs[EthIndex].IPv6_Enable != 1) { TCRIT("IPv6 is not enabled yet... \n"); *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } if ((pSetLanReq->ConfigData.IPv6_IPAddrSrc > BMC_OTHER_SOURCE) ||(pSetLanReq->ConfigData.IPv6_IPAddrSrc == UNSPECIFIED_IP_SOURCE)) { *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } else if((pSetLanReq->ConfigData.IPv6_IPAddrSrc == BIOS_IP_SOURCE) || (pSetLanReq->ConfigData.IPv6_IPAddrSrc == BMC_OTHER_SOURCE)) { /* we only support DHCP and Static IP source */ *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } if (pBMCInfo->LANCfs[EthIndex].IPv6_IPAddrSrc == pSetLanReq->ConfigData.IPv6_IPAddrSrc ) { TCRIT("LAN or VLAN if current SRC is DHCP/Static and incoming SRC is DHCP/Static, do nothing\n"); break; } pBMCInfo->LANCfs[EthIndex].IPv6_IPAddrSrc = pSetLanReq->ConfigData.IPv6_IPAddrSrc ; if ( (pSetLanReq->ConfigData.IPv6_IPAddrSrc == STATIC_IP_SOURCE ) || (pSetLanReq->ConfigData.IPv6_IPAddrSrc == DHCP_IP_SOURCE ) ) { NWConfig6.CfgMethod = pSetLanReq->ConfigData.IPv6_IPAddrSrc; SetPendStatus(PEND_OP_SET_IPV6_IP_ADDR_SOURCE,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_IPV6_IP_ADDR_SOURCE,(INT8U*) &NWConfig6,sizeof(NWConfig6),(pSetLanReq->ChannelNum & 0x0F), BMCInst ); } break; case LAN_PARAMS_AMI_OEM_IPV6_IP_ADDR: pendStatus = GetPendStatus(PEND_OP_SET_IPV6_IP_ADDR); if (pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } TDBG("\n Entered in LAN_PARAMS_AMI_OEM_IPV6_IP_ADDR \n"); /* check for IPv6 enable state */ if ( pBMCInfo->LANCfs[EthIndex].IPv6_Enable != 1) { TCRIT("IPv6 is not enabled yet... \n"); *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } /* Do IP address source check */ if( pBMCInfo->LANCfs[EthIndex].IPv6_IPAddrSrc == DHCP_IP_SOURCE) { TCRIT("IPv6 Address source is currently in DHCP \n"); *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } /*Validate the Index value*/ if(pSetLanReq->ConfigData.IPv6Addr.IPv6_Cntr & 0xF0) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } /*Validate the IPv6 address*/ if(0 != IsValidGlobalIPv6Addr((struct in6_addr*)&pSetLanReq->ConfigData.IPv6Addr.IPv6_IPAddr)) { TCRIT("Invalid Global IPv6 Address\n"); *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } /*Validate the duplicate IPv6 Address*/ nwReadNWCfg_v4_v6( &NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); for(i=0;iConfigData.IPv6Addr.IPv6_IPAddr,IP6_ADDR_LEN) == 0) && pSetLanReq->ConfigData.IPv6Addr.IPv6_Cntr != i) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } } _fmemcpy(pBMCInfo->LANCfs[EthIndex].IPv6_IPAddr[pSetLanReq->ConfigData.IPv6Addr.IPv6_Cntr], pSetLanReq->ConfigData.IPv6Addr.IPv6_IPAddr, IP6_ADDR_LEN ); SetPendStatus(PEND_OP_SET_IPV6_IP_ADDR,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_IPV6_IP_ADDR, (INT8U*) &pSetLanReq->ConfigData.IPv6Addr,\ sizeof (IPv6Addr_T),(pSetLanReq->ChannelNum & 0x0F), BMCInst ); break; case LAN_PARAMS_AMI_OEM_IPV6_PREFIX_LENGTH: pendStatus = GetPendStatus(PEND_OP_SET_IPV6_PREFIX_LENGTH); if (pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } TDBG("\n Entered in LAN_PARAMS_AMI_OEM_IPV6_PREFIX_LENGTH \n"); /* check for IPv6 enable state */ if ( pBMCInfo->LANCfs[EthIndex].IPv6_Enable != 1) { TCRIT("IPv6 is not enabled yet... \n"); *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } /* Do IP address source check */ if( pBMCInfo->LANCfs[EthIndex].IPv6_IPAddrSrc == DHCP_IP_SOURCE) { TCRIT("IPv6 Address source is currently in DHCP \n"); *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } /*Validate the Index value*/ if(pSetLanReq->ConfigData.IPv6Prefix.IPv6_Prepos & 0xF0) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } pBMCInfo->LANCfs[EthIndex].IPv6_PrefixLen[pSetLanReq->ConfigData.IPv6Prefix.IPv6_Prepos] = pSetLanReq->ConfigData.IPv6Prefix.IPv6_PrefixLen; SetPendStatus(PEND_OP_SET_IPV6_PREFIX_LENGTH,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_IPV6_PREFIX_LENGTH,(INT8U*) &pSetLanReq->ConfigData.IPv6Prefix, sizeof(IPv6Prefix_T),(pSetLanReq->ChannelNum & 0x0F), BMCInst ); break; case LAN_PARAMS_AMI_OEM_IPV6_GATEWAY_IP: pendStatus = GetPendStatus(PEND_OP_SET_IPV6_GATEWAY); if (pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } TDBG("\n Entered in LAN_PARAMS_AMI_OEM_IPV6_GATEWAY_IP \n"); /* check for IPv6 enable state */ if ( pBMCInfo->LANCfs[EthIndex].IPv6_Enable != 1) { TCRIT("IPv6 is not enabled yet... \n"); *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } /* Do IP address source check */ if( pBMCInfo->LANCfs[EthIndex].IPv6_IPAddrSrc == DHCP_IP_SOURCE) { TCRIT("IPv6 Address source is currently in DHCP \n"); *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } /*Validate the IPv6 address*/ if(0 != IsValidGlobalIPv6Addr((struct in6_addr*)&pSetLanReq->ConfigData.IPv6_GatewayIPAddr)) { TCRIT("Invalid Global IPv6 Address\n"); *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } _fmemcpy( pBMCInfo->LANCfs[EthIndex].IPv6_GatewayIPAddr, pSetLanReq->ConfigData.IPv6_GatewayIPAddr, IP6_ADDR_LEN ); _fmemcpy( NWConfig6.Gateway, pSetLanReq->ConfigData.IPv6_GatewayIPAddr, IP6_ADDR_LEN ); SetPendStatus(PEND_OP_SET_IPV6_GATEWAY,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_IPV6_GATEWAY,(INT8U*) &NWConfig6,sizeof(NWConfig6),(pSetLanReq->ChannelNum & 0x0F), BMCInst ); break; case LAN_PARAMS_AMI_OEM_IPV6_IP_ADDR_EUI64: /* The first byte is the index and it should contain atleast one byte of IPv6 address and it cannot exceed 8 bytes incase of EUI-64 algo */ if((ReqLen < 2) || (ReqLen > 9)) { *pRes = CC_REQ_INV_LEN; return sizeof(INT8U); } pendStatus = GetPendStatus(PEND_OP_SET_IPV6_IP_ADDR); if (pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } TDBG("\n Entered in LAN_PARAMS_AMI_OEM_IPV6_IP_ADDR_EUI64 \n"); /* Check for IPv6 enabled state */ if(pBMCInfo->LANCfs[EthIndex].IPv6_Enable != 1) { TCRIT("IPv6 is not enabled yet... \n"); *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof(INT8U); } /* Do IP address source check */ if(pBMCInfo->LANCfs[EthIndex].IPv6_IPAddrSrc == DHCP_IP_SOURCE) { TCRIT("IPv6 Address source is currently in DHCP \n"); *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } /*Validate the Index value*/ if(pSetLanReq->ConfigData.IPv6Addr.IPv6_Cntr & 0xF0) { TCRIT("Index of the given IPv6 Address is invalid. \n"); *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } /* The request may be of variable length, so fill the network prefix by appending zeros. This is to avoid garbage values */ for(i = ReqLen-1; i<8; i++) { pSetLanReq->ConfigData.IPv6Addr.IPv6_IPAddr[i] = 0; } /* Generate the IPv6 address using EUI-64 algo */ if(nwFormIPv6Addr_EUI64((INT8U*) &pSetLanReq->ConfigData.IPv6Addr.IPv6_IPAddr, netindex, g_corefeatures.global_ipv6) != 0) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } /* Get the current network configuration settings */ nwReadNWCfg_v4_v6(&NWConfig, &NWConfig6, netindex, g_corefeatures.global_ipv6); /*Validate the duplicate IPv6 Address*/ for(i=0; iConfigData.IPv6Addr.IPv6_IPAddr, IP6_ADDR_LEN) == 0) && pSetLanReq->ConfigData.IPv6Addr.IPv6_Cntr != i) { TCRIT("\n Error in setting the IPv6 address - Duplicate :( \n"); *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } } _fmemcpy(pBMCInfo->LANCfs[EthIndex].IPv6_IPAddr[pSetLanReq->ConfigData.IPv6Addr.IPv6_Cntr], pSetLanReq->ConfigData.IPv6Addr.IPv6_IPAddr, IP6_ADDR_LEN); SetPendStatus(PEND_OP_SET_IPV6_IP_ADDR,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_IPV6_IP_ADDR, (INT8U*) &pSetLanReq->ConfigData.IPv6Addr, sizeof(IPv6Addr_T), (pSetLanReq->ChannelNum & 0x0F), BMCInst); break; case LAN_PARAMS_AMI_OEM_PHY_SETTINGS: if(ReqLen != 4) { pSetLanRes->CompletionCode = CC_REQ_INV_LEN; return sizeof(*pSetLanRes); } memset(IfcName, 0, sizeof(IfcName)); if(GetIfcNameByIndex(EthIndex, IfcName) != 0) { TCRIT("Error in Getting Interface Name for the lan Index:%d\n",EthIndex); pSetLanRes->CompletionCode = CC_INV_DATA_FIELD; return sizeof(*pSetLanRes); } if(nwGetEthInformation(&PHYCfg, IfcName) == 0) { if(((PHYCfg.autoneg == pSetLanReq->ConfigData.PHYConfig.AutoNegotiationEnable) && (PHYCfg.speed == pSetLanReq->ConfigData.PHYConfig.Speed) && (PHYCfg.duplex == pSetLanReq->ConfigData.PHYConfig.Duplex))) { TDBG("There is no change in the link mode, ignoring the request for setting the speed/duplex.\n"); break; } } else { pSetLanRes->CompletionCode = CC_UNSPECIFIED_ERR; return sizeof(*pSetLanRes); } if(pSetLanReq->ConfigData.PHYConfig.Speed != 0xFFFF && pSetLanReq->ConfigData.PHYConfig.Duplex != 0xFF) { if(IsLinkModeSupported(&PHYCfg,pSetLanReq->ConfigData.PHYConfig.Speed,pSetLanReq->ConfigData.PHYConfig.Duplex) <= 0) { TCRIT("Unsupported link mode \n"); pSetLanRes->CompletionCode = CC_INV_DATA_FIELD; return sizeof(*pSetLanRes); } } SetPendStatus(PEND_OP_SET_SPEED, PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_SPEED, (INT8U*) &(pSetLanReq->ConfigData.PHYConfig), sizeof(PHYConfig_T),(pSetLanReq->ChannelNum & 0x0F), BMCInst ); break; case LAN_PARAMS_AMI_OEM_MTU_SETTINGS: if(ReqLen != 2) { pSetLanRes->CompletionCode = CC_REQ_INV_LEN; return sizeof(*pSetLanRes); } /* Setting MTU values less than 1280 disables IPv6, RFC 1280 recommends MTU value should be greater than 1200 for IPV6. so restricting MTU value b/w 1280 to 1500.*/ if( (pSetLanReq->ConfigData.MTU_size < 1280) || (pSetLanReq->ConfigData.MTU_size > 1500) ) { pSetLanRes->CompletionCode = CC_INV_DATA_FIELD; return sizeof(*pSetLanRes); } SetPendStatus(PEND_OP_SET_MTU_SIZE, PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_MTU_SIZE, (INT8U*) &(pSetLanReq->ConfigData.MTU_size), sizeof(INT16U),(pSetLanReq->ChannelNum & 0x0F), BMCInst ); break; case LAN_PARAMS_SSI_OEM_2ND_PRI_ETH_MAC_ADDR: if(g_corefeatures.ssi_support == ENABLED) { pendStatus = GetPendStatus(PEND_OP_SET_MAC_ADDRESS); if(pendStatus == PEND_STATUS_PENDING) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (INT8U); } if (!enableSetMACAddr) { pSetLanRes->CompletionCode = CC_ATTEMPT_TO_SET_RO_PARAM; return sizeof(INT8U); } else { EnableSetMACAddress_T macAddrEnabled; memset(&macAddrEnabled, 0, sizeof(EnableSetMACAddress_T)); macAddrEnabled.EthIndex = 0x1; /* Specify the 2nd interface */ memcpy(&macAddrEnabled.MACAddress, pSetLanReq->ConfigData.SSI2ndPriEthMACAddr, MAC_ADDR_LEN); SetPendStatus(PEND_OP_SET_MAC_ADDRESS, PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_MAC_ADDRESS, (INT8U*)&macAddrEnabled, sizeof(EnableSetMACAddress_T), 0x1, BMCInst); } break; } else { pSetLanRes->CompletionCode = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } case LAN_PARAMS_SSI_OEM_LINK_CTRL: if(g_corefeatures.ssi_support == ENABLED) { pSetLanRes->CompletionCode = CC_ATTEMPT_TO_SET_RO_PARAM; /* Read Only */ } else { pSetLanRes->CompletionCode = CC_PARAM_NOT_SUPPORTED; } return sizeof(INT8U); case LAN_PARAMS_SSI_OEM_CMM_IP_ADDR: if(g_corefeatures.ssi_support == ENABLED) { _fmemcpy(pBMCInfo->SSIConfig.CMMIPAddr, pSetLanReq->ConfigData.CMMIPAddr, IP_ADDR_LEN); FlushIPMI((INT8U*)&pBMCInfo->SSIConfig, (INT8U*)&pBMCInfo->SSIConfig, pBMCInfo->IPMIConfLoc.SSIConfigAddr, sizeof(SSIConfig_T), BMCInst); break; } else { pSetLanRes->CompletionCode = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } default: if(g_corefeatures.ncsi_cmd_support == ENABLED) { switch (pSetLanReq->ParameterSelect) { case LAN_PARAMS_AMI_OEM_NCSI_CONFIG_NUM: pSetLanRes->CompletionCode = CC_ATTEMPT_TO_SET_RO_PARAM; return sizeof(*pSetLanRes); case LAN_PARAMS_AMI_OEM_NCSI_SETTINGS: NIC_Count=g_coremacros.global_nic_count; if (ReqLen != 3) pSetLanRes->CompletionCode = CC_REQ_INV_LEN; else if (pSetLanReq->ConfigData.NCSIPortConfig.Interface >= NIC_Count) pSetLanRes->CompletionCode = CC_INV_DATA_FIELD; else { pendStatus = GetPendStatus(PEND_OP_SET_NCSI_CHANNEL_ID); if(pendStatus == PEND_STATUS_PENDING) { *pRes = CC_NODE_BUSY; return sizeof (INT8U); } NCSIConfig_T configData; char interfaceName[8]; memset(&configData, 0, sizeof(NCSIConfig_T)); memset(interfaceName, 0, sizeof(interfaceName)); snprintf(interfaceName, sizeof(interfaceName), "%s%d", "eth", pSetLanReq->ConfigData.NCSIPortConfig.Interface); if (NCSIGetPortConfigByName(interfaceName, &configData) != 0) pSetLanRes->CompletionCode = CC_INV_DATA_FIELD; else { configData.PackageId = pSetLanReq->ConfigData.NCSIPortConfig.PackageId; configData.ChannelId = pSetLanReq->ConfigData.NCSIPortConfig.ChannelId; if (NCSISetPortConfigByName(interfaceName, configData) != 0) pSetLanRes->CompletionCode = CC_INV_DATA_FIELD; else { SetPendStatus(PEND_OP_SET_NCSI_CHANNEL_ID, PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_NCSI_CHANNEL_ID, NULL, 0, 0, BMCInst); pSetLanRes->CompletionCode = CC_NORMAL; } } } return sizeof(*pSetLanRes); case LAN_PARAMS_AMI_OEM_NCSI_MODE_CHANGE: NIC_Count=g_coremacros.global_nic_count; if (ReqLen != 2) pSetLanRes->CompletionCode = CC_REQ_INV_LEN; else if (pSetLanReq->ConfigData.NCSIModeConfig.Interface >= NIC_Count) pSetLanRes->CompletionCode = CC_INV_DATA_FIELD; else { pendStatus = GetPendStatus(PEND_OP_SET_NCSI_MODE_CHANGE); if(pendStatus == PEND_STATUS_PENDING) { *pRes = CC_NODE_BUSY; return sizeof (INT8U); } NCSIConfig_T configData; char interfaceName[8]; memset(&configData, 0, sizeof(NCSIConfig_T)); memset(interfaceName, 0, sizeof(interfaceName)); snprintf(interfaceName, sizeof(interfaceName), "%s%d", "eth", pSetLanReq->ConfigData.NCSIModeConfig.Interface); if (NCSIGetPortConfigByName(interfaceName, &configData) != 0) pSetLanRes->CompletionCode = CC_INV_DATA_FIELD; else { configData.AutoSelect = pSetLanReq->ConfigData.NCSIModeConfig.NCSIMode; if (NCSISetPortConfigByName(interfaceName, configData) != 0) pSetLanRes->CompletionCode = CC_INV_DATA_FIELD; else { SetPendStatus(PEND_OP_SET_NCSI_MODE_CHANGE, PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_NCSI_MODE_CHANGE, NULL, 0, 0, BMCInst); pSetLanRes->CompletionCode = CC_NORMAL; } } } return sizeof(*pSetLanRes); case LAN_PARAMS_AMI_OEM_NCSI_EXTENSION: if ((0x20 == pSetLanReq->ConfigData.NCSIPHYConfigSet.Command) && (g_corefeatures.ncsi_keep_phy_linkup_support == ENABLED)) { NIC_Count=g_coremacros.global_nic_count; if (ReqLen != 3) pSetLanRes->CompletionCode = CC_REQ_INV_LEN; else if (pSetLanReq->ConfigData.NCSIPHYConfigSet.Interface >= NIC_Count) pSetLanRes->CompletionCode = CC_INV_DATA_FIELD; else { pendStatus = GetPendStatus(PEND_OP_SET_NCSI_VETOBIT); if(pendStatus == PEND_STATUS_PENDING) { *pRes = CC_NODE_BUSY; return sizeof (INT8U); } NCSIConfig_T configData; char interfaceName[8]; memset(&configData, 0, sizeof(NCSIConfig_T)); memset(interfaceName, 0, sizeof(interfaceName)); snprintf(interfaceName, sizeof(interfaceName), "%s%d", "eth", pSetLanReq->ConfigData.NCSIPHYConfigSet.Interface); if (NCSIGetPortConfigByName(interfaceName, &configData) != 0) pSetLanRes->CompletionCode = CC_INV_DATA_FIELD; else { configData.VetoBit= pSetLanReq->ConfigData.NCSIPHYConfigSet.VetoBit; if (NCSISetPortConfigByName(interfaceName, configData) != 0) pSetLanRes->CompletionCode = CC_INV_DATA_FIELD; else { SetPendStatus(PEND_OP_SET_NCSI_VETOBIT, PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_NCSI_VETOBIT, NULL, 0, 0, BMCInst); pSetLanRes->CompletionCode = CC_NORMAL; } } } } else { pSetLanRes->CompletionCode = CC_PARAM_NOT_SUPPORTED; } return sizeof(*pSetLanRes); default: TDBG("In Valid Option\n"); } } pSetLanRes->CompletionCode = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } pSetLanRes->CompletionCode = CC_NORMAL; if(g_PDKHandle[PDK_POSTSETLANPARAM] != NULL) { ((int(*)(INT8U*, INT8U, int))(g_PDKHandle[PDK_POSTSETLANPARAM]))(pReq, ReqLen, BMCInst); } FlushIPMI((INT8U*)&pBMCInfo->LANCfs[0],(INT8U*)&pBMCInfo->LANCfs[EthIndex],pBMCInfo->IPMIConfLoc.LANCfsAddr, sizeof(LANConfig_T),BMCInst); 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(INT8U *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 (INT8U *Addr) { INT8U IntervalInSec; INT8U Status; int nRet; NWCFG_STRUCT NWConfig; NWCFG6_STRUCT NWConfig6; INT8U 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 (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { _NEAR_ GetLanConfigReq_T* pGetLanReq = (_NEAR_ GetLanConfigReq_T*) pReq; _NEAR_ GetLanConfigRes_T* pGetLanRes = (_NEAR_ GetLanConfigRes_T*) pRes; _FAR_ BMCSharedMem_T* pSharedMem = BMC_GET_SHARED_MEM (BMCInst); INT8U IsOemDefined = FALSE; NWCFG_STRUCT NWConfig; NWCFG6_STRUCT NWConfig6; // V6DNS_CONFIG v6dnsconfig; INT8U EthIndex,netindex= 0xFF,i; _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; int ncsiPortConfigNum = 0; ETHCFG_STRUCT PHYCfg; ChannelInfo_T* pChannelInfo = NULL; char IfcName[16]; /* Eth interface name */ INT8U ComStrLen=MAX_COMM_STRING_SIZE; int retValue = 0,NIC_Count = 0; pGetLanRes->CCParamRev.CompletionCode = CC_NORMAL; pGetLanRes->CCParamRev.ParamRevision = PARAMETER_REVISION_FORMAT; if(pGetLanReq->ChannelNum & RESERVED_VALUE_70) { /* Alarm !!! Somebody is trying to set Reseved Bits */ *pRes = CC_INV_DATA_FIELD; return sizeof (*pRes); } if((pGetLanReq->ParameterSelect >= MIN_LAN_OEM_CONF_PARAM) && (pGetLanReq->ParameterSelect <= MAX_LAN_OEM_CONF_PARAM) ) { /* Converts OEM parameter value to equivalent AMI parameter value */ if (0 != GetLanAMIParamValue (&pGetLanReq->ParameterSelect, &IsOemDefined) ) { pGetLanRes->CCParamRev.CompletionCode = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } /* Hook for OEM to handle this parameter */ if ( (IsOemDefined) && (g_PDKHandle[PDK_GETLANOEMPARAM] != NULL) ) { return ((int(*)(INT8U *, INT8U, INT8U *,int))(g_PDKHandle[PDK_GETLANOEMPARAM]))(pReq, ReqLen, pRes, BMCInst); } } if (g_PDKHandle[PDK_BEFOREGETLANPARM] != NULL) { retValue = ((int(*)(INT8U *, INT8U, INT8U *,int))(g_PDKHandle[PDK_BEFOREGETLANPARM]))(pReq, ReqLen, pRes, BMCInst); if(retValue != 0) { return retValue; } } //! Validate the SetSelector value. if ( (0x00 != pGetLanReq->SetSelect) && (pGetLanReq->ParameterSelect != LAN_PARAM_SELECT_DEST_TYPE) && (pGetLanReq->ParameterSelect != LAN_PARAM_SELECT_DEST_ADDR) && (pGetLanReq->ParameterSelect != LAN_PARAM_VLAN_TAGS) && (pGetLanReq->ParameterSelect != LAN_PARAMS_AMI_OEM_SNMPV6_DEST_ADDR) && (pGetLanReq->ParameterSelect != LAN_PARAMS_AMI_OEM_IPV6_IP_ADDR) && (pGetLanReq->ParameterSelect != LAN_PARAMS_AMI_OEM_IPV6_IP_ADDR_EUI64) && (pGetLanReq->ParameterSelect != LAN_PARAMS_AMI_OEM_IPV6_PREFIX_LENGTH)) { if( g_corefeatures.ncsi_cmd_support == ENABLED ) { if ((pGetLanReq->ParameterSelect != LAN_PARAMS_AMI_OEM_NCSI_SETTINGS) && (pGetLanReq->ParameterSelect != LAN_PARAMS_AMI_OEM_NCSI_MODE_CHANGE) && (pGetLanReq->ParameterSelect != LAN_PARAMS_AMI_OEM_NCSI_EXTENSION)) { *pRes = CC_INV_DATA_FIELD; return sizeof (*pRes); } } else { *pRes = CC_INV_DATA_FIELD; return sizeof (*pRes); } } //! Validate the BlockSelector value. if (0x00 != pGetLanReq->BlockSelect) { *pRes = CC_INV_DATA_FIELD; return sizeof (*pRes); } EthIndex= GetEthIndex(pGetLanReq->ChannelNum & 0x0F, BMCInst); if(0xff == EthIndex) { *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } /*Get the EthIndex*/ if(GetIfcName(EthIndex,IfcName, BMCInst) != 0) { TCRIT("Error in Getting IfcName\n"); *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } for(i=0;iChannelNum & GET_PARAMETER_REVISION_MASK) != 0) { if((MAX_LAN_CONF_PARAM >= pGetLanReq->ParameterSelect) || ((MIN_LAN_OEM_CONF_PARAM <= pGetLanReq->ParameterSelect) && (MAX_LAN_OEM_CONF_PARAM >= pGetLanReq->ParameterSelect)) ) { return sizeof(GetLanCCRev_T); } else { *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof (*pRes); } } else { switch(pGetLanReq->ParameterSelect) { case LAN_PARAM_SET_IN_PROGRESS: LOCK_BMC_SHARED_MEM(BMCInst); pGetLanRes->ConfigData.SetInProgress = BMC_GET_SHARED_MEM(BMCInst)->m_Lan_SetInProgress; UNLOCK_BMC_SHARED_MEM(BMCInst); break; case LAN_PARAM_AUTH_TYPE_SUPPORT: pGetLanRes->ConfigData.AuthTypeSupport = pBMCInfo->LANCfs[EthIndex].AuthTypeSupport; break; case LAN_PARAM_AUTH_TYPE_ENABLES: LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (&pGetLanRes->ConfigData.AuthTypeEnables, &(pBMCInfo->LANCfs[EthIndex].AuthTypeEnables), sizeof(AuthTypeEnables_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); break; case LAN_PARAM_IP_ADDRESS: if((g_corefeatures.delayed_lan_restart_support) && (pBMCInfo->LANCfs[EthIndex].IPAddrSrc == STATIC_IP_SOURCE)) { if(pBMCInfo->LANCfs[EthIndex].IPv4_Enable) { _fmemcpy (NWConfig.IPAddr,pBMCInfo->LANCfs[EthIndex].IPAddr, IP_ADDR_LEN); } else { memset(&NWConfig, 0, sizeof(NWConfig)); } } else { nwReadNWCfg_v4_v6( &NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); } _fmemcpy (pGetLanRes->ConfigData.IPAddr, NWConfig.IPAddr, IP_ADDR_LEN); break; case LAN_PARAM_IP_ADDRESS_SOURCE: if(g_corefeatures.delayed_lan_restart_support) { if(pBMCInfo->LANCfs[EthIndex].IPv4_Enable) { NWConfig.CfgMethod = pBMCInfo->LANCfs[EthIndex].IPAddrSrc; } else { memset(&NWConfig, 0, sizeof(NWConfig)); } } else { nwReadNWCfg_v4_v6( &NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); } pGetLanRes->ConfigData.IPAddrSrc = NWConfig.CfgMethod; break; case LAN_PARAM_MAC_ADDRESS: nwGetNWInformations(&NWConfig,IfcName); _fmemcpy (pGetLanRes->ConfigData.MACAddr, NWConfig.MAC, MAC_ADDR_LEN); break; case LAN_PARAM_SUBNET_MASK: if((g_corefeatures.delayed_lan_restart_support) && (pBMCInfo->LANCfs[EthIndex].IPAddrSrc == STATIC_IP_SOURCE)) { if(pBMCInfo->LANCfs[EthIndex].IPv4_Enable) { _fmemcpy (NWConfig.Mask,pBMCInfo->LANCfs[EthIndex].SubNetMask, IP_ADDR_LEN); } else { memset(&NWConfig, 0, sizeof(NWConfig)); } } else { nwReadNWCfg_v4_v6( &NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); } _fmemcpy (pGetLanRes->ConfigData.SubNetMask, NWConfig.Mask, IP_ADDR_LEN); break; case LAN_PARAM_IPv4_HEADER: LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (&pGetLanRes->ConfigData.Ipv4HdrParam, &(pBMCInfo->LANCfs[EthIndex].Ipv4HdrParam), sizeof(IPv4HdrParams_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); break; case LAN_PARAM_PRI_RMCP_PORT: pGetLanRes->ConfigData.PrimaryRMCPPort = htoipmi_u16(pBMCInfo->LANCfs[EthIndex].PrimaryRMCPPort); break; case LAN_PARAM_SEC_RMCP_PORT: /* Returning Invalid error message */ *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof (INT8U); /*pGetLanRes->ConfigData.SecondaryPort = htoipmi_u16(pPMConfig->LANConfig[EthIndex].SecondaryPort);*/ break; case LAN_PARAM_BMC_GENERATED_ARP_CONTROL: pGetLanRes->ConfigData.BMCGeneratedARPControl = pBMCInfo->LANCfs[EthIndex].BMCGeneratedARPControl; break; case LAN_PARAM_GRATITIOUS_ARP_INTERVAL: pGetLanRes->ConfigData.GratitousARPInterval = pBMCInfo->LANCfs[EthIndex].GratitousARPInterval; break; case LAN_PARAM_DEFAULT_GATEWAY_IP: if((g_corefeatures.delayed_lan_restart_support) && (pBMCInfo->LANCfs[EthIndex].IPAddrSrc == STATIC_IP_SOURCE)) { if(pBMCInfo->LANCfs[EthIndex].IPv4_Enable) { _fmemcpy (NWConfig.Gateway, pBMCInfo->LANCfs[EthIndex].DefaultGatewayIPAddr, IP_ADDR_LEN); } else { memset(&NWConfig, 0, sizeof(NWConfig)); } } else { nwReadNWCfg_v4_v6( &NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); } _fmemcpy (pGetLanRes->ConfigData.DefaultGatewayIPAddr, NWConfig.Gateway, IP_ADDR_LEN); break; case LAN_PARAM_DEFAULT_GATEWAY_MAC: nwReadNWCfg_v4_v6( &NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); nwGetSrcMacAddr(&NWConfig.Gateway[0],netindex, &pGetLanRes->ConfigData.DefaultGatewayMACAddr[0]); break; case LAN_PARAM_BACKUP_GATEWAY_IP: LOCK_BMC_SHARED_MEM(BMCInst); nwGetBkupGWyAddr(pGetLanRes->ConfigData.BackupGatewayIPAddr,netindex); UNLOCK_BMC_SHARED_MEM(BMCInst); break; case LAN_PARAM_BACKUP_GATEWAY_MAC: LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (pGetLanRes->ConfigData.BackupGatewayMACAddr, pBMCInfo->LANCfs[EthIndex].BackupGatewayMACAddr, MAC_ADDR_LEN); UNLOCK_BMC_SHARED_MEM(BMCInst); break; case LAN_PARAM_COMMUNITY_STRING: if (g_PDKHandle[PDK_GETSNMPCOMMUNITYNAME] != NULL ) { if(((int(*)(INT8U *, INT8U *,int))(g_PDKHandle[PDK_GETSNMPCOMMUNITYNAME]))(pGetLanRes->ConfigData.CommunityStr,&ComStrLen, BMCInst)==0) break; } LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (pGetLanRes->ConfigData.CommunityStr, pBMCInfo->LANCfs[EthIndex].CommunityStr, MAX_COMM_STRING_SIZE); UNLOCK_BMC_SHARED_MEM(BMCInst); break; case LAN_PARAM_DEST_NUM: pGetLanRes->ConfigData.NumDest = pBMCInfo->LANCfs[EthIndex].NumDest; break; case LAN_PARAM_SELECT_DEST_TYPE: //if (pGetLanReq->SetSelect > NUM_LAN_DESTINATION) if ( pGetLanReq->SetSelect > pBMCInfo->LANCfs[EthIndex].NumDest ) { *pRes = CC_PARAM_OUT_OF_RANGE ; return sizeof (*pRes); } if (0 == pGetLanReq->SetSelect) { LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (&pGetLanRes->ConfigData.DestType, &pSharedMem->VolLANDestType[EthIndex], sizeof(LANDestType_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); } else { LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (&pGetLanRes->ConfigData.DestType, &(pBMCInfo->LANCfs[EthIndex].DestType[pGetLanReq->SetSelect - 1]), sizeof(LANDestType_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); } break; case LAN_PARAM_SELECT_DEST_ADDR: //if (pGetLanReq->SetSelect > NUM_LAN_DESTINATION) if ( pGetLanReq->SetSelect > pBMCInfo->LANCfs[EthIndex].NumDest ) { *pRes = CC_PARAM_OUT_OF_RANGE ; return sizeof (*pRes); } if (0 == pGetLanReq->SetSelect) { LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (&pGetLanRes->ConfigData.DestAddr, &pSharedMem->VolLANDest[EthIndex], sizeof(LANDestAddr_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); } else { LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (&pGetLanRes->ConfigData.DestAddr, &(pBMCInfo->LANCfs[EthIndex].DestAddr[pGetLanReq->SetSelect - 1]), sizeof(LANDestAddr_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); } break; case LAN_PARAM_VLAN_ID: if( pBMCInfo->IpmiConfig.VLANIfcSupport == 1) { pGetLanRes->ConfigData.VLANID = pBMCInfo->LANCfs[EthIndex].VLANID; } break; case LAN_PARAM_VLAN_PRIORITY: pGetLanRes->ConfigData.VLANPriority = pBMCInfo->LANCfs[EthIndex].VLANPriority; break; case LAN_PARAM_CIPHER_SUITE_ENTRY_SUP: pGetLanRes->ConfigData.CipherSuiteSup = N0_OF_CIPHER_SUITE_SUPPORTED; break; case LAN_PARAM_CIPHER_SUITE_ENTRIES: { int i; _fmemset (pGetLanRes->ConfigData.CipherSuiteEntries, 0, sizeof (pGetLanRes->ConfigData.CipherSuiteEntries)); for (i = 0; i < (N0_OF_CIPHER_SUITE_SUPPORTED); i++) { pGetLanRes->ConfigData.CipherSuiteEntries[i+1] = g_CipherRec[1 + i * 5]; } } break; case LAN_PARAM_CIPHER_SUITE_PRIV_LEVELS: LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (pGetLanRes->ConfigData.CipherSuitePrivLevels, pBMCInfo->LANCfs[EthIndex].CipherSuitePrivLevels, MAX_NUM_CIPHER_SUITE_PRIV_LEVELS); UNLOCK_BMC_SHARED_MEM(BMCInst); break; case LAN_PARAM_VLAN_TAGS: *((_NEAR_ INT8U*)&pGetLanRes->ConfigData) = pGetLanReq->SetSelect; if (pGetLanReq->SetSelect > pBMCInfo->LANCfs[EthIndex].NumDest) { pGetLanRes->CCParamRev.CompletionCode = CC_PARAM_OUT_OF_RANGE; return sizeof (GetLanCCRev_T); } if (0 == pGetLanReq->SetSelect) { LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (((_NEAR_ INT8U*) &pGetLanRes->ConfigData) + 1,&pSharedMem->VLANDestTag, sizeof(VLANDestTags_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); } else { if (pGetLanReq->SetSelect > pBMCInfo->LANCfs[EthIndex].NumDest) { pGetLanRes->CCParamRev.CompletionCode = CC_PARAM_OUT_OF_RANGE; return sizeof(GetLanCCRev_T); } LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (((_NEAR_ INT8U*)&pGetLanRes->ConfigData) + 1, &pBMCInfo->LANCfs[EthIndex].VLANDestTags[pGetLanReq->SetSelect - 1], sizeof(VLANDestTags_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); } break; case LAN_PARAMS_BAD_PASSWORD_THRESHOLD: LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy(&pGetLanRes->ConfigData.BadPasswd, &pBMCInfo->LANCfs[EthIndex].BadPasswd,sizeof(BadPassword_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); break; case LAN_PARAMS_AMI_OEM_SNMPV6_DEST_ADDR: if ( pGetLanReq->SetSelect > pBMCInfo->LANCfs[EthIndex].NumDest ) { *pRes = CC_PARAM_OUT_OF_RANGE ; return sizeof (*pRes); } if (0 == pGetLanReq->SetSelect) { LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (&pGetLanRes->ConfigData.Destv6Addr, &pSharedMem->VolLANv6Dest[EthIndex], sizeof(LANDestv6Addr_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); } else { LOCK_BMC_SHARED_MEM(BMCInst); _fmemcpy (&pGetLanRes->ConfigData.Destv6Addr, &(pBMCInfo->LANCfs[EthIndex].Destv6Addr[pGetLanReq->SetSelect - 1]), sizeof(LANDestv6Addr_T)); UNLOCK_BMC_SHARED_MEM(BMCInst); } TDBG("\n GetLanconfig: Getting SNMPv6 configuration done..\n"); return sizeof(GetLanConfigRes_T); break; case LAN_PARAMS_AMI_OEM_ENABLE_SET_MAC: pGetLanRes->ConfigData.ChangeMACEnabled = enableSetMACAddr; return sizeof(GetLanCCRev_T) + sizeof(INT8U); case LAN_PARAMS_AMI_OEM_IPV6_ENABLE: if(g_corefeatures.delayed_lan_restart_support) { NWConfig6.enable = pBMCInfo->LANCfs[EthIndex].IPv6_Enable; } else { nwReadNWCfg_v4_v6( &NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); } pGetLanRes->ConfigData.IPv6_Enable = NWConfig6.enable; return sizeof(GetLanCCRev_T) + sizeof(INT8U); break; case LAN_PARAMS_AMI_OEM_IPV6_IP_ADDR_SOURCE: if(g_corefeatures.delayed_lan_restart_support) { if((pBMCInfo->LANCfs[EthIndex].IPv6_Enable)) { NWConfig6.CfgMethod = pBMCInfo->LANCfs[EthIndex].IPv6_IPAddrSrc; } else { memset(&NWConfig6, 0, sizeof(NWConfig6)); } } else { nwReadNWCfg_v4_v6( &NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); } pGetLanRes->ConfigData.IPv6_IPAddrSrc = NWConfig6.CfgMethod; return sizeof(GetLanCCRev_T) + sizeof(INT8U); break; case LAN_PARAMS_AMI_OEM_IPV6_IP_ADDR: case LAN_PARAMS_AMI_OEM_IPV6_IP_ADDR_EUI64: if(pGetLanReq->SetSelect & 0xF0) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } if((g_corefeatures.delayed_lan_restart_support) && (pBMCInfo->LANCfs[EthIndex].IPv6_IPAddrSrc == STATIC_IP_SOURCE)) { if((pBMCInfo->LANCfs[EthIndex].IPv6_Enable)) { _fmemcpy (NWConfig6.GlobalIPAddr,pBMCInfo->LANCfs[EthIndex].IPv6_IPAddr, IP6_ADDR_LEN*MAX_IPV6ADDRS); } else { memset(&NWConfig6, 0, sizeof(NWConfig6)); } } else { nwReadNWCfg_v4_v6( &NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); } _fmemcpy (pGetLanRes->ConfigData.IPv6_LinkAddr, NWConfig6.GlobalIPAddr[(pGetLanReq->SetSelect & 0x0F)], IP6_ADDR_LEN); return sizeof(GetLanCCRev_T) + IP6_ADDR_LEN; break; case LAN_PARAMS_AMI_OEM_IPV6_LINK_ADDR: nwReadNWCfg_v4_v6( &NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); _fmemcpy (pGetLanRes->ConfigData.IPv6_LinkAddr, NWConfig6.LinkIPAddr, IP6_ADDR_LEN); return sizeof(GetLanCCRev_T) + IP6_ADDR_LEN; case LAN_PARAMS_AMI_OEM_IPV6_PREFIX_LENGTH: if(pGetLanReq->SetSelect & 0xF0) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } if((g_corefeatures.delayed_lan_restart_support) && (pBMCInfo->LANCfs[EthIndex].IPv6_IPAddrSrc == STATIC_IP_SOURCE)) { if((pBMCInfo->LANCfs[EthIndex].IPv6_Enable)) { NWConfig6.GlobalPrefix[(pGetLanReq->SetSelect & 0x0F)] = pBMCInfo->LANCfs[EthIndex].IPv6_PrefixLen[(pGetLanReq->SetSelect & 0x0F)]; } else { memset(&NWConfig6, 0, sizeof(NWConfig6)); } } else { nwReadNWCfg_v4_v6( &NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); } pGetLanRes->ConfigData.IPv6_LinkAddrPrefix = NWConfig6.GlobalPrefix[(pGetLanReq->SetSelect & 0x0F)]; return sizeof(GetLanCCRev_T) + sizeof(INT8U); break; case LAN_PARAMS_AMI_OEM_IPV6_LINK_ADDR_PREFIX: nwReadNWCfg_v4_v6( &NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); pGetLanRes->ConfigData.IPv6_LinkAddrPrefix = NWConfig6.LinkPrefix; return sizeof(GetLanCCRev_T) + sizeof(INT8U); break; case LAN_PARAMS_AMI_OEM_IPV6_GATEWAY_IP: if((g_corefeatures.delayed_lan_restart_support) && (pBMCInfo->LANCfs[EthIndex].IPv6_IPAddrSrc == STATIC_IP_SOURCE)) { if((pBMCInfo->LANCfs[EthIndex].IPv6_Enable)) { _fmemcpy (NWConfig6.Gateway,pBMCInfo->LANCfs[EthIndex].IPv6_GatewayIPAddr, IP6_ADDR_LEN); } else { memset(&NWConfig6, 0, sizeof(NWConfig6)); } } else { nwReadNWCfg_v4_v6( &NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); } _fmemcpy (pGetLanRes->ConfigData.IPv6_GatewayIPAddr, NWConfig6.Gateway, IP6_ADDR_LEN); return sizeof(GetLanCCRev_T) + IP6_ADDR_LEN; break; case LAN_PARAMS_AMI_OEM_PHY_SETTINGS: memset(IfcName, 0, sizeof(IfcName)); if(GetIfcNameByIndex(EthIndex, IfcName) != 0) { TCRIT("Error in Getting Interface Name for the lan Index:%d\n",EthIndex); } if(nwGetEthInformation(&PHYCfg, IfcName) !=0) { pGetLanRes->CCParamRev.CompletionCode = CC_UNSPECIFIED_ERR; return sizeof(GetLanCCRev_T); } pGetLanRes->ConfigData.PHYConfig.Interface = EthIndex; pGetLanRes->ConfigData.PHYConfig.AutoNegotiationEnable = PHYCfg.autoneg; pGetLanRes->ConfigData.PHYConfig.Speed = PHYCfg.speed; pGetLanRes->ConfigData.PHYConfig.Duplex = PHYCfg.duplex; pGetLanRes->ConfigData.PHYConfig.CapabilitiesSupported = PHYCfg.supported; return sizeof(GetLanCCRev_T) + sizeof(PHYConfig_T); case LAN_PARAMS_AMI_OEM_MTU_SETTINGS: memset(IfcName,0,sizeof(IfcName)); if(GetIfcNameByIndex(EthIndex, IfcName) != 0) { TCRIT("Error in Getting Interface Name for the lan Index:%d\n",EthIndex); pGetLanRes->CCParamRev.CompletionCode = CC_UNSPECIFIED_ERR; return sizeof(GetLanCCRev_T); } if(nwGetEthInformation(&PHYCfg, IfcName) !=0) { pGetLanRes->CCParamRev.CompletionCode = CC_UNSPECIFIED_ERR; return sizeof(GetLanCCRev_T); } pGetLanRes->ConfigData.MTU_size = PHYCfg.maxtxpkt; return sizeof(GetLanCCRev_T) + sizeof(INT16U); case LAN_PARAMS_SSI_OEM_2ND_PRI_ETH_MAC_ADDR: if(g_corefeatures.ssi_support == ENABLED) { netindex = 0x1; /* Specify the 2nd interface */ nwReadNWCfg_v4_v6(&NWConfig, &NWConfig6, netindex,g_corefeatures.global_ipv6); _fmemcpy(pGetLanRes->ConfigData.SSI2ndPriEthMACAddr, NWConfig.MAC, MAC_ADDR_LEN); return sizeof(GetLanCCRev_T) + sizeof(pGetLanRes->ConfigData.SSI2ndPriEthMACAddr); } else { pGetLanRes->CCParamRev.CompletionCode = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } break; case LAN_PARAMS_SSI_OEM_LINK_CTRL: if(g_corefeatures.ssi_support == ENABLED) { pGetLanRes->ConfigData.SSILinkControl = 0; pChannelInfo = getChannelInfo(pBMCInfo->RMCPLAN1Ch, BMCInst); if(NULL == pChannelInfo) { *pRes = CC_UNSPECIFIED_ERR; return sizeof (*pRes); } if (pChannelInfo->AccessMode == 0x02) /* If 1st channal is available */ pGetLanRes->ConfigData.SSILinkControl |= BIT0; NIC_Count = g_coremacros.global_nic_count; if (NIC_Count == 2) { pChannelInfo = getChannelInfo(pBMCInfo->RMCPLAN2Ch, BMCInst); if(NULL == pChannelInfo) { *pRes = CC_UNSPECIFIED_ERR; return sizeof (*pRes); } if (pChannelInfo->AccessMode == 0x02) /* If 2nd channal is available */ pGetLanRes->ConfigData.SSILinkControl |= BIT1; } return sizeof(GetLanCCRev_T) + sizeof(pGetLanRes->ConfigData.SSILinkControl); } else { pGetLanRes->CCParamRev.CompletionCode = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } break; case LAN_PARAMS_SSI_OEM_CMM_IP_ADDR: if(g_corefeatures.ssi_support == ENABLED) { _fmemcpy (pGetLanRes->ConfigData.CMMIPAddr, pBMCInfo->SSIConfig.CMMIPAddr, IP_ADDR_LEN); return sizeof(GetLanCCRev_T) + sizeof(pGetLanRes->ConfigData.CMMIPAddr); } else { pGetLanRes->CCParamRev.CompletionCode = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } break; default: if(g_corefeatures.ncsi_cmd_support == ENABLED) { switch(pGetLanReq->ParameterSelect) { case LAN_PARAMS_AMI_OEM_NCSI_CONFIG_NUM: NCSIGetTotalPorts(&ncsiPortConfigNum); if (ncsiPortConfigNum >= 0xFF) { pGetLanRes->CCParamRev.CompletionCode = CC_INV_DATA_FIELD; return sizeof(GetLanCCRev_T); } else { pGetLanRes->ConfigData.NumNCSIPortConfigs = ncsiPortConfigNum; return sizeof(GetLanCCRev_T) + sizeof(INT8U); } break; case LAN_PARAMS_AMI_OEM_NCSI_SETTINGS: { NIC_Count=g_coremacros.global_nic_count; if (pGetLanReq->SetSelect >= NIC_Count) { pGetLanRes->CCParamRev.CompletionCode = CC_INV_DATA_FIELD; return sizeof(GetLanCCRev_T); } NCSIConfig_T configData; char interfaceName[8]; memset(&configData, 0, sizeof(NCSIConfig_T)); memset(interfaceName, 0, sizeof(interfaceName)); snprintf(interfaceName, sizeof(interfaceName), "%s%d", "eth", pGetLanReq->SetSelect); if (NCSIGetPortConfigByName(interfaceName, &configData) != 0) { pGetLanRes->CCParamRev.CompletionCode = CC_INV_DATA_FIELD; return sizeof(GetLanCCRev_T); } if (configData.PackageId >= 0xFF || configData.ChannelId >= 0xFF) { pGetLanRes->CCParamRev.CompletionCode = CC_INV_DATA_FIELD; return sizeof(GetLanCCRev_T); } pGetLanRes->ConfigData.NCSIPortConfig.Interface = pGetLanReq->SetSelect; pGetLanRes->ConfigData.NCSIPortConfig.PackageId = configData.PackageId; pGetLanRes->ConfigData.NCSIPortConfig.ChannelId = configData.ChannelId; return sizeof(GetLanCCRev_T) + sizeof(NCSIPortConfig_T); } break; case LAN_PARAMS_AMI_OEM_NCSI_MODE_CHANGE: { NIC_Count=g_coremacros.global_nic_count; if (pGetLanReq->SetSelect >= NIC_Count) { pGetLanRes->CCParamRev.CompletionCode = CC_INV_DATA_FIELD; return sizeof(GetLanCCRev_T); } NCSIConfig_T configData; char interfaceName[8]; memset(&configData, 0, sizeof(NCSIConfig_T)); memset(interfaceName, 0, sizeof(interfaceName)); snprintf(interfaceName, sizeof(interfaceName), "%s%d", "eth", pGetLanReq->SetSelect); if (NCSIGetPortConfigByName(interfaceName, &configData) != 0) { pGetLanRes->CCParamRev.CompletionCode = CC_INV_DATA_FIELD; return sizeof(GetLanCCRev_T); } if (configData.AutoSelect>= 0xFF) { pGetLanRes->CCParamRev.CompletionCode = CC_INV_DATA_FIELD; return sizeof(GetLanCCRev_T); } pGetLanRes->ConfigData.NCSIModeConfig.Interface = pGetLanReq->SetSelect; pGetLanRes->ConfigData.NCSIModeConfig.NCSIMode = configData.AutoSelect; return sizeof(GetLanCCRev_T) + sizeof(NCSIModeConfig_T); } break; case LAN_PARAMS_AMI_OEM_NCSI_EXTENSION: { char ncsi_default_ifc[IFNAMSIZ + 1] = "eth1"; if ((pGetLanReq->SetSelect == 0x20) && (g_corefeatures.ncsi_keep_phy_linkup_support == ENABLED)) { NIC_Count=g_coremacros.global_nic_count; NCSIConfig_T configData; char interfaceName[8]; memset(&configData, 0, sizeof(NCSIConfig_T)); memset(interfaceName, 0, sizeof(interfaceName)); GetMacrodefine_string("CONFIG_SPX_FEATURE_NCSI_DEFAULT_INTERFACE", ncsi_default_ifc); snprintf(interfaceName, sizeof(interfaceName), "%s", ncsi_default_ifc); if (NCSIGetPortConfigByName(interfaceName, &configData) != 0) { pGetLanRes->CCParamRev.CompletionCode = CC_INV_DATA_FIELD; return sizeof(GetLanCCRev_T); } char Interface[2]; snprintf(Interface, sizeof(Interface), "%c", interfaceName[3]); pGetLanRes->ConfigData.NCSIPHYConfigGet.Interface = atoi(Interface); pGetLanRes->ConfigData.NCSIPHYConfigGet.VetoBit = configData.VetoBit; return sizeof(GetLanCCRev_T) + sizeof(NCSIPHYConfigGet_T); } else { pGetLanRes->CCParamRev.CompletionCode = CC_PARAM_NOT_SUPPORTED; return sizeof(GetLanCCRev_T); } } break; default: TDBG("In Valid Option\n"); } } pGetLanRes->CCParamRev.CompletionCode = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } } return sizeof(GetLanCCRev_T) + LanconfigParameterLength[pGetLanReq->ParameterSelect]; } /*--------------------------------------------------- * SuspendBMCArps *---------------------------------------------------*/ int SuspendBMCArps (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { _NEAR_ SuspendBMCArpsReq_T* pArpReq = (_NEAR_ SuspendBMCArpsReq_T*) pReq; _NEAR_ SuspendBMCArpsRes_T* pArpRes = (_NEAR_ SuspendBMCArpsRes_T*) pRes; INT8U 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 (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { _NEAR_ GetIPUDPRMCPStatsReq_T* pGetIPUDPRMCPStatsReq = (_NEAR_ GetIPUDPRMCPStatsReq_T*) pReq; _NEAR_ GetIPUDPRMCPStatsRes_T* pGetIPUDPRMCPStatsRes = (_NEAR_ GetIPUDPRMCPStatsRes_T*) pRes; _FAR_ 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 (INT8U); } //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 (INT8U); } 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 (INT8U); } //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 (INT8U); } //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 *----------------------------------------------*/ INT8U UpdateArpStatus (INT8U EthIndex,BOOL IsTimerRunning, int BMCInst) { INT8U GratArpSuspend; INT8U ArpSuspend; INT8U 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; }