diff --git a/dhcp_configuration.cpp b/dhcp_configuration.cpp
index 7707461..690ae47 100644
--- a/dhcp_configuration.cpp
+++ b/dhcp_configuration.cpp
@@ -45,14 +45,14 @@
     return name;
 }
 
-bool Configuration::nTPEnabled(bool value)
+bool Configuration::ntpEnabled(bool value)
 {
-    if (value == nTPEnabled())
+    if (value == ntpEnabled())
     {
         return value;
     }
 
-    auto ntp = ConfigIntf::nTPEnabled(value);
+    auto ntp = ConfigIntf::ntpEnabled(value);
     manager.writeToConfigurationFile();
     manager.restartSystemdUnit(phosphor::network::networkdService);
     manager.restartSystemdUnit(phosphor::network::timeSynchdService);
@@ -60,14 +60,14 @@
     return ntp;
 }
 
-bool Configuration::dNSEnabled(bool value)
+bool Configuration::dnsEnabled(bool value)
 {
-    if (value == dNSEnabled())
+    if (value == dnsEnabled())
     {
         return value;
     }
 
-    auto dns = ConfigIntf::dNSEnabled(value);
+    auto dns = ConfigIntf::dnsEnabled(value);
     manager.writeToConfigurationFile();
     manager.restartSystemdUnit(phosphor::network::networkdService);
 
diff --git a/dhcp_configuration.hpp b/dhcp_configuration.hpp
index cc2083e..441c7b2 100644
--- a/dhcp_configuration.hpp
+++ b/dhcp_configuration.hpp
@@ -7,6 +7,11 @@
 #include <string>
 #include <xyz/openbmc_project/Network/DHCPConfiguration/server.hpp>
 
+#ifndef SDBUSPP_NEW_CAMELCASE
+#define dnsEnabled dNSEnabled
+#define ntpEnabled nTPEnabled
+#endif
+
 namespace phosphor
 {
 namespace network
@@ -47,8 +52,8 @@
         Iface(bus, objPath.c_str(), true),
         bus(bus), manager(parent)
     {
-        ConfigIntf::dNSEnabled(getDHCPPropFromConf("UseDNS"));
-        ConfigIntf::nTPEnabled(getDHCPPropFromConf("UseNTP"));
+        ConfigIntf::dnsEnabled(getDHCPPropFromConf("UseDNS"));
+        ConfigIntf::ntpEnabled(getDHCPPropFromConf("UseNTP"));
         ConfigIntf::hostNameEnabled(getDHCPPropFromConf("UseHostname"));
         ConfigIntf::sendHostNameEnabled(getDHCPPropFromConf("SendHostname"));
         emit_object_added();
@@ -60,14 +65,14 @@
      *  @param[in] value - true if DNS server needed from DHCP server
      *                     else false.
      */
-    bool dNSEnabled(bool value) override;
+    bool dnsEnabled(bool value) override;
 
     /** @brief If true then NTP servers received from the DHCP server
                will be used by systemd-timesyncd.
      *  @param[in] value - true if NTP server needed from DHCP server
      *                     else false.
      */
-    bool nTPEnabled(bool value) override;
+    bool ntpEnabled(bool value) override;
 
     /** @brief If true then Hostname received from the DHCP server will
      *         be set as the hostname of the system
@@ -94,9 +99,9 @@
               sendHostNameEnabled).
      *
      */
-    using ConfigIntf::dNSEnabled;
+    using ConfigIntf::dnsEnabled;
     using ConfigIntf::hostNameEnabled;
-    using ConfigIntf::nTPEnabled;
+    using ConfigIntf::ntpEnabled;
     using ConfigIntf::sendHostNameEnabled;
 
   private:
diff --git a/ethernet_interface.cpp b/ethernet_interface.cpp
index 6b3099e..3e891c6 100644
--- a/ethernet_interface.cpp
+++ b/ethernet_interface.cpp
@@ -83,8 +83,8 @@
     auto intfName = objPath.substr(objPath.rfind("/") + 1);
     std::replace(intfName.begin(), intfName.end(), '_', '.');
     interfaceName(intfName);
-    EthernetInterfaceIntf::dHCPEnabled(dhcpEnabled);
-    EthernetInterfaceIntf::iPv6AcceptRA(getIPv6AcceptRAFromConf());
+    EthernetInterfaceIntf::dhcpEnabled(dhcpEnabled);
+    EthernetInterfaceIntf::ipv6AcceptRA(getIPv6AcceptRAFromConf());
     route::Table routingTable;
     auto gatewayList = routingTable.getDefaultGateway();
     auto gateway6List = routingTable.getDefaultGateway6();
@@ -115,12 +115,12 @@
     // would be same as parent interface.
     if (intfName.find(".") == std::string::npos)
     {
-        MacAddressIntf::mACAddress(getMACAddress(intfName));
+        MacAddressIntf::macAddress(getMACAddress(intfName));
     }
-    EthernetInterfaceIntf::nTPServers(getNTPServersFromConf());
+    EthernetInterfaceIntf::ntpServers(getNTPServersFromConf());
 
     EthernetInterfaceIntf::linkUp(linkUp());
-    EthernetInterfaceIntf::nICEnabled(nICEnabled());
+    EthernetInterfaceIntf::nicEnabled(nicEnabled());
 
 #if NIC_SUPPORTS_ETHTOOL
     InterfaceInfo ifInfo = EthernetInterface::getInterfaceInfo();
@@ -151,38 +151,38 @@
 
 void EthernetInterface::disableDHCP(IP::Protocol protocol)
 {
-    DHCPConf dhcpState = EthernetInterfaceIntf::dHCPEnabled();
+    DHCPConf dhcpState = EthernetInterfaceIntf::dhcpEnabled();
     if (dhcpState == EthernetInterface::DHCPConf::both)
     {
         if (protocol == IP::Protocol::IPv4)
         {
-            dHCPEnabled(EthernetInterface::DHCPConf::v6);
+            dhcpEnabled(EthernetInterface::DHCPConf::v6);
         }
         else if (protocol == IP::Protocol::IPv6)
         {
-            dHCPEnabled(EthernetInterface::DHCPConf::v4);
+            dhcpEnabled(EthernetInterface::DHCPConf::v4);
         }
     }
     else if ((dhcpState == EthernetInterface::DHCPConf::v4) &&
              (protocol == IP::Protocol::IPv4))
     {
-        dHCPEnabled(EthernetInterface::DHCPConf::none);
+        dhcpEnabled(EthernetInterface::DHCPConf::none);
     }
     else if ((dhcpState == EthernetInterface::DHCPConf::v6) &&
              (protocol == IP::Protocol::IPv6))
     {
-        dHCPEnabled(EthernetInterface::DHCPConf::none);
+        dhcpEnabled(EthernetInterface::DHCPConf::none);
     }
 }
 
 bool EthernetInterface::dhcpIsEnabled(IP::Protocol family, bool ignoreProtocol)
 {
-    return ((EthernetInterfaceIntf::dHCPEnabled() ==
+    return ((EthernetInterfaceIntf::dhcpEnabled() ==
              EthernetInterface::DHCPConf::both) ||
-            ((EthernetInterfaceIntf::dHCPEnabled() ==
+            ((EthernetInterfaceIntf::dhcpEnabled() ==
               EthernetInterface::DHCPConf::v6) &&
              ((family == IP::Protocol::IPv6) || ignoreProtocol)) ||
-            ((EthernetInterfaceIntf::dHCPEnabled() ==
+            ((EthernetInterfaceIntf::dhcpEnabled() ==
               EthernetInterface::DHCPConf::v4) &&
              ((family == IP::Protocol::IPv4) || ignoreProtocol)));
 }
@@ -275,7 +275,7 @@
     return idx;
 }
 
-ObjectPath EthernetInterface::iP(IP::Protocol protType, std::string ipaddress,
+ObjectPath EthernetInterface::ip(IP::Protocol protType, std::string ipaddress,
                                  uint8_t prefixLength, std::string gateway)
 {
 
@@ -321,30 +321,30 @@
     return objectPath;
 }
 
-ObjectPath EthernetInterface::neighbor(std::string iPAddress,
-                                       std::string mACAddress)
+ObjectPath EthernetInterface::neighbor(std::string ipAddress,
+                                       std::string macAddress)
 {
-    if (!isValidIP(AF_INET, iPAddress) && !isValidIP(AF_INET6, iPAddress))
+    if (!isValidIP(AF_INET, ipAddress) && !isValidIP(AF_INET6, ipAddress))
     {
         log<level::ERR>("Not a valid IP address",
-                        entry("ADDRESS=%s", iPAddress.c_str()));
-        elog<InvalidArgument>(Argument::ARGUMENT_NAME("iPAddress"),
-                              Argument::ARGUMENT_VALUE(iPAddress.c_str()));
+                        entry("ADDRESS=%s", ipAddress.c_str()));
+        elog<InvalidArgument>(Argument::ARGUMENT_NAME("ipAddress"),
+                              Argument::ARGUMENT_VALUE(ipAddress.c_str()));
     }
-    if (!mac_address::isUnicast(mac_address::fromString(mACAddress)))
+    if (!mac_address::isUnicast(mac_address::fromString(macAddress)))
     {
         log<level::ERR>("Not a valid MAC address",
-                        entry("MACADDRESS=%s", iPAddress.c_str()));
-        elog<InvalidArgument>(Argument::ARGUMENT_NAME("mACAddress"),
-                              Argument::ARGUMENT_VALUE(mACAddress.c_str()));
+                        entry("MACADDRESS=%s", ipAddress.c_str()));
+        elog<InvalidArgument>(Argument::ARGUMENT_NAME("macAddress"),
+                              Argument::ARGUMENT_VALUE(macAddress.c_str()));
     }
 
     std::string objectPath =
-        generateStaticNeighborObjectPath(iPAddress, mACAddress);
-    staticNeighbors.emplace(iPAddress,
+        generateStaticNeighborObjectPath(ipAddress, macAddress);
+    staticNeighbors.emplace(ipAddress,
                             std::make_shared<phosphor::network::Neighbor>(
-                                bus, objectPath.c_str(), *this, iPAddress,
-                                mACAddress, Neighbor::State::Permanent));
+                                bus, objectPath.c_str(), *this, ipAddress,
+                                macAddress, Neighbor::State::Permanent));
     manager.writeToConfigurationFile();
     return objectPath;
 }
@@ -383,7 +383,7 @@
         autoneg = edata.autoneg;
     }
 
-    nicEnabled = nICEnabled();
+    nicEnabled = nicEnabled();
     linkState = linkUp();
 
     return std::make_tuple(speed, duplex, autoneg, linkState, nicEnabled);
@@ -397,7 +397,7 @@
 std::string
     EthernetInterface::getMACAddress(const std::string& interfaceName) const
 {
-    std::string activeMACAddr = MacAddressIntf::mACAddress();
+    std::string activeMACAddr = MacAddressIntf::macAddress();
     EthernetIntfSocket eifSocket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
 
     if (eifSocket.sock < 0)
@@ -434,11 +434,11 @@
     return hexId.str();
 }
 
-std::string EthernetInterface::generateNeighborId(const std::string& iPAddress,
-                                                  const std::string& mACAddress)
+std::string EthernetInterface::generateNeighborId(const std::string& ipAddress,
+                                                  const std::string& macAddress)
 {
     std::stringstream hexId;
-    std::string hashString = iPAddress + mACAddress;
+    std::string hashString = ipAddress + macAddress;
 
     // Only want 8 hex digits.
     hexId << std::hex << ((std::hash<std::string>{}(hashString)) & 0xFFFFFFFF);
@@ -457,9 +457,9 @@
     manager.writeToConfigurationFile();
 }
 
-void EthernetInterface::deleteStaticNeighborObject(const std::string& iPAddress)
+void EthernetInterface::deleteStaticNeighborObject(const std::string& ipAddress)
 {
-    auto it = staticNeighbors.find(iPAddress);
+    auto it = staticNeighbors.find(ipAddress);
     if (it == staticNeighbors.end())
     {
         log<level::ERR>(
@@ -538,34 +538,34 @@
 }
 
 std::string EthernetInterface::generateStaticNeighborObjectPath(
-    const std::string& iPAddress, const std::string& mACAddress) const
+    const std::string& ipAddress, const std::string& macAddress) const
 {
     std::filesystem::path objectPath;
     objectPath /= objPath;
     objectPath /= "static_neighbor";
-    objectPath /= generateNeighborId(iPAddress, mACAddress);
+    objectPath /= generateNeighborId(ipAddress, macAddress);
     return objectPath.string();
 }
 
-bool EthernetInterface::iPv6AcceptRA(bool value)
+bool EthernetInterface::ipv6AcceptRA(bool value)
 {
-    if (value == EthernetInterfaceIntf::iPv6AcceptRA())
+    if (value == EthernetInterfaceIntf::ipv6AcceptRA())
     {
         return value;
     }
-    EthernetInterfaceIntf::iPv6AcceptRA(value);
+    EthernetInterfaceIntf::ipv6AcceptRA(value);
     manager.writeToConfigurationFile();
     return value;
 }
 
-EthernetInterface::DHCPConf EthernetInterface::dHCPEnabled(DHCPConf value)
+EthernetInterface::DHCPConf EthernetInterface::dhcpEnabled(DHCPConf value)
 {
-    if (value == EthernetInterfaceIntf::dHCPEnabled())
+    if (value == EthernetInterfaceIntf::dhcpEnabled())
     {
         return value;
     }
 
-    EthernetInterfaceIntf::dHCPEnabled(value);
+    EthernetInterfaceIntf::dhcpEnabled(value);
     manager.writeToConfigurationFile();
     return value;
 }
@@ -594,10 +594,10 @@
     return value;
 }
 
-bool EthernetInterface::nICEnabled() const
+bool EthernetInterface::nicEnabled() const
 {
     EthernetIntfSocket eifSocket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
-    bool value = EthernetInterfaceIntf::nICEnabled();
+    bool value = EthernetInterfaceIntf::nicEnabled();
 
     if (eifSocket.sock < 0)
     {
@@ -618,9 +618,9 @@
     return value;
 }
 
-bool EthernetInterface::nICEnabled(bool value)
+bool EthernetInterface::nicEnabled(bool value)
 {
-    if (value == EthernetInterfaceIntf::nICEnabled())
+    if (value == EthernetInterfaceIntf::nicEnabled())
     {
         return value;
     }
@@ -628,7 +628,7 @@
     EthernetIntfSocket eifSocket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
     if (eifSocket.sock < 0)
     {
-        return EthernetInterfaceIntf::nICEnabled();
+        return EthernetInterfaceIntf::nicEnabled();
     }
 
     ifreq ifr{0};
@@ -637,7 +637,7 @@
     {
         log<level::ERR>("ioctl failed for SIOCGIFFLAGS:",
                         entry("ERROR=%s", strerror(errno)));
-        return EthernetInterfaceIntf::nICEnabled();
+        return EthernetInterfaceIntf::nicEnabled();
     }
 
     ifr.ifr_flags &= ~IFF_UP;
@@ -647,9 +647,9 @@
     {
         log<level::ERR>("ioctl failed for SIOCSIFFLAGS:",
                         entry("ERROR=%s", strerror(errno)));
-        return EthernetInterfaceIntf::nICEnabled();
+        return EthernetInterfaceIntf::nicEnabled();
     }
-    EthernetInterfaceIntf::nICEnabled(value);
+    EthernetInterfaceIntf::nicEnabled(value);
     writeConfigurationFile();
 
     return value;
@@ -805,7 +805,7 @@
     DHCPConf dhcpEnabled =
         getDHCPValue(manager.getConfDir().string(), vlanInterfaceName);
     auto vlanIntf = std::make_unique<phosphor::network::VlanInterface>(
-        bus, path.c_str(), dhcpEnabled, EthernetInterfaceIntf::nICEnabled(), id,
+        bus, path.c_str(), dhcpEnabled, EthernetInterfaceIntf::nicEnabled(), id,
         *this, manager);
 
     // Fetch the ip address from the system
@@ -823,12 +823,12 @@
     std::string path = objPath;
     path += "_" + std::to_string(id);
 
-    // Pass the parents nICEnabled property, so that the child
+    // Pass the parents nicEnabled property, so that the child
     // VLAN interface can inherit.
 
     auto vlanIntf = std::make_unique<phosphor::network::VlanInterface>(
         bus, path.c_str(), EthernetInterface::DHCPConf::none,
-        EthernetInterfaceIntf::nICEnabled(), id, *this, manager);
+        EthernetInterfaceIntf::nicEnabled(), id, *this, manager);
 
     // write the device file for the vlan interface.
     vlanIntf->writeDeviceFile();
@@ -882,9 +882,9 @@
     return servers;
 }
 
-ServerList EthernetInterface::nTPServers(ServerList servers)
+ServerList EthernetInterface::ntpServers(ServerList servers)
 {
-    auto ntpServers = EthernetInterfaceIntf::nTPServers(servers);
+    auto ntpServers = EthernetInterfaceIntf::ntpServers(servers);
 
     writeConfigurationFile();
     // timesynchd reads the NTP server configuration from the
@@ -934,13 +934,13 @@
 
     // Write the link section
     stream << "[Link]\n";
-    auto mac = MacAddressIntf::mACAddress();
+    auto mac = MacAddressIntf::macAddress();
     if (!mac.empty())
     {
         stream << "MACAddress=" << mac << "\n";
     }
 
-    if (!EthernetInterfaceIntf::nICEnabled())
+    if (!EthernetInterfaceIntf::nicEnabled())
     {
         stream << "Unmanaged=yes\n";
     }
@@ -953,7 +953,7 @@
     stream << "LinkLocalAddressing=no\n";
 #endif
     stream << std::boolalpha
-           << "IPv6AcceptRA=" << EthernetInterfaceIntf::iPv6AcceptRA() << "\n";
+           << "IPv6AcceptRA=" << EthernetInterfaceIntf::ipv6AcceptRA() << "\n";
 
     // Add the VLAN entry
     for (const auto& intf : vlanInterfaces)
@@ -962,7 +962,7 @@
                << "\n";
     }
     // Add the NTP server
-    for (const auto& ntp : EthernetInterfaceIntf::nTPServers())
+    for (const auto& ntp : EthernetInterfaceIntf::ntpServers())
     {
         stream << "NTP=" << ntp << "\n";
     }
@@ -975,7 +975,7 @@
 
     // Add the DHCP entry
     stream << "DHCP="s +
-                  mapDHCPToSystemd[EthernetInterfaceIntf::dHCPEnabled()] + "\n";
+                  mapDHCPToSystemd[EthernetInterfaceIntf::dhcpEnabled()] + "\n";
 
     // Static IP addresses
     for (const auto& addr : addrs)
@@ -1029,8 +1029,8 @@
     {
         stream << "[Neighbor]"
                << "\n";
-        stream << "Address=" << neighbor.second->iPAddress() << "\n";
-        stream << "MACAddress=" << neighbor.second->mACAddress() << "\n";
+        stream << "Address=" << neighbor.second->ipAddress() << "\n";
+        stream << "MACAddress=" << neighbor.second->macAddress() << "\n";
     }
 
     // Write the dhcp section irrespective of whether DHCP is enabled or not
@@ -1050,10 +1050,10 @@
     stream << "ClientIdentifier=mac\n";
     if (manager.getDHCPConf())
     {
-        auto value = manager.getDHCPConf()->dNSEnabled() ? "true"s : "false"s;
+        auto value = manager.getDHCPConf()->dnsEnabled() ? "true"s : "false"s;
         stream << "UseDNS="s + value + "\n";
 
-        value = manager.getDHCPConf()->nTPEnabled() ? "true"s : "false"s;
+        value = manager.getDHCPConf()->ntpEnabled() ? "true"s : "false"s;
         stream << "UseNTP="s + value + "\n";
 
         value = manager.getDHCPConf()->hostNameEnabled() ? "true"s : "false"s;
@@ -1065,7 +1065,7 @@
     }
 }
 
-std::string EthernetInterface::mACAddress(std::string value)
+std::string EthernetInterface::macAddress(std::string value)
 {
     ether_addr newMAC;
     try
@@ -1091,15 +1091,15 @@
     std::string validMAC = mac_address::toString(newMAC);
 
     // We don't need to update the system if the address is unchanged
-    ether_addr oldMAC = mac_address::fromString(MacAddressIntf::mACAddress());
+    ether_addr oldMAC = mac_address::fromString(MacAddressIntf::macAddress());
     if (!stdplus::raw::equal(newMAC, oldMAC))
     {
         // Update everything that depends on the MAC value
         for (const auto& [name, intf] : vlanInterfaces)
         {
-            intf->MacAddressIntf::mACAddress(validMAC);
+            intf->MacAddressIntf::macAddress(validMAC);
         }
-        MacAddressIntf::mACAddress(validMAC);
+        MacAddressIntf::macAddress(validMAC);
 
         // TODO: would remove the call below and
         //      just restart systemd-netwokd
diff --git a/ethernet_interface.hpp b/ethernet_interface.hpp
index e2418a2..8e28b51 100644
--- a/ethernet_interface.hpp
+++ b/ethernet_interface.hpp
@@ -13,6 +13,16 @@
 #include <xyz/openbmc_project/Network/EthernetInterface/server.hpp>
 #include <xyz/openbmc_project/Network/MACAddress/server.hpp>
 
+#ifndef SDBUSPP_NEW_CAMELCASE
+#define dhcpEnabled dHCPEnabled
+#define ip iP
+#define ipAddress iPAddress
+#define ipv6AcceptRA iPv6AcceptRA
+#define macAddress mACAddress
+#define nicEnabled nICEnabled
+#define ntpServers nTPServers
+#endif
+
 namespace phosphor
 {
 namespace network
@@ -92,29 +102,29 @@
      */
     virtual void loadNameServers();
 
-    /** @brief Function to create ipaddress dbus object.
+    /** @brief Function to create ipAddress dbus object.
      *  @param[in] addressType - Type of ip address.
-     *  @param[in] ipaddress- IP address.
+     *  @param[in] ipAddress- IP address.
      *  @param[in] prefixLength - Length of prefix.
      *  @param[in] gateway - Gateway ip address.
      */
 
-    ObjectPath iP(IP::Protocol addressType, std::string ipaddress,
+    ObjectPath ip(IP::Protocol addressType, std::string ipAddress,
                   uint8_t prefixLength, std::string gateway) override;
 
     /** @brief Function to create static neighbor dbus object.
      *  @param[in] ipAddress - IP address.
      *  @param[in] macAddress - Low level MAC address.
      */
-    ObjectPath neighbor(std::string iPAddress, std::string mACAddress) override;
+    ObjectPath neighbor(std::string ipAddress, std::string macAddress) override;
 
-    /* @brief delete the dbus object of the given ipaddress.
-     * @param[in] ipaddress - IP address.
+    /* @brief delete the dbus object of the given ipAddress.
+     * @param[in] ipAddress - IP address.
      */
-    void deleteObject(const std::string& ipaddress);
+    void deleteObject(const std::string& ipAddress);
 
-    /* @brief delete the dbus object of the given ipaddress.
-     * @param[in] ipaddress - IP address.
+    /* @brief delete the dbus object of the given ipAddress.
+     * @param[in] ipAddress - IP address.
      */
     void deleteStaticNeighborObject(const std::string& ipAddress);
 
@@ -139,7 +149,7 @@
     unsigned ifIndex() const;
 
     /* @brief Gets all the ip addresses.
-     * @returns the list of ipaddress.
+     * @returns the list of ipAddress.
      */
     const AddressMap& getAddresses() const
     {
@@ -155,7 +165,7 @@
     }
 
     /** Set value of DHCPEnabled */
-    DHCPConf dHCPEnabled(DHCPConf value) override;
+    DHCPConf dhcpEnabled(DHCPConf value) override;
 
     /** @brief Selectively disables DHCP
      *  @param[in] protocol - The IPv4 or IPv6 protocol to return to static
@@ -167,16 +177,16 @@
     bool linkUp() const override;
 
     /** Retrieve NIC State */
-    bool nICEnabled() const override;
+    bool nicEnabled() const override;
 
     /** Set value of NICEnabled */
-    bool nICEnabled(bool value) override;
+    bool nicEnabled(bool value) override;
 
     /** @brief sets the MAC address.
      *  @param[in] value - MAC address which needs to be set on the system.
      *  @returns macAddress of the interface or throws an error.
      */
-    std::string mACAddress(std::string value) override;
+    std::string macAddress(std::string value) override;
 
     /** @brief get the IPv6AcceptRA flag from the network configuration file
      *
@@ -186,12 +196,12 @@
     /** @brief check conf file for Router Advertisements
      *
      */
-    bool iPv6AcceptRA(bool value) override;
+    bool ipv6AcceptRA(bool value) override;
 
     /** @brief sets the NTP servers.
      *  @param[in] value - vector of NTP servers.
      */
-    ServerList nTPServers(ServerList value) override;
+    ServerList ntpServers(ServerList value) override;
 
     /** @brief sets the DNS/nameservers.
      *  @param[in] value - vector of DNS servers.
@@ -233,11 +243,11 @@
      */
     std::string defaultGateway6(std::string gateway) override;
 
-    using EthernetInterfaceIntf::dHCPEnabled;
+    using EthernetInterfaceIntf::dhcpEnabled;
     using EthernetInterfaceIntf::interfaceName;
     using EthernetInterfaceIntf::linkUp;
-    using EthernetInterfaceIntf::nICEnabled;
-    using MacAddressIntf::mACAddress;
+    using EthernetInterfaceIntf::nicEnabled;
+    using MacAddressIntf::macAddress;
 
     using EthernetInterfaceIntf::defaultGateway;
     using EthernetInterfaceIntf::defaultGateway6;
@@ -264,7 +274,7 @@
 
     /** @brief construct the ip address dbus object path.
      *  @param[in] addressType - Type of ip address.
-     *  @param[in] ipaddress - IP address.
+     *  @param[in] ipAddress - IP address.
      *  @param[in] prefixLength - Length of prefix.
      *  @param[in] gateway - Gateway address.
 
@@ -272,34 +282,34 @@
      */
 
     std::string generateObjectPath(IP::Protocol addressType,
-                                   const std::string& ipaddress,
+                                   const std::string& ipAddress,
                                    uint8_t prefixLength,
                                    const std::string& gateway) const;
 
     std::string
-        generateStaticNeighborObjectPath(const std::string& iPAddress,
-                                         const std::string& mACAddress) const;
+        generateStaticNeighborObjectPath(const std::string& ipAddress,
+                                         const std::string& macAddress) const;
 
-    /** @brief generates the id by doing hash of ipaddress,
+    /** @brief generates the id by doing hash of ipAddress,
      *         prefixlength and the gateway.
-     *  @param[in] ipaddress - IP address.
+     *  @param[in] ipAddress - IP address.
      *  @param[in] prefixLength - Length of prefix.
      *  @param[in] gateway - Gateway address.
      *  @return hash string.
      */
 
-    static std::string generateId(const std::string& ipaddress,
+    static std::string generateId(const std::string& ipAddress,
                                   uint8_t prefixLength,
                                   const std::string& gateway);
 
-    /** @brief generates the id by doing hash of ipaddress
+    /** @brief generates the id by doing hash of ipAddress
      *         and the mac address.
-     *  @param[in] iPAddress  - IP address.
-     *  @param[in] mACAddress - Gateway address.
+     *  @param[in] ipAddress  - IP address.
+     *  @param[in] macAddress - Gateway address.
      *  @return hash string.
      */
-    static std::string generateNeighborId(const std::string& iPAddress,
-                                          const std::string& mACAddress);
+    static std::string generateNeighborId(const std::string& ipAddress,
+                                          const std::string& macAddress);
 
     /** @brief write the dhcp section **/
     void writeDHCPSection(std::fstream& stream);
diff --git a/neighbor.cpp b/neighbor.cpp
index dc6a581..11b0666 100644
--- a/neighbor.cpp
+++ b/neighbor.cpp
@@ -91,8 +91,8 @@
     NeighborObj(bus, objPath, true),
     parent(parent)
 {
-    this->iPAddress(ipAddress);
-    this->mACAddress(macAddress);
+    this->ipAddress(ipAddress);
+    this->macAddress(macAddress);
     this->state(state);
 
     // Emit deferred signal.
@@ -101,7 +101,7 @@
 
 void Neighbor::delete_()
 {
-    parent.deleteStaticNeighborObject(iPAddress());
+    parent.deleteStaticNeighborObject(ipAddress());
 }
 
 } // namespace network
diff --git a/network_manager.cpp b/network_manager.cpp
index c55c9bb..10a2573 100644
--- a/network_manager.cpp
+++ b/network_manager.cpp
@@ -219,7 +219,7 @@
         if (interface.first == inventoryEthPair.first)
         {
             auto returnMAC =
-                interface.second->mACAddress(inventoryEthPair.second);
+                interface.second->macAddress(inventoryEthPair.second);
             if (returnMAC == inventoryEthPair.second)
             {
                 log<level::INFO>("Set the MAC on "),
diff --git a/test/test_ethernet_interface.cpp b/test/test_ethernet_interface.cpp
index 67a26dc..6f441f7 100644
--- a/test/test_ethernet_interface.cpp
+++ b/test/test_ethernet_interface.cpp
@@ -101,14 +101,14 @@
     void createIPObject(IP::Protocol addressType, const std::string& ipaddress,
                         uint8_t subnetMask, const std::string& gateway)
     {
-        interface.iP(addressType, ipaddress, subnetMask, gateway);
+        interface.ip(addressType, ipaddress, subnetMask, gateway);
     }
 };
 
 TEST_F(TestEthernetInterface, NoIPaddress)
 {
     EXPECT_EQ(countIPObjects(), 0);
-    EXPECT_EQ(mac_address::toString(mac), interface.mACAddress());
+    EXPECT_EQ(mac_address::toString(mac), interface.macAddress());
 }
 
 TEST_F(TestEthernetInterface, AddIPAddress)
@@ -194,7 +194,7 @@
 {
     ServerList servers = {"10.1.1.1", "10.2.2.2", "10.3.3.3"};
     EXPECT_CALL(manager, restartSystemdUnit(networkdService)).Times(1);
-    interface.nTPServers(servers);
+    interface.ntpServers(servers);
     fs::path filePath = confDir;
     filePath /= "00-bmc-test0.network";
     config::Parser parser(filePath.string());
diff --git a/test/test_vlan_interface.cpp b/test/test_vlan_interface.cpp
index 85f4f40..740b6fd 100644
--- a/test/test_vlan_interface.cpp
+++ b/test/test_vlan_interface.cpp
@@ -103,7 +103,7 @@
     void createIPObject(IP::Protocol addressType, const std::string& ipaddress,
                         uint8_t subnetMask, const std::string& gateway)
     {
-        interface.iP(addressType, ipaddress, subnetMask, gateway);
+        interface.ip(addressType, ipaddress, subnetMask, gateway);
     }
 
     bool isValueFound(const std::vector<std::string>& values,
diff --git a/vlan_interface.cpp b/vlan_interface.cpp
index 7762adc..4920c77 100644
--- a/vlan_interface.cpp
+++ b/vlan_interface.cpp
@@ -23,7 +23,7 @@
 
 VlanInterface::VlanInterface(sdbusplus::bus::bus& bus,
                              const std::string& objPath, DHCPConf dhcpEnabled,
-                             bool nICEnabled, uint32_t vlanID,
+                             bool nicEnabled, uint32_t vlanID,
                              EthernetInterface& intf, Manager& parent) :
     VlanIface(bus, objPath.c_str()),
     DeleteIface(bus, objPath.c_str()),
@@ -31,14 +31,14 @@
     parentInterface(intf)
 {
     id(vlanID);
-    EthernetInterfaceIntf::nICEnabled(nICEnabled);
+    EthernetInterfaceIntf::nicEnabled(nicEnabled);
     VlanIface::interfaceName(EthernetInterface::interfaceName());
-    MacAddressIntf::mACAddress(parentInterface.mACAddress());
+    MacAddressIntf::macAddress(parentInterface.macAddress());
 
     emit_object_added();
 }
 
-std::string VlanInterface::mACAddress(std::string)
+std::string VlanInterface::macAddress(std::string)
 {
     log<level::ERR>("Tried to set MAC address on VLAN");
     elog<InternalFailure>();
diff --git a/vlan_interface.hpp b/vlan_interface.hpp
index a6674ea..c003056 100644
--- a/vlan_interface.hpp
+++ b/vlan_interface.hpp
@@ -58,7 +58,7 @@
      *  @param[in] value - MAC address which needs to be set on the system.
      *  @returns macAddress of the interface or throws an error.
      */
-    std::string mACAddress(std::string value) override;
+    std::string macAddress(std::string value) override;
 
     /** @brief writes the device configuration.
                systemd reads this configuration file