/*
 * Copyright (c) 2006 Kontron Canada, Inc.  All Rights Reserved.
 * Copyright (c) 2003 Sun Microsystems, Inc.  All Rights Reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * Redistribution of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *
 * Redistribution in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *
 * Neither the name of Sun Microsystems, Inc. or the names of
 * contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 *
 * This software is provided "AS IS," without a warranty of any kind.
 * ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
 * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED.
 * SUN MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE
 * FOR ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING
 * OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.  IN NO EVENT WILL
 * SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA,
 * OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
 * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF
 * LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE,
 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 */

#include <ipmitool/ipmi_intf.h>
#include <ipmitool/ipmi_mc.h>
#include <ipmitool/ipmi_hpmfwupg.h>
#include <ipmitool/helper.h>
#include <ipmitool/ipmi_strings.h>
#include <ipmitool/log.h>
#include "../src/plugins/lan/md5.h"
#include <stdio.h>
#include <time.h>
#include <sys/param.h>

#if HAVE_CONFIG_H
# include <config.h>
#endif

extern int verbose;

int HpmfwupgUpgrade(struct ipmi_intf *intf, char *imageFilename,
		int activate, int, int);
int HpmfwupgValidateImageIntegrity(struct HpmfwupgUpgradeCtx *pFwupgCtx);
int HpmfwupgPreparationStage(struct ipmi_intf *intf,
		struct HpmfwupgUpgradeCtx *pFwupgCtx, int option);
int HpmfwupgUpgradeStage(struct ipmi_intf *intf,
		struct HpmfwupgUpgradeCtx *pFwupgCtx, int option);
int HpmfwupgActivationStage(struct ipmi_intf *intf,
		struct HpmfwupgUpgradeCtx *pFwupgCtx);
int HpmfwupgGetTargetUpgCapabilities(struct ipmi_intf *intf,
		struct HpmfwupgGetTargetUpgCapabilitiesCtx *pCtx);
int HpmfwupgGetComponentProperties(struct ipmi_intf *intf,
		struct HpmfwupgGetComponentPropertiesCtx *pCtx);
int HpmfwupgQuerySelftestResult(struct ipmi_intf *intf,
		struct HpmfwupgQuerySelftestResultCtx *pCtx,
		struct HpmfwupgUpgradeCtx *pFwupgCtx);
int HpmfwupgQueryRollbackStatus(struct ipmi_intf *intf,
		struct HpmfwupgQueryRollbackStatusCtx *pCtx,
		struct HpmfwupgUpgradeCtx *pFwupgCtx);
int HpmfwupgAbortUpgrade(struct ipmi_intf *intf,
		struct HpmfwupgAbortUpgradeCtx *pCtx);
int HpmfwupgInitiateUpgradeAction(struct ipmi_intf *intf,
		struct HpmfwupgInitiateUpgradeActionCtx *pCtx,
		struct HpmfwupgUpgradeCtx *pFwupgCtx);
int HpmfwupgUploadFirmwareBlock(struct ipmi_intf *intf,
		struct HpmfwupgUploadFirmwareBlockCtx *pCtx,
		struct HpmfwupgUpgradeCtx *pFwupgCtx, int count,
		unsigned int *pOffset, unsigned int *blockLen);
int HpmfwupgFinishFirmwareUpload(struct ipmi_intf *intf,
		struct HpmfwupgFinishFirmwareUploadCtx *pCtx,
		struct HpmfwupgUpgradeCtx *pFwupgCtx, int option);
int HpmfwupgActivateFirmware(struct ipmi_intf *intf,
		struct HpmfwupgActivateFirmwareCtx *pCtx,
		struct HpmfwupgUpgradeCtx *pFwupgCtx);
int HpmfwupgGetUpgradeStatus(struct ipmi_intf *intf,
		struct HpmfwupgGetUpgradeStatusCtx *pCtxstruct,
		struct HpmfwupgUpgradeCtx *pFwupgCtx, int silent);
int HpmfwupgManualFirmwareRollback(struct ipmi_intf *intf,
		struct HpmfwupgManualFirmwareRollbackCtx *pCtx);
void HpmfwupgPrintUsage(void);
unsigned char HpmfwupgCalculateChecksum(unsigned char *pData,
		unsigned int length);
int HpmfwupgGetDeviceId(struct ipmi_intf *intf,
		struct ipm_devid_rsp *pGetDevId);
int HpmfwupgGetBufferFromFile(char *imageFilename,
		struct HpmfwupgUpgradeCtx *pFwupgCtx);
int HpmfwupgWaitLongDurationCmd(struct ipmi_intf *intf,
		struct HpmfwupgUpgradeCtx *pFwupgCtx);
struct ipmi_rs *HpmfwupgSendCmd(struct ipmi_intf *intf,
		struct ipmi_rq req, struct HpmfwupgUpgradeCtx* pFwupgCtx);


int HpmFwupgActionUploadFirmware(struct HpmfwupgComponentBitMask components,
		struct HpmfwupgUpgradeCtx* pFwupgCtx,
		unsigned char **pImagePtr,
		struct ipmi_intf *intf,
		int option,
		int *pFlagColdReset);

/* HpmGetuserInput - get input from user
 *
 * returns TRUE if its Yes or FALSE if its No
 */
int
HpmGetUserInput(char *str)
{
	char userInput[2];
	int ret;

	printf("%s", str);
	ret = scanf("%s", userInput);
	if (!ret) {
		return 1;
	}
	if (toupper(userInput[0]) == 'Y') {
		return 1;
	}
	return 0;
}

/* HpmDisplayLine - display the line with the given character
 */
void
HpmDisplayLine(char *s, int n)
{
	while (n--) {
		printf ("%c", *s);
	}
	printf("\n");
}

/* HpmDisplayUpgradeHeader - display the Upgrade header information
 */
void
HpmDisplayUpgradeHeader(void)
{
	printf("\n");
	HpmDisplayLine("-", 79);
	printf(
"|ID  | Name        |                     Versions                        | %%  |\n");
	printf(
"|    |             |      Active     |      Backup     |      File       |    |\n");
	printf(
"|----|-------------|-----------------|-----------------|-----------------|----|\n");
}

/* HpmDisplayUpgrade - display the progress of the upgrade; prints the "."
 * for every 5% of its completion.
 */
void
HpmDisplayUpgrade(int skip, unsigned int totalSent,
		unsigned int displayFWLength, time_t timeElapsed)
{
	int percent;
	static int old_percent = -1;
	if (skip) {
		printf("Skip|\n");
		return;
	}
	fflush(stdout);

	percent = ((float)totalSent / displayFWLength) * 100;
	if (percent != old_percent) {
		if (old_percent != -1) {
			printf("\b\b\b\b\b");
		}
		printf("%3d%%|", percent);
		old_percent = percent;
	}
	if (totalSent == displayFWLength) {
		/* Display the time taken to complete the upgrade */
		printf(
"\n|    |Upload Time: %02ld:%02ld             | Image Size: %7d bytes              |\n",
			timeElapsed / 60, timeElapsed % 60, totalSent);
		old_percent = -1;
	}
}

/* HpmDisplayVersionHeader - display the information about version header
 */
void
HpmDisplayVersionHeader(int mode)
{
	if (mode & IMAGE_VER) {
		HpmDisplayLine("-", 74);
		printf(
"|ID  | Name        |                     Versions                        |\n");
		printf(
"|    |             |     Active      |     Backup      |      File       |\n");
		HpmDisplayLine("-", 74);
	} else {
		HpmDisplayLine("-",74 );
		printf(
"|ID  | Name        |                     Versions                        |\n");
		printf(
"|    |             |     Active      |     Backup      |      Deferred   |\n");
		HpmDisplayLine("-", 74);
	}
}

/* HpmDisplayVersion - display the version of the image and target
 */
void
HpmDisplayVersion(int mode, VERSIONINFO *pVersion, int upgradable)
{
	/*
	 * If the cold reset is required then we can display * on it
	 * so that user is aware that he needs to do payload power
	 * cycle after upgrade
	 */
	printf("|%c%c%2d|%-13s|",
			pVersion->coldResetRequired ? '*' : ' ',
			upgradable ? '^' : ' ',
			pVersion->componentId, pVersion->descString);

	if (mode & TARGET_VER) {
		if ((pVersion->targetMajor == 0xFF
					|| (pVersion->targetMajor == 0x7F))
				&& pVersion->targetMinor == 0xFF) {
			printf(" ---.-- -------- |");
		} else {
			printf(" %3d.%02x %02X%02X%02X%02X |",
					pVersion->targetMajor,
					pVersion->targetMinor,
					pVersion->targetAux[0],
					pVersion->targetAux[1],
					pVersion->targetAux[2],
					pVersion->targetAux[3]);
		}
		if (mode & ROLLBACK_VER) {
			if ((pVersion->rollbackMajor == 0xFF
						|| (pVersion->rollbackMajor == 0x7F))
					&& pVersion->rollbackMinor == 0xFF) {
				printf(" ---.-- -------- |");
			} else {
				printf(" %3d.%02x %02X%02X%02X%02X |",
						pVersion->rollbackMajor,
						pVersion->rollbackMinor,
						pVersion->rollbackAux[0],
						pVersion->rollbackAux[1],
						pVersion->rollbackAux[2],
						pVersion->rollbackAux[3]);
			}
		} else {
			printf(" ---.-- -------- |");
		}
	}
	if (mode & IMAGE_VER) {
		if ((pVersion->imageMajor == 0xFF
					|| (pVersion->imageMajor == 0x7F))
				&& pVersion->imageMinor == 0xFF) {
			printf(" ---.-- |");
		} else {
			printf(" %3d.%02x %02X%02X%02X%02X |",
					pVersion->imageMajor,
					pVersion->imageMinor,
					pVersion->imageAux[0],
					pVersion->imageAux[1],
					pVersion->imageAux[2],
					pVersion->imageAux[3]);
		}
	} else {
		if ((pVersion->deferredMajor == 0xFF
					|| (pVersion->deferredMajor == 0x7F))
				&& pVersion->deferredMinor == 0xFF) {
			printf(" ---.-- -------- |");
		} else {
			printf(" %3d.%02x %02X%02X%02X%02X |",
					pVersion->deferredMajor,
					pVersion->deferredMinor,
					pVersion->deferredAux[0],
					pVersion->deferredAux[1],
					pVersion->deferredAux[2],
					pVersion->deferredAux[3]);
		}
	}
}

/* HpmfwupgTargerCheck - get target information and displays it on the screen
 */
int
HpmfwupgTargetCheck(struct ipmi_intf *intf, int option)
{
	struct HpmfwupgGetTargetUpgCapabilitiesCtx targetCapCmd;
	int rc = HPMFWUPG_SUCCESS;
	int componentId = 0;
	int flagColdReset = FALSE;
	struct ipm_devid_rsp devIdrsp;
	struct HpmfwupgGetComponentPropertiesCtx getCompProp;
	int mode = 0;
	rc = HpmfwupgGetDeviceId(intf, &devIdrsp);
	if (rc != HPMFWUPG_SUCCESS) {
		lprintf(LOG_NOTICE,
				"Verify whether the Target board is present \n");
		return HPMFWUPG_ERROR;
	}
	rc = HpmfwupgGetTargetUpgCapabilities(intf, &targetCapCmd);
	if (rc != HPMFWUPG_SUCCESS) {
		/* That indicates the target is not responding to the command
		 * May be that there is no HPM support
		 */
		lprintf(LOG_NOTICE,
				"Board might not be supporting the HPM.1 Standards\n");
		return rc;
	}
	if (option & VIEW_MODE) {
		lprintf(LOG_NOTICE, "-------Target Information-------");
		lprintf(LOG_NOTICE, "Device Id          : 0x%x",
				devIdrsp.device_id);
		lprintf(LOG_NOTICE, "Device Revision    : 0x%x",
				devIdrsp.device_revision);
		lprintf(LOG_NOTICE, "Product Id         : 0x%04x",
				buf2short(devIdrsp.product_id));
		lprintf(LOG_NOTICE, "Manufacturer Id    : 0x%04x (%s)\n\n",
				buf2short(devIdrsp.manufacturer_id),
				val2str(buf2short(devIdrsp.manufacturer_id),ipmi_oem_info));
		HpmDisplayVersionHeader(TARGET_VER|ROLLBACK_VER);
	}
	for (componentId = HPMFWUPG_COMPONENT_ID_0;
			componentId < HPMFWUPG_COMPONENT_ID_MAX;
			componentId++ ) {
		/* If the component is supported */
		if (((1 << componentId) & targetCapCmd.resp.componentsPresent.ComponentBits.byte)) {
			memset((PVERSIONINFO)&gVersionInfo[componentId], 0x00, sizeof(VERSIONINFO));
			getCompProp.req.componentId = componentId;
			getCompProp.req.selector = HPMFWUPG_COMP_GEN_PROPERTIES;
			rc = HpmfwupgGetComponentProperties(intf, &getCompProp);
			if (rc != HPMFWUPG_SUCCESS) {
				lprintf(LOG_NOTICE, "Get CompGenProp Failed for component Id %d\n",
						componentId);
				return rc;
			}
			gVersionInfo[componentId].rollbackSupported = getCompProp.resp.Response.
				generalPropResp.GeneralCompProperties.bitfield.rollbackBackup;
			gVersionInfo[componentId].coldResetRequired =  getCompProp.resp.Response.
				generalPropResp.GeneralCompProperties.bitfield.payloadColdReset;
			gVersionInfo[componentId].deferredActivationSupported =  getCompProp.resp.Response.
				generalPropResp.GeneralCompProperties.bitfield.deferredActivation;
			getCompProp.req.selector = HPMFWUPG_COMP_DESCRIPTION_STRING;
			rc = HpmfwupgGetComponentProperties(intf, &getCompProp);
			if (rc != HPMFWUPG_SUCCESS) {
				lprintf(LOG_NOTICE,
						"Get CompDescString Failed for component Id %d\n",
						componentId);
				return rc;
			}
			memcpy(gVersionInfo[componentId].descString,
					getCompProp.resp.Response.descStringResp.descString,
					HPMFWUPG_DESC_STRING_LENGTH);
			gVersionInfo[componentId].descString[HPMFWUPG_DESC_STRING_LENGTH] = '\0';
			getCompProp.req.selector = HPMFWUPG_COMP_CURRENT_VERSION;
			rc = HpmfwupgGetComponentProperties(intf, &getCompProp);
			if (rc != HPMFWUPG_SUCCESS) {
				lprintf(LOG_NOTICE,
						"Get CompCurrentVersion Failed for component Id %d\n",
						componentId);
				return rc;
			}
			gVersionInfo[componentId].componentId = componentId;
			gVersionInfo[componentId].targetMajor = getCompProp.resp.Response.
				currentVersionResp.currentVersion[0];
			gVersionInfo[componentId].targetMinor = getCompProp.resp.Response.
				currentVersionResp.currentVersion[1];
			gVersionInfo[componentId].targetAux[0] = getCompProp.resp.Response.
				currentVersionResp.currentVersion[2];
			gVersionInfo[componentId].targetAux[1] = getCompProp.resp.Response.
				currentVersionResp.currentVersion[3];
			gVersionInfo[componentId].targetAux[2] = getCompProp.resp.Response.
				currentVersionResp.currentVersion[4];
			gVersionInfo[componentId].targetAux[3] = getCompProp.resp.Response.
				currentVersionResp.currentVersion[5];
			mode = TARGET_VER;
			if (gVersionInfo[componentId].rollbackSupported) {
				getCompProp.req.selector = HPMFWUPG_COMP_ROLLBACK_FIRMWARE_VERSION;
				rc = HpmfwupgGetComponentProperties(intf, &getCompProp);
				if (rc != HPMFWUPG_SUCCESS) {
					lprintf(LOG_NOTICE,
							"Get CompRollbackVersion Failed for component Id %d\n",
							componentId);
				} else {
					gVersionInfo[componentId].rollbackMajor = getCompProp.resp
						.Response.rollbackFwVersionResp.rollbackFwVersion[0];
					gVersionInfo[componentId].rollbackMinor = getCompProp.resp
						.Response.rollbackFwVersionResp.rollbackFwVersion[1];
					gVersionInfo[componentId].rollbackAux[0] = getCompProp.resp.Response.rollbackFwVersionResp.rollbackFwVersion[2];
					gVersionInfo[componentId].rollbackAux[1] = getCompProp.resp.Response.rollbackFwVersionResp.rollbackFwVersion[3];
					gVersionInfo[componentId].rollbackAux[2] = getCompProp.resp.Response.rollbackFwVersionResp.rollbackFwVersion[4];
					gVersionInfo[componentId].rollbackAux[3] = getCompProp.resp.Response.rollbackFwVersionResp.rollbackFwVersion[5];
				}
				mode |= ROLLBACK_VER;
			} else {
				gVersionInfo[componentId].rollbackMajor = 0xff;
				gVersionInfo[componentId].rollbackMinor = 0xff;
				gVersionInfo[componentId].rollbackAux[0] = 0xff;
				gVersionInfo[componentId].rollbackAux[1] = 0xff;
				gVersionInfo[componentId].rollbackAux[2] = 0xff;
				gVersionInfo[componentId].rollbackAux[3] = 0xff;
			}
			if (gVersionInfo[componentId].deferredActivationSupported) {
				getCompProp.req.selector = HPMFWUPG_COMP_DEFERRED_FIRMWARE_VERSION;
				rc = HpmfwupgGetComponentProperties(intf, &getCompProp);
				if (rc != HPMFWUPG_SUCCESS) {
					lprintf(LOG_NOTICE,
							"Get CompRollbackVersion Failed for component Id %d\n",
							componentId);
				} else {
					gVersionInfo[componentId].deferredMajor = getCompProp.resp
						.Response.deferredFwVersionResp.deferredFwVersion[0];
					gVersionInfo[componentId].deferredMinor = getCompProp.resp
						.Response.deferredFwVersionResp.deferredFwVersion[1];
					gVersionInfo[componentId].deferredAux[0] = getCompProp.resp.Response.deferredFwVersionResp.deferredFwVersion[2];
					gVersionInfo[componentId].deferredAux[1] = getCompProp.resp.Response.deferredFwVersionResp.deferredFwVersion[3];
					gVersionInfo[componentId].deferredAux[2] = getCompProp.resp.Response.deferredFwVersionResp.deferredFwVersion[4];
					gVersionInfo[componentId].deferredAux[3] = getCompProp.resp.Response.deferredFwVersionResp.deferredFwVersion[5];
				}
			} else {
				gVersionInfo[componentId].deferredMajor = 0xff;
				gVersionInfo[componentId].deferredMinor = 0xff;
				gVersionInfo[componentId].deferredAux[0] = 0xff;
				gVersionInfo[componentId].deferredAux[1] = 0xff;
				gVersionInfo[componentId].deferredAux[2] = 0xff;
				gVersionInfo[componentId].deferredAux[3] = 0xff;
			}
			if (gVersionInfo[componentId].coldResetRequired) {
				/*
				 * If any of the component indicates that the Payload Cold reset is required
				 * then set the flag
				 */
				flagColdReset = TRUE;
			}
			if (option & VIEW_MODE) {
				HpmDisplayVersion(mode,
						&gVersionInfo[componentId],
						0);
				printf("\n");
			}
		}
	}
	if (option & VIEW_MODE) {
		HpmDisplayLine("-",74 );
		fflush(stdout);
		lprintf(LOG_NOTICE,
				"(*) Component requires Payload Cold Reset");
		printf("\n\n");
	}
	return HPMFWUPG_SUCCESS;
}

/* HpmfwupgUpgrade - perform the HPM.1 firmware upgrade procedure as defined
 * the IPM Controller Firmware Upgrade Specification version 1.0
 */
int
HpmfwupgUpgrade(struct ipmi_intf *intf, char *imageFilename, int activate,
		int componentMask, int option)
{
	int rc = HPMFWUPG_SUCCESS;
	struct HpmfwupgUpgradeCtx  fwupgCtx;
	/* INITIALIZE UPGRADE CONTEXT */
	memset(&fwupgCtx, 0, sizeof (fwupgCtx));
	/* GET IMAGE BUFFER FROM FILE */
	rc = HpmfwupgGetBufferFromFile(imageFilename, &fwupgCtx);
	/* VALIDATE IMAGE INTEGRITY */
	if (rc == HPMFWUPG_SUCCESS) {
		printf("Validating firmware image integrity...");
		fflush(stdout);
		rc = HpmfwupgValidateImageIntegrity(&fwupgCtx);
		if (rc == HPMFWUPG_SUCCESS) {
			printf("OK\n");
			fflush(stdout);
		}
	}
	/* PREPARATION STAGE */
	if (rc == HPMFWUPG_SUCCESS) {
		printf("Performing preparation stage...");
		fflush(stdout);
		rc = HpmfwupgPreparationStage(intf, &fwupgCtx, option);
		if (rc == HPMFWUPG_SUCCESS) {
			printf("OK\n");
			fflush(stdout);
		}
	}
	/* UPGRADE STAGE */
	if (rc == HPMFWUPG_SUCCESS) {
		if (option & VIEW_MODE) {
			lprintf(LOG_NOTICE,
					"\nComparing Target & Image File version");
		} else if (option & COMPARE_MODE) {
			lprintf(LOG_NOTICE,
					"\nPerforming upload for compare stage:");
		} else {
			lprintf(LOG_NOTICE, "\nPerforming upgrade stage:");
		}
		if (option & VIEW_MODE) {
			rc = HpmfwupgPreUpgradeCheck(intf,
					&fwupgCtx,componentMask, VIEW_MODE);
		} else {
			rc = HpmfwupgPreUpgradeCheck(intf, &fwupgCtx,
					componentMask, option);
			if (rc == HPMFWUPG_SUCCESS) {
				if (verbose) {
					printf("Component update mask : 0x%02x\n",
							fwupgCtx.compUpdateMask.ComponentBits.byte);
				}
				rc = HpmfwupgUpgradeStage(intf, &fwupgCtx, option);
			}
		}
	}
	/* ACTIVATION STAGE */
	if (rc == HPMFWUPG_SUCCESS && activate) {
		/* check if upgrade components mask is non-zero */
		if (fwupgCtx.compUpdateMask.ComponentBits.byte) {
			lprintf(LOG_NOTICE, "Performing activation stage: ");
			rc = HpmfwupgActivationStage(intf, &fwupgCtx);
		} else {
			lprintf(LOG_NOTICE,
					"No components updated. Skipping activation stage.\n");
		}
	}
	if (rc == HPMFWUPG_SUCCESS) {
		if (option & VIEW_MODE) {
		/* Dont display anything here in case we are just viewing it */
		lprintf(LOG_NOTICE," ");
		} else if (option & COMPARE_MODE) {
			lprintf(LOG_NOTICE,
					"\nFirmware comparison procedure complete\n");
		} else {
			lprintf(LOG_NOTICE,
					"\nFirmware upgrade procedure successful\n");
		}
	} else if (option & VIEW_MODE) {
		/* Dont display anything here in case we are just viewing it */
		lprintf(LOG_NOTICE," ");
	} else if (option & COMPARE_MODE) {
		lprintf(LOG_NOTICE,
				"Firmware comparison procedure failed\n");
	} else {
		lprintf(LOG_NOTICE, "Firmware upgrade procedure failed\n");
	}
	if (fwupgCtx.pImageData) {
		free(fwupgCtx.pImageData);
		fwupgCtx.pImageData = NULL;
	}
	return rc;
}

/* HpmfwupgValidateImageIntegrity - validate a HPM.1 firmware image file as
 * defined in section 4 of the IPM Controller Firmware Upgrade Specification
 * version 1.0
 */
int
HpmfwupgValidateImageIntegrity(struct HpmfwupgUpgradeCtx *pFwupgCtx)
{
	struct HpmfwupgImageHeader *pImageHeader = (struct HpmfwupgImageHeader*)pFwupgCtx->pImageData;
	md5_state_t ctx;
	static unsigned char md[HPMFWUPG_MD5_SIGNATURE_LENGTH];
	unsigned char *pMd5Sig = pFwupgCtx->pImageData
		+ (pFwupgCtx->imageSize - HPMFWUPG_MD5_SIGNATURE_LENGTH);
	/* Validate MD5 checksum */
	memset(md, 0, HPMFWUPG_MD5_SIGNATURE_LENGTH);
	memset(&ctx, 0, sizeof(md5_state_t));
	md5_init(&ctx);
	md5_append(&ctx, pFwupgCtx->pImageData,
			pFwupgCtx->imageSize - HPMFWUPG_MD5_SIGNATURE_LENGTH);
	md5_finish(&ctx, md);
	if (memcmp(md, pMd5Sig, HPMFWUPG_MD5_SIGNATURE_LENGTH) != 0) {
		lprintf(LOG_NOTICE, "\n    Invalid MD5 signature");
		return HPMFWUPG_ERROR;
	}
	/* Validate Header signature */
	if(strncmp(pImageHeader->signature,
				HPMFWUPG_IMAGE_SIGNATURE,
				HPMFWUPG_HEADER_SIGNATURE_LENGTH) != 0) {
		lprintf(LOG_NOTICE,"\n    Invalid image signature");
		return HPMFWUPG_ERROR;
	}
	/* Validate Header image format version */
	if (pImageHeader->formatVersion != HPMFWUPG_IMAGE_HEADER_VERSION) {
		lprintf(LOG_NOTICE,"\n    Unrecognized image version");
		return HPMFWUPG_ERROR;
	}
	/* Validate header checksum */
	if (HpmfwupgCalculateChecksum((unsigned char*)pImageHeader,
				sizeof(struct HpmfwupgImageHeader)
				+ pImageHeader->oemDataLength
				+ sizeof(unsigned char)/*checksum*/) != 0) {
		lprintf(LOG_NOTICE,"\n    Invalid header checksum");
		return HPMFWUPG_ERROR;
	}
	return HPMFWUPG_SUCCESS;
}

/* HpmfwupgPreparationStage - prepere stage of a firmware upgrade procedure as
 * defined in section 3.2 of the IPM Controller Firmware Upgrade Specification
 * version 1.0
 */
int
HpmfwupgPreparationStage(struct ipmi_intf *intf,
		struct HpmfwupgUpgradeCtx *pFwupgCtx, int option)
{
	int componentId;
	int rc = HPMFWUPG_SUCCESS;
	struct HpmfwupgGetTargetUpgCapabilitiesCtx targetCapCmd;
	struct HpmfwupgImageHeader *pImageHeader = (struct HpmfwupgImageHeader*)
		pFwupgCtx->pImageData;
	/* Get device ID */
	rc = HpmfwupgGetDeviceId(intf, &pFwupgCtx->devId);
	/* Match current IPMC IDs with upgrade image */
	if (rc != HPMFWUPG_SUCCESS) {
		return HPMFWUPG_ERROR;
	}
	/* Validate device ID */
	if (pImageHeader->deviceId == pFwupgCtx->devId.device_id) {
		/* Validate product ID */
		if (memcmp(pImageHeader->prodId,
					pFwupgCtx->devId.product_id,
					HPMFWUPG_PRODUCT_ID_LENGTH ) == 0) {
			/* Validate man ID */
			if (memcmp(pImageHeader->manId,
						pFwupgCtx->devId.manufacturer_id,
						HPMFWUPG_MANUFATURER_ID_LENGTH) != 0) {
				lprintf(LOG_NOTICE,
						"\n    Invalid image file for manufacturer %u",
						buf2short(pFwupgCtx->devId.manufacturer_id));
				rc = HPMFWUPG_ERROR;
			}
		} else {
			lprintf(LOG_NOTICE,
					"\n    Invalid image file for product %u",
					buf2short(pFwupgCtx->devId.product_id));
			rc = HPMFWUPG_ERROR;
		}
	} else {
		lprintf(LOG_NOTICE, "\n    Invalid device ID %x",
				pFwupgCtx->devId.device_id);
		rc = HPMFWUPG_ERROR;
	}
	if (rc != HPMFWUPG_SUCCESS) {
		/* Giving one more chance to user to check whether its OK to continue even if the
		 * product ID does not match. This is helpful as sometimes we just want to update
		 * and dont care whether we have a different product Id. If the user says NO then
		 * we need to just bail out from here
		 */
		if (!((option & FORCE_MODE) || (option & VIEW_MODE))) {
			printf("\n\n Use \"force\" option for copying all the components\n");
			return HPMFWUPG_ERROR;
		}
		printf("\n    Image Information");
		printf("\n        Device Id : 0x%x", pImageHeader->deviceId);
		printf("\n        Prod   Id : 0x%02x%02x",
				pImageHeader->prodId[1], pImageHeader->prodId[0]);
		printf("\n        Manuf  Id : 0x%02x%02x%02x",
				pImageHeader->manId[2],
				pImageHeader->manId[1],
				pImageHeader->manId[0]);
		printf("\n    Board Information");
		printf("\n        Device Id : 0x%x", pFwupgCtx->devId.device_id);
		printf("\n        Prod   Id : 0x%02x%02x",
				pFwupgCtx->devId.product_id[1], pFwupgCtx->devId.product_id[0]);
		printf("\n        Manuf  Id : 0x%02x%02x%02x",
				pFwupgCtx->devId.manufacturer_id[2],
				pFwupgCtx->devId.manufacturer_id[1],
				pFwupgCtx->devId.manufacturer_id[0]);
		if (HpmGetUserInput("\n Continue ignoring DeviceID/ProductID/ManufacturingID (Y/N): ")) {
			rc = HPMFWUPG_SUCCESS;
		} else {
			return HPMFWUPG_ERROR;
		}
	}
	/* Validate earliest compatible revision */
	/* Validate major & minor revision */
	if (pImageHeader->compRevision[0] > pFwupgCtx->devId.fw_rev1
			|| (pImageHeader->compRevision[0] == pFwupgCtx->devId.fw_rev1
				&& pImageHeader->compRevision[1] > pFwupgCtx->devId.fw_rev2)) {
		/* Version not compatible for upgrade */
		lprintf(LOG_NOTICE, "\n    Version: Major: %d", pImageHeader->compRevision[0]);
		lprintf(LOG_NOTICE, "             Minor: %x", pImageHeader->compRevision[1]);
		lprintf(LOG_NOTICE, "    Not compatible with ");
		lprintf(LOG_NOTICE, "    Version: Major: %d", pFwupgCtx->devId.fw_rev1);
		lprintf(LOG_NOTICE, "             Minor: %x", pFwupgCtx->devId.fw_rev2);
		/* Confirming it once again */
		if (!((option & FORCE_MODE) || (option & VIEW_MODE))) {
			return HPMFWUPG_ERROR;
		}
		if (HpmGetUserInput("\n Continue IGNORING Earliest compatibility (Y/N): ")) {
			rc = HPMFWUPG_SUCCESS;
		} else {
			return HPMFWUPG_ERROR;
		}
	}
	/* Get target upgrade capabilities */
	rc = HpmfwupgGetTargetUpgCapabilities(intf, &targetCapCmd);
	if (rc != HPMFWUPG_SUCCESS) {
		return HPMFWUPG_ERROR;
	}
	/* Copy response to context */
	memcpy(&pFwupgCtx->targetCap,
			&targetCapCmd.resp,
			sizeof(struct HpmfwupgGetTargetUpgCapabilitiesResp));
	if (option & VIEW_MODE) {
		/* do nothing */
	} else {
		/* Make sure all component IDs defined in the
		 * upgrade image are supported by the IPMC
		 */
		if ((pImageHeader->components.ComponentBits.byte &
					pFwupgCtx->targetCap.componentsPresent.ComponentBits.byte) !=
					pImageHeader->components.ComponentBits.byte) {
			lprintf(LOG_NOTICE,
					"\n    Some components present in the image file are not supported by the IPMC");
			return HPMFWUPG_ERROR;
		}
		/* Make sure the upgrade is desirable rigth now */
		if (pFwupgCtx->targetCap.GlobalCapabilities.bitField.fwUpgUndesirable == 1) {
			lprintf(LOG_NOTICE, "\n    Upgrade undesirable at this moment");
			return HPMFWUPG_ERROR;
		}
		/* Get confimation from the user if he wants to continue when
		 * service affected during upgrade
		 */
		if (!(option & COMPARE_MODE)
				&& (pFwupgCtx->targetCap.GlobalCapabilities.bitField.servAffectDuringUpg == 1
					|| pImageHeader->imageCapabilities.bitField.servAffected == 1)) {
			if (HpmGetUserInput("\nServices may be affected during upgrade. Do you wish to continue? (y/n): ")) {
				rc = HPMFWUPG_SUCCESS;
			} else {
				return HPMFWUPG_ERROR;
			}
		}
	}
	/* Get the general properties of each component present in image */
	for (componentId = HPMFWUPG_COMPONENT_ID_0;
			componentId < HPMFWUPG_COMPONENT_ID_MAX;
			componentId++) {
		/* Reset component properties */
		memset(&pFwupgCtx->genCompProp[componentId], 0,
				sizeof (struct HpmfwupgGetGeneralPropResp));
		if ((1 << componentId & pImageHeader->components.ComponentBits.byte)) {
			struct HpmfwupgGetComponentPropertiesCtx getCompPropCmd;
			/* Get general component properties */
			getCompPropCmd.req.componentId = componentId;
			getCompPropCmd.req.selector = HPMFWUPG_COMP_GEN_PROPERTIES;
			rc = HpmfwupgGetComponentProperties(intf, &getCompPropCmd);
			if (rc == HPMFWUPG_SUCCESS) {
				/* Copy response to context */
				memcpy(&pFwupgCtx->genCompProp[componentId],
						&getCompPropCmd.resp,
						sizeof(struct HpmfwupgGetGeneralPropResp));
			}
		}
	}
	return rc;
}

int
image_version_upgradable(VERSIONINFO *pVersionInfo)
{
	/* If the image and active target versions are different, then
	 * upgrade */
	if ((pVersionInfo->imageMajor != pVersionInfo->targetMajor)
			|| (pVersionInfo->imageMinor != pVersionInfo->targetMinor)
			|| (pVersionInfo->imageAux[0] != pVersionInfo->targetAux[0])
			|| (pVersionInfo->imageAux[1] != pVersionInfo->targetAux[1])
			|| (pVersionInfo->imageAux[2] != pVersionInfo->targetAux[2])
			|| (pVersionInfo->imageAux[3] != pVersionInfo->targetAux[3])) {
		return (1);
	}
	/* If the image and active target versions are the same and rollback
	 * is not supported, then there's nothing to do, skip the upgrade
	 */
	if (!pVersionInfo->rollbackSupported) {
		return (0);
	}
	/* If the image and rollback target versions are different, then
	 * go ahead and upgrade
	 */
	if ((pVersionInfo->imageMajor != pVersionInfo->rollbackMajor)
			|| (pVersionInfo->imageMinor != pVersionInfo->rollbackMinor)
			|| (pVersionInfo->imageAux[0] != pVersionInfo->rollbackAux[0])
			|| (pVersionInfo->imageAux[1] != pVersionInfo->rollbackAux[1])
			|| (pVersionInfo->imageAux[2] != pVersionInfo->rollbackAux[2])
			|| (pVersionInfo->imageAux[3] != pVersionInfo->rollbackAux[3])) {
		return (1);
	}
	/* Image and rollback target versions are the same too, skip it */
	return (0);
}

/* HpmfwupgValidateActionRecordChecksum - validate checksum of the specified
 * action record header.
 */
int
HpmfwupgValidateActionRecordChecksum(struct HpmfwupgActionRecord *pActionRecord)
{
	int rc = HPMFWUPG_SUCCESS;
	/* Validate action record checksum */
	if (HpmfwupgCalculateChecksum((unsigned char*)pActionRecord,
				sizeof(struct HpmfwupgActionRecord)) != 0) {
	/* Due to ambiguity in the HPM.1 specification, for the case of
	 * the Upload Firmware Image action type, the record header length
	 * might be thought as either the first 3 bytes, or the first 34 bytes
	 * which precede the firmware image data.
	 * For the latter case we re-calculate the Upload Firmware Image
	 * record checksum for the 34 byte header length.
	 */
		if (pActionRecord->actionType != HPMFWUPG_ACTION_UPLOAD_FIRMWARE
				|| HpmfwupgCalculateChecksum((unsigned char*)pActionRecord,
					sizeof(struct HpmfwupgActionRecord)
					+ sizeof(struct HpmfwupgFirmwareImage))) {
			lprintf(LOG_NOTICE, "    Invalid Action record.");
			rc = HPMFWUPG_ERROR;
		}
	}
	return rc;
}

/* HpmfwupgPreUpgradeCheck - make pre-Upgrade check, this mainly helps in
 * checking which all version upgrade is skippable because the image version
 * is same as target version.
 */
int
HpmfwupgPreUpgradeCheck(struct ipmi_intf *intf,
		struct HpmfwupgUpgradeCtx *pFwupgCtx,
		int componentMask, int option)
{
	unsigned char *pImagePtr;
	struct HpmfwupgActionRecord *pActionRecord;
	struct HpmfwupgImageHeader *pImageHeader;
	int componentId;
	pImageHeader = (struct HpmfwupgImageHeader*)pFwupgCtx->pImageData;
	/* Put pointer after image header */
	pImagePtr = (unsigned char*)(pFwupgCtx->pImageData
			+ sizeof(struct HpmfwupgImageHeader)
			+ pImageHeader->oemDataLength
			+ sizeof(unsigned char)/*chksum*/);
	if (option & VIEW_MODE) {
		HpmDisplayVersionHeader(TARGET_VER|ROLLBACK_VER|IMAGE_VER);
	}
	/* Perform actions defined in the image */
	while (pImagePtr < (pFwupgCtx->pImageData + pFwupgCtx->imageSize
				- HPMFWUPG_MD5_SIGNATURE_LENGTH)) {
		/* Get action record */
		pActionRecord = (struct HpmfwupgActionRecord*)pImagePtr;
		/* Validate action record checksum */
		if (HpmfwupgValidateActionRecordChecksum(pActionRecord) != HPMFWUPG_SUCCESS) {
			return HPMFWUPG_ERROR;
		}
		/* Validate affected components */
		if (pActionRecord->components.ComponentBits.byte
				&& !pFwupgCtx->targetCap.componentsPresent.ComponentBits.byte) {
			lprintf(LOG_NOTICE,
					"    Invalid action record. One or more affected components is not supported");
			return HPMFWUPG_ERROR;
		}
		switch (pActionRecord->actionType) {
		case HPMFWUPG_ACTION_BACKUP_COMPONENTS:
			{
				/* Make sure every component specified by
				 * this action record
				 * supports the backup operation
				 */
				for (componentId = HPMFWUPG_COMPONENT_ID_0;
						componentId < HPMFWUPG_COMPONENT_ID_MAX;
						componentId++) {
					if (((1 << componentId) & pActionRecord->components.ComponentBits.byte)
							&& pFwupgCtx->genCompProp[componentId].GeneralCompProperties.bitfield.rollbackBackup == 0) {
						lprintf(LOG_NOTICE,
								"    Component ID %d does not support backup",
								componentId);
						return HPMFWUPG_ERROR;
					}
				}
				pImagePtr += sizeof(struct HpmfwupgActionRecord);
			}
			break;
		case HPMFWUPG_ACTION_PREPARE_COMPONENTS:
			{
				/* Make sure every components specified by
				 * this action
				 * supports the prepare operation
				 */
				for (componentId = HPMFWUPG_COMPONENT_ID_0;
						componentId < HPMFWUPG_COMPONENT_ID_MAX;
						componentId++) {
					if (((1 << componentId) & pActionRecord->components.ComponentBits.byte)
							&& pFwupgCtx->genCompProp[componentId].GeneralCompProperties.bitfield.preparationSupport == 0) {
						lprintf(LOG_NOTICE,
								"    Component ID %d does not support preparation",
								componentId);
						return HPMFWUPG_ERROR;
					}
				}
				pImagePtr += sizeof(struct HpmfwupgActionRecord);
			}
			break;
		case HPMFWUPG_ACTION_UPLOAD_FIRMWARE:
			/* Upload all firmware blocks */
			{
				struct HpmfwupgFirmwareImage *pFwImage;
				unsigned char *pData;
				unsigned int firmwareLength;
				unsigned char mode;
				unsigned char componentId;
				unsigned char componentIdByte;
				unsigned int upgrade_comp;
				VERSIONINFO *pVersionInfo;
				/* Save component ID on which the upload is done */
				componentIdByte = pActionRecord->components.ComponentBits.byte;
				componentId = 0;
				while ((componentIdByte >>= 1) != 0) {
					componentId++;
				}
				pFwImage = (struct HpmfwupgFirmwareImage*)(pImagePtr
						+ sizeof(struct HpmfwupgActionRecord));
				pData = ((unsigned char*)pFwImage
						+ sizeof(struct HpmfwupgFirmwareImage));
				/* Get firmware length */
				firmwareLength  =  pFwImage->length[0];
				firmwareLength |= (pFwImage->length[1] << 8)  & 0xff00;
				firmwareLength |= (pFwImage->length[2] << 16) & 0xff0000;
				firmwareLength |= (pFwImage->length[3] << 24) & 0xff000000;

				pVersionInfo = &gVersionInfo[componentId];

				pVersionInfo->imageMajor   = pFwImage->version[0];
				pVersionInfo->imageMinor   = pFwImage->version[1];
				pVersionInfo->imageAux[0]  = pFwImage->version[2];
				pVersionInfo->imageAux[1]  = pFwImage->version[3];
				pVersionInfo->imageAux[2]  = pFwImage->version[4];
				pVersionInfo->imageAux[3]  = pFwImage->version[5];

				mode = TARGET_VER | IMAGE_VER;
				/* check if component is selected for upgrade */
				upgrade_comp = !componentMask
					|| (componentMask & pActionRecord->components.ComponentBits.byte);
				/* check if current component version requires upgrade */
				if (upgrade_comp && !(option & (FORCE_MODE|COMPARE_MODE))) {
					upgrade_comp = image_version_upgradable(pVersionInfo);
				}
				if (verbose) {
					lprintf(LOG_NOTICE,
							"%s component %d",
							(upgrade_comp ? "Updating" : "Skipping"), 
							componentId);
				}
				if (upgrade_comp) {
					pFwupgCtx->compUpdateMask.ComponentBits.byte|= 1 << componentId;
				}
				if (option & VIEW_MODE) {
					if (pVersionInfo->rollbackSupported) {
						mode|= ROLLBACK_VER;
					}
					HpmDisplayVersion(mode,pVersionInfo, upgrade_comp);
					printf("\n");
				}
				pImagePtr = pData + firmwareLength;
			}
			break;
		default:
			lprintf(LOG_NOTICE,
					"    Invalid Action type. Cannot continue");
			return HPMFWUPG_ERROR;
			break;
		}
	}
	if (option & VIEW_MODE) {
		HpmDisplayLine("-",74);
		fflush(stdout);
		lprintf(LOG_NOTICE,
				"(*) Component requires Payload Cold Reset");
		lprintf(LOG_NOTICE,
				"(^) Indicates component would be upgraded");
	}
	return HPMFWUPG_SUCCESS;
}

/* HpmfwupgUpgradeStage - upgrade stage of a firmware upgrade procedure as
 * defined in section 3.3 of the IPM Controller Firmware Upgrade Specification
 * version 1.0
 */
int
HpmfwupgUpgradeStage(struct ipmi_intf *intf,
		struct HpmfwupgUpgradeCtx *pFwupgCtx, int option)
{
	struct HpmfwupgImageHeader *pImageHeader = (struct HpmfwupgImageHeader*)
		pFwupgCtx->pImageData;
	struct HpmfwupgActionRecord* pActionRecord;
	int rc = HPMFWUPG_SUCCESS;
	unsigned char *pImagePtr;
	unsigned int actionsSize;
	int flagColdReset = FALSE;
	/* Put pointer after image header */
	pImagePtr = (unsigned char*)
		(pFwupgCtx->pImageData + sizeof(struct HpmfwupgImageHeader) +
		pImageHeader->oemDataLength + sizeof(unsigned char)/*checksum*/);
	/* Deternime actions size */
	actionsSize = pFwupgCtx->imageSize - sizeof(struct HpmfwupgImageHeader);
	if (!(option & VIEW_MODE)) {
		HpmDisplayUpgradeHeader();
	}
	/* Perform actions defined in the image */
	while (( pImagePtr < (pFwupgCtx->pImageData + pFwupgCtx->imageSize -
					HPMFWUPG_MD5_SIGNATURE_LENGTH))
			&& (rc == HPMFWUPG_SUCCESS)) {
		/* Get action record */
		pActionRecord = (struct HpmfwupgActionRecord*)pImagePtr;
		/* Validate action record checksum */
		rc = HpmfwupgValidateActionRecordChecksum(pActionRecord);
		if (rc != HPMFWUPG_SUCCESS) {
			continue;
		}
		switch(pActionRecord->actionType) {
		case HPMFWUPG_ACTION_BACKUP_COMPONENTS:
			{
				if (!(option & COMPARE_MODE)) {
					/* Send Upgrade Action command */
					struct HpmfwupgInitiateUpgradeActionCtx initUpgActionCmd;
					/* Affect only selected components */
					initUpgActionCmd.req.componentsMask.ComponentBits.byte =
						pFwupgCtx->compUpdateMask.ComponentBits.byte &
						pActionRecord->components.ComponentBits.byte;
					/* Action is prepare components */
					if (initUpgActionCmd.req.componentsMask.ComponentBits.byte) {
						initUpgActionCmd.req.upgradeAction  = HPMFWUPG_UPGRADE_ACTION_BACKUP;
						rc = HpmfwupgInitiateUpgradeAction(intf, &initUpgActionCmd, pFwupgCtx);
					}
				}
				pImagePtr+= sizeof(struct HpmfwupgActionRecord);
			}
			break;
		case HPMFWUPG_ACTION_PREPARE_COMPONENTS:
			{
				if (!(option & COMPARE_MODE)) {
					/* Send prepare components command */
					struct HpmfwupgInitiateUpgradeActionCtx initUpgActionCmd;
					/* Affect only selected components */
					initUpgActionCmd.req.componentsMask.ComponentBits.byte =
						pFwupgCtx->compUpdateMask.ComponentBits.byte &
						pActionRecord->components.ComponentBits.byte;
					if (initUpgActionCmd.req.componentsMask.ComponentBits.byte) {
						/* Action is prepare components */
						initUpgActionCmd.req.upgradeAction = HPMFWUPG_UPGRADE_ACTION_PREPARE;
						rc = HpmfwupgInitiateUpgradeAction(intf, &initUpgActionCmd, pFwupgCtx);
					}
				}
				pImagePtr+= sizeof(struct HpmfwupgActionRecord);
			}
			break;
		case HPMFWUPG_ACTION_UPLOAD_FIRMWARE:
			/* Upload all firmware blocks */
			rc = HpmFwupgActionUploadFirmware(pActionRecord->components,
					pFwupgCtx,
					&pImagePtr,
					intf,
					option,
					&flagColdReset);
			break;
		default:
			lprintf(LOG_NOTICE, "    Invalid Action type. Cannot continue");
			rc = HPMFWUPG_ERROR;
			break;
		}
	}
	HpmDisplayLine("-", 79);
	fflush(stdout);
	lprintf(LOG_NOTICE, "(*) Component requires Payload Cold Reset");
	return rc;
}

int
HpmFwupgActionUploadFirmware(struct HpmfwupgComponentBitMask components,
		struct HpmfwupgUpgradeCtx *pFwupgCtx,
		unsigned char **pImagePtr,
		struct ipmi_intf *intf,
		int option,
		int *pFlagColdReset)
{
	struct HpmfwupgFirmwareImage *pFwImage;
	struct HpmfwupgInitiateUpgradeActionCtx initUpgActionCmd;
	struct HpmfwupgUploadFirmwareBlockCtx uploadCmd;
	struct HpmfwupgFinishFirmwareUploadCtx finishCmd;
	VERSIONINFO *pVersionInfo;
	time_t start,end;

	int rc = HPMFWUPG_SUCCESS;
	int skip = TRUE;
	unsigned char *pData, *pDataInitial;
	unsigned short count;
	unsigned int totalSent = 0;
	unsigned short bufLength = 0;
	unsigned short bufLengthIsSet = 0;
	unsigned int firmwareLength = 0;

	unsigned int displayFWLength = 0;
	unsigned char *pDataTemp;
	unsigned int imageOffset = 0x00;
	unsigned int blockLength = 0x00;
	unsigned int lengthOfBlock = 0x00;
	unsigned int numTxPkts = 0;
	unsigned int numRxPkts = 0;
	unsigned char mode = 0;
	unsigned char componentId = 0x00;
	unsigned char componentIdByte = 0x00;
	uint16_t max_rq_size;

	/* Save component ID on which the upload is done */
	componentIdByte = components.ComponentBits.byte;
	while ((componentIdByte>>= 1) != 0) {
		componentId++;
	}
	pFwupgCtx->componentId = componentId;
	pVersionInfo = (VERSIONINFO *)&gVersionInfo[componentId];
	pFwImage = (struct HpmfwupgFirmwareImage*)((*pImagePtr)
			+ sizeof(struct HpmfwupgActionRecord));
	pDataInitial = ((unsigned char *)pFwImage
			+ sizeof(struct HpmfwupgFirmwareImage));
	pData = pDataInitial;

	/* Find max buffer length according the connection parameters */
	max_rq_size = ipmi_intf_get_max_request_data_size(intf);

	/* validate lower bound of max request size */
	if (max_rq_size <= sizeof(struct HpmfwupgUploadFirmwareBlockReq)) {
		lprintf(LOG_ERROR, "Maximum request size is too small to "
				"send a upload request.");
		return HPMFWUPG_ERROR;
	}

	bufLength = max_rq_size - sizeof(struct HpmfwupgUploadFirmwareBlockReq);

	/* Get firmware length */
	firmwareLength =  pFwImage->length[0];
	firmwareLength|= (pFwImage->length[1] << 8)  & 0xff00;
	firmwareLength|= (pFwImage->length[2] << 16) & 0xff0000;
	firmwareLength|= (pFwImage->length[3] << 24) & 0xff000000;
	mode = TARGET_VER | IMAGE_VER;
	if (pVersionInfo->rollbackSupported) {
		mode |= ROLLBACK_VER;
	}
	if ((option & DEBUG_MODE)) {
		printf("\n\n Comp ID : %d	 [%-20s]\n",
				pVersionInfo->componentId,
				pFwImage->desc);
	} else {
		HpmDisplayVersion(mode, pVersionInfo, 0);
	}
	if ((1 << componentId) & pFwupgCtx->compUpdateMask.ComponentBits.byte) {
		if (verbose) {
			lprintf(LOG_NOTICE, "Do not skip %d",
					componentId);
		}
		skip = FALSE;
	}
	if (!skip) {
		HpmDisplayUpgrade(0,0,1,0);
		/* Initialize parameters */
		uploadCmd.req = malloc(max_rq_size);
		if (!uploadCmd.req) {
			lprintf(LOG_ERR, "ipmitool: malloc failure");
			return HPMFWUPG_ERROR;
		}
		uploadCmd.req->blockNumber = 0;
		/* Send Initiate Upgrade Action */
		initUpgActionCmd.req.componentsMask = components;
		if (option & COMPARE_MODE) {
			/* Action is compare */
			initUpgActionCmd.req.upgradeAction = HPMFWUPG_UPGRADE_ACTION_COMPARE;
		} else {
			/* Action is upgrade */
			initUpgActionCmd.req.upgradeAction = HPMFWUPG_UPGRADE_ACTION_UPGRADE;
		}
		rc = HpmfwupgInitiateUpgradeAction(intf, &initUpgActionCmd, pFwupgCtx);
		if (rc != HPMFWUPG_SUCCESS) {
			skip = TRUE;
		}
		if ((pVersionInfo->coldResetRequired) && (!skip)) {
			*pFlagColdReset = TRUE;
		}
		/* pDataInitial is the starting pointer of the image data  */
		/* pDataTemp is one which we will move across */
		pData = pDataInitial;
		pDataTemp = pDataInitial;
		lengthOfBlock = firmwareLength;
		totalSent = 0x00;
		displayFWLength= firmwareLength;
		time(&start);
		while ((pData < (pDataTemp+lengthOfBlock)) && (rc == HPMFWUPG_SUCCESS)) {
			if ((pData+bufLength) <= (pDataTemp+lengthOfBlock)) {
				count = bufLength;
			} else {
				count = (unsigned short)((pDataTemp+lengthOfBlock) - pData);
			}
			memcpy(&uploadCmd.req->data, pData, bufLength);
			imageOffset = 0x00;
			blockLength = 0x00;
			numTxPkts++;
			rc = HpmfwupgUploadFirmwareBlock(intf, &uploadCmd,
					pFwupgCtx, count, &imageOffset,&blockLength);
			numRxPkts++;
			if (rc != HPMFWUPG_SUCCESS) {
				if (rc == HPMFWUPG_UPLOAD_BLOCK_LENGTH && !bufLengthIsSet) {
					rc = HPMFWUPG_SUCCESS;
					/* Retry with a smaller buffer length */
					if (strstr(intf->name,"lan") != NULL && bufLength > 8) {
						bufLength-= 8;
						lprintf(LOG_INFO,
								"Trying reduced buffer length: %d",
								bufLength);
					} else if (bufLength) {
						bufLength-= 1;
						lprintf(LOG_INFO,
								"Trying reduced buffer length: %d",
								bufLength);
					} else {
						rc = HPMFWUPG_ERROR;
					}
				} else if (rc == HPMFWUPG_UPLOAD_RETRY) {
					rc = HPMFWUPG_SUCCESS;
				} else {
					fflush(stdout);
					lprintf(LOG_NOTICE,
							"\n Error in Upload FIRMWARE command [rc=%d]\n",
							rc);
					lprintf(LOG_NOTICE,
							"\n TotalSent:0x%x ",
							totalSent);
					/* Exiting from the function */
					rc = HPMFWUPG_ERROR;
				}
			} else {
				/* success, buf length is valid */
				bufLengthIsSet = 1;
				if (imageOffset + blockLength > firmwareLength ||
						imageOffset + blockLength < blockLength) {
					/*
					 * blockLength is the remaining length of the firmware to upload so
					 * if imageOffset and blockLength sum is greater than the firmware
					 * length then its kind of error
					 */
					lprintf(LOG_NOTICE,
							"\n Error in Upload FIRMWARE command [rc=%d]\n",
							rc);
					lprintf(LOG_NOTICE,
							"\n TotalSent:0x%x Img offset:0x%x  Blk length:0x%x  Fwlen:0x%x\n",
							totalSent,imageOffset,blockLength,firmwareLength);
					rc = HPMFWUPG_ERROR;
					continue;
				}
				totalSent += count;
				if (imageOffset != 0x00) {
					/* block Length is valid  */
					lengthOfBlock = blockLength;
					pDataTemp = pDataInitial + imageOffset;
					pData = pDataTemp;
					if (displayFWLength == firmwareLength) {
						/* This is basically used only to make sure that we display uptil 100% */
						displayFWLength = blockLength + totalSent;
					}
				} else {
					pData += count;
				}
				time(&end);
				/*
				 * Just added debug mode in case we need to see exactly how many bytes have
				 * gone through - Its a hidden option used mainly should be used for debugging
				 */
				if (option & DEBUG_MODE) {
					fflush(stdout);
					printf(" Blk Num : %02x        Bytes : %05x ",
							uploadCmd.req->blockNumber,totalSent);
					if (imageOffset || blockLength) {
						printf("\n--> ImgOff : %x BlkLen : %x\n",
								imageOffset,blockLength);
					}
					if (displayFWLength == totalSent) {
						printf("\n Time Taken %02ld:%02ld",
								(end-start)/60, (end-start)%60);
						printf("\n\n");
					}
				} else {
					HpmDisplayUpgrade(0, totalSent,
							displayFWLength, (end-start));
				}
				uploadCmd.req->blockNumber++;
			}
		}
		/* free buffer */
		free(uploadCmd.req);
		uploadCmd.req = NULL;
	}
	if (skip) {
		HpmDisplayUpgrade(1,0,0,0);
		if ((option & COMPARE_MODE)
				&& !pFwupgCtx->genCompProp[pFwupgCtx->componentId].GeneralCompProperties.bitfield.comparisonSupport) {
			printf("|    |Comparison isn't supported for given compenent.                        |\n");
		}
		*pImagePtr = pDataInitial + firmwareLength;
	}
	if (rc == HPMFWUPG_SUCCESS && !skip) {
		/* Send finish component */
		/* Set image length */
		finishCmd.req.componentId = componentId;
		/* We need to send the actual data that is sent
		 * not the comlete firmware image length
		 */
		finishCmd.req.imageLength[0] = totalSent & 0xFF;
		finishCmd.req.imageLength[1] = (totalSent >> 8) & 0xFF;
		finishCmd.req.imageLength[2] = (totalSent >> 16) & 0xFF;
		finishCmd.req.imageLength[3] = (totalSent >> 24) & 0xFF;
		rc = HpmfwupgFinishFirmwareUpload(intf, &finishCmd,
				pFwupgCtx, option);
		*pImagePtr = pDataInitial + firmwareLength;
	}
	return rc;
}

/* HpmfwupgActivationStage - validate stage of a firmware upgrade procedure as
 * defined in section 3.4 of the IPM Controller Firmware Upgrade Specification
 * version 1.0
 */
int
HpmfwupgActivationStage(struct ipmi_intf *intf,
		struct HpmfwupgUpgradeCtx *pFwupgCtx)
{
	int rc = HPMFWUPG_SUCCESS;
	struct HpmfwupgActivateFirmwareCtx activateCmd;
	struct HpmfwupgImageHeader *pImageHeader = (struct HpmfwupgImageHeader*)
		pFwupgCtx->pImageData;
	/* Print out stuf...*/
	printf("    ");
	fflush(stdout);
	/* Activate new firmware */
	activateCmd.req.rollback_override = 0;
	rc = HpmfwupgActivateFirmware(intf, &activateCmd, pFwupgCtx);
	if (rc == HPMFWUPG_SUCCESS) {
		/* Query self test result if supported by target and new image */
		if ((pFwupgCtx->targetCap.GlobalCapabilities.bitField.ipmcSelftestCap == 1)
				|| (pImageHeader->imageCapabilities.bitField.imageSelfTest == 1)) {
			struct HpmfwupgQuerySelftestResultCtx selfTestCmd;
			rc = HpmfwupgQuerySelftestResult(intf, &selfTestCmd,
					pFwupgCtx);
			if (rc == HPMFWUPG_SUCCESS) {
				/* Get the self test result */
				if (selfTestCmd.resp.result1 != 0x55) {
					/* Perform manual rollback if necessary */
					/* BACKUP/ MANUAL ROLLBACK not supported by this UA */
					lprintf(LOG_NOTICE, "    Self test failed:");
					lprintf(LOG_NOTICE, "    Result1 = %x",
							selfTestCmd.resp.result1);
					lprintf(LOG_NOTICE, "    Result2 = %x",
							selfTestCmd.resp.result2);
					rc = HPMFWUPG_ERROR;
				}
			} else {
				/* Perform manual rollback if necessary */
				/* BACKUP / MANUAL ROLLBACK not supported by this UA */
				lprintf(LOG_NOTICE,"    Self test failed.");
			}
		}
	}
	/* If activation / self test failed, query rollback
	 * status if automatic rollback supported
	 */
	if (rc == HPMFWUPG_ERROR) {
		if ((pFwupgCtx->targetCap.GlobalCapabilities.bitField.autRollback == 1)
				&& (pFwupgCtx->genCompProp[pFwupgCtx->componentId].GeneralCompProperties.bitfield.rollbackBackup != 0x00)) {
			struct HpmfwupgQueryRollbackStatusCtx rollCmd;
			lprintf(LOG_NOTICE,"    Getting rollback status...");
			fflush(stdout);
			rc = HpmfwupgQueryRollbackStatus(intf,
					&rollCmd, pFwupgCtx);
		}
	}
	return rc;
}

int
HpmfwupgGetBufferFromFile(char *imageFilename,
		struct HpmfwupgUpgradeCtx *pFwupgCtx)
{
	int rc = HPMFWUPG_SUCCESS;
	int ret = 0;
	FILE *pImageFile = fopen(imageFilename, "rb");
	if (pImageFile == NULL) {
		lprintf(LOG_ERR, "Cannot open image file '%s'",
				imageFilename);
		return HPMFWUPG_ERROR;
	}
	/* Get the raw data in file */
	fseek(pImageFile, 0, SEEK_END);
	pFwupgCtx->imageSize  = ftell(pImageFile);
	pFwupgCtx->pImageData = malloc(sizeof(unsigned char)*pFwupgCtx->imageSize);
	if (pFwupgCtx->pImageData == NULL) {
		lprintf(LOG_ERR, "ipmitool: malloc failure");
		fclose(pImageFile);
		return HPMFWUPG_ERROR;
	}
	rewind(pImageFile);
	ret = fread(pFwupgCtx->pImageData,
			sizeof(unsigned char),
			pFwupgCtx->imageSize,
			pImageFile);
	if (ret != pFwupgCtx->imageSize) {
		lprintf(LOG_ERR,
				"Failed to read file %s size %d", 
				imageFilename,
				pFwupgCtx->imageSize);
		rc = HPMFWUPG_ERROR;
	}
	fclose(pImageFile);
	return rc;
}

int
HpmfwupgGetDeviceId(struct ipmi_intf *intf, struct ipm_devid_rsp *pGetDevId)
{
	struct ipmi_rs *rsp;
	struct ipmi_rq req;
	memset(&req, 0, sizeof(req));
	req.msg.netfn = IPMI_NETFN_APP;
	req.msg.cmd = BMC_GET_DEVICE_ID;
	req.msg.data_len = 0;
	rsp = HpmfwupgSendCmd(intf, req, NULL);
	if (rsp == NULL) {
		lprintf(LOG_ERR, "Error getting device ID.");
		return HPMFWUPG_ERROR;
	}
	if (rsp->ccode != 0x00) {
		lprintf(LOG_ERR, "Error getting device ID.");
		lprintf(LOG_ERR, "compcode=0x%x: %s",
				rsp->ccode,
				val2str(rsp->ccode, completion_code_vals));
		return HPMFWUPG_ERROR;
	}
	memcpy(pGetDevId, rsp->data, sizeof(struct ipm_devid_rsp));
	return HPMFWUPG_SUCCESS;
}

int
HpmfwupgGetTargetUpgCapabilities(struct ipmi_intf *intf,
		struct HpmfwupgGetTargetUpgCapabilitiesCtx *pCtx)
{
	struct ipmi_rs *rsp;
	struct ipmi_rq req;
	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
	memset(&req, 0, sizeof(req));
	req.msg.netfn = IPMI_NETFN_PICMG;
	req.msg.cmd = HPMFWUPG_GET_TARGET_UPG_CAPABILITIES;
	req.msg.data = (unsigned char*)&pCtx->req;
	req.msg.data_len = sizeof(struct HpmfwupgGetTargetUpgCapabilitiesReq);
	rsp = HpmfwupgSendCmd(intf, req, NULL);
	if (rsp == NULL) {
		lprintf(LOG_ERR,
				"Error getting target upgrade capabilities.");
		return HPMFWUPG_ERROR;
	}
	if (rsp->ccode != 0x00) {
		lprintf(LOG_ERR,
				"Error getting target upgrade capabilities, ccode: 0x%x: %s",
				rsp->ccode,
				val2str(rsp->ccode, completion_code_vals));
		return HPMFWUPG_ERROR;
	}
	memcpy(&pCtx->resp, rsp->data,
			sizeof(struct HpmfwupgGetTargetUpgCapabilitiesResp));
	if (verbose) {
		lprintf(LOG_NOTICE, "TARGET UPGRADE CAPABILITIES");
		lprintf(LOG_NOTICE, "-------------------------------");
		lprintf(LOG_NOTICE, "HPM.1 version............%d    ",
				pCtx->resp.hpmVersion);
		lprintf(LOG_NOTICE, "Component 0 presence....[%c]   ",
				pCtx->resp.componentsPresent.ComponentBits.bitField.component0 ? 'y' : 'n');
		lprintf(LOG_NOTICE, "Component 1 presence....[%c]   ",
				pCtx->resp.componentsPresent.ComponentBits.bitField.component1 ? 'y' : 'n');
		lprintf(LOG_NOTICE, "Component 2 presence....[%c]   ",
				pCtx->resp.componentsPresent.ComponentBits.bitField.component2 ? 'y' : 'n');
		lprintf(LOG_NOTICE, "Component 3 presence....[%c]   ",
				pCtx->resp.componentsPresent.ComponentBits.bitField.component3 ? 'y' : 'n');
		lprintf(LOG_NOTICE, "Component 4 presence....[%c]   ",
				pCtx->resp.componentsPresent.ComponentBits.bitField.component4 ? 'y' : 'n');
		lprintf(LOG_NOTICE, "Component 5 presence....[%c]   ",
				pCtx->resp.componentsPresent.ComponentBits.bitField.component5 ? 'y' : 'n');
		lprintf(LOG_NOTICE, "Component 6 presence....[%c]   ",
				pCtx->resp.componentsPresent.ComponentBits.bitField.component6 ? 'y' : 'n');
		lprintf(LOG_NOTICE, "Component 7 presence....[%c]   ",
				pCtx->resp.componentsPresent.ComponentBits.bitField.component7 ? 'y' : 'n');
		lprintf(LOG_NOTICE, "Upgrade undesirable.....[%c]   ",
				pCtx->resp.GlobalCapabilities.bitField.fwUpgUndesirable ? 'y' : 'n');
		lprintf(LOG_NOTICE, "Aut rollback override...[%c]   ",
				pCtx->resp.GlobalCapabilities.bitField.autRollbackOverride ? 'y' : 'n');
		lprintf(LOG_NOTICE, "IPMC degraded...........[%c]   ",
				pCtx->resp.GlobalCapabilities.bitField.ipmcDegradedDurinUpg ? 'y' : 'n');
		lprintf(LOG_NOTICE, "Defered activation......[%c]   ",
				pCtx->resp.GlobalCapabilities.bitField.deferActivation ? 'y' : 'n');
		lprintf(LOG_NOTICE, "Service affected........[%c]   ",
				pCtx->resp.GlobalCapabilities.bitField.servAffectDuringUpg ? 'y' : 'n');
		lprintf(LOG_NOTICE, "Manual rollback.........[%c]   ",
				pCtx->resp.GlobalCapabilities.bitField.manualRollback ? 'y' : 'n');
		lprintf(LOG_NOTICE, "Automatic rollback......[%c]   ",
				pCtx->resp.GlobalCapabilities.bitField.autRollback ? 'y' : 'n');
		lprintf(LOG_NOTICE, "Self test...............[%c]   ",
				pCtx->resp.GlobalCapabilities.bitField.ipmcSelftestCap ? 'y' : 'n');
		lprintf(LOG_NOTICE, "Upgrade timeout.........[%d sec] ",
				pCtx->resp.upgradeTimeout*5);
		lprintf(LOG_NOTICE, "Self test timeout.......[%d sec] ",
				pCtx->resp.selftestTimeout*5);
		lprintf(LOG_NOTICE, "Rollback timeout........[%d sec] ",
				pCtx->resp.rollbackTimeout*5);
		lprintf(LOG_NOTICE, "Inaccessibility timeout.[%d sec] \n",
				pCtx->resp.inaccessTimeout*5);
	}
	return HPMFWUPG_SUCCESS;
}

int
HpmfwupgGetComponentProperties(struct ipmi_intf *intf,
		struct HpmfwupgGetComponentPropertiesCtx *pCtx)
{
	int rc = HPMFWUPG_SUCCESS;
	struct ipmi_rs * rsp;
	struct ipmi_rq req;
	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
	memset(&req, 0, sizeof(req));
	req.msg.netfn = IPMI_NETFN_PICMG;
	req.msg.cmd = HPMFWUPG_GET_COMPONENT_PROPERTIES;
	req.msg.data = (unsigned char*)&pCtx->req;
	req.msg.data_len = sizeof(struct HpmfwupgGetComponentPropertiesReq);
	rsp = HpmfwupgSendCmd(intf, req, NULL);
	if (rsp == NULL) {
		lprintf(LOG_NOTICE,
				"Error getting component properties\n");
		return HPMFWUPG_ERROR;
	}
	if (rsp->ccode != 0x00) {
		lprintf(LOG_NOTICE,
				"Error getting component properties");
		lprintf(LOG_NOTICE,
				"compcode=0x%x: %s",
				rsp->ccode,
				val2str(rsp->ccode, completion_code_vals));
		return HPMFWUPG_ERROR;
	}
	switch (pCtx->req.selector) {
	case HPMFWUPG_COMP_GEN_PROPERTIES:
		memcpy(&pCtx->resp, rsp->data, sizeof(struct HpmfwupgGetGeneralPropResp));
		if (verbose) {
			lprintf(LOG_NOTICE, "GENERAL PROPERTIES");
			lprintf(LOG_NOTICE, "-------------------------------");
			lprintf(LOG_NOTICE, "Payload cold reset req....[%c]   ",
					pCtx->resp.Response.generalPropResp.GeneralCompProperties.bitfield.payloadColdReset ? 'y' : 'n');
			lprintf(LOG_NOTICE, "Def. activation supported.[%c]   ",
					pCtx->resp.Response.generalPropResp.GeneralCompProperties.bitfield.deferredActivation ? 'y' : 'n');
			lprintf(LOG_NOTICE, "Comparison supported......[%c]   ",
					pCtx->resp.Response.generalPropResp.GeneralCompProperties.bitfield.comparisonSupport ? 'y' : 'n');
			lprintf(LOG_NOTICE, "Preparation supported.....[%c]   ",
					pCtx->resp.Response.generalPropResp.GeneralCompProperties.bitfield.preparationSupport ? 'y' : 'n');
			lprintf(LOG_NOTICE, "Rollback supported........[%c]   \n",
					pCtx->resp.Response.generalPropResp.GeneralCompProperties.bitfield.rollbackBackup ? 'y' : 'n');
		}
		break;
	case HPMFWUPG_COMP_CURRENT_VERSION:
		memcpy(&pCtx->resp, rsp->data,
				sizeof(struct HpmfwupgGetCurrentVersionResp));
		if (verbose) {
			lprintf(LOG_NOTICE, "Current Version: ");
			lprintf(LOG_NOTICE, " Major: %d",
					pCtx->resp.Response.currentVersionResp.currentVersion[0]);
			lprintf(LOG_NOTICE, " Minor: %x",
					pCtx->resp.Response.currentVersionResp.currentVersion[1]);
			lprintf(LOG_NOTICE, " Aux  : %03d %03d %03d %03d\n",
					pCtx->resp.Response.currentVersionResp.currentVersion[2],
					pCtx->resp.Response.currentVersionResp.currentVersion[3],
					pCtx->resp.Response.currentVersionResp.currentVersion[4],
					pCtx->resp.Response.currentVersionResp.currentVersion[5]);
		}
		break;
	case HPMFWUPG_COMP_DESCRIPTION_STRING:
		memcpy(&pCtx->resp, rsp->data,
				sizeof(struct HpmfwupgGetDescStringResp));
		if (verbose) {
			char descString[HPMFWUPG_DESC_STRING_LENGTH + 1];
			memcpy(descString,
					pCtx->resp.Response.descStringResp.descString,
					HPMFWUPG_DESC_STRING_LENGTH);
			descString[HPMFWUPG_DESC_STRING_LENGTH] = '\0';
			lprintf(LOG_NOTICE,
					"Description string: %s\n",
					descString);
		}
		break;
	case HPMFWUPG_COMP_ROLLBACK_FIRMWARE_VERSION:
		memcpy(&pCtx->resp, rsp->data, sizeof(struct HpmfwupgGetRollbackFwVersionResp));
		if (verbose) {
			lprintf(LOG_NOTICE, "Rollback FW Version: ");
			lprintf(LOG_NOTICE, " Major: %d",
					pCtx->resp.Response.rollbackFwVersionResp.rollbackFwVersion[0]);
			lprintf(LOG_NOTICE, " Minor: %x",
					pCtx->resp.Response.rollbackFwVersionResp.rollbackFwVersion[1]);
			lprintf(LOG_NOTICE, " Aux  : %03d %03d %03d %03d\n",
					pCtx->resp.Response.rollbackFwVersionResp.rollbackFwVersion[2],
					pCtx->resp.Response.rollbackFwVersionResp.rollbackFwVersion[3],
					pCtx->resp.Response.rollbackFwVersionResp.rollbackFwVersion[4],
					pCtx->resp.Response.rollbackFwVersionResp.rollbackFwVersion[5]);
		}
		break;
	case HPMFWUPG_COMP_DEFERRED_FIRMWARE_VERSION:
		memcpy(&pCtx->resp, rsp->data, sizeof(struct HpmfwupgGetDeferredFwVersionResp));
		if (verbose) {
			lprintf(LOG_NOTICE, "Deferred FW Version: ");
			lprintf(LOG_NOTICE, " Major: %d",
					pCtx->resp.Response.deferredFwVersionResp.deferredFwVersion[0]);
			lprintf(LOG_NOTICE, " Minor: %x",
					pCtx->resp.Response.deferredFwVersionResp.deferredFwVersion[1]);
			lprintf(LOG_NOTICE, " Aux  : %03d %03d %03d %03d\n",
					pCtx->resp.Response.deferredFwVersionResp.deferredFwVersion[2],
					pCtx->resp.Response.deferredFwVersionResp.deferredFwVersion[3],
					pCtx->resp.Response.deferredFwVersionResp.deferredFwVersion[4],
					pCtx->resp.Response.deferredFwVersionResp.deferredFwVersion[5]);
		}
		break;
	case HPMFWUPG_COMP_OEM_PROPERTIES:
		/* OEM Properties command */
		memcpy(&pCtx->resp, rsp->data, sizeof(struct HpmfwupgGetOemProperties));
		if (verbose) {
			unsigned char i = 0;
			lprintf(LOG_NOTICE,"OEM Properties: ");
			for (i=0; i < HPMFWUPG_OEM_LENGTH; i++) {
				lprintf(LOG_NOTICE, " 0x%x ",
						pCtx->resp.Response.oemProperties.oemRspData[i]);
			}
		}
		break;
	default:
		lprintf(LOG_NOTICE,"Unsupported component selector");
		rc = HPMFWUPG_ERROR;
		break;
	}
	return rc;
}

int
HpmfwupgAbortUpgrade(struct ipmi_intf *intf,
		struct HpmfwupgAbortUpgradeCtx *pCtx)
{
	int rc = HPMFWUPG_SUCCESS;
	struct ipmi_rs *rsp;
	struct ipmi_rq req;
	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
	memset(&req, 0, sizeof(req));
	req.msg.netfn = IPMI_NETFN_PICMG;
	req.msg.cmd = HPMFWUPG_ABORT_UPGRADE;
	req.msg.data = (unsigned char*)&pCtx->req;
	req.msg.data_len = sizeof(struct HpmfwupgAbortUpgradeReq);
	rsp = HpmfwupgSendCmd(intf, req, NULL);
	if (rsp == NULL) {
		lprintf(LOG_ERR, "Error - aborting upgrade.");
		return HPMFWUPG_ERROR;
	}
	if (rsp->ccode != 0x00) {
		lprintf(LOG_ERR, "Error aborting upgrade");
		lprintf(LOG_ERR, "compcode=0x%x: %s",
				rsp->ccode,
				val2str(rsp->ccode, completion_code_vals));
		rc = HPMFWUPG_ERROR;
	}
	return rc;
}

int
HpmfwupgInitiateUpgradeAction(struct ipmi_intf *intf,
		struct HpmfwupgInitiateUpgradeActionCtx *pCtx,
		struct HpmfwupgUpgradeCtx *pFwupgCtx)
{
	int rc = HPMFWUPG_SUCCESS;
	struct ipmi_rs *rsp;
	struct ipmi_rq req;
	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
	memset(&req, 0, sizeof(req));
	req.msg.netfn = IPMI_NETFN_PICMG;
	req.msg.cmd = HPMFWUPG_INITIATE_UPGRADE_ACTION;
	req.msg.data = (unsigned char*)&pCtx->req;
	req.msg.data_len = sizeof(struct HpmfwupgInitiateUpgradeActionReq);
	rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
	if (rsp == NULL) {
		lprintf(LOG_ERR, "Error initiating upgrade action.");
		return HPMFWUPG_ERROR;
	}
	/* Long duration command handling */
	if (rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS) {
		rc = HpmfwupgWaitLongDurationCmd(intf, pFwupgCtx);
	} else if (rsp->ccode != 0x00) {
		lprintf(LOG_NOTICE,"Error initiating upgrade action");
		lprintf(LOG_NOTICE, "compcode=0x%x: %s",
				rsp->ccode,
				val2str(rsp->ccode, completion_code_vals));
		rc = HPMFWUPG_ERROR;
	}
	return rc;
}

int
HpmfwupgUploadFirmwareBlock(struct ipmi_intf *intf,
		struct HpmfwupgUploadFirmwareBlockCtx *pCtx,
		struct HpmfwupgUpgradeCtx *pFwupgCtx, int count,
		unsigned int *imageOffset, unsigned int *blockLength)
{
	int rc = HPMFWUPG_SUCCESS;
	struct ipmi_rs *rsp;
	struct ipmi_rq req;
	pCtx->req->picmgId = HPMFWUPG_PICMG_IDENTIFIER;
	memset(&req, 0, sizeof(req));
	req.msg.netfn = IPMI_NETFN_PICMG;
	req.msg.cmd = HPMFWUPG_UPLOAD_FIRMWARE_BLOCK;
	req.msg.data = (unsigned char *)pCtx->req;
	/* 2 is the size of the upload struct - data */
	req.msg.data_len = 2 + count;
	rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
	if (rsp == NULL) {
		lprintf(LOG_NOTICE, "Error uploading firmware block.");
		return HPMFWUPG_ERROR;
	}
	if (rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS
			|| rsp->ccode == 0x00) {
		/*
		 * We need to check if the response also contains the next upload firmware offset
		 * and the firmware length in its response - These are optional but very vital
		 */
		if (rsp->data_len > 1) {
			/*
			 * If the response data length is greater than 1 it should contain both the
			 * the Section offset and section length. Because we cannot just have
			 * Section offset without section length so the length should be 9
			 */
			if (rsp->data_len == 9) {
				/* rsp->data[1] - LSB  rsp->data[2]  - rsp->data[3] = MSB */
				*imageOffset = (rsp->data[4] << 24) + (rsp->data[3] << 16) + (rsp->data[2] << 8) + rsp->data[1];
				*blockLength = (rsp->data[8] << 24) + (rsp->data[7] << 16) + (rsp->data[6] << 8) + rsp->data[5];
			} else {
				 /*
				 * The Spec does not say much for this kind of errors where the
				 * firmware returned only offset and length so currently returning it
				 * as 0x82 - Internal CheckSum Error
				 */
				lprintf(LOG_NOTICE,
						"Error wrong rsp->datalen %d for Upload Firmware block command\n",
						rsp->data_len);
				rsp->ccode = HPMFWUPG_INT_CHECKSUM_ERROR;
			}
		}
	}
	/* Long duration command handling */
	if (rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS) {
		rc = HpmfwupgWaitLongDurationCmd(intf, pFwupgCtx);
	} else if (rsp->ccode != 0x00)  {
		/* PATCH --> This validation is to handle retryables errors codes on IPMB bus.
		 *           This will be fixed in the next release of open ipmi and this
		 *           check will have to be removed. (Buggy version = 39)
		 */
		if (HPMFWUPG_IS_RETRYABLE(rsp->ccode)) {
			lprintf(LOG_DEBUG, "HPM: [PATCH]Retryable error detected");
			rc = HPMFWUPG_UPLOAD_RETRY;
		} else if (rsp->ccode == IPMI_CC_REQ_DATA_INV_LENGTH ||
				rsp->ccode == IPMI_CC_REQ_DATA_FIELD_EXCEED) {
			/* If completion code = 0xc7(0xc8), we will retry with a reduced buffer length.
			 * Do not print error.
			 */
			rc = HPMFWUPG_UPLOAD_BLOCK_LENGTH;
		} else {
			lprintf(LOG_ERR, "Error uploading firmware block");
			lprintf(LOG_ERR, "compcode=0x%x: %s",
					rsp->ccode,
					val2str(rsp->ccode,
						completion_code_vals));
			rc = HPMFWUPG_ERROR;
		}
	}
	return rc;
}

int
HpmfwupgFinishFirmwareUpload(struct ipmi_intf *intf,
		struct HpmfwupgFinishFirmwareUploadCtx *pCtx,
		struct HpmfwupgUpgradeCtx *pFwupgCtx, int option)
{
	int rc = HPMFWUPG_SUCCESS;
	struct ipmi_rs *rsp;
	struct ipmi_rq req;
	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
	memset(&req, 0, sizeof(req));
	req.msg.netfn = IPMI_NETFN_PICMG;
	req.msg.cmd = HPMFWUPG_FINISH_FIRMWARE_UPLOAD;
	req.msg.data = (unsigned char*)&pCtx->req;
	req.msg.data_len = sizeof(struct HpmfwupgFinishFirmwareUploadReq);
	rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
	if (rsp == NULL) {
		lprintf(LOG_ERR, "Error fininshing firmware upload.");
		return HPMFWUPG_ERROR;
	}
	/* Long duration command handling */
	if (rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS) {
		rc = HpmfwupgWaitLongDurationCmd(intf, pFwupgCtx);
	} else if ((option & COMPARE_MODE) && rsp->ccode == 0x83) {
		printf("|    |Component's active copy doesn't match the upgrade image                 |\n");
	} else if ((option & COMPARE_MODE) && rsp->ccode == IPMI_CC_OK) {
		printf("|    |Comparison passed                                                       |\n");
	} else if ( rsp->ccode != IPMI_CC_OK ) {
		lprintf(LOG_ERR, "Error finishing firmware upload");
		lprintf(LOG_ERR, "compcode=0x%x: %s",
				rsp->ccode,
				val2str(rsp->ccode, completion_code_vals));
		rc = HPMFWUPG_ERROR;
	}
	return rc;
}

int
HpmfwupgActivateFirmware(struct ipmi_intf *intf,
		struct HpmfwupgActivateFirmwareCtx *pCtx,
		struct HpmfwupgUpgradeCtx *pFwupgCtx)
{
	int rc = HPMFWUPG_SUCCESS;
	struct ipmi_rs *rsp;
	struct ipmi_rq req;
	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
	memset(&req, 0, sizeof(req));
	req.msg.netfn = IPMI_NETFN_PICMG;
	req.msg.cmd = HPMFWUPG_ACTIVATE_FIRMWARE;
	req.msg.data = (unsigned char*)&pCtx->req;
	req.msg.data_len = sizeof(struct HpmfwupgActivateFirmwareReq)
		- (!pCtx->req.rollback_override ? 1 : 0);
	rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
	if (rsp == NULL) {
		lprintf(LOG_ERR, "Error activating firmware.");
		return HPMFWUPG_ERROR;
	}
	/* Long duration command handling */
	if (rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS) {
		printf("Waiting firmware activation...");
		fflush(stdout);
		rc = HpmfwupgWaitLongDurationCmd(intf, pFwupgCtx);
		if (rc == HPMFWUPG_SUCCESS) {
			lprintf(LOG_NOTICE, "OK");
		} else {
			lprintf(LOG_NOTICE, "Failed");
		}
	} else if (rsp->ccode != IPMI_CC_OK) {
		lprintf(LOG_ERR, "Error activating firmware");
		lprintf(LOG_ERR, "compcode=0x%x: %s",
				rsp->ccode,
				val2str(rsp->ccode, completion_code_vals));
		rc = HPMFWUPG_ERROR;
	}
	return rc;
}

int
HpmfwupgGetUpgradeStatus(struct ipmi_intf *intf,
		struct HpmfwupgGetUpgradeStatusCtx *pCtx,
		struct HpmfwupgUpgradeCtx *pFwupgCtx,
		int silent)
{
	struct ipmi_rs *rsp;
	struct ipmi_rq req;
	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
	memset(&req, 0, sizeof(req));
	req.msg.netfn = IPMI_NETFN_PICMG;
	req.msg.cmd = HPMFWUPG_GET_UPGRADE_STATUS;
	req.msg.data = (unsigned char*)&pCtx->req;
	req.msg.data_len = sizeof(struct HpmfwupgGetUpgradeStatusReq);
	rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
	if (!rsp) {
		lprintf(LOG_NOTICE,
				"Error getting upgrade status. Failed to get response.");
		return HPMFWUPG_ERROR;
	}
	if (rsp->ccode == 0x00) {
		memcpy(&pCtx->resp, rsp->data, 
				sizeof(struct HpmfwupgGetUpgradeStatusResp));
		if (!silent) {
			lprintf(LOG_NOTICE, "Upgrade status:");
			lprintf(LOG_NOTICE,
					" Command in progress:          %x",
					pCtx->resp.cmdInProcess);
			lprintf(LOG_NOTICE,
					" Last command completion code: %x",
					pCtx->resp.lastCmdCompCode);
		}
	} else if (HPMFWUPG_IS_RETRYABLE(rsp->ccode)) {
		/* PATCH --> This validation is to handle retryable errors 
		 *           codes on the IPMB bus.
		 *           This will be fixed in the next release of 
		 *           open ipmi and this check can be removed. 
		 *           (Buggy version = 39)
		 */
		if (!silent) {
			lprintf(LOG_DEBUG, "HPM: Retryable error detected");
		}
		pCtx->resp.lastCmdCompCode = HPMFWUPG_COMMAND_IN_PROGRESS;
	} else {
		lprintf(LOG_NOTICE, "Error getting upgrade status");
		lprintf(LOG_NOTICE, "compcode=0x%x: %s", rsp->ccode,
				val2str(rsp->ccode, completion_code_vals));
		return HPMFWUPG_ERROR;
	}
	return HPMFWUPG_SUCCESS;
}

int
HpmfwupgManualFirmwareRollback(struct ipmi_intf *intf,
		struct HpmfwupgManualFirmwareRollbackCtx *pCtx)
{
	struct HpmfwupgUpgradeCtx fwupgCtx;
	struct HpmfwupgGetTargetUpgCapabilitiesCtx targetCapCmd;
	int rc = HPMFWUPG_SUCCESS;
	struct ipmi_rs *rsp;
	struct ipmi_rq req;
	/* prepare fake upgrade context */
	memset(&fwupgCtx, 0, sizeof (fwupgCtx));
	verbose--;
	rc = HpmfwupgGetTargetUpgCapabilities(intf, &targetCapCmd);
	verbose++;
	if (rc != HPMFWUPG_SUCCESS) {
		return rc;
	}
	memcpy(&fwupgCtx.targetCap, &targetCapCmd.resp, sizeof(targetCapCmd.resp));
	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
	memset(&req, 0, sizeof(req));
	req.msg.netfn = IPMI_NETFN_PICMG;
	req.msg.cmd = HPMFWUPG_MANUAL_FIRMWARE_ROLLBACK;
	req.msg.data = (unsigned char*)&pCtx->req;
	req.msg.data_len = sizeof(struct HpmfwupgManualFirmwareRollbackReq);
	rsp = HpmfwupgSendCmd(intf, req, &fwupgCtx);
	if (rsp == NULL) {
		lprintf(LOG_ERR, "Error sending manual rollback.");
		return HPMFWUPG_ERROR;
	}
	/* Long duration command handling */
	if (rsp->ccode == IPMI_CC_OK
			|| rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS) {
		struct HpmfwupgQueryRollbackStatusCtx resCmd;
		printf("Waiting firmware rollback...");
		fflush(stdout);
		rc = HpmfwupgQueryRollbackStatus(intf, &resCmd, &fwupgCtx);
	} else if ( rsp->ccode != 0x00 ) {
		lprintf(LOG_ERR, "Error sending manual rollback");
		lprintf(LOG_ERR, "compcode=0x%x: %s",  
				rsp->ccode,
				val2str(rsp->ccode, completion_code_vals));
		rc = HPMFWUPG_ERROR;
	}
	return rc;
}

int
HpmfwupgQueryRollbackStatus(struct ipmi_intf *intf,
		struct HpmfwupgQueryRollbackStatusCtx *pCtx,
		struct HpmfwupgUpgradeCtx *pFwupgCtx)
{
	int rc = HPMFWUPG_SUCCESS;
	struct ipmi_rs *rsp;
	struct ipmi_rq req;
	unsigned int rollbackTimeout = 0;
	unsigned int timeoutSec1, timeoutSec2;
	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
	memset(&req, 0, sizeof(req));
	req.msg.netfn = IPMI_NETFN_PICMG;
	req.msg.cmd = HPMFWUPG_QUERY_ROLLBACK_STATUS;
	req.msg.data = (unsigned char*)&pCtx->req;
	req.msg.data_len = sizeof(struct HpmfwupgQueryRollbackStatusReq);
	/* If we are not in upgrade context, we use default timeout values */
	if (pFwupgCtx != NULL) {
		struct HpmfwupgImageHeader *pImageHeader;
		if (pFwupgCtx->pImageData) {
			pImageHeader = (struct HpmfwupgImageHeader*)pFwupgCtx->pImageData;
			rollbackTimeout = pImageHeader->rollbackTimeout;
		} else {
			rollbackTimeout = 0;
		}
		/* Use the greater of the two timeouts (header and target caps) */
		rollbackTimeout = MAX(rollbackTimeout,
				pFwupgCtx->targetCap.rollbackTimeout) * 5;
	} else {
		rollbackTimeout = HPMFWUPG_DEFAULT_UPGRADE_TIMEOUT;
	}
	/* Poll rollback status until completion or timeout */
	timeoutSec1 = time(NULL);
	timeoutSec2 = time(NULL);
	do {
		/* Must wait at least 100 ms between status requests */
		usleep(100000);
		rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
		/* PATCH --> This validation is to handle retryables errors codes on IPMB bus.
		 *           This will be fixed in the next release of open ipmi and this
		 *           check will have to be removed. (Buggy version = 39)
		 */
		if (rsp) {
			if (HPMFWUPG_IS_RETRYABLE(rsp->ccode)) {
				lprintf(LOG_DEBUG,"HPM: [PATCH]Retryable error detected");
				rsp->ccode = HPMFWUPG_COMMAND_IN_PROGRESS;
			}
		}
		timeoutSec2 = time(NULL);
	} while (rsp
			&& ((rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS)
				|| (rsp->ccode == IPMI_CC_TIMEOUT))
			&& (timeoutSec2 - timeoutSec1 < rollbackTimeout));
	if (rsp == NULL) {
		lprintf(LOG_ERR, "Error getting upgrade status.");
		return HPMFWUPG_ERROR;
	}
	if (rsp->ccode == 0x00) {
		memcpy(&pCtx->resp, rsp->data,
				sizeof(struct HpmfwupgQueryRollbackStatusResp));
		if (pCtx->resp.rollbackComp.ComponentBits.byte != 0) {
			/* Rollback occured */
			lprintf(LOG_NOTICE,
					"Rollback occured on component mask: 0x%02x",
					pCtx->resp.rollbackComp.ComponentBits.byte);
		} else {
			lprintf(LOG_NOTICE,
					"No Firmware rollback occured");
		}
	} else if (rsp->ccode == 0x81) {
		lprintf(LOG_ERR,
				"Rollback failed on component mask: 0x%02x",
				pCtx->resp.rollbackComp.ComponentBits.byte);
		rc = HPMFWUPG_ERROR;
	} else {
		lprintf(LOG_ERR,
				"Error getting rollback status");
		lprintf(LOG_ERR,
				"compcode=0x%x: %s",  
				rsp->ccode,
				val2str(rsp->ccode, completion_code_vals));
		rc = HPMFWUPG_ERROR;
	}
	return rc;
}

int
HpmfwupgQuerySelftestResult(struct ipmi_intf *intf, struct HpmfwupgQuerySelftestResultCtx *pCtx,
		struct HpmfwupgUpgradeCtx *pFwupgCtx)
{
	int rc = HPMFWUPG_SUCCESS;
	struct ipmi_rs *rsp;
	struct ipmi_rq req;
	unsigned char selfTestTimeout = 0;
	unsigned int timeoutSec1, timeoutSec2;
	pCtx->req.picmgId = HPMFWUPG_PICMG_IDENTIFIER;
	/* If we are not in upgrade context, we use default timeout values */
	if (pFwupgCtx != NULL) {
		/* Getting selftest timeout from new image */
		struct HpmfwupgImageHeader *pImageHeader = (struct HpmfwupgImageHeader*)
			pFwupgCtx->pImageData;
		selfTestTimeout = MAX(pImageHeader->selfTestTimeout,
		pFwupgCtx->targetCap.selftestTimeout) * 5;
	} else {
		selfTestTimeout = HPMFWUPG_DEFAULT_UPGRADE_TIMEOUT;
	}
	memset(&req, 0, sizeof(req));
	req.msg.netfn = IPMI_NETFN_PICMG;
	req.msg.cmd = HPMFWUPG_QUERY_SELFTEST_RESULT;
	req.msg.data = (unsigned char*)&pCtx->req;
	req.msg.data_len = sizeof(struct HpmfwupgQuerySelftestResultReq);
	/* Poll rollback status until completion or timeout */
	timeoutSec1 = time(NULL);
	timeoutSec2 = time(NULL);
	do {
		/* Must wait at least 100 ms between status requests */
		usleep(100000);
		rsp = HpmfwupgSendCmd(intf, req, pFwupgCtx);
		/* PATCH --> This validation is to handle retryables errors codes on IPMB bus.
		 *           This will be fixed in the next release of open ipmi and this
		 *           check will have to be removed. (Buggy version = 39)
		 */
		if (rsp) {
			if (HPMFWUPG_IS_RETRYABLE(rsp->ccode)) {
				lprintf(LOG_DEBUG,
						"HPM: [PATCH]Retryable error detected");
				rsp->ccode = HPMFWUPG_COMMAND_IN_PROGRESS;
			}
		}
		timeoutSec2 = time(NULL);
	} while (rsp
			&& (rsp->ccode == HPMFWUPG_COMMAND_IN_PROGRESS)
			&& (timeoutSec2 - timeoutSec1 < selfTestTimeout));
	if (rsp == NULL) {
		lprintf(LOG_NOTICE, "Error getting upgrade status\n");
		return HPMFWUPG_ERROR;
	}
	if (rsp->ccode == 0x00) {
		memcpy(&pCtx->resp, rsp->data,
				sizeof(struct HpmfwupgQuerySelftestResultResp));
		if (verbose) {
			lprintf(LOG_NOTICE, "Self test results:");
			lprintf(LOG_NOTICE, "Result1 = %x",
					pCtx->resp.result1);
			lprintf(LOG_NOTICE, "Result2 = %x",
					pCtx->resp.result2);
		}
	} else {
		lprintf(LOG_NOTICE, "Error getting self test results");
		lprintf(LOG_NOTICE, "compcode=0x%x: %s",
				rsp->ccode,
				val2str(rsp->ccode, completion_code_vals));
		rc = HPMFWUPG_ERROR;
	}
	return rc;
}

struct ipmi_rs *
HpmfwupgSendCmd(struct ipmi_intf *intf, struct ipmi_rq req,
		struct HpmfwupgUpgradeCtx *pFwupgCtx)
{
	struct ipmi_rs *rsp;
	unsigned int inaccessTimeout = 0, inaccessTimeoutCounter = 0;
	unsigned int upgradeTimeout  = 0, upgradeTimeoutCounter  = 0;
	unsigned int  timeoutSec1, timeoutSec2;
	unsigned char retry = 0;
	/* If we are not in upgrade context, we use default timeout values */
	if (pFwupgCtx != NULL) {
		inaccessTimeout = pFwupgCtx->targetCap.inaccessTimeout*5;
		upgradeTimeout  = pFwupgCtx->targetCap.upgradeTimeout*5;
	} else {
		/* keeping the inaccessTimeout to 60 seconds results in almost 2900 retries
		 * So if the target is not available it will be retrying the command for 2900
		 * times which is not effecient -So reducing the Timout to 5 seconds which is
		 * almost 200 retries if it continuously recieves 0xC3 as completion code.
		 */
		inaccessTimeout = HPMFWUPG_DEFAULT_UPGRADE_TIMEOUT;
		upgradeTimeout  = HPMFWUPG_DEFAULT_UPGRADE_TIMEOUT;
	}
	timeoutSec1 = time(NULL);
	do {
		static unsigned char isValidSize = FALSE;
		rsp = intf->sendrecv(intf, &req);
		if (rsp == NULL) {
			#define HPM_LAN_PACKET_RESIZE_LIMIT 6
			/* also covers lanplus */
			if (strstr(intf->name, "lan") != NULL) {
				static int errorCount=0;
				static struct ipmi_rs fakeRsp;
				lprintf(LOG_DEBUG,
						"HPM: no response available");
				lprintf(LOG_DEBUG,
						"HPM: the command may be rejected for security reasons");
				if (req.msg.netfn == IPMI_NETFN_PICMG
						&& req.msg.cmd == HPMFWUPG_UPLOAD_FIRMWARE_BLOCK
						&& errorCount < HPM_LAN_PACKET_RESIZE_LIMIT
						&& (!isValidSize)) {
					lprintf(LOG_DEBUG,
							"HPM: upload firmware block API called");
					lprintf(LOG_DEBUG,
							"HPM: returning length error to force resize");
					fakeRsp.ccode = IPMI_CC_REQ_DATA_INV_LENGTH;
					rsp = &fakeRsp;
					errorCount++;
				} else if (req.msg.netfn == IPMI_NETFN_PICMG
						&& (req.msg.cmd == HPMFWUPG_ACTIVATE_FIRMWARE
							|| req.msg.cmd == HPMFWUPG_MANUAL_FIRMWARE_ROLLBACK)) {
					/*
					 * rsp == NULL and command activate firmware or manual firmware
					 * rollback most likely occurs when we have sent a firmware activation
					 * request. Fake a command in progress response.
					 */
					lprintf(LOG_DEBUG,
							"HPM: activate/rollback firmware API called");
					lprintf(LOG_DEBUG,
							"HPM: returning in progress to handle IOL session lost");
					fakeRsp.ccode = HPMFWUPG_COMMAND_IN_PROGRESS;
					rsp = &fakeRsp;
				} else if (req.msg.netfn == IPMI_NETFN_PICMG
						&& (req.msg.cmd == HPMFWUPG_QUERY_ROLLBACK_STATUS
							|| req.msg.cmd == HPMFWUPG_GET_UPGRADE_STATUS
							|| req.msg.cmd == HPMFWUPG_QUERY_SELFTEST_RESULT)
						&& ( !intf->target_addr || intf->target_addr == intf->my_addr)) {
					/* reopen session only if target IPMC is directly accessed */
					/*
					 * rsp == NULL and command get upgrade status or query rollback
					 * status most likely occurs when we are waiting for firmware
					 * activation. Try to re-open the IOL session (re-open will work
					 * once the IPMC recovers from firmware activation.
					 */
					lprintf(LOG_DEBUG, "HPM: upg/rollback status firmware API called");
					lprintf(LOG_DEBUG, "HPM: try to re-open IOL session");
					{
						/* force session re-open */
						intf->opened = 0;
						intf->session->authtype = IPMI_SESSION_AUTHTYPE_NONE;
						intf->session->session_id = 0;
						intf->session->in_seq = 0;
						intf->session->out_seq = 0;
						intf->session->active = 0;
						intf->session->retry = 10;
						while (intf->open(intf) == HPMFWUPG_ERROR
								&& inaccessTimeoutCounter < inaccessTimeout) {
							inaccessTimeoutCounter += (time(NULL) - timeoutSec1);
							timeoutSec1 = time(NULL);
						}
						/* Fake timeout to retry command */
						fakeRsp.ccode = 0xc3;
						rsp = &fakeRsp;
					}
				}
			}
		}
		/* Handle inaccessibility timeout (rsp = NULL if IOL) */
		if (rsp == NULL || rsp->ccode == 0xff || rsp->ccode == 0xc3 || rsp->ccode == 0xd3) {
			if (inaccessTimeoutCounter < inaccessTimeout) {
				timeoutSec2 = time(NULL);
				if (timeoutSec2 > timeoutSec1) {
					inaccessTimeoutCounter += timeoutSec2 - timeoutSec1;
					timeoutSec1 = time(NULL);
				}
				usleep(100000);
				retry = 1;
			} else {
				retry = 0;
			}
		} else if ( rsp->ccode == 0xc0 ) {
			/* Handle node busy timeout */
			if (upgradeTimeoutCounter < upgradeTimeout) {
				timeoutSec2 = time(NULL);
				if (timeoutSec2 > timeoutSec1) {
					timeoutSec1 = time(NULL);
					upgradeTimeoutCounter += timeoutSec2 - timeoutSec1;
				}
				usleep(100000);
				retry = 1;
			} else {
				retry = 0;
			}
		} else {
# ifdef ENABLE_OPENIPMI_V39_PATCH
			if (rsp->ccode == IPMI_CC_OK) {
				errorCount = 0 ;
			}
# endif
			retry = 0;
			if (req.msg.netfn == IPMI_NETFN_PICMG
					&& req.msg.cmd == HPMFWUPG_UPLOAD_FIRMWARE_BLOCK
					&& (!isValidSize)) {
				lprintf(LOG_INFO,
						"Buffer length is now considered valid");
				isValidSize = TRUE;
			}
		}
	} while (retry);
	return rsp;
}

int
HpmfwupgWaitLongDurationCmd(struct ipmi_intf *intf,
		struct HpmfwupgUpgradeCtx *pFwupgCtx)
{
	int rc = HPMFWUPG_SUCCESS;
	unsigned int upgradeTimeout = 0;
	unsigned int  timeoutSec1, timeoutSec2;
	struct HpmfwupgGetUpgradeStatusCtx upgStatusCmd;
	/* If we are not in upgrade context, we use default timeout values */
	if (pFwupgCtx != NULL) {
		upgradeTimeout = (unsigned int)(pFwupgCtx->targetCap.upgradeTimeout*5);
		if (verbose) {
			printf("Use File Upgrade Capabilities: %i seconds\n",
					upgradeTimeout);
		}
	} else {
		/* Try to retreive from Caps */
		struct HpmfwupgGetTargetUpgCapabilitiesCtx targetCapCmd;
		if(HpmfwupgGetTargetUpgCapabilities(intf, &targetCapCmd) != HPMFWUPG_SUCCESS) {
			upgradeTimeout = HPMFWUPG_DEFAULT_UPGRADE_TIMEOUT;
			if (verbose) {
				printf("Use default timeout: %i seconds\n",
						upgradeTimeout);
			}
		} else {
			upgradeTimeout = (unsigned int)(targetCapCmd.resp.upgradeTimeout * 5);
			if (verbose) {
				printf("Use Command Upgrade Capabilities Timeout: %i seconds\n",
						upgradeTimeout);
			}
		}
	}
	if (rc == HPMFWUPG_SUCCESS) {
		/* Poll upgrade status until completion or timeout*/
		timeoutSec1 = time(NULL);
		timeoutSec2 = time(NULL);
		rc = HpmfwupgGetUpgradeStatus(intf, &upgStatusCmd,
				pFwupgCtx, 1);
	}
	while (
			/* With KCS: Cover the case where we sometime
			 * receive d5 (on the first get status) from
			 * the ipmi driver.
			 */
			(upgStatusCmd.resp.lastCmdCompCode == 0x80 ||
					upgStatusCmd.resp.lastCmdCompCode == 0xD5)
			&& ((timeoutSec2 - timeoutSec1) < upgradeTimeout )
			&& (rc == HPMFWUPG_SUCCESS)) {
		/* Must wait at least 1000 ms between status requests */
		usleep(1000000);
		timeoutSec2 = time(NULL);
		rc = HpmfwupgGetUpgradeStatus(intf, &upgStatusCmd, pFwupgCtx, 1);
/*
 *		printf("Get Status: %x - %x = %x _ %x [%x]\n",
 (				timeoutSec2, timeoutSec1,
 *				(timeoutSec2 - timeoutSec1),
 *				upgradeTimeout, rc);
 */
	}
	if (upgStatusCmd.resp.lastCmdCompCode != 0x00) {
		if (verbose) {
			lprintf(LOG_NOTICE,
					"Error waiting for command %x, compcode = %x",
					upgStatusCmd.resp.cmdInProcess,
					upgStatusCmd.resp.lastCmdCompCode);
		}
		rc = HPMFWUPG_ERROR;
	}
	return rc;
}

unsigned char
HpmfwupgCalculateChecksum(unsigned char *pData, unsigned int length)
{
	unsigned char checksum = 0;
	int dataIdx = 0;
	for (dataIdx = 0; dataIdx < length; dataIdx++) {
		checksum += pData[dataIdx];
	}
	return checksum;
}

void
HpmfwupgPrintUsage(void)
{
	lprintf(LOG_NOTICE,
"help                    - This help menu.");
	lprintf(LOG_NOTICE,
"");
	lprintf(LOG_NOTICE,
"check                   - Check the target information.");
	lprintf(LOG_NOTICE,
"check <file>            - If the user is unsure of what update is going to be ");
	lprintf(LOG_NOTICE,
"                          This will display the existing target version and");
	lprintf(LOG_NOTICE,
"                          image version on the screen");
	lprintf(LOG_NOTICE,
"");
	lprintf(LOG_NOTICE,
"upgrade <file> [component x...] [force] [activate]");
	lprintf(LOG_NOTICE,
"                        - Copies components from a valid HPM.1 image to the target.");
	lprintf(LOG_NOTICE,
"                          If one or more components specified by \"component\",");
	lprintf(LOG_NOTICE,
"                          only the specified components are copied.");
	lprintf(LOG_NOTICE,
"                          Otherwise, all the image components are copied.");
	lprintf(LOG_NOTICE,
"                          Before copy, each image component undergoes a version check");
	lprintf(LOG_NOTICE,
"                          and can be skipped if the target component version");
	lprintf(LOG_NOTICE,
"                          is the same or more recent.");
	lprintf(LOG_NOTICE,
"                          Use \"force\" to bypass the version check results.");
	lprintf(LOG_NOTICE,
"                          Make sure to check the versions first using the");
	lprintf(LOG_NOTICE,
"                          \"check <file>\" command.");
	lprintf(LOG_NOTICE,
"                          If \"activate\" is specified, the newly uploaded firmware");
	lprintf(LOG_NOTICE,
"                          is activated.");
	lprintf(LOG_NOTICE,
"upgstatus               - Returns the status of the last long duration command.");
	lprintf(LOG_NOTICE,
"");
	lprintf(LOG_NOTICE,
"compare <file>          - Perform \"Comparison of the Active Copy\" action for all the");
	lprintf(LOG_NOTICE,
"                          components present in the file.");
	lprintf(LOG_NOTICE,
"compare <file> component x - Compare only component <x> from the given <file>");
	lprintf(LOG_NOTICE,
"activate                - Activate the newly uploaded firmware.");
	lprintf(LOG_NOTICE,
"activate norollback     - Activate the newly uploaded firmware but inform");
	lprintf(LOG_NOTICE,
"                          the target to not automatically rollback if ");
	lprintf(LOG_NOTICE,
"                          the upgrade fails.");
	lprintf(LOG_NOTICE,
"");
	lprintf(LOG_NOTICE,
"targetcap               - Get the target upgrade capabilities.");
	lprintf(LOG_NOTICE,
"");
	lprintf(LOG_NOTICE,
"compprop <id> <prop>    - Get specified component properties from the target.");
	lprintf(LOG_NOTICE,
"                          Valid component <id>: 0-7 ");
	lprintf(LOG_NOTICE,
"                          Properties <prop> can be one of the following: ");
	lprintf(LOG_NOTICE,
"                          0- General properties");
	lprintf(LOG_NOTICE,
"                          1- Current firmware version");
	lprintf(LOG_NOTICE,
"                          2- Description string");
	lprintf(LOG_NOTICE,
"                          3- Rollback firmware version");
	lprintf(LOG_NOTICE,
"                          4- Deferred firmware version");
	lprintf(LOG_NOTICE,
"");
	lprintf(LOG_NOTICE,
"abort                   - Abort the on-going firmware upgrade.");
	lprintf(LOG_NOTICE,
"");
	lprintf(LOG_NOTICE,
"rollback                - Performs a manual rollback on the IPM Controller.");
	lprintf(LOG_NOTICE,
"                          firmware");
	lprintf(LOG_NOTICE,
"rollbackstatus          - Query the rollback status.");
	lprintf(LOG_NOTICE,
"");
	lprintf(LOG_NOTICE,
"selftestresult          - Query the self test results.\n");
}

int
ipmi_hpmfwupg_main(struct ipmi_intf *intf, int argc, char **argv)
{
	int rc = HPMFWUPG_SUCCESS;
	int activateFlag = 0x00;
	int componentMask = 0;
	int componentId = 0;
	int option = 0;

	lprintf(LOG_DEBUG,"ipmi_hpmfwupg_main()");
	lprintf(LOG_NOTICE, "\nPICMG HPM.1 Upgrade Agent %d.%d.%d: \n",
			HPMFWUPG_VERSION_MAJOR, HPMFWUPG_VERSION_MINOR,
			HPMFWUPG_VERSION_SUBMINOR);
	if (argc < 1) {
		lprintf(LOG_ERR, "Not enough parameters given.");
		HpmfwupgPrintUsage();
		return HPMFWUPG_ERROR;
	}
	if (strcmp(argv[0], "help") == 0) {
		HpmfwupgPrintUsage();
		return HPMFWUPG_SUCCESS;
	} else if ((strcmp(argv[0], "check") == 0)) {
		/* hpm check */
		if (argv[1] == NULL) {
			rc = HpmfwupgTargetCheck(intf,VIEW_MODE);
		} else {
			/* hpm check <filename> */
			rc = HpmfwupgTargetCheck(intf,0);
			if (rc == HPMFWUPG_SUCCESS) {
				rc = HpmfwupgUpgrade(intf, argv[1], 0,
						0, VIEW_MODE);
			}
		}
	} else if (strcmp(argv[0], "upgrade") == 0) {
		int i =0;
		for (i=1; i< argc ; i++) {
			if (strcmp(argv[i],"activate") == 0) {
				activateFlag = 1;
			}
			/* hpm upgrade <filename> force */
			if (strcmp(argv[i],"force") == 0) {
				option |= FORCE_MODE;
			}
			/* hpm upgrade <filename> component <comp Id> */
			if (strcmp(argv[i],"component") == 0) {
				if (i+1 < argc) {
					/* Error Checking */
					if (str2int(argv[i+1], &componentId) != 0
							|| componentId < 0
							|| componentId > HPMFWUPG_COMPONENT_ID_MAX) {
						lprintf(LOG_ERR,
								"Given Component ID '%s' is invalid.",
								argv[i+1]);
						lprintf(LOG_ERR,
								"Valid Compoment ID is: <0..7>");
						return HPMFWUPG_ERROR;
					}
					if( verbose ) {
						lprintf(LOG_NOTICE,
								"Component Id %d provided",
								componentId );
					}
					componentMask |= 1 << componentId;
				} else {
					/* That indicates the user has
					 * given component on console but
					 * not given any ID
					 */
					lprintf(LOG_NOTICE,
							"No component Id provided\n");
					return  HPMFWUPG_ERROR;
				}
			}
			if (strcmp(argv[i],"debug") == 0) {
				option |= DEBUG_MODE;
			}
		}
		rc = HpmfwupgTargetCheck(intf, 0);
		if (rc == HPMFWUPG_SUCCESS) {
			/* Call the Upgrade function to start the upgrade */
			rc = HpmfwupgUpgrade(intf, argv[1], activateFlag,
					componentMask, option);
		}
	} else if (strcmp(argv[0], "compare") == 0) {
		int i = 0;
		for (i=1; i< argc; i++) {
			/* hpm compare <file> [component x...] */
			if (strcmp(argv[i],"component") == 0) {
				if (i+1 < argc) {
					/* Error Checking */
					if (str2int(argv[i+1], &componentId) != 0
							|| componentId < 0
							|| componentId > HPMFWUPG_COMPONENT_ID_MAX) {
						lprintf(LOG_ERR,
								"Given Component ID '%s' is invalid.",
								argv[i+1]);
						lprintf(LOG_ERR,
								"Valid Compoment ID is: <0..7>");
						return HPMFWUPG_ERROR;
					}
					if( verbose ) {
						lprintf(LOG_NOTICE,
								"Component Id %d provided",
								componentId);
					}
					componentMask|= 1 << componentId;
				} else {
					/* That indicates the user
					 * has given component on
					 * console but not
					 * given any ID
					 */
					lprintf(LOG_NOTICE,
							"No component Id provided\n");
					return  HPMFWUPG_ERROR;
				}
			} else if (strcmp(argv[i],"debug") == 0) {
				option|= DEBUG_MODE;
			}
		}
		option|= (COMPARE_MODE);
		rc = HpmfwupgTargetCheck(intf, 0);
		if (rc == HPMFWUPG_SUCCESS) {
			rc = HpmfwupgUpgrade(intf, argv[1], 0,
					componentMask, option);
		}
	} else if ((argc >= 1) && (strcmp(argv[0], "activate") == 0)) {
		struct HpmfwupgActivateFirmwareCtx cmdCtx;
		if ((argc == 2) && (strcmp(argv[1], "norollback") == 0)) {
			cmdCtx.req.rollback_override = 1;
		} else {
			cmdCtx.req.rollback_override = 0;
		}
		rc = HpmfwupgActivateFirmware(intf, &cmdCtx, NULL);
	} else if ((argc == 1) && (strcmp(argv[0], "targetcap") == 0)) {
		struct HpmfwupgGetTargetUpgCapabilitiesCtx cmdCtx;
		verbose++;
		rc = HpmfwupgGetTargetUpgCapabilities(intf, &cmdCtx);
	} else if ((argc == 3) && (strcmp(argv[0], "compprop") == 0)) {
		struct HpmfwupgGetComponentPropertiesCtx cmdCtx;
		if (str2uchar(argv[1], &(cmdCtx.req.componentId)) != 0
				|| cmdCtx.req.componentId > 7) {
			lprintf(LOG_ERR,
					"Given Component ID '%s' is invalid.",
					argv[1]);
			lprintf(LOG_ERR,
					"Valid Compoment ID is: <0..7>");
			return (-1);
		}
		if (str2uchar(argv[2], &(cmdCtx.req.selector)) != 0
				|| cmdCtx.req.selector > 4) {
			lprintf(LOG_ERR,
					"Given Properties selector '%s' is invalid.",
					argv[2]);
			lprintf(LOG_ERR,
					"Valid Properties selector is: <0..4>");
			return (-1);
		}
		verbose++;
		rc = HpmfwupgGetComponentProperties(intf, &cmdCtx);
	} else if ((argc == 1) && (strcmp(argv[0], "abort") == 0)) {
		struct HpmfwupgAbortUpgradeCtx cmdCtx;
		verbose++;
		rc = HpmfwupgAbortUpgrade(intf, &cmdCtx);
	} else if ((argc == 1) && (strcmp(argv[0], "upgstatus") == 0)) {
		struct HpmfwupgGetUpgradeStatusCtx cmdCtx;
		verbose++;
		rc = HpmfwupgGetUpgradeStatus(intf, &cmdCtx, NULL, 0);
	} else if ((argc == 1) && (strcmp(argv[0], "rollback") == 0)) {
		struct HpmfwupgManualFirmwareRollbackCtx cmdCtx;
		verbose++;
		rc = HpmfwupgManualFirmwareRollback(intf, &cmdCtx);
	} else if ((argc == 1) && (strcmp(argv[0], "rollbackstatus") == 0)) {
		struct HpmfwupgQueryRollbackStatusCtx  cmdCtx;
		verbose++;
		rc = HpmfwupgQueryRollbackStatus(intf, &cmdCtx, NULL);
	} else if ((argc == 1) && (strcmp(argv[0], "selftestresult") == 0)) {
		struct HpmfwupgQuerySelftestResultCtx cmdCtx;
		verbose++;
		rc = HpmfwupgQuerySelftestResult(intf, &cmdCtx, NULL);
	} else {
		lprintf(LOG_ERR, "Invalid HPM command: %s", argv[0]);
		HpmfwupgPrintUsage();
		rc = HPMFWUPG_ERROR;
	}
	return rc;
}