Change H->hpp & C->cpp
Change-Id: I4bb8cf7a58c517f348a524d3e027ebcd1dcd0dea
Signed-off-by: Matthew Barth <msbarth@us.ibm.com>
diff --git a/writefrudata.cpp b/writefrudata.cpp
new file mode 100644
index 0000000..3619966
--- /dev/null
+++ b/writefrudata.cpp
@@ -0,0 +1,797 @@
+#include <vector>
+#include <stdlib.h>
+#include <dlfcn.h>
+#include <errno.h>
+#include <stdio.h>
+#include <systemd/sd-bus.h>
+#include <unistd.h>
+#include <host-ipmid/ipmid-api.h>
+#include <iostream>
+#include <memory>
+#include <algorithm>
+#include <fstream>
+#include <sstream>
+#include <mapper.h>
+#include "frup.h"
+#include "fru-area.hpp"
+
+// OpenBMC System Manager dbus framework
+const char *sys_object_name = "/org/openbmc/managers/System";
+const char *sys_intf_name = "org.openbmc.managers.System";
+
+//----------------------------------------------------------------
+// Constructor
+//----------------------------------------------------------------
+ipmi_fru::ipmi_fru(const uint8_t fruid, const ipmi_fru_area_type type,
+ sd_bus *bus_type, bool bmc_fru)
+{
+ iv_fruid = fruid;
+ iv_type = type;
+ iv_bmc_fru = bmc_fru;
+ iv_bus_type = bus_type;
+ iv_valid = false;
+ iv_data = NULL;
+ iv_present = false;
+
+ if(iv_type == IPMI_FRU_AREA_INTERNAL_USE)
+ {
+ iv_name = "INTERNAL_";
+ }
+ else if(iv_type == IPMI_FRU_AREA_CHASSIS_INFO)
+ {
+ iv_name = "CHASSIS_";
+ }
+ else if(iv_type == IPMI_FRU_AREA_BOARD_INFO)
+ {
+ iv_name = "BOARD_";
+ }
+ else if(iv_type == IPMI_FRU_AREA_PRODUCT_INFO)
+ {
+ iv_name = "PRODUCT_";
+ }
+ else if(iv_type == IPMI_FRU_AREA_MULTI_RECORD)
+ {
+ iv_name = "MULTI_";
+ }
+ else
+ {
+ iv_name = IPMI_FRU_AREA_TYPE_MAX;
+ fprintf(stderr, "ERROR: Invalid Area type :[%d]\n",iv_type);
+ }
+}
+
+//-----------------------------------------------------
+// For a FRU area type, accepts the data and updates
+// area specific data.
+//-----------------------------------------------------
+void ipmi_fru::set_data(const uint8_t *data, const size_t len)
+{
+ iv_len = len;
+ iv_data = new uint8_t[len];
+ memcpy(iv_data, data, len);
+}
+
+//-----------------------------------------------------
+// Sets the dbus parameters
+//-----------------------------------------------------
+void ipmi_fru::update_dbus_paths(const char *bus_name,
+ const char *obj_path, const char *intf_name)
+{
+ iv_bus_name = bus_name;
+ iv_obj_path = obj_path;
+ iv_intf_name = intf_name;
+}
+
+//-------------------
+// Destructor
+//-------------------
+ipmi_fru::~ipmi_fru()
+{
+ sd_bus_error bus_error = SD_BUS_ERROR_NULL;
+ sd_bus_message *response = NULL;
+ int rc = 0;
+
+ if(iv_data != NULL)
+ {
+ delete [] iv_data;
+ iv_data = NULL;
+ }
+
+ // If we have not been successful in doing some updates and we are a BMC
+ // fru, then need to set the fault bits.
+ bool valid_dbus = !(iv_bus_name.empty()) &&
+ !(iv_obj_path.empty()) &&
+ !(iv_intf_name.empty());
+
+ // Based on bmc_fru, success in updating the FRU inventory we need to set
+ // some special bits.
+ if(iv_bmc_fru && valid_dbus)
+ {
+ // Set the Fault bit if we did not successfully process the fru
+ const char *fault_bit = iv_valid ? "False" : "True";
+
+ rc = sd_bus_call_method(iv_bus_type, // On the System Bus
+ iv_bus_name.c_str(), // Service to contact
+ iv_obj_path.c_str(), // Object path
+ iv_intf_name.c_str(), // Interface name
+ "setFault", // Method to be called
+ &bus_error, // object to return error
+ &response, // Response message on success
+ "s", // input message (string)
+ fault_bit); // First argument to setFault
+
+ if(rc <0)
+ {
+ fprintf(stderr,"Failed to set Fault bit, value:[%s] for fruid:[%d], path:[%s]\n",
+ fault_bit, iv_fruid, iv_obj_path.c_str());
+ }
+ else
+ {
+ printf("Fault bit set to :[%s] for fruid:[%d], Path:[%s]\n",
+ fault_bit, iv_fruid,iv_obj_path.c_str());
+ }
+
+ sd_bus_error_free(&bus_error);
+ sd_bus_message_unref(response);
+
+ // Set the Present bits
+ const char *present_bit = iv_present ? "True" : "False";
+
+ rc = sd_bus_call_method(iv_bus_type, // On the System Bus
+ iv_bus_name.c_str(), // Service to contact
+ iv_obj_path.c_str(), // Object path
+ iv_intf_name.c_str(), // Interface name
+ "setPresent", // Method to be called
+ &bus_error, // object to return error
+ &response, // Response message on success
+ "s", // input message (string)
+ present_bit); // First argument to setPresent
+ if(rc < 0)
+ {
+ fprintf(stderr,"Failed to set Present bit for fruid:[%d], path:[%s]\n",
+ iv_fruid, iv_obj_path.c_str());
+ }
+ else
+ {
+ printf("Present bit set to :[%s] for fruid:[%d], Path[%s]:\n",
+ present_bit, iv_fruid, iv_obj_path.c_str());
+ }
+
+ sd_bus_error_free(&bus_error);
+ sd_bus_message_unref(response);
+ }
+}
+
+// Sets up the sd_bus structures for the given fru type
+int ipmi_fru::setup_sd_bus_paths(void)
+{
+ // Need this to get respective DBUS objects
+ sd_bus_error bus_error = SD_BUS_ERROR_NULL;
+ sd_bus_message *response = NULL;
+ int rc = 0;
+
+ // What we need is BOARD_1, PRODUCT_1, CHASSIS_1 etc..
+ char *inv_bus_name = NULL;
+ const char *inv_obj_path = NULL,
+ *inv_intf_name = NULL;
+ char fru_area_name[16] = {0};
+ char *sys_bus_name = NULL;
+ sprintf(fru_area_name,"%s%d",iv_name.c_str(), iv_fruid);
+
+#ifdef __IPMI_DEBUG__
+ printf("Getting sd_bus for :[%s]\n",fru_area_name);
+#endif
+
+ rc = mapper_get_service(iv_bus_type, sys_object_name, &sys_bus_name);
+ if(rc < 0)
+ {
+ fprintf(stderr, "Failed to get system manager service:[%s]\n",
+ strerror(-rc));
+ goto exit;
+ }
+
+ // We want to call a method "getObjectFromId" on System Bus that is
+ // made available over OpenBmc system services.
+
+ rc = sd_bus_call_method(iv_bus_type, // On the System Bus
+ sys_bus_name, // Service to contact
+ sys_object_name, // Object path
+ sys_intf_name, // Interface name
+ "getObjectFromId", // Method to be called
+ &bus_error, // object to return error
+ &response, // Response message on success
+ "ss", // input message (string,string)
+ "FRU_STR", // First argument to getObjectFromId
+ fru_area_name); // Second Argument
+ if(rc < 0)
+ {
+ fprintf(stderr, "Failed to resolve fruid:[%d] to dbus: [%s]\n", iv_fruid, bus_error.message);
+ }
+ else
+ {
+ // Method getObjectFromId returns 2 parameters and all are strings, namely
+ // object_path and interface name for accessing that particular
+ // FRU over Inventory SDBUS manager. 'ss' here mentions that format.
+ rc = sd_bus_message_read(response, "(ss)", &inv_obj_path, &inv_intf_name);
+ if(rc < 0)
+ {
+ fprintf(stderr, "Failed to parse response message:[%s]\n", strerror(-rc));
+ }
+ else
+ {
+ rc = mapper_get_service(iv_bus_type, inv_obj_path, &inv_bus_name);
+ if(rc < 0)
+ {
+ fprintf(stderr, "Failed to get inventory item service:[%s]\n",
+ strerror(-rc));
+ goto exit;
+ }
+ // Update the paths in the area object
+ update_dbus_paths(inv_bus_name, inv_obj_path, inv_intf_name);
+ }
+ }
+
+exit:
+#ifdef __IPMI_DEBUG__
+ printf("fru_area=[%s], inv_bus_name=[%s], inv_obj_path=[%s], inv_intf_name=[%s]\n",
+ fru_area_name, inv_bus_name, inv_obj_path, inv_intf_name);
+#endif
+
+ free(sys_bus_name);
+ free(inv_bus_name);
+ sd_bus_error_free(&bus_error);
+ sd_bus_message_unref(response);
+
+ return rc;
+}
+
+//------------------------------------------------
+// Takes the pointer to stream of bytes and length
+// and returns the 8 bit checksum
+// This algo is per IPMI V2.0 spec
+//-------------------------------------------------
+unsigned char calculate_crc(const unsigned char *data, size_t len)
+{
+ char crc = 0;
+ size_t byte = 0;
+
+ for(byte = 0; byte < len; byte++)
+ {
+ crc += *data++;
+ }
+
+ return(-crc);
+}
+
+//---------------------------------------------------------------------
+// Accepts a fru area offset in commom hdr and tells which area it is.
+//---------------------------------------------------------------------
+ipmi_fru_area_type get_fru_area_type(uint8_t area_offset)
+{
+ ipmi_fru_area_type type = IPMI_FRU_AREA_TYPE_MAX;
+
+ switch(area_offset)
+ {
+ case IPMI_FRU_INTERNAL_OFFSET:
+ type = IPMI_FRU_AREA_INTERNAL_USE;
+ break;
+
+ case IPMI_FRU_CHASSIS_OFFSET:
+ type = IPMI_FRU_AREA_CHASSIS_INFO;
+ break;
+
+ case IPMI_FRU_BOARD_OFFSET:
+ type = IPMI_FRU_AREA_BOARD_INFO;
+ break;
+
+ case IPMI_FRU_PRODUCT_OFFSET:
+ type = IPMI_FRU_AREA_PRODUCT_INFO;
+ break;
+
+ case IPMI_FRU_MULTI_OFFSET:
+ type = IPMI_FRU_AREA_MULTI_RECORD;
+ break;
+
+ default:
+ type = IPMI_FRU_AREA_TYPE_MAX;
+ }
+
+ return type;
+}
+
+///-----------------------------------------------
+// Validates the data for crc and mandatory fields
+///-----------------------------------------------
+int verify_fru_data(const uint8_t *data, const size_t len)
+{
+ uint8_t checksum = 0;
+ int rc = -1;
+
+ // Validate for first byte to always have a value of [1]
+ if(data[0] != IPMI_FRU_HDR_BYTE_ZERO)
+ {
+ fprintf(stderr, "Invalid entry:[%d] in byte-0\n",data[0]);
+ return rc;
+ }
+#ifdef __IPMI_DEBUG__
+ else
+ {
+ printf("SUCCESS: Validated [0x%X] in entry_1 of fru_data\n",data[0]);
+ }
+#endif
+
+ // See if the calculated CRC matches with the embedded one.
+ // CRC to be calculated on all except the last one that is CRC itself.
+ checksum = calculate_crc(data, len - 1);
+ if(checksum != data[len-1])
+ {
+#ifdef __IPMI_DEBUG__
+ fprintf(stderr, "Checksum mismatch."
+ " Calculated:[0x%X], Embedded:[0x%X]\n",
+ checksum, data[len]);
+#endif
+ return rc;
+ }
+#ifdef __IPMI_DEBUG__
+ else
+ {
+ printf("SUCCESS: Checksum matches:[0x%X]\n",checksum);
+ }
+#endif
+
+ return EXIT_SUCCESS;
+}
+
+//------------------------------------------------------------------------
+// Takes FRU data, invokes Parser for each fru record area and updates
+// Inventory
+//------------------------------------------------------------------------
+int ipmi_update_inventory(fru_area_vec_t & area_vec)
+{
+ // Generic error reporter
+ int rc = 0;
+
+ // Dictionary object to hold Name:Value pair
+ sd_bus_message *fru_dict = NULL;
+
+ // SD Bus error report mechanism.
+ sd_bus_error bus_error = SD_BUS_ERROR_NULL;
+
+ // Response from sd bus calls
+ sd_bus_message *response = NULL;
+
+ // For each FRU area, extract the needed data , get it parsed and update
+ // the Inventory.
+ for(auto& iter : area_vec)
+ {
+ // Start fresh on each.
+ sd_bus_error_free(&bus_error);
+ sd_bus_message_unref(response);
+ sd_bus_message_unref(fru_dict);
+
+ // Constructor to allow further initializations and customization.
+ rc = sd_bus_message_new_method_call((iter)->get_bus_type(),
+ &fru_dict,
+ (iter)->get_bus_name(),
+ (iter)->get_obj_path(),
+ (iter)->get_intf_name(),
+ "update");
+ if(rc < 0)
+ {
+ fprintf(stderr,"ERROR: creating a update method call for bus_name:[%s]\n",
+ (iter)->get_bus_name());
+ break;
+ }
+
+ // A Dictionary ({}) having (string, variant)
+ rc = sd_bus_message_open_container(fru_dict, 'a', "{sv}");
+ if(rc < 0)
+ {
+ fprintf(stderr,"ERROR:[%d] creating a dict container:\n",errno);
+ break;
+ }
+
+ // Fill the container with information
+ rc = parse_fru_area((iter)->get_type(), (void *)(iter)->get_data(), (iter)->get_len(), fru_dict);
+ if(rc < 0)
+ {
+ fprintf(stderr,"ERROR parsing FRU records\n");
+ break;
+ }
+
+ sd_bus_message_close_container(fru_dict);
+
+ // Now, Make the actual call to update the FRU inventory database with the
+ // dictionary given by FRU Parser. There is no response message expected for
+ // this.
+ rc = sd_bus_call((iter)->get_bus_type(), // On the System Bus
+ fru_dict, // With the Name:value dictionary array
+ 0, //
+ &bus_error, // Object to return error.
+ &response); // Response message if any.
+
+ if(rc < 0)
+ {
+ fprintf(stderr, "ERROR:[%s] updating FRU inventory for ID:[0x%X]\n",
+ bus_error.message, (iter)->get_fruid());
+ break;
+ }
+ else if((iter)->is_bmc_fru())
+ {
+ // For FRUs that are accessible by HostBoot, host boot does all of
+ // these.
+ printf("SUCCESS: Updated:[%s_%d] successfully. Setting Valid bit\n",
+ (iter)->get_name(), (iter)->get_fruid());
+
+ (iter)->set_valid(true);
+ }
+ else
+ {
+ printf("SUCCESS: Updated:[%s_%d] successfully\n",
+ (iter)->get_name(), (iter)->get_fruid());
+ }
+ } // END walking the vector of areas and updating
+
+ sd_bus_error_free(&bus_error);
+ sd_bus_message_unref(response);
+ sd_bus_message_unref(fru_dict);
+
+ return rc;
+}
+
+///----------------------------------------------------
+// Checks if a particular fru area is populated or not
+///----------------------------------------------------
+bool remove_invalid_area(const std::unique_ptr<ipmi_fru> &fru_area)
+{
+ // Filter the ones that do not have dbus reference.
+ if((strlen((fru_area)->get_bus_name()) == 0) ||
+ (strlen((fru_area)->get_obj_path()) == 0) ||
+ (strlen((fru_area)->get_intf_name()) == 0))
+ {
+ return true;
+ }
+ return false;
+}
+
+///----------------------------------------------------------------------------------
+// Populates various FRU areas
+// @prereq : This must be called only after validating common header.
+///----------------------------------------------------------------------------------
+int ipmi_populate_fru_areas(uint8_t *fru_data, const size_t data_len,
+ fru_area_vec_t & fru_area_vec)
+{
+ size_t area_offset = 0;
+ int rc = -1;
+
+ // Now walk the common header and see if the file size has atleast the last
+ // offset mentioned by the common_hdr. If the file size is less than the
+ // offset of any if the fru areas mentioned in the common header, then we do
+ // not have a complete file.
+ for(uint8_t fru_entry = IPMI_FRU_INTERNAL_OFFSET;
+ fru_entry < (sizeof(struct common_header) -2); fru_entry++)
+ {
+ rc = -1;
+ // Actual offset in the payload is the offset mentioned in common header
+ // multipled by 8. Common header is always the first 8 bytes.
+ area_offset = fru_data[fru_entry] * IPMI_EIGHT_BYTES;
+ if(area_offset && (data_len < (area_offset + 2)))
+ {
+ // Our file size is less than what it needs to be. +2 because we are
+ // using area len that is at 2 byte off area_offset
+ fprintf(stderr, "fru file is incomplete. Size:[%zd]\n",data_len);
+ return rc;
+ }
+ else if(area_offset)
+ {
+ // Read 2 bytes to know the actual size of area.
+ uint8_t area_hdr[2] = {0};
+ memcpy(area_hdr, &((uint8_t *)fru_data)[area_offset], sizeof(area_hdr));
+
+ // Size of this area will be the 2nd byte in the fru area header.
+ size_t area_len = area_hdr[1] * IPMI_EIGHT_BYTES;
+ uint8_t area_data[area_len] = {0};
+
+ printf("fru data size:[%zd], area offset:[%zd], area_size:[%zd]\n",
+ data_len, area_offset, area_len);
+
+ // See if we really have that much buffer. We have area offset amd
+ // from there, the actual len.
+ if(data_len < (area_len + area_offset))
+ {
+ fprintf(stderr, "Incomplete Fru file.. Size:[%zd]\n",data_len);
+ return rc;
+ }
+
+ // Save off the data.
+ memcpy(area_data, &((uint8_t *)fru_data)[area_offset], area_len);
+
+ // Validate the crc
+ rc = verify_fru_data(area_data, area_len);
+ if(rc < 0)
+ {
+ fprintf(stderr, "Error validating fru area. offset:[%zd]\n",area_offset);
+ return rc;
+ }
+ else
+ {
+ printf("Successfully verified area checksum. offset:[%zd]\n",area_offset);
+ }
+
+ // We already have a vector that is passed to us containing all
+ // of the fields populated. Update the data portion now.
+ for(auto& iter : fru_area_vec)
+ {
+ if((iter)->get_type() == get_fru_area_type(fru_entry))
+ {
+ (iter)->set_data(area_data, area_len);
+ }
+ }
+ } // If we have fru data present
+ } // Walk common_hdr
+
+ // Not all the fields will be populated in a fru data. Mostly all cases will
+ // not have more than 2 or 3.
+ fru_area_vec.erase(std::remove_if(fru_area_vec.begin(), fru_area_vec.end(),
+ remove_invalid_area), fru_area_vec.end());
+
+ return EXIT_SUCCESS;
+}
+
+///---------------------------------------------------------
+// Validates the fru data per ipmi common header constructs.
+// Returns with updated common_hdr and also file_size
+//----------------------------------------------------------
+int ipmi_validate_common_hdr(const uint8_t *fru_data, const size_t data_len)
+{
+ int rc = -1;
+
+ uint8_t common_hdr[sizeof(struct common_header)] = {0};
+ if(data_len >= sizeof(common_hdr))
+ {
+ memcpy(common_hdr, fru_data, sizeof(common_hdr));
+ }
+ else
+ {
+ fprintf(stderr, "Incomplete fru data file. Size:[%zd]\n", data_len);
+ return rc;
+ }
+
+ // Verify the crc and size
+ rc = verify_fru_data(common_hdr, sizeof(common_hdr));
+ if(rc < 0)
+ {
+ fprintf(stderr, "Failed to validate common header\n");
+ return rc;
+ }
+
+ return EXIT_SUCCESS;
+}
+
+//------------------------------------------------------------
+// Cleanup routine
+//------------------------------------------------------------
+int cleanup_error(FILE *fru_fp, fru_area_vec_t & fru_area_vec)
+{
+ if(fru_fp != NULL)
+ {
+ fclose(fru_fp);
+ fru_fp = NULL;
+ }
+
+ if(!(fru_area_vec.empty()))
+ {
+ fru_area_vec.clear();
+ }
+
+ return -1;
+}
+
+
+///-----------------------------------------------------
+// Get the fru area names defined in BMC for a given @fruid.
+//----------------------------------------------------
+int get_defined_fru_area(sd_bus *bus_type, const uint8_t fruid,
+ std::vector<std::string> &defined_fru_area)
+{
+ // Need this to get respective DBUS objects
+ sd_bus_error bus_error = SD_BUS_ERROR_NULL;
+ sd_bus_message *response = NULL;
+ int rc = 0;
+ const char *areas = NULL;
+ char *sys_bus_name = NULL;
+
+#ifdef __IPMI_DEBUG__
+ printf("Getting fru areas defined in Skeleton for :[%d]\n", fruid);
+#endif
+
+ rc = mapper_get_service(bus_type, sys_object_name, &sys_bus_name);
+ if(rc < 0)
+ {
+ fprintf(stderr, "Failed to get system manager service:[%s]\n",
+ strerror(-rc));
+ goto exit;
+ }
+
+ // We want to call a method "getFRUArea" on System Bus that is
+ // made available over OpenBmc system services.
+ rc = sd_bus_call_method(bus_type, // On the System Bus
+ sys_bus_name, // Service to contact
+ sys_object_name, // Object path
+ sys_intf_name, // Interface name
+ "getFRUArea", // Method to be called
+ &bus_error, // object to return error
+ &response, // Response message on success
+ "y", // input message (integer)
+ fruid); // Argument
+
+ if(rc < 0)
+ {
+ fprintf(stderr, "Failed to get fru area for fruid:[%d] to dbus: [%s]\n",
+ fruid, bus_error.message);
+ }
+ else
+ {
+ // if several fru area names are defined, the names are combined to
+ // a string seperated by ','
+ rc = sd_bus_message_read(response, "s", &areas);
+ if(rc < 0)
+ {
+ fprintf(stderr, "Failed to parse response message from getFRUArea:[%s]\n",
+ strerror(-rc));
+ }
+ else
+ {
+#ifdef __IPMI_DEBUG__
+ printf("get defined fru area: id: %d, areas: %s\n", fruid, areas);
+#endif
+ std::string area_name;
+ std::stringstream ss(areas);
+ // fru area names string is seperated by ',', parse it into tokens
+ while (std::getline(ss, area_name, ','))
+ {
+ if (!area_name.empty())
+ defined_fru_area.emplace_back(area_name);
+ }
+ }
+ }
+
+exit:
+
+ free(sys_bus_name);
+ sd_bus_error_free(&bus_error);
+ sd_bus_message_unref(response);
+
+ return rc;
+}
+
+
+///-----------------------------------------------------
+// Accepts the filename and validates per IPMI FRU spec
+//----------------------------------------------------
+int ipmi_validate_fru_area(const uint8_t fruid, const char *fru_file_name,
+ sd_bus *bus_type, const bool bmc_fru)
+{
+ size_t data_len = 0;
+ size_t bytes_read = 0;
+ int rc = -1;
+
+ // Vector that holds individual IPMI FRU AREAs. Although MULTI and INTERNAL
+ // are not used, keeping it here for completeness.
+ fru_area_vec_t fru_area_vec;
+ std::vector<std::string> defined_fru_area;
+
+ // BMC defines fru areas that should be present in Skeleton
+ rc = get_defined_fru_area(bus_type, fruid, defined_fru_area);
+ if(rc < 0)
+ {
+ fprintf(stderr, "ERROR: cannot get defined fru area\n");
+ return rc;
+ }
+ for(uint8_t fru_entry = IPMI_FRU_INTERNAL_OFFSET;
+ fru_entry < (sizeof(struct common_header) -2); fru_entry++)
+ {
+ // Create an object and push onto a vector.
+ std::unique_ptr<ipmi_fru> fru_area = std::make_unique<ipmi_fru>
+ (fruid, get_fru_area_type(fru_entry), bus_type, bmc_fru);
+
+ // Physically being present
+ bool present = access(fru_file_name, F_OK) == 0;
+ fru_area->set_present(present);
+
+ // Only setup dbus path for areas defined in BMC.
+ // Otherwise Skeleton will report 'not found' error
+ std::string fru_area_name = fru_area->get_name() + std::to_string(fruid);
+ auto iter = std::find(defined_fru_area.begin(), defined_fru_area.end(),
+ fru_area_name);
+ if (iter != defined_fru_area.end())
+ {
+ fru_area->setup_sd_bus_paths();
+ }
+ fru_area_vec.emplace_back(std::move(fru_area));
+ }
+
+ FILE *fru_fp = fopen(fru_file_name,"rb");
+ if(fru_fp == NULL)
+ {
+ fprintf(stderr, "ERROR: opening:[%s]\n",fru_file_name);
+ perror("Error:");
+ return cleanup_error(fru_fp, fru_area_vec);
+ }
+
+ // Get the size of the file to see if it meets minimum requirement
+ if(fseek(fru_fp, 0, SEEK_END))
+ {
+ perror("Error:");
+ return cleanup_error(fru_fp, fru_area_vec);
+ }
+
+ // Allocate a buffer to hold entire file content
+ data_len = ftell(fru_fp);
+ uint8_t fru_data[data_len] = {0};
+
+ rewind(fru_fp);
+ bytes_read = fread(fru_data, data_len, 1, fru_fp);
+ if(bytes_read != 1)
+ {
+ fprintf(stderr, "Failed reading fru data. Bytes_read=[%zd]\n",bytes_read);
+ perror("Error:");
+ return cleanup_error(fru_fp, fru_area_vec);
+ }
+
+ // We are done reading.
+ fclose(fru_fp);
+ fru_fp = NULL;
+
+ rc = ipmi_validate_common_hdr(fru_data, data_len);
+ if(rc < 0)
+ {
+ return cleanup_error(fru_fp, fru_area_vec);
+ }
+
+ // Now that we validated the common header, populate various fru sections if we have them here.
+ rc = ipmi_populate_fru_areas(fru_data, data_len, fru_area_vec);
+ if(rc < 0)
+ {
+ fprintf(stderr,"Populating FRU areas failed for:[%d]\n",fruid);
+ return cleanup_error(fru_fp, fru_area_vec);
+ }
+ else
+ {
+ printf("SUCCESS: Populated FRU areas for:[%s]\n",fru_file_name);
+ }
+
+#ifdef __IPMI_DEBUG__
+ for(auto& iter : fru_area_vec)
+ {
+ printf("FRU ID : [%d]\n",(iter)->get_fruid());
+ printf("AREA NAME : [%s]\n",(iter)->get_name());
+ printf("TYPE : [%d]\n",(iter)->get_type());
+ printf("LEN : [%d]\n",(iter)->get_len());
+ printf("BUS NAME : [%s]\n", (iter)->get_bus_name());
+ printf("OBJ PATH : [%s]\n", (iter)->get_obj_path());
+ printf("INTF NAME :[%s]\n", (iter)->get_intf_name());
+ }
+#endif
+
+ // If the vector is populated with everything, then go ahead and update the
+ // inventory.
+ if(!(fru_area_vec.empty()))
+ {
+
+#ifdef __IPMI_DEBUG__
+ printf("\n SIZE of vector is : [%d] \n",fru_area_vec.size());
+#endif
+ rc = ipmi_update_inventory(fru_area_vec);
+ if(rc <0)
+ {
+ fprintf(stderr, "Error updating inventory\n");
+ }
+ }
+
+ // we are done with all that we wanted to do. This will do the job of
+ // calling any destructors too.
+ fru_area_vec.clear();
+
+ return rc;
+}