/**************************************************************** **************************************************************** ** ** ** (C)Copyright 2005-2006, American Megatrends Inc. ** ** ** ** All Rights Reserved. ** ** ** ** 6145-F, Northbelt Parkway, Norcross, ** ** ** ** Georgia - 30071, USA. Phone-(770)-246-8600. ** ** ** **************************************************************** ****************************************************************/ /***************************************************************** * * AppDevice.c * AppDevice Commands Handler * * Author: Govind Kothandapani * : Rama Bisa * : Basavaraj Astekar * : Bakka Ravinder Reddy * *****************************************************************/ #define ENABLE_DEBUG_MACROS 0 #include "Types.h" #include "Debug.h" #include "IPMI_Main.h" #include "SharedMem.h" #include "Support.h" #include "Message.h" #include "IPMIDefs.h" #include "MsgHndlr.h" #include "IPMI_IPM.h" #include "IPMI_AppDevice.h" #include "AppDevice.h" #include "RMCP.h" #include "MD.h" #include "LANIfc.h" #include "WDT.h" #include "NVRAccess.h" #include "Util.h" //#include "libipmi_struct.h" //#include "nwcfg.h" #include "Ethaddr.h" //#include "IPMIConf.h" #include "IPMBIfc.h" #include "IPMI_KCS.h" //#include "ipmi_userifc.h" //#include "hmac_md5.h" //#include "hmac.h" //#include "MD5_128.h" #include "Badpasswd.h" #include "hal_hw.h" //#include "iniparser.h" #include "Session.h" //#include #include "LANConfig.h" #include /* getaddrinfo(3) et al. */ #include /* sockaddr_in & sockaddr_in6 definition. */ //#include "userprivilege.h" #include //#include "PDKBridgeMsg.h" //#include "featuredef.h" //#include "blowfish.h" #include "bmc_main.h" #include "session.h" #include "bmc_type.h" #define USER_ID_ENABLED 0x01 #define USER_ID_DISABLED 0x02 #define OP_USERID_ONLY_LENGTH 2 #define OP_ENABLE_USER_ID 1 #define OP_DISABLE_USER_ID 0 #define BIT3_BIT0_MASK 0xf #define GET_AUTH_TYPE_MASK 0xc0 #define AUTH_TYPE_V15 0x0 #define AUTH_TYPE_V20 0x40 #define AUTH_CODE_V15_MASK 0x0f #define AUTH_CODE_V15_1 0x1 #define AUTH_CODE_V15_2 0x2 #define AUTH_CODE_V15_3 0x5 #define AUTH_CODE_V20_MASK 0x3f #define MIN_AUTH_CODE_V20 0x04 #define MAX_AUTH_CODE_V20 0xc0 #define NULL_USER 1 #define ZERO_SETSELECTOR 0x00 #define MAX_TYPE_OF_ENCODING 0x02 #define MAX_STRING_LENGTH_COPY 14 #define ASCII_LATIN1 0x00 #define UTF_8 0x01 #define UNICODE 0x02 /* Reserved bit macro definitions */ #define RESERVED_BITS_SENDMS 0x03 //(BIT1 | BIT0) /* Auth code length */ #define HMAC_SHA1_96_LEN 12 //#if APP_DEVICE == 1 #define COUNT_INCREASE 1 #define COUNT_DECREASE -1 #define MAX_BT_PKT_LEN 255 #define RESERVED_USERS_FILE "/etc/reservedusers" /*macro definitions for set user password options*/ #define DISABLE_USER 0 #define ENABLE_USER 1 #define SET_PASSWORD 2 #define TEST_PASSWORD 3 /*** Global variables ***/ _FAR_ INT8U g_TmrRunning; /*** Module variables ***/ static _FAR_ MsgPkt_T m_MsgPkt; /**< Message Packet for posting and retrieving messaged to/from queue */ static INT8U m_Set_ChReserveBit[] ={0xF0,0x0,0x30}; //extern IfcName_T Ifcnametable[MAX_LAN_CHANNELS]; /** * @fn CheckReservedUsers * @brief This function will checks for reserved users. * @param Username - Username. * @retval availability of reserved users. */ static int CheckForReservedUsers(char *Username) { //dictionary *dict = NULL; //char *sectionname = NULL; //int nsec=0 , i=0; //TDBG("filename is %s\n",RESERVED_USERS_FILE); //dict = iniparser_load(RESERVED_USERS_FILE); //if(dict == NULL) //{ // TINFO("Unable to parse dummy users file :%s", RESERVED_USERS_FILE); // return -1; //} //nsec = iniparser_getnsec(dict); //for (i=0;iIpmiConfig.MaxChUsers; // INT8U channelIndex = 0; // // // for (channelIndex = 0; channelIndex < MAX_NUM_CHANNELS; channelIndex++) // { // if (pBMCInfo->ChConfig[channelIndex].ChType == 0xff) continue; // // pChannelInfo = (ChannelInfo_T*)&pBMCInfo->ChConfig[channelIndex].ChannelInfo; // // if (((value > 0) && ((pChannelInfo->NoCurrentUser + value) > maxUserCount)) || // ((value < 0) && ((pChannelInfo->NoCurrentUser + value) < 0))) // { // continue; // } // // pNvrChannelInfo = GetNVRChConfigs(pChannelInfo, bmcInstId); // // pChannelInfo->NoCurrentUser+=value; // pNvrChannelInfo->NoCurrentUser+=value; // FlushChConfigs((INT8U*)pNvrChannelInfo,pNvrChannelInfo->ChannelNumber,bmcInstId); //} } static int IsPrivilegeAvailable(INT8U requestedPrivilege, INT8U channelNumber, int bmcInstId) { // //_FAR_ PMConfig_T* pPMConfig = (_FAR_ PMConfig_T*) GetNVRAddr(NVRH_PMCONFIG, bmcInstId); // BMCInfo_t *pBMCInfo = &g_BMCInfo;//[bmcInstId]; // INT8U EthIndex = GetEthIndex(channelNumber & 0x0F, bmcInstId); // INT8U privilege = 0x00; // // if(0xff == EthIndex) return -1; // // //Get requested privilege status (enabled or disabled) from PMConfig by channel // switch (requestedPrivilege) // { // case PRIV_CALLBACK: // privilege = pBMCInfo->LANCfs[EthIndex].AuthTypeEnables.AuthTypeCallBack; // break; // // case PRIV_USER: // privilege = pBMCInfo->LANCfs[EthIndex].AuthTypeEnables.AuthTypeUser; // break; // // case PRIV_OPERATOR: // privilege = pBMCInfo->LANCfs[EthIndex].AuthTypeEnables.AuthTypeOperator; // break; // // case PRIV_ADMIN: // privilege = pBMCInfo->LANCfs[EthIndex].AuthTypeEnables.AuthTypeAdmin; // break; // // case PRIV_OEM: // privilege = pBMCInfo->LANCfs[EthIndex].AuthTypeEnables.AuthTypeOem; // break; // // default: // return -1; // } // // //All bits are 0 that means privilege level is disabled // return ((privilege != 0x00) ? 0 : -1); } /*------------------------------------- * ValidateIPMBChksum1 *-------------------------------------*/ /* Function to validate IPMB Checksum1 for SendMessage Cmd */ static int ValidateIPMBChksum1(_NEAR_ INT8U* Data) { int i=0; INT8U chksum=0; for (i = 0; i < 3; i++) { chksum += *(Data + i); } if (chksum != 0) { return FALSE; } return TRUE; } /*------------------------------------- * ResetWDT *-------------------------------------*/ int ResetWDT (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // INT8U u8ExpirationFlag; // BMCInfo_t *pBMCInfo = &g_BMCInfo;//[BMCInst]; // // // if (pBMCInfo->Msghndlr.TmrSet == FALSE) // { // *pRes = CC_ATTEMPT_TO_RESET_UNIN_WATCHDOG; // return sizeof (*pRes); // } // // // save the WDT expiration flag for later use // u8ExpirationFlag = g_WDTTmrMgr.WDTTmr.ExpirationFlag; // // // /* Reset of Watchdog should not happen once // once pretimeout interrupt interval is reached*/ // if(pBMCInfo->WDTPreTmtStat == TRUE) // { // *pRes = CC_PARAM_NOT_SUP_IN_CUR_STATE; // return sizeof (*pRes); // } // // g_WDTTmrMgr.TmrPresent = TRUE; // g_WDTTmrMgr.TmrInterval = pBMCInfo->WDTConfig.InitCountDown; // g_WDTTmrMgr.PreTimeOutInterval = SEC_TO_MS * pBMCInfo->WDTConfig.PreTimeOutInterval; // // /* if the pre-timeout interrupt is not configured, adjust the pre-timeout interrupt // timeout value beyound the regular WDT timeout value so that it won't get triggered // before the WDT timeout. */ // if ((pBMCInfo->WDTConfig.TmrActions & 0x70) == 0) // { // g_WDTTmrMgr.PreTimeOutInterval = g_WDTTmrMgr.TmrInterval+ 1; // } // // _fmemcpy (&g_WDTTmrMgr.WDTTmr, &pBMCInfo->WDTConfig, sizeof (WDTConfig_T)); // // // restore the WDT expiration flag, don't use the one from the flash // g_WDTTmrMgr.WDTTmr.ExpirationFlag = u8ExpirationFlag; // // // clear WDT sensor event history // if( g_corefeatures.internal_sensor == ENABLED ) // RestartWD2Sensor(BMCInst); // // if(g_corefeatures.wdt_flush_support == ENABLED ) // { // FlushIPMI((INT8U*)&pBMCInfo->WDTConfig,(INT8U*)&pBMCInfo->WDTConfig,pBMCInfo->IPMIConfLoc.WDTDATAddr, // sizeof(WDTConfig_T),BMCInst); // } // // if(BMC_GET_SHARED_MEM(BMCInst)->IsWDTPresent == FALSE) // { // LOCK_BMC_SHARED_MEM(BMCInst); // BMC_GET_SHARED_MEM(BMCInst)->IsWDTRunning=TRUE; // BMC_GET_SHARED_MEM(BMCInst)->IsWDTPresent=TRUE; // UNLOCK_BMC_SHARED_MEM(BMCInst); // sem_post(&g_BMCInfo;//[BMCInst].WDTSem); // } // else // { // LOCK_BMC_SHARED_MEM(BMCInst); // BMC_GET_SHARED_MEM(BMCInst)->IsWDTRunning=TRUE; // BMC_GET_SHARED_MEM(BMCInst)->IsWDTPresent=TRUE; // UNLOCK_BMC_SHARED_MEM(BMCInst); // //Set SetWDTUpdated flag to reload initial countdown value. // g_BMCInfo[BMCInst].SetWDTUpdated = TRUE; // } // // // *pRes = CC_NORMAL; // // return sizeof (*pRes); } /*--------------------------------------- * SetWDT *---------------------------------------*/ int SetWDT (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ SetWDTReq_T* pSetWDTReq = (_NEAR_ SetWDTReq_T*)pReq; //#if GET_MSG_FLAGS != UNIMPLEMENTED // GetMsgFlagsRes_T GetMsgFlagsRes; //#endif // _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo;//[BMCInst]; // // // //Check for Reserved bits // if((pSetWDTReq->TmrUse & (BIT5 | BIT4 | BIT3)) || !(pSetWDTReq->TmrUse & (BIT2 | BIT1 | BIT0)) || ((pSetWDTReq->TmrUse & (BIT1 | BIT2)) == (BIT1 | BIT2)) || // (pSetWDTReq->TmrActions & (BIT7 |BIT6 | BIT3 | BIT2)) || (pSetWDTReq->ExpirationFlag & (BIT7 | BIT6 | BIT0))) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(*pRes); // } // //#if NO_WDT_PRETIMEOUT_INTERRUPT == 1 // // do not support pre-timeout interrupt // if (pSetWDTReq->TmrActions & 0x70) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(*pRes); // } //#endif // // pSetWDTReq->InitCountDown = htoipmi_u16(pSetWDTReq->InitCountDown); // // // error out if the pre-timeout interrupt is greater than the initial countdown value // if (pSetWDTReq->InitCountDown < 10 * pSetWDTReq->PreTimeOutInterval) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(*pRes); // } // // // only clear the memory version of the bit(s) when the input bit is set #31175 // g_WDTTmrMgr.WDTTmr.ExpirationFlag &= ~pSetWDTReq->ExpirationFlag; // pSetWDTReq->ExpirationFlag = g_WDTTmrMgr.WDTTmr.ExpirationFlag; // // // /* Copy the Timer configuration in NVRAM */ // LOCK_BMC_SHARED_MEM(BMCInst); // _fmemset ((_FAR_ INT8U*)&pBMCInfo->WDTConfig, 0, sizeof (WDTConfig_T)); // _fmemcpy ((_FAR_ INT8U*)&pBMCInfo->WDTConfig, (_FAR_ INT8U*)pSetWDTReq, sizeof (SetWDTReq_T)); // UNLOCK_BMC_SHARED_MEM(BMCInst); // // if (TRUE ==BMC_GET_SHARED_MEM(BMCInst)->IsWDTRunning) // { // /* To check wheather Dont stop bit is set or not */ // if (pSetWDTReq->TmrUse & 0x40) // { // /* Set the count down value to given value */ // g_WDTTmrMgr.TmrPresent = TRUE; // LOCK_BMC_SHARED_MEM(BMCInst); // BMC_GET_SHARED_MEM(BMCInst)->IsWDTPresent =TRUE; // UNLOCK_BMC_SHARED_MEM(BMCInst); // g_WDTTmrMgr.TmrInterval= pSetWDTReq->InitCountDown; // g_WDTTmrMgr.PreTimeOutInterval = (SEC_TO_MS * pSetWDTReq->PreTimeOutInterval); // // /* If PreTimeOutInt is set, clear it */ // if (0 != (pSetWDTReq->TmrActions & 0x70)) // { // pSetWDTReq->TmrActions &= ~0x70; // } // else // { // // if the pre-timeout interrupt is not configured, adjust the pre-timeout interrupt // // timeout value beyound the regular WDT timeout value so that it won't get triggered // // before the WDT timeout. // g_WDTTmrMgr.PreTimeOutInterval = pSetWDTReq->InitCountDown + 1; // } // _fmemcpy (&g_WDTTmrMgr.WDTTmr, pSetWDTReq, sizeof (WDTConfig_T )); // // } // else // { // /* Stop the timer */ // g_WDTTmrMgr.TmrPresent = FALSE; // LOCK_BMC_SHARED_MEM(BMCInst); // BMC_GET_SHARED_MEM(BMCInst)->IsWDTRunning=FALSE; // BMC_GET_SHARED_MEM(BMCInst)->IsWDTPresent =FALSE; // UNLOCK_BMC_SHARED_MEM(BMCInst); // g_WDTTmrMgr.TmrInterval= pSetWDTReq->InitCountDown; // g_WDTTmrMgr.PreTimeOutInterval = SEC_TO_MS * pSetWDTReq->PreTimeOutInterval; // // clear WDT sensor event history // if( g_corefeatures.internal_sensor == ENABLED) // RestartWD2Sensor(BMCInst); // } // // /* Clear the pre-timeout interupt flag */ // LOCK_BMC_SHARED_MEM(BMCInst); // pBMCInfo->WDTConfig.PreTimeoutActionTaken = 0x00; // BMC_GET_SHARED_MEM (BMCInst)->MsgFlags &= ~0x08; /* Clear the flag */ //#if GET_MSG_FLAGS != UNIMPLEMENTED // // Clear SMS_ATN bit if and only if the Get Message Flag return 0 in byte 2. // GetMsgFlags (NULL, 0, (INT8U *)&GetMsgFlagsRes,BMCInst); // TDBG("GetMsgFlagsRes.CompletionCode : %X, GetMsgFlagsRes.MsgFlags : %X\n", // GetMsgFlagsRes.CompletionCode, GetMsgFlagsRes.MsgFlags); // if (GetMsgFlagsRes.CompletionCode == CC_NORMAL && GetMsgFlagsRes.MsgFlags == 0) //#else // if((BMC_GET_SHARED_MEM(BMCInst)->MsgFlags & BIT3_BIT0_MASK) == 0) //#endif // { // /* Clear the SMS_ATN bit */ // if (pBMCInfo->IpmiConfig.KCS1IfcSupport == 1) // { // CLEAR_SMS_ATN (0, BMCInst); // } // if (pBMCInfo->IpmiConfig.KCS2IfcSupport == 1) // { // CLEAR_SMS_ATN (1, BMCInst); // } // if (pBMCInfo->IpmiConfig.KCS3IfcSuppport == 1) // { // CLEAR_SMS_ATN (2, BMCInst); // } // } // UNLOCK_BMC_SHARED_MEM(BMCInst); // // } // else // { // g_WDTTmrMgr.TmrInterval = pSetWDTReq->InitCountDown; // g_WDTTmrMgr.TmrPresent = FALSE; // LOCK_BMC_SHARED_MEM(BMCInst); // BMC_GET_SHARED_MEM(BMCInst)->IsWDTPresent =FALSE; // UNLOCK_BMC_SHARED_MEM(BMCInst); // // clear WDT sensor event history // if( g_corefeatures.internal_sensor == ENABLED) // RestartWD2Sensor(BMCInst); // } // // // Modify ARP status to resume the thread // // after receiving set Watchdog Timer command // //BMC_GET_SHARED_MEM(BMCInst)->GratArpStatus = RESUME_ARPS; // // int i = 0; // // for (i = 0; i < MAX_LAN_CHANNELS; i++) // { // if((pBMCInfo->LanIfcConfig[i].Enabled == TRUE) // && (pBMCInfo->LanIfcConfig[i].Up_Status == LAN_IFC_UP)) // { // BMC_GET_SHARED_MEM(BMCInst)->ArpSuspendStatus[i] = RESUME_ARPS; // UpdateArpStatus(pBMCInfo->LanIfcConfig[i].Ethindex, BMC_GET_SHARED_MEM(BMCInst)->IsWDTRunning, BMCInst); // } // } // if(g_corefeatures.wdt_flush_support == ENABLED ) // { // FlushIPMI((INT8U*)&pBMCInfo->WDTConfig,(INT8U*)&pBMCInfo->WDTConfig,pBMCInfo->IPMIConfLoc.WDTDATAddr, // sizeof(WDTConfig_T),BMCInst); // } // // set the "Don't Log" bit // g_WDTTmrMgr.WDTTmr.TmrUse &= 0x7F; // g_WDTTmrMgr.WDTTmr.TmrUse |= (pSetWDTReq->TmrUse & 0x80); // // g_BMCInfo[BMCInst].SetWDTUpdated = TRUE; // g_BMCInfo[BMCInst].Msghndlr.TmrSet = TRUE; // pBMCInfo->WDTPreTmtStat = FALSE; // *pRes = CC_NORMAL; // // return sizeof (*pRes); } /*--------------------------------------- * GetWDT *---------------------------------------*/ int GetWDT (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ GetWDTRes_T* pGetWDTRes = (_NEAR_ GetWDTRes_T*)pRes; // BMCInfo_t *pBMCInfo = &g_BMCInfo;//[BMCInst]; // // /* Copy the current settings from the NVRAM */ // LOCK_BMC_SHARED_MEM(BMCInst); // _fmemcpy ((_FAR_ INT8U*)&pGetWDTRes->CurrentSettings, // (_FAR_ INT8U*)&pBMCInfo->WDTConfig, sizeof (WDTConfig_T)); // UNLOCK_BMC_SHARED_MEM(BMCInst); // // // get the WDT expiration from the global veriable in memory, not from the flash // pGetWDTRes->CurrentSettings.ExpirationFlag = g_WDTTmrMgr.WDTTmr.ExpirationFlag; // // // get the current "Don't Log" bit // pGetWDTRes->CurrentSettings.TmrUse &= 0x7F; // pGetWDTRes->CurrentSettings.TmrUse |= (g_WDTTmrMgr.WDTTmr.TmrUse & 0x80); // if (TRUE == BMC_GET_SHARED_MEM(BMCInst)->IsWDTPresent) // { // // set the WDT running bit #30235/30467 // pGetWDTRes->CurrentSettings.TmrUse |= 0x40; // /* Present count down in 1/100 of second */ // } // else // { // // clear the WDT running bit #30235/30467 for Timer Use (ie) WatchDog Timer status // pGetWDTRes->CurrentSettings.TmrUse &= ~0x40; // pGetWDTRes->CurrentSettings.ExpirationFlag = (pGetWDTRes->CurrentSettings.ExpirationFlag) & 0x3E; // } // // pGetWDTRes->PresentCountDown = g_WDTTmrMgr.TmrInterval; // pGetWDTRes->CurrentSettings.InitCountDown = htoipmi_u16(pGetWDTRes->CurrentSettings.InitCountDown); // pGetWDTRes->CompletionCode = CC_NORMAL; // // return sizeof (GetWDTRes_T); } /*--------------------------------------- * SetBMCGlobalEnables *---------------------------------------*/ int SetBMCGlobalEnables (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // INT8U GblEnblByte = *pReq; // BMCInfo_t *pBMCInfo = &g_BMCInfo;//[BMCInst]; // MsgPkt_T MsgPkt; // // _fmemset (&MsgPkt, 0, sizeof (MsgPkt_T)); // // /* Check For the reserved bit 4 */ // if ( GblEnblByte & BIT4) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->BMCMsgMutex,WAIT_INFINITE); // if (((BMC_GET_SHARED_MEM (BMCInst)->GlobalEnables ^ GblEnblByte)) & 0x20) // { // /* OEM 0 puts us in ICTS compatibility mode for IPMIv2, // * Send a message to lan process so it can change behavior // */ // MsgPkt.Channel = GetLANChannel(0, BMCInst); // MsgPkt.Param = LAN_ICTS_MODE; // MsgPkt.Privilege = PRIV_LOCAL; // if (GblEnblByte & 0x20) // MsgPkt.Cmd = 1; // else // MsgPkt.Cmd = 0; // PostMsg(&MsgPkt,LAN_IFC_Q,BMCInst); // } // // BMC_GET_SHARED_MEM (BMCInst)->GlobalEnables = GblEnblByte; // *pRes = CC_NORMAL; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); return sizeof (*pRes); } /*--------------------------------------- * GetBMCGlobalEnables *---------------------------------------*/ int GetBMCGlobalEnables (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ GetBMCGblEnblRes_T* pGetBMCGblEnblRes = (_NEAR_ GetBMCGblEnblRes_T*)pRes; // BMCInfo_t *pBMCInfo = &g_BMCInfo;//[BMCInst]; // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->BMCMsgMutex,WAIT_INFINITE); // pGetBMCGblEnblRes->CompletionCode = CC_NORMAL; // pGetBMCGblEnblRes->BMCGblEnblByte = BMC_GET_SHARED_MEM (BMCInst)->GlobalEnables; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // return sizeof (GetBMCGblEnblRes_T); } /*--------------------------------------- * ClrMsgFlags *---------------------------------------*/ int ClrMsgFlags (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ ClearMsgsFlagReq_T* pClearMsgsFlagReq = (_NEAR_ ClearMsgsFlagReq_T*)pReq; // INT8U *kcsifcnum; //#if GET_MSG_FLAGS != UNIMPLEMENTED // GetMsgFlagsRes_T GetMsgFlagsRes; //#endif // _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo;//[BMCInst]; // // //Check for Reserved bits // if(pClearMsgsFlagReq->Flag & (BIT4 | BIT2)) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(*pRes); // } // // OS_THREAD_TLS_GET(g_tls.CurKCSIfcNum,kcsifcnum); // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->BMCMsgMutex,WAIT_INFINITE); // /* Flush Receive Message Queue */ // if (0 != (pClearMsgsFlagReq->Flag & 0x01)) // { // while (0 == GetMsg (&m_MsgPkt, &g_RcvMsgQ[*kcsifcnum][0], WAIT_NONE,BMCInst)) // { // BMC_GET_SHARED_MEM (BMCInst)->NumRcvMsg[*kcsifcnum]--; // } // // BMC_GET_SHARED_MEM (BMCInst)->MsgFlags &= ~0x01; /* Clear the flag */ // } // // /* Flush Event Message Buffer */ // if (0 != (pClearMsgsFlagReq->Flag & 0x02)) // { // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->EventMutex,WAIT_INFINITE); // while (0 == GetMsg (&m_MsgPkt, EVT_MSG_Q, WAIT_NONE,BMCInst)) // { // BMC_GET_SHARED_MEM (BMCInst)->NumEvtMsg--; // } // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->EventMutex); // BMC_GET_SHARED_MEM (BMCInst)->MsgFlags &= ~0x02; /* Clear the flag */ // } // // /* Clear WatchdogTimer Interrupt*/ // if (0 != (pClearMsgsFlagReq->Flag & 0x08)) // { // /* Clear the pre-timeout interupt flag */ // pBMCInfo->WDTConfig.PreTimeoutActionTaken = 0x00; // BMC_GET_SHARED_MEM (BMCInst)->MsgFlags &= ~0x08; /* Clear the flag */ // if(g_corefeatures.wdt_flush_support == ENABLED ) // { // FlushIPMI((INT8U*)&pBMCInfo->WDTConfig,(INT8U*)&pBMCInfo->WDTConfig,pBMCInfo->IPMIConfLoc.WDTDATAddr, // sizeof(WDTConfig_T),BMCInst); // } // // } // //#if GET_MSG_FLAGS != UNIMPLEMENTED // // Clear SMS_ATN bit if and only if the Get Message Flag return 0 in byte 2. // GetMsgFlags (NULL, 0, (INT8U *)&GetMsgFlagsRes,BMCInst); // TDBG("GetMsgFlagsRes.CompletionCode : %X, GetMsgFlagsRes.MsgFlags : %X\n", // GetMsgFlagsRes.CompletionCode, GetMsgFlagsRes.MsgFlags); // if (GetMsgFlagsRes.CompletionCode == CC_NORMAL && GetMsgFlagsRes.MsgFlags == 0) //#else // if((BMC_GET_SHARED_MEM(BMCInst)->MsgFlags & BIT3_BIT0_MASK) == 0) //#endif // { // /* Clear the SMS_ATN bit */ // if (pBMCInfo->IpmiConfig.KCS1IfcSupport == 1) // { // CLEAR_SMS_ATN (0, BMCInst); // } // if (pBMCInfo->IpmiConfig.KCS2IfcSupport == 1) // { // CLEAR_SMS_ATN (1, BMCInst); // } // if (pBMCInfo->IpmiConfig.KCS3IfcSuppport == 1) // { // CLEAR_SMS_ATN (2, BMCInst); // } // } // // *pRes = CC_NORMAL; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // // return sizeof (*pRes); } /*--------------------------------------- GetMsgFlags ---------------------------------------*/ int GetMsgFlags (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ GetMsgFlagsRes_T* pGetMsgFlagsRes = (_NEAR_ GetMsgFlagsRes_T*)pRes; // BMCInfo_t *pBMCInfo = &g_BMCInfo;//[BMCInst]; // INT8U *kcsifcnum; // // OS_THREAD_TLS_GET(g_tls.CurKCSIfcNum,kcsifcnum); // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->BMCMsgMutex,WAIT_INFINITE); // /* get the message flags */ // pGetMsgFlagsRes->MsgFlags = BMC_GET_SHARED_MEM (BMCInst)->MsgFlags; // // if (BMC_GET_SHARED_MEM (BMCInst)->NumEvtMsg >= EVT_MSG_BUF_SIZE) // { // /* If Event MessageBuffer is Full set the BIT */ // pGetMsgFlagsRes->MsgFlags |= 0x02; // } // else // { // /* else reset the Flag */ // pGetMsgFlagsRes->MsgFlags &= ~0x02; // } // // if(kcsifcnum != NULL && 0 != BMC_GET_SHARED_MEM (BMCInst)->NumRcvMsg[*kcsifcnum]) // { // /* if any Message in ReceiveMsgQ set the Flag */ // pGetMsgFlagsRes->MsgFlags |= 0x01; // } // else // { // /* else reset the Flag */ // pGetMsgFlagsRes->MsgFlags &= ~0x01; // } // // /* get the Pre-Timeout Bits Value & Set it to Response Data */ // //PRETIMEOUT BIT is 3rd bit so changed accordingly // pGetMsgFlagsRes->MsgFlags |= (pBMCInfo->WDTConfig.PreTimeoutActionTaken & 0x08); // // /* Update the Message flags in shared Mem */ // BMC_GET_SHARED_MEM (BMCInst)->MsgFlags |= pGetMsgFlagsRes->MsgFlags; // pGetMsgFlagsRes->CompletionCode = CC_NORMAL; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // // return sizeof (GetMsgFlagsRes_T); } /*--------------------------------------- * EnblMsgChannelRcv *---------------------------------------*/ int EnblMsgChannelRcv (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ EnblMsgChRcvReq_T* pEnblMsgChRcvReq = (_NEAR_ EnblMsgChRcvReq_T*)pReq; // _NEAR_ EnblMsgChRcvRes_T* pEnblMsgChRcvRes = (_NEAR_ EnblMsgChRcvRes_T*)pRes; // _FAR_ ChannelInfo_T* pChannelInfo; // BMCInfo_t *pBMCInfo = &g_BMCInfo;//[BMCInst]; // // //Check for Reserved bits // if(pEnblMsgChRcvReq->ChannelNum & (BIT7 | BIT6 | BIT5 | BIT4)) // { // pEnblMsgChRcvRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(*pRes); // } // // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->ChUserMutex,WAIT_INFINITE); // pChannelInfo = getChannelInfo (pEnblMsgChRcvReq->ChannelNum & 0x0F, BMCInst); // // TDBG ("ENBL_MSG_CH_RCV: processing..\n"); // // if (NULL == pChannelInfo) // { // pEnblMsgChRcvRes->CompletionCode = CC_INV_DATA_FIELD; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // return sizeof (*pRes); // } // // switch (pEnblMsgChRcvReq->ChannelState) // { // case 0: // /* disable Receive Message Queue for this Channel */ // pChannelInfo->ReceiveMsgQ = 0x0; // break; // // case 1: // /*enable Recevive Message Queue for this Channel */ // pChannelInfo->ReceiveMsgQ = 0x1; // break; // // case 2: // /*get Channel State */ // pEnblMsgChRcvRes->ChannelState = pChannelInfo->ReceiveMsgQ; // break; // // default: // pEnblMsgChRcvRes->CompletionCode = CC_INV_DATA_FIELD; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // return sizeof (*pRes); // } // // pEnblMsgChRcvRes->CompletionCode = CC_NORMAL; // // /*get Channel Number */ // pEnblMsgChRcvRes->ChannelNum = pEnblMsgChRcvReq->ChannelNum & 0x0F; // // pEnblMsgChRcvRes->ChannelState = pChannelInfo->ReceiveMsgQ; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // // return sizeof (EnblMsgChRcvRes_T); } /*--------------------------------------- * GetMessage *---------------------------------------*/ int GetMessage (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ GetMsgRes_T* pGetMsgRes = (_NEAR_ GetMsgRes_T*)pRes; // _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo;//[BMCInst]; // INT8U Index = 0,*kcsifcnum; //#if GET_MSG_FLAGS != UNIMPLEMENTED // GetMsgFlagsRes_T GetMsgFlagsRes; //#endif // // OS_THREAD_TLS_GET(g_tls.CurKCSIfcNum,kcsifcnum); // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->BMCMsgMutex,WAIT_INFINITE); // if (0 != GetMsg (&m_MsgPkt, &g_RcvMsgQ[*kcsifcnum][0], WAIT_NONE,BMCInst)) // { // /* if Queue is Empty */ // pGetMsgRes->CompletionCode = CC_GET_MSG_QUEUE_EMPTY; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // return sizeof (*pRes); // } // // BMC_GET_SHARED_MEM (BMCInst)->NumRcvMsg[*kcsifcnum]--; // //#if GET_MSG_FLAGS != UNIMPLEMENTED // // Clear SMS_ATN bit if and only if the Get Message Flag return 0 in byte 2. // GetMsgFlags (NULL, 0, (INT8U *)&GetMsgFlagsRes,BMCInst); // TDBG("GetMsgFlagsRes.CompletionCode : %X, GetMsgFlagsRes.MsgFlags : %X\n", // GetMsgFlagsRes.CompletionCode, GetMsgFlagsRes.MsgFlags); // if (GetMsgFlagsRes.CompletionCode == CC_NORMAL && GetMsgFlagsRes.MsgFlags == 0) //#else // if (0 == BMC_GET_SHARED_MEM (BMCInst)->NumRcvMsg[*kcsifcnum]) //#endif // { // /* Clear the SMS_ATN bit */ // CLEAR_SMS_ATN (*kcsifcnum,BMCInst); // } // // /* Completion Code */ // pGetMsgRes->CompletionCode = CC_NORMAL; // /* Channel number and privilege level */ // pGetMsgRes->ChannelNum = m_MsgPkt.Channel; // // Index = sizeof (GetMsgRes_T); // // /* First byte should be session handle */ // if(pBMCInfo->IpmiConfig.SecondaryIPMBSupport == 0x01) // { // if ((PRIMARY_IPMB_CHANNEL != m_MsgPkt.Channel) && (pBMCInfo->SecondaryIPMBCh != m_MsgPkt.Channel)) // { // pGetMsgRes->ChannelNum |= m_MsgPkt.Privilege << 0x04; // pRes [Index++] = m_MsgPkt.Param; // } // } // else // { // if(PRIMARY_IPMB_CHANNEL != m_MsgPkt.Channel) // { // pGetMsgRes->ChannelNum |= m_MsgPkt.Privilege << 0x04; // pRes [Index++] = m_MsgPkt.Param; // } // } // // /* copy the Message data */ // _fmemcpy ((_FAR_ INT8U*)&pRes[Index], &m_MsgPkt.Data[1], m_MsgPkt.Size-1); // // IPMI_DBG_PRINT ("GetMsg: Sending the following data through requested channel\n"); // IPMI_DBG_PRINT_BUF (pRes, m_MsgPkt.Size + Index); // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // // return ((m_MsgPkt.Size-1)+ Index); /*+ 2 for completion code & channel No. */ } /*--------------------------------------- * SendMessage *---------------------------------------*/ int SendMessage (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ SendMsgReq_T* pSendMsgReq = (_NEAR_ SendMsgReq_T*)pReq; // _NEAR_ SendMsgRes_T* pSendMsgRes = (_NEAR_ SendMsgRes_T*)pRes; // _NEAR_ IPMIMsgHdr_T* pIPMIMsgHdr; // char QueueName[MAX_STR_LENGTH]; // _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo;//[BMCInst]; // INT8U Tracking; // INT8U Channel=0,resaddr=0; // INT8U ResLen = 1; // INT8U RetVal = 0; // INT8U Offset = 1; // INT8U SeqNum = pBMCInfo->SendMsgSeqNum; // INT8U PBTbl = PRIMARY_PB_TBL; // INT8U SrcSessionHndl = 0; // _FAR_ ChannelInfo_T* pChannelInfo; // int tmpBMCInst= 0; // MsgPkt_T ResPkt; // _FAR_ SessionInfo_T* pSessionInfo = NULL; // INT32U *CurSesID; // INT8U *curprivlevel,*curchannel,*kcsifcnum; // // if (ReqLen < 1) // { // *pRes = CC_REQ_INV_LEN; // return sizeof (*pRes); // } // // if(pSendMsgReq->ChNoTrackReq == 0xC0) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // /* Get the channel number */ // Channel = pSendMsgReq->ChNoTrackReq & 0x0F; // // /* Get Tracking field */ // Tracking = pSendMsgReq->ChNoTrackReq >> 6; // // if (Tracking == RESERVED_BITS_SENDMS) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // OS_THREAD_TLS_GET(g_tls.CurSessionID,CurSesID); // OS_THREAD_TLS_GET(g_tls.CurChannel,curchannel); // OS_THREAD_TLS_GET(g_tls.CurKCSIfcNum,kcsifcnum); // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->BMCMsgMutex,WAIT_INFINITE); // if(g_corefeatures.mbmc_single_nic == ENABLED // && g_corefeatures.ifc_specific_msg_handling != ENABLED) // { // ResLen = 0; // g_MBMCInfo.sbmcinst = BMCInst; // memset((char *)&ResPkt,0,sizeof(MsgPkt_T)); // pIPMIMsgHdr = (IPMIMsgHdr_T*)(&pBMCInfo->LANConfig.MsgReq.Data[sizeof (IPMIMsgHdr_T) + 1]); // m_MsgPkt.Param = PARAM_IFC; // m_MsgPkt.Channel = *curchannel; // m_MsgPkt.NetFnLUN = pIPMIMsgHdr->NetFnLUN; // m_MsgPkt.Cmd = pIPMIMsgHdr->Cmd; // m_MsgPkt.Privilege = PRIV_ADMIN; // m_MsgPkt.Size = pBMCInfo->LANConfig.MsgReq.Size - sizeof (IPMIMsgHdr_T) - 2; // _fmemcpy (m_MsgPkt.Data, pIPMIMsgHdr, m_MsgPkt.Size); // // if(g_PDKHandle[PDK_MBMCSINGLENICSENDMSG] != NULL) // { // tmpBMCInst = ( (int (*)(INT8U,int) ) g_PDKHandle[PDK_MBMCSINGLENICSENDMSG]) ( m_MsgPkt.Data[0],BMCInst); // } // // if(tmpBMCInst == 0) // { // resaddr = (m_MsgPkt.Data[0] - pBMCInfo->IpmiConfig.BMCSlaveAddr) >> 1; // if(0 <= resaddr && resaddr < BMCInstCount && (m_MsgPkt.Data[0] - pBMCInfo->IpmiConfig.BMCSlaveAddr)%2 == 0) // { // tmpBMCInst = resaddr + 1; // } // else // { // *pRes = CC_INV_DATA_FIELD; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // return sizeof(*pRes); // } // } // // _fmemcpy(ResPkt.Data,pBMCInfo->LANConfig.MsgReq.Data,sizeof(IPMIMsgHdr_T)); // ResPkt.Param = BRIDGING_REQUEST; // ResPkt.Cmd = pIPMIMsgHdr->Cmd; // ((IPMIMsgHdr_T *)ResPkt.Data)->NetFnLUN = ((pBMCInfo->LANConfig.MsgReq.NetFnLUN >> 2) +1) << 2; // ResPkt.Data [sizeof(IPMIMsgHdr_T)] = CC_NORMAL; // ResPkt.Size = sizeof (IPMIMsgHdr_T) + 1 + 1; // IPMI Header + Completion Code + Second Checksum // /* Calculate the Second CheckSum */ // ResPkt.Data[ResPkt.Size - 1] = CalculateCheckSum2 (ResPkt.Data, ResPkt.Size-1); // if (0 != PostMsg (&ResPkt,LAN_RES_Q,BMCInst)) // { // TDBG ("SendMsg: Failed to post message to interface queue\n"); // } // // pSessionInfo = getSessionInfo (SESSION_ID_INFO,CurSesID,BMCInst); // if (NULL != pSessionInfo) // { // g_MBMCInfo.SrcSessionHndl = pSessionInfo->SessionHandle; // } // else // { // *pRes = CC_UNSPECIFIED_ERR; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // return sizeof(*pRes); // } // // memset(QueueName,0,sizeof(QueueName)); // sprintf(QueueName,"%s%d",LAN_IFC_Q,BMCInst); // strcpy ((char *)m_MsgPkt.SrcQ,QueueName); // // /* Post the message to Message Handler */ // if (0 != PostMsg (&m_MsgPkt,MSG_HNDLR_Q,tmpBMCInst)) // { // TDBG ("SendMsg: Failed to post message to interface queue\n"); // } // } // else // { // m_MsgPkt.Param = BRIDGING_REQUEST; // m_MsgPkt.Channel = Channel; // m_MsgPkt.Size = ReqLen - 1; /* -1 to skip channel num */ // // /* Copy the message data */ // _fmemcpy (m_MsgPkt.Data, &pReq[1], m_MsgPkt.Size); // /* Copy the IPMI Message header */ // pIPMIMsgHdr = (_NEAR_ IPMIMsgHdr_T*)&m_MsgPkt.Data[Offset - 1]; // if(ValidateIPMBChksum1((_NEAR_ INT8U*)pIPMIMsgHdr) == FALSE) // { // *pRes = CC_INV_DATA_FIELD; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // return sizeof (*pRes); // } // // if(m_MsgPkt.Data[ReqLen - 2] != CalculateCheckSum2 ((_FAR_ INT8U*)pIPMIMsgHdr, ReqLen - Offset - 1)) // { // *pRes = CC_INV_DATA_FIELD; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // return sizeof (*pRes); // } // //#if 0 // printf("SendMsg: ReqLen = %d, size = %ld\n",ReqLen,m_MsgPkt.Size); // // for(i = 0; i < m_MsgPkt.Size;i++) // printf("MsgPkt_Data %02X\n",m_MsgPkt.Data[i]); // printf("\n"); //#endif // // if(pBMCInfo->IpmiConfig.LANIfcSupport == 1) // { // /* To Check the Wheather LAN Channel */ // if (IsLANChannel(*curchannel & 0xF, BMCInst)) // { // _FAR_ SessionInfo_T* pSessionInfo = getSessionInfo (SESSION_ID_INFO,CurSesID,BMCInst); // // if (NULL != pSessionInfo) // { // SrcSessionHndl = pSessionInfo->SessionHandle; // } // // TDBG ("SendMsg: To LAN Interface for reference\n"); // // Offset++; : causes bridging issues // strcpy ((char *)m_MsgPkt.SrcQ, LAN_IFC_Q); // } // } // // if(pBMCInfo->IpmiConfig.SerialIfcSupport == 1) // { // /* To Check the Wheather Serial Channel */ // if (pBMCInfo->SERIALch != CH_NOT_USED && (*curchannel & 0xF) == pBMCInfo->SERIALch && pBMCInfo->IpmiConfig.SerialIfcSupport == 1) // { // _FAR_ SessionInfo_T* pSessionInfo = getSessionInfo (SESSION_ID_INFO,CurSesID,BMCInst); // // if (NULL != pSessionInfo) // { // SrcSessionHndl = pSessionInfo->SessionHandle; // } // // TDBG ("SendMsg: To Serial Interface for reference\n"); // // Offset++; : causes bridging issues // strcpy ((char *)m_MsgPkt.SrcQ, SERIAL_IFC_Q); // } // } // // if((Channel == PRIMARY_IPMB_CHANNEL) && pBMCInfo->IpmiConfig.PrimaryIPMBSupport == 1) // { // TDBG ("SendMsg: To Primary IPMB Interface\n"); // strcpy ((char *)m_MsgPkt.SrcQ, IPMB_PRIMARY_IFC_Q); // } // else if((pBMCInfo->SecondaryIPMBCh != CH_NOT_USED && Channel == pBMCInfo->SecondaryIPMBCh) && pBMCInfo->IpmiConfig.SecondaryIPMBSupport == 1) // { // TDBG ("SendMsg: To SMLink IPMB Interface\n"); // strcpy ((char *)m_MsgPkt.SrcQ, IPMB_SECONDARY_IFC_Q); // } // else if ((pBMCInfo->SERIALch != CH_NOT_USED && Channel == pBMCInfo->SERIALch) && pBMCInfo->IpmiConfig.SerialIfcSupport == 1) // { // TDBG ("SendMsg: To Serial Interface\n"); // Offset++; // strcpy ((char *)m_MsgPkt.SrcQ, SERIAL_IFC_Q); // } // else if ((pBMCInfo->ICMBCh != CH_NOT_USED && Channel == pBMCInfo->ICMBCh) && pBMCInfo->IpmiConfig.ICMBIfcSupport == 1) // { // TDBG ("SendMsg: To ICMB Interface\n"); // strcpy ((char *)m_MsgPkt.SrcQ, ICMB_IFC_Q); // } // else if(pBMCInfo->SYSCh != CH_NOT_USED && Channel == pBMCInfo->SYSCh) // { // TDBG ("SendMsg: To System Interface\n"); // /* // * According to IPMI Spec v2.0. // * It is recommended to send CC_DEST_UNAVAILABLE // * completion code, if the channel is disabled for // * receiving messages. // * */ // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->ChUserMutex,WAIT_INFINITE); // pChannelInfo = getChannelInfo(Channel,BMCInst); // if(NULL == pChannelInfo) // { // *pRes = CC_INV_DATA_FIELD; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // return sizeof (*pRes); // } // if (0x0 == pChannelInfo->ReceiveMsgQ) // { // printf ("The Channel(0x%x) has been Disabled " // "for Receive message\n", Channel); // *pRes = CC_DEST_UNAVAILABLE; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // return sizeof (*pRes); // } // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // strcpy ((char *)m_MsgPkt.SrcQ, &g_RcvMsgQ[*kcsifcnum][0]); // m_MsgPkt.Param = SrcSessionHndl; // } // else // { // printf ("SendMsg: Invalid Channel\n"); // *pRes = CC_DEST_UNAVAILABLE; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // return sizeof (*pRes); // } // // if( (TRUE == pBMCInfo->NMConfig.NMSupport) && (pBMCInfo->NMConfig.NMDevSlaveAddress == pIPMIMsgHdr->ResAddr) && // (Channel == (NM_PRIMARY_IPMB_BUS == pBMCInfo->NMConfig.NM_IPMBBus) ? pBMCInfo->PrimaryIPMBCh : pBMCInfo->SecondaryIPMBCh) ) // { // if( (pBMCInfo->RMCPLAN1Ch == *curchannel) || // (pBMCInfo->RMCPLAN2Ch == *curchannel) || // (pBMCInfo->RMCPLAN3Ch == *curchannel) || // (pBMCInfo->RMCPLAN4Ch == *curchannel) || // (pBMCInfo->SERIALch == *curchannel) ) // { // OS_THREAD_TLS_GET(g_tls.CurPrivLevel,curprivlevel); // if(PRIV_ADMIN != *curprivlevel) // { // TDBG("Insufficient Privilege\n"); // *pRes = CC_INSUFFIENT_PRIVILEGE; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // return sizeof(*pRes); // } // } // } // // if(g_PDKHandle[PDK_BEFORESENDMESSAGE] != NULL) // { // RetVal = ( (int (*)(INT8U*, INT8U, INT8U*, int) ) g_PDKHandle[PDK_BEFORESENDMESSAGE]) ( pReq, ReqLen, pRes, BMCInst); // // if(0 < RetVal) // { // return RetVal; // } // } // // if (1 == Tracking) // { // /* Response length is set to zero to make MsgHndlr skip responding to this request // * The Response will be handled by the ipmb interface after verifying NAK. // */ // ResLen = 0; // // /* Tracking is not required if originator is System ifc */ // if (SYS_IFC_CHANNEL == (*curchannel & 0xF)) // { // *pRes = CC_INV_DATA_FIELD; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // return sizeof (*pRes); // } // // PBTbl = (Channel == pBMCInfo->SecondaryIPMBCh) ? SECONDARY_PB_TBL : PRIMARY_PB_TBL ; // // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->PendBridgeMutex, WAIT_INFINITE); // // /* Store in the table for response tracking */ // while(TRUE) // { // if (FALSE == m_PendingBridgedResTbl[PBTbl][SeqNum].Used) // { // m_PendingBridgedResTbl[PBTbl][SeqNum].TimeOut = pBMCInfo->IpmiConfig.SendMsgTimeout; // m_PendingBridgedResTbl[PBTbl][SeqNum].ChannelNum = (*curchannel & 0xF); // m_PendingBridgedResTbl[PBTbl][SeqNum].OriginSrc = ORIGIN_SENDMSG; // pBMCInfo->SendMsgSeqNum = SeqNum; // // if (1 != Offset) // { // m_PendingBridgedResTbl[PBTbl][SeqNum].DstSessionHandle = pReq[Offset]; /* Session handle */ // } // // m_PendingBridgedResTbl[PBTbl][SeqNum].SrcSessionHandle = SrcSessionHndl; // // _fmemcpy (&m_PendingBridgedResTbl[PBTbl][SeqNum].ReqMsgHdr, pIPMIMsgHdr, sizeof (IPMIMsgHdr_T)); // // /* Format the IPMI Msg Hdr */ // if(Channel == pBMCInfo->PrimaryIPMBCh) // { // pIPMIMsgHdr->ReqAddr = pBMCInfo->IpmiConfig.PrimaryIPMBAddr; // } // else if(Channel == pBMCInfo->SecondaryIPMBCh) // { // pIPMIMsgHdr->ReqAddr = pBMCInfo->IpmiConfig.SecondaryIPMBAddr; // } // else // { // pIPMIMsgHdr->ReqAddr = pBMCInfo->IpmiConfig.BMCSlaveAddr; // } // // pIPMIMsgHdr->RqSeqLUN = (pBMCInfo->SendMsgSeqNum << 2) & 0xFC; /* Seq Num and LUN =00 */ // // /* Recalculate the checksum */ // m_MsgPkt.Data[ReqLen - 2] = CalculateCheckSum2 ((_FAR_ INT8U*)pIPMIMsgHdr, ReqLen - Offset - 1); // if(IsLANChannel(*curchannel & 0xF, BMCInst)) // { // memset(QueueName,0,sizeof(QueueName)); // sprintf(QueueName,"%s%d",LAN_IFC_Q,BMCInst); // strcpy ((char *)m_PendingBridgedResTbl[PBTbl][SeqNum].DestQ,QueueName); // } // else if (pBMCInfo->SERIALch != CH_NOT_USED && (*curchannel & 0xF) == pBMCInfo->SERIALch && pBMCInfo->IpmiConfig.SerialIfcSupport == 1) // { // memset(QueueName,0,sizeof(QueueName)); // sprintf(QueueName,"%s%d",SERIAL_IFC_Q,BMCInst); // strcpy ((char *)m_PendingBridgedResTbl[PBTbl][SeqNum].DestQ,QueueName); // } // else // { // if(( (*curchannel & 0xF) == PRIMARY_IPMB_CHANNEL) && (pBMCInfo->IpmiConfig.PrimaryIPMBSupport == 1 )) // { // memset(QueueName,0,sizeof(QueueName)); // sprintf(QueueName,"%s%d",IPMB_PRIMARY_IFC_Q,BMCInst); // strcpy ((char *)m_PendingBridgedResTbl[PBTbl][SeqNum].DestQ,QueueName); // } // else if((pBMCInfo->SecondaryIPMBCh != CH_NOT_USED && Channel == pBMCInfo->SecondaryIPMBCh) && pBMCInfo->IpmiConfig.SecondaryIPMBSupport == 1) // { // memset(QueueName,0,sizeof(QueueName)); // sprintf(QueueName,"%s%d",IPMB_SECONDARY_IFC_Q,BMCInst); // strcpy ((char *)m_PendingBridgedResTbl[PBTbl][SeqNum].DestQ,QueueName); // } // else if ((pBMCInfo->SERIALch != CH_NOT_USED && Channel == pBMCInfo->SERIALch) && pBMCInfo->IpmiConfig.SerialIfcSupport == 1) // { // memset(QueueName,0,sizeof(QueueName)); // sprintf(QueueName,"%s%d",SERIAL_IFC_Q,BMCInst); // strcpy ((char *)m_PendingBridgedResTbl[PBTbl][SeqNum].DestQ,QueueName); // } // else if((pBMCInfo->SMBUSCh != CH_NOT_USED && Channel == pBMCInfo->SMBUSCh) && pBMCInfo->IpmiConfig.SMBUSIfcSupport == 1) // { // //strcpy ((char *)m_PendingBridgedResTbl[i].DestQ, NULL); // } // else if ((pBMCInfo->ICMBCh != CH_NOT_USED && Channel == pBMCInfo->ICMBCh) && pBMCInfo->IpmiConfig.ICMBIfcSupport == 1) // { // memset(QueueName,0,sizeof(QueueName)); // sprintf(QueueName,"%s%d",ICMB_IFC_Q,BMCInst); // strcpy ((char *)m_PendingBridgedResTbl[PBTbl][SeqNum].DestQ,QueueName); // } // } // m_PendingBridgedResTbl[PBTbl][SeqNum].Used = TRUE; // IPMI_DBG_PRINT_1( "SendMessage: Bridged message added index = %d.\n", SeqNum); // // break; // } // else // { // SeqNum = (SeqNum + 1) & 0x3F; // // if (SeqNum == pBMCInfo->SendMsgSeqNum) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->PendBridgeMutex); // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // /* If not been added to the Pending Bridge table, an error should be reported back. // If not, for internal channel, the thread calling it may end up waiting! */ // *pRes = CC_NODE_BUSY; // return sizeof (*pRes); // } // } // } // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->PendBridgeMutex); // } // // if ((pBMCInfo->SYSCh == (*curchannel & 0xF)) && pBMCInfo->IpmiConfig.SYSIfcSupport == 0x01) // { // // ResLen = 0; // /* Format the IPMI Msg Hdr */ // // Fill the address from Infrastrucure function instead of using PRIMARY_IPMB_ADDR/SECONDARY_IPMB_ADDR // if(Channel == pBMCInfo->PrimaryIPMBCh) // { // pIPMIMsgHdr->ReqAddr = pBMCInfo->IpmiConfig.PrimaryIPMBAddr; // } // else if(Channel == pBMCInfo->SecondaryIPMBCh) // { // pIPMIMsgHdr->ReqAddr = pBMCInfo->IpmiConfig.SecondaryIPMBAddr; // } // else // { // pIPMIMsgHdr->ReqAddr = pBMCInfo->IpmiConfig.BMCSlaveAddr; // } // // /*Change the encapsulated request's LUN based on originating KCS interface */ // pIPMIMsgHdr->RqSeqLUN = (pIPMIMsgHdr->RqSeqLUN & 0xFC) | (*kcsifcnum + 0x01); // m_MsgPkt.Data[ReqLen - 2] = CalculateCheckSum2 ((_FAR_ INT8U*)pIPMIMsgHdr, ReqLen - Offset - 1); // pBMCInfo->BridgeMsgKCSIfc = *kcsifcnum; // } // // IPMI_DBG_PRINT ("SendMsgCmd:Posting to interface"); // IPMI_DBG_PRINT_BUF (m_MsgPkt.Data, m_MsgPkt.Size); // // m_MsgPkt.Cmd = PAYLOAD_IPMI_MSG; // // /* Post the message to interface */ // if (0 != PostMsg (&m_MsgPkt,(INT8S *)m_MsgPkt.SrcQ, BMCInst)) // { // TDBG ("SendMsg: Failed to post message to interface queue\n"); // } // // pSendMsgRes->CompletionCode = CC_NORMAL; // // if(pBMCInfo->IpmiConfig.SecondaryIPMBSupport == 0x01) // { // if ((PRIMARY_IPMB_CHANNEL== (*curchannel & 0xF) || pBMCInfo->SecondaryIPMBCh == (*curchannel & 0xF)) && 1 == Tracking) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // return 0; // } // } // else // { // if ( PRIMARY_IPMB_CHANNEL == (*curchannel & 0xF) && (1 == Tracking)) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // return 0; // } // } // } // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // return ResLen; } /*--------------------------------------- * ReadEvtMsgBuffer *---------------------------------------*/ int ReadEvtMsgBuffer (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ ReadEvtMsgBufRes_T* pReadEvtMsgBufRes = (_NEAR_ ReadEvtMsgBufRes_T*)pRes; //#if GET_MSG_FLAGS != UNIMPLEMENTED // GetMsgFlagsRes_T GetMsgFlagsRes; //#endif // _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo;//[BMCInst]; // // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->BMCMsgMutex,WAIT_INFINITE); // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->EventMutex,WAIT_INFINITE); // if (-2 == GetMsg(&m_MsgPkt, EVT_MSG_Q, WAIT_NONE, BMCInst)) // { // /*If queue is empty */ // pReadEvtMsgBufRes->CompletionCode = CC_EVT_MSG_QUEUE_EMPTY;/* Queue is empty */ // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->EventMutex); // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // return sizeof (*pRes); // } // // if (BMC_GET_SHARED_MEM (BMCInst)->NumEvtMsg == 0) // { // pReadEvtMsgBufRes->CompletionCode = CC_EVT_MSG_QUEUE_EMPTY; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->EventMutex); // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // return sizeof (*pRes); // } // // BMC_GET_SHARED_MEM (BMCInst)->NumEvtMsg--; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->EventMutex); // //#if GET_MSG_FLAGS != UNIMPLEMENTED // // Clear SMS_ATN bit if and only if the Get Message Flag return 0 in byte 2. // GetMsgFlags (NULL, 0, (INT8U *)&GetMsgFlagsRes,BMCInst); // TDBG("GetMsgFlagsRes.CompletionCode : %X, GetMsgFlagsRes.MsgFlags : %X\n", // GetMsgFlagsRes.CompletionCode, GetMsgFlagsRes.MsgFlags); // if (GetMsgFlagsRes.CompletionCode == CC_NORMAL && GetMsgFlagsRes.MsgFlags == 0) //#else // if (0 == BMC_GET_SHARED_MEM (BMCInst)->NumEvtMsg) //#endif // { // /* if there is no messssage in buffer reset SMS/EVT ATN bit */ // // CLEAR_SMS_ATN (); // if (pBMCInfo->IpmiConfig.KCS1IfcSupport == 1) // { // CLEAR_SMS_ATN (0, BMCInst); // } // if (pBMCInfo->IpmiConfig.KCS2IfcSupport == 1) // { // CLEAR_SMS_ATN (1, BMCInst); // } // if (pBMCInfo->IpmiConfig.KCS3IfcSuppport == 1) // { // CLEAR_SMS_ATN (2, BMCInst); // } // } // // /* clear EventMessageBuffer full flag */ // BMC_GET_SHARED_MEM (BMCInst)->MsgFlags &= ~0x02; // // pReadEvtMsgBufRes->CompletionCode = CC_NORMAL; /* Completion Code */ // // /* copy the Message data */ // _fmemcpy (pReadEvtMsgBufRes->ResData, m_MsgPkt.Data, m_MsgPkt.Size); // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->BMCMsgMutex); // // return sizeof (ReadEvtMsgBufRes_T); } /*--------------------------------------- * GetBTIfcCap *---------------------------------------*/ int GetBTIfcCap (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { _NEAR_ GetBTIfcCapRes_T* pGetBTIfcCapRes = (_NEAR_ GetBTIfcCapRes_T*)pRes; pGetBTIfcCapRes->CompletionCode = CC_NORMAL; pGetBTIfcCapRes->NumReqSupported = 2; pGetBTIfcCapRes->InputBufSize = MAX_BT_PKT_LEN; pGetBTIfcCapRes->OutputBufSize = MAX_BT_PKT_LEN; pGetBTIfcCapRes->RespTime = 1; pGetBTIfcCapRes->Retries = 0; return sizeof (GetBTIfcCapRes_T); } /*--------------------------------------- * GetSystemGUID *---------------------------------------*/ int GetSystemGUID (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { //_NEAR_ GetSysGUIDRes_T* pGetSysGUIDRes = (_NEAR_ GetSysGUIDRes_T*)pRes; //pGetSysGUIDRes->CompletionCode = CC_NORMAL; //LOCK_BMC_SHARED_MEM (BMCInst); //_fmemcpy (&pGetSysGUIDRes->Node, BMC_GET_SHARED_MEM (BMCInst)->SystemGUID, 16); //UNLOCK_BMC_SHARED_MEM (BMCInst); //return sizeof (GetSysGUIDRes_T); } #define SUPPORT_IPMI20 0x02 #define SUPPORT_IPMI15 0x01 /*--------------------------------------- * GetChAuthCap *---------------------------------------*/ int GetChAuthCap (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // printf("start GetChAuthCap\n"); _NEAR_ GetChAuthCapReq_T* pGetChAuthCapReq = (_NEAR_ GetChAuthCapReq_T*)pReq; _NEAR_ GetChAuthCapRes_T* pGetChAuthCapRes = (_NEAR_ GetChAuthCapRes_T*)pRes; memset (pGetChAuthCapRes, 0, sizeof (GetChAuthCapRes_T)); pGetChAuthCapRes->CompletionCode=0x00; pGetChAuthCapRes->ChannelNum=0x01; pGetChAuthCapRes->AuthType=0x36; pGetChAuthCapRes->PerMsgUserAuthLoginStatus=0x04; SessionSequenceNumberCount=0; return sizeof(GetChAuthCapRes_T); } /*--------------------------------------- * GetSessionChallenge *---------------------------------------*/ int GetSessionChallenge (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // printf("start GetSessionChallenge\n"); _NEAR_ GetSesChallengeReq_T* pGetSesChalReq = (_NEAR_ GetSesChallengeReq_T*)pReq; _NEAR_ GetSesChallengeRes_T* pGetSesChalRes = (_NEAR_ GetSesChallengeRes_T*)pRes; INT32U TemId=0xffb52dfb;//0xfb2db5ff memset (pGetSesChalRes, 0, sizeof (GetSesChallengeRes_T)); pGetSesChalRes->CompletionCode=0x00; pGetSesChalRes->TempSessionID=TemId; pGetSesChalRes->ChallengeString[0]=0x54; pGetSesChalRes->ChallengeString[1]=0xdf; pGetSesChalRes->ChallengeString[2]=0xe1; pGetSesChalRes->ChallengeString[3]=0xbf; pGetSesChalRes->ChallengeString[4]=0x56; pGetSesChalRes->ChallengeString[5]=0x47; pGetSesChalRes->ChallengeString[6]=0x87; pGetSesChalRes->ChallengeString[7]=0x88; pGetSesChalRes->ChallengeString[8]=0xea; pGetSesChalRes->ChallengeString[9]=0x7b; pGetSesChalRes->ChallengeString[10]=0xa1; pGetSesChalRes->ChallengeString[11]=0x54; pGetSesChalRes->ChallengeString[12]=0x37; pGetSesChalRes->ChallengeString[13]=0x5b; pGetSesChalRes->ChallengeString[14]=0x79; pGetSesChalRes->ChallengeString[15]=0xe3; // SessionSequenceNumberCount=SessionSequenceNumberCount+1; return sizeof (GetSesChallengeRes_T); } /*--------------------------------------- * ActivateSession *---------------------------------------*/ int ActivateSession (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // printf("start ActivateSession:\n"); _NEAR_ ActivateSesReq_T* pAcvtSesReq = (_NEAR_ ActivateSesReq_T*)pReq; _NEAR_ ActivateSesRes_T* pAcvtSesRes = (_NEAR_ ActivateSesRes_T*)pRes; INT32U SesId=0xffb52dfb;//0xfb2db5ff; INT32U InbSeq=0x2ae8944a;//0x4a94e82a; memset (pAcvtSesRes, 0, sizeof (ActivateSesRes_T)); pAcvtSesRes->CompletionCode=0x00; pAcvtSesRes->AuthType=0x02; pAcvtSesRes->SessionID=SesId; pAcvtSesRes->InboundSeq=InbSeq; pAcvtSesRes->Privilege=0x04; SessionSequenceNumberCount=SessionSequenceNumberCount+1; return sizeof (ActivateSesRes_T); } /*--------------------------------------- * SetSessionPrivLevel *---------------------------------------*/ int SetSessionPrivLevel (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { _NEAR_ SetSesPrivLevelReq_T* pSetSesPrivLevelReq = (_NEAR_ SetSesPrivLevelReq_T*)pReq; _NEAR_ SetSesPrivLevelRes_T* pSetSesPrivLevelRes = (_NEAR_ SetSesPrivLevelRes_T*)pRes; memset (pSetSesPrivLevelRes, 0, sizeof (SetSesPrivLevelRes_T)); pSetSesPrivLevelRes->CompletionCode=0x00; pSetSesPrivLevelRes->Privilege=0x04; SessionSequenceNumberCount=SessionSequenceNumberCount+1; return sizeof (SetSesPrivLevelRes_T); } /*--------------------------------------- * CloseSession *---------------------------------------*/ int CloseSession (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { SessionSequenceNumberCount=SessionSequenceNumberCount+1; return sizeof (*pRes); } //#if GET_SESSION_INFO != UNIMPLEMENTED /*--------------------------------------- * GetSessionInfo *---------------------------------------*/ int GetSessionInfo (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ GetSesInfoReq_T* pGetSesInfoReq = (_NEAR_ GetSesInfoReq_T*)pReq; // _NEAR_ GetSesInfoRes_T* pGetSesInfoRes = (_NEAR_ GetSesInfoRes_T*)pRes; // _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo;//[BMCInst]; // LANSesInfoRes_T LANSesInfo; // LANIPv6SesInfoRes_T LANIPv6SesInfo; // _FAR_ SessionInfo_T* pSessInfo; // _FAR_ ChannelInfo_T* pChannelInfo; // _FAR_ void* SessionArg; // INT8U SessionArgAlign[4]; // INT8U SessionArgType,EthIndex, netindex = 0xFF; // char IfcName[IFNAMSIZ]; // INT32U *CurSesID,*curchannel; // int i; // // *pRes = CC_REQ_INV_LEN; // // switch (pGetSesInfoReq->SessionIndex) // { // case 0: // /* Get session information for this session */ // if (1 != ReqLen) // { // return sizeof (*pRes); // } // SessionArgType = SESSION_ID_INFO; // OS_THREAD_TLS_GET(g_tls.CurSessionID,CurSesID); // SessionArg = CurSesID; // break; // // case 0xFF: // if (5 != ReqLen) // { // return sizeof (*pRes); // } // SessionArgType = SESSION_ID_INFO; // // SessionArgAlign[0] = pGetSesInfoReq->SessionHandleOrID[0]; // SessionArgAlign[1] = pGetSesInfoReq->SessionHandleOrID[1]; // SessionArgAlign[2] = pGetSesInfoReq->SessionHandleOrID[2]; // SessionArgAlign[3] = pGetSesInfoReq->SessionHandleOrID[3]; // SessionArg = SessionArgAlign; // break; // // case 0xFE: // if (2 != ReqLen) // { // return sizeof (*pRes); // } // if (pGetSesInfoReq->SessionHandleOrID[0] == 0) // { // *pRes=CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // SessionArgType = SESSION_HANDLE_INFO; // SessionArgAlign[0] = pGetSesInfoReq->SessionHandleOrID[0]; // SessionArgAlign[1] = pGetSesInfoReq->SessionHandleOrID[1]; // SessionArgAlign[2] = pGetSesInfoReq->SessionHandleOrID[2]; // SessionArgAlign[3] = pGetSesInfoReq->SessionHandleOrID[3]; // SessionArg = SessionArgAlign; // break; // // default: // if (1 != ReqLen) // { // return sizeof (*pRes); // } // SessionArgType = SESSION_INDEX_INFO; // SessionArg = &pGetSesInfoReq->SessionIndex; // break; // } // // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->SessionTblMutex, WAIT_INFINITE); // pSessInfo = getSessionInfo (SessionArgType, SessionArg, BMCInst); // if (NULL == pSessInfo) // { // TDBG ("GetSessionInfo: pSessInfo is NULL\n"); // /* if there is no active channel for the current session Index // * return the following bytes // */ // // OS_THREAD_TLS_GET(g_tls.CurChannel,curchannel); // pChannelInfo = getChannelInfo (*curchannel & 0xF, BMCInst); // if(NULL == pChannelInfo) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SessionTblMutex); // pGetSesInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // pGetSesInfoRes->CompletionCode = CC_NORMAL; // pGetSesInfoRes->SessionHandle = BMC_GET_SHARED_MEM (BMCInst)->SessionHandle; // pGetSesInfoRes->NumPossibleActiveSession= pBMCInfo->IpmiConfig.MaxSession; // pGetSesInfoRes->NumActiveSession = GetNumOfActiveSessions (BMCInst); // // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SessionTblMutex); // return (sizeof (GetSesInfoRes_T) - sizeof (ActiveSesInfo_T) - sizeof (SessionInfoRes_T)); // } // // memset (pGetSesInfoRes,0,sizeof(GetSesInfoRes_T)); // pChannelInfo = getChannelInfo (pSessInfo->Channel, BMCInst); // if(NULL == pChannelInfo) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SessionTblMutex); // pGetSesInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // pGetSesInfoRes->CompletionCode = CC_NORMAL; // pGetSesInfoRes->SessionHandle = pSessInfo->SessionHandle; // pGetSesInfoRes->NumPossibleActiveSession = pBMCInfo->IpmiConfig.MaxSession; // pGetSesInfoRes->NumActiveSession = GetNumOfActiveSessions (BMCInst); // pGetSesInfoRes->ActiveSesinfo.UserID = pSessInfo->UserId & 0x3F; // pGetSesInfoRes->ActiveSesinfo.Privilege = pSessInfo->Privilege & 0x0F; // /* Set protocol bit as per Auth Type, bit4 must be 1 for IPMIv2.0 RMCP, 0 for IPMIv1.5 */ // if( AUTHTYPE_RMCP_PLUS_FORMAT == pSessInfo->AuthType ) // { // pGetSesInfoRes->ActiveSesinfo.ChannelNum = (pSessInfo->Channel & 0x0F) | 0x10; // }else // { // pGetSesInfoRes->ActiveSesinfo.ChannelNum = pSessInfo->Channel & 0x0F; // } // EthIndex= GetEthIndex(pSessInfo->Channel & 0x0F, BMCInst); // if(0xff == EthIndex) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SessionTblMutex); // *pRes = CC_INV_DATA_FIELD; // DeleteSession (pSessInfo,BMCInst); // return sizeof (INT8U); // } // memset(IfcName,0,sizeof(IfcName)); // /*Get the EthIndex*/ // if(GetIfcName(EthIndex,IfcName, BMCInst) == -1) // { // TCRIT("Error in Getting Ifc name\n"); // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SessionTblMutex); // *pRes = CC_INV_DATA_FIELD; // return sizeof (INT8U); // } // // for(i=0;iSessionTblMutex); // *pRes = CC_INV_DATA_FIELD; // return sizeof (INT8U); // } // if (IsLANChannel( pSessInfo->Channel, BMCInst)) // { // if(g_corefeatures.global_ipv6 == ENABLED) // { // if(GetIPAdrressType(&pSessInfo->LANRMCPPkt.IPHdr.Srcv6Addr[0])==4) // { // memset(&LANSesInfo,0,sizeof(LANSesInfo)); // /* IP Address */ // _fmemcpy (&(LANSesInfo.IPAddress), // &pSessInfo->LANRMCPPkt.IPHdr.Srcv6Addr[sizeof(struct in6_addr)-sizeof(struct in_addr)], // sizeof(struct in_addr)); // /* MAC Address */ // if(pSessInfo->LANRMCPPkt.MACHdr.DestAddr[0] == 0) // nwGetSrcCacheMacAddr((INT8U*)&pSessInfo->LANRMCPPkt.IPHdr.Srcv6Addr[12], // netindex, pSessInfo->LANRMCPPkt.MACHdr.DestAddr); // // _fmemcpy(LANSesInfo.MACAddress, pSessInfo->LANRMCPPkt.MACHdr.DestAddr, MAC_ADDR_LEN); // /* Port number */ // LANSesInfo.PortNumber = pSessInfo->LANRMCPPkt.UDPHdr.SrcPort; // // _fmemcpy ((pRes+sizeof (GetSesInfoRes_T) - sizeof (SessionInfoRes_T)),&LANSesInfo, sizeof (LANSesInfoRes_T)); // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SessionTblMutex); // return (sizeof (GetSesInfoRes_T) - sizeof (SessionInfoRes_T)+sizeof (LANSesInfoRes_T)); // } // else // { // /* IP Address */ // memset(&LANIPv6SesInfo,0,sizeof(LANIPv6SesInfo)); // _fmemcpy (&(LANIPv6SesInfo.IPv6Address), // pSessInfo->LANRMCPPkt.IPHdr.Srcv6Addr, // sizeof(struct in6_addr)); // /* MAC Address */ // if(pSessInfo->LANRMCPPkt.MACHdr.DestAddr[0] == 0) // nwGetSrcMacAddr_IPV6((INT8U*)&pSessInfo->LANRMCPPkt.IPHdr.Srcv6Addr, // pSessInfo->LANRMCPPkt.MACHdr.DestAddr); // // _fmemcpy(LANIPv6SesInfo.MACAddress, pSessInfo->LANRMCPPkt.MACHdr.DestAddr, MAC_ADDR_LEN); // /* Port number */ // LANIPv6SesInfo.PortNumber = pSessInfo->LANRMCPPkt.UDPHdr.SrcPort; // // _fmemcpy ((pRes+sizeof (GetSesInfoRes_T) - sizeof(SessionInfoRes_T)),&LANIPv6SesInfo, sizeof (LANIPv6SesInfoRes_T)); // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SessionTblMutex); // return (sizeof (GetSesInfoRes_T) - sizeof (SessionInfoRes_T)+sizeof (LANIPv6SesInfoRes_T)); // } // } // else // { // // /* IP Address */ // _fmemcpy (pGetSesInfoRes->SesInfo.LANSesInfo.IPAddress, // pSessInfo->LANRMCPPkt.IPHdr.Srcv4Addr, // sizeof (pSessInfo->LANRMCPPkt.IPHdr.Srcv4Addr)); // /* MAC Address */ // if(pSessInfo->LANRMCPPkt.MACHdr.DestAddr[0] == 0) // nwGetSrcCacheMacAddr((INT8U*)pSessInfo->LANRMCPPkt.IPHdr.Srcv4Addr, netindex, // pSessInfo->LANRMCPPkt.MACHdr.DestAddr); // _fmemcpy(pGetSesInfoRes->SesInfo.LANSesInfo.MACAddress, // pSessInfo->LANRMCPPkt.MACHdr.DestAddr, MAC_ADDR_LEN); // /* Port number */ // pGetSesInfoRes->SesInfo.LANSesInfo.PortNumber = pSessInfo->LANRMCPPkt.UDPHdr.SrcPort; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SessionTblMutex); // return (sizeof (GetSesInfoRes_T) - sizeof (SessionInfoRes_T) + sizeof (LANSesInfoRes_T)); // } // } // else if (pBMCInfo->IpmiConfig.SerialIfcSupport == 1 && pBMCInfo->SERIALch== pSessInfo->Channel) // { // // pChannelInfo = getChannelInfo (pBMCInfo->SERIALch, BMCInst); // if(NULL == pChannelInfo) // { // pGetSesInfoRes->CompletionCode = CC_INV_DATA_FIELD; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SessionTblMutex); // return sizeof (*pRes); // } // // pGetSesInfoRes->SesInfo.SerialSesInfo.SessionActivityType = 0; // pGetSesInfoRes->SesInfo.SerialSesInfo.DestinationSelector = 0; // // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SessionTblMutex); // return (sizeof (GetSesInfoRes_T) - sizeof (SessionInfoRes_T) + sizeof (SerialSesInfoRes_T)); // } // else // { // pChannelInfo = getChannelInfo(pSessInfo->Channel, BMCInst); // if(NULL == pChannelInfo) // { // pGetSesInfoRes->CompletionCode = CC_INV_DATA_FIELD; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SessionTblMutex); // return sizeof (*pRes); // } // // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->SessionTblMutex); // return (sizeof (GetSesInfoRes_T) - sizeof (SessionInfoRes_T)); // } } //#endif /** * @fn GetAuthCodeForTypeV15 * @brief This function will use the encryption technique supported * in IPMI V1.5 in order to produce Auth Code. * @param[in] pUserInfo - Pointer to User info structure. * @param[in] pGetAuthCodeReq - Pointer to the structure of request data * @param[out] pGetAuthCodeRes - Pointer to the resultant data. * @retval size of the result data. */ static int GetAuthCodeForTypeV15 (UserInfo_T* pUserInfo, GetAuthCodeReq_T* pGetAuthCodeReq, GetAuthCodeRes_T* pGetAuthCodeRes,int BMCInst) { // INT8U AuthCode; // INT8U InBuffer[2*IPMI15_MAX_PASSWORD_LEN + HASH_DATA_LENGTH]; // char UserPswd[MAX_PASSWD_LEN]; // INT8U PwdEncKey[MAX_SIZE_KEY + 1] = {0}; // _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo;//[BMCInst]; // // memset(&(pGetAuthCodeRes->AuthCode), 0, AUTH_CODE_HASH_LEN); // AuthCode = pGetAuthCodeReq->AuthType & AUTH_CODE_V15_MASK; // if((pGetAuthCodeReq->AuthType & (BIT5 | BIT4)) || // (AuthCode == AUTHTYPE_RESERVED) || (AuthCode == AUTHTYPE_NONE) || // (AuthCode == AUTHTYPE_STRAIGHT_PASSWORD) || // (AuthCode > AUTHTYPE_OEM_PROPRIETARY)) // { // pGetAuthCodeRes->CompletionCode = CC_INV_DATA_FIELD; // return (sizeof (GetAuthCodeRes_T) - 4); // } // // 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[pUserInfo->UserId - 1].EncryptedPswd), MAX_PASSWORD_LEN, UserPswd, MAX_PASSWORD_LEN, PwdEncKey)) // { // TCRIT("Error in decrypting the IPMI User password for User ID:%d.\n", pUserInfo->UserId); // pGetAuthCodeRes->CompletionCode = CC_UNSPECIFIED_ERR; // return sizeof(*pGetAuthCodeRes); // } // memcpy(&InBuffer[0],UserPswd,IPMI15_MAX_PASSWORD_LEN); // } // else // { // memcpy(&InBuffer[0],pUserInfo->UserPassword,IPMI15_MAX_PASSWORD_LEN); // } // // LOCK_BMC_SHARED_MEM(BMCInst); // switch (AuthCode) // { // #if 0 // As per IPMIv2 Markup E4, Straight Password key is Reserved // case AUTH_TYPE_PASSWORD: /* Straight password */ // if (0 == _fmemcmp (pUserInfo->UserPassword,pGetAuthCodeReq->HashData,IPMI15_MAX_PASSWORD_LEN)) // { // _fmemcpy (pGetAuthCodeRes->AuthCode, "OK", 2); // } // else // { // pGetAuthCodeRes->CompletionCode = CC_INV_DATA_FIELD; // } // break; // #endif // // case AUTH_TYPE_MD2: /* MD2 */ // _fmemcpy (&InBuffer[IPMI15_MAX_PASSWORD_LEN], // pGetAuthCodeReq->HashData, HASH_DATA_LENGTH); // if (g_corefeatures.userpswd_encryption == ENABLED) // { // _fmemcpy(&InBuffer[IPMI15_MAX_PASSWORD_LEN+HASH_DATA_LENGTH], // UserPswd, IPMI15_MAX_PASSWORD_LEN); // } // else // { // _fmemcpy(&InBuffer[IPMI15_MAX_PASSWORD_LEN+HASH_DATA_LENGTH], // pUserInfo->UserPassword, IPMI15_MAX_PASSWORD_LEN); // } // // AuthCodeCalMD2 (InBuffer, pGetAuthCodeRes->AuthCode, sizeof (InBuffer)); // break; // // case AUTH_TYPE_MD5: /* MD5 */ // _fmemcpy (&InBuffer[IPMI15_MAX_PASSWORD_LEN], // pGetAuthCodeReq->HashData, HASH_DATA_LENGTH); // if (g_corefeatures.userpswd_encryption == ENABLED) // { // _fmemcpy(&InBuffer[IPMI15_MAX_PASSWORD_LEN+HASH_DATA_LENGTH], // UserPswd,IPMI15_MAX_PASSWORD_LEN); // } // else // { // _fmemcpy(&InBuffer[IPMI15_MAX_PASSWORD_LEN+HASH_DATA_LENGTH], // pUserInfo->UserPassword,IPMI15_MAX_PASSWORD_LEN); // } // AuthCodeCalMD5 (InBuffer, pGetAuthCodeRes->AuthCode, sizeof (InBuffer)); // break; // // default: // pGetAuthCodeRes->CompletionCode = CC_INV_DATA_FIELD; // } // // UNLOCK_BMC_SHARED_MEM(BMCInst); // // IPMI V1.5 AuthCode is only 16 byte. // return (sizeof (GetAuthCodeRes_T) - 4); } /** * @fn GetAuthCodeForTypeV20 * @brief This function will use the encryption technique supported * in IPMI V2.0 in order to produce Auth Code. * @param[in] pUserInfo - Pointer to User info structure. * @param[in] pGetAuthCodeReq - Pointer to the structure of request data * @param[out] pGetAuthCodeRes - Pointer to the resultant data. * @retval size of the result data. */ static int GetAuthCodeForTypeV20 (UserInfo_T* pUserInfo, GetAuthCodeReq_T* pGetAuthCodeReq, GetAuthCodeRes_T* pGetAuthCodeRes,int BMCInst) { // INT8U AuthCode; // INT8U UserPasswdLen=0; // INT8U DecVal = 0; // _FAR_ INT8U m_SIK [SESSION_INTEGRITY_KEY_SIZE]; // char UserPswd[MAX_PASSWD_LEN]; // unsigned char PwdEncKey[MAX_SIZE_KEY + 1] = {0}; // _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo;//[BMCInst]; // // 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[pUserInfo->UserId - 1].EncryptedPswd), MAX_PASSWORD_LEN, UserPswd, MAX_PASSWORD_LEN, PwdEncKey)) // { // TCRIT("\nError in decrypting the IPMI User password for user with ID:%d.\n", pUserInfo->UserId); // pGetAuthCodeRes->CompletionCode = CC_UNSPECIFIED_ERR; // return sizeof (*pGetAuthCodeRes); // } // } // else // { // memcpy(&UserPswd, pUserInfo->UserPassword, MAX_PASSWD_LEN); // } // // /* Calculate password length */ // UserPasswdLen = _fstrlen ((_FAR_ char*)UserPswd); // UserPasswdLen = (UserPasswdLen > MAX_PASSWORD_LEN) ? // MAX_PASSWORD_LEN : UserPasswdLen; // // memset(&(pGetAuthCodeRes->AuthCode), 0, AUTH_CODE_HASH_LEN); // AuthCode = pGetAuthCodeReq->AuthType & AUTH_CODE_V20_MASK; // /* Validate the Auth Code */ // if ((AuthCode > MIN_AUTH_CODE_V20) && (AuthCode < MAX_AUTH_CODE_V20)) // { // pGetAuthCodeRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(GetAuthCodeRes_T); // } // // LOCK_BMC_SHARED_MEM(BMCInst); // switch(AuthCode) // { // case AUTH_NONE: /* none */ // TDBG ("\nInside AUTH_NONE in GetAuthCode"); // pGetAuthCodeRes->CompletionCode = CC_INV_DATA_FIELD; // break; // // case AUTH_HMAC_SHA1_96: /* HMAC-SHA1-96 */ // TDBG ("\nInside AUTH_HMAC_SHA1_96 in GetAuthCode"); // hmac_sha1 ((INT8U *)UserPswd, UserPasswdLen, // (INT8U *)pGetAuthCodeReq->HashData, HASH_DATA_LEN, // (INT8U *)m_SIK, SESSION_INTEGRITY_KEY_SIZE); // // hmac_sha1 ((INT8U *)m_SIK, SESSION_INTEGRITY_KEY_SIZE, // (INT8U *)pGetAuthCodeReq->HashData, HASH_DATA_LEN, // (INT8U *)&(pGetAuthCodeRes->AuthCode), HMAC_SHA1_96_LEN); // // DecVal = AUTH_CODE_HASH_LEN - HMAC_SHA1_96_LEN; // break; // // case AUTH_HMAC_MD5_128: /* HMAC-MD5-128 */ // TDBG ("\nInside AUTH_HMAC_MD5_128 in GetAuthCode"); // hmac_md5 ((unsigned char*)UserPswd, UserPasswdLen, // pGetAuthCodeReq->HashData, HASH_DATA_LEN, // m_SIK, SESSION_HMAC_MD5_I_KEY_SIZE); // // hmac_md5 (m_SIK, SESSION_HMAC_MD5_I_KEY_SIZE, // pGetAuthCodeReq->HashData, HASH_DATA_LEN, // (unsigned char *)&(pGetAuthCodeRes->AuthCode), // SESSION_HMAC_MD5_I_KEY_SIZE); // DecVal = AUTH_CODE_HASH_LEN - SESSION_HMAC_MD5_I_KEY_SIZE; // break; // // case AUTH_MD5_128: /* MD5-128 */ // TDBG ("\nInside AUTH_MD5_128 in GetAuthCode"); // MD5_128 ((char *)UserPswd, UserPasswdLen, // (char *)pGetAuthCodeReq->HashData, HASH_DATA_LEN, // (char *)m_SIK, SESSION_MD5_KEY_SIZE); // // MD5_128 ((char *)m_SIK, SESSION_INTEGRITY_KEY_SIZE, // (char *)pGetAuthCodeReq->HashData, HASH_DATA_LEN, // (char *)&(pGetAuthCodeRes->AuthCode), SESSION_MD5_KEY_SIZE); // DecVal = AUTH_CODE_HASH_LEN - SESSION_MD5_KEY_SIZE; // break; // // case AUTH_HMAC_SHA256_128: /* HMAC-SHA256-128 */ // TDBG ("\nInside AUTH_HMAC_SHA256_128 in GetAuthCode"); // hmac_sha256 ((unsigned char *)UserPswd, UserPasswdLen, // (unsigned char *)pGetAuthCodeReq->HashData, HASH_DATA_LEN, // (unsigned char *)m_SIK, SHA2_HASH_KEY_SIZE); // // hmac_sha256 (m_SIK, SHA2_HASH_KEY_SIZE, // (unsigned char *)pGetAuthCodeReq->HashData, HASH_DATA_LEN, // (unsigned char *)&(pGetAuthCodeRes->AuthCode), HMAC_SHA256_128_LEN); // DecVal = AUTH_CODE_HASH_LEN - HMAC_SHA256_128_LEN; // break; // // //! TODO: Need support in openssl. // default: /* OEM or Reserved */ // pGetAuthCodeRes->CompletionCode = CC_INV_DATA_FIELD; // } // // UNLOCK_BMC_SHARED_MEM(BMCInst); // if (DecVal > sizeof(GetAuthCodeRes_T)) // return sizeof(GetAuthCodeRes_T); // else // return (sizeof(GetAuthCodeRes_T) - DecVal); } /** * @fn GetAuthCode * @brief This function will encrypt the given 16 byte data with * the algorithm given and return Auth Code. * @param[in] pReq - Request data. * @param[in] ReqLen - Length of the request data. * @param[out] pRes - Result data * @retval size of the result data. */ int GetAuthCode (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,int BMCInst) { _NEAR_ GetAuthCodeReq_T* pGetAuthCodeReq = (_NEAR_ GetAuthCodeReq_T*)pReq; _NEAR_ GetAuthCodeRes_T* pGetAuthCodeRes = (_NEAR_ GetAuthCodeRes_T*)pRes; BMCInfo_t *pBMCInfo = &g_BMCInfo;//[BMCInst]; _FAR_ UserInfo_T* pUserInfo; INT8U AuthType,*curchannel; _FAR_ ChannelInfo_T* pChannelInfo; int nRetSize = 0; // printf("start GetAuthCode\n"); /* Check for Reserved Bits */ if((pGetAuthCodeReq->ChannelNum & (BIT7 | BIT6 | BIT5 | BIT4)) || (pGetAuthCodeReq->UserID & (BIT7 | BIT6))) { pGetAuthCodeRes->CompletionCode = CC_INV_DATA_FIELD; return sizeof(*pRes); } //OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->ChUserMutex,WAIT_INFINITE); /* Validate the channel number given */ if (CURRENT_CHANNEL_NUM == pGetAuthCodeReq->ChannelNum) { OS_THREAD_TLS_GET(g_tls.CurChannel,curchannel); pChannelInfo = getChannelInfo(*curchannel & 0xF,BMCInst); } else pChannelInfo = getChannelInfo(pGetAuthCodeReq->ChannelNum,BMCInst); if (NULL == pChannelInfo) { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); *pRes = CC_INV_DATA_FIELD; return sizeof(*pRes); } /* Get the user information for the given userID */ pUserInfo = getUserIdInfo (pGetAuthCodeReq->UserID,BMCInst); if (NULL == pUserInfo) { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); TDBG ("AppDevice.c : GetAuthCode - Invalid user Id\n"); pGetAuthCodeRes->CompletionCode = CC_INV_DATA_FIELD; return sizeof (*pRes); } AuthType = pGetAuthCodeReq->AuthType & GET_AUTH_TYPE_MASK; pGetAuthCodeRes->CompletionCode = CC_NORMAL; switch(AuthType) { case AUTH_TYPE_V15: /* IPMI v1.5 AuthCode Algorithms */ nRetSize = GetAuthCodeForTypeV15(pUserInfo, pGetAuthCodeReq, pGetAuthCodeRes,BMCInst); break; case AUTH_TYPE_V20: /* IPMI v2.0/RMCP+ Algorithm Number */ nRetSize = GetAuthCodeForTypeV20(pUserInfo, pGetAuthCodeReq, pGetAuthCodeRes,BMCInst); break; default: // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); pGetAuthCodeRes->CompletionCode = CC_INV_DATA_FIELD; return sizeof(*pRes); } // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); return nRetSize; } /*--------------------------------------- * SetChAccess *---------------------------------------*/ int SetChAccess (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ SetChAccessReq_T* pSetChAccessReq = (_NEAR_ SetChAccessReq_T*)pReq; // INT8U ChannelNum, AccessMode; // _FAR_ ChannelInfo_T* pNvrChInfo; // _FAR_ ChannelInfo_T* pChannelInfo; // _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo;//[BMCInst]; // INT8U AccessFlags = 0,i=0,*curchannel; //// char ChFilename[MAX_CHFILE_NAME]; // // /* Reserve Bit Checking for Set Channel Acces */ // for(i=0;iChannelNum & 0x0F; // if (CURRENT_CHANNEL_NUM == ChannelNum) // { // OS_THREAD_TLS_GET(g_tls.CurChannel,curchannel); // ChannelNum = *curchannel & 0xF; // } // // if (((GetBits (pSetChAccessReq->Privilege, 0x0F)) < PRIV_LEVEL_CALLBACK) || // ((GetBits (pSetChAccessReq->Privilege, 0x0F)) > PRIV_LEVEL_PROPRIETARY)) // { // IPMI_DBG_PRINT_1 ("Invalid Channel Privilege = 0x%x\n", pSetChAccessReq->Privilege); // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->ChUserMutex,WAIT_INFINITE); // pChannelInfo = getChannelInfo(ChannelNum, BMCInst); // if (NULL == pChannelInfo) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // /*point to NVRAM ChannelInfo */ // pNvrChInfo = GetNVRChConfigs(pChannelInfo,BMCInst); // // if (SESSIONLESS_CHANNEL == pChannelInfo->SessionSupport) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // /* Channel is sessionless channel this command is not supported */ // *pRes = CC_SET_CH_COMMAND_NOT_SUPPORTED; // return sizeof (*pRes); // } // // // AccessMode = pSetChAccessReq->ChannelAccess & 0x07; // if(ChannelNum == pBMCInfo->SERIALch) // { // if( NULL != g_PDKHandle[PDK_SWITCHMUX]) // { // ((void(*)(INT8U, int))(g_PDKHandle[PDK_SWITCHMUX]))(AccessMode ,BMCInst); // } // } // // /* if the requested access mode is supported for the given channel */ // if (0 == (pChannelInfo->AccessModeSupported & (1 << AccessMode))) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_SET_CH_ACCES_MODE_NOT_SUPPORTED; // return sizeof (*pRes); // } // // AccessFlags = GetBits (pSetChAccessReq->ChannelAccess, 0xC0); // // switch (AccessFlags) // { // case 0: // /* dont set channel access */ // break; // // case 1: // /*set in Non volatile Memory and in voatile Memory */ // pNvrChInfo->Alerting = GetBits (pSetChAccessReq->ChannelAccess , 0x20); // pNvrChInfo->PerMessageAuth = GetBits (pSetChAccessReq->ChannelAccess , 0x10); // pNvrChInfo->UserLevelAuth = GetBits (pSetChAccessReq->ChannelAccess , 0x08); // pNvrChInfo->AccessMode = AccessMode; // /* write to NVRAM */ // FlushChConfigs((INT8U*)pNvrChInfo,pNvrChInfo->ChannelNumber,BMCInst); // pChannelInfo->Alerting = pNvrChInfo->Alerting; // pChannelInfo->PerMessageAuth= pNvrChInfo->PerMessageAuth; // pChannelInfo->UserLevelAuth = pNvrChInfo->UserLevelAuth; // pChannelInfo->AccessMode = AccessMode; // break; // // case 2: // /*set in volatile Memmory only */ // pChannelInfo->Alerting = GetBits (pSetChAccessReq->ChannelAccess, 0x20); // pChannelInfo->PerMessageAuth= GetBits (pSetChAccessReq->ChannelAccess, 0x10); // pChannelInfo->UserLevelAuth = GetBits (pSetChAccessReq->ChannelAccess, 0x08); // pChannelInfo->AccessMode = AccessMode; // } // // switch (GetBits (pSetChAccessReq->Privilege, 0xC0)) // { // case 0: // /* dont set prilivege level */ // break; // // case 1: // /* set in non volatile mem and volatile memeory*/ /*set privilege*/ // pNvrChInfo->MaxPrivilege = GetBits (pSetChAccessReq->Privilege, 0x0F); // pChannelInfo->MaxPrivilege = pNvrChInfo->MaxPrivilege; // break; // // case 2: // /*set privilege*/ // /* set in volatile memeory only */ // pChannelInfo->MaxPrivilege = GetBits (pSetChAccessReq->Privilege, 0x0F); // } // // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_NORMAL; // // return sizeof (*pRes); } /*--------------------------------------- * GetChAccess *---------------------------------------*/ int GetChAccess (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ GetChAccessReq_T* pGetChAccessReq = (_NEAR_ GetChAccessReq_T*)pReq; // _NEAR_ GetChAccessRes_T* pGetChAccessRes = (_NEAR_ GetChAccessRes_T*)pRes; // _FAR_ ChannelInfo_T* pChannelInfo; // _FAR_ ChannelInfo_T* pNvrChInfo; // INT8U ChannelNum,AccessFlag,*curchannel; // BMCInfo_t *pBMCInfo = &g_BMCInfo;//[BMCInst]; // // /* Check for reserved bits */ // if((0 != (pGetChAccessReq->ChannelNum & 0xf0)) || // (0 != (pGetChAccessReq-> AccessFlag & 0x3f))) // { // pGetChAccessRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // ChannelNum = pGetChAccessReq->ChannelNum & 0x0F; // if (CURRENT_CHANNEL_NUM == ChannelNum) // { // OS_THREAD_TLS_GET(g_tls.CurChannel,curchannel); // ChannelNum = *curchannel & 0xF; // } // // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->ChUserMutex,WAIT_INFINITE); // pChannelInfo = getChannelInfo (ChannelNum, BMCInst); // // if (NULL == pChannelInfo) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // pGetChAccessRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // if (SESSIONLESS_CHANNEL == pChannelInfo->SessionSupport) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // /* Channel is sessionless channel this command is not supported */ // pGetChAccessRes->CompletionCode = CC_GET_CH_COMMAND_NOT_SUPPORTED; // return sizeof (*pRes); // } // // AccessFlag = GetBits (pGetChAccessReq->AccessFlag, 0xC0); // // pGetChAccessRes->CompletionCode = CC_NORMAL; // // switch (AccessFlag) // { // case 1: // /* Get Channel Information from NVRAM */ // pNvrChInfo = GetNVRChConfigs(pChannelInfo,BMCInst); // // pGetChAccessRes->ChannelAccess = SetBits (0x20, pNvrChInfo->Alerting); // pGetChAccessRes->ChannelAccess |= SetBits (0x10, pNvrChInfo->PerMessageAuth); // pGetChAccessRes->ChannelAccess |= SetBits (0x08, pNvrChInfo->UserLevelAuth); // pGetChAccessRes->ChannelAccess |= SetBits (0x07, pNvrChInfo->AccessMode); // pGetChAccessRes->Privilege = SetBits (0x0F, pNvrChInfo->MaxPrivilege); // break; // // case 2: // /* Get Channel Information from Volatile RAM */ // pGetChAccessRes->ChannelAccess = SetBits (0x20, pChannelInfo->Alerting); // pGetChAccessRes->ChannelAccess |= SetBits (0x10, pChannelInfo->PerMessageAuth); // pGetChAccessRes->ChannelAccess |= SetBits (0x08, pChannelInfo->UserLevelAuth); // pGetChAccessRes->ChannelAccess |= SetBits (0x07, pChannelInfo->AccessMode); // pGetChAccessRes->Privilege = SetBits (0x0F, pChannelInfo->MaxPrivilege); // break; // // default: // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // pGetChAccessRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // return sizeof (GetChAccessRes_T); } /*--------------------------------------- * GetChInfo *---------------------------------------*/ int GetChInfo (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ GetChInfoReq_T* pGetChInfoReq = (_NEAR_ GetChInfoReq_T*)pReq; // _NEAR_ GetChInfoRes_T* pGetChInfoRes = (_NEAR_ GetChInfoRes_T*)pRes; // BMCInfo_t *pBMCInfo = &g_BMCInfo;//[BMCInst]; // _FAR_ ChannelInfo_T* pChannelInfo; // INT8U ChannelNum,*curchannel; // // if(pGetChInfoReq->ChannelNum & (BIT7 | BIT6 | BIT5 | BIT4)) //Check for Reserved bits // { // pGetChInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(*pRes); // } // // ChannelNum = pGetChInfoReq->ChannelNum; // if (CURRENT_CHANNEL_NUM == ChannelNum) // { // OS_THREAD_TLS_GET(g_tls.CurChannel,curchannel); // ChannelNum = *curchannel & 0xF; // // /* UDS, not being a physical channel, will hold LAN properties */ // if(UDS_CHANNEL == ChannelNum) // { // ChannelNum = LAN_RMCP_CHANNEL1_TYPE; // } // } // // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->ChUserMutex,WAIT_INFINITE); // pChannelInfo = getChannelInfo(ChannelNum, BMCInst); // if (NULL == pChannelInfo) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // pGetChInfoRes->CompletionCode = CC_INV_DATA_FIELD ; // return sizeof (*pRes); // } // // pGetChInfoRes->CompletionCode = CC_NORMAL; // pGetChInfoRes->ChannelNum = ChannelNum; // pGetChInfoRes->ChannelMedium = pChannelInfo->ChannelMedium; // pGetChInfoRes->ChannelProtocol = pChannelInfo->ChannelProtocol; // pGetChInfoRes->SessionActiveSupport = pChannelInfo->SessionSupport << 6; // pGetChInfoRes->SessionActiveSupport |= pChannelInfo->ActiveSession; // // _fmemcpy (pGetChInfoRes->VendorID, pChannelInfo->ProtocolVendorId, // sizeof (pGetChInfoRes->VendorID)); // _fmemcpy (pGetChInfoRes->AuxiliaryInfo, pChannelInfo->AuxiliaryInfo, // sizeof (pGetChInfoRes->AuxiliaryInfo)); // // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // // return sizeof (GetChInfoRes_T); } /*--------------------------------------- * IsChannelSuppGroups *---------------------------------------*/ INT8U IsChannelSuppGroups(INT8U ChannelNum,int BMCInst) { // _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo;//[BMCInst]; // _FAR_ ChannelInfo_T* pChannelInfo; // if(IsLANChannel(ChannelNum, BMCInst)) // { // // pChannelInfo = getChannelInfo (ChannelNum, BMCInst); // if(pChannelInfo==NULL) // return 0; // if(pChannelInfo->ChannelType==LAN_RMCP_CHANNEL1_TYPE) // { // return pChannelInfo->ChannelType; // } // else // { // if(pChannelInfo->ChannelType==LAN_RMCP_CHANNEL2_TYPE) // { // return pChannelInfo->ChannelType; // } // else // { // if(pChannelInfo->ChannelType==LAN_RMCP_CHANNEL3_TYPE) // { // return pChannelInfo->ChannelType; // } // else // return 0; // } // } // return 0; // } // else // { // if (pBMCInfo->IpmiConfig.SerialIfcSupport == 1 && (pBMCInfo->SERIALch != CH_NOT_USED && ChannelNum == pBMCInfo->SERIALch)) // { // pChannelInfo = getChannelInfo (ChannelNum, BMCInst); // if(pChannelInfo==NULL) // return 0; // return pChannelInfo->ChannelType; // } // else // return 0; // } } /*--------------------------------------- * ModifyUsrGRP *---------------------------------------*/ int ModifyUsrGrp(char * UserName,INT8U ChannelNum,INT8U OldAccessLimit, INT8U NewAccessLimit ) { // // char oldgrp[20]="",newgrp[20]=""; // // if(0 == NewAccessLimit) // { // DeleteUsrFromIPMIGrp(UserName); // } // // if(PRIV_LEVEL_NO_ACCESS == OldAccessLimit) // { // strcpy(oldgrp,g_GrpPriv[g_ChannelPrivtbl[ChannelNum].Privilege].grpname); // } // else if(IGNORE_ADD_OR_REMOVE != OldAccessLimit) // { // strcpy(oldgrp,g_GrpPriv[g_ChannelPrivtbl[ChannelNum].Privilege+OldAccessLimit].grpname); // } // // if(PRIV_LEVEL_NO_ACCESS == NewAccessLimit) // { // strcpy(newgrp,g_GrpPriv[g_ChannelPrivtbl[ChannelNum].Privilege].grpname); // } // else if(IGNORE_ADD_OR_REMOVE != NewAccessLimit) // { // strcpy(newgrp,g_GrpPriv[g_ChannelPrivtbl[ChannelNum].Privilege+NewAccessLimit].grpname); // } // // AddIPMIUsrtoChGrp(UserName,(char *)oldgrp,(char *)newgrp); return 0; } /*--------------------------------------- * SetUserAccess *---------------------------------------*/ int SetUserAccess (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ SetUserAccessReq_T* pSetUserAccessReq = (_NEAR_ SetUserAccessReq_T*)pReq; // _FAR_ ChannelUserInfo_T* pChUserInfo; // _FAR_ UserInfo_T* pUserInfo; // _FAR_ ChannelInfo_T* pChannelInfo; // _FAR_ ChannelInfo_T* pNvrChInfo; // _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo;//[BMCInst]; // _FAR_ ChannelUserInfo_T * pNVRChUserInfo=NULL; //// char ChFilename[MAX_CHFILE_NAME]; // INT8U Index; // INT8U ChannelNum,IPMIMessaging,*curchannel; // INT8U OldAccessLimit; // int ret=0; // // if (ReqLen == sizeof(SetUserAccessReq_T) - sizeof(pSetUserAccessReq->SessionLimit) ) // { // pSetUserAccessReq->SessionLimit = 0; // } // else if(ReqLen == sizeof(SetUserAccessReq_T)) // { // if(0 != pSetUserAccessReq->SessionLimit) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // } // else // { // *pRes = CC_REQ_INV_LEN; // return sizeof (*pRes); // } // // // Check for Reserved bits // if((pSetUserAccessReq->UserID & (BIT7 | BIT6)) || (pSetUserAccessReq->SessionLimit & (BIT7 | BIT6 | BIT5 | BIT4)) || (pSetUserAccessReq->AccessLimit == PRIV_LEVEL_RESERVED) || (pSetUserAccessReq->AccessLimit > PRIV_LEVEL_PROPRIETARY && pSetUserAccessReq->AccessLimit != PRIV_LEVEL_NO_ACCESS)) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(*pRes); // } // // ChannelNum = pSetUserAccessReq->ChannelNoUserAccess & 0x0F; // if (CURRENT_CHANNEL_NUM == ChannelNum) // { // OS_THREAD_TLS_GET(g_tls.CurChannel,curchannel); // ChannelNum = *curchannel & 0xF; // } // // /*Removing the Hard coding of admin user // if(pSetUserAccessReq->UserID == IPMI_ROOT_USER) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // */ // // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->ChUserMutex,WAIT_INFINITE); // pChannelInfo = getChannelInfo (ChannelNum, BMCInst); // if((NULL == pChannelInfo) || (pSetUserAccessReq->UserID > pBMCInfo->IpmiConfig.MaxUsers) || (SESSIONLESS_CHANNEL == pChannelInfo->SessionSupport)) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // pUserInfo = getUserIdInfo(pSetUserAccessReq->UserID, BMCInst); // if (NULL == pUserInfo) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // TDBG ("AppDevice.c : SetUserAccess - Invalid user Id\n"); // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // // TDBG("pChannle info is %p\n",pChannelInfo); // TDBG("UserId id is %d\n",pSetUserAccessReq->UserID); // TDBG("pUserInfo->ID is %ld and USERID is %ld\n",pUserInfo->ID,USER_ID); // // if (pUserInfo->ID != USER_ID) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // TCRIT("Invalid data field\n"); // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // /* User 's session limit should be lesser than Channel 's session limit */ // if(pSetUserAccessReq->SessionLimit > pBMCInfo->IpmiConfig.MaxSession) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // // pNvrChInfo = GetNVRChConfigs(pChannelInfo,BMCInst); // pNVRChUserInfo = GetNVRChUserConfigs(pChannelInfo,BMCInst); // pChUserInfo = getChUserIdInfo (pSetUserAccessReq->UserID , &Index, pChannelInfo->ChannelUserInfo, BMCInst); // // if (NULL == pChUserInfo) // { // /* Add the user in NVRAM */ // pChUserInfo = AddChUser (pChannelInfo->ChannelUserInfo, &Index, BMCInst); // if(pChUserInfo == NULL) // { // /*Return proper completion if the user exceeds the max channel users*/ // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // pChUserInfo->ID = USER_ID; // pChUserInfo->UserId = pSetUserAccessReq->UserID; // pNVRChUserInfo[Index].UserId = pSetUserAccessReq->UserID; // // pChUserInfo->AccessLimit = PRIV_LEVEL_NO_ACCESS; // /* Initial depends on the Request Bit */ // pChUserInfo->IPMIMessaging=FALSE; // pChUserInfo->ActivatingSOL=FALSE; // pChUserInfo->UserAccessCallback = FALSE; // pChUserInfo->LinkAuth = FALSE; // pNVRChUserInfo[Index].ID = USER_ID; // pNVRChUserInfo[Index].IPMIMessaging=FALSE; // pNVRChUserInfo[Index].ActivatingSOL=FALSE; // pNVRChUserInfo[Index].UserId = pSetUserAccessReq->UserID; // pNVRChUserInfo[Index].LinkAuth = FALSE; // pNVRChUserInfo[Index].UserAccessCallback =FALSE; // } // // if (0 != (pSetUserAccessReq->ChannelNoUserAccess & 0x80)) // { // /* set the user access for the channel */ // IPMIMessaging = GetBits (pSetUserAccessReq->ChannelNoUserAccess, 0x10); // if (FALSE == IPMIMessaging) // { // /* Disable the IPMI Messaging if Its in Enables state */ // if((TRUE == pChUserInfo->IPMIMessaging)&& (pChannelInfo->NoCurrentUser > 1) ) // { // /* Initialize based on the Request Bit */ // pChUserInfo->IPMIMessaging=IPMIMessaging; // pNVRChUserInfo[Index].IPMIMessaging=IPMIMessaging; // } // } // else // { // if(TRUE == pChUserInfo->IPMIMessaging) // { // pChUserInfo->Lock = USER_UNLOCKED; // pChUserInfo->LockedTime = 0; // pChUserInfo->FailureAttempts = 0; // } // else if(FALSE == pChUserInfo->IPMIMessaging) /* Enable the IPMI Messaging ,If its in disabled state */ // { // /* Initialize based on the Request Bit */ // pChUserInfo->IPMIMessaging=IPMIMessaging; // pNVRChUserInfo[Index].IPMIMessaging=IPMIMessaging; // pChUserInfo->Lock = USER_UNLOCKED; // pChUserInfo->LockedTime = 0; // pChUserInfo->FailureAttempts = 0; // } // } // // /* set in RAM */ // pChUserInfo->UserAccessCallback = GetBits (pSetUserAccessReq->ChannelNoUserAccess, 0x40); // pChUserInfo->LinkAuth = GetBits (pSetUserAccessReq->ChannelNoUserAccess, 0x20); // // pNVRChUserInfo[Index].UserId = pSetUserAccessReq->UserID; // pNVRChUserInfo[Index].LinkAuth = // GetBits (pSetUserAccessReq->ChannelNoUserAccess, 0x20); // pNVRChUserInfo[Index].UserAccessCallback = // GetBits (pSetUserAccessReq->ChannelNoUserAccess, 0x40); // // // } // OldAccessLimit=pChUserInfo->AccessLimit; // pChUserInfo->AccessLimit = GetBits (pSetUserAccessReq->AccessLimit, 0x0F); // // ret=ModifyUsrGrp((char *)pUserInfo->UserName,ChannelNum,OldAccessLimit,pChUserInfo->AccessLimit); // if(ret < 0) // { // TCRIT("User Has No LAN or Serial Preivilege!!\n"); // } // // pNVRChUserInfo[Index].AccessLimit = pChUserInfo->AccessLimit; // /* set in NVRAM */ // if (0 == (pUserInfo->MaxSession)) // { // /* This is MAX User session Limit */ // pUserInfo->MaxSession = pBMCInfo->IpmiConfig.MaxSession; // } // // // FlushIPMI((INT8U*)&pBMCInfo->UserInfo[0],(INT8U*)&pBMCInfo->UserInfo[0],pBMCInfo->IPMIConfLoc.UserInfoAddr, // sizeof(UserInfo_T)*MAX_USER_CFG_MDS,BMCInst); // FlushChConfigs((INT8U*)pNvrChInfo,pNvrChInfo->ChannelNumber,BMCInst); // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // // *pRes = CC_NORMAL; // // return sizeof (*pRes); } /*--------------------------------------- * GetUserAccess *---------------------------------------*/ int GetUserAccess (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ GetUserAccessReq_T* pGetUserAccessReq = (_NEAR_ GetUserAccessReq_T*)pReq; // _NEAR_ GetUserAccessRes_T* pGetUserAccessRes = (_NEAR_ GetUserAccessRes_T*)pRes; // _FAR_ ChannelUserInfo_T* pChUserInfo; // _FAR_ UserInfo_T* pUserInfo; // _FAR_ ChannelInfo_T* pChannelInfo; // _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo;//[BMCInst]; // INT8U Index,*curchannel; // // // Check for Reserved bits // if((pGetUserAccessReq->ChannelNum & (BIT7 | BIT6 | BIT5 | BIT4)) || (pGetUserAccessReq->UserID & (BIT7 | BIT6)) || (pGetUserAccessReq->UserID == 0x00)) // { // pGetUserAccessRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(*pRes); // } // // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->ChUserMutex,WAIT_INFINITE); // if (pGetUserAccessReq->ChannelNum == CURRENT_CHANNEL_NUM) // { // OS_THREAD_TLS_GET(g_tls.CurChannel,curchannel); // pChannelInfo = getChannelInfo(*curchannel,BMCInst); // } // else // pChannelInfo = getChannelInfo(pGetUserAccessReq->ChannelNum,BMCInst); // // //TDBG("UserID is %d\n",pGetUserAccessReq->UserID); // // if ((NULL == pChannelInfo) || // (pGetUserAccessReq->UserID > pBMCInfo->IpmiConfig.MaxUsers) || // (SESSIONLESS_CHANNEL == pChannelInfo->SessionSupport)) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // pGetUserAccessRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // pUserInfo = getUserIdInfo (pGetUserAccessReq->UserID, BMCInst); // // if (NULL == pUserInfo) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // pGetUserAccessRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // if (TRUE == pUserInfo->UserStatus) // { // pGetUserAccessRes->CurrentUserID = SetBits (0xC0, USER_ID_ENABLED); // } // else // { // pGetUserAccessRes->CurrentUserID = SetBits (0xC0, USER_ID_DISABLED); // } // // pChUserInfo = getChUserIdInfo (pGetUserAccessReq->UserID, &Index, pChannelInfo->ChannelUserInfo ,BMCInst); // // if (NULL == pChUserInfo) // { // pGetUserAccessRes->ChannelAccess = SetBits (0x0F, 0x0F); // pGetUserAccessRes->ChannelAccess |= SetBits (0x10, FALSE); // pGetUserAccessRes->ChannelAccess |= SetBits (0x20, FALSE); // pGetUserAccessRes->ChannelAccess |= SetBits (0x40, FALSE); // } // else // { // pGetUserAccessRes->ChannelAccess = SetBits (0x0F, pChUserInfo->AccessLimit); // pGetUserAccessRes->ChannelAccess |= SetBits (0x10, pChUserInfo->IPMIMessaging); // pGetUserAccessRes->ChannelAccess |= SetBits (0x20, pChUserInfo->LinkAuth); // pGetUserAccessRes->ChannelAccess |= SetBits (0x40, pChUserInfo->UserAccessCallback); // } // // pGetUserAccessRes->CompletionCode = CC_NORMAL; // pGetUserAccessRes->MaxNoUserID = SetBits (0x3F, pChannelInfo->MaxUser); // pGetUserAccessRes->CurrentUserID |= SetBits (0x3F, pChannelInfo->NoCurrentUser); // pGetUserAccessRes->FixedUserID = SetBits (0x3F, pChannelInfo->NoFixedUser); // // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // // return sizeof (GetUserAccessRes_T); } /*--------------------------------------- * SetUserName *---------------------------------------*/ int SetUserName (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ SetUserNameReq_T* pSetUserNameReq = (_NEAR_ SetUserNameReq_T*)pReq; // _FAR_ UserInfo_T* pUserInfo; // _FAR_ ChannelInfo_T* pChannelInfo=NULL; // _FAR_ ChannelInfo_T* pNvrChInfo; // _FAR_ ChannelUserInfo_T* pChUserInfo; // _FAR_ ChannelUserInfo_T * pNVRChUserInfo=NULL; // _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo;//[BMCInst]; // INT8U Ch, Index,Chtype; // //INT16S Err; // INT8U i; // INT8U UserName[MAX_USERNAME_LEN + 1]; //plus 1 for null terminator // INT8U InvalidChar[]={ ' ' , ',' , '.' , '/' , ':' , ';' , '\\' , '(', ')' , 0x01 , // 0x02 , 0x03 , 0x04 , 0x05 , 0x06 , 0x07 , 0x08 , 0x09, 0x0A , // 0x0B , 0x0C , 0x0D , 0x0E , 0x0F , 0x10 , 0x11 , 0x12, 0x13 , // 0x14 , 0x15 , 0x16 , 0x17 , 0x18 , 0x19 , 0x1A , 0x1B, 0x1C , // 0x1D , 0x1E , 0x1F , 0x7F} ; // //// char ChFilename[MAX_CHFILE_NAME]; // //INT8U Handle = sizeof(ChInfo_T)-sizeof(ChannelInfo_T); // // // Check for Reserved bits // if(pSetUserNameReq->UserID & (BIT7 | BIT6) || (pSetUserNameReq->UserID == 0x00)) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(*pRes); // } // // /*User Id exceeded the limit or Cant set NULL User */ // if (pSetUserNameReq->UserID > pBMCInfo->IpmiConfig.MaxUsers ) // { // *pRes = CC_INV_DATA_FIELD ; // return sizeof (*pRes); // } // // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->ChUserMutex,WAIT_INFINITE); // pUserInfo = getUserIdInfo(pSetUserNameReq->UserID, BMCInst); // // /* If the user is fixed user */ // if (((pUserInfo != NULL) && (pUserInfo->FixedUser == TRUE))) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_INV_DATA_FIELD ; // return sizeof (*pRes); // } // // /* We should not set the NULL user */ // if(0== pSetUserNameReq->UserName [0] ) // { // printf("\n Setting the NULL user :%x",pSetUserNameReq->UserID); // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_INV_DATA_FIELD ; // return sizeof (*pRes); // } // // /* check for numeric first char and special chars */ // if( 0 != isdigit(pSetUserNameReq->UserName[0] ) ) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_INV_DATA_FIELD; // return sizeof(*pRes); // } // else // { // for(i=0;iUserName, sizeof(pSetUserNameReq->UserName)); // UserName[MAX_USERNAME_LEN] = '\0'; // if( NULL != strchr((const char *)UserName, InvalidChar[i] )) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_INV_DATA_FIELD; // return sizeof(*pRes); // } // } // } // // //Don't check duplicated user names for 0xFF, this request is for deleting user // if(0xFF != pSetUserNameReq->UserName [0]) // { // //checking for Duplicate user names // if(CheckForDuplicateUsers(pSetUserNameReq->UserName,BMCInst)==FALSE) // { // //setting user's name with same name // if(!strncmp((char *)pUserInfo->UserName,(char *)pSetUserNameReq->UserName, MAX_USERNAME_LEN)) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_NORMAL; // return sizeof (*pRes); // } // TINFO("Duplicate ipmi user!!\n"); // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // } // //checking for reserved user names // if(CheckForReservedUsers((char *)pSetUserNameReq->UserName) != 0) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // // /* Add to Linux data base */ // //Err = 0; // // /* If User[0] is 0xFF means the user is requested to delete */ // if ((0xFF == pSetUserNameReq->UserName [0]) || // (0 == pSetUserNameReq->UserName [0] )) // { // if ((0 == pUserInfo->CurrentSession) && (0 != disableUser (pSetUserNameReq->UserID,BMCInst))) // { // /* Delete this user form all the channel */ // for (Ch = 0; Ch < MAX_NUM_CHANNELS; Ch++) // { // if(pBMCInfo->ChConfig[Ch].ChType != 0xff) // { // pChannelInfo = (ChannelInfo_T*)&pBMCInfo->ChConfig[Ch].ChannelInfo; // } // else // { // continue; // } // // pNvrChInfo = GetNVRChConfigs(pChannelInfo,BMCInst); // pNVRChUserInfo = GetNVRChUserConfigs(pChannelInfo,BMCInst); // // pChUserInfo = getChUserIdInfo(pSetUserNameReq->UserID, &Index, pChannelInfo->ChannelUserInfo,BMCInst); // // if (pChUserInfo != NULL) // { // ModifyUsrGrp((char *)pUserInfo->UserName,pChannelInfo->ChannelNumber,pChUserInfo->AccessLimit,IGNORE_ADD_OR_REMOVE); // AddIPMIUsrtoShellGrp((char *)pUserInfo->UserName, pUserInfo->UserShell, IGNORE_ADD_OR_REMOVE_SHELL); // AddIPMIUsrtoFlagsGrp((char *)pUserInfo->UserName,pUserInfo->ExtendedPrivilege,IGNORE_ADD_OR_REMOVE); // pNVRChUserInfo[Index].UserId = 0; // pNVRChUserInfo[Index].IPMIMessaging=FALSE; // pNVRChUserInfo[Index].ActivatingSOL=FALSE; // pNVRChUserInfo[Index].ID=0; // pChUserInfo->ID=0; // pChUserInfo->UserId = 0; // pChUserInfo->IPMIMessaging=FALSE; // pChUserInfo->ActivatingSOL=FALSE; // if( pUserInfo->UserStatus == TRUE) // { // pChannelInfo->NoCurrentUser--; // pNvrChInfo->NoCurrentUser--; // } // FlushChConfigs((INT8U*)pNvrChInfo,pNvrChInfo->ChannelNumber,BMCInst); // } // else // { // if(pUserInfo != NULL) // DeleteUsrFromIPMIGrp((char *)pUserInfo->UserName); // } // } // // /* Checking for valid user, empty users doesnt conatain user directories*/ // if (USER_ID == pUserInfo->ID) // { // //removing the user directory created in add user // if(RemoveUsrDir((char *)pUserInfo->UserName)!=0) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_UNSPECIFIED_ERR; // return sizeof (*pRes); // } // } // /* Delete the user both in Volatile & Non Volatile memory*/ // pBMCInfo->GenConfig.CurrentNoUser--; // _fmemset (pUserInfo, 0, sizeof (UserInfo_T)); // FlushIPMI((INT8U*)&pBMCInfo->UserInfo[0],(INT8U*)&pBMCInfo->UserInfo[0],pBMCInfo->IPMIConfLoc.UserInfoAddr, // sizeof(UserInfo_T)*MAX_USER_CFG_MDS,BMCInst); // } // else // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_INV_DATA_FIELD ; // return sizeof (*pRes); // } // } // else if (USER_ID != pUserInfo->ID)//adding users // { // for (i = 0; i < MAX_USERNAME_LEN; i++) // { // if(!(isascii(pSetUserNameReq->UserName[i]))) // { // *pRes = CC_INV_DATA_FIELD ; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // return sizeof (*pRes); // } // } // /* If First time-if user ID does not exist */ // /* if the user name is set for the first time */ // pUserInfo->ID = USER_ID; // pUserInfo->UserId = pSetUserNameReq->UserID; // /* allow for IPMI Mesaging */ // pUserInfo->UserStatus = FALSE; // /* set default max session */ // pUserInfo->MaxSession = pBMCInfo->IpmiConfig.MaxSession; // // pBMCInfo->GenConfig.CurrentNoUser++; // for (Ch = 0; Ch < MAX_NUM_CHANNELS; Ch++) // { // if((Chtype = IsChannelSuppGroups(Ch,BMCInst)) == 0) // continue; // AddUsrtoIPMIGrp((char *)pSetUserNameReq->UserName,Chtype); // ModifyUsrGrp((char *)pSetUserNameReq->UserName,Ch,IGNORE_ADD_OR_REMOVE,PRIV_LEVEL_NO_ACCESS); // } // AddIPMIUsrtoShellGrp((char *)pSetUserNameReq->UserName, IGNORE_ADD_OR_REMOVE_SHELL, pUserInfo->UserShell); // AddIPMIUsrtoFlagsGrp((char *)pSetUserNameReq->UserName, IGNORE_ADD_OR_REMOVE, pUserInfo->ExtendedPrivilege); // //creating ssh directorys for new user // if( CreateSSHUserDir((char *)pSetUserNameReq->UserName) != 0) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_UNSPECIFIED_ERR; // return sizeof (*pRes); // } // //creating authentication key for new user // if (CreateSSHAuthKeyFile((char *)pSetUserNameReq->UserName)!= 0) // { // *pRes = CC_UNSPECIFIED_ERR; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // return sizeof (*pRes); // } // TINFO("user folders created successfuy----\n"); // // } // else if (USER_ID == pUserInfo->ID)//modifying users // { // for (i = 0; i < MAX_USERNAME_LEN; i++) // { // if(!(isascii(pSetUserNameReq->UserName[i]))) // { // *pRes = CC_INV_DATA_FIELD ; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // return sizeof (*pRes); // } // } // /* If user name isn't set before we create a folder */ // if( 0 == pUserInfo->UserName[0] ) // { // CreateSSHUserDir((char *)pSetUserNameReq->UserName); // } // else // { // RenameUserDir((char *)pUserInfo->UserName, (char *)pSetUserNameReq->UserName); // } // // for (Ch = 0; Ch < MAX_NUM_CHANNELS; Ch++) // { // if((Chtype = IsChannelSuppGroups(Ch,BMCInst)) == 0) // { // continue; // } // AddUsrtoIPMIGrp((char *)pSetUserNameReq->UserName,Chtype); // pChannelInfo = getChannelInfo (Ch, BMCInst); // if(NULL == pChannelInfo) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // pChUserInfo = getChUserIdInfo(pSetUserNameReq->UserID, &Index, pChannelInfo->ChannelUserInfo,BMCInst); // if (pChUserInfo != NULL) // { // ModifyUsrGrp((char *)pUserInfo->UserName, pChannelInfo->ChannelNumber, pChUserInfo->AccessLimit, IGNORE_ADD_OR_REMOVE);//Remove User // ModifyUsrGrp((char *)pSetUserNameReq->UserName, pChannelInfo->ChannelNumber, IGNORE_ADD_OR_REMOVE, pChUserInfo->AccessLimit);//add user // } // else // { // ModifyUsrGrp((char *)pUserInfo->UserName, Ch,PRIV_LEVEL_NO_ACCESS, IGNORE_ADD_OR_REMOVE);//Remove User // ModifyUsrGrp((char *)pSetUserNameReq->UserName, Ch, IGNORE_ADD_OR_REMOVE, PRIV_LEVEL_NO_ACCESS);//add user // } // } // AddIPMIUsrtoShellGrp((char *)pUserInfo->UserName, pUserInfo->UserShell, IGNORE_ADD_OR_REMOVE_SHELL);//Remove User from Shell Group // AddIPMIUsrtoShellGrp((char *)pSetUserNameReq->UserName, IGNORE_ADD_OR_REMOVE_SHELL, pUserInfo->UserShell);//Add User in Shell Group // AddIPMIUsrtoFlagsGrp((char *)pUserInfo->UserName, pUserInfo->ExtendedPrivilege, IGNORE_ADD_OR_REMOVE);//Remove User from Flags Group // AddIPMIUsrtoFlagsGrp((char *)pSetUserNameReq->UserName, IGNORE_ADD_OR_REMOVE, pUserInfo->ExtendedPrivilege);//Add User in Flags Group // } // _fmemcpy (pUserInfo->UserName, pSetUserNameReq->UserName, MAX_USERNAME_LEN); // // FlushIPMI((INT8U*)&pBMCInfo->UserInfo[0],(INT8U*)&pBMCInfo->UserInfo[0],pBMCInfo->IPMIConfLoc.UserInfoAddr, // sizeof(UserInfo_T)*MAX_USER_CFG_MDS,BMCInst); // FlushIPMI((INT8U*)&pBMCInfo->GenConfig,(INT8U*)&pBMCInfo->GenConfig,pBMCInfo->IPMIConfLoc.GenConfigAddr, // sizeof(GENConfig_T),BMCInst); // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_NORMAL; // return sizeof (*pRes); } /*--------------------------------------- * GetUserName *---------------------------------------*/ int GetUserName (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ GetUserNameReq_T* pGetUserNameReq = (_NEAR_ GetUserNameReq_T*)pReq; // _NEAR_ GetUserNameRes_T* pGetUserNameRes = (_NEAR_ GetUserNameRes_T*)pRes; // _FAR_ UserInfo_T* pUserInfo; // _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo;//[BMCInst]; // //INT16S Err; // // // Check for Reserved bits // if(pGetUserNameReq->UserID & (BIT7 | BIT6) || (pGetUserNameReq->UserID == 0x00)) // { // pGetUserNameRes->CompletionCode = CC_INV_DATA_FIELD ; // return sizeof(*pRes); // } // // if (pGetUserNameReq->UserID > pBMCInfo->IpmiConfig.MaxUsers) // { // /* if user ID exceeded the Max limit */ // pGetUserNameRes->CompletionCode = CC_INV_DATA_FIELD ; // return sizeof (*pRes);/* Invalied user id */ // } // // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->ChUserMutex,WAIT_INFINITE); // pUserInfo = getUserIdInfo(pGetUserNameReq->UserID, BMCInst); // // /* if User is disabled or if User is not created */ // // //if user is disabled we dont have to return invalid data field // //instead we return everything possible about the user // // if pUserInfo is NULL then nothing in the structure at all // // pUserInfo being NULL is probably not possible // // If the signature doesnt match then the useris not yet configured // // so reasonable to return an error // if ((NULL == pUserInfo) || (pUserInfo->ID != USER_ID)) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // /* User with given ID is disabled */ // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // //if we are here then the user is just disabled // if(FALSE == pUserInfo->UserStatus) // { // TDBG("user is just dissabled\n"); // //user is just disabled!! // } // // //Err = 0; // pGetUserNameRes->CompletionCode = CC_NORMAL; // _fmemcpy (pGetUserNameRes->UserName, pUserInfo->UserName, MAX_USERNAME_LEN); // // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // // return sizeof (GetUserNameRes_T); } /*--------------------------------------- * SetUserPassword *---------------------------------------*/ int SetUserPassword (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ SetUserPswdReq_T* pSetUserPswdReq = (_NEAR_ SetUserPswdReq_T*)pReq; // _FAR_ UserInfo_T* pUserInfo; // _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo;//[BMCInst]; // INT8U UserId=0, Operation; // INT8U UserPswd[MAX_PASSWD_LEN]; // INT8S EncryptedUserPswd[MAX_ENCRYPTED_PSWD_LEN] = {0}; // INT8U PwdEncKey[MAX_SIZE_KEY + 1] = {0}; // INT8U i; // INT8U UserPassword[ MAX_PASSWORD_LEN + 1 ]; // INT8U InvalidChar[] = { 0x01 , 0x02 , 0x03 , 0x04 ,0x05 , 0x06 , 0x07 , 0x08 , 0x09 , 0x0A, // 0x0B , 0x0C , 0x0D , 0x0E , 0x0F , 0x10 , 0x11 , 0x12 , 0x13 , 0x14, // 0x15 , 0x16 , 0x17 , 0x18 , 0x19 , 0x1A , 0x1B , 0x1C , 0x1D , 0x1E , // 0x1F , 0x7F }; // // // Operation = pSetUserPswdReq->Operation & 0x03; // UserId = pSetUserPswdReq->UserID & 0x3F; // // if ((((pSetUserPswdReq->UserID & TWENTY_BYTE_PWD) == 0) && (ReqLen != IPMI_15_PASSWORD_LEN)) // ||(((pSetUserPswdReq->UserID & TWENTY_BYTE_PWD) == TWENTY_BYTE_PWD) && (ReqLen != IPMI_20_PASSWORD_LEN))) // { // /* For enable or disable using the password field is optional */ // if (ReqLen == OP_USERID_ONLY_LENGTH) // { // if ((Operation != OP_ENABLE_USER_ID) && (Operation != OP_DISABLE_USER_ID)) // { // *pRes = CC_REQ_INV_LEN; // return sizeof (*pRes); //Invalid operation. // } // } // else // { // *pRes = CC_REQ_INV_LEN; // return sizeof (*pRes); //password len invalid // } // } // // /* Reserved bits checking */ // if((pSetUserPswdReq->UserID & BIT6) || (UserId == 0) || (pSetUserPswdReq->Operation & (BIT7 | BIT6 | BIT5 | BIT4 | BIT3 | BIT2))) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // if (ReqLen == IPMI_15_PASSWORD_LEN) // { // _fmemset (pSetUserPswdReq->Password + 16, 0, 4); // } // ReqLen -=2; // // if (UserId > pBMCInfo->IpmiConfig.MaxUsers) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); /*User Id exceeded the limit*/ // } // // OS_THREAD_MUTEX_ACQUIRE(&pBMCInfo->ChUserMutex,WAIT_INFINITE); // pUserInfo = getUserIdInfo (UserId, BMCInst); // // if ( NULL == pUserInfo ) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // IPMI_WARNING ("Invalid User Id \n"); // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // TDBG("pUserInfo is %p\n",pUserInfo); // // *pRes = CC_NORMAL; // // switch (Operation) // { // // case DISABLE_USER: // TDBG("In disable user for user id %d\n",UserId); // /*disable user */ // if(pUserInfo == NULL) // { // //the user is already disabled!! // //no point in disabling him again // } // else if(disableUser(UserId, BMCInst) == 0) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // //we cannot disable this user because he is the only user in the channel // TDBG("not disabling user\n"); // /* cannot disable user since this user is the only user in the channel*/ // *pRes = CC_SETPASSWORD_CANNOT_DISABLE_USER; // return sizeof (*pRes); // } // else // { // //here we can disable the user // // TDBG("will disable user\n"); // // if (pUserInfo->UserStatus == TRUE) // { // pBMCInfo->GenConfig.CurrentNoUser--; // UpdateCurrentEnabledUserCount(COUNT_DECREASE, BMCInst); // } // // pUserInfo->UserStatus = FALSE; // // //when user is disabled ".ssh" folder of the user is renamed to restrict user login // TDBG("renaming the .ssh folder to _.ssh\n"); // if(RenameUserSSHDir((char *)pUserInfo->UserName)!=0) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_UNSPECIFIED_ERR; // return sizeof (*pRes); // } // } // // break; // // case ENABLE_USER: // /*enable user */ // if (USER_ID == pUserInfo->ID) // { // /* if for the first time then Increment the Current user No */ // if ( pUserInfo->UserStatus == FALSE ) // { // pBMCInfo->GenConfig.CurrentNoUser++; // UpdateCurrentEnabledUserCount(COUNT_INCREASE, BMCInst); // } // pUserInfo->UserStatus = TRUE; // // //when user is enabled the pub key is restored to original name to allow login // TDBG("restoring the ._ssh folder to .ssh\n"); // if( RestoreUsrSSHDir((char *)pUserInfo->UserName)!=0) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_UNSPECIFIED_ERR; // return sizeof (*pRes); // } // if (0 == pUserInfo->UserName [0]) // { // TDBG ("The user Name is Not yet set.. So No synching with the linux \n"); // *pRes = CC_NORMAL; // FlushIPMI((INT8U*)&pBMCInfo->UserInfo[0],(INT8U*)&pBMCInfo->UserInfo[0],pBMCInfo->IPMIConfLoc.UserInfoAddr, // sizeof(UserInfo_T)*MAX_USER_CFG_MDS,BMCInst); // FlushIPMI((INT8U*)&pBMCInfo->GenConfig,(INT8U*)&pBMCInfo->GenConfig,pBMCInfo->IPMIConfLoc.GenConfigAddr, // sizeof(GENConfig_T),BMCInst); // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // return sizeof (*pRes); // } // TDBG ("Synching with the Linux User dataBase \n"); // } // else // { // /* Looks like the User info is not there So just enable the user in the IPMI */ // /* no need to Ssync with the linux databse since there will b No corresponding user in the linux database */ // TCRIT("Enable user called on a not yet enabled user!!\n"); // /* If First time-if user ID does not exist */ // /* if the user is enabled for the first time */ // pUserInfo->ID = USER_ID; // pUserInfo->UserId = UserId; // pUserInfo->UserStatus = TRUE; // pUserInfo->MaxSession = pBMCInfo->IpmiConfig.MaxSession; // // pBMCInfo->GenConfig.CurrentNoUser++; // UpdateCurrentEnabledUserCount(COUNT_INCREASE, BMCInst); // // //when user is enabled the pub key is restored to original name to allow login // TDBG("restoring the ._ssh folder to .ssh\n"); // if(RestoreUsrSSHDir((char *)pUserInfo->UserName)!=0) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_UNSPECIFIED_ERR; // return sizeof (*pRes); // } // memset(pUserInfo->UserName, 0, MAX_USERNAME_LEN); // /* If user name isn't set before we save the configuration */ // FlushIPMI((INT8U*)&pBMCInfo->UserInfo[0], (INT8U*)&pBMCInfo->UserInfo[0], pBMCInfo->IPMIConfLoc.UserInfoAddr, // sizeof(UserInfo_T)*MAX_USER_CFG_MDS, BMCInst); // FlushIPMI((INT8U*)&pBMCInfo->GenConfig, (INT8U*)&pBMCInfo->GenConfig, pBMCInfo->IPMIConfLoc.GenConfigAddr, // sizeof(GENConfig_T), BMCInst); // *pRes = CC_NORMAL; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // return sizeof (*pRes); // } // break; // // case SET_PASSWORD: // /*set password */ // if (USER_ID == pUserInfo->ID) // { // /*check for special characters*/ // for( i = 0 ; i < sizeof(InvalidChar) ; i++ ) // { // strncpy((char *)UserPassword,(const char *) pSetUserPswdReq->Password, sizeof(pSetUserPswdReq->Password)); // UserPassword[MAX_PASSWORD_LEN] = '\0'; // if( NULL != strchr((const char *)UserPassword, InvalidChar[i] )) // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_INV_DATA_FIELD; // return sizeof(*pRes); // } // } // // pUserInfo->MaxPasswordSize = ReqLen; // if (g_corefeatures.userpswd_encryption == ENABLED) // { // /* Get Encryption Key from the MBMCInfo_t structure */ // memcpy(PwdEncKey, &(g_MBMCInfo.PwdEncKey), MAX_SIZE_KEY); // // if(EncryptPassword((INT8S *)pSetUserPswdReq->Password, MAX_PASSWORD_LEN, EncryptedUserPswd, MAX_PASSWORD_LEN, PwdEncKey)) // { // TCRIT("Error in encrypting the IPMI User Password for user ID:%d\n", pSetUserPswdReq->UserID); // *pRes = CC_UNSPECIFIED_ERR; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // return sizeof(INT8U); // } // memset(&(pBMCInfo->EncryptedUserInfo[UserId - 1].EncryptedPswd), 0, MAX_ENCRYPTED_PSWD_LEN); // memcpy(&(pBMCInfo->EncryptedUserInfo[UserId - 1].EncryptedPswd), EncryptedUserPswd, MAX_ENCRYPTED_PSWD_LEN); // memcpy(pBMCInfo->UserInfo[UserId - 1].UserPassword, "$ENCRYPTED$", 11); // } // else // { // _fmemcpy (pUserInfo->UserPassword, pSetUserPswdReq->Password, MAX_PASSWORD_LEN); // } // if(ENABLED != g_corefeatures.disable_empty_passwd_login) // { // TDBG("\nSet User Password .Password is configured succussfully...\n"); // pUserInfo->UserPasswdConfigured = 1; // } // } // else // { // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // break; // // case TEST_PASSWORD: // if (g_corefeatures.userpswd_encryption == ENABLED) // { // /* Get Encryption Key from the MBMCInfo_t structure */ // memcpy(PwdEncKey, &(g_MBMCInfo.PwdEncKey), MAX_SIZE_KEY); // // if(DecryptPassword((INT8S *)(pBMCInfo->EncryptedUserInfo[UserId - 1].EncryptedPswd), MAX_PASSWORD_LEN, (char *)UserPswd, MAX_PASSWORD_LEN, PwdEncKey)) // { // TCRIT("Error in Decrypting IPMI User Password for user with ID:%d\n", UserId); // *pRes = CC_UNSPECIFIED_ERR; // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // return sizeof(*pRes); // } // } // else // { // _fmemcpy (UserPswd, pUserInfo->UserPassword, MAX_PASSWORD_LEN); // } // /*Test Password */ // if( ReqLen != pUserInfo->MaxPasswordSize && (pUserInfo->MaxPasswordSize != 0)) // { // *pRes = CC_PASSWORD_TEST_FAILED_WRONG_SIZE; // } // else if (((FALSE == pUserInfo->UserStatus) && (pUserInfo->ID != USER_ID)) || // (0 != _fmemcmp (UserPswd, pSetUserPswdReq->Password, MAX_PASSWORD_LEN))) // { // *pRes = CC_PASSWORD_TEST_FAILED; // } // // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // return sizeof (*pRes); // break; // } // // FlushIPMI((INT8U*)&pBMCInfo->UserInfo[0],(INT8U*)&pBMCInfo->UserInfo[0],pBMCInfo->IPMIConfLoc.UserInfoAddr, // sizeof(UserInfo_T)*MAX_USER_CFG_MDS,BMCInst); // FlushIPMI((INT8U*)&pBMCInfo->GenConfig,(INT8U*)&pBMCInfo->GenConfig,pBMCInfo->IPMIConfLoc.GenConfigAddr, // sizeof(GENConfig_T),BMCInst); // FlushIPMI((INT8U*)&pBMCInfo->EncryptedUserInfo[0], (INT8U*)&pBMCInfo->EncryptedUserInfo[0], pBMCInfo->IPMIConfLoc.EncUserPasswdAddr, // sizeof(EncryptedUserInfo_T) * MAX_USER_CFG_MDS, BMCInst); // OS_THREAD_MUTEX_RELEASE(&pBMCInfo->ChUserMutex); // return sizeof (*pRes); } /*--------------------------------------- * MasterWriteRead *---------------------------------------*/ int MasterWriteRead (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ MasterWriteReadReq_T* pMasterWriteReadReq = (_NEAR_ MasterWriteReadReq_T*)pReq; // _NEAR_ MasterWriteReadRes_T* pMasterWriteReadRes = (_NEAR_ MasterWriteReadRes_T*)pRes; // _FAR_ BMCInfo_t* pBMCInfo = &g_BMCInfo;//[BMCInst]; // _NEAR_ INT8U* OutBuffer; // _NEAR_ INT8U* InBuffer; // INT8U ChannelNum, BusID, BusType, SlaveAddr, ReadCount, WriteCount; // INT8S BusName[64]; // int retval = 0; // INT8U OrgReadCount; // INT8U I2CBusId=0; // INT8U DevID = 0; // This will be '0' by Default... /dev/peci0 // INT8U Target = 0x30; // This is the Client address. 30h = 48 is Default for CPU0 // INT8U Domain = 0; // Multi-Domain support. Default is '0' // INT8U Xmit_Feedback = 0; // If full response is Desired, enable this. Default is '1' // INT8U AWFCS = 0; // Enable AWFCS in the Transmitted packet by Hw. Default is '0' // INT8U Read_Len = 0; // Number of bytes of read back Data from PECI Client // INT8U Write_Len = 0; // Number of bytes of data, host is sending to client // INT8U *Write_Data = NULL; // Pointer to the Data sent by User to the PECI Client // INT8U *Read_Data = NULL; // Pointer to the Data received from PECI Client to be sent to user // int ret_val = 0; // // if(pMasterWriteReadReq->SlaveAddress & BIT0) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // ReadCount = pMasterWriteReadReq->ReadCount; // ChannelNum = GetBits (pMasterWriteReadReq->BusTypeChNo, 0xF0); // BusID = GetBits (pMasterWriteReadReq->BusTypeChNo, 0x0E); // BusType = GetBits (pMasterWriteReadReq->BusTypeChNo, 0x01); // SlaveAddr = (pMasterWriteReadReq->SlaveAddress >> 1); // // if ((BusType == 0x00 && BusID != 0x00) || ((BusType == 0x01) && (BusID == 0x00))) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // Command order: // // ipmitool -H -I lan -U -P bus=7 // // : Bus# must be 0x07 for comunicating with PECI over IPMI. Other buses are not for this feature // // : This is the PECI Client target address. // // : Number of bytes of data to read from the PECI Response // // : Number of bytes of data being written, as per the PECI Spec. Number of Bytes after Domain. // // : 0x01 or 0x00 indicates enabling or disabling of AWFCS feature respectively // // : 0x01 or 0x00 indicates domain=1 or domain=0 for multi-domain commands respectively // // : Rest of data like Command, and other params as per the PECI Spec. // // // If BusType is External (0x01) and BusID is 7, then we consider to communicate with PECI // // if(g_corefeatures.peci_over_ipmi == ENABLED ) // { // if ((BusType & 0x01) && (BusID == 0x07)) // { // DevID = 0; // Xmit_Feedback = 0; // Target = pMasterWriteReadReq->SlaveAddress; // Read_Len = ReadCount; // Write_Len = pMasterWriteReadReq->Data[0]; // AWFCS = pMasterWriteReadReq->Data[1]; // Domain = pMasterWriteReadReq->Data[2]; // Write_Data = &pMasterWriteReadReq->Data[3]; // Read_Data = &pMasterWriteReadRes->Data[0]; // // memset(&pMasterWriteReadRes->Data[0], 0, sizeof(pMasterWriteReadRes->Data)); // // // Call the PECI Generic Handler for passing the command to the PECI Controller // if(g_HALPECIHandle[HAL_PECI_COMMAND] != NULL) // { // ret_val = ((int(*)(char, char, char, char, char, char *, char, char *, char))g_HALPECIHandle[HAL_PECI_COMMAND]) (DevID, Target, // Domain, Xmit_Feedback, AWFCS, // (char *)Write_Data, Write_Len, // (char *)Read_Data, Read_Len ); // } // else // { // pMasterWriteReadRes->CompletionCode = CC_PARAM_NOT_SUP_IN_CUR_STATE; // return sizeof (*pRes); // } // // /* Check if peci issue command operation is success or not */ // if (ret_val == -1) // { // pMasterWriteReadRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // // pMasterWriteReadRes->CompletionCode = CC_NORMAL; // // return (sizeof (*pRes) + ReadCount); // } // } // // if(0 ==BusType){ // if(PRIMARY_IPMB_CHANNEL == ChannelNum) // { // I2CBusId=pBMCInfo->IpmiConfig.PrimaryIPMBBusNumber; // } // else if((pBMCInfo->IpmiConfig.SecondaryIPMBSupport == 0x01)&&(pBMCInfo->SecondaryIPMBCh == ChannelNum)) // { // I2CBusId=pBMCInfo->IpmiConfig.SecondaryIPMBBusNumber; // }else{ // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // } // } // else // { // if(BusID==pBMCInfo->IpmiConfig.PrimaryIPMBBusNumber) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // }else if((pBMCInfo->IpmiConfig.SecondaryIPMBSupport == 0x01)&&(BusID==pBMCInfo->IpmiConfig.SecondaryIPMBBusNumber)) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof (*pRes); // }else{ // I2CBusId=BusID; // } // } // // if (ReqLen < 3) // { // *pRes = CC_REQ_INV_LEN; // return sizeof (*pRes); // } // // /* number of bytes to write // * = pMasterWriteReadReq length - 3 for Request Data byte - // * BusTypeChNo,SlaveAddr,Readcount + 1 byte for address // */ // WriteCount = ReqLen - 3; // // OutBuffer = (pMasterWriteReadReq->Data); // InBuffer = pMasterWriteReadRes->Data; // sprintf(BusName,"/dev/i2c%d",I2CBusId); // // // Save original ReadCount in case we need to modify it // OrgReadCount = ReadCount; // // // If both ReadCount and WriteCount are zero, then force a read of 1 byte. // // If we do not do this, the write command will fail. // // Having both counts 0 is a way of "pinging" the given device to see if it // // is responding to its address. // // if (ReadCount == 0 && WriteCount == 0) // { // ReadCount = 1; // } // // if (ReadCount > 0 && WriteCount == 0) // { // if(g_HALI2CHandle[HAL_I2C_MR] != NULL) // { // retval = ((int(*)(char *,u8,u8 *,size_t))g_HALI2CHandle[HAL_I2C_MR]) (BusName, SlaveAddr, InBuffer, ReadCount); // if (retval < 0) // { // pMasterWriteReadRes->CompletionCode = (retval & MASTER_RW_ERRCODE); // return sizeof (*pRes); // } // } // else // { // pMasterWriteReadRes->CompletionCode = CC_PARAM_NOT_SUP_IN_CUR_STATE; // return sizeof(*pRes); // } // // ReadCount = OrgReadCount; // // /* copy the bytes read to Response Data */ // _fmemcpy (pMasterWriteReadRes->Data, InBuffer, ReadCount); // } // else if(ReadCount > 0 && WriteCount > 0 ) // { // if(g_HALI2CHandle[HAL_I2C_RW] != NULL) // { // retval = ((int(*)(char *,u8,u8 *,u8 *,size_t,size_t))g_HALI2CHandle[HAL_I2C_RW]) (BusName, SlaveAddr, OutBuffer, InBuffer, WriteCount, ReadCount); // if (retval < 0) // { // pMasterWriteReadRes->CompletionCode = (retval & MASTER_RW_ERRCODE); // return sizeof (*pRes); // } // } // else // { // pMasterWriteReadRes->CompletionCode = CC_PARAM_NOT_SUP_IN_CUR_STATE; // return sizeof(*pRes); // } // // ReadCount = OrgReadCount; // // /* copy the bytes read to Response Data */ // _fmemcpy (pMasterWriteReadRes->Data, InBuffer, ReadCount); // } // else // { // /* No data to read so use master write instead, // * otherwise some devices (EEPROM) that have not finished writing // * will fail on the read transaction and possibly corrupt data // */ // if(g_HALI2CHandle[HAL_I2C_MW] != NULL) // { // retval= ((ssize_t(*)(char *,u8,u8 *,size_t))g_HALI2CHandle[HAL_I2C_MW]) (BusName, SlaveAddr, OutBuffer, WriteCount); // if(retval < 0) // { // pMasterWriteReadRes->CompletionCode = (retval & MASTER_RW_ERRCODE); // return sizeof (*pRes); // } // } // else // { // pMasterWriteReadRes->CompletionCode = CC_PARAM_NOT_SUP_IN_CUR_STATE; // return sizeof(*pRes); // } // } // // pMasterWriteReadRes->CompletionCode = CC_NORMAL; // // return (sizeof (*pRes) + ReadCount); } //#if 0 /*------------------------------------------- * ComputeAuthCode *-------------------------------------------*/ void ComputeAuthCode (_FAR_ INT8U* pPassword, _NEAR_ SessionHdr_T* pSessionHdr, _NEAR_ IPMIMsgHdr_T* pIPMIMsg, _NEAR_ INT8U* pAuthCode, INT8U ChannelType) { // if (AUTH_TYPE_PASSWORD == pSessionHdr->AuthType) // { // _fmemcpy (pAuthCode, pPassword, MAX_PASSWORD_LEN); // } // else // { // INT8U AuthBuf [MAX_AUTH_PARAM_SIZE]; // INT16U AuthBufLen = 0; // INT8U IPMIMsgLen = *((_NEAR_ INT8U*) pIPMIMsg - 1); // // /* Password */ // _fmemcpy (AuthBuf, pPassword, MAX_PASSWORD_LEN); // AuthBufLen += MAX_PASSWORD_LEN; // /* Session ID */ // _fmemcpy (AuthBuf + AuthBufLen, &pSessionHdr->SessionID, sizeof (INT32U)); // AuthBufLen += sizeof (INT32U); // /* IPMI Response Message */ // _fmemcpy (AuthBuf + AuthBufLen, pIPMIMsg, IPMIMsgLen); // AuthBufLen += IPMIMsgLen; // // if (ChannelType == MULTI_SESSION_CHANNEL) // { // /* Session Sequence Number */ // _fmemcpy (AuthBuf + AuthBufLen, // &pSessionHdr->SessionSeqNum, sizeof (INT32U)); // AuthBufLen += sizeof (INT32U); // } // /* Password */ // _fmemcpy (AuthBuf + AuthBufLen, pPassword, MAX_PASSWORD_LEN); // AuthBufLen += MAX_PASSWORD_LEN; // // switch (pSessionHdr->AuthType) // { // case AUTH_TYPE_MD2 : // AuthCodeCalMD2 (AuthBuf, pAuthCode, AuthBufLen); // break; // // case AUTH_TYPE_MD5 : // AuthCodeCalMD5 (AuthBuf, pAuthCode, AuthBufLen); // break; // // default : // TDBG ("RMCP: Invalid Authentication Type \n"); // } // } } //#endif /*--------------------------------------- * GetSystemInfoParam *---------------------------------------*/ int GetSystemInfoParam (_NEAR_ INT8U* pReq, INT8U ReqLen, _NEAR_ INT8U* pRes,_NEAR_ int BMCInst) { // _NEAR_ GetSystemInfoParamReq_T* pGetSysInfoReq = (_NEAR_ GetSystemInfoParamReq_T*)pReq; // _NEAR_ GetSystemInfoParamRes_T* pGetSysInfoRes = ( _NEAR_ GetSystemInfoParamRes_T* ) pRes ; // _NEAR_ GetSystemInfoParamOEMRes_T* pGetSysInfoOEMRes = ( _NEAR_ GetSystemInfoParamOEMRes_T* ) pRes ; // BMCInfo_t *pBMCInfo = &g_BMCInfo;//[BMCInst]; // _FAR_ SystemInfoConfig_T* pSysInfoCfg; // INT8U resSize = sizeof(pGetSysInfoRes->CompletionCode) + sizeof(pGetSysInfoRes->ParamRevision); // INT8U oem_len; // unsigned long oem_addr; // // // Check for Reserved bits // if(pGetSysInfoReq->ParamRev & (BIT6 | BIT5 | BIT4 | BIT3 | BIT2 | BIT1 | BIT0)) // { // pGetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pGetSysInfoRes->CompletionCode); // } // // pGetSysInfoRes->CompletionCode = CC_NORMAL; // // /* Fill the param's older Version and the present version */ // pGetSysInfoRes->ParamRevision = ((PARAM_OLDER_REVISION << 4) & 0xF0 ) | PARAM_PRESENT_REVISION; // // /* Check for Revision only parameter */ // if (pGetSysInfoReq->ParamRev & GET_PARAM_REV_ONLY ) // { // if((MAX_APP_CONF_PARAM >= pGetSysInfoReq->ParamSelector)) // { // return resSize; // } // else if(( NULL != g_PDKHandle[PDK_GETSYSINFOPARAM]) && // ((MIN_SYSINFO_OEM_CONF_PARAM <= pGetSysInfoReq->ParamSelector) && (MAX_SYSINFO_OEM_CONF_PARAM >= pGetSysInfoReq->ParamSelector))) // { // oem_len = ((int(*)(INT8U, unsigned long*,int))(g_PDKHandle[PDK_GETSYSINFOPARAM]))(pGetSysInfoReq->ParamSelector, &oem_addr ,BMCInst); // if( oem_len == 0) // { // pGetSysInfoRes->CompletionCode = CC_SYS_INFO_PARAM_NOT_SUPPORTED; // return sizeof(INT8U); // } // else // return resSize; // } // else // { // *pRes = CC_PARAM_NOT_SUPPORTED; // return sizeof (*pRes); // } // } // // /* Get Systen Info parameters from NVRAM */ // pSysInfoCfg = &pBMCInfo->SystemInfoConfig; // // switch(pGetSysInfoReq->ParamSelector) // { // case SET_IN_PROGRESS_PARAM: /*Parameter 0 volatile*/ // if( (0x00 != pGetSysInfoReq->SetSelector) || (0x00 != pGetSysInfoReq->BlockSelector) ) // { // pGetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pGetSysInfoRes->CompletionCode); // } // // LOCK_BMC_SHARED_MEM(BMCInst); // pGetSysInfoRes->SysInfo.SetInProgress = BMC_GET_SHARED_MEM(BMCInst)->m_Sys_SetInProgress; // UNLOCK_BMC_SHARED_MEM(BMCInst); // resSize++; // break; // // case SYS_FW_VERSION_PARAM: // _fmemset(&pGetSysInfoRes->SysInfo.SysVerInfo,0,sizeof(SysVerInfo_T)); // if((pGetSysInfoReq->SetSelector >= MAX_BLOCK_SIZE)|| (0x00 != pGetSysInfoReq->BlockSelector)) // { // pGetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pGetSysInfoRes->CompletionCode); // } // // pGetSysInfoRes->SysInfo.SysVerInfo.SetSelector = pGetSysInfoReq->SetSelector; // resSize++; // if(pGetSysInfoReq->SetSelector==ZERO_SETSELECTOR) // { // pGetSysInfoRes->SysInfo.SysVerInfo.SysFWVersion[0]=pSysInfoCfg->SysFWVersion.TypeOfEncoding; // pGetSysInfoRes->SysInfo.SysVerInfo.SysFWVersion[1]=pSysInfoCfg->SysFWVersion.StringLength; // _fmemcpy(&pGetSysInfoRes->SysInfo.SysVerInfo.SysFWVersion[2], pSysInfoCfg->SysFWVersion.SysFWVersionName,MAX_STRING_LENGTH_COPY); // resSize += MAX_BLOCK_SIZE; // } // else // { // _fmemcpy(&pGetSysInfoRes->SysInfo.SysVerInfo.SysFWVersion[0], // &pSysInfoCfg->SysFWVersion.SysFWVersionName[(pGetSysInfoReq->SetSelector * MAX_BLOCK_SIZE) - 2],MAX_BLOCK_SIZE); // resSize += MAX_BLOCK_SIZE; // } // break; // // case SYS_NAME_PARAM: // if((pGetSysInfoReq->SetSelector >= MAX_BLOCK_SIZE)|| (0x00 != pGetSysInfoReq->BlockSelector)) // { // pGetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pGetSysInfoRes->CompletionCode); // } // // pGetSysInfoRes->SysInfo.SysNameInfo.SetSelector = pGetSysInfoReq->SetSelector; // resSize++; // if(pGetSysInfoReq->SetSelector==ZERO_SETSELECTOR) // { // pGetSysInfoRes->SysInfo.SysNameInfo.SysName[0]=pSysInfoCfg->SysName.TypeOfEncoding_Sys_Name; // pGetSysInfoRes->SysInfo.SysNameInfo.SysName[1]=pSysInfoCfg->SysName.StringLength_Sys_Name; // _fmemcpy(&pGetSysInfoRes->SysInfo.SysNameInfo.SysName[2],&pSysInfoCfg->SysName.SystemName,MAX_STRING_LENGTH_COPY); // resSize += MAX_BLOCK_SIZE; // } // else // { // _fmemcpy(&pGetSysInfoRes->SysInfo.SysNameInfo.SysName[0], // &pSysInfoCfg->SysName.SystemName[(pGetSysInfoReq->SetSelector * MAX_BLOCK_SIZE) - 2], MAX_BLOCK_SIZE); // resSize += MAX_BLOCK_SIZE; // } // break; // // case PRIM_OS_NAME_PARAM: // if((pGetSysInfoReq->SetSelector >= MAX_BLOCK_SIZE)|| (0x00 != pGetSysInfoReq->BlockSelector)) // { // pGetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pGetSysInfoRes->CompletionCode); // } // // pGetSysInfoRes->SysInfo.PrimOSInfo.SetSelector = pGetSysInfoReq->SetSelector; // resSize++; // if(pGetSysInfoReq->SetSelector==ZERO_SETSELECTOR) // { // pGetSysInfoRes->SysInfo.PrimOSInfo.PrimaryOSName[0]=pSysInfoCfg->PrimaryOSName.TypeOfEncoding_PrimaryOSName; // pGetSysInfoRes->SysInfo.PrimOSInfo.PrimaryOSName[1]=pSysInfoCfg->PrimaryOSName.StringLength_PrimaryOSName; // _fmemcpy(&pGetSysInfoRes->SysInfo.PrimOSInfo.PrimaryOSName[2], &pSysInfoCfg->PrimaryOSName.PrimaryOperatingSystemName, MAX_STRING_LENGTH_COPY); // resSize += MAX_BLOCK_SIZE; // } // else // { // _fmemcpy(&pGetSysInfoRes->SysInfo.PrimOSInfo.PrimaryOSName[0], // &pSysInfoCfg->PrimaryOSName.PrimaryOperatingSystemName[(pGetSysInfoReq->SetSelector * MAX_BLOCK_SIZE) - 2],MAX_BLOCK_SIZE); // resSize += MAX_BLOCK_SIZE; // } // break; // // case OS_NAME_PARAM: // /*Parameter 4 volatile*/ // _fmemset(&pGetSysInfoRes->SysInfo.OSInfo,0,sizeof(OSInfo_T)); // if((pGetSysInfoReq->SetSelector >= MAX_BLOCK_SIZE)||(0x00 != pGetSysInfoReq->BlockSelector)) // { // pGetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pGetSysInfoRes->CompletionCode); // } // pGetSysInfoRes->SysInfo.OSInfo.SetSelector = pGetSysInfoReq->SetSelector; // resSize++; // if(pGetSysInfoReq->SetSelector==ZERO_SETSELECTOR) // { // LOCK_BMC_SHARED_MEM(BMCInst); // pGetSysInfoRes->SysInfo.OSInfo.OperatingSystemName[0]=BMC_GET_SHARED_MEM(BMCInst)->OperatingSystemName.TypeOfEncoding_OSName; // pGetSysInfoRes->SysInfo.OSInfo.OperatingSystemName[1]=BMC_GET_SHARED_MEM(BMCInst)->OperatingSystemName.StringLength_OSName; // _fmemcpy(&pGetSysInfoRes->SysInfo.OSInfo.OperatingSystemName[2], BMC_GET_SHARED_MEM(BMCInst)->OperatingSystemName.OSName, MAX_STRING_LENGTH_COPY); // UNLOCK_BMC_SHARED_MEM(BMCInst); // resSize += MAX_BLOCK_SIZE; // } // else // { // LOCK_BMC_SHARED_MEM(BMCInst); // _fmemcpy(&pGetSysInfoRes->SysInfo.OSInfo.OperatingSystemName[0], // &BMC_GET_SHARED_MEM(BMCInst)->OperatingSystemName.OSName[(pGetSysInfoReq->SetSelector * MAX_BLOCK_SIZE) - 2],MAX_BLOCK_SIZE); // UNLOCK_BMC_SHARED_MEM(BMCInst); // resSize += MAX_BLOCK_SIZE; // } // // break; // // default: // if(g_PDKHandle[PDK_GETSYSINFOPARAM] != NULL && // (pGetSysInfoReq->ParamSelector >= 192 && pGetSysInfoReq->ParamSelector <= 255)) // { // oem_len = ((int(*)(INT8U, unsigned long*,int))(g_PDKHandle[PDK_GETSYSINFOPARAM]))(pGetSysInfoReq->ParamSelector, &oem_addr ,BMCInst); // if( oem_len == 0) // { // pGetSysInfoRes->CompletionCode = CC_SYS_INFO_PARAM_NOT_SUPPORTED; // return sizeof(INT8U); // } // else // { // //Acquire the OEM parameters // if( oem_len < MSG_PAYLOAD_SIZE - sizeof(GetLanCCRev_T)) // { // memcpy((char*)pGetSysInfoOEMRes + sizeof(GetSystemInfoParamOEMRes_T) ,\ // (unsigned int*)oem_addr , oem_len); // } // else // { // pGetSysInfoRes->CompletionCode = CC_SYS_INFO_PARAM_NOT_SUPPORTED; // return sizeof(INT8U); // } // return sizeof(GetSystemInfoParamOEMRes_T) + oem_len; // } // } // else // { // pGetSysInfoRes->CompletionCode = CC_SYS_INFO_PARAM_NOT_SUPPORTED; // return sizeof(pGetSysInfoRes->CompletionCode); // } // } // /* return the size of the response */ // return resSize; } int validatestring(INT8U* String,int len,INT8U TOE) { int i,delimit = 0,strlen = 0; for(i=0;iParamSelector < 192 )){ // if( !( (SET_IN_PROGRESS_PARAM == pSetSysInfoReq->ParamSelector && ( ReqLen == ( sizeof(pSetSysInfoReq->ParamSelector) + sizeof(INT8U) /* for Data */ ) )) || // ( pSetSysInfoReq->ParamSelector < MAX_PARAM_SELECTOR && ReqLen == ( sizeof(pSetSysInfoReq->ParamSelector) + sizeof(INT8U) /* for set Selector */ + MAX_BLOCK_SIZE))) ) // { // pSetSysInfoRes->CompletionCode = CC_REQ_INV_LEN; // return sizeof(pSetSysInfoRes->CompletionCode); // } // } // // pSetInProgress = &BMC_GET_SHARED_MEM(BMCInst)->m_Sys_SetInProgress; // // pSetSysInfoRes->CompletionCode = CC_NORMAL; // // /*Get NVRAM System Info Configuration parameters */ // pSysInfoCfg = &pBMCInfo->SystemInfoConfig; // // switch (pSetSysInfoReq->ParamSelector) // { // /*Parameter 0 volatile */ // case SET_IN_PROGRESS_PARAM: // LOCK_BMC_SHARED_MEM(BMCInst); // /* If Request for Set In progress */ // if(( SYS_INFO_SET_IN_PROGRESS == *pSetInProgress ) && // ( SYS_INFO_SET_IN_PROGRESS == pSetSysInfoReq->SysInfo.SetInProgress )) // { // UNLOCK_BMC_SHARED_MEM(BMCInst); // /* Trying to SetinProgress when already in set*/ // pSetSysInfoRes->CompletionCode = CC_SYS_INFO_SET_IN_PROGRESS ; // return sizeof(pSetSysInfoRes->CompletionCode); // } else if( SYS_INFO_COMMIT_WRITE == pSetSysInfoReq->SysInfo.SetInProgress ) // { // /* Write SysInfoConfig to NVR */ // FlushIPMI((INT8U*)&pBMCInfo->SystemInfoConfig,(INT8U*)&pBMCInfo->SystemInfoConfig, // pBMCInfo->IPMIConfLoc.SystemInfoConfigAddr,sizeof(SystemInfoConfig_T),BMCInst); // /* Write volatile data to the BMC Shared memory */ // // } else if ( SYS_INFO_SET_COMPLETE == pSetSysInfoReq->SysInfo.SetInProgress ) // { // //PMCONFIG_FILE(BMCInst,PMConfigFile); // /* Set it to set Complete */ // *pSetInProgress = pSetSysInfoReq->SysInfo.SetInProgress; // FlushIPMI((INT8U*)&pBMCInfo->SystemInfoConfig,(INT8U*)&pBMCInfo->SystemInfoConfig, // pBMCInfo->IPMIConfLoc.SystemInfoConfigAddr,sizeof(SystemInfoConfig_T),BMCInst); // } else if ( SYS_INFO_SET_IN_PROGRESS != pSetSysInfoReq->SysInfo.SetInProgress ) // { // UNLOCK_BMC_SHARED_MEM(BMCInst); // pSetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pSetSysInfoRes->CompletionCode); // } // // *pSetInProgress = pSetSysInfoReq->SysInfo.SetInProgress; // UNLOCK_BMC_SHARED_MEM(BMCInst); // break; // // case SYS_FW_VERSION_PARAM: // // if(pSetSysInfoReq->SysInfo.SysVerInfo.SetSelector >= MAX_BLOCK_SIZE) // { // pSetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pSetSysInfoRes->CompletionCode); // } // if(pSetSysInfoReq->SysInfo.SysNameInfo.SetSelector==ZERO_SETSELECTOR) // { // if(pSetSysInfoReq->SysInfo.SysVerInfo.SysFWVersion[1]> MAX_FW_VER_LENGTH) // { // pSetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pSetSysInfoRes->CompletionCode); // } // if(pSetSysInfoReq->SysInfo.SysVerInfo.SysFWVersion[0] > MAX_TYPE_OF_ENCODING) // { // pSetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pSetSysInfoRes->CompletionCode); // } // memset(&pSysInfoCfg->SysFWVersion,0,sizeof(pSysInfoCfg->SysFWVersion)); // pSysInfoCfg->SysFWVersion.TypeOfEncoding=pSetSysInfoReq->SysInfo.SysVerInfo.SysFWVersion[0]; // pSysInfoCfg->SysFWVersion.StringLength=pSetSysInfoReq->SysInfo.SysVerInfo.SysFWVersion[1]; // /*First character should not be a delimiter*/ // if(pSetSysInfoReq->SysInfo.SysVerInfo.SysFWVersion[2] == 0x0 || ((pSetSysInfoReq->SysInfo.SysVerInfo.SysFWVersion[0] == UNICODE) && (pSetSysInfoReq->SysInfo.SysVerInfo.SysFWVersion[2] == 0x0 || pSetSysInfoReq->SysInfo.SysVerInfo.SysFWVersion[3] == 0x0))) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // strlen = validatestring(&pSetSysInfoReq->SysInfo.SysVerInfo.SysFWVersion[2],MAX_BLOCK_SIZE-2,pSetSysInfoReq->SysInfo.SysVerInfo.SysFWVersion[0]); // if(strlen == -1 || (strlen > pSetSysInfoReq->SysInfo.SysVerInfo.SysFWVersion[1]) || ((pSetSysInfoReq->SysInfo.SysVerInfo.SysFWVersion[1] <= (MAX_BLOCK_SIZE - 2)) && strlen != pSetSysInfoReq->SysInfo.SysVerInfo.SysFWVersion[1])) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // if(((MAX_BLOCK_SIZE -2) < pSetSysInfoReq->SysInfo.SysVerInfo.SysFWVersion[1]) && (strlen != (MAX_BLOCK_SIZE - 2))) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // _fmemcpy(&pSysInfoCfg->SysFWVersion.SysFWVersionName[0],&pSetSysInfoReq->SysInfo.SysVerInfo.SysFWVersion[2], MAX_STRING_LENGTH_COPY); // FlushIPMI((INT8U*)&pBMCInfo->SystemInfoConfig,(INT8U*)&pBMCInfo->SystemInfoConfig.SysFWVersion, // pBMCInfo->IPMIConfLoc.SystemInfoConfigAddr,sizeof(SysFWVersion_T),BMCInst); // } // else // { // _fmemcpy(&pSysInfoCfg->SysFWVersion.SysFWVersionName[(pSetSysInfoReq->SysInfo.SysVerInfo.SetSelector* MAX_BLOCK_SIZE) - 2], // &pSetSysInfoReq->SysInfo.SysVerInfo.SysFWVersion[0],MAX_BLOCK_SIZE); // len = ((pSetSysInfoReq->SysInfo.SysVerInfo.SetSelector* MAX_BLOCK_SIZE) + MAX_BLOCK_SIZE) - 2; // strlen = validatestring(&pSysInfoCfg->SysFWVersion.SysFWVersionName[0],len,pSysInfoCfg->SysFWVersion.TypeOfEncoding); // if(strlen == -1 || (strlen > pSysInfoCfg->SysFWVersion.StringLength)) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // /*Check the String length*/ // if(((len < pSysInfoCfg->SysFWVersion.StringLength) && (len != strlen)) || ((len > pSysInfoCfg->SysFWVersion.StringLength) && (pSysInfoCfg->SysFWVersion.StringLength != strlen))) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // if((len == pSysInfoCfg->SysFWVersion.StringLength) && (pSysInfoCfg->SysFWVersion.StringLength != strlen)) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // // FlushIPMI((INT8U*)&pBMCInfo->SystemInfoConfig, // (INT8U*)&pBMCInfo->SystemInfoConfig.SysFWVersion,pBMCInfo->IPMIConfLoc.SystemInfoConfigAddr,sizeof(SysFWVersion_T),BMCInst); // } // break; // // case SYS_NAME_PARAM: // if(pSetSysInfoReq->SysInfo.SysNameInfo.SetSelector >= MAX_BLOCK_SIZE ) // { // pSetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pSetSysInfoRes->CompletionCode); // } // if(pSetSysInfoReq->SysInfo.SysNameInfo.SetSelector==ZERO_SETSELECTOR) // { // if((pSetSysInfoReq->SysInfo.SysNameInfo.SysName[1] > MAX_SYS_NAME_LENGTH)) // { // pSetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pSetSysInfoRes->CompletionCode); // } // if(pSetSysInfoReq->SysInfo.SysNameInfo.SysName[0]>MAX_TYPE_OF_ENCODING) // { // pSetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pSetSysInfoRes->CompletionCode); // } // memset(&pSysInfoCfg->SysName,0,sizeof(pSysInfoCfg->SysName)); // pSysInfoCfg->SysName.TypeOfEncoding_Sys_Name=pSetSysInfoReq->SysInfo.SysNameInfo.SysName[0]; // pSysInfoCfg->SysName.StringLength_Sys_Name=pSetSysInfoReq->SysInfo.SysNameInfo.SysName[1]; // // /*First character should not be a delimiter*/ // if(pSetSysInfoReq->SysInfo.SysNameInfo.SysName[2] == 0x0 || ((pSetSysInfoReq->SysInfo.SysNameInfo.SysName[0] == UNICODE) && (pSetSysInfoReq->SysInfo.SysNameInfo.SysName[2] == 0x0 || pSetSysInfoReq->SysInfo.SysNameInfo.SysName[3] == 0x0))) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // // strlen = validatestring(&pSetSysInfoReq->SysInfo.SysNameInfo.SysName[2],MAX_BLOCK_SIZE-2,pSetSysInfoReq->SysInfo.SysNameInfo.SysName[0]); // if(strlen == -1 || (strlen > pSetSysInfoReq->SysInfo.SysNameInfo.SysName[1]) || ((pSetSysInfoReq->SysInfo.SysNameInfo.SysName[1] <= (MAX_BLOCK_SIZE - 2)) && strlen != pSetSysInfoReq->SysInfo.SysNameInfo.SysName[1])) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // if(((MAX_BLOCK_SIZE -2) < pSetSysInfoReq->SysInfo.SysNameInfo.SysName[1]) && (strlen != (MAX_BLOCK_SIZE - 2))) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // // _fmemcpy(&pSysInfoCfg->SysName.SystemName[0], &pSetSysInfoReq->SysInfo.SysNameInfo.SysName[2],MAX_STRING_LENGTH_COPY); // FlushIPMI((INT8U*)&pBMCInfo->SystemInfoConfig,(INT8U*)&pBMCInfo->SystemInfoConfig.SysName, // pBMCInfo->IPMIConfLoc.SystemInfoConfigAddr,sizeof(SysName_T),BMCInst); // } // else // { // _fmemcpy(&pSysInfoCfg->SysName.SystemName[(pSetSysInfoReq->SysInfo.SysNameInfo.SetSelector* MAX_BLOCK_SIZE) - 2], // &pSetSysInfoReq->SysInfo.SysNameInfo.SysName,MAX_BLOCK_SIZE); // len = ((pSetSysInfoReq->SysInfo.SysNameInfo.SetSelector* MAX_BLOCK_SIZE) + MAX_BLOCK_SIZE) - 2; // strlen = validatestring(&pSysInfoCfg->SysName.SystemName[0],len,pSysInfoCfg->SysName.TypeOfEncoding_Sys_Name); // if(strlen == -1 || (strlen > pSysInfoCfg->SysName.StringLength_Sys_Name)) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // /*Check the String length*/ // if(((len < pSysInfoCfg->SysName.StringLength_Sys_Name) && (len != strlen)) || ((len > pSysInfoCfg->SysName.StringLength_Sys_Name) && (pSysInfoCfg->SysName.StringLength_Sys_Name != strlen))) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // if((len == pSysInfoCfg->SysName.StringLength_Sys_Name) && (pSysInfoCfg->SysName.StringLength_Sys_Name != strlen)) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // // FlushIPMI((INT8U*)&pBMCInfo->SystemInfoConfig,(INT8U*)&pBMCInfo->SystemInfoConfig.SysName, // pBMCInfo->IPMIConfLoc.SystemInfoConfigAddr,sizeof(SysName_T),BMCInst); // } // break; // // case PRIM_OS_NAME_PARAM: // if(pSetSysInfoReq->SysInfo.PrimOSInfo.SetSelector >= MAX_BLOCK_SIZE ) // { // pSetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pSetSysInfoRes->CompletionCode); // } // if(pSetSysInfoReq->SysInfo.PrimOSInfo.SetSelector==ZERO_SETSELECTOR) // { // if((pSetSysInfoReq->SysInfo.PrimOSInfo.PrimaryOSName[1] > MAX_PRIM_OS_NAME_LENGTH)) // { // pSetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pSetSysInfoRes->CompletionCode); // // } // if(pSetSysInfoReq->SysInfo.PrimOSInfo.PrimaryOSName[0]>MAX_TYPE_OF_ENCODING) // { // pSetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pSetSysInfoRes->CompletionCode); // } // memset(&pSysInfoCfg->PrimaryOSName,0,sizeof(pSysInfoCfg->PrimaryOSName)); // pSysInfoCfg->PrimaryOSName.TypeOfEncoding_PrimaryOSName=pSetSysInfoReq->SysInfo.PrimOSInfo.PrimaryOSName[0]; // pSysInfoCfg->PrimaryOSName.StringLength_PrimaryOSName=pSetSysInfoReq->SysInfo.PrimOSInfo.PrimaryOSName[1]; // // /*First character should not be a delimiter*/ // if(pSetSysInfoReq->SysInfo.PrimOSInfo.PrimaryOSName[2] == 0x0 || ((pSetSysInfoReq->SysInfo.PrimOSInfo.PrimaryOSName[0] == UNICODE) && (pSetSysInfoReq->SysInfo.PrimOSInfo.PrimaryOSName[2] == 0x0 || pSetSysInfoReq->SysInfo.PrimOSInfo.PrimaryOSName[3] == 0x0))) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // // strlen = validatestring(&pSetSysInfoReq->SysInfo.PrimOSInfo.PrimaryOSName[2],MAX_BLOCK_SIZE-2,pSetSysInfoReq->SysInfo.PrimOSInfo.PrimaryOSName[0]); // if(strlen == -1 || (strlen > pSetSysInfoReq->SysInfo.PrimOSInfo.PrimaryOSName[1]) || ((pSetSysInfoReq->SysInfo.PrimOSInfo.PrimaryOSName[1] <= (MAX_BLOCK_SIZE - 2)) && strlen != pSetSysInfoReq->SysInfo.PrimOSInfo.PrimaryOSName[1])) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // if(((MAX_BLOCK_SIZE -2) < pSetSysInfoReq->SysInfo.PrimOSInfo.PrimaryOSName[1]) && (strlen != (MAX_BLOCK_SIZE - 2))) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // // _fmemcpy(&pSysInfoCfg->PrimaryOSName.PrimaryOperatingSystemName[0], &pSetSysInfoReq->SysInfo.PrimOSInfo.PrimaryOSName[2], MAX_STRING_LENGTH_COPY); // FlushIPMI((INT8U*)&pBMCInfo->SystemInfoConfig,(INT8U*)&pBMCInfo->SystemInfoConfig.PrimaryOSName, // pBMCInfo->IPMIConfLoc.SystemInfoConfigAddr,sizeof(PrimaryOSName_T),BMCInst); // } // else // { // _fmemcpy(&pSysInfoCfg->PrimaryOSName.PrimaryOperatingSystemName[(pSetSysInfoReq->SysInfo.PrimOSInfo.SetSelector * MAX_BLOCK_SIZE) - 2], // &pSetSysInfoReq->SysInfo.PrimOSInfo.PrimaryOSName, MAX_BLOCK_SIZE); // len = ((pSetSysInfoReq->SysInfo.PrimOSInfo.SetSelector* MAX_BLOCK_SIZE) + MAX_BLOCK_SIZE) - 2; // strlen = validatestring(&pSysInfoCfg->PrimaryOSName.PrimaryOperatingSystemName[0],len,pSysInfoCfg->PrimaryOSName.TypeOfEncoding_PrimaryOSName); // if(strlen == -1 || (strlen > pSysInfoCfg->PrimaryOSName.StringLength_PrimaryOSName)) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // /*Check the String length*/ // if(((len < pSysInfoCfg->PrimaryOSName.StringLength_PrimaryOSName) && (len != strlen)) || ((len > pSysInfoCfg->PrimaryOSName.StringLength_PrimaryOSName) && (pSysInfoCfg->PrimaryOSName.StringLength_PrimaryOSName != strlen))) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // if((len == pSysInfoCfg->PrimaryOSName.StringLength_PrimaryOSName) && (pSysInfoCfg->PrimaryOSName.StringLength_PrimaryOSName != strlen)) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // // FlushIPMI((INT8U*)&pBMCInfo->SystemInfoConfig, // (INT8U*)&pBMCInfo->SystemInfoConfig.PrimaryOSName,pBMCInfo->IPMIConfLoc.SystemInfoConfigAddr,sizeof(PrimaryOSName_T),BMCInst); // } // break; // // case OS_NAME_PARAM: // /*Parameter 4 volatile*/ // if(pSetSysInfoReq->SysInfo.OSInfo.SetSelector >= MAX_BLOCK_SIZE ) // { // pSetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pSetSysInfoRes->CompletionCode); // } // if(pSetSysInfoReq->SysInfo.OSInfo.SetSelector==ZERO_SETSELECTOR) // { // if(pSetSysInfoReq->SysInfo.OSInfo.OperatingSystemName[1] > MAX_OS_NAME_LENGTH) // { // pSetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pSetSysInfoRes->CompletionCode); // } // if(pSetSysInfoReq->SysInfo.OSInfo.OperatingSystemName[0] > MAX_TYPE_OF_ENCODING) // { // pSetSysInfoRes->CompletionCode = CC_INV_DATA_FIELD; // return sizeof(pSetSysInfoRes->CompletionCode); // } // // /*First character should not be a delimiter*/ // if(pSetSysInfoReq->SysInfo.OSInfo.OperatingSystemName[2] == 0x0 || ((pSetSysInfoReq->SysInfo.OSInfo.OperatingSystemName[0] == UNICODE) && (pSetSysInfoReq->SysInfo.OSInfo.OperatingSystemName[2] == 0x0 || pSetSysInfoReq->SysInfo.OSInfo.OperatingSystemName[3] == 0x0))) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // // strlen = validatestring(&pSetSysInfoReq->SysInfo.OSInfo.OperatingSystemName[2],MAX_BLOCK_SIZE-2,pSetSysInfoReq->SysInfo.OSInfo.OperatingSystemName[0]); // if(strlen == -1 || (strlen > pSetSysInfoReq->SysInfo.OSInfo.OperatingSystemName[1]) || ((pSetSysInfoReq->SysInfo.OSInfo.OperatingSystemName[1] <= (MAX_BLOCK_SIZE - 2)) && strlen != pSetSysInfoReq->SysInfo.OSInfo.OperatingSystemName[1])) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // if(((MAX_BLOCK_SIZE -2) < pSetSysInfoReq->SysInfo.OSInfo.OperatingSystemName[1]) && (strlen != (MAX_BLOCK_SIZE - 2))) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // // memset(&BMC_GET_SHARED_MEM(BMCInst)->OperatingSystemName,0,sizeof(OSName_T)); // LOCK_BMC_SHARED_MEM(BMCInst); // BMC_GET_SHARED_MEM(BMCInst)->OperatingSystemName.TypeOfEncoding_OSName=pSetSysInfoReq->SysInfo.OSInfo.OperatingSystemName[0]; // BMC_GET_SHARED_MEM(BMCInst)->OperatingSystemName.StringLength_OSName=pSetSysInfoReq->SysInfo.OSInfo.OperatingSystemName[1]; // _fmemcpy(&BMC_GET_SHARED_MEM(BMCInst)->OperatingSystemName.OSName, &pSetSysInfoReq->SysInfo.OSInfo.OperatingSystemName[2], // MAX_STRING_LENGTH_COPY); // UNLOCK_BMC_SHARED_MEM (BMCInst); // } // else // { // LOCK_BMC_SHARED_MEM(BMCInst); // _fmemcpy(&OSName[0],&BMC_GET_SHARED_MEM(BMCInst)->OperatingSystemName.OSName[0],MAX_OS_NAME_LENGTH); // _fmemcpy(&OSName[(pSetSysInfoReq->SysInfo.OSInfo.SetSelector * MAX_BLOCK_SIZE) - 2],&pSetSysInfoReq->SysInfo.OSInfo.OperatingSystemName,MAX_BLOCK_SIZE); // len = ((pSetSysInfoReq->SysInfo.OSInfo.SetSelector* MAX_BLOCK_SIZE) + MAX_BLOCK_SIZE) - 2; // strlen = validatestring(&OSName[0],len,BMC_GET_SHARED_MEM(BMCInst)->OperatingSystemName.TypeOfEncoding_OSName); // if(strlen == -1 || (strlen > BMC_GET_SHARED_MEM(BMCInst)->OperatingSystemName.StringLength_OSName)) // { // *pRes = CC_INV_DATA_FIELD; // UNLOCK_BMC_SHARED_MEM(BMCInst); // return sizeof(INT8U); // } // /*Check the String length*/ // if(((len < BMC_GET_SHARED_MEM(BMCInst)->OperatingSystemName.StringLength_OSName) && (len != strlen)) || ((len > BMC_GET_SHARED_MEM(BMCInst)->OperatingSystemName.StringLength_OSName) && (BMC_GET_SHARED_MEM(BMCInst)->OperatingSystemName.StringLength_OSName != strlen))) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // if((len == BMC_GET_SHARED_MEM(BMCInst)->OperatingSystemName.StringLength_OSName) && (BMC_GET_SHARED_MEM(BMCInst)->OperatingSystemName.StringLength_OSName != strlen)) // { // *pRes = CC_INV_DATA_FIELD; // return sizeof(INT8U); // } // // _fmemcpy(&(BMC_GET_SHARED_MEM(BMCInst)->OperatingSystemName.OSName[(pSetSysInfoReq->SysInfo.OSInfo.SetSelector * MAX_BLOCK_SIZE) - 2]), // &pSetSysInfoReq->SysInfo.OSInfo.OperatingSystemName,MAX_BLOCK_SIZE); // UNLOCK_BMC_SHARED_MEM (BMCInst); // } // break; // // default: // if(g_PDKHandle[PDK_SETSYSINFOPARAM] != NULL && // (pSetSysInfoReq->ParamSelector >= 192 && pSetSysInfoReq->ParamSelector <= 255)) // { // oem_addr[0] = (unsigned long)((char*)pSetSysInfoOEMReq + sizeof(SetSystemInfoParamOEMReq_T)); // size = ((int(*)(INT8U, unsigned long*,int))(g_PDKHandle[PDK_SETSYSINFOPARAM]))(pSetSysInfoReq->ParamSelector, oem_addr ,BMCInst); // if(size <= 0) // { // switch (oem_addr[1]) { // case CC_SYS_INFO_READ_ONLY_PARAM: // pSetSysInfoRes->CompletionCode = CC_SYS_INFO_READ_ONLY_PARAM; // break; // default: // pSetSysInfoRes->CompletionCode = CC_PARAM_NOT_SUPPORTED; // } // } // else // { // pSetSysInfoRes->CompletionCode = CC_SYS_INFO_PARAM_NOT_SUPPORTED; // return sizeof(pSetSysInfoRes->CompletionCode); // } // } // } // return sizeof(pSetSysInfoRes->CompletionCode); } //#endif /* APP_DEVICE */