#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); memcpy(m_MsgPkt.Data, pSetLanReq, sizeof(SetLanConfigReq_T)); PostMsg(gPendActionIfc, &m_MsgPkt); //Update memcpy(g_BMCInfo.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"); //Update g_BMCInfo.LanInfo[index].IPAddrSrc = pSetLanReq->ConfigData.IPAddrSrc ; FlushIpmiConfig(); // if ((pSetLanReq->ConfigData.IPAddrSrc > BMC_OTHER_SOURCE) // ||(pSetLanReq->ConfigData.IPAddrSrc == UNSPECIFIED_IP_SOURCE)) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof (uint8_t); // } // if ( g_BMCInfo.IpmiConfig.IPAddrSrc == pSetLanReq->ConfigData.IPAddrSrc ) // { // printf("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 ))) // g_BMCInfo.IpmiConfig.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 (uint8_t); // } // 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,(uint8_t*) &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(*)(uint8_t))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 (uint8_t); // } // NWConfig.CfgMethod = STATIC_IP_SOURCE; // SetPendStatus(PEND_OP_SET_SOURCE,PEND_STATUS_PENDING); // PostPendTask(PEND_OP_SET_SOURCE, (uint8_t*) &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(*)(uint8_t))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: /* 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); memcpy(m_MsgPkt.Data, pSetLanReq, sizeof(SetLanConfigReq_T)); PostMsg(gPendActionIfc, &m_MsgPkt); //Update memcpy(g_BMCInfo.LanInfo[index].MACAddr, pSetLanReq->ConfigData.MACAddr, 6); FlushIpmiConfig(); printf("---> old_mac: %s, new_mac: %s\n", old_mac, macStr); pSetLanRes->CompletionCode = CC_NORMAL; } break; case LAN_PARAM_SUBNET_MASK: /*Returning valid completion code in case of attempt to set netmask in DHCP mode */ if(g_BMCInfo.LanInfo[index].IPAddrSrc == DHCP_IP_SOURCE) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (uint8_t); } 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); memcpy(m_MsgPkt.Data, pSetLanReq, sizeof(SetLanConfigReq_T)); PostMsg(gPendActionIfc, &m_MsgPkt); //Update memcpy(g_BMCInfo.LanInfo[index].NetMask, pSetLanReq->ConfigData.SubNetMask, 4); FlushIpmiConfig(); pSetLanRes->CompletionCode = CC_NORMAL; break; case LAN_PARAM_IPv4_HEADER: printf("Not implement\n"); // pendStatus = GetPendStatus(PEND_OP_SET_IPV4_HEADERS); // if(pendStatus == PEND_STATUS_PENDING) // { // *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; // return sizeof (uint8_t); // } // 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, (uint8_t*)&(pSetLanReq->ConfigData.Ipv4HdrParam), // sizeof(pSetLanReq->ConfigData.Ipv4HdrParam),(pSetLanReq->ChannelNum & 0x0F),BMCInst); break; case LAN_PARAM_PRI_RMCP_PORT: printf("Not implement\n"); //需要重启网络线程 // pendStatus = GetPendStatus(PEND_RMCP_PORT_CHANGE); // if(pendStatus == PEND_STATUS_PENDING) // { // *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; // return sizeof (uint8_t); // } // 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,(uint8_t*)&(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 (uint8_t); /*pPMConfig->LANConfig[EthIndex].SecondaryPort = ipmitoh_u16 (pSetLanReq->ConfigData.SecondaryPort);*/ break; case LAN_PARAM_BMC_GENERATED_ARP_CONTROL: printf("Not implement\n"); // 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: printf("Not implement\n"); // pBMCInfo->LANCfs[EthIndex].GratitousARPInterval = // pSetLanReq->ConfigData.GratitousARPInterval; break; case LAN_PARAM_DEFAULT_GATEWAY_IP: /*Returning valid completion code in case of attempt to set default gateway ip in DHCP mode */ if(g_BMCInfo.LanInfo[index].IPAddrSrc == DHCP_IP_SOURCE) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof (uint8_t); } 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); memcpy(m_MsgPkt.Data, pSetLanReq, sizeof(SetLanConfigReq_T)); PostMsg(gPendActionIfc, &m_MsgPkt); //Update memcpy(g_BMCInfo.LanInfo[index].DefaultGW, pSetLanReq->ConfigData.DefaultGatewayIPAddr, 4); FlushIpmiConfig(); 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"); // nwReadNWCfg_v4_v6( &NWConfig,&NWConfig6, netindex,g_corefeatures.global_ipv6); // _fmemcpy ((uint8_t*)&GWIp,pSetLanReq->ConfigData.BackupGatewayIPAddr, IP_ADDR_LEN); // _fmemcpy ((uint8_t*)&Subnetmask,&NWConfig.Mask[0],IP_ADDR_LEN); // _fmemcpy ((uint8_t*)&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 (uint8_t); // } // } // 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: printf("Not implement\n"); // 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: printf("Not implement\n"); // if (g_PDKHandle[PDK_SETSNMPCOMMUNITYNAME] != NULL ) // { // if(((int(*)(uint8_t *, uint8_t,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(uint8_t); case LAN_PARAM_SELECT_DEST_TYPE: printf("Not implement\n"); // // 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: printf("Not implement\n"); // pendStatus = GetPendStatus(PEND_OP_SET_GATEWAY); // if(pendStatus == PEND_STATUS_PENDING) // { // *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; // return sizeof (uint8_t); // } // // 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,(uint8_t*)&NWConfig,sizeof(NWConfig),(pSetLanReq->ChannelNum & 0x0F),BMCInst); // } break; case LAN_PARAM_VLAN_ID: printf("Not implement\n"); // 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 (uint8_t); // } // 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,(uint8_t*)&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 (uint8_t); // } // SetPendStatus(PEND_OP_DECONFIG_VLAN_IFC,PEND_STATUS_PENDING); // PostPendTask(PEND_OP_DECONFIG_VLAN_IFC,(uint8_t*)&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 (uint8_t); // } // //NWConfig.VLANID=0; // NWConfig.CfgMethod = pBMCInfo->LANCfs[EthIndex].IPAddrSrc; // SetPendStatus(PEND_OP_SET_SOURCE,PEND_STATUS_PENDING); // PostPendTask(PEND_OP_SET_SOURCE,(uint8_t*) &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(uint8_t); // } break; case LAN_PARAM_VLAN_PRIORITY: printf("Not implement\n"); // 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(uint8_t); // } 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"); // 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: printf("Not implement\n"); // if (0 == pSetLanReq->ConfigData.DestAddr.SetSelect) // { // LOCK_BMC_SHARED_MEM(BMCInst); // _fmemcpy(&pSharedMem->VLANDestTag, // (( uint8_t*)&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 (uint8_t); // } // LOCK_BMC_SHARED_MEM(BMCInst); // _fmemcpy(&pBMCInfo->LANCfs[EthIndex].VLANDestTags [pSetLanReq->ConfigData.DestAddr.SetSelect - 1], // (( uint8_t*)&pSetLanReq->ConfigData) + 1, sizeof(VLANDestTags_T)); // UNLOCK_BMC_SHARED_MEM(BMCInst); // } break; case LAN_PARAMS_BAD_PASSWORD_THRESHOLD: printf("Not implement\n"); // 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; 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, int BMCInst) // { // GetLanConfigReq_T* pGetLanReq = ( GetLanConfigReq_T*) pReq; // GetLanConfigRes_T* pGetLanRes = ( GetLanConfigRes_T*) pRes; // BMCSharedMem_T* pSharedMem = BMC_GET_SHARED_MEM (BMCInst); // uint8_t IsOemDefined = FALSE; // NWCFG_STRUCT NWConfig; // NWCFG6_STRUCT NWConfig6; // // V6DNS_CONFIG v6dnsconfig; // uint8_t EthIndex,netindex= 0xFF,i; // BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; // int ncsiPortConfigNum = 0; // ETHCFG_STRUCT PHYCfg; // ChannelInfo_T* pChannelInfo = NULL; // char IfcName[16]; /* Eth interface name */ // uint8_t ComStrLen=MAX_COMM_STRING_SIZE; // int retValue = 0,NIC_Count = 0; // 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); // } // 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(uint8_t); // } // /* Hook for OEM to handle this parameter */ // if ( (IsOemDefined) && (g_PDKHandle[PDK_GETLANOEMPARAM] != NULL) ) // { // return ((int(*)(uint8_t *, uint8_t, uint8_t *,int))(g_PDKHandle[PDK_GETLANOEMPARAM]))(pReq, ReqLen, pRes, BMCInst); // } // } // if (g_PDKHandle[PDK_BEFOREGETLANPARM] != NULL) // { // retValue = ((int(*)(uint8_t *, uint8_t, uint8_t *,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)) // { // printf("GetLanConfigParam log1\n"); // 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) // { // printf("GetLanConfigParam log2\n"); // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // EthIndex= GetEthIndex(pGetLanReq->ChannelNum & 0x0F, BMCInst); // if(0xff == EthIndex) // { // printf("GetLanConfigParam log3\n"); // *pRes = CC_INV_DATA_FIELD; // return sizeof (uint8_t); // } // /*Get the EthIndex*/ // if(GetIfcName(EthIndex,IfcName, BMCInst) != 0) // { // TCRIT("Error in Getting IfcName\n"); // *pRes = CC_INV_DATA_FIELD; // return sizeof (uint8_t); // } // 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 // { // printf("GetLanConfigParam log4\n"); // 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 (uint8_t); // /*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(*)(uint8_t *, uint8_t *,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: // *(( uint8_t*)&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 ((( uint8_t*) &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 ((( uint8_t*)&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(uint8_t); // 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(uint8_t); // 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(uint8_t); // 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(uint8_t); // } // 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(uint8_t); // } // 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(uint8_t); // 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(uint8_t); // 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(uint16_t); // 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(uint8_t); // } // 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(uint8_t); // } // 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(uint8_t); // } // 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(uint8_t); // } // 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) // { // printf("---> log5, SetSelect = %d, NIC_Count = %d\n",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(uint8_t); // } // } // 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; // }