diff --git a/writefrudata.cpp b/writefrudata.cpp
index 72a3baa..f00c067 100644
--- a/writefrudata.cpp
+++ b/writefrudata.cpp
@@ -34,18 +34,18 @@
 
 //------------------------------------------------------------
 // Cleanup routine
-// Must always be called as last reference to fru_fp.
+// Must always be called as last reference to fruFilePointer.
 //------------------------------------------------------------
-int cleanupError(FILE* fru_fp, FruAreaVector& fru_area_vec)
+int cleanupError(FILE* fruFilePointer, FruAreaVector& fruAreaVec)
 {
-    if (fru_fp != NULL)
+    if (fruFilePointer != NULL)
     {
-        std::fclose(fru_fp);
+        std::fclose(fruFilePointer);
     }
 
-    if (!(fru_area_vec.empty()))
+    if (!(fruAreaVec.empty()))
     {
-        fru_area_vec.clear();
+        fruAreaVec.clear();
     }
 
     return -1;
@@ -144,7 +144,7 @@
 // Takes FRU data, invokes Parser for each fru record area and updates
 // Inventory
 //------------------------------------------------------------------------
-int updateInventory(FruAreaVector& area_vec, sdbusplus::bus::bus& bus)
+int updateInventory(FruAreaVector& areaVector, sdbusplus::bus::bus& bus)
 {
     // Generic error reporter
     int rc = 0;
@@ -153,7 +153,7 @@
 
     // For each FRU area, extract the needed data , get it parsed and update
     // the Inventory.
-    for (const auto& fruArea : area_vec)
+    for (const auto& fruArea : areaVector)
     {
         fruid = fruArea->getFruID();
         // Fill the container with information
@@ -296,11 +296,11 @@
 //---------------------------------------------------------------------
 // Accepts a fru area offset in commom hdr and tells which area it is.
 //---------------------------------------------------------------------
-ipmi_fru_area_type getFruAreaType(uint8_t area_offset)
+ipmi_fru_area_type getFruAreaType(uint8_t areaOffset)
 {
     ipmi_fru_area_type type = IPMI_FRU_AREA_TYPE_MAX;
 
-    switch (area_offset)
+    switch (areaOffset)
     {
         case IPMI_FRU_INTERNAL_OFFSET:
             type = IPMI_FRU_AREA_INTERNAL_USE;
@@ -347,7 +347,7 @@
 #ifdef __IPMI_DEBUG__
     else
     {
-        log<level::DEBUG>("Validated in entry_1 of fru_data",
+        log<level::DEBUG>("Validated in entry_1 of fruData",
                           entry("ENTRY=0x%X", static_cast<uint32_t>(data[0])));
     }
 #endif
@@ -378,10 +378,10 @@
 ///----------------------------------------------------
 // Checks if a particular fru area is populated or not
 ///----------------------------------------------------
-bool removeInvalidArea(const std::unique_ptr<IPMIFruArea>& fru_area)
+bool removeInvalidArea(const std::unique_ptr<IPMIFruArea>& fruArea)
 {
     // Filter the ones that are empty
-    if (!(fru_area->getLength()))
+    if (!(fruArea->getLength()))
     {
         return true;
     }
@@ -392,114 +392,113 @@
 // Populates various FRU areas
 // @prereq : This must be called only after validating common header.
 ///----------------------------------------------------------------------------------
-int ipmiPopulateFruAreas(uint8_t* fru_data, const size_t data_len,
-                         FruAreaVector& fru_area_vec)
+int ipmiPopulateFruAreas(uint8_t* fruData, const size_t dataLen,
+                         FruAreaVector& fruAreaVec)
 {
     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++)
+    // offset mentioned by the struct common_header. 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 fruEntry = IPMI_FRU_INTERNAL_OFFSET;
+         fruEntry < (sizeof(struct common_header) - 2); fruEntry++)
     {
         rc = -1;
         // Actual offset in the payload is the offset mentioned in common header
         // multiplied by 8. Common header is always the first 8 bytes.
-        size_t area_offset = fru_data[fru_entry] * IPMI_EIGHT_BYTES;
-        if (area_offset && (data_len < (area_offset + 2)))
+        size_t areaOffset = fruData[fruEntry] * IPMI_EIGHT_BYTES;
+        if (areaOffset && (dataLen < (areaOffset + 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
+            // using area len that is at 2 byte off areaOffset
             log<level::ERR>("fru file is incomplete",
-                            entry("SIZE=%d", data_len));
+                            entry("SIZE=%d", dataLen));
             return rc;
         }
-        else if (area_offset)
+        else if (areaOffset)
         {
             // Read 2 bytes to know the actual size of area.
-            uint8_t area_hdr[2] = {0};
-            std::memcpy(area_hdr, &((uint8_t*)fru_data)[area_offset],
-                        sizeof(area_hdr));
+            uint8_t areaHeader[2] = {0};
+            std::memcpy(areaHeader, &((uint8_t*)fruData)[areaOffset],
+                        sizeof(areaHeader));
 
             // 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};
+            size_t areaLen = areaHeader[1] * IPMI_EIGHT_BYTES;
+            uint8_t areaData[areaLen] = {0};
 
-            log<level::DEBUG>("Fru Data", entry("SIZE=%d", data_len),
-                              entry("AREA OFFSET=%d", area_offset),
-                              entry("AREA_SIZE=%d", area_len));
+            log<level::DEBUG>("Fru Data", entry("SIZE=%d", dataLen),
+                              entry("AREA OFFSET=%d", areaOffset),
+                              entry("AREA_SIZE=%d", areaLen));
 
             // 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))
+            if (dataLen < (areaLen + areaOffset))
             {
                 log<level::ERR>("Incomplete Fru file",
-                                entry("SIZE=%d", data_len));
+                                entry("SIZE=%d", dataLen));
                 return rc;
             }
 
             // Save off the data.
-            std::memcpy(area_data, &((uint8_t*)fru_data)[area_offset],
-                        area_len);
+            std::memcpy(areaData, &((uint8_t*)fruData)[areaOffset], areaLen);
 
             // Validate the crc
-            rc = verifyFruData(area_data, area_len);
+            rc = verifyFruData(areaData, areaLen);
             if (rc < 0)
             {
                 log<level::ERR>("Err validating fru area",
-                                entry("OFFSET=%d", area_offset));
+                                entry("OFFSET=%d", areaOffset));
                 return rc;
             }
             else
             {
                 log<level::DEBUG>("Successfully verified area checksum.",
-                                  entry("OFFSET=%d", area_offset));
+                                  entry("OFFSET=%d", areaOffset));
             }
 
             // 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)
+            for (auto& iter : fruAreaVec)
             {
-                if (iter->getType() == getFruAreaType(fru_entry))
+                if (iter->getType() == getFruAreaType(fruEntry))
                 {
-                    iter->setData(area_data, area_len);
+                    iter->setData(areaData, areaLen);
                 }
             }
         } // If we have fru data present
-    }     // Walk common_hdr
+    }     // Walk struct common_header
 
     // 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(),
-                                      removeInvalidArea),
-                       fru_area_vec.end());
+    fruAreaVec.erase(
+        std::remove_if(fruAreaVec.begin(), fruAreaVec.end(), removeInvalidArea),
+        fruAreaVec.end());
 
     return EXIT_SUCCESS;
 }
 
 ///---------------------------------------------------------
 // Validates the fru data per ipmi common header constructs.
-// Returns with updated common_hdr and also file_size
+// Returns with updated struct common_header and also file_size
 //----------------------------------------------------------
-int ipmiValidateCommonHeader(const uint8_t* fru_data, const size_t data_len)
+int ipmiValidateCommonHeader(const uint8_t* fruData, const size_t dataLen)
 {
     int rc = -1;
 
-    uint8_t common_hdr[sizeof(struct common_header)] = {0};
-    if (data_len >= sizeof(common_hdr))
+    uint8_t commonHdr[sizeof(struct common_header)] = {0};
+    if (dataLen >= sizeof(commonHdr))
     {
-        std::memcpy(common_hdr, fru_data, sizeof(common_hdr));
+        std::memcpy(commonHdr, fruData, sizeof(commonHdr));
     }
     else
     {
-        log<level::ERR>("Incomplete fru data file", entry("SIZE=%d", data_len));
+        log<level::ERR>("Incomplete fru data file", entry("SIZE=%d", dataLen));
         return rc;
     }
 
     // Verify the crc and size
-    rc = verifyFruData(common_hdr, sizeof(common_hdr));
+    rc = verifyFruData(commonHdr, sizeof(commonHdr));
     if (rc < 0)
     {
         log<level::ERR>("Failed to validate common header");
@@ -512,89 +511,88 @@
 ///-----------------------------------------------------
 // Accepts the filename and validates per IPMI FRU spec
 //----------------------------------------------------
-int validateFRUArea(const uint8_t fruid, const char* fru_file_name,
-                    sdbusplus::bus::bus& bus, const bool bmc_fru)
+int validateFRUArea(const uint8_t fruid, const char* fruFilename,
+                    sdbusplus::bus::bus& bus, const bool bmcOnlyFru)
 {
-    size_t data_len = 0;
-    size_t bytes_read = 0;
+    size_t dataLen = 0;
+    size_t bytesRead = 0;
     int rc = -1;
 
     // Vector that holds individual IPMI FRU AREAs. Although MULTI and INTERNAL
     // are not used, keeping it here for completeness.
-    FruAreaVector fru_area_vec;
+    FruAreaVector fruAreaVec;
 
-    for (uint8_t fru_entry = IPMI_FRU_INTERNAL_OFFSET;
-         fru_entry < (sizeof(struct common_header) - 2); fru_entry++)
+    for (uint8_t fruEntry = IPMI_FRU_INTERNAL_OFFSET;
+         fruEntry < (sizeof(struct common_header) - 2); fruEntry++)
     {
         // Create an object and push onto a vector.
-        std::unique_ptr<IPMIFruArea> fru_area = std::make_unique<IPMIFruArea>(
-            fruid, getFruAreaType(fru_entry), bmc_fru);
+        std::unique_ptr<IPMIFruArea> fruArea = std::make_unique<IPMIFruArea>(
+            fruid, getFruAreaType(fruEntry), bmcOnlyFru);
 
         // Physically being present
-        bool present = access(fru_file_name, F_OK) == 0;
-        fru_area->setPresent(present);
+        bool present = access(fruFilename, F_OK) == 0;
+        fruArea->setPresent(present);
 
-        fru_area_vec.emplace_back(std::move(fru_area));
+        fruAreaVec.emplace_back(std::move(fruArea));
     }
 
-    FILE* fru_fp = std::fopen(fru_file_name, "rb");
-    if (fru_fp == NULL)
+    FILE* fruFilePointer = std::fopen(fruFilename, "rb");
+    if (fruFilePointer == NULL)
     {
         log<level::ERR>("Unable to open fru file",
-                        entry("FILE=%s", fru_file_name),
+                        entry("FILE=%s", fruFilename),
                         entry("ERRNO=%s", std::strerror(errno)));
-        return cleanupError(fru_fp, fru_area_vec);
+        return cleanupError(fruFilePointer, fruAreaVec);
     }
 
     // Get the size of the file to see if it meets minimum requirement
-    if (std::fseek(fru_fp, 0, SEEK_END))
+    if (std::fseek(fruFilePointer, 0, SEEK_END))
     {
         log<level::ERR>("Unable to seek fru file",
-                        entry("FILE=%s", fru_file_name),
+                        entry("FILE=%s", fruFilename),
                         entry("ERRNO=%s", std::strerror(errno)));
-        return cleanupError(fru_fp, fru_area_vec);
+        return cleanupError(fruFilePointer, fruAreaVec);
     }
 
     // Allocate a buffer to hold entire file content
-    data_len = std::ftell(fru_fp);
-    uint8_t fru_data[data_len] = {0};
+    dataLen = std::ftell(fruFilePointer);
+    uint8_t fruData[dataLen] = {0};
 
-    std::rewind(fru_fp);
-    bytes_read = std::fread(fru_data, data_len, 1, fru_fp);
-    if (bytes_read != 1)
+    std::rewind(fruFilePointer);
+    bytesRead = std::fread(fruData, dataLen, 1, fruFilePointer);
+    if (bytesRead != 1)
     {
         log<level::ERR>("Failed reading fru data.",
-                        entry("BYTESREAD=%d", bytes_read),
+                        entry("BYTESREAD=%d", bytesRead),
                         entry("ERRNO=%s", std::strerror(errno)));
-        return cleanupError(fru_fp, fru_area_vec);
+        return cleanupError(fruFilePointer, fruAreaVec);
     }
 
     // We are done reading.
-    std::fclose(fru_fp);
-    fru_fp = NULL;
+    std::fclose(fruFilePointer);
+    fruFilePointer = NULL;
 
-    rc = ipmiValidateCommonHeader(fru_data, data_len);
+    rc = ipmiValidateCommonHeader(fruData, dataLen);
     if (rc < 0)
     {
-        return cleanupError(fru_fp, fru_area_vec);
+        return cleanupError(fruFilePointer, fruAreaVec);
     }
 
     // Now that we validated the common header, populate various fru sections if
     // we have them here.
-    rc = ipmiPopulateFruAreas(fru_data, data_len, fru_area_vec);
+    rc = ipmiPopulateFruAreas(fruData, dataLen, fruAreaVec);
     if (rc < 0)
     {
         log<level::ERR>("Populating FRU areas failed", entry("FRU=%d", fruid));
-        return cleanupError(fru_fp, fru_area_vec);
+        return cleanupError(fruFilePointer, fruAreaVec);
     }
     else
     {
-        log<level::DEBUG>("Populated FRU areas",
-                          entry("FILE=%s", fru_file_name));
+        log<level::DEBUG>("Populated FRU areas", entry("FILE=%s", fruFilename));
     }
 
 #ifdef __IPMI_DEBUG__
-    for (const auto& iter : fru_area_vec)
+    for (const auto& iter : fruAreaVec)
     {
         std::printf("FRU ID : [%d]\n", iter->getFruID());
         std::printf("AREA NAME : [%s]\n", iter->getName());
@@ -608,13 +606,13 @@
 
     // If the vector is populated with everything, then go ahead and update the
     // inventory.
-    if (!(fru_area_vec.empty()))
+    if (!(fruAreaVec.empty()))
     {
 
 #ifdef __IPMI_DEBUG__
-        std::printf("\n SIZE of vector is : [%d] \n", fru_area_vec.size());
+        std::printf("\n SIZE of vector is : [%d] \n", fruAreaVec.size());
 #endif
-        rc = updateInventory(fru_area_vec, bus);
+        rc = updateInventory(fruAreaVec, bus);
         if (rc < 0)
         {
             log<level::ERR>("Error updating inventory.");
@@ -623,7 +621,7 @@
 
     // we are done with all that we wanted to do. This will do the job of
     // calling any destructors too.
-    fru_area_vec.clear();
+    fruAreaVec.clear();
 
     return rc;
 }