/***************************************************************** ***************************************************************** *** ** *** (C)Copyright 2005-2006, American Megatrends Inc. ** *** ** *** All Rights Reserved. ** *** ** *** 6145-F, Northbelt Parkway, Norcross, ** *** ** *** Georgia - 30071, USA. Phone-(770)-246-8600. ** *** ** ***************************************************************** ***************************************************************** * * AMIConf.c * AMI specific configuration commands related implementation. * * Author: Benson Chuang *****************************************************************/ #include "Debug.h" #include "Support.h" #include "IPMIDefs.h" #include "AMIRestoreDefaults.h" #include "flshfiles.h" #include "flashlib.h" #include "PendTask.h" #include #include #include #include #include //#include "OSPort.h" #include "NVRData.h" #include "NVRAccess.h" #include "PMConfig.h" #include "IPMI_AMIConf.h" #include "AMIConf.h" #include "nwcfg.h" #include "Ethaddr.h" #include "MsgHndlr.h" #include "ncml.h" //#include "IPMIConf.h" #include "hostname.h" #include #include "stunnel_cfg.h" #include "unix.h" #include "Sensor.h" #include "SDR.h" #include #include "featuredef.h" #include "SEL.h" #include "blowfish.h" #include "vmedia_cfg.h" #include #include "AppDevice.h" #include "userprivilege.h" #include "Extendedpriv.h" #include "Platform.h" #include "safesystem.h" #include "LANConfig.h" #include "bmc_type.h" #define MAX_FULL_SEL_ENTRIES 0x4000 #define SNMP_LIBS "/usr/local/lib/libsnmpusers.so" #define RMS_SET "rms_set" #define DNS_PARAM_LENGTH 0x6 /* * Service commands */ char *ServiceNameList[MAX_SERVICE_NUM] = { WEB_SERVICE_NAME, KVM_SERVICE_NAME, CDMEDIA_SERVICE_NAME, FDMEDIA_SERVICE_NAME, HDMEDIA_SERVICE_NAME, SSH_SERVICE_NAME, TELNET_SERVICE_NAME, SOLSSH_SERVICE_NAME, }; /** * @brief IPTABLES Firewall configuration request parameter lengths **/ static const INT8U FirewallConfigParamLength [] = { 4+1, /* IP Address block*/ 8+1, /* IP Address Range block*/ 2+1+1, /* Port No block*/ 4+1+1, /* Port Range block*/ 4+1, /* IP Address unblock*/ 8+1, /* IP Address Range unblock*/ 2+1+1, /* Port No unblock*/ 4+1+1, /* Port Range unblock*/ 0, /* Flushing iptables */ 1+1, /* Block all */ 1+1, /* remove Block all */ }; /** * @brief IPTABLES Get Firewall configuration request parameter lengths **/ static const INT8U GetFirewallConfigParamLength [] = { 0, /* Get No Of Entries*/ 1, /* Get A Entry Info */ }; /* * @brief Network Interface Configuration request parameter length */ static const INT8U NwIfcStateConfigParamLenght [] = { 2, /*Eth Interface*/ 7, /*Bond Interface*/ }; /* * @brief DNS configuration Request parameter length */ static const INT8U NwDNSConfigParamLength[] = { 66, 0xFF, 4, 64, 3, }; /** * @brief UDS Session Information request parameter lengths **/ static const INT8U UDSSessionInfoParamLength[]={ 1, 5, 2, 2, 5, 2, 1, }; /* * RIS Configuration commands */ char *ServiceList[4] = { RMS_CD_SECTION_NAME, RMS_FD_SECTION_NAME, RMS_HD_SECTION_NAME, RMS_SET, }; /* * RIS Configuration commands length */ static const INT8U ServiceLen[] = { 3, 3, 3, 2, }; /** * @brief RIS Configuration commands request parameter lengths **/ static const INT32U ServiceParamLength [] = { 64, /*Image Name Length */ 64, /* Shared Path length*/ 63, /* IP Address Range block*/ 64, /* User Name*/ 32, /* Password*/ 6, /* share Type */ 64, /* Domain name*/ }; /** * @brief RIS media selection **/ static const INT8U ServiceParam[] = { 1,/*CD MEDIA */ 2, /* FD MEDIA*/ 4, /* HD MEDIA*/ }; //extern IfcName_T Ifcnametable[MAX_LAN_CHANNELS]; /* * DNS related commands */ INT8U CheckSlaveVLANInterface(INT8U Slaves, INT8U *VLANID, int BMCInst) { _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; char IfcName[16]; int i, j, isFirstIndex = 1; if (VLANID == NULL) return (CC_UNSPECIFIED_ERR); (*VLANID) = 0; /*Check Slaves Entry*/ for(i = 0; i < BOND_MAX_SLAVE; i++) { if( (Slaves >> i) & IFACE_ENABLED) { if(CheckIfcEntry( i, ETH_IFACE_TYPE) != 0) { IPMI_WARNING("Slave Entry %d is not presented in interface table\n",i); return (CC_INV_DATA_FIELD); } memset(IfcName, 0, sizeof(IfcName)); sprintf(IfcName,"eth%d", i); for(j = 0; j < sizeof(pBMCInfo->LanIfcConfig)/sizeof(LANIFCConfig_T); j++) { if(strcmp(IfcName, pBMCInfo->LanIfcConfig[j].ifname) == 0) { TDBG ("VLANID for %s : %d\n", IfcName, pBMCInfo->LANConfig.VLANID[j]); if (isFirstIndex == 1) { (*VLANID) = pBMCInfo->LANConfig.VLANID[j]; isFirstIndex = 0; } else { if(pBMCInfo->LANConfig.VLANID[j] != (*VLANID)) { return OEMCC_VLAN_ENABLED_ON_SLAVE; } } } } } } return 0; } /* @fn CheckVLANInterface @brief This function is used to check VLAN interface presence @params Ifcname[in] - interface name BMCInst[in] BMC instance @returns 1 on VLAN Enabled, 0 on VLAN Disabled */ int CheckVLANInterface(char* Ifcname,int BMCInst) { _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; int i; for(i=0;iLanIfcConfig)/sizeof(LANIFCConfig_T);i++) { if(strcmp(Ifcname,pBMCInfo->LanIfcConfig[i].ifname) == 0) { if(pBMCInfo->LANConfig.VLANID[i] != 0) return 1; } } return 0; } /* @fn ValidateDomainName @brief This function is used to validate the DNS Domain Name @params hostname - Domain Name to be validated @returns 1 on valid domain name , 0 on invalid domain name */ int ValidateDomainName(const char *hostname) { int count = 0; const char *c, *domain; static char *invaliddomainname = "()<>@,;:\\\"[]"; /* Here we validate the domain*/ if (!*(domain = c = hostname)) return 0; do { if (*c == '.') { if (c == domain || *(c - 1) == '.') return 0; count++; } if (*c <= ' ' || *c >= 127) return 0; if (strchr(invaliddomainname, *c)) return 0; } while (*++c); return (count >= 1); } /* @fn ValidateDNSReqInfo @brief This function is used to validate the DNS Request params DomainIndex and Domainpriority depending on DomainDHCP @params DomainDHCP - Domain DHCP/static @params DomainIndex - Domain Index @params Domainpriority - Domain Prioriry IPV4/IPV6 @returns 0 on valid set DNS conf requested, others - error codes */ int ValidateDNSReqInfo(INT8U DomainDHCP, INT8U DomainIndex, INT8U Domainpriority) { int Ifccount=0,retValue,ifcslaved=0,i; if(DomainDHCP) { Ifccount = g_coremacros.global_nic_count; if(g_corefeatures.bond_support == ENABLED) { for(i = 0; i < Ifccount; i++) // loop to check if bonding is configured { retValue = -1; retValue = CheckBondSlave(i); if(retValue == -1) { return CC_UNSPECIFIED_ERR; } if(retValue == 1) { ifcslaved = 1; if(i == DomainIndex) { return CC_IFC_ALREADY_SLAVEDTO_BOND; } break; } if(retValue != 0) { TDBG("Error in reading network configuration.\n"); return CC_UNSPECIFIED_ERR; } } } switch(ifcslaved) { case BONDING_ACTIVE: if(Domainpriority != 1) // Currently IPV6 is not supported for Bonding, so filtering IPV6 request { return CC_DNS_CURRENTLY_NOT_SUPPORTED_FOR_IPV6; } break; case BONDING_NOTACTIVE: for(i=0;i<(sizeof(Ifcnametable)/sizeof(Ifcnametable[0]));i++) { if(strstr(Ifcnametable[i].Ifcname,"bond")) { if(Ifcnametable[i].Index == DomainIndex) { return CC_INV_DATA_FIELD; } } } if((Domainpriority != 1) && (Domainpriority != 2)) // filter domain priorities other then ipv4 and ipv6 { return CC_INV_DATA_FIELD; } break; default: TCRIT("Unable to read the interface state of bonding\n"); } } else { if(DomainIndex || Domainpriority) { return CC_INV_DATA_FIELD; } } return 0; } int AMIGetDNSConf( _NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes,int BMCInst) { _NEAR_ AMIGetDNSConfReq_T* pAMIGetDNSConfReq = (_NEAR_ AMIGetDNSConfReq_T*) pReq; _NEAR_ AMIGetDNSConfRes_T* pAMIGetDNSConfRes = (_NEAR_ AMIGetDNSConfRes_T*) pRes; HOSTNAMECONF HostnameConfig; DOMAINCONF DomainConfig; DNSCONF DnsIPConfig; INT8U regBMC_FQDN[MAX_LAN_CHANNELS]; INT8U Ifccount; memset(&HostnameConfig, 0, sizeof(HostnameConfig)); memset(&DomainConfig, 0, sizeof(DomainConfig)); memset(&DnsIPConfig, 0, sizeof(DnsIPConfig)); memset(regBMC_FQDN, 0, sizeof(regBMC_FQDN)); /*Validate the Block selector*/ if( 0 != pAMIGetDNSConfReq->Blockselect && (pAMIGetDNSConfReq->Param != AMI_DNS_CONF_DOMAIN_NAME ) && (pAMIGetDNSConfReq->Param != AMI_DNS_CONF_DNS_IP)) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } nwGetAllDNSConf( &HostnameConfig, &DomainConfig, &DnsIPConfig,regBMC_FQDN ); pAMIGetDNSConfRes->CompletionCode = CC_SUCCESS; switch(pAMIGetDNSConfReq->Param) { case AMI_DNS_CONF_HOST_NAME: memset(&pAMIGetDNSConfRes->DNSCfg.HName,0,sizeof(HOSTNAMECONF)); pAMIGetDNSConfRes->DNSCfg.HName.HostSetting = HostnameConfig.HostSetting; pAMIGetDNSConfRes->DNSCfg.HName.HostNameLen= HostnameConfig.HostNameLen; memcpy(pAMIGetDNSConfRes->DNSCfg.HName.HostName,HostnameConfig.HostName,HostnameConfig.HostNameLen); return sizeof(INT8U) + sizeof(HOSTNAMECONF); break; case AMI_DNS_CONF_REGISTER: if(g_corefeatures.bond_support == ENABLED) { Ifccount = g_coremacros.global_nic_count + 1; //count for bond interface } else { Ifccount = g_coremacros.global_nic_count; } memcpy(pAMIGetDNSConfRes->DNSCfg.RegDNSConf,regBMC_FQDN,Ifccount); return sizeof(INT8U) + Ifccount; break; case AMI_DNS_CONF_DOMAIN_SETTINGS: pAMIGetDNSConfRes->DNSCfg.DomainConf.DomainDHCP = DomainConfig.dhcpEnable; pAMIGetDNSConfRes->DNSCfg.DomainConf.DomainIndex = DomainConfig.EthIndex; pAMIGetDNSConfRes->DNSCfg.DomainConf.Domainpriority= DomainConfig.v4v6; pAMIGetDNSConfRes->DNSCfg.DomainConf.DomainLen= DomainConfig.domainnamelen; return sizeof(INT8U) + sizeof(DomainSetting); break; case AMI_DNS_CONF_DOMAIN_NAME: if(pAMIGetDNSConfReq->Blockselect > MAX_BLOCK || pAMIGetDNSConfReq->Blockselect == 0) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } memcpy(pAMIGetDNSConfRes->DNSCfg.DomainName,&DomainConfig.domainname[MAX_DOMAIN_BLOCK_SIZE * (pAMIGetDNSConfReq->Blockselect -1)],MAX_DOMAIN_BLOCK_SIZE); return sizeof(INT8U) + MAX_DOMAIN_BLOCK_SIZE; break; case AMI_DNS_CONF_DNS_SETTING: pAMIGetDNSConfRes->DNSCfg.DNSConf.IPPriority = DnsIPConfig.IPPriority; pAMIGetDNSConfRes->DNSCfg.DNSConf.DNSDHCP = DnsIPConfig.DNSDHCP; pAMIGetDNSConfRes->DNSCfg.DNSConf.DNSIndex = DnsIPConfig.DNSIndex; return sizeof(INT8U) + sizeof(DNSSetting); break; case AMI_DNS_CONF_DNS_IP: if(pAMIGetDNSConfReq->Blockselect == 1) { if(IN6_IS_ADDR_V4MAPPED(&DnsIPConfig.DNSIP1)) { memcpy(pAMIGetDNSConfRes->DNSCfg.DNSIPAddr,&DnsIPConfig.DNSIP1[IP6_ADDR_LEN - IP_ADDR_LEN],IP_ADDR_LEN); return sizeof(INT8U) + IP_ADDR_LEN; } else { memcpy(pAMIGetDNSConfRes->DNSCfg.DNSIPAddr,DnsIPConfig.DNSIP1,IP6_ADDR_LEN); return sizeof(INT8U) + IP6_ADDR_LEN; } } else if(pAMIGetDNSConfReq->Blockselect == 2) { if(IN6_IS_ADDR_V4MAPPED(&DnsIPConfig.DNSIP2)) { memcpy(pAMIGetDNSConfRes->DNSCfg.DNSIPAddr,&DnsIPConfig.DNSIP2[IP6_ADDR_LEN - IP_ADDR_LEN],IP_ADDR_LEN); return sizeof(INT8U) + IP_ADDR_LEN; } else { memcpy(pAMIGetDNSConfRes->DNSCfg.DNSIPAddr,DnsIPConfig.DNSIP2,IP6_ADDR_LEN); return sizeof(INT8U) + IP6_ADDR_LEN; } } else if(pAMIGetDNSConfReq->Blockselect == 3) { if(IN6_IS_ADDR_V4MAPPED(&DnsIPConfig.DNSIP3)) { memcpy(pAMIGetDNSConfRes->DNSCfg.DNSIPAddr,&DnsIPConfig.DNSIP3[IP6_ADDR_LEN - IP_ADDR_LEN],IP_ADDR_LEN); return sizeof(INT8U) + IP_ADDR_LEN; } else { memcpy(pAMIGetDNSConfRes->DNSCfg.DNSIPAddr,DnsIPConfig.DNSIP3,IP6_ADDR_LEN); return sizeof(INT8U) + IP6_ADDR_LEN; } } else { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } break; case AMI_DNS_CONF_DNS_RESTART: *pRes = OEMCC_ATTEMPT_TO_GET_WO_PARAM; return sizeof(INT8U); break; case AMI_DNS_CONF_DNS_ENABLE: pAMIGetDNSConfRes->DNSCfg.DNSEnable = DnsIPConfig.DNSEnable; return sizeof(INT8U) + sizeof(INT8U); break; default: *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); break; } return(sizeof(AMIGetDNSConfRes_T)); } int AMISetDNSConf( _NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes,int BMCInst) { _NEAR_ AMISetDNSConfRes_T *pAMISetDNSConfRes = (_NEAR_ AMISetDNSConfRes_T *)pRes; _NEAR_ AMISetDNSConfReq_T *pAMISetDNSConfReq = (_NEAR_ AMISetDNSConfReq_T*)pReq; // _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; int i,domainnamelength=0; INT8U Ifccount, retValue, ifcslaved=0,status=-1,*curchannel; char *ptr = NULL; UINT8 reservedBit = REG_BMC_RESERVED; int sizeWritten = 0; FILE *fp = NULL; char tsigprivate[255] = {0}; if(ReqLen >= 2) { ReqLen -= 2; } else { *pRes = CC_REQ_INV_LEN; return sizeof(INT8U); } if(g_corefeatures.online_flashing_support == ENABLED) { if(IsCardInFlashMode()) { IPMI_WARNING("Card in Active flash mode, Not safe to set any of network configurations...\n"); *pRes = CC_DEV_IN_FIRMWARE_UPDATE_MODE; return sizeof(INT8U); } } if(DNS_PARAM_LENGTH > pAMISetDNSConfReq->ParamSelect) { if( (ReqLen != NwDNSConfigParamLength[pAMISetDNSConfReq->ParamSelect - 1]) && ((NwDNSConfigParamLength[pAMISetDNSConfReq->ParamSelect - 1])!=0xFF) ) { TDBG("ReqLen %ld\n",ReqLen); *pRes = CC_REQ_INV_LEN; return sizeof(INT8U); } } /*Validate the Block selector*/ if( 0 != pAMISetDNSConfReq->Blockselector && (pAMISetDNSConfReq->ParamSelect != AMI_DNS_CONF_DOMAIN_NAME ) && (pAMISetDNSConfReq->ParamSelect != AMI_DNS_CONF_DNS_IP)) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } switch(pAMISetDNSConfReq->ParamSelect) { case AMI_DNS_CONF_HOST_NAME: /*Reserved bit checking*/ if(pAMISetDNSConfReq->DnsConfig.HName.HostSetting > 0x1) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } /*Check the Maximum host name length i.e user can send 63 bytes and last one is null character*/ if(pAMISetDNSConfReq->DnsConfig.HName.HostNameLen > MAX_HOSTNAME_LEN - 1) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } TDBG("HostName Setting %d and Length %d\n",pAMISetDNSConfReq->DnsConfig.HName.HostSetting,pAMISetDNSConfReq->DnsConfig.HName.HostNameLen); LOCK_BMC_SHARED_MEM(BMCInst); BMC_GET_SHARED_MEM (BMCInst)->DNSconf.HostSetting = pAMISetDNSConfReq->DnsConfig.HName.HostSetting; BMC_GET_SHARED_MEM (BMCInst)->DNSconf.HostNameLen = pAMISetDNSConfReq->DnsConfig.HName.HostNameLen; memcpy(BMC_GET_SHARED_MEM (BMCInst)->DNSconf.HostName,pAMISetDNSConfReq->DnsConfig.HName.HostName,pAMISetDNSConfReq->DnsConfig.HName.HostNameLen); UNLOCK_BMC_SHARED_MEM(BMCInst); break; case AMI_DNS_CONF_REGISTER: /*Added the validation to check the request data when the NIC count is 2. This check will be removed once we support 4 NIC*/ if((g_coremacros.global_nic_count < MAX_LAN_CHANNELS) && (ReqLen!=3)) { *pRes = CC_REQ_INV_LEN ; return sizeof(INT8U); } // Allow setting this parameter only if DNS Service is enabled if(BMC_GET_SHARED_MEM(BMCInst)->DNSconf.DNSEnable == 0) { TCRIT("DNS is currently disabled. Dissallowing to set the dns configurations...\n"); *pRes = CC_DNS_CURRENTLY_NOT_ENABLED; return sizeof(INT8U); } if(g_corefeatures.bond_support == ENABLED) { if(g_coremacros.global_nic_count < MAX_LAN_CHANNELS) Ifccount = g_coremacros.global_nic_count + 1; //count for bond interface else Ifccount = g_coremacros.global_nic_count; // for 4 NIC supported BMC for(i = 0; i < Ifccount; i++) { retValue = -1; retValue = CheckBondSlave(i); if(retValue == -1) { *pRes = CC_UNSPECIFIED_ERR; return sizeof(INT8U); } if(retValue == 1) { ifcslaved = 1; if(pAMISetDNSConfReq->DnsConfig.RegDNSConf[i]) { *pRes = CC_IFC_ALREADY_SLAVEDTO_BOND; return sizeof(INT8U); } } if(retValue != 0) TDBG("Error in reading network configuration.\n"); if((i == (Ifccount-1)) && (ifcslaved == 0)) { if( Ifccount != MAX_LAN_CHANNELS) { if (pAMISetDNSConfReq->DnsConfig.RegDNSConf[g_coremacros.global_nic_count]) { TDBG("Attempted to set DNS Conf for Bonding Interface, which is inactive\n"); *pRes = CC_BOND_DISABLED_TOCONF_DNS; return sizeof(INT8U); } } } } } else { Ifccount = g_coremacros.global_nic_count; if(Ifccount < MAX_LAN_CHANNELS) { if (pAMISetDNSConfReq->DnsConfig.RegDNSConf[Ifccount]) { TDBG("Attempted to set DNS Conf for Bonding Interface, which is inactive\n"); *pRes = CC_BOND_DISABLED_TOCONF_DNS; return sizeof(INT8U); } } } if (g_corefeatures.tsig_support == ENABLED) { reservedBit = reservedBit & REG_BMC_RESERVED_TSIG; } for(i = 0; i < Ifccount; i++) { if(pAMISetDNSConfReq->DnsConfig.RegDNSConf[i] & reservedBit) { TDBG("Register value %d\n",pAMISetDNSConfReq->DnsConfig.RegDNSConf[i]); *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } if (((pAMISetDNSConfReq->DnsConfig.RegDNSConf[i] & REG_BMC_FQDN) == REG_BMC_FQDN) && ((pAMISetDNSConfReq->DnsConfig.RegDNSConf[i] & REG_BMC_TSIG) == REG_BMC_TSIG)) { TCRIT("TSIG can't be enabled with FQDN support"); *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } if(((pAMISetDNSConfReq->DnsConfig.RegDNSConf[i] & REG_BMC_FQDN) == REG_BMC_FQDN) && ((pAMISetDNSConfReq->DnsConfig.RegDNSConf[i] & REG_BMC_HOSTNAME) == REG_BMC_HOSTNAME)) { TCRIT("AMISetDNSConf(): Enabling both FQDN and Hostname options is not allowable as these are options of DHCP"); *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } } TDBG("DNS Register Settings %d %d %d\n",pAMISetDNSConfReq->DnsConfig.RegDNSConf[0],pAMISetDNSConfReq->DnsConfig.RegDNSConf[1],pAMISetDNSConfReq->DnsConfig.RegDNSConf[2]); LOCK_BMC_SHARED_MEM(BMCInst); memcpy(BMC_GET_SHARED_MEM (BMCInst)->DNSconf.RegisterBMC,pAMISetDNSConfReq->DnsConfig.RegDNSConf,Ifccount); UNLOCK_BMC_SHARED_MEM(BMCInst); break; case AMI_DNS_CONF_TSIG_UPLOAD: if (g_corefeatures.tsig_support == ENABLED) { /* Check Requested Length */ if ((ReqLen > MAX_TSIG_PRIVKEY_SIZE) || (ReqLen <= 0)) { TCRIT("Invalid Request Length\n"); *pRes = CC_REQ_INV_LEN; return sizeof(INT8U); } fp = fopen(TEMP_TSIG_PRIVATE_FILE, "wb"); if (fp == NULL) { TCRIT("Error in Opening File\n"); *pRes = CC_UNSPECIFIED_ERR; return sizeof(INT8U); } sizeWritten = fwrite(&pAMISetDNSConfReq->DnsConfig.PrivateKey[0], 1, ReqLen, fp); if (sizeWritten != ReqLen) { TCRIT("Error in writing into the file\n"); fclose(fp); *pRes = CC_UNSPECIFIED_ERR; return sizeof(INT8U); } fclose(fp); /* Now Open the File for validation */ fp = fopen(TEMP_TSIG_PRIVATE_FILE, "rb"); if(fp == NULL) { TCRIT("Error in Opening File\n"); unlink(TEMP_TSIG_PRIVATE_FILE); *pRes = CC_UNSPECIFIED_ERR; return sizeof(INT8U); } //HMAC-MD5 Algorithm type check ptr = fgets(tsigprivate, sizeof(tsigprivate)-1, fp);//read 1st line ptr = fgets(tsigprivate, sizeof(tsigprivate)-1, fp); if (strcmp(tsigprivate, TSIG_ALG_TYPE_HMAC_MD5) != 0) { TCRIT("The private key's algorithm is not HMAC-MD5."); fclose(fp); unlink(TEMP_TSIG_PRIVATE_FILE); *pRes = CC_TSIGPRIVATEKEY_VALIDATION_FAILED; return sizeof(INT8U); } fclose(fp); if(moveFile(TEMP_TSIG_PRIVATE_FILE, CONF_TSIG_PRIVATE_FILE) != 0) { TCRIT("Error in moving TSIG private key file."); *pRes = CC_UNSPECIFIED_ERR; return sizeof(INT8U); } } else { *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } break; case AMI_DNS_CONF_DOMAIN_SETTINGS: /*Check the reserve bit*/ if(pAMISetDNSConfReq->DnsConfig.DomainConf.DomainDHCP > 1) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } status = ValidateDNSReqInfo(pAMISetDNSConfReq->DnsConfig.DomainConf.DomainDHCP, pAMISetDNSConfReq->DnsConfig.DomainConf.DomainIndex,pAMISetDNSConfReq->DnsConfig.DomainConf.Domainpriority); if(status !=0) { *pRes = status; return sizeof(INT8U); } TDBG("Domain DHCP %d\nDomainIndex %d\nDomainLen %d\nDomainpriority%d\n", pAMISetDNSConfReq->DnsConfig.DomainConf.DomainDHCP, pAMISetDNSConfReq->DnsConfig.DomainConf.DomainIndex, pAMISetDNSConfReq->DnsConfig.DomainConf.DomainLen, pAMISetDNSConfReq->DnsConfig.DomainConf.Domainpriority); LOCK_BMC_SHARED_MEM(BMCInst); BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DomainDHCP = pAMISetDNSConfReq->DnsConfig.DomainConf.DomainDHCP; BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DomainIndex = pAMISetDNSConfReq->DnsConfig.DomainConf.DomainIndex; BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DomainLen = pAMISetDNSConfReq->DnsConfig.DomainConf.DomainLen; BMC_GET_SHARED_MEM (BMCInst)->DNSconf.Domainpriority = pAMISetDNSConfReq->DnsConfig.DomainConf.Domainpriority; UNLOCK_BMC_SHARED_MEM(BMCInst); break; case AMI_DNS_CONF_DOMAIN_NAME: if( pAMISetDNSConfReq->Blockselector == 0x0 || pAMISetDNSConfReq->Blockselector > MAX_BLOCK) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } ptr = malloc(sizeof(BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DomainName)); domainnamelength = sizeof(BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DomainName); strncpy(ptr ,(char *)BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DomainName, domainnamelength); LOCK_BMC_SHARED_MEM(BMCInst); if(pAMISetDNSConfReq->Blockselector == 0x01) memset(&BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DomainName,0,(MAX_BLOCK * MAX_DOMAIN_BLOCK_SIZE)); memcpy(&BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DomainName[ MAX_DOMAIN_BLOCK_SIZE * (pAMISetDNSConfReq->Blockselector - 1)],pAMISetDNSConfReq->DnsConfig.DomainName,MAX_DOMAIN_BLOCK_SIZE); // Validate the Domain Name if the domain name is of length DomainLen, which is set by user if(strlen((char *)BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DomainName) >= BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DomainLen) { if((ValidateDomainName((char *)BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DomainName)) == INVALID_DOMAIN_NAME) { strncpy((char *)BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DomainName, ptr, domainnamelength); UNLOCK_BMC_SHARED_MEM(BMCInst); free(ptr); ptr = NULL; TDBG("Validating Domain name has fialed\n"); *pRes = CC_INV_DOMAIN_NAME; return sizeof(INT8U); } } else if(strlen((char *)BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DomainName) > BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DomainLen) { strncpy((char *)BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DomainName, ptr, domainnamelength); UNLOCK_BMC_SHARED_MEM(BMCInst); free(ptr); ptr = NULL; TDBG("Domain Name Length is Greater than the preset param DomainLen(set for Domain Name)\n"); *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } UNLOCK_BMC_SHARED_MEM(BMCInst); free(ptr); ptr = NULL; break; case AMI_DNS_CONF_DNS_SETTING: /*Check the reserve bits*/ if((pAMISetDNSConfReq->DnsConfig.DNSConf.DNSDHCP > 1) || (pAMISetDNSConfReq->DnsConfig.DNSConf.IPPriority > 2)) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } status = ValidateDNSReqInfo(pAMISetDNSConfReq->DnsConfig.DNSConf.DNSDHCP, pAMISetDNSConfReq->DnsConfig.DNSConf.DNSIndex, pAMISetDNSConfReq->DnsConfig.DNSConf.IPPriority); if(status !=0) { *pRes = status; return sizeof(INT8U); } TDBG("IPPriority %d\n",pAMISetDNSConfReq->DnsConfig.DNSConf.IPPriority); LOCK_BMC_SHARED_MEM(BMCInst); BMC_GET_SHARED_MEM (BMCInst)->DNSconf.IPPriority = pAMISetDNSConfReq->DnsConfig.DNSConf.IPPriority; BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DNSDHCP = pAMISetDNSConfReq->DnsConfig.DNSConf.DNSDHCP; BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DNSIndex = pAMISetDNSConfReq->DnsConfig.DNSConf.DNSIndex; UNLOCK_BMC_SHARED_MEM(BMCInst); break; case AMI_DNS_CONF_DNS_IP: if( pAMISetDNSConfReq->Blockselector == 0x0 || pAMISetDNSConfReq->Blockselector > MAX_DNS_IP_ADDRESS) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } if((ReqLen != IP_ADDR_LEN) && (ReqLen != IP6_ADDR_LEN)) { TDBG("Reqlen %ld\n",ReqLen); *pRes = CC_REQ_INV_LEN; return sizeof(INT8U); } /*Validate the IPv6 address*/ if(ReqLen == IP6_ADDR_LEN && 0 != IsValidGlobalIPv6Addr((struct in6_addr*)&pAMISetDNSConfReq->DnsConfig.DNSIPAddr)) { TCRIT("Invalid Global IPv6 Address\n"); *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } TDBG("Block Selector %d\n",pAMISetDNSConfReq->Blockselector); LOCK_BMC_SHARED_MEM(BMCInst); if(pAMISetDNSConfReq->Blockselector == 1) { memset(&BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DNSIPAddr1,0,IP6_ADDR_LEN); if(ReqLen == IP_ADDR_LEN) { BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DNSIPAddr1[10] = 0xFF; BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DNSIPAddr1[11] = 0xFF; memcpy(&BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DNSIPAddr1[12],pAMISetDNSConfReq->DnsConfig.DNSIPAddr,ReqLen); TDBG("DNS ipv4 address %d %d %d %d\n",pAMISetDNSConfReq->DnsConfig.DNSIPAddr[0],pAMISetDNSConfReq->DnsConfig.DNSIPAddr[1], pAMISetDNSConfReq->DnsConfig.DNSIPAddr[2],pAMISetDNSConfReq->DnsConfig.DNSIPAddr[3]); } else { memcpy(BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DNSIPAddr1,pAMISetDNSConfReq->DnsConfig.DNSIPAddr,ReqLen); } } else if(pAMISetDNSConfReq->Blockselector == 2) { memset(&BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DNSIPAddr2,0,IP6_ADDR_LEN); if(ReqLen == IP_ADDR_LEN) { BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DNSIPAddr2[10] = 0xFF; BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DNSIPAddr2[11] = 0xFF; memcpy(&BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DNSIPAddr2[12],pAMISetDNSConfReq->DnsConfig.DNSIPAddr,ReqLen); } else { memcpy(BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DNSIPAddr2,pAMISetDNSConfReq->DnsConfig.DNSIPAddr,ReqLen); } } else if(pAMISetDNSConfReq->Blockselector == 3) { memset(&BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DNSIPAddr3,0,IP6_ADDR_LEN); if(ReqLen == IP_ADDR_LEN) { BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DNSIPAddr3[10] = 0xFF; BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DNSIPAddr3[11] = 0xFF; memcpy(&BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DNSIPAddr3[12],pAMISetDNSConfReq->DnsConfig.DNSIPAddr,ReqLen); TDBG("DNS ipv4 address %d %d %d %d\n",pAMISetDNSConfReq->DnsConfig.DNSIPAddr[0],pAMISetDNSConfReq->DnsConfig.DNSIPAddr[1], pAMISetDNSConfReq->DnsConfig.DNSIPAddr[2],pAMISetDNSConfReq->DnsConfig.DNSIPAddr[3]); } else { memcpy(BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DNSIPAddr3,pAMISetDNSConfReq->DnsConfig.DNSIPAddr,ReqLen); } } UNLOCK_BMC_SHARED_MEM(BMCInst); break; case AMI_DNS_CONF_DNS_RESTART: if(ReqLen != 0) { *pRes = CC_REQ_INV_LEN; return sizeof(INT8U); } SetPendStatus(PEND_OP_SET_ALL_DNS_CFG,PEND_STATUS_PENDING); OS_THREAD_TLS_GET(g_tls.CurChannel,curchannel); PostPendTask(PEND_OP_SET_ALL_DNS_CFG, 0, 0,*curchannel & 0xF,BMCInst); break; case AMI_DNS_CONF_DNS_ENABLE: /* Validate the request byte */ if(pAMISetDNSConfReq->DnsConfig.DNSEnable > 1) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } /* Update the shared memory */ LOCK_BMC_SHARED_MEM(BMCInst); BMC_GET_SHARED_MEM (BMCInst)->DNSconf.DNSEnable = pAMISetDNSConfReq->DnsConfig.DNSEnable; UNLOCK_BMC_SHARED_MEM(BMCInst); /* If we disable the DNS service, disable the registrations of BMC hostname too... */ if(pAMISetDNSConfReq->DnsConfig.DNSEnable == 0) { LOCK_BMC_SHARED_MEM(BMCInst); for(i = 0; i < MAX_LAN_CHANNELS; i++) BMC_GET_SHARED_MEM(BMCInst)->DNSconf.RegisterBMC[i] = 0; UNLOCK_BMC_SHARED_MEM(BMCInst); } break; default: *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); break; } pAMISetDNSConfRes->CompletionCode = CC_SUCCESS; return(sizeof(AMISetDNSConfRes_T)); } /* *@fn GetINT32UBitsNum *@brief This function will check which bit number is "1" in a value with INT32 type, * but only one bit number will be allowed to be "1". *@param value - The input value *@param bitnum - Which bit number is "1". *@return Returns -1 on failure * Returns 0 on success */ static int GetINT32UBitsNum (INT32U value, INT8U *bitnum) { const INT8U startbit = 0; const INT8U endbit = 31; INT32U mask = 0x00000000; INT32U count = 0; INT8U i = 0; for(i=startbit;i<=endbit;i++) { mask = (1< 0) && (service_bit <= HDMEDIA_SERVICE_ID_BIT)) { /* Update the stunnel configuration when ports change for kvm & media services */ UpdateStunnelEntry(ServiceNameList[service_bit]); if (send_signal_by_name("Adviserd", SIGALRM) != 0) { TDBG ("Unable to send the signal to the requested process\n"); } } switch (service_bit) { case WEB_SERVICE_ID_BIT: if(stat("/etc/init.d/webgo.sh",&buf) == 0) { safe_system("/etc/init.d/webgo.sh restart &"); } else if(stat("/etc/init.d/lighttpd.sh",&buf) == 0) { safe_system("/etc/init.d/lighttpd.sh restart &"); } break; case KVM_SERVICE_ID_BIT: safe_system("/etc/init.d/adviserd.sh restart &"); break; case CDMEDIA_SERVICE_ID_BIT: safe_system("/etc/init.d/cdserver restart &"); break; case FDMEDIA_SERVICE_ID_BIT: safe_system("/etc/init.d/fdserver restart &"); break; case HDMEDIA_SERVICE_ID_BIT: safe_system("/etc/init.d/hdserver restart &"); break; case SSH_SERVICE_ID_BIT: safe_system("/etc/init.d/ssh stop"); safe_system("/etc/init.d/ssh start"); break; case TELNET_SERVICE_ID_BIT: safe_system("/etc/init.d/telnetd stop"); safe_system("/etc/init.d/telnetd start &"); break; default : break; } return 0; } int AMIGetServiceConf( _NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes,int BMCInst) { _NEAR_ AMIGetServiceConfReq_T* pAMIGetServiceConfReq = (_NEAR_ AMIGetServiceConfReq_T*) pReq; _NEAR_ AMIGetServiceConfRes_T* pAMIGetServiceConfRes = (_NEAR_ AMIGetServiceConfRes_T*) pRes; SERVICE_CONF_STRUCT conf; INT32U Value = 0; INT8U ServiceIDBit = 0; int ServiceErr = 0; /* Match the service_id byte with ServiceName */ Value = (pAMIGetServiceConfReq->ServiceID); ServiceErr = GetINT32UBitsNum (Value, &ServiceIDBit); if(ServiceErr < 0) { TCRIT("Error in getting bit number from service_id\n"); *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } if(ServiceNameList[ServiceIDBit] == NULL) { TCRIT("ServiceName is not found in ServiceNameList\n"); *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } ServiceErr = get_service_configurations(ServiceNameList[ServiceIDBit], &conf); if(ServiceErr < 0) { *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } memset(pAMIGetServiceConfRes, 0, sizeof(AMIGetServiceConfRes_T)); pAMIGetServiceConfRes->ServiceID = pAMIGetServiceConfReq->ServiceID; pAMIGetServiceConfRes->Enable = conf.CurrentState; strcpy(pAMIGetServiceConfRes->InterfaceName, conf.InterfaceName); pAMIGetServiceConfRes->InterfaceName [MAX_SERVICE_IFACE_NAME_SIZE] = '\0'; pAMIGetServiceConfRes->NonSecureAccessPort = conf.NonSecureAccessPort; pAMIGetServiceConfRes->SecureAccessPort = conf.SecureAccessPort; pAMIGetServiceConfRes->SessionInactivityTimeout = conf.SessionInactivityTimeout; pAMIGetServiceConfRes->MaxAllowSession = conf.MaxAllowSession; pAMIGetServiceConfRes->CurrentActiveSession = conf.CurrentActiveSession; pAMIGetServiceConfRes->MaxSessionInactivityTimeout= conf.MaxSessionInactivityTimeout; pAMIGetServiceConfRes->MinSessionInactivityTimeout= conf.MinSessionInactivityTimeout; TDBG( "AMIGETSERVICE: ServiceID=%lu, Enable=%d, Name=%s,\n" "port=%d, port=%d, timeout=%d, maxsession=%d, activesession=%d\n, " "MaxSessionInactivityTimeout=%d, MinSessionInactivityTimeout=%d", pAMIGetServiceConfRes->ServiceID, pAMIGetServiceConfRes->Enable, pAMIGetServiceConfRes->InterfaceName, pAMIGetServiceConfRes->NonSecureAccessPort, pAMIGetServiceConfRes->SecureAccessPort, pAMIGetServiceConfRes->SessionInactivityTimeout, pAMIGetServiceConfRes->MaxAllowSession, pAMIGetServiceConfRes->CurrentActiveSession, pAMIGetServiceConfRes->MaxSessionInactivityTimeout, pAMIGetServiceConfRes->MinSessionInactivityTimeout); pAMIGetServiceConfRes->CompletionCode = CC_SUCCESS; return(sizeof(AMIGetServiceConfRes_T)); } int AMISetServiceConf( _NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes,int BMCInst) { _NEAR_ AMISetServiceConfReq_T* pAMISetServiceConfReq = (_NEAR_ AMISetServiceConfReq_T*) pReq; _NEAR_ AMISetServiceConfRes_T* pAMISetServiceConfRes = (_NEAR_ AMISetServiceConfRes_T*) pRes; SERVICE_CONF_STRUCT conf,ReqConf; INT32U Value = 0; INT8U ServiceIDBit = 0; int ServiceErr = 0,i; int RebootService = 0; if ( '\0' != pAMISetServiceConfReq->InterfaceName[MAX_SERVICE_IFACE_NAME_SIZE]) { TCRIT("Error : The last byte must be null in Interface name \n"); *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } /* Match the service_id byte with ServiceName */ Value = (pAMISetServiceConfReq->ServiceID); ServiceErr = GetINT32UBitsNum (Value, &ServiceIDBit); if(ServiceErr < 0) { TCRIT("Error in Getting Bit Number from Service ID\n"); *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } if(ServiceNameList[ServiceIDBit] == NULL) { TCRIT("Service Name Not Available for the Requested Service ID\n"); *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } memset(&ReqConf,0,sizeof(SERVICE_CONF_STRUCT)); memcpy(&ReqConf.ServiceName[0],ServiceNameList[ServiceIDBit],sizeof(ReqConf.ServiceName)); memcpy(&ReqConf.InterfaceName[0],&pAMISetServiceConfReq->InterfaceName[0],sizeof(pAMISetServiceConfReq->InterfaceName)); ReqConf.CurrentState = pAMISetServiceConfReq->Enable; ReqConf.MaxAllowSession = pAMISetServiceConfReq->MaxAllowSession; ReqConf.SessionInactivityTimeout = pAMISetServiceConfReq->SessionInactivityTimeout; ReqConf.SecureAccessPort = pAMISetServiceConfReq->SecureAccessPort; ReqConf.NonSecureAccessPort = pAMISetServiceConfReq->NonSecureAccessPort; ReqConf.CurrentActiveSession = pAMISetServiceConfReq->CurrentActiveSession; if(g_corefeatures.bond_support == ENABLED) { for(i = 0; i < sizeof(Ifcnametable)/sizeof(IfcName_T); i++) { if(strcmp(Ifcnametable[i].Ifcname,ReqConf.InterfaceName) == 0 ) { if(CheckBondSlave(Ifcnametable[i].Index) == 1) { *pRes = NCML_ERR_INVALID_INTERFACE_NAME; return sizeof(INT8U); } else { break; } } } } ServiceErr=Validate_SetServiceConfiguration(&ReqConf); if(ServiceErr !=CC_NORMAL) { *pRes=ServiceErr; TCRIT("Validate_SetServiceConfiguration Failed %d\n",ServiceErr); return sizeof(INT8U); } ServiceErr = get_service_configurations(ReqConf.ServiceName, &conf); if (ServiceErr < 0) { TCRIT("Error in Getting the Configuration for the Requested Service\n"); *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } if ((conf.CurrentState != ReqConf.CurrentState) || (memcmp(conf.InterfaceName, ReqConf.InterfaceName, strlen(conf.InterfaceName)) != 0) || (conf.NonSecureAccessPort != ReqConf.NonSecureAccessPort) || (conf.SecureAccessPort != ReqConf.SecureAccessPort) || (conf.SessionInactivityTimeout != ReqConf.SessionInactivityTimeout) || (conf.MaxAllowSession != ReqConf.MaxAllowSession)) { RebootService = 1; } memset(&conf, 0, sizeof(SERVICE_CONF_STRUCT)); memcpy(&conf.ServiceName[0],&ReqConf.ServiceName[0],sizeof(ReqConf.ServiceName)); conf.CurrentState = ReqConf.CurrentState; strcpy(conf.InterfaceName, ReqConf.InterfaceName); conf.NonSecureAccessPort = ReqConf.NonSecureAccessPort; conf.SecureAccessPort = ReqConf.SecureAccessPort; conf.SessionInactivityTimeout = ReqConf.SessionInactivityTimeout; conf.MaxAllowSession = ReqConf.MaxAllowSession; conf.CurrentActiveSession = ReqConf.CurrentActiveSession; ServiceErr = set_service_configurations(ServiceNameList[ServiceIDBit], &conf,g_corefeatures.timeoutd_sess_timeout); if(ServiceErr < 0) { TCRIT("Error in Setting the Configuration for the Requested Service\n"); *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } if (RebootService) { RestartService(ServiceIDBit,BMCInst); RebootService = 0; } pAMISetServiceConfRes->CompletionCode = CC_SUCCESS; return(sizeof(AMISetServiceConfRes_T)); } int AMILinkDownResilent( _NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes,int BMCInst) { _NEAR_ AMILinkDownResilentReq_T* pAMILinkDownResilentReq = (_NEAR_ AMILinkDownResilentReq_T*) pReq; _NEAR_ AMILinkDownResilentRes_T* pAMILinkDownResilentRes = (_NEAR_ AMILinkDownResilentRes_T *) pRes; _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; pAMILinkDownResilentRes->CompletionCode = CC_SUCCESS; if(pAMILinkDownResilentReq->LinkDownEnable== 1) { pBMCInfo->IpmiConfig.LinkDownResilentSupport = 1; pAMILinkDownResilentRes->LinkEnableStatus = pBMCInfo->IpmiConfig.LinkDownResilentSupport; } else if(pAMILinkDownResilentReq->LinkDownEnable == 0) { pBMCInfo->IpmiConfig.LinkDownResilentSupport = 0; pAMILinkDownResilentRes->LinkEnableStatus = pBMCInfo->IpmiConfig.LinkDownResilentSupport; } else if(pAMILinkDownResilentReq->LinkDownEnable == 0xFF) { pAMILinkDownResilentRes->LinkEnableStatus = pBMCInfo->IpmiConfig.LinkDownResilentSupport; } else { *pRes = CC_INV_DATA_FIELD; } return sizeof(AMILinkDownResilentRes_T); } /* * @fn ValidateSetIfaceStateBond * @brief Validate the SetIface State Bond Command inupt * @param[in] pReq - Request Structure. * @param[out] pRes - Response Structure. * @param[out] VLANID - VLANID of the slave interfaces (if any, otherwise return 0). * @param[in] CheckBondDisable - Validate the Bond disable feature. * @param[in] BMCInst - Instance of the BMC. * @return */ int ValidateSetIfaceStateBond (INT8U *pReq, INT8U *pRes, INT8U *VLANID, int CheckBondDisable, int BMCInst) { AMISetIfaceStateReq_T *pAMIIfaceStateReq = (AMISetIfaceStateReq_T *)pReq; AMISetIfaceStateRes_T *pAMIIfaceStateRes = (AMISetIfaceStateRes_T *)pRes; _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; int Ifccount = 0, i; char IfcName[16]; if(g_corefeatures.bond_support != ENABLED) { *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } if((pAMIIfaceStateReq->ConfigData.BondIface.AutoConf & ENABLE_DISABLE_MASK)!= 0) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } if( pAMIIfaceStateReq->ConfigData.BondIface.Slaves == 0) { *pRes = CC_INSUFFICIENT_SLAVE_COUNT; return sizeof(INT8U); } /*Get the no of LAN interface count*/ if(get_network_interface_count(&Ifccount) < 0) { pAMIIfaceStateRes->CompletionCode = CC_UNSPECIFIED_ERR; return sizeof(INT8U); } if(Ifccount <= 1) { *pRes = OEMCC_INSUFFIENT_LANIFC_COUNT; return sizeof(INT8U); } if(pAMIIfaceStateReq->ConfigData.BondIface.BondIndex== 0xff) { IPMI_WARNING("\nInvalid EthIndex number :%x", pAMIIfaceStateReq->ConfigData.BondIface.BondIndex); *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } if (CheckBondDisable == 1) { if(g_corefeatures.delayed_lan_restart_support) { if((!pBMCInfo->BondConfig.Enable) && (pAMIIfaceStateReq->ConfigData.BondIface.Enable == IFACE_DISABLED)) { *pRes = OEMCC_BOND_ALREADY_DISABLED; return sizeof(INT8U); } } else { GetNoofInterface(); memset(IfcName,0,sizeof(IfcName)); sprintf(IfcName,"bond%d",pAMIIfaceStateReq->ConfigData.BondIface.BondIndex); for(i=0;iConfigData.BondIface.Enable == IFACE_DISABLED)) { *pRes = OEMCC_BOND_ALREADY_DISABLED; return sizeof(INT8U); } break; } } if(i == sizeof(Ifcnametable)/sizeof(IfcName_T)) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } } } TDBG("Enable:%d\nBondIndex:%d\nBondMode:%d\nmiiinterval:%d\nSlave:%d\nAutoConf:%d\n", pAMIIfaceStateReq->ConfigData.BondIface.Enable, pAMIIfaceStateReq->ConfigData.BondIface.BondIndex, pAMIIfaceStateReq->ConfigData.BondIface.BondMode, pAMIIfaceStateReq->ConfigData.BondIface.MiiInterval, pAMIIfaceStateReq->ConfigData.BondIface.Slaves, pAMIIfaceStateReq->ConfigData.BondIface.AutoConf); /*Validate the bonding mode*/ if( pAMIIfaceStateReq->ConfigData.BondIface.BondMode > MAX_BOND_MODE) { IPMI_WARNING("Bond Mode is exceeded\n"); *pRes = CC_INV_DATA_FIELD; return (sizeof(INT8U)); } /*Validate the supported bonding modes*/ if( pAMIIfaceStateReq->ConfigData.BondIface.BondMode == MAX_BOND_MODE ) { IPMI_WARNING("Bond Mode %d is not supported\n",pAMIIfaceStateReq->ConfigData.BondIface.BondMode); *pRes = OEMCC_UNSUPPORTED_BOND_MODE; return (sizeof(INT8U)); } /*Validate the miiinterval*/ if(pAMIIfaceStateReq->ConfigData.BondIface.MiiInterval < DEFAULT_MII_INTERVAL) { IPMI_WARNING("Mii interval should be greater than 100\n"); *pRes = CC_INV_DATA_FIELD; return (sizeof(INT8U)); } *pRes = CheckSlaveVLANInterface(pAMIIfaceStateReq->ConfigData.BondIface.Slaves, VLANID, BMCInst); if ((*pRes) != 0) { return (sizeof(INT8U)); } return 0; } /** * @fn AMISetIfaceState * @brief This function sets the status of interfaces * @param Request message and BMC instance * @return success completion code */ int AMISetIfaceState( _NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes,int BMCInst) { _NEAR_ AMISetIfaceStateReq_T* pAMIIfaceStateReq = (_NEAR_ AMISetIfaceStateReq_T *) pReq; _NEAR_ AMISetIfaceStateRes_T* pAMIIfaceStateRes = (_NEAR_ AMISetIfaceStateRes_T *) pRes; NWCFG_STRUCT cfg; NWCFG6_STRUCT cfg6; int retValue = 0; char IfcName[16],tmpstr[16]; int EthIndex = 0,i,ethcount=0; INT8U CurrentIfaceState = 0x00, VLANID = 0,*curchannel; _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; BondIface bond; int Ifccount = 0; memset(&bond,0,sizeof(BondIface)); INT8U netch = 0; if ( ReqLen >= 1 ) { ReqLen -= 1; } else { *pRes = CC_REQ_INV_LEN; return sizeof (INT8U); } if(IsBMCNFSMode() != 0) { IPMI_WARNING("Card in NFS mode, Not safe to set any of interface configurations...\n"); *pRes = CC_CMD_UNSUPPORTED_UNCONFIGURABLE; return sizeof(INT8U); } if(g_corefeatures.online_flashing_support == ENABLED) { if(IsCardInFlashMode()) { IPMI_WARNING("Card in Active flash mode, Not safe to set any of network configurations...\n"); *pRes = CC_DEV_IN_FIRMWARE_UPDATE_MODE; return sizeof(INT8U); } } if( 0x02 >pAMIIfaceStateReq->Params) { if(ReqLen != NwIfcStateConfigParamLenght[pAMIIfaceStateReq->Params]) { TCRIT("params:%d reqLen:%ld\n",pAMIIfaceStateReq->Params,ReqLen); *pRes = CC_REQ_INV_LEN; return sizeof(INT8U); } } if (g_PDKHandle[PDK_BEFORESETIFACESTATE] != NULL ) { retValue = ((int(*)(INT8U *, INT8U, INT8U *,int)) (g_PDKHandle[PDK_BEFORESETIFACESTATE]))(pReq, ReqLen, pRes, BMCInst); if(retValue != 0) { return retValue; } } OS_THREAD_TLS_GET(g_tls.CurChannel,curchannel); switch(pAMIIfaceStateReq->Params) { case AMI_IFACE_STATE_ETH: if(pAMIIfaceStateReq->ConfigData.EthIface.EthIndex == 0xff) { IPMI_WARNING("\nInvalid EthIndex number :%x", pAMIIfaceStateReq->ConfigData.EthIface.EthIndex); *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } //Checking for valid EnableState if( (pAMIIfaceStateReq->ConfigData.EthIface.EnableState != DISABLE_V4_V6) && (pAMIIfaceStateReq->ConfigData.EthIface.EnableState != ENABLE_V4) && (pAMIIfaceStateReq->ConfigData.EthIface.EnableState != ENABLE_V6) && (pAMIIfaceStateReq->ConfigData.EthIface.EnableState != ENABLE_V4_V6) ) { IPMI_WARNING("\nInvalid EnableState :%x", pAMIIfaceStateReq->ConfigData.EthIface.EnableState); *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } /*Ethindex to be enabled*/ EthIndex = pAMIIfaceStateReq->ConfigData.EthIface.EthIndex; /*Compare the bonding and eth interfaces */ if(GetIfcNameByIndex(EthIndex, IfcName) != 0) { IPMI_WARNING("Invalid EthIndex number %d\n",EthIndex); *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } sprintf(tmpstr,"bond"); if(strstr(IfcName,tmpstr) != NULL) { IPMI_WARNING("Given EthIndex %d is specific to bonding interface. Use specific parameter for bonding\n",EthIndex); *pRes = OEMCC_INV_PARAM_ONLY_FOR_NON_BONDING; return sizeof(INT8U); } if(!((g_corefeatures.delayed_lan_restart_support) && !(pBMCInfo->BondConfig.Enable))) { /*Check if the given Interface is the slave of any Bond interfaces*/ retValue= CheckBondSlave(pAMIIfaceStateReq->ConfigData.EthIface.EthIndex); if(retValue == -1) { *pRes = CC_UNSPECIFIED_ERR; return sizeof(INT8U); } if(retValue == 1) { *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof(INT8U); } } /*Update the interface status*/ GetNoofInterface(); for(i=0;iConfigData.EthIface.EnableState) { TCRIT("Iface state is the same, do nothing\n"); *pRes = CC_SUCCESS; return sizeof(AMISetIfaceStateRes_T); } if(ENABLE_V6 == pAMIIfaceStateReq->ConfigData.EthIface.EnableState) { if(g_corefeatures.global_ipv6 == ENABLED) { TDBG("IPv6 only enabled"); } else { TCRIT("IPMI support for IPv6 is Disabled...\n"); *pRes = OEMCC_INV_IP4_NOT_ENABLED; return sizeof (INT8U); } } if((ethcount == 1) && pAMIIfaceStateReq->ConfigData.EthIface.EnableState == 0x0) { *pRes =OEMCC_INV_MIN_IFC_COUNT_DISABLED; return sizeof(INT8U); } pBMCInfo->LANCfs[EthIndex].IPv6_Enable = (pAMIIfaceStateReq->ConfigData.EthIface.EnableState & ENABLE_V6) ? 1 : 0; pBMCInfo->LANCfs[EthIndex].IPv4_Enable= (pAMIIfaceStateReq->ConfigData.EthIface.EnableState & ENABLE_V4) ? 1 : 0; SetPendStatus(PEND_OP_SET_ETH_IFACE_STATE,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_ETH_IFACE_STATE, (INT8U *)&pAMIIfaceStateReq->ConfigData.EthIface, sizeof(EthIfaceState),*curchannel & 0xF,BMCInst); FlushIPMI((INT8U*)&pBMCInfo->LANCfs[0], (INT8U*)&pBMCInfo->LANCfs[EthIndex], pBMCInfo->IPMIConfLoc.LANCfsAddr, sizeof(LANConfig_T),BMCInst); break; case AMI_IFACE_BOND_ENABLED: *pRes = CC_ATTEMPT_TO_SET_RO_PARAM; return sizeof (*pRes); break; case AMI_GET_IFACE_COUNT: *pRes = CC_ATTEMPT_TO_SET_RO_PARAM; return sizeof (*pRes); break; case AMI_GET_IFACE_CHANNEL: *pRes = CC_ATTEMPT_TO_SET_RO_PARAM; return sizeof (*pRes); break; case AMI_GET_IFACE_NAME: *pRes = CC_ATTEMPT_TO_SET_RO_PARAM; return sizeof (*pRes); break; case AMI_IFACE_STATE_BOND: retValue = ValidateSetIfaceStateBond (pReq, pRes, &VLANID, 1, BMCInst); if (retValue != 0) { return retValue; } sprintf(IfcName,"bond%d",pAMIIfaceStateReq->ConfigData.BondIface.BondIndex); for(i=0;iLanIfcConfig[i].ifname,IfcName) == 0) { EthIndex=pBMCInfo->LanIfcConfig[i].Ethindex; netch = pBMCInfo->LanIfcConfig[i].Chnum ; break; } } if (pAMIIfaceStateReq->ConfigData.BondIface.Enable == 1) { memset(&cfg, 0, sizeof(NWCFG_STRUCT)); memset(&cfg6, 0, sizeof(NWCFG6_STRUCT)); memset(IfcName,0,sizeof(IfcName)); if(g_corefeatures.delayed_lan_restart_support) { if((pBMCInfo->LANCfs[EthIndex].IPv4_Enable == 0) && (pBMCInfo->LANCfs[EthIndex].IPv6_Enable == 0)) { *pRes = OEMCC_ETH_IFACE_DISABLED; return sizeof(INT8U); } } else { retValue = nwReadNWCfg_v4_v6(&cfg, &cfg6,EthIndex,g_corefeatures.global_ipv6); if(retValue != 0) TCRIT("Error in reading network configuration.\n"); if ((cfg.enable == 0) && (cfg6.enable == 0)) { *pRes = OEMCC_ETH_IFACE_DISABLED; return sizeof(INT8U); } } } _fmemcpy (&pBMCInfo->BondConfig, &(pAMIIfaceStateReq->ConfigData.BondIface), sizeof(BondIface)); SetPendStatus(PEND_OP_SET_BOND_IFACE_STATE,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_BOND_IFACE_STATE, (INT8U *)&pAMIIfaceStateReq->ConfigData.BondIface, sizeof(BondIface),netch & 0xF,BMCInst); if (VLANID != 0) { cfg.VLANID = VLANID; SetPendStatus(PEND_OP_SET_VLAN_ID, PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_VLAN_ID, (INT8U*)&cfg, sizeof(cfg), (*curchannel & 0x0F), BMCInst ); } FlushIPMI((INT8U*)&pBMCInfo->BondConfig, (INT8U*)&pBMCInfo->BondConfig, pBMCInfo->IPMIConfLoc.BONDConfigAddr, sizeof(BondIface),BMCInst); break; case AMI_BOND_ACTIVE_SLAVE: if(g_corefeatures.bond_support != ENABLED) { *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } memset(IfcName,0,sizeof(IfcName)); sprintf(IfcName,"bond%d",pAMIIfaceStateReq->ConfigData.ActiveSlave.BondIndex); for(i=0;iConfigData.ActiveSlave.ActiveIndex == 0x0) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } /*Index value 0xff will enable both eth0 and eth1 interface*/ if(pAMIIfaceStateReq->ConfigData.ActiveSlave.ActiveIndex != 0xff ) { for(i=0;iConfigData.ActiveSlave.ActiveIndex >> i) & IFACE_ENABLED) { Ifccount++; /*Check Slave Entry presence*/ if(CheckIfcEntry(i,ETH_IFACE_TYPE) != 0) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } } } } if (nwGetBondConf( &bond, pAMIIfaceStateReq->ConfigData.ActiveSlave.BondIndex) != 0) { TDBG("Error in getting Bonding Configurations\n"); } if((bond.BondMode == BOND_ACTIVE_BACKUP) && ((pAMIIfaceStateReq->ConfigData.ActiveSlave.ActiveIndex == 0xff) || (Ifccount > 1))) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } if(bond.BondMode == BOND_ACTIVE_BACKUP) { for(i=0;iConfigData.ActiveSlave.ActiveIndex >> i) & IFACE_ENABLED) { if(CheckIfcLinkStatus(i) != 1) { *pRes = OEMCC_ACTIVE_SLAVE_LINK_DOWN; return sizeof(INT8U); } break; } } } SetPendStatus(PEND_OP_SET_ACTIVE_SLAVE,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_ACTIVE_SLAVE, (INT8U *)&pAMIIfaceStateReq->ConfigData.ActiveSlave, sizeof(ActiveSlave_T),*curchannel & 0xF,BMCInst); break; case AMI_BOND_VLAN_ENABLED: if(g_corefeatures.bond_support == ENABLED) { *pRes = CC_ATTEMPT_TO_SET_RO_PARAM; } else { *pRes = CC_PARAM_NOT_SUPPORTED; } return sizeof (*pRes); break; default: pAMIIfaceStateRes->CompletionCode = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } pAMIIfaceStateRes->CompletionCode = CC_SUCCESS; return sizeof(AMISetIfaceStateRes_T); } /** * @fn AMIGetIfaceState * @brief This function returns the status of interfaces * @param Request message and BMC instance * @return status of interfaces */ int AMIGetIfaceState( _NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes,int BMCInst) { _NEAR_ AMIGetIfaceStateReq_T* pAMIIfaceStateReq = (_NEAR_ AMIGetIfaceStateReq_T *) pReq; _NEAR_ AMIGetIfaceStateRes_T* pAMIIfaceStateRes = (_NEAR_ AMIGetIfaceStateRes_T *) pRes; _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; NWCFG_STRUCT cfg; NWCFG6_STRUCT cfg6; BondIface bond; char tmpstr[16]; char IfcName[16],EthIfcname[MAX_ETHIFC_LEN * MAX_LAN_CHANNELS]; int retValue = 0,i,Ifccount = 0,j,count=0; int EthIndex = 0,NIC_Count = 0,netindex = 0; INT8U CurrentIfaceState = 0x00; if(0 != pAMIIfaceStateReq->BlockSelect) { IPMI_WARNING("Invalid BlockSelect :%x\n", pAMIIfaceStateReq->BlockSelect); *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } if (g_PDKHandle[PDK_BEFOREGETIFACESTATE] != NULL ) { retValue = ((int(*)(INT8U *, INT8U, INT8U *,int)) (g_PDKHandle[PDK_BEFOREGETIFACESTATE]))(pReq, ReqLen, pRes, BMCInst); if(retValue != 0) { return retValue; } } GetNoofInterface(); switch(pAMIIfaceStateReq->Params) { case AMI_IFACE_STATE_ETH: if(pAMIIfaceStateReq->SetSelect== 0xff) { IPMI_WARNING("\nInvalid EthIndex number :%x", pAMIIfaceStateReq->SetSelect); *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } EthIndex = pAMIIfaceStateReq->SetSelect; if(GetIfcNameByIndex(EthIndex, IfcName) != 0) { IPMI_WARNING("Invalid EthIndex number %d\n",EthIndex); *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } /* sprintf(tmpstr,"bond0"); if(strcmp(tmpstr,IfcName) == 0) { IPMI_WARNING("Given EthIndex %d is specific to bonding interface. Use specific parameter for bonding\n",EthIndex); *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); }*/ memset(&cfg, 0, sizeof(NWCFG_STRUCT)); memset(&cfg6, 0, sizeof(NWCFG6_STRUCT)); if((g_corefeatures.delayed_lan_restart_support)) { netindex = EthIndex; if(pBMCInfo->BondConfig.Enable == 1) { sprintf(tmpstr,"bond0"); for(i=0; i < MAX_LAN_CHANNELS; i++) { if(strcmp(tmpstr, pBMCInfo->LanIfcConfig[i].ifname) == 0) { netindex = pBMCInfo->LanIfcConfig[i].Ethindex; } } } cfg6.enable = pBMCInfo->LANCfs[netindex].IPv6_Enable; cfg.enable = pBMCInfo->LANCfs[netindex].IPv4_Enable; } else { retValue = nwReadNWCfg_v4_v6(&cfg, &cfg6, EthIndex,g_corefeatures.global_ipv6); if(retValue != 0) TCRIT("Error in reading network configuration.\n"); } pAMIIfaceStateRes->ConfigData.EthIface.EthIndex = EthIndex; CurrentIfaceState = ((cfg6.enable<<1) | cfg.enable); pAMIIfaceStateRes->ConfigData.EthIface.EnableState = CurrentIfaceState; pAMIIfaceStateRes->CompletionCode = CC_NORMAL; return sizeof(INT8U) + sizeof(EthIfaceState); break; case AMI_IFACE_STATE_BOND: if(g_corefeatures.bond_support == ENABLED) { if(pAMIIfaceStateReq->SetSelect== 0xff) { IPMI_WARNING("\nInvalid EthIndex number :%x", pAMIIfaceStateReq->SetSelect); *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } EthIndex = pAMIIfaceStateReq->SetSelect; memset(&bond,0,sizeof(BondIface)); if(g_corefeatures.delayed_lan_restart_support) { if(EthIndex == pBMCInfo->BondConfig.BondIndex) { memcpy(&bond, &pBMCInfo->BondConfig, sizeof(BondIface)); } } else { if (nwGetBondConf( &bond, EthIndex) != 0) { TDBG("Error in getting Bonding Configurations\n"); } } pAMIIfaceStateRes->CompletionCode = CC_NORMAL; pAMIIfaceStateRes->ConfigData.BondIface.Enable = bond.Enable; pAMIIfaceStateRes->ConfigData.BondIface.BondIndex = bond.BondIndex; pAMIIfaceStateRes->ConfigData.BondIface.BondMode = bond.BondMode; pAMIIfaceStateRes->ConfigData.BondIface.MiiInterval = bond.MiiInterval; pAMIIfaceStateRes->ConfigData.BondIface.Slaves = bond.Slaves; pAMIIfaceStateRes->ConfigData.BondIface.AutoConf = bond.AutoConf; return sizeof(INT8U) +sizeof(BondIface); } else { *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } break; case AMI_IFACE_BOND_ENABLED: if(pAMIIfaceStateReq->SetSelect != 0) { IPMI_WARNING("\nInvalid BondIndex number :%x", pAMIIfaceStateReq->SetSelect); *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } memset(IfcName,0,sizeof(IfcName)); sprintf(IfcName,"bond%d",pAMIIfaceStateReq->SetSelect); for(i=0;iLanIfcConfig)/sizeof(LANIFCConfig_T);i++) { if((strcmp(IfcName,pBMCInfo->LanIfcConfig[i].ifname) == 0 ) && (pBMCInfo->LanIfcConfig[i].Up_Status == 1)) { pAMIIfaceStateRes->ConfigData.BondEnable.Enabled = 1; break; } else { pAMIIfaceStateRes->ConfigData.BondEnable.Enabled = 0; pAMIIfaceStateRes->ConfigData.BondEnable.BondIndex = 0; } } for(i=0;i< sizeof(Ifcnametable)/sizeof(IfcName_T);i++) { if(Ifcnametable[i].Ifcname[0] == 0) continue; if( (strcmp(IfcName,Ifcnametable[i].Ifcname) == 0) && (pAMIIfaceStateRes->ConfigData.BondEnable.Enabled == 1)) { pAMIIfaceStateRes->ConfigData.BondEnable.BondIndex = Ifcnametable[i].Index; break; } } pAMIIfaceStateRes->CompletionCode = CC_NORMAL; return sizeof(INT8U)+sizeof(BondEnabled_T); break; case AMI_GET_IFACE_COUNT: /*Get the no of LAN interface count support for IPMI*/ if( NULL != g_PDKHandle[PDK_GETIFACECOUNT]) { if( 0xFF != (((INT8U(*)(INT8U *, INT8U *, int))(g_PDKHandle[PDK_GETIFACECOUNT])) (pAMIIfaceStateRes->ConfigData.LANCount.EthIndex, &pAMIIfaceStateRes->ConfigData.LANCount.Count, BMCInst))) { pAMIIfaceStateRes->CompletionCode = CC_NORMAL; return sizeof (AMIGetIfaceStateRes_T); } } if(get_network_interface_count(&Ifccount) < 0) { pAMIIfaceStateRes->CompletionCode = CC_UNSPECIFIED_ERR; return sizeof(INT8U); } memset(EthIfcname,0,MAX_ETHIFC_LEN * MAX_LAN_CHANNELS); memset(pAMIIfaceStateRes->ConfigData.LANCount.EthIndex,0,MAX_LAN_CHANNEL); if(get_network_interfaces_name(EthIfcname,Ifccount) < 0) { pAMIIfaceStateRes->CompletionCode = CC_UNSPECIFIED_ERR; return sizeof(INT8U); } count = 0; /*Get the Index value of each LAN Interface*/ for(i=0;iConfigData.LANCount.EthIndex[count] = Ifcnametable[i].Index; count++; } } } /* force count value to match CONFIG_SPX_FEATURE_GLOBAL_NIC_COUNT */ NIC_Count =g_coremacros.global_nic_count; if(count > NIC_Count) { count = NIC_Count; } pAMIIfaceStateRes->CompletionCode = CC_NORMAL; pAMIIfaceStateRes->ConfigData.LANCount.Count = count; return sizeof(INT8U)+sizeof(LANIfcCount_T); break; case AMI_GET_IFACE_CHANNEL: pAMIIfaceStateRes->ConfigData.IfcChannel.Channel = 0; for(i=0;iSetSelect) { for(j=0;jLanIfcConfig[j].ifname) == 0) { pAMIIfaceStateRes->ConfigData.IfcChannel.Channel = pBMCInfo->LanIfcConfig[j].Chnum; pAMIIfaceStateRes->CompletionCode = CC_SUCCESS; return sizeof(INT8U)+sizeof(GetIfcChannel_T); } } } } *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); break; case AMI_GET_IFACE_NAME: memset(&pAMIIfaceStateRes->ConfigData.IfcName.IfcName,0,sizeof(MAX_IFACE_NAME)); for(i=0;iSetSelect) { memcpy(&pAMIIfaceStateRes->ConfigData.IfcName.IfcName,&Ifcnametable[i].Ifcname,MAX_IFACE_NAME); pAMIIfaceStateRes->CompletionCode = CC_SUCCESS; return sizeof(INT8U)+sizeof(GetIfcName_T); } } *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); break; case AMI_BOND_ACTIVE_SLAVE: if(g_corefeatures.bond_support == ENABLED) { memset(IfcName,0,sizeof(IfcName)); sprintf(IfcName,"bond%d",pAMIIfaceStateReq->SetSelect); for(i=0;iConfigData.ActiveSlave.BondIndex = pAMIIfaceStateReq->SetSelect; break; } } /*Bond index is Invalid*/ if(i == sizeof(Ifcnametable)/sizeof(IfcName_T)) { *pRes = OEMCC_BOND_NOT_ENABLED; return sizeof(INT8U); } /*Get the active slave configuration*/ nwGetActiveSlave(pAMIIfaceStateReq->SetSelect,&pAMIIfaceStateRes->ConfigData.ActiveSlave.ActiveIndex); pAMIIfaceStateRes->CompletionCode = CC_NORMAL; return sizeof(INT8U)+sizeof(ActiveSlave_T); } else { *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } break; case AMI_BOND_VLAN_ENABLED: if(g_corefeatures.bond_support == ENABLED) { memset(IfcName,0,sizeof(IfcName)); sprintf(IfcName,"bond%d",pAMIIfaceStateReq->SetSelect); if(CheckVLANInterface(IfcName, BMCInst) == 1) pAMIIfaceStateRes->ConfigData.BondVLAN.Enabled = 1; else pAMIIfaceStateRes->ConfigData.BondVLAN.Enabled = 0; pAMIIfaceStateRes->CompletionCode = CC_SUCCESS; return sizeof(INT8U)+sizeof(BondVLAN_T); } else { *pRes = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } break; default: pAMIIfaceStateRes->CompletionCode = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } pAMIIfaceStateRes->CompletionCode = CC_SUCCESS; return sizeof (AMIGetIfaceStateRes_T); } /** * @fn AMISetFirewall * @brief This function sets the iptables Firewall * @param Request message and Iptables State */ int AMISetFirewall ( _NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes ,int BMCInst ) { _NEAR_ AMISetFirewallReq_T *pAMISetFirewallReq = ( _NEAR_ AMISetFirewallReq_T *) pReq; _NEAR_ AMISetFirewallRes_T *pAMISetFirewallRes = ( _NEAR_ AMISetFirewallRes_T *) pRes; INT8U *curchannel; if(g_corefeatures.system_firewall_support != CORE_FEATURE_ENABLED) { pAMISetFirewallRes->CompletionCode = CC_INV_CMD; return sizeof(INT8U); } if(0x0b > pAMISetFirewallReq->Param ) //Max known Firewall paramter { if ((ReqLen-1) != FirewallConfigParamLength [pAMISetFirewallReq->Param ]) { *pRes = CC_REQ_INV_LEN; TDBG("Your entered Parameter %d is not a valid data \n",pAMISetFirewallReq->Param); return sizeof (INT8U); } else { TDBG("Your entered Parameter %d is a valid data... \n",pAMISetFirewallReq->Param); } } void *dl_handle = NULL; void ( *dl_func )( void *, void * ); void ( *dl_block )( void * ); dl_handle = NULL; dl_handle = dlopen ( "/usr/local/lib/libiptables.so", RTLD_NOW ); if(NULL == dl_handle) { IPMI_ERROR("Error in loading libiptables.so library %s\n", dlerror() ); return 0; } switch ( pAMISetFirewallReq->Param ) { case IP_IPV4: dl_func = dlsym( dl_handle, "block_ip_ipv4" ); if(NULL == dl_func) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(dl_handle); return 0; } dl_func ( (void *)&pAMISetFirewallReq->State,(void *) pAMISetFirewallReq->CMD_INFO.IPAddr_ipv4 ); break; case IPS_IPV4: dl_func = dlsym( dl_handle, "block_ip_range_ipv4" ); if(NULL == dl_func) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(dl_handle); return 0; } dl_func ( (void *)&pAMISetFirewallReq->State,(void *) &pAMISetFirewallReq->CMD_INFO.IPRange_ipv4 ); break; case PORT: dl_func = dlsym( dl_handle, "block_port" ); if(NULL == dl_func) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(dl_handle); return 0; } dl_func ( (void *)&pAMISetFirewallReq->State,(void *) &pAMISetFirewallReq->CMD_INFO.Port_Data); break; case PORT_RANGE: dl_func = dlsym ( dl_handle, "block_range_ports" ); if(NULL == dl_func) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(dl_handle); return 0; } dl_func ( (void *)&pAMISetFirewallReq->State,(void *) &pAMISetFirewallReq->CMD_INFO.Port_Range); break; case IP_IPV4_Unlock: dl_func = dlsym( dl_handle, "release_ip_ipv4" ); if(NULL == dl_func) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(dl_handle); return 0; } dl_func ( (void *)&pAMISetFirewallReq->State,(void *) pAMISetFirewallReq->CMD_INFO.IPAddr_ipv4 ); break; case IPS_IPV4_Unlock: dl_func = dlsym( dl_handle, "release_range_ip_ipv4" ); if(NULL == dl_func) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(dl_handle); return 0; } dl_func ( (void *)&pAMISetFirewallReq->State,(void *) &pAMISetFirewallReq->CMD_INFO.IPRange_ipv4 ); break; case PORT_Release: dl_func = dlsym( dl_handle, "release_port" ); if(NULL == dl_func) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(dl_handle); return 0; } dl_func ( (void *)&pAMISetFirewallReq->State,(void *) &pAMISetFirewallReq->CMD_INFO.Port_Data ); break; case PORT_RANGE_Release: dl_func = dlsym( dl_handle, "release_range_port" ); if(NULL == dl_func) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(dl_handle); return 0; } dl_func ( (void *)&pAMISetFirewallReq->State,(void *) &pAMISetFirewallReq->CMD_INFO.Port_Range); break; case FLUSH: dl_func = dlsym (dl_handle, "flush_iptables"); if ( NULL == dl_func ) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(dl_handle); return 0; } dl_func ( (void *) NULL, (void *)NULL ); break; /* case ENABLE_ALL: dl_func = dlsym (dl_handle, "enable_all"); if ( NULL == dl_func ) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(dl_handle); return 0; } dl_func ( (void *) NULL ); break; */ case DISABLE_ALL: if ( pAMISetFirewallReq->CMD_INFO.Block > 3 || pAMISetFirewallReq->CMD_INFO.Block == 0) { IPMI_ERROR("Invalid data\n"); *pRes = CC_INV_DATA_FIELD; dlclose(dl_handle); return sizeof(INT8U); } OS_THREAD_TLS_GET(g_tls.CurChannel,curchannel); SetPendStatus(PEND_OP_SET_BLOCK_ALL,PEND_STATUS_PENDING); PostPendTask(PEND_OP_SET_BLOCK_ALL, (INT8U *)&pAMISetFirewallReq->CMD_INFO.Block, sizeof(INT8U),*curchannel & 0xF,BMCInst); break; case REMOVE_DISABLE_ALL: if ( pAMISetFirewallReq->CMD_INFO.Unblock > 3 || pAMISetFirewallReq->CMD_INFO.Unblock == 0) { IPMI_ERROR("Invalid data\n"); *pRes = CC_INV_DATA_FIELD; dlclose(dl_handle); return sizeof(INT8U); } dl_block = dlsym (dl_handle, "remove_block_all"); if ( NULL == dl_block) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(dl_handle); return 0; } dl_block ( (void *)&pAMISetFirewallReq->CMD_INFO.Unblock); break; default: pAMISetFirewallRes->CompletionCode = CC_PARAM_NOT_SUPPORTED; } dlclose (dl_handle); pAMISetFirewallRes->CompletionCode = CC_SUCCESS; return sizeof(AMISetFirewallRes_T); } /** * @fn AMIGetFirewall * @brief This function is used to Get the iptables rules * @param Request message and Command Info */ int AMIGetFirewall ( _NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes ,int BMCInst ) { _NEAR_ AMIGetFirewallReq_T *pAMIGetFirewallReq = ( _NEAR_ AMIGetFirewallReq_T *) pReq; _NEAR_ AMIGetFirewallRes_T *pAMIGetFirewallRes = ( _NEAR_ AMIGetFirewallRes_T *) pRes; int retVal=0; if(g_corefeatures.system_firewall_support != CORE_FEATURE_ENABLED) { pAMIGetFirewallRes->CCParam.CompletionCode = CC_INV_CMD; return sizeof(INT8U); } if(0x02 > pAMIGetFirewallReq->Param ) //Max known Firewall paramter { if ((ReqLen-1) != GetFirewallConfigParamLength [pAMIGetFirewallReq->Param ]) { *pRes = CC_REQ_INV_LEN; TDBG("Your entered Parameter %d is not a valid data \n",pAMIGetFirewallReq->Param); return sizeof (INT8U); } else { TDBG("Your entered Parameter %d is a valid data... \n",pAMIGetFirewallReq->Param); } } void *dl_handle = NULL; int ( *dl_func )( void * ,void * )=NULL; int ( *dl_func0 )()=NULL; dl_handle = dlopen ( "/usr/local/lib/libiptables.so", RTLD_NOW ); if(NULL == dl_handle) { IPMI_ERROR("Error in loading libiptables.so library %s\n", dlerror() ); return -1; } switch( pAMIGetFirewallReq->Param ) { case GET_IPTABLE_COUNT: dl_func0 = dlsym (dl_handle, "get_iptable_count"); if ( NULL == dl_func0 ) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(pAMIGetFirewallRes); return -1; } pAMIGetFirewallRes->FWInfo.TotalCount= dl_func0 (); break; case GET_ENTRY_INFO: dl_func = dlsym (dl_handle, "get_iptable_entry"); if ( NULL == dl_func ) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(pAMIGetFirewallRes); return CC_PARAM_NOT_SUPPORTED; } retVal = dl_func ( (INT8U *)&pAMIGetFirewallReq->EntryNo, (INT8U *)&pAMIGetFirewallRes->FWInfo.Info ); if(retVal == -1) { pAMIGetFirewallRes->CCParam.CompletionCode = CC_INV_DATA_FIELD; return sizeof(INT8U); } break; case IS_BLOCK_ALL: dl_func0 = dlsym (dl_handle, "IsBlockAllEnabled"); if ( NULL == dl_func0 ) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(pAMIGetFirewallRes); return -1; } retVal = dl_func0(); if(retVal != -1) { pAMIGetFirewallRes->FWInfo.IsBlockAll=retVal; } else { pAMIGetFirewallRes->FWInfo.IsBlockAll=0; } break; default: pAMIGetFirewallRes->CCParam.CompletionCode = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } dlclose (dl_handle); pAMIGetFirewallRes->CCParam.CompletionCode = CC_SUCCESS; if( pAMIGetFirewallReq->Param == GET_IPTABLE_COUNT) { return sizeof(GetFWCC_T)+sizeof(INT8U); } else if( pAMIGetFirewallReq->Param == IS_BLOCK_ALL) { return sizeof(GetFWCC_T)+sizeof(INT8U); } else { return sizeof(GetFWCC_T) + sizeof(pAMIGetFirewallRes->FWInfo.Info.TYPE) + FirewallConfigParamLength[pAMIGetFirewallRes->FWInfo.Info.TYPE]; } } int AMISetSNMPConf( _NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes,int BMCInst) { _NEAR_ AMISetSNMPConfRes_T *pAMISetSNMPConfRes = (_NEAR_ AMISetSNMPConfRes_T *)pRes; _NEAR_ AMISetSNMPConfReq_T * snmpcfg = (_NEAR_ AMISetSNMPConfReq_T*)pReq; void *dl_snmphandle = NULL; int ( *dl_snmpadduser )( char*,char*,INT8U,INT8U,INT8U)=NULL; int ( *dl_snmpdeluser)()=NULL; _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; _FAR_ UserInfo_T* pUserInfo; INT8U PwdEncKey[MAX_SIZE_KEY] = {0}; char Tmp_UserName[MAX_USERNAME_LEN+1]={0}; char User_password[MAX_PASSWORD_LEN]={0}; char Tmp_Password[MAX_PASSWORD_LEN+1]={0}; memset(Tmp_UserName,0,sizeof(Tmp_UserName)); memset(Tmp_Password,0,sizeof(Tmp_Password)); if (snmpcfg->UserID == 0) { pAMISetSNMPConfRes->CompletionCode = CC_INV_DATA_FIELD ; return sizeof (*pRes); } pUserInfo = getUserIdInfo(snmpcfg->UserID, BMCInst); if(pUserInfo == NULL) { pAMISetSNMPConfRes->CompletionCode = CC_INV_DATA_FIELD ; return sizeof (*pRes); } if(snmpcfg->UserID != pUserInfo->UserId) { pAMISetSNMPConfRes->CompletionCode = CC_INV_DATA_FIELD ; return sizeof (*pRes); } memcpy(Tmp_UserName,pUserInfo->UserName,MAX_USERNAME_LEN); Tmp_UserName[strlen(Tmp_UserName)] = '\0'; if(*Tmp_UserName == '\0') { pAMISetSNMPConfRes->CompletionCode = CC_NULL_USERID_NOT_SUPPORTED ; return sizeof (*pRes); } if (g_corefeatures.userpswd_encryption == ENABLED) { /* Get Encryption Key from the MBMCInfo_t structure */ LOCK_BMC_SHARED_MEM(BMCInst); memcpy(PwdEncKey, &(g_MBMCInfo.PwdEncKey), MAX_SIZE_KEY); UNLOCK_BMC_SHARED_MEM(BMCInst); if(DecryptPassword((INT8S *)(pBMCInfo->EncryptedUserInfo[snmpcfg->UserID - 1].EncryptedPswd), MAX_PASSWORD_LEN, User_password, MAX_PASSWORD_LEN, PwdEncKey)) { *pRes = CC_UNSPECIFIED_ERR; return sizeof(*pRes); } memcpy(Tmp_Password,User_password,MAX_PASSWORD_LEN); Tmp_Password[strlen(Tmp_Password)] = '\0'; } else { memcpy(Tmp_Password,pUserInfo->UserPassword,MAX_PASSWORD_LEN); Tmp_Password[strlen(Tmp_Password)] = '\0'; } if(g_corefeatures.snmp_support == ENABLED) { dl_snmphandle = dlopen (SNMP_LIBS,RTLD_NOW); if(NULL == dl_snmphandle) { IPMI_ERROR("Error in loading libsnmpuser.so library %s\n", dlerror() ); return -1; } //only add to SNMP Config if snmp is enabled for the user if (snmpcfg->snmp_enable == 1){ dl_snmpadduser = dlsym (dl_snmphandle, "SNMPAddUser"); if ( NULL == dl_snmpadduser) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(dl_snmphandle); return -1; } if((dl_snmpadduser)((char *)Tmp_UserName,(char *)Tmp_Password, snmpcfg->snmp_access_type, snmpcfg->snmp_enc_type_1, snmpcfg->snmp_enc_type_2)!=0) { *pRes = CC_INV_DATA_FIELD; return sizeof(*pRes); } } else if (snmpcfg->snmp_enable == 0){ dl_snmpdeluser = dlsym (dl_snmphandle, "SNMPDelUser"); if ( NULL == dl_snmpdeluser) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(dl_snmphandle); return -1; } (dl_snmpdeluser)((char *)Tmp_UserName);//if the username exists in the snmpcfg, needs to be deleted } else { *pRes = CC_INV_DATA_FIELD; return sizeof(*pRes); } pAMISetSNMPConfRes->CompletionCode = CC_SUCCESS; dlclose(dl_snmphandle); return(sizeof(AMISetSNMPConfRes_T)); } else { *pRes = CC_INV_CMD; return sizeof(*pRes); } } int AMIGetSNMPConf( _NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes, int BMCInst) { _NEAR_ AMIGetSNMPConfRes_T *pAMIGetSNMPConfRes = (_NEAR_ AMIGetSNMPConfRes_T *)pRes; _NEAR_ AMIGetSNMPConfReq_T * snmpcfg = (_NEAR_ AMIGetSNMPConfReq_T*)pReq; void *dl_snmphandle = NULL; int ( *dl_snmpgetuser)(char *,INT8U *,INT8U *,INT8U *,INT8U *)=NULL; INT8U snmp_enable,snmp_access_type,snmp_enc_type_1,snmp_enc_type_2; _FAR_ UserInfo_T* pUserInfo; char Tmp_UserName[MAX_USERNAME_LEN+1]={0}; memset(Tmp_UserName,0,sizeof(Tmp_UserName)); if (snmpcfg->UserID == 0) { pAMIGetSNMPConfRes->CompletionCode = CC_INV_DATA_FIELD ; return sizeof (*pRes); } pUserInfo = getUserIdInfo(snmpcfg->UserID, BMCInst); if(pUserInfo == NULL) { pAMIGetSNMPConfRes->CompletionCode = CC_INV_DATA_FIELD ; return sizeof (*pRes); } if(snmpcfg->UserID != pUserInfo->UserId) { pAMIGetSNMPConfRes->CompletionCode = CC_INV_DATA_FIELD ; return sizeof (*pRes); } memcpy(Tmp_UserName,pUserInfo->UserName,MAX_USERNAME_LEN); Tmp_UserName[strlen(Tmp_UserName)] = '\0'; if(*Tmp_UserName == '\0') { pAMIGetSNMPConfRes->CompletionCode = CC_NULL_USERID_NOT_SUPPORTED ; return sizeof (*pRes); } if(g_corefeatures.snmp_support == ENABLED) { dl_snmphandle = dlopen (SNMP_LIBS,RTLD_NOW); if(NULL == dl_snmphandle) { IPMI_ERROR("Error in loading libsnmpuser.so library %s\n", dlerror() ); return -1; } dl_snmpgetuser = dlsym (dl_snmphandle,"SNMPGetUser"); if ( NULL == dl_snmpgetuser) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(dl_snmphandle); return -1; } dl_snmpgetuser((char *)Tmp_UserName, &snmp_enable, &snmp_access_type, &snmp_enc_type_1, &snmp_enc_type_2); pAMIGetSNMPConfRes->CompletionCode = CC_SUCCESS; pAMIGetSNMPConfRes->UserID = snmpcfg->UserID; pAMIGetSNMPConfRes->snmp_enable = snmp_enable; pAMIGetSNMPConfRes->snmp_access_type = snmp_access_type; pAMIGetSNMPConfRes->snmp_enc_type_1 = snmp_enc_type_1; pAMIGetSNMPConfRes->snmp_enc_type_2 = snmp_enc_type_2; dlclose(dl_snmphandle); return(sizeof(AMIGetSNMPConfRes_T)); } else { *pRes = CC_INV_CMD; return sizeof(*pRes); } } /** * @fn AMIGetSELPolicy * @brief This function returns current SEL policy. * @param Request message and BMC instance * @return Current SEL policy */ int AMIGetSELPolicy (_NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes, int BMCInst) { _NEAR_ AMIGetSELPolicyRes_T* pAMIGetSELPolicyRes = (_NEAR_ AMIGetSELPolicyRes_T*)pRes; BMCInfo_t *pBMCInfo = &g_BMCInfo[BMCInst]; OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->SELConfig.SELMutex, WAIT_INFINITE); pAMIGetSELPolicyRes->CompletionCode = CC_NORMAL; pAMIGetSELPolicyRes->SELPolicy = pBMCInfo->AMIConfig.CircularSEL; OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SELConfig.SELMutex); return sizeof(AMIGetSELPolicyRes_T); } /** * @fn AMISetSELPolicy * @brief This function sets current SEL policy. * @param Request message and BMC instance * @return Success completion code */ int AMISetSELPolicy (_NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes, int BMCInst) { _NEAR_ AMISetSELPolicyRes_T* pAMISetSELPolicyRes = (_NEAR_ AMISetSELPolicyRes_T*)pRes; BMCInfo_t *pBMCInfo = &g_BMCInfo[BMCInst]; if(g_corefeatures.circular_sel == ENABLED) { _NEAR_ AMISetSELPolicyReq_T* pAMISetSELPolicyReq = (_NEAR_ AMISetSELPolicyReq_T*)pReq; OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->SELConfig.SELMutex, WAIT_INFINITE); /* Validate SEL policy */ if (pAMISetSELPolicyReq->SELPolicy != LINEAR_SEL && pAMISetSELPolicyReq->SELPolicy != CIRCULAR_SEL) { pAMISetSELPolicyRes->CompletionCode = CC_INV_DATA_FIELD; OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SELConfig.SELMutex); return sizeof(*pRes); } SetSELPolicy(pAMISetSELPolicyReq->SELPolicy, BMCInst); pAMISetSELPolicyRes->CompletionCode = CC_NORMAL; OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SELConfig.SELMutex); return sizeof(AMISetSELPolicyRes_T); } else { /* If Circular SEL feature is disabled in Project Configuration, return Not Support In Current State code. */ pAMISetSELPolicyRes->CompletionCode = CC_PARAM_NOT_SUP_IN_CUR_STATE; return sizeof(*pRes); } } /* *@fn AMIGetSELEntires *@param This function retrieves the SEL entries *@return Returns CC_NORMAL */ int AMIGetSELEntires(_NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes, int BMCInst) { AMIGetSELEntriesReq_T *pAMIGetSelEntriesReq = (AMIGetSELEntriesReq_T *)pReq; AMIGetSELEntriesRes_T *pAMIGetSelEntiresRes = (AMIGetSELEntriesRes_T *)pRes; BMCInfo_t *pBMCInfo = &g_BMCInfo[BMCInst]; SELRepository_T *m_sel = NULL; INT16U NumRecords = 0; if(g_corefeatures.del_sel_reclaim_support != ENABLED) { m_sel = (SELRepository_T*)GetSDRSELNVRAddr((pBMCInfo->IpmiConfig.SDRAllocationSize * 1024), BMCInst); NumRecords = m_sel->NumRecords; } else { NumRecords = pBMCInfo->SELReclaimRepos.pSELReclaimInfo->NumRecords; } OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->SELConfig.SELMutex, WAIT_INFINITE); if(((NumRecords - pAMIGetSelEntriesReq->Noofentretrieved) * sizeof(SELRec_T)) < MAX_FULL_SEL_ENTRIES) { pAMIGetSelEntiresRes->Status = FULL_SEL_ENTRIES; pAMIGetSelEntiresRes->Noofentries = NumRecords - pAMIGetSelEntriesReq->Noofentretrieved; } else if(NumRecords == SEL_EMPTY_REPOSITORY) { pAMIGetSelEntiresRes->CompletionCode = OEMCC_SEL_EMPTY_REPOSITORY; OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SELConfig.SELMutex); return sizeof(*pRes); } else if (NumRecords < pAMIGetSelEntriesReq->Noofentretrieved) { pAMIGetSelEntiresRes->CompletionCode = OEMCC_SEL_CLEARED; OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SELConfig.SELMutex); return sizeof(*pRes); } else { pAMIGetSelEntiresRes->Status = PARTIAL_SEL_ENTRIES; pAMIGetSelEntiresRes->Noofentries = ((MAX_FULL_SEL_ENTRIES - sizeof(AMIGetSELEntriesRes_T))/sizeof(SELRec_T)); } if(g_corefeatures.del_sel_reclaim_support != ENABLED) { memcpy((INT8U*)(pAMIGetSelEntiresRes + 1),(INT8U*)&m_sel->SELRecord[pAMIGetSelEntriesReq->Noofentretrieved], sizeof(SELRec_T)*pAMIGetSelEntiresRes->Noofentries); } else { CopySELReclaimEntries(&(SEL_RECLAIM_HEAD_NODE(BMCInst)),(INT8U *)(pAMIGetSelEntiresRes+1), pAMIGetSelEntriesReq->Noofentretrieved,pAMIGetSelEntiresRes->Noofentries,BMCInst); } pAMIGetSelEntiresRes->LastRecID = BMC_GET_SHARED_MEM(BMCInst)->m_LastRecID; pAMIGetSelEntiresRes->CompletionCode = CC_NORMAL; OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SELConfig.SELMutex); return sizeof(AMIGetSELEntriesRes_T) + (sizeof(SELRec_T) * pAMIGetSelEntiresRes->Noofentries); } /** * @fn AMIGetSensorInfo * @brief This function Gets all the Sensor Info needed for Web. * @param Request message and BMC instance * @return Proper completion code */ int AMIGetSenforInfo(_NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes, int BMCInst) { AMIGetSensorInfoRes_T *pAMIGetSensorInfoRes = (AMIGetSensorInfoRes_T *)pRes; BMCInfo_t *pBMCInfo = &g_BMCInfo[BMCInst]; INT8U* pValidSensor = NULL; INT16U SensorIndex = 0; SensorInfo_T pSensor ; SenInfo_T SensorInfo; BOOL SensorIsSigned = FALSE; INT16U SensorReading = 0; SensorSharedMem_T* pSMSharedMem; _FAR_ SDRRecHdr_T* pSDRRec; _FAR_ FullSensorRec_T* FullSDR; _FAR_ CompactSensorRec_T* CompSDR; int i = 0; /* Get the Sensor Shared Memory */ pSMSharedMem = (_FAR_ SensorSharedMem_T*)&pBMCInfo->SensorSharedMem; if(pBMCInfo->SenConfig.ValidSensorCnt == 0) { pAMIGetSensorInfoRes->CompletionCode = OEMCC_SENSOR_INFO_EMPTY; return sizeof(*pRes); } OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->m_hSMSharedMemMutex, SHARED_MEM_TIMEOUT); pValidSensor = (INT8U*)(pAMIGetSensorInfoRes+1); for(i = 0; i < pBMCInfo->SenConfig.ValidSensorCnt; i++) { SensorIndex = pBMCInfo->SenConfig.ValidSensorList[i]; pSensor = pSMSharedMem->SensorInfo[SensorIndex]; /*Copy the SDR Header*/ memcpy(&SensorInfo.hdr,pSensor.SDRRec,sizeof(SDRRecHdr_T)); SensorInfo.SensorNumber = pSensor.SensorNumber; SensorInfo.SensorTypeCode = pSensor.SensorTypeCode; SensorInfo.EventTypeCode = pSensor.EventTypeCode; SensorInfo.Units1 = pSensor.Units1; SensorInfo.Units2 = pSensor.Units2; SensorInfo.Units3 = pSensor.Units3; SensorInfo.M_LSB = pSensor.M_LSB; SensorInfo.M_MSB_Tolerance = pSensor.M_MSB_Tolerance; SensorInfo.B_LSB = pSensor.B_LSB; SensorInfo.B_MSB_Accuracy = pSensor.B_MSB_Accuracy; SensorInfo.Accuracy_MSB_Exp = pSensor.Accuracy_MSB_Exp; SensorInfo.RExp_BExp = pSensor.RExp_BExp; SensorInfo.LowerNonCritical = pSensor.LowerNonCritical; SensorInfo.LowerCritical = pSensor.LowerCritical; SensorInfo.LowerNonRecoverable = pSensor.LowerNonRecoverable; SensorInfo.UpperNonCritical = pSensor.UpperNonCritical; SensorInfo.UpperCritical = pSensor.UpperCritical; SensorInfo.UpperNonRecoverable= pSensor.UpperNonRecoverable; SensorInfo.Settable_Readable_ThreshMask= pSensor.SettableThreshMask; SensorInfo.Flags = pSensor.EventFlags & 0xe0; if((pSensor.EventFlags & BIT5) != 0) { SensorInfo.SensorReading = 0; } SensorReading = pSensor.SensorReading; SensorInfo.SensorReading = 0; SensorIsSigned = ( 0 != (pSensor.InternalFlags & BIT1)); if (THRESHOLD_SENSOR_CLASS == pSensor.EventTypeCode) { SensorInfo.SensorReading = (SensorReading & 0x00FF); SensorInfo.ComparisonStatus = 0; if((pSensor.DeassertionEventEnablesByte2 & BIT6) == BIT6 ) { if (CompareValues(SensorIsSigned, SensorInfo.SensorReading, pSensor.UpperNonRecoverable) >= 0) { SensorInfo.ComparisonStatus |= BIT5; } } if((pSensor.DeassertionEventEnablesByte2 & BIT5) == BIT5 ) { if (CompareValues(SensorIsSigned, SensorInfo.SensorReading, pSensor.UpperCritical) >= 0) { SensorInfo.ComparisonStatus |= BIT4; } } if((pSensor.DeassertionEventEnablesByte2 & BIT4) == BIT4 ) { if (CompareValues(SensorIsSigned, SensorInfo.SensorReading, pSensor.UpperNonCritical) >= 0) { SensorInfo.ComparisonStatus |= BIT3; } } if((pSensor.AssertionEventEnablesByte2 & BIT6) == BIT6 ) { if (CompareValues(SensorIsSigned, SensorInfo.SensorReading, pSensor.LowerNonRecoverable) <= 0) { SensorInfo.ComparisonStatus |= BIT2; } } if((pSensor.AssertionEventEnablesByte2 & BIT5) == BIT5 ) { if (CompareValues(SensorIsSigned, SensorInfo.SensorReading, pSensor.LowerCritical) <= 0) { SensorInfo.ComparisonStatus |= BIT1; } } if((pSensor.AssertionEventEnablesByte2 & BIT4) == BIT4 ) { if (CompareValues(SensorIsSigned, SensorInfo.SensorReading, pSensor.LowerNonCritical) <= 0) { SensorInfo.ComparisonStatus |= BIT0; } } SensorInfo.ComparisonStatus &= ((pSensor.SettableThreshMask >> 8) & 0xFF); SensorInfo.OptionalStatus = 0; // For Threshold sensor, [7:6] - reserved. Returned as 1b. Ignore on read. SensorInfo.ComparisonStatus |= THRESHOLD_RESERVED_BIT; } else { SensorInfo.ComparisonStatus = (((INT8U) (SensorReading & 0x00FF)) & ((INT8U) (pSensor.SettableThreshMask & 0x00FF)) ); SensorInfo.OptionalStatus = (((INT8U) (SensorReading >> 8)) & ((INT8U) (pSensor.SettableThreshMask >> 8)) ); // For Discrete sensor, [7] - reserved. Returned as 1b. Ignore on read. SensorInfo.OptionalStatus |= DISCRETE_RESERVED_BIT; } if((pSensor.EventFlags & BIT7) == 0) { SensorInfo.AssertionEventByte1 = 0; SensorInfo.AssertionEventByte2 = 0; SensorInfo.DeassertionEventByte1 = 0; SensorInfo.DeassertionEventByte2 = 0; } if((pSensor.SensorCaps & BIT6) == 0) { SensorInfo.AssertionEventByte1 = (pSensor.AssertionHistoryByte1 & pSensor.AssertionEventEnablesByte1); SensorInfo.AssertionEventByte2 = (pSensor.AssertionHistoryByte2 & pSensor.AssertionEventEnablesByte2); SensorInfo.DeassertionEventByte1 = (pSensor.DeassertionHistoryByte1 & pSensor.DeassertionEventEnablesByte1); SensorInfo.DeassertionEventByte2 = (pSensor.DeassertionHistoryByte2 & pSensor.DeassertionEventEnablesByte2); } else { SensorInfo.AssertionEventByte1 = (pSensor.AssertionEventOccuredByte1 & pSensor.AssertionEventEnablesByte1); SensorInfo.AssertionEventByte2 = (pSensor.AssertionEventOccuredByte2 & pSensor.AssertionEventEnablesByte2); SensorInfo.DeassertionEventByte1 = (pSensor.DeassertionEventOccuredByte1 & pSensor.DeassertionEventEnablesByte1); SensorInfo.DeassertionEventByte2 = (pSensor.DeassertionEventOccuredByte2 & pSensor.DeassertionEventEnablesByte2); } pSDRRec = GetSDRRec(pSensor.SDRRec->ID,BMCInst); if(pSensor.SDRRec->Type == FULL_SDR_REC) /*Full SDR*/ { FullSDR = (_FAR_ FullSensorRec_T *)pSDRRec; SensorInfo.OwnerID = FullSDR->OwnerID; SensorInfo.OwnerLUN= FullSDR->OwnerLUN; SensorInfo.MaxReading = FullSDR->MaxReading; SensorInfo.MinReading = FullSDR->MinReading; SensorInfo.Linearization = FullSDR->Linearization; memset(SensorInfo.SensorName,0,MAX_ID_STR_LEN); strncpy(SensorInfo.SensorName,FullSDR->IDStr, MAX_ID_STR_LEN - (sizeof(FullSensorRec_T) - sizeof(SDRRecHdr_T) - FullSDR->hdr.Len)); } else if(pSensor.SDRRec->Type == COMPACT_SDR_REC) /*Compact SDR*/ { CompSDR = (_FAR_ CompactSensorRec_T *)pSDRRec; SensorInfo.OwnerID = CompSDR->OwnerID; SensorInfo.OwnerLUN= CompSDR->OwnerLUN; SensorInfo.MaxReading = 0; SensorInfo.MinReading = 0; SensorInfo.Linearization = 0; memset(SensorInfo.SensorName,0,MAX_ID_STR_LEN); strncpy(SensorInfo.SensorName,CompSDR->IDStr, MAX_ID_STR_LEN - (sizeof(CompactSensorRec_T) - sizeof(SDRRecHdr_T) - CompSDR->hdr.Len)); } memcpy(pValidSensor,(INT8U *)&SensorInfo,sizeof(SenInfo_T)); pValidSensor = pValidSensor + sizeof(SenInfo_T); } OS_THREAD_MUTEX_RELEASE(&pBMCInfo->m_hSMSharedMemMutex); pAMIGetSensorInfoRes->CompletionCode = CC_NORMAL; pAMIGetSensorInfoRes->Noofentries = pBMCInfo->SenConfig.ValidSensorCnt; return sizeof(AMIGetSensorInfoRes_T) + (sizeof(SenInfo_T) * pBMCInfo->SenConfig.ValidSensorCnt); } /** * @fn AMIGetIPMISessionTimeOut * @brief This function Gets IPMI session timeout. * @param Request message and BMC instance * @return Proper completion code */ int AMIGetIPMISessionTimeOut(_NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes, int BMCInst) { AMIGetIPMISessionTimeOutRes_T * pAMIGetIPMISessionTimeOutRes = (AMIGetIPMISessionTimeOutRes_T *)pRes; /* Chk request Length */ if( ReqLen != 0 ) { *pRes = CC_REQ_INV_LEN; return sizeof (INT8U); } BMCInfo_t *pBMCInfo = &g_BMCInfo[BMCInst]; pAMIGetIPMISessionTimeOutRes->IPMISessionTimeOut = pBMCInfo->IpmiConfig.SessionTimeOut; pAMIGetIPMISessionTimeOutRes->CompletionCode = CC_NORMAL; return sizeof( AMIGetIPMISessionTimeOutRes_T ); } /** * @fn AMIGetUDSInfo * @brief This function Gets UDS Info for Requesting IP's. * @param IPV4/IPV6 Address and BMC instance * @return Channel Number,BMC Instance and Completion Code */ int AMIGetUDSInfo(_NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes, int BMCInst) { AMIGetUDSInfoReq_T *pAMIGetUDSInfoReq = (AMIGetUDSInfoReq_T *)pReq; AMIGetUDSInfoRes_T *pAMIGetUDSInfoRes = (AMIGetUDSInfoRes_T *)pRes; int ChannelNum = -1; INT8U NoofBMC = 1; _FAR_ ChannelInfo_T* pChannelInfo; for(NoofBMC = 1;NoofBMC <= MAX_NUM_BMC; NoofBMC++) { ChannelNum = GetChannelByAddr((char *)&pAMIGetUDSInfoReq->SessionIPAddr[0],NoofBMC); if(ChannelNum == -1) { if(g_corefeatures.global_ipv6 == ENABLED) { ChannelNum = GetChannelByIPv6Addr((char *)&pAMIGetUDSInfoReq->SessionIPAddr[0], NoofBMC); if(ChannelNum != -1) { TDBG("IPV6 Address Found and Channel Number is %x\n",ChannelNum); break; } } } else { TDBG("IPV4 Address Found and Channel Number is %d\n",ChannelNum); break; } } if(ChannelNum != -1) { pChannelInfo = getChannelInfo(ChannelNum,NoofBMC); if(NULL == pChannelInfo) { *pRes = CC_INV_DATA_FIELD; return sizeof (*pRes); } pAMIGetUDSInfoRes->CompletionCode = CC_NORMAL; pAMIGetUDSInfoRes->ChannelNum = ChannelNum; pAMIGetUDSInfoRes->ChannelType = pChannelInfo->ChannelType; pAMIGetUDSInfoRes->BMCInstance = NoofBMC; } else { pAMIGetUDSInfoRes->CompletionCode = CC_INV_DATA_FIELD; return sizeof(INT8U); } return sizeof(AMIGetUDSInfoRes_T); } /** * @fn AMIGetUDSSessionInfo * @brief This function Gets UDS Session Info for Requesting Session Handle * /Session Index/Session ID. * @param Parameter Selector and BMC instance * @return UDS Session Information and Completion Code */ int AMIGetUDSSessionInfo(_NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes, int BMCInst) { AMIGetUDSSessionInfoReq_T *pAMIGetUDSSessionInfoReq = (AMIGetUDSSessionInfoReq_T *)pReq; AMIGetUDSSessionInfoRes_T *pAMIGetUDSSessionInfoRes = ( AMIGetUDSSessionInfoRes_T *)pRes; UDSSessionTbl_T *pUDSSessionTblInfo = NULL; INT8U ArgType =0xFF; BMCInfo_t *pBMCInfo = &g_BMCInfo[BMCInst]; INT8U Index,ResLen; if( ReqLen != UDSSessionInfoParamLength[pAMIGetUDSSessionInfoReq->UDSSessionParam]) { *pRes = CC_REQ_INV_LEN; return sizeof(*pRes); } pAMIGetUDSSessionInfoRes->CompletionCode = CC_NORMAL; switch(pAMIGetUDSSessionInfoReq->UDSSessionParam) { case UDS_SESSION_COUNT_INFO: pAMIGetUDSSessionInfoRes->UDSLoggedInInfo.UDSSessionCountInfo.MaxAllowedSession = pBMCInfo->IpmiConfig.MaxSession; pAMIGetUDSSessionInfoRes->UDSLoggedInInfo.UDSSessionCountInfo.ActiveSessionCount = pBMCInfo->UDSSessionTblInfo.SessionCount; return sizeof(INT8U )+sizeof(UDSSessionCount_T); case UDS_SESSION_ID_INFO: ArgType = UDS_SESSION_ID_INFO; break; case UDS_SESSION_HANDLE_INFO: ArgType = UDS_SESSION_HANDLE_INFO; break; case UDS_SESSION_INDEX_INFO: ArgType = UDS_SESSION_INDEX_INFO; break; case UDS_SOCKET_ID_INFO: ArgType = UDS_SOCKET_ID_INFO; break; case UDS_SESSION_PID_INFO: ArgType = UDS_SESSION_INDEX_INFO; pUDSSessionTblInfo = GetUDSSessionInfo(ArgType,(void *)&pAMIGetUDSSessionInfoReq->UDSSessionHandleOrIDOrIndex[0],BMCInst); if(NULL == pUDSSessionTblInfo) { *pRes =CC_INV_DATA_FIELD; return sizeof(*pRes); } pAMIGetUDSSessionInfoRes->UDSLoggedInInfo.UDSSessionPIDInfo.ProcessID = ipmitoh_u32(pUDSSessionTblInfo->ProcessID); pAMIGetUDSSessionInfoRes->UDSLoggedInInfo.UDSSessionPIDInfo.ThreadID = ipmitoh_u32(pUDSSessionTblInfo->ThreadID); return sizeof(INT8U )+sizeof(UDSSessionPIDInfo_T); break; case UDS_ACTIVE_SESSION_INDEX_LIST: pRes[0] = CC_NORMAL; for(Index = 0, ResLen = 1; Index < pBMCInfo->IpmiConfig.MaxSession; Index++) { if(FALSE == pBMCInfo->UDSSessionTblInfo.UDSSessionTbl[Index].Activated) { continue; } pRes[ResLen] = Index; ResLen++; } return ResLen; break; default: *pRes=CC_INV_DATA_FIELD; return sizeof (*pRes); } pUDSSessionTblInfo = GetUDSSessionInfo(ArgType,(void *)&pAMIGetUDSSessionInfoReq->UDSSessionHandleOrIDOrIndex[0],BMCInst); if(NULL == pUDSSessionTblInfo) { *pRes =CC_INV_DATA_FIELD; return sizeof(*pRes); } /* Filling up the required Session Related Response for the requested Session ID/Session Handle/Session Index */ pAMIGetUDSSessionInfoRes->UDSLoggedInInfo.UDSLoggedInSessionInfo.LoggedInSessionID = pUDSSessionTblInfo->SessionID; pAMIGetUDSSessionInfoRes->UDSLoggedInInfo.UDSLoggedInSessionInfo.LoggedInSessionHandle = pUDSSessionTblInfo->LoggedInSessionHandle; pAMIGetUDSSessionInfoRes->UDSLoggedInInfo.UDSLoggedInSessionInfo.LoggedInTime = pUDSSessionTblInfo->LoggedInTime; pAMIGetUDSSessionInfoRes->UDSLoggedInInfo.UDSLoggedInSessionInfo.LoggedInUserID = pUDSSessionTblInfo->LoggedInUserID; pAMIGetUDSSessionInfoRes->UDSLoggedInInfo.UDSLoggedInSessionInfo.LoggedInPrivilege = pUDSSessionTblInfo->LoggedInPrivilege; pAMIGetUDSSessionInfoRes->UDSLoggedInInfo.UDSLoggedInSessionInfo.AuthenticationMechanism = pUDSSessionTblInfo->AuthenticationMechanism; pAMIGetUDSSessionInfoRes->UDSLoggedInInfo.UDSLoggedInSessionInfo.UDSChannelNum = pUDSSessionTblInfo->UDSChannelNum; pAMIGetUDSSessionInfoRes->UDSLoggedInInfo.UDSLoggedInSessionInfo.ChannelNum = pUDSSessionTblInfo->LoggedInChannel; pAMIGetUDSSessionInfoRes->UDSLoggedInInfo.UDSLoggedInSessionInfo.SessionTimeoutValue = pUDSSessionTblInfo->SessionTimeoutValue; return sizeof(INT8U)+sizeof(UDSLoggedInSessionInfo_T); } /** * @fn RISServiceStatus * @brief This function Gets Remote Image service feature supported and enable informations */ int RISServiceStatus() { VMediaCfg_T media_cfg; int ServiceErr = 0; /*Check for Feature is supported*/ if(ENABLED != g_corefeatures.rmedia_support ) { TCRIT("Remote Images Service is Not Supported\n"); return CC_INV_CMD; } memset(&media_cfg, 0, sizeof(VMediaCfg_T)); ServiceErr = GetVMediaCfg(&media_cfg,g_corefeatures.lmedia_support,g_corefeatures.rmedia_support); if(ServiceErr < 0) { TCRIT("Error in Getting Vmedia Configuration\n"); return CC_UNSPECIFIED_ERR; } /*Check for RIS Sevice is Enabled*/ if(ENABLED != media_cfg.rmedia_enable ) { TCRIT("Remote Images Service is Not Enabled\n"); return CC_SERVICE_NOT_ENABLED; } return CC_SUCCESS; } /** * @fn RISSetServiceStatus * @brief This function Sets Remote Image service feature supported and enable informations */ int RISSetServiceStatus(INT8U Status) { VMediaCfg_T media_cfg; int ServiceErr = 0; /*Check for Feature is supported*/ if(ENABLED != g_corefeatures.rmedia_support ) { TCRIT("Remote Images Service is Not Supported\n"); return CC_INV_CMD; } memset(&media_cfg, 0, sizeof(VMediaCfg_T)); ServiceErr = GetVMediaCfg(&media_cfg,g_corefeatures.lmedia_support,g_corefeatures.rmedia_support); if(ServiceErr < 0) { TCRIT("Error in Getting Vmedia Configuration\n"); return CC_UNSPECIFIED_ERR; } /*Check for RIS Sevice Status*/ if(Status != media_cfg.rmedia_enable ) { media_cfg.rmedia_enable = Status; ServiceErr = SetVMediaCfg(&media_cfg,g_corefeatures.lmedia_support,g_corefeatures.rmedia_support); if(ServiceErr < 0) { TCRIT("Error in Getting Vmedia Configuration\n"); return CC_UNSPECIFIED_ERR; } } return CC_SUCCESS; } /** * @fn AMIGetRISConf * @brief This function Gets Remote Image service configuration Info for Requesting Session Handle * /Session Index/Session ID. * @param Parameter Selector * @return Remote Image service configuration Information and Completion Code */ int AMIGetRISConf( _NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes,int BMCInst) { _NEAR_ AMIGetRISConfReq_T* pAMIGetRISConfReq = (_NEAR_ AMIGetRISConfReq_T*) pReq; _NEAR_ AMIGetRISConfRes_T* pAMIGetRISConfRes = (_NEAR_ AMIGetRISConfRes_T*) pRes; MediaCfg_T conf; INT32U Value = 0; INT8U MediaTypeBit = 0; int ServiceErr = 0; /* Match the service_id byte with ServiceName */ Value = (pAMIGetRISConfReq->MediaType); ServiceErr = GetINT32UBitsNum (Value, &MediaTypeBit); if(ServiceErr < 0) { TCRIT("Error in getting bit number from service_id\n"); *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } if(ServiceList[MediaTypeBit] == NULL) { TCRIT("MediaName is not found in ServiceList\n"); *pRes = CC_INVALID_MEDIA_TYPE; return sizeof (INT8U); } /*Check for Feature is supported*/ if(ENABLED != g_corefeatures.rmedia_support ) { TCRIT("Remote Images Service is Not Supported\n"); *pRes = CC_INV_CMD; return sizeof (INT8U); } ServiceErr = GetMediaCfg(&conf,ServiceList[MediaTypeBit]); if(ServiceErr < 0) { *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } memset(pAMIGetRISConfRes, 0, sizeof(AMIGetRISConfRes_T)); pAMIGetRISConfRes->MediaType= pAMIGetRISConfReq->MediaType; pAMIGetRISConfRes->ParameterSelect= pAMIGetRISConfReq->ParameterSelect; pAMIGetRISConfRes->CompletionCode = CC_SUCCESS; switch(pAMIGetRISConfReq->ParameterSelect) { case RIS_IMAGE_NAME: _fmemcpy(pAMIGetRISConfRes->Config.ImageName, conf.Image_Name,MAX_IMAGE_NAME_LEN); return (sizeof(AMIGetRISConfRes_T) - sizeof(RISConfig_T) + MAX_IMAGE_NAME_LEN); case RIS_REMOTE_PATH: _fmemcpy(pAMIGetRISConfRes->Config.MountPath, conf.Image_Path,MAX_IMAGE_PATH_SIZE); return (sizeof(AMIGetRISConfRes_T) - sizeof(RISConfig_T) + MAX_IMAGE_PATH_SIZE); case RIS_IP_ADDR: _fmemcpy(pAMIGetRISConfRes->Config.RemoteIP, conf.Ip_Addr,MAX_IP_ADDR_LEN); return (sizeof(AMIGetRISConfRes_T) - sizeof(RISConfig_T) + MAX_IP_ADDR_LEN); case RIS_USER_NAME: _fmemcpy(pAMIGetRISConfRes->Config.UserName, conf.Username,MAX_RMS_USERNAME_LEN); return (sizeof(AMIGetRISConfRes_T) - sizeof(RISConfig_T) + MAX_RMS_USERNAME_LEN); case RIS_PASSWORD: // Should not expose password don't enable below line //_fmemcpy(pAMIGetRISConfRes->Config.Password, conf.Password,MAX_RMS_PASSWORD_LEN); return (sizeof(AMIGetRISConfRes_T) - sizeof(RISConfig_T) + MAX_RMS_PASSWORD_LEN); case RIS_SHARE_TYPE: _fmemcpy(pAMIGetRISConfRes->Config.ShareType, conf.Share_Type,MAX_SHARE_TYPE_LEN); return (sizeof(AMIGetRISConfRes_T) - sizeof(RISConfig_T) + MAX_SHARE_TYPE_LEN); case RIS_DOMAIN: _fmemcpy(pAMIGetRISConfRes->Config.Domain, conf.Domain,MAX_DOMAIN_LEN); return(MAX_DOMAIN_LEN+3); default: pAMIGetRISConfRes->CompletionCode = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } } /** * @fn VerifyData * @brief This function checks for presence of multiple string in the given array * @param Data * @return 0 on success and -1 on failure */ int VerifyData(INT8S *Data) { int trace; for( trace=MAX_DOMAIN_BLOCK_SIZE*MAX_BLOCK;trace>=0;trace--) /*Finds last Non-NULL Char from last*/ { if(Data[trace]!='\0') break; } if(trace==-1) { TDBG("String does't have any NULL termination\n"); return trace; } if(trace+1==strlen(Data)) { return 0; } else { TDBG("First NULL at =%d, Last NULL at =%d,String =%s\n",strlen(Data),trace+1,Data); return -1; } } /** * @fn SetBlockData * @brief This function sets Block of data nad progress bit * @param Request message BMCShared memory parameter bit , data , BMC instance ,errcode, Datalen * @outparam ValidData * @return success completion code */ int SetBlockData(AMISetRISConfReq_T* Req,INT8U *SharedBit,INT8U *SharedData,int BMCInst,INT8U ErrCode,INT8S *ValidData, int Datalen) { struct addrinfo *pResult; INT8U RetVal = CC_SUCCESS; /* Progress Bit From Shared Memory*/ INT8U ProgressBit = *SharedBit ; /*If Blockselector is zero .its for setting ProgressBit*/ if( 0x0 == Req->Blockselector ) { /*Validate ProgressBit*/ if( ( SET_COMPLETE != Req->config.ProgressBit) && ( SET_IN_PROGRESS != Req->config.ProgressBit) ) { RetVal = CC_INV_PROGRESS_BIT; } /* Valid Progress BIt .Process the request*/ else { /* ProgressBit and request progressBit are equal*/ if(Req->config.ProgressBit == ProgressBit) { /* ProgressBit is Already set as SET_IN_PROGRESS Dont allow to set data*/ if(( SET_IN_PROGRESS == ProgressBit ) && ( SET_IN_PROGRESS == Req->config.ProgressBit )) { RetVal = CC_SET_IN_PROGRESS; } /* IF SET_COMPLETE Bit is set already send success code as response*/ else if(( SET_COMPLETE == ProgressBit ) && ( SET_COMPLETE == Req->config.ProgressBit )) { memset(SharedData,0,MAX_DOMAIN_BLOCK_SIZE*MAX_BLOCK); RetVal = CC_SUCCESS; } } /* Allow ProgressBit to set if both are not equal*/ else { /* Update the progress bit*/ LOCK_BMC_SHARED_MEM(BMCInst); *SharedBit = Req->config.ProgressBit; UNLOCK_BMC_SHARED_MEM(BMCInst); /* IF SET_COMPLETE Bit is set write data from shared memory to file*/ if(SET_COMPLETE == Req->config.ProgressBit ) { _fmemcpy(ValidData,SharedData,(MAX_DOMAIN_BLOCK_SIZE*MAX_BLOCK)+1); memset(SharedData,0,MAX_DOMAIN_BLOCK_SIZE*MAX_BLOCK); if(0 != strlen(ValidData)) { /*Validation Completed Write data to file*/ RetVal = WRITE_TO_FILE; if(Req->ParameterSelect == RIS_DOMAIN) { if (0 != getaddrinfo((char *)ValidData, NULL, NULL, &pResult)) { RetVal = CC_INVALID_DOMAIN; } } } else { RetVal = ErrCode ; } } /* IF SET_IN_PROGRESS Bit is send success code as response*/ else { RetVal = CC_SUCCESS; } } } } /*If Blockselector is 1 to 4 .its for setting data*/ else if(( Req->Blockselector > 0x0) && ( Req->Blockselector <= MAX_BLOCK) ) { /* SET_IN_PROGRESS BIT is not set.Dont allow to set data*/ if(SET_IN_PROGRESS != ProgressBit) { RetVal = CC_PROGRESS_BIT_NOT_SET; } /* SET_IN_PROGRESS BIT is set. Update data inShared memory*/ else { LOCK_BMC_SHARED_MEM(BMCInst); memset(SharedData+(MAX_DOMAIN_BLOCK_SIZE * (Req->Blockselector - 1)), 0,MAX_DOMAIN_BLOCK_SIZE); switch(Req->ParameterSelect) { case RIS_IMAGE_NAME: _fmemcpy( SharedData+(MAX_DOMAIN_BLOCK_SIZE * (Req->Blockselector - 1)),Req->config.ImageName,Datalen); break; case RIS_REMOTE_PATH: _fmemcpy( SharedData+(MAX_DOMAIN_BLOCK_SIZE * (Req->Blockselector - 1)),Req->config.MountPath,Datalen); break; case RIS_USER_NAME: _fmemcpy( SharedData+(MAX_DOMAIN_BLOCK_SIZE * (Req->Blockselector - 1)),Req->config.UserName,Datalen); break; case RIS_DOMAIN: _fmemcpy( SharedData+(MAX_DOMAIN_BLOCK_SIZE * (Req->Blockselector - 1)),Req->config.Domain,Datalen); break; default: break; } UNLOCK_BMC_SHARED_MEM(BMCInst); } } else { RetVal = CC_INVALID_BLOCK_SELECTOR; } return RetVal; } /** * @fn AMISetRISConf * @brief This function sets the RIS configurations * @param Parameter selector and Request message and BMC instance * @return success completion code */ int AMISetRISConf( _NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes,int BMCInst) { _NEAR_ AMISetRISConfReq_T* pAMISetRISConfReq = (_NEAR_ AMISetRISConfReq_T*) pReq; _NEAR_ AMISetRISConfRes_T* pAMISetRISConfRes = (_NEAR_ AMISetRISConfRes_T*) pRes; MediaCfg_T conf; INT32U Value = 0; INT8U ServiceTypeBit = 0; int ServiceErr = 0; int DataLen = 0; INT8U MediaType = 0; INT8U done = 0; INT8S IPV4[sizeof(struct in_addr)]; INT8 IPV6[sizeof(struct in6_addr)]; INT8S IPAddr[MAX_IP_ADDR_LEN]; INT8U ValidIP = 0; INT8S *EndsWith = NULL; INT8U EndsWithLen = 0; INT8U ValidImage = 0; INT8S ValidData[MAX_DOMAIN_BLOCK_SIZE*MAX_BLOCK+1]; /* Match the service_id byte with ServiceName */ Value = (pAMISetRISConfReq->MediaType); ServiceErr = GetINT32UBitsNum (Value, &ServiceTypeBit); if(ServiceErr < 0) { TCRIT("Error in Getting Bit Number from Service ID\n"); if (ReqLen <=0) *pRes = CC_REQ_INV_LEN; else *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } else { if ( ReqLen >= ServiceLen[ServiceTypeBit]) { DataLen = ReqLen - ServiceLen[ServiceTypeBit]; } else { *pRes = CC_REQ_INV_LEN; return sizeof (INT8U); } } if(ServiceList[ServiceTypeBit] == NULL) { TCRIT("Service Name Not Available for the Requested Service ID\n"); *pRes = CC_INVALID_MEDIA_TYPE; return sizeof (INT8U); } /* Enable/Disable Remote Images Service*/ if(0 == memcmp(ServiceList[ServiceTypeBit],RMS_SET,strlen(RMS_SET))) { /* Check For parameter Field length*/ if(DataLen > 0) { *pRes = CC_REQ_FIELD_LEN_EXCEEDED; return sizeof (INT8U); } /* Check for valid start/stop bit*/ if ((pAMISetRISConfReq->ParameterSelect != RIS_START) && (pAMISetRISConfReq->ParameterSelect != RIS_STOP )) { *pRes = CC_INVALID_COMMAND; return sizeof (INT8U); } /* Set RIS Status*/ ServiceErr = RISSetServiceStatus(pAMISetRISConfReq->ParameterSelect); *pRes = ServiceErr; return sizeof (INT8U); } /*Validate the Block selector*/ if( 0 != pAMISetRISConfReq->Blockselector && (pAMISetRISConfReq->ParameterSelect != RIS_IMAGE_NAME ) && (pAMISetRISConfReq->ParameterSelect != RIS_REMOTE_PATH ) && (pAMISetRISConfReq->ParameterSelect != RIS_USER_NAME) && (pAMISetRISConfReq->ParameterSelect != RIS_DOMAIN)) { *pRes = CC_INV_DATA_FIELD; return sizeof(INT8U); } if((pAMISetRISConfReq->Blockselector==0) && (pAMISetRISConfReq->ParameterSelect != RIS_IP_ADDR ) && (pAMISetRISConfReq->ParameterSelect != RIS_PASSWORD ) && (pAMISetRISConfReq->ParameterSelect !=RIS_SHARE_TYPE ) && (ReqLen!=4)) { *pRes = CC_REQ_INV_LEN; return sizeof (INT8U); } /* Check For RIS support*/ ServiceErr = RISServiceStatus(); if(ServiceErr != 0) { *pRes = ServiceErr; return sizeof (INT8U); } /* Check For parameter Field length*/ if(DataLen <=0) { *pRes = CC_REQ_INV_LEN; return sizeof (INT8U); } else if (DataLen > ServiceParamLength [pAMISetRISConfReq->ParameterSelect ]) { *pRes = CC_REQ_FIELD_LEN_EXCEEDED; TDBG("Your entered Parameter %d is not a valid data \n",pAMISetRISConfReq->ParameterSelect); return sizeof (INT8U); } else { TDBG("Your entered Parameter %d is a valid data... \n",pAMISetRISConfReq->ParameterSelect); } //set image name to particular service structure if(pAMISetRISConfReq->ParameterSelect == RIS_IMAGE_NAME) { memset(ValidData,0,(MAX_DOMAIN_BLOCK_SIZE*MAX_BLOCK) + 1); *pRes = SetBlockData(pAMISetRISConfReq, &(BMC_GET_SHARED_MEM (BMCInst)->RISconf.ImageNameBit),&BMC_GET_SHARED_MEM (BMCInst)->RISconf.ImageName[0], BMCInst,CC_INVALID_IMAGE_FILE_NAME,ValidData, DataLen); if(*pRes != WRITE_TO_FILE) { return sizeof (INT8U); } if(VerifyData(ValidData)==-1) { *pRes = CC_INVALID_IMAGE_FILE_NAME; return sizeof (INT8U); } EndsWith = strrchr(ValidData, '.'); if( EndsWith != NULL ) { EndsWithLen = strlen(EndsWith); if( EndsWithLen != strlen(".iso") ) { *pRes = CC_INVALID_IMAGE_FILE_NAME; return sizeof (INT8U); } if(0 == memcmp(ServiceList[ServiceTypeBit],RMS_CD_SECTION_NAME,strlen(RMS_CD_SECTION_NAME))) { if((0 == memcmp(EndsWith, ".iso",EndsWithLen)) || ( 0 == memcmp(EndsWith, ".ISO",EndsWithLen))) ValidImage = 1; } else { if((0 == memcmp(EndsWith, ".img",EndsWithLen)) || ( 0 == memcmp(EndsWith, ".IMG",EndsWithLen))) ValidImage = 1; } } if ((EndsWith == NULL ) || ( !ValidImage )) { *pRes = CC_INVALID_IMAGE_FILE_NAME; return sizeof (INT8U); } MediaType = ServiceTypeBit; done = 1; } else if(pAMISetRISConfReq->ParameterSelect == RIS_REMOTE_PATH) { memset(ValidData,0,MAX_DOMAIN_BLOCK_SIZE*MAX_BLOCK); *pRes = SetBlockData(pAMISetRISConfReq, &(BMC_GET_SHARED_MEM (BMCInst)->RISconf.MountPathBit),&BMC_GET_SHARED_MEM (BMCInst)->RISconf.MountPath[0], BMCInst,CC_INVALID_IMG_PATH,ValidData, DataLen); if(*pRes != WRITE_TO_FILE) { return sizeof (INT8U); } if(VerifyData(ValidData)==-1) { *pRes = CC_INVALID_IMG_PATH; return sizeof (INT8U); } } else if(pAMISetRISConfReq->ParameterSelect == RIS_USER_NAME) { memset(ValidData,0,MAX_DOMAIN_BLOCK_SIZE*MAX_BLOCK); *pRes = SetBlockData(pAMISetRISConfReq, &(BMC_GET_SHARED_MEM (BMCInst)->RISconf.UserNameBit),&BMC_GET_SHARED_MEM (BMCInst)->RISconf.UserName[0], BMCInst,CC_INVALID_USR_NAME,ValidData, DataLen); if(*pRes != WRITE_TO_FILE) { return sizeof (INT8U); } if(VerifyData(ValidData)==-1) { *pRes = CC_INVALID_USR_NAME; return sizeof (INT8U); } } else if(pAMISetRISConfReq->ParameterSelect == RIS_PASSWORD) { pAMISetRISConfReq->config.Password[DataLen]='\0'; if(0 == strlen(pAMISetRISConfReq->config.Password)) { *pRes = CC_INVALID_PASSWD; return sizeof (INT8U); } } else if(pAMISetRISConfReq->ParameterSelect == RIS_SHARE_TYPE) { pAMISetRISConfReq->config.ShareType[DataLen]='\0'; if(0 == strlen(pAMISetRISConfReq->config.ShareType)) { *pRes = CC_INVALID_SHARE_TYPE; return sizeof (INT8U); } if((strncmp(pAMISetRISConfReq->config.ShareType, SHARE_TYPE_NFS,DataLen) == 0) || (strncmp(pAMISetRISConfReq->config.ShareType, SHARE_TYPE_CIFS,DataLen) == 0) ) { } else { *pRes = CC_INVALID_SHARE_TYPE; return sizeof (INT8U); } } else if(pAMISetRISConfReq->ParameterSelect == RIS_IP_ADDR) { pAMISetRISConfReq->config.RemoteIP[DataLen]='\0'; if(0 == strlen(pAMISetRISConfReq->config.RemoteIP)) { *pRes = CC_INVALID_IP_ADDR; return sizeof (INT8U); } memset(IPAddr,0,MAX_IP_ADDR_LEN); _fmemcpy(IPAddr,pAMISetRISConfReq->config.RemoteIP,DataLen); if (inet_pton (AF_INET6, IPAddr, (char*)IPV6)) { ValidIP ++; } if ( inet_pton (AF_INET, IPAddr, (char*)IPV4)) { ValidIP ++; } if( !ValidIP) { *pRes = CC_INVALID_IP_ADDR; return sizeof (INT8U); } } else if(pAMISetRISConfReq->ParameterSelect == RIS_DOMAIN) { memset(ValidData,0,MAX_DOMAIN_BLOCK_SIZE*MAX_BLOCK); *pRes = SetBlockData(pAMISetRISConfReq, &(BMC_GET_SHARED_MEM (BMCInst)->RISconf.DomainNameBit),&BMC_GET_SHARED_MEM (BMCInst)->RISconf.DomainName[0], BMCInst,CC_INVALID_DOMAIN,ValidData, DataLen); if(*pRes != WRITE_TO_FILE) { return sizeof (INT8U); } if(VerifyData(ValidData)==-1) { *pRes = CC_INVALID_DOMAIN; return sizeof (INT8U); } } pAMISetRISConfRes->CompletionCode = CC_SUCCESS; /*ParameterSelect is other then RIS_IMAGE_NAME need to set it for CD,FD,HD structure*/ do { memset(&conf,0,sizeof(MediaCfg_T)); ServiceErr = GetMediaCfg(&conf,ServiceList[MediaType]); if(ServiceErr < 0) { *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } switch (pAMISetRISConfReq->ParameterSelect) { case RIS_IMAGE_NAME: memset(conf.Image_Name ,0,MAX_IMAGE_NAME_LEN); _fmemcpy(conf.Image_Name,ValidData,strlen(ValidData)+1); break; case RIS_REMOTE_PATH: memset(conf.Image_Path ,0,MAX_IMAGE_PATH_SIZE); _fmemcpy(conf.Image_Path,ValidData,strlen(ValidData)+1); break; case RIS_IP_ADDR: memset(conf.Ip_Addr,0,MAX_IP_ADDR_LEN ); _fmemcpy(conf.Ip_Addr,pAMISetRISConfReq->config.RemoteIP,DataLen); break; case RIS_USER_NAME: memset(conf.Username,0,MAX_RMS_USERNAME_LEN ); _fmemcpy(conf.Username,ValidData,strlen(ValidData)+1); break; case RIS_PASSWORD: memset(conf.Password,0,MAX_RMS_PASSWORD_LEN ); _fmemcpy(conf.Password,pAMISetRISConfReq->config.Password,DataLen); break; case RIS_SHARE_TYPE: memset(conf.Share_Type,0,MAX_SHARE_TYPE_LEN ); _fmemcpy(conf.Share_Type,pAMISetRISConfReq->config.ShareType,DataLen); break; case RIS_DOMAIN: memset(conf.Domain,0,MAX_DOMAIN_LEN); _fmemcpy(conf.Domain,ValidData,strlen(ValidData)+1); break; default: pAMISetRISConfRes->CompletionCode = CC_PARAM_NOT_SUPPORTED; return sizeof(INT8U); } ServiceErr = SetMediaCfg(&conf,ServiceList[MediaType]); if(ServiceErr < 0) { *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } /*Stop the service only if its running*/ if(1 == conf.Start_Mount ) { ServiceErr = RMediaStartAndStop(ServiceParam[MediaType], RIS_STOP ); if(ServiceErr < 0) { *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } } MediaType++; }while((MediaType < MAX_SERVICE_COUNT) && (!done)); return(sizeof(AMISetServiceConfRes_T)); } int AMIRISStartStop( _NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes,int BMCInst) { _NEAR_ AMIRISStartStopReq_T* pAMIRISStartStopReq = (_NEAR_ AMIRISStartStopReq_T*) pReq; _NEAR_ AMIRISStartStopRes_T* pAMIRISStartStopRes = (_NEAR_ AMIRISStartStopRes_T*) pRes; MediaCfg_T conf; INT32U Value = 0; INT8U MediaTypeBit = 0; int ServiceErr = 0; if ( ReqLen < 2 ) { *pRes = CC_REQ_INV_LEN; return sizeof (INT8U); } /* Match the service_id byte with ServiceName */ Value = (pAMIRISStartStopReq->MediaType); ServiceErr = GetINT32UBitsNum (Value, &MediaTypeBit); if(ServiceErr < 0) { TCRIT("Error in Getting Bit Number from Service ID\n"); *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } if(ServiceList[MediaTypeBit] == NULL) { TCRIT("Service Name Not Available for the Requested Service ID\n"); *pRes = CC_INVALID_MEDIA_TYPE; return sizeof (INT8U); } /* Check For RIS support*/ ServiceErr = RISServiceStatus(); if(ServiceErr != 0) { *pRes = ServiceErr; return sizeof (INT8U); } if ((pAMIRISStartStopReq->ParameterSelect != RIS_START) && (pAMIRISStartStopReq->ParameterSelect != RIS_STOP )) { *pRes = CC_INVALID_COMMAND; return sizeof (INT8U); } memset(&conf,0,sizeof(MediaCfg_T)); ServiceErr = GetMediaCfg(&conf,ServiceList[MediaTypeBit]); if(ServiceErr < 0) { *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } /*Return incase minumum configuration is not met*/ if((0 ==strlen(conf.Image_Name)) ||( 0 == strlen(conf.Image_Path )) ||( 0 ==strlen( conf.Ip_Addr)) ||( 0 == strlen(conf.Share_Type ))) { *pRes = CC_INVALID_CONFIGURATION; return sizeof (INT8U); } /*If Request command start/stop bit and configuration start/stop bit are same */ if(pAMIRISStartStopReq->ParameterSelect == conf.Start_Mount ) { *pRes = CC_SUCCESS; return sizeof (INT8U); } ServiceErr = RMediaStartAndStop(ServiceParam[MediaTypeBit],pAMIRISStartStopReq->ParameterSelect ); if(ServiceErr < 0) { *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } pAMIRISStartStopRes->CompletionCode = CC_SUCCESS; return(sizeof(AMIRISStartStopRes_T)); } /*--------------------------------------- * AMIControlDebugMsg *---------------------------------------*/ int AMIControlDebugMsg(_NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes, int BMCInst) { AMIControlDebugMsgReq_T *pAMIControlDebugMsgReq = (AMIControlDebugMsgReq_T *)pReq; AMIControlDebugMsgRes_T *pAMIControlDebugMsgRes = (AMIControlDebugMsgRes_T*)pRes; char Cmd[MAX_STRING_LEN] = {0}; if(g_corefeatures.runtime_dbgmsg_support == ENABLED) { pAMIControlDebugMsgRes->CompletionCode = CC_NORMAL; if(pAMIControlDebugMsgReq->CtrlDebugMsg == 1) { snprintf(Cmd,sizeof(Cmd),"touch %s",ENABLE_DBG_MSG); safe_system(Cmd); pAMIControlDebugMsgRes->DebugMsgStatus = DEBUG_MSG_ENABLED; } else if(pAMIControlDebugMsgReq->CtrlDebugMsg == 0) { unlink(ENABLE_DBG_MSG); pAMIControlDebugMsgRes->DebugMsgStatus = DEBUG_MSG_DISABLED; } else { pAMIControlDebugMsgRes->CompletionCode = CC_INV_DATA_FIELD; } return sizeof(AMIControlDebugMsgRes_T); } else { *pRes = CC_INV_CMD; return sizeof(*pRes); } } /*--------------------------------------- * AMIGetDebugMsgStatus *---------------------------------------*/ int AMIGetDebugMsgStatus(_NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes, int BMCInst) { struct stat buff; AMIGetDebugMsgStatusRes_T *pAMIGetDebugMsgStatusRes = (AMIGetDebugMsgStatusRes_T *)pRes; if(g_corefeatures.runtime_dbgmsg_support == ENABLED) { if(stat(ENABLE_DBG_MSG,&buff) == 0) { pAMIGetDebugMsgStatusRes->DebugMsgStatus = DEBUG_MSG_ENABLED; } else { pAMIGetDebugMsgStatusRes->DebugMsgStatus = DEBUG_MSG_DISABLED; } pAMIGetDebugMsgStatusRes->CompletionCode = CC_NORMAL; return sizeof(AMIGetDebugMsgStatusRes_T); } else { *pRes = CC_INV_CMD; return sizeof(*pRes); } } /* *@fn AMI_SET_EXTENDED_PRIV *@brief This command helps to get users shell * @param pReq - Request for the command * @param ReqLen - Request length for the command * @param pRes - Respose for the command * @param BMCInst- BMC Instance * @return Returns size of AMIGetUserShelltypeRes_T */ int AMIGetExtendedPrivilege(_NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes,int BMCInst) { _NEAR_ AMISetExtendedPrivReq_T* pGetExtendedprivReq = (_NEAR_ AMISetExtendedPrivReq_T*)pReq; _NEAR_ AMIGetExtendedPrivRes_T* pGetExtendedprivRes = (_NEAR_ AMIGetExtendedPrivRes_T*)pRes; _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; _FAR_ UserInfo_T* pUserInfo = NULL; INT8U UserId=0; UserId = pGetExtendedprivReq->UserID & 0x3F; /* if user ID exceeded the Max limit */ if (pGetExtendedprivReq->UserID > pBMCInfo->IpmiConfig.MaxUsers) { pGetExtendedprivRes->CompletionCode = CC_INV_DATA_FIELD ; return sizeof (*pRes);/* Invalied user id */ } pUserInfo = getUserIdInfo(UserId, BMCInst); /* User with given ID is not created */ if ( NULL == pUserInfo ) { *pRes = CC_INV_DATA_FIELD; return sizeof (*pRes); } LOCK_BMC_SHARED_MEM(BMCInst); pGetExtendedprivRes->CompletionCode = CC_NORMAL; pGetExtendedprivRes->Extendedpriv = pUserInfo->ExtendedPrivilege; UNLOCK_BMC_SHARED_MEM(BMCInst); return sizeof (AMIGetExtendedPrivRes_T); } /* *@fn AMISetExtendedpriv *@brief This command helps to set users shell * @param pReq - Request for the command * @param ReqLen - Request length for the command * @param pRes - Respose for the command * @param BMCInst- BMC Instance * @return Returns size of AMISetUserShelltypeRes_T */ int AMISetExtendedPrivilege(_NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes,int BMCInst) { _NEAR_ AMISetExtendedPrivReq_T* pSetExtendedprivReq = (_NEAR_ AMISetExtendedPrivReq_T*)pReq; _FAR_ UserInfo_T* pUserInfo = NULL; _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo[BMCInst]; INT8U UserId=0; INT32U oldExtendedprivstatus =0; UserId = pSetExtendedprivReq->UserID & 0x3F; /* if user ID exceeded the Max limit */ if (pSetExtendedprivReq->UserID > pBMCInfo->IpmiConfig.MaxUsers) { *pRes = CC_INV_DATA_FIELD ; return sizeof (*pRes);/* Invalid user id */ } if(pSetExtendedprivReq->Extendedpriv & INVALID_PRIV_REQUEST) { *pRes = CC_INV_DATA_FIELD ; return sizeof (*pRes);/* Invalid Extended Privilege requested*/ } pUserInfo = getUserIdInfo(UserId, BMCInst); /* If User is not created */ if ( NULL == pUserInfo ) { *pRes = CC_INV_DATA_FIELD; return sizeof (*pRes); } /* Skipping Updation If older and newer privilege same */ if(pUserInfo->ExtendedPrivilege == pSetExtendedprivReq->Extendedpriv ) { *pRes = CC_NORMAL; return sizeof (*pRes); } LOCK_BMC_SHARED_MEM(BMCInst); oldExtendedprivstatus = pUserInfo->ExtendedPrivilege; pUserInfo->ExtendedPrivilege = pSetExtendedprivReq->Extendedpriv; if ( 0 != pUserInfo->UserName[0]) { AddIPMIUsrtoFlagsGrp((char *)pUserInfo->UserName, oldExtendedprivstatus, pUserInfo->ExtendedPrivilege); } UNLOCK_BMC_SHARED_MEM(BMCInst); FlushIPMI((INT8U*)&pBMCInfo->UserInfo[0],(INT8U*)&pBMCInfo->UserInfo[0],pBMCInfo->IPMIConfLoc.UserInfoAddr, sizeof(UserInfo_T)*MAX_USER_CFG_MDS,BMCInst); *pRes = CC_NORMAL; return sizeof (*pRes); } /** * OnGethostlockvalue_dynm * @brief This method helpd to get the adviser configuration * @param AdviserCfg - adviserd conf structure */ int OnGethostlockvalue_dynm(int *hostlock_feature) { void *dl_handle = NULL; int ( *dl_func )( void *); dl_handle = NULL; int retval =0; int value=0; dl_handle = dlopen ( "/usr/local/lib/libadvisercfg.so", RTLD_NOW ); if(NULL == dl_handle) { return -1; } dl_func = dlsym( dl_handle, "OnGethostlockfeature_dynm" ); if(NULL == dl_func) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(dl_handle); return -1; } retval= dl_func ( (void *)&value); if(retval < 0) return retval; *hostlock_feature = value; return retval; } /** * OnGethostlockvalue_dynm * @brief This method helpd to get the adviser configuration * @param AdviserCfg - adviserd conf structure */ int OnSethostlockvalue_dynm(int hostlock_feature) { void *dl_handle = NULL; int ( *dl_func )( void *); dl_handle = NULL; int retval =0; dl_handle = dlopen ( "/usr/local/lib/libadvisercfg.so", RTLD_NOW ); if(NULL == dl_handle) { return -1; } dl_func = dlsym( dl_handle, "OnSethostlockfeature_dynm" ); if(NULL == dl_func) { IPMI_ERROR("Error in getting symbol %s \n", dlerror()); dlclose(dl_handle); return -1; } retval= dl_func ( (void *)hostlock_feature); return retval; } /* *@fn AMIGetHostLockFeatureStatus *@brief This command helps to get host monitor lock Feature status * @param pReq - Request for the command * @param ReqLen - Request length for the command * @param pRes - Respose for the command * @param BMCInst- BMC Instance * @return Returns size of AMIGetHostLockFeatureStatusRes_T */ int AMIGetHostLockFeatureStatus(_NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes, int BMCInst) { AMIGetHostLockFeatureStatusRes_T *pAMIGetHLFeatureStsRes = (AMIGetHostLockFeatureStatusRes_T *)pRes; int status =-1; int hostlockfeatureStatus=0; int retval=0; if(g_corefeatures.host_lock_feature != ENABLED) { *pRes = CC_INV_CMD; return sizeof (INT8U); } if ( ReqLen > 0 ) { *pRes = CC_REQ_INV_LEN; return sizeof (INT8U); } retval = OnGethostlockvalue_dynm(&hostlockfeatureStatus); if(retval <0) { *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } status = hostlockfeatureStatus & (1<<0); pAMIGetHLFeatureStsRes->LockFeatureStatus =status; pAMIGetHLFeatureStsRes->CompletionCode = CC_NORMAL; return sizeof(AMIGetHostLockFeatureStatusRes_T); } /* *@fn AMISetHostLockFeatureStatus *@brief This command helps to set host monitor lock feature * @param pReq - Request for the command * @param ReqLen - Request length for the command * @param pRes - Respose for the command * @param BMCInst- BMC Instance * @return Returns completion code */ int AMISetHostLockFeatureStatus(_NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes,int BMCInst) { _NEAR_ AMISetHostLockFeatureStatusReq_T* pAMISetHLFeatureStsReq = (_NEAR_ AMISetHostLockFeatureStatusReq_T*)pReq; int ret = -1; *pRes = CC_NORMAL; int status=0,hostlockfeatureStatus=0; INT8U *curchannel; RestartService_T Service; if(g_corefeatures.host_lock_feature != ENABLED) { *pRes = CC_INV_CMD; return sizeof (INT8U); } // check incoming Feature status to Enable/Disable if ( (HLENABLED != pAMISetHLFeatureStsReq->LockFeatureStatus) && (HLDISABLED != pAMISetHLFeatureStsReq->LockFeatureStatus) ) { *pRes = CC_INV_FEATURE_CMD; return sizeof (INT8U); } ret = OnGethostlockvalue_dynm(&hostlockfeatureStatus); if(ret <0) { *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } status = hostlockfeatureStatus & (1<<0); // check incoming lockstatus to same as existing if(status == pAMISetHLFeatureStsReq->LockFeatureStatus) { *pRes = CC_SUCCESS; return sizeof (INT8U); } if(pAMISetHLFeatureStsReq->LockFeatureStatus == 1) { hostlockfeatureStatus |= (1<<0); } else if(pAMISetHLFeatureStsReq->LockFeatureStatus == 0) { hostlockfeatureStatus &= ~(1 << 0); } ret = OnSethostlockvalue_dynm(hostlockfeatureStatus); if(ret < 0) { *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } else { //Post BMC Reboot task to Pend task Service.ServiceName = ADVISER_CONF; Service.SleepSeconds = 3; // Sleep for 3 Seconds SetPendStatus(PEND_OP_RESTART_SERVICES, PEND_STATUS_PENDING); OS_THREAD_TLS_GET(g_tls.CurChannel,curchannel); PostPendTask(PEND_OP_RESTART_SERVICES, (INT8U *) &Service, sizeof(RestartService_T),*curchannel & 0xF,BMCInst); } *pRes = CC_NORMAL; return sizeof (*pRes); } /* *@fn AMIGetHostLockStatus *@brief This command helps to get host monitor lock status * @param pReq - Request for the command * @param ReqLen - Request length for the command * @param pRes - Respose for the command * @param BMCInst- BMC Instance * @return Returns size of AMIGetHostLockStatusRes_T */ int AMIGetHostAutoLockStatus(_NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes, int BMCInst) { AMIGetHostAutoLockStatusRes_T *pAMIGetHostLockStatusRes = (AMIGetHostAutoLockStatusRes_T *)pRes; int status =-1; int hostlockfeature=0,hostlockfeatureStatus=0; int ret=-1; if(g_corefeatures.host_auto_lock != ENABLED) { *pRes = CC_INV_CMD; return sizeof (INT8U); } if ( ReqLen > 0 ) { *pRes = CC_REQ_INV_LEN; return sizeof (INT8U); } ret = OnGethostlockvalue_dynm(&hostlockfeatureStatus); if(ret <0) { *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } hostlockfeature = hostlockfeatureStatus & (1<<0); //If Host Lock Feature is Disabled return error code if(HLDISABLED == hostlockfeature) { *pRes = CC_FEATURE_NOT_ENABLED; return sizeof (INT8U); } status = hostlockfeatureStatus & (1<<1); if(status == (1<<1)) { pAMIGetHostLockStatusRes->LockStatus =1; } else pAMIGetHostLockStatusRes->LockStatus =0; pAMIGetHostLockStatusRes->CompletionCode = CC_NORMAL; return sizeof(AMIGetHostAutoLockStatusRes_T); } /*@fn AMISetHostLockStatus *@brief This command helps to set host monitor lock * @param pReq - Request for the command * @param ReqLen - Request length for the command * @param pRes - Respose for the command * @param BMCInst- BMC Instance * @return Returns completion code */ int AMISetHostAutoLockStatus(_NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes,int BMCInst) { _NEAR_ AMISetHostAutoLockStatusReq_T* pAMISetHostLockStatusReq = (_NEAR_ AMISetHostAutoLockStatusReq_T*)pReq; int ret = -1; int hostlockfeature=0,hostlockfeatureStatus=0; int prev_autolock_status = 0; *pRes = CC_NORMAL; RestartService_T Service; INT8U *curchannel; if(g_corefeatures.host_auto_lock != ENABLED) { *pRes = CC_INV_CMD; return sizeof (INT8U); } ret = OnGethostlockvalue_dynm(&hostlockfeatureStatus); if(ret <0) { *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } hostlockfeature = hostlockfeatureStatus & (1<<0); //If Host Lock Feature is Disabled return error code if(HLDISABLED == hostlockfeature) { *pRes = CC_FEATURE_NOT_ENABLED; return sizeof (INT8U); } // check incoming lockstatus to lock/unlock if ( (HOSTLOCK_CMD !=pAMISetHostLockStatusReq->LockStatus) && (HOSTUNLOCK_CMD !=pAMISetHostLockStatusReq->LockStatus) ) { *pRes = CC_INV_LOCK_CMD; return sizeof (INT8U); } prev_autolock_status = hostlockfeatureStatus & (1<<1); // check incoming lockstatus to same as existing if ( prev_autolock_status == pAMISetHostLockStatusReq->LockStatus) { *pRes = CC_SUCCESS; return sizeof (INT8U); } if(pAMISetHostLockStatusReq->LockStatus == 1) { hostlockfeatureStatus |= (1<<1); } else if(pAMISetHostLockStatusReq->LockStatus == 0) { hostlockfeatureStatus &= ~(1 << 1); } else { *pRes = CC_INV_DATA_FIELD; return sizeof (INT8U); } ret = OnSethostlockvalue_dynm(hostlockfeatureStatus); if(ret < 0) { *pRes = CC_UNSPECIFIED_ERR; return sizeof (INT8U); } else { //Post BMC Reboot task to Pend task Service.ServiceName = ADVISER_CONF; Service.SleepSeconds = 3; // Sleep for 3 Seconds SetPendStatus(PEND_OP_RESTART_SERVICES, PEND_STATUS_PENDING); OS_THREAD_TLS_GET(g_tls.CurChannel,curchannel); PostPendTask(PEND_OP_RESTART_SERVICES, (INT8U *) &Service, sizeof(RestartService_T),*curchannel & 0xF,BMCInst); } *pRes = CC_NORMAL; return sizeof (*pRes); } int AMIGetChannelType(_NEAR_ INT8U *pReq, INT32U ReqLen, _NEAR_ INT8U *pRes, int BMCInst) { _NEAR_ AMIGetChannelTypeReq_T *pAMIGetChTypeReq = (_NEAR_ AMIGetChannelTypeReq_T*)pReq; _NEAR_ AMIGetChannelTypeRes_T *pAMIGetChTypeRes = (_NEAR_ AMIGetChannelTypeRes_T*)pRes; BMCInfo_t *pBMCInfo = &g_BMCInfo[BMCInst]; _FAR_ ChannelInfo_T* pChannelInfo; if((pAMIGetChTypeReq->ChannelNumber & 0xF0) || (CURRENT_CHANNEL_NUM == pAMIGetChTypeReq->ChannelNumber)) { pAMIGetChTypeRes->CompletionCode = CC_INV_DATA_FIELD; return sizeof(*pRes); } OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->ChUserMutex,WAIT_INFINITE); pChannelInfo = getChannelInfo(pAMIGetChTypeReq->ChannelNumber, BMCInst); if (NULL == pChannelInfo) { OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); pAMIGetChTypeRes->CompletionCode = CC_INV_DATA_FIELD ; return sizeof (*pRes); } pAMIGetChTypeRes->CompletionCode = CC_NORMAL; pAMIGetChTypeRes->ChannelType = pChannelInfo->ChannelType; pAMIGetChTypeRes->ChannelNumber = pAMIGetChTypeReq->ChannelNumber; OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); return sizeof (AMIGetChannelTypeRes_T); }