diff --git a/phosphor-ldap-config/ldap_config.cpp b/phosphor-ldap-config/ldap_config.cpp
index bd3c97f..51b785a 100644
--- a/phosphor-ldap-config/ldap_config.cpp
+++ b/phosphor-ldap-config/ldap_config.cpp
@@ -51,14 +51,14 @@
 
 Config::Config(sdbusplus::bus::bus& bus, const char* path, const char* filePath,
                const char* caCertFile, const char* certFile, bool secureLDAP,
-               std::string lDAPServerURI, std::string lDAPBindDN,
-               std::string lDAPBaseDN, std::string&& lDAPBindDNPassword,
-               ConfigIface::SearchScope lDAPSearchScope,
-               ConfigIface::Type lDAPType, bool lDAPServiceEnabled,
+               std::string ldapServerURI, std::string ldapBindDN,
+               std::string ldapBaseDN, std::string&& ldapBindDNPassword,
+               ConfigIface::SearchScope ldapSearchScope,
+               ConfigIface::Type ldapType, bool ldapServiceEnabled,
                std::string userNameAttr, std::string groupNameAttr,
                ConfigMgr& parent) :
     Ifaces(bus, path, true),
-    secureLDAP(secureLDAP), lDAPBindPassword(std::move(lDAPBindDNPassword)),
+    secureLDAP(secureLDAP), ldapBindPassword(std::move(ldapBindDNPassword)),
     tlsCacertFile(caCertFile), tlsCertFile(certFile), configFilePath(filePath),
     objectPath(path), bus(bus), parent(parent),
     certificateInstalledSignal(
@@ -77,12 +77,12 @@
         std::bind(std::mem_fn(&Config::certificateChanged), this,
                   std::placeholders::_1))
 {
-    ConfigIface::lDAPServerURI(lDAPServerURI);
-    ConfigIface::lDAPBindDN(lDAPBindDN);
-    ConfigIface::lDAPBaseDN(lDAPBaseDN);
-    ConfigIface::lDAPSearchScope(lDAPSearchScope);
-    ConfigIface::lDAPType(lDAPType);
-    EnableIface::enabled(lDAPServiceEnabled);
+    ConfigIface::ldapServerURI(ldapServerURI);
+    ConfigIface::ldapBindDN(ldapBindDN);
+    ConfigIface::ldapBaseDN(ldapBaseDN);
+    ConfigIface::ldapSearchScope(ldapSearchScope);
+    ConfigIface::ldapType(ldapType);
+    EnableIface::enabled(ldapServiceEnabled);
     ConfigIface::userNameAttribute(userNameAttr);
     ConfigIface::groupNameAttribute(groupNameAttr);
     // NOTE: Don't update the bindDN password under ConfigIface
@@ -108,7 +108,7 @@
 
 Config::Config(sdbusplus::bus::bus& bus, const char* path, const char* filePath,
                const char* caCertFile, const char* certFile,
-               ConfigIface::Type lDAPType, ConfigMgr& parent) :
+               ConfigIface::Type ldapType, ConfigMgr& parent) :
     Ifaces(bus, path, true),
     secureLDAP(false), tlsCacertFile(caCertFile), tlsCertFile(certFile),
     configFilePath(filePath), objectPath(path), bus(bus), parent(parent),
@@ -126,7 +126,7 @@
         std::bind(std::mem_fn(&Config::certificateChanged), this,
                   std::placeholders::_1))
 {
-    ConfigIface::lDAPType(lDAPType);
+    ConfigIface::ldapType(ldapType);
 
     configPersistPath = parent.dbusPersistentPath;
     configPersistPath += objectPath;
@@ -202,16 +202,16 @@
     confData << "bind_timelimit 30\n";
     confData << "pagesize 1000\n";
     confData << "referrals off\n\n";
-    confData << "uri " << lDAPServerURI() << "\n\n";
-    confData << "base " << lDAPBaseDN() << "\n\n";
-    confData << "binddn " << lDAPBindDN() << "\n";
-    if (!lDAPBindPassword.empty())
+    confData << "uri " << ldapServerURI() << "\n\n";
+    confData << "base " << ldapBaseDN() << "\n\n";
+    confData << "binddn " << ldapBindDN() << "\n";
+    if (!ldapBindPassword.empty())
     {
-        confData << "bindpw " << lDAPBindPassword << "\n";
+        confData << "bindpw " << ldapBindPassword << "\n";
         isPwdTobeWritten = true;
     }
     confData << "\n";
-    switch (lDAPSearchScope())
+    switch (ldapSearchScope())
     {
         case ConfigIface::SearchScope::sub:
             confData << "scope sub\n\n";
@@ -223,8 +223,8 @@
             confData << "scope base\n\n";
             break;
     }
-    confData << "base passwd " << lDAPBaseDN() << "\n";
-    confData << "base shadow " << lDAPBaseDN() << "\n\n";
+    confData << "base passwd " << ldapBaseDN() << "\n";
+    confData << "base shadow " << ldapBaseDN() << "\n\n";
     if (secureLDAP == true)
     {
         confData << "ssl on\n";
@@ -248,7 +248,7 @@
         confData << "ssl off\n";
     }
     confData << "\n";
-    if (lDAPType() == ConfigIface::Type::ActiveDirectory)
+    if (ldapType() == ConfigIface::Type::ActiveDirectory)
     {
         if (ConfigIface::userNameAttribute().empty())
         {
@@ -278,7 +278,7 @@
                  << ConfigIface::userNameAttribute() << "\n";
         confData << "nss_initgroups_ignoreusers ALLLOCAL\n";
     }
-    else if (lDAPType() == ConfigIface::Type::OpenLdap)
+    else if (ldapType() == ConfigIface::Type::OpenLdap)
     {
         if (ConfigIface::userNameAttribute().empty())
         {
@@ -326,12 +326,12 @@
     return;
 }
 
-std::string Config::lDAPBindDNPassword(std::string value)
+std::string Config::ldapBindDNPassword(std::string value)
 {
     // Don't update the D-bus object, this is just to
     // facilitate if user wants to change the bind dn password
     // once d-bus object gets created.
-    lDAPBindPassword = value;
+    ldapBindPassword = value;
     try
     {
         if (enabled())
@@ -353,12 +353,12 @@
     return value;
 }
 
-std::string Config::lDAPServerURI(std::string value)
+std::string Config::ldapServerURI(std::string value)
 {
     std::string val;
     try
     {
-        if (value == lDAPServerURI())
+        if (value == ldapServerURI())
         {
             return value;
         }
@@ -374,7 +374,7 @@
         {
             log<level::ERR>("bad LDAP Server URI",
                             entry("LDAPSERVERURI=%s", value.c_str()));
-            elog<InvalidArgument>(Argument::ARGUMENT_NAME("lDAPServerURI"),
+            elog<InvalidArgument>(Argument::ARGUMENT_NAME("ldapServerURI"),
                                   Argument::ARGUMENT_VALUE(value.c_str()));
         }
 
@@ -384,7 +384,7 @@
                             entry("TLSCACERTFILE=%s", tlsCacertFile.c_str()));
             elog<NoCACertificate>();
         }
-        val = ConfigIface::lDAPServerURI(value);
+        val = ConfigIface::ldapServerURI(value);
         if (enabled())
         {
             writeConfig();
@@ -413,12 +413,12 @@
     return val;
 }
 
-std::string Config::lDAPBindDN(std::string value)
+std::string Config::ldapBindDN(std::string value)
 {
     std::string val;
     try
     {
-        if (value == lDAPBindDN())
+        if (value == ldapBindDN())
         {
             return value;
         }
@@ -427,11 +427,11 @@
         {
             log<level::ERR>("Not a valid LDAP BINDDN",
                             entry("LDAPBINDDN=%s", value.c_str()));
-            elog<InvalidArgument>(Argument::ARGUMENT_NAME("lDAPBindDN"),
+            elog<InvalidArgument>(Argument::ARGUMENT_NAME("ldapBindDN"),
                                   Argument::ARGUMENT_VALUE(value.c_str()));
         }
 
-        val = ConfigIface::lDAPBindDN(value);
+        val = ConfigIface::ldapBindDN(value);
         if (enabled())
         {
             writeConfig();
@@ -456,12 +456,12 @@
     return val;
 }
 
-std::string Config::lDAPBaseDN(std::string value)
+std::string Config::ldapBaseDN(std::string value)
 {
     std::string val;
     try
     {
-        if (value == lDAPBaseDN())
+        if (value == ldapBaseDN())
         {
             return value;
         }
@@ -470,11 +470,11 @@
         {
             log<level::ERR>("Not a valid LDAP BASEDN",
                             entry("BASEDN=%s", value.c_str()));
-            elog<InvalidArgument>(Argument::ARGUMENT_NAME("lDAPBaseDN"),
+            elog<InvalidArgument>(Argument::ARGUMENT_NAME("ldapBaseDN"),
                                   Argument::ARGUMENT_VALUE(value.c_str()));
         }
 
-        val = ConfigIface::lDAPBaseDN(value);
+        val = ConfigIface::ldapBaseDN(value);
         if (enabled())
         {
             writeConfig();
@@ -499,17 +499,17 @@
     return val;
 }
 
-ConfigIface::SearchScope Config::lDAPSearchScope(ConfigIface::SearchScope value)
+ConfigIface::SearchScope Config::ldapSearchScope(ConfigIface::SearchScope value)
 {
     ConfigIface::SearchScope val;
     try
     {
-        if (value == lDAPSearchScope())
+        if (value == ldapSearchScope())
         {
             return value;
         }
 
-        val = ConfigIface::lDAPSearchScope(value);
+        val = ConfigIface::ldapSearchScope(value);
         if (enabled())
         {
             writeConfig();
@@ -531,10 +531,10 @@
     return val;
 }
 
-ConfigIface::Type Config::lDAPType(ConfigIface::Type value)
+ConfigIface::Type Config::ldapType(ConfigIface::Type value)
 {
     elog<NotAllowed>(NotAllowedArgument::REASON("ReadOnly Property"));
-    return lDAPType();
+    return ldapType();
 }
 
 bool Config::enabled(bool value)
@@ -643,11 +643,11 @@
 void Config::save(Archive& archive, const std::uint32_t version) const
 {
     archive(this->enabled());
-    archive(lDAPServerURI());
-    archive(lDAPBindDN());
-    archive(lDAPBaseDN());
-    archive(lDAPSearchScope());
-    archive(lDAPBindPassword);
+    archive(ldapServerURI());
+    archive(ldapBindDN());
+    archive(ldapBaseDN());
+    archive(ldapSearchScope());
+    archive(ldapBindPassword);
     archive(userNameAttribute());
     archive(groupNameAttribute());
 }
@@ -661,20 +661,20 @@
 
     std::string str;
     archive(str);
-    ConfigIface::lDAPServerURI(str);
+    ConfigIface::ldapServerURI(str);
 
     archive(str);
-    ConfigIface::lDAPBindDN(str);
+    ConfigIface::ldapBindDN(str);
 
     archive(str);
-    ConfigIface::lDAPBaseDN(str);
+    ConfigIface::ldapBaseDN(str);
 
     ConfigIface::SearchScope scope;
     archive(scope);
-    ConfigIface::lDAPSearchScope(scope);
+    ConfigIface::ldapSearchScope(scope);
 
     archive(str);
-    lDAPBindPassword = str;
+    ldapBindPassword = str;
 
     archive(str);
     ConfigIface::userNameAttribute(str);
@@ -717,11 +717,11 @@
             cereal::BinaryInputArchive iarchive(is);
             iarchive(*this);
 
-            if (isValidLDAPURI(lDAPServerURI(), LDAPscheme))
+            if (isValidLDAPURI(ldapServerURI(), LDAPscheme))
             {
                 secureLDAP = false;
             }
-            else if (isValidLDAPURI(lDAPServerURI(), LDAPSscheme))
+            else if (isValidLDAPURI(ldapServerURI(), LDAPSscheme))
             {
                 secureLDAP = true;
             }
diff --git a/phosphor-ldap-config/ldap_config.hpp b/phosphor-ldap-config/ldap_config.hpp
index e68f434..f3c88e4 100644
--- a/phosphor-ldap-config/ldap_config.hpp
+++ b/phosphor-ldap-config/ldap_config.hpp
@@ -19,6 +19,15 @@
 #include <set>
 #include <string>
 
+#ifndef SDBUSPP_NEW_CAMELCASE
+#define ldapBaseDN lDAPBaseDN
+#define ldapBindDN lDAPBindDN
+#define ldapBindDNPassword lDAPBindDNPassword
+#define ldapSearchScope lDAPSearchScope
+#define ldapServerURI lDAPServerURI
+#define ldapType lDAPType
+#endif
+
 namespace phosphor
 {
 namespace ldap
@@ -65,14 +74,14 @@
      *  @param[in] caCertFile - LDAP's CA certificate file.
      *  @param[in] certFile - LDAP's client certificate file.
      *  @param[in] secureLDAP - Specifies whether to use SSL or not.
-     *  @param[in] lDAPServerURI - LDAP URI of the server.
-     *  @param[in] lDAPBindDN - distinguished name with which to bind.
-     *  @param[in] lDAPBaseDN -  distinguished name to use as search base.
-     *  @param[in] lDAPBindDNPassword - credentials with which to bind.
-     *  @param[in] lDAPSearchScope - the search scope.
-     *  @param[in] lDAPType - Specifies the LDAP server type which can be AD
+     *  @param[in] ldapServerURI - LDAP URI of the server.
+     *  @param[in] ldapBindDN - distinguished name with which to bind.
+     *  @param[in] ldapBaseDN -  distinguished name to use as search base.
+     *  @param[in] ldapBindDNPassword - credentials with which to bind.
+     *  @param[in] ldapSearchScope - the search scope.
+     *  @param[in] ldapType - Specifies the LDAP server type which can be AD
      *              or openLDAP.
-     *  @param[in] lDAPServiceEnabled - Specifies whether the service would be
+     *  @param[in] ldapServiceEnabled - Specifies whether the service would be
      *  enabled or not.
      *  @param[in] groupNameAttribute - Specifies attribute name that contains
      *             the name of the Group in the LDAP server.
@@ -84,65 +93,65 @@
 
     Config(sdbusplus::bus::bus& bus, const char* path, const char* filePath,
            const char* caCertFile, const char* certFile, bool secureLDAP,
-           std::string lDAPServerURI, std::string lDAPBindDN,
-           std::string lDAPBaseDN, std::string&& lDAPBindDNPassword,
-           ConfigIface::SearchScope lDAPSearchScope, ConfigIface::Type lDAPType,
-           bool lDAPServiceEnabled, std::string groupNameAttribute,
+           std::string ldapServerURI, std::string ldapBindDN,
+           std::string ldapBaseDN, std::string&& ldapBindDNPassword,
+           ConfigIface::SearchScope ldapSearchScope, ConfigIface::Type ldapType,
+           bool ldapServiceEnabled, std::string groupNameAttribute,
            std::string userNameAttribute, ConfigMgr& parent);
 
     /** @brief Constructor to put object onto bus at a D-Bus path.
      *  @param[in] bus - Bus to attach to.
      *  @param[in] path - The D-Bus object path to attach at.
      *  @param[in] filePath - LDAP configuration file.
-     *  @param[in] lDAPType - Specifies the LDAP server type which can be AD
+     *  @param[in] ldapType - Specifies the LDAP server type which can be AD
      *              or openLDAP.
      *  @param[in] parent - parent of config object.
      */
     Config(sdbusplus::bus::bus& bus, const char* path, const char* filePath,
            const char* caCertFile, const char* certFile,
-           ConfigIface::Type lDAPType, ConfigMgr& parent);
+           ConfigIface::Type ldapType, ConfigMgr& parent);
 
     using ConfigIface::groupNameAttribute;
-    using ConfigIface::lDAPBaseDN;
-    using ConfigIface::lDAPBindDN;
-    using ConfigIface::lDAPBindDNPassword;
-    using ConfigIface::lDAPSearchScope;
-    using ConfigIface::lDAPServerURI;
-    using ConfigIface::lDAPType;
+    using ConfigIface::ldapBaseDN;
+    using ConfigIface::ldapBindDN;
+    using ConfigIface::ldapBindDNPassword;
+    using ConfigIface::ldapSearchScope;
+    using ConfigIface::ldapServerURI;
+    using ConfigIface::ldapType;
     using ConfigIface::setPropertyByName;
     using ConfigIface::userNameAttribute;
     using EnableIface::enabled;
 
     /** @brief Update the Server URI property.
-     *  @param[in] value - lDAPServerURI value to be updated.
-     *  @returns value of changed lDAPServerURI.
+     *  @param[in] value - ldapServerURI value to be updated.
+     *  @returns value of changed ldapServerURI.
      */
-    std::string lDAPServerURI(std::string value) override;
+    std::string ldapServerURI(std::string value) override;
 
     /** @brief Update the BindDN property.
-     *  @param[in] value - lDAPBindDN value to be updated.
-     *  @returns value of changed lDAPBindDN.
+     *  @param[in] value - ldapBindDN value to be updated.
+     *  @returns value of changed ldapBindDN.
      */
-    std::string lDAPBindDN(std::string value) override;
+    std::string ldapBindDN(std::string value) override;
 
     /** @brief Update the BaseDN property.
-     *  @param[in] value - lDAPBaseDN value to be updated.
-     *  @returns value of changed lDAPBaseDN.
+     *  @param[in] value - ldapBaseDN value to be updated.
+     *  @returns value of changed ldapBaseDN.
      */
-    std::string lDAPBaseDN(std::string value) override;
+    std::string ldapBaseDN(std::string value) override;
 
     /** @brief Update the Search scope property.
-     *  @param[in] value - lDAPSearchScope value to be updated.
-     *  @returns value of changed lDAPSearchScope.
+     *  @param[in] value - ldapSearchScope value to be updated.
+     *  @returns value of changed ldapSearchScope.
      */
     ConfigIface::SearchScope
-        lDAPSearchScope(ConfigIface::SearchScope value) override;
+        ldapSearchScope(ConfigIface::SearchScope value) override;
 
     /** @brief Update the LDAP Type property.
-     *  @param[in] value - lDAPType value to be updated.
-     *  @returns value of changed lDAPType.
+     *  @param[in] value - ldapType value to be updated.
+     *  @returns value of changed ldapType.
      */
-    ConfigIface::Type lDAPType(ConfigIface::Type value) override;
+    ConfigIface::Type ldapType(ConfigIface::Type value) override;
 
     /** @brief Update the ldapServiceEnabled property.
      *  @param[in] value - ldapServiceEnabled value to be updated.
@@ -163,10 +172,10 @@
     std::string groupNameAttribute(std::string value) override;
 
     /** @brief Update the BindDNPasword property.
-     *  @param[in] value - lDAPBindDNPassword value to be updated.
-     *  @returns value of changed lDAPBindDNPassword.
+     *  @param[in] value - ldapBindDNPassword value to be updated.
+     *  @returns value of changed ldapBindDNPassword.
      */
-    std::string lDAPBindDNPassword(std::string value) override;
+    std::string ldapBindDNPassword(std::string value) override;
 
     /** @brief Function required by Cereal to perform deserialization.
      *  @tparam Archive - Cereal archive type (binary in our case).
@@ -249,7 +258,7 @@
 
   private:
     bool secureLDAP;
-    std::string lDAPBindPassword{};
+    std::string ldapBindPassword{};
     std::string tlsCacertFile{};
     std::string tlsCertFile{};
     std::string configFilePath{};
diff --git a/phosphor-ldap-config/ldap_config_mgr.cpp b/phosphor-ldap-config/ldap_config_mgr.cpp
index 3021793..5dea8e8 100644
--- a/phosphor-ldap-config/ldap_config_mgr.cpp
+++ b/phosphor-ldap-config/ldap_config_mgr.cpp
@@ -76,27 +76,27 @@
 }
 
 std::string ConfigMgr::createConfig(
-    std::string lDAPServerURI, std::string lDAPBindDN, std::string lDAPBaseDN,
-    std::string lDAPBindDNPassword, CreateIface::SearchScope lDAPSearchScope,
-    CreateIface::Create::Type lDAPType, std::string groupNameAttribute,
+    std::string ldapServerURI, std::string ldapBindDN, std::string ldapBaseDN,
+    std::string ldapBindDNPassword, CreateIface::SearchScope ldapSearchScope,
+    CreateIface::Create::Type ldapType, std::string groupNameAttribute,
     std::string userNameAttribute)
 {
     bool secureLDAP = false;
 
-    if (isValidLDAPURI(lDAPServerURI, LDAPSscheme))
+    if (isValidLDAPURI(ldapServerURI, LDAPSscheme))
     {
         secureLDAP = true;
     }
-    else if (isValidLDAPURI(lDAPServerURI, LDAPscheme))
+    else if (isValidLDAPURI(ldapServerURI, LDAPscheme))
     {
         secureLDAP = false;
     }
     else
     {
         log<level::ERR>("bad LDAP Server URI",
-                        entry("LDAPSERVERURI=%s", lDAPServerURI.c_str()));
-        elog<InvalidArgument>(Argument::ARGUMENT_NAME("lDAPServerURI"),
-                              Argument::ARGUMENT_VALUE(lDAPServerURI.c_str()));
+                        entry("LDAPSERVERURI=%s", ldapServerURI.c_str()));
+        elog<InvalidArgument>(Argument::ARGUMENT_NAME("ldapServerURI"),
+                              Argument::ARGUMENT_VALUE(ldapServerURI.c_str()));
     }
 
     if (secureLDAP && !fs::exists(tlsCacertFile.c_str()))
@@ -106,20 +106,20 @@
         elog<NoCACertificate>();
     }
 
-    if (lDAPBindDN.empty())
+    if (ldapBindDN.empty())
     {
         log<level::ERR>("Not a valid LDAP BINDDN",
-                        entry("LDAPBINDDN=%s", lDAPBindDN.c_str()));
+                        entry("LDAPBINDDN=%s", ldapBindDN.c_str()));
         elog<InvalidArgument>(Argument::ARGUMENT_NAME("LDAPBindDN"),
-                              Argument::ARGUMENT_VALUE(lDAPBindDN.c_str()));
+                              Argument::ARGUMENT_VALUE(ldapBindDN.c_str()));
     }
 
-    if (lDAPBaseDN.empty())
+    if (ldapBaseDN.empty())
     {
         log<level::ERR>("Not a valid LDAP BASEDN",
-                        entry("LDAPBASEDN=%s", lDAPBaseDN.c_str()));
+                        entry("LDAPBASEDN=%s", ldapBaseDN.c_str()));
         elog<InvalidArgument>(Argument::ARGUMENT_NAME("LDAPBaseDN"),
-                              Argument::ARGUMENT_VALUE(lDAPBaseDN.c_str()));
+                              Argument::ARGUMENT_VALUE(ldapBaseDN.c_str()));
     }
 
     // With current implementation we support only two default LDAP server.
@@ -129,16 +129,16 @@
 
     std::string objPath;
 
-    if (static_cast<ConfigIface::Type>(lDAPType) == ConfigIface::Type::OpenLdap)
+    if (static_cast<ConfigIface::Type>(ldapType) == ConfigIface::Type::OpenLdap)
     {
         openLDAPConfigPtr.reset(nullptr);
         objPath = openLDAPDbusObjectPath;
         openLDAPConfigPtr = std::make_unique<Config>(
             bus, objPath.c_str(), configFilePath.c_str(), tlsCacertFile.c_str(),
-            tlsCertFile.c_str(), secureLDAP, lDAPServerURI, lDAPBindDN,
-            lDAPBaseDN, std::move(lDAPBindDNPassword),
-            static_cast<ConfigIface::SearchScope>(lDAPSearchScope),
-            static_cast<ConfigIface::Type>(lDAPType), false, groupNameAttribute,
+            tlsCertFile.c_str(), secureLDAP, ldapServerURI, ldapBindDN,
+            ldapBaseDN, std::move(ldapBindDNPassword),
+            static_cast<ConfigIface::SearchScope>(ldapSearchScope),
+            static_cast<ConfigIface::Type>(ldapType), false, groupNameAttribute,
             userNameAttribute, *this);
     }
     else
@@ -147,10 +147,10 @@
         objPath = ADDbusObjectPath;
         ADConfigPtr = std::make_unique<Config>(
             bus, objPath.c_str(), configFilePath.c_str(), tlsCacertFile.c_str(),
-            tlsCertFile.c_str(), secureLDAP, lDAPServerURI, lDAPBindDN,
-            lDAPBaseDN, std::move(lDAPBindDNPassword),
-            static_cast<ConfigIface::SearchScope>(lDAPSearchScope),
-            static_cast<ConfigIface::Type>(lDAPType), false, groupNameAttribute,
+            tlsCertFile.c_str(), secureLDAP, ldapServerURI, ldapBindDN,
+            ldapBaseDN, std::move(ldapBindDNPassword),
+            static_cast<ConfigIface::SearchScope>(ldapSearchScope),
+            static_cast<ConfigIface::Type>(ldapType), false, groupNameAttribute,
             userNameAttribute, *this);
     }
     restartService(nscdService);
diff --git a/phosphor-ldap-config/ldap_config_mgr.hpp b/phosphor-ldap-config/ldap_config_mgr.hpp
index f623783..9ba69d4 100644
--- a/phosphor-ldap-config/ldap_config_mgr.hpp
+++ b/phosphor-ldap-config/ldap_config_mgr.hpp
@@ -63,13 +63,13 @@
 
     /** @brief concrete implementation of the pure virtual funtion
             xyz.openbmc_project.User.Ldap.Create.createConfig.
-     *  @param[in] lDAPServerURI - LDAP URI of the server.
-     *  @param[in] lDAPBindDN - distinguished name with which bind to bind
+     *  @param[in] ldapServerURI - LDAP URI of the server.
+     *  @param[in] ldapBindDN - distinguished name with which bind to bind
             to the directory server for lookups.
-     *  @param[in] lDAPBaseDN -  distinguished name to use as search base.
-     *  @param[in] lDAPBindDNPassword - credentials with which to bind.
-     *  @param[in] lDAPSearchScope - the search scope.
-     *  @param[in] lDAPType - Specifies the LDAP server type which can be AD
+     *  @param[in] ldapBaseDN -  distinguished name to use as search base.
+     *  @param[in] ldapBindDNPassword - credentials with which to bind.
+     *  @param[in] ldapSearchScope - the search scope.
+     *  @param[in] ldapType - Specifies the LDAP server type which can be AD
             or openLDAP.
      *  @param[in] groupNameAttribute - Specifies attribute name that contains
      *             the name of the Group in the LDAP server.
@@ -77,11 +77,11 @@
      *             the username in the LDAP server.
      *  @returns the object path of the D-Bus object created.
      */
-    std::string createConfig(std::string lDAPServerURI, std::string lDAPBindDN,
-                             std::string lDAPBaseDN,
-                             std::string lDAPBindDNPassword,
-                             CreateIface::SearchScope lDAPSearchScope,
-                             CreateIface::Type lDAPType,
+    std::string createConfig(std::string ldapServerURI, std::string ldapBindDN,
+                             std::string ldapBaseDN,
+                             std::string ldapBindDNPassword,
+                             CreateIface::SearchScope ldapSearchScope,
+                             CreateIface::Type ldapType,
                              std::string groupNameAttribute,
                              std::string userNameAttribute) override;