diff --git a/ethernet_interface.cpp b/ethernet_interface.cpp
index c24a3e8..39c12cf 100644
--- a/ethernet_interface.cpp
+++ b/ethernet_interface.cpp
@@ -33,10 +33,6 @@
 using namespace phosphor::logging;
 using namespace sdbusplus::xyz::openbmc_project::Common::Error;
 
-constexpr auto MAC_ADDRESS_FORMAT = "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx";
-constexpr size_t SIZE_MAC = 18;
-constexpr size_t SIZE_BUFF = 512;
-
 EthernetInterface::EthernetInterface(sdbusplus::bus::bus& bus,
                                      const std::string& objPath,
                                      bool dhcpEnabled,
@@ -51,7 +47,7 @@
     std::replace(intfName.begin(), intfName.end(), '_', '.');
     interfaceName(intfName);
     EthernetInterfaceIntf::dHCPEnabled(dhcpEnabled);
-    mACAddress(getMACAddress(intfName));
+    MacAddressIntf::mACAddress(getMACAddress(intfName));
 
     // Emit deferred signal.
     if (emitSignal)
@@ -116,7 +112,7 @@
     if (dHCPEnabled())
     {
         log<level::INFO>("DHCP enabled on the interface"),
-                        entry("INTERFACE=%s",interfaceName());
+                        entry("INTERFACE=%s",interfaceName().c_str());
         return;
     }
 
@@ -200,7 +196,7 @@
         const std::string& interfaceName) const
 {
     struct ifreq ifr{};
-    char macAddress[SIZE_MAC] {};
+    char macAddress[mac_address::size] {};
 
     int sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
     if (sock < 0)
@@ -218,7 +214,7 @@
         return macAddress;
     }
 
-    snprintf(macAddress, SIZE_MAC, MAC_ADDRESS_FORMAT,
+    snprintf(macAddress, mac_address::size, mac_address::format,
             ifr.ifr_hwaddr.sa_data[0], ifr.ifr_hwaddr.sa_data[1],
             ifr.ifr_hwaddr.sa_data[2], ifr.ifr_hwaddr.sa_data[3],
             ifr.ifr_hwaddr.sa_data[4], ifr.ifr_hwaddr.sa_data[5]);
@@ -510,5 +506,71 @@
     }
 }
 
+std::string EthernetInterface::mACAddress(std::string value)
+{
+    if (!mac_address::validate(value))
+    {
+        log<level::DEBUG>("MACAddress is not valid.",
+                          entry("MAC=%s", value.c_str()));
+        return MacAddressIntf::mACAddress();
+    }
+
+    // check whether MAC is broadcast mac.
+    auto intMac = mac_address::internal::convertToInt(value);
+
+    if (!(intMac ^ mac_address::broadcastMac))
+    {
+        log<level::DEBUG>("MACAddress is a broadcast mac.",
+                          entry("MAC=%s", value.c_str()));
+        return MacAddressIntf::mACAddress();
+    }
+
+    // Allow the mac to be set if one of the condition is true.
+    //   1) Incoming Mac is of local admin type.
+    //      or
+    //   2) Incoming mac is same as eeprom Mac.
+
+    if (!(intMac & mac_address::localAdminMask))
+    {
+        try
+        {
+            auto inventoryMac = mac_address::getfromInventory(bus);
+            auto intInventoryMac = mac_address::internal::convertToInt(inventoryMac);
+
+            if (intInventoryMac != intMac)
+            {
+                log<level::DEBUG>("Given MAC address is neither a local Admin \
+                                   type nor is same as in inventory");
+                return MacAddressIntf::mACAddress();
+            }
+        }
+        catch(InternalFailure& e)
+        {
+            log<level::ERR>("Exception occured during getting of MAC \
+                               address from Inventory");
+            return  MacAddressIntf::mACAddress();
+        }
+    }
+    auto interface = interfaceName();
+    execute("/sbin/fw_setenv", "fw_setenv", "ethaddr", value.c_str());
+    //TODO: would replace below three calls
+    //      with restarting of systemd-netwokd
+    //      through https://github.com/systemd/systemd/issues/6696
+    execute("/sbin/ip", "ip", "link", "set", "dev", interface.c_str(), "down");
+    execute("/sbin/ip", "ip", "link", "set", "dev", interface.c_str(), "address",
+            value.c_str());
+
+    execute("/sbin/ip", "ip", "link", "set", "dev", interface.c_str(), "up");
+
+    auto mac = MacAddressIntf::mACAddress(std::move(value));
+    //update all the vlan interfaces
+    for(const auto& intf: vlanInterfaces)
+    {
+        intf.second->updateMacAddress();
+    }
+    return mac;
+
+}
+
 }//namespace network
 }//namespace phosphor
diff --git a/ethernet_interface.hpp b/ethernet_interface.hpp
index 5283da4..3a746d2 100644
--- a/ethernet_interface.hpp
+++ b/ethernet_interface.hpp
@@ -27,6 +27,8 @@
 
 using EthernetInterfaceIntf =
     sdbusplus::xyz::openbmc_project::Network::server::EthernetInterface;
+using MacAddressIntf =
+    sdbusplus::xyz::openbmc_project::Network::server::MACAddress;
 
 namespace fs = std::experimental::filesystem;
 
@@ -113,6 +115,12 @@
         /** Set value of DHCPEnabled */
         bool dHCPEnabled(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.
+         */
+        std::string mACAddress(std::string value) override;
+
         /** @brief create Vlan interface.
          *  @param[in] id- VLAN identifier.
          */
@@ -130,6 +138,7 @@
 
         using EthernetInterfaceIntf::dHCPEnabled;
         using EthernetInterfaceIntf::interfaceName;
+        using MacAddressIntf::mACAddress;
 
     protected:
 
diff --git a/util.cpp b/util.cpp
index e5394ba..679b2cb 100644
--- a/util.cpp
+++ b/util.cpp
@@ -364,11 +364,152 @@
     }
     catch (InternalFailure& e)
     {
-       log<level::INFO>("Exception occured during getting of DHCP value");
+        log<level::INFO>("Exception occured during getting of DHCP value");
     }
     return dhcp;
 }
 
+namespace internal
+{
 
+void executeCommandinChildProcess(const char* path, char** args)
+{
+    using namespace std::string_literals;
+    pid_t pid = fork();
+    int status {};
+
+    if (pid == 0)
+    {
+        execv(path, args);
+        auto error = errno;
+        // create the command from var args.
+        std::string command = path + " "s;
+
+        for(int i = 0; args[i]; i++)
+        {
+             command += args[i] + " "s;
+        }
+
+        log<level::ERR>("Couldn't exceute the command",
+                        entry("ERRNO=%d", error),
+                        entry("CMD=%s", command.c_str()));
+        elog<InternalFailure>();
+    }
+    else if (pid < 0)
+    {
+        auto error = errno;
+        log<level::ERR>("Error occurred during fork",
+                        entry("ERRNO=%d", error));
+        elog<InternalFailure>();
+    }
+    else if (pid > 0)
+    {
+        while (waitpid(pid, &status, 0) == -1)
+        {
+            if (errno != EINTR)
+            {   //Error other than EINTR
+                status = -1;
+                break;
+            }
+        }
+
+        if(status < 0)
+        {
+            std::string command = path + " "s;
+            for(int i = 0; args[i]; i++)
+            {
+                command += args[i] + " "s;
+            }
+
+            log<level::ERR>("Unable to execute the command",
+                            entry("CMD=%s", command.c_str(),
+                            entry("STATUS=%d", status)));
+            elog<InternalFailure>();
+        }
+    }
+
+}
+} //namespace internal
+
+namespace mac_address
+{
+
+constexpr auto mapperBus = "xyz.openbmc_project.ObjectMapper";
+constexpr auto mapperObj = "/xyz/openbmc_project/object_mapper";
+constexpr auto mapperIntf = "xyz.openbmc_project.ObjectMapper";
+constexpr auto propIntf = "org.freedesktop.DBus.Properties";
+constexpr auto methodGet = "Get";
+
+using DbusObjectPath = std::string;
+using DbusService = std::string;
+using DbusInterface = std::string;
+using ObjectTree = std::map<DbusObjectPath,
+                            std::map<DbusService, std::vector<DbusInterface>>>;
+
+constexpr auto invBus = "xyz.openbmc_project.Inventory.Manager";
+constexpr auto invNetworkIntf =
+        "xyz.openbmc_project.Inventory.Item.NetworkInterface";
+constexpr auto invRoot = "/xyz/openbmc_project/inventory";
+
+std::string getfromInventory(sdbusplus::bus::bus& bus)
+{
+    std::vector<DbusInterface> interfaces;
+    interfaces.emplace_back(invNetworkIntf);
+
+    auto depth = 0;
+
+    auto mapperCall = bus.new_method_call(mapperBus,
+                                          mapperObj,
+                                          mapperIntf,
+                                          "GetSubTree");
+
+    mapperCall.append(invRoot, depth, interfaces);
+
+    auto mapperReply = bus.call(mapperCall);
+    if (mapperReply.is_method_error())
+    {
+        log<level::ERR>("Error in mapper call");
+        elog<InternalFailure>();
+    }
+
+    ObjectTree objectTree;
+    mapperReply.read(objectTree);
+
+    if (objectTree.empty())
+    {
+        log<level::ERR>("No Object has implemented the interface",
+                        entry("INTERFACE=%s", invNetworkIntf));
+        elog<InternalFailure>();
+    }
+
+    // It is expected that only one object have impelmented this interface.
+
+    auto objPath = objectTree.begin()->first;
+    auto service = objectTree.begin()->second.begin()->first;
+
+    sdbusplus::message::variant<std::string> value;
+
+    auto method = bus.new_method_call(
+                      service.c_str(),
+                      objPath.c_str(),
+                      propIntf,
+                      methodGet);
+
+    method.append(invNetworkIntf, "MACAddress");
+
+    auto reply = bus.call(method);
+    if (reply.is_method_error())
+    {
+         log<level::ERR>("Failed to get MACAddress",
+                        entry("PATH=%s", objPath.c_str()),
+                        entry("INTERFACE=%s", invNetworkIntf));
+        elog<InternalFailure>();
+    }
+
+    reply.read(value);
+    return value.get<std::string>();
+}
+
+}//namespace mac_address
 }//namespace network
 }//namespace phosphor
diff --git a/util.hpp b/util.hpp
index 2015b0c..2d5c3f3 100644
--- a/util.hpp
+++ b/util.hpp
@@ -5,11 +5,60 @@
 #include "config.h"
 #include "types.hpp"
 #include <sdbusplus/bus.hpp>
+#include <regex>
 
 namespace phosphor
 {
 namespace network
 {
+namespace mac_address
+{
+
+constexpr auto regex = "^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$";
+constexpr auto localAdminMask = 0x020000000000;
+constexpr auto broadcastMac = 0xFFFFFFFFFFFF;
+
+constexpr auto format = "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx";
+constexpr size_t size = 18;
+
+/** @brief validate the mac address
+ *  @param[in] value - MAC address.
+ *  @returns true if validate otherwise false.
+ */
+inline bool validate(const std::string& value)
+{
+    std::regex regexToCheck(regex);
+    return std::regex_search(value, regexToCheck);
+}
+
+/** @brief gets the MAC address from the Inventory.
+ *  @param[in] bus - DBUS Bus Object.
+ */
+std::string getfromInventory(sdbusplus::bus::bus& bus);
+
+namespace internal
+{
+/** @brief Converts the given mac address into unsigned 64 bit integer
+ *  @param[in] value - MAC address.
+ *  @returns converted unsigned 64 bit number.
+ */
+inline uint64_t convertToInt(const std::string& value)
+{
+    unsigned char mac[6];
+
+    sscanf(value.c_str(), "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
+           mac + 0, mac + 1, mac + 2, mac + 3, mac + 4, mac + 5);
+    return
+        static_cast<uint64_t>(mac[0]) << 40 |
+        static_cast<uint64_t>(mac[1]) << 32 |
+        static_cast<uint64_t>(mac[2]) << 24 |
+        static_cast<uint64_t>(mac[3]) << 16 |
+        static_cast<uint64_t>(mac[4]) << 8 |
+        static_cast<uint64_t>(mac[5]);
+}
+
+}//namespace internal
+}//namespace mac_address
 
 /* @brief converts the given subnet into prefix notation.
  * @param[in] addressFamily - IP address family(AF_INET/AF_INET6).
@@ -74,6 +123,31 @@
  */
 bool getDHCPValue(const std::string& confDir, const std::string& intf);
 
+namespace internal
+{
+
+/* @brief runs the given command in child process.
+ * @param[in] path - path of the binary file which needs to be execeuted.
+ * @param[in] args - arguments of the command.
+ */
+void executeCommandinChildProcess(const char* path, char** args);
+
+} // namespace internal
+
+/* @brief runs the given command in child process.
+ * @param[in] path -path of the binary file which needs to be execeuted.
+ * @param[in] tArgs - arguments of the command.
+ */
+template<typename... ArgTypes>
+void execute(const char* path, ArgTypes&&... tArgs)
+{
+    using expandType = char*[];
+
+    expandType args = { const_cast<char*>(tArgs)..., nullptr };
+
+    internal::executeCommandinChildProcess(path, args);
+}
+
 } //namespace network
 
 class Descriptor
diff --git a/vlan_interface.cpp b/vlan_interface.cpp
index 8684a73..8f7c5ce 100644
--- a/vlan_interface.cpp
+++ b/vlan_interface.cpp
@@ -33,7 +33,7 @@
 {
     id(vlanID);
     VlanIface::interfaceName(EthernetInterface::interfaceName());
-    mACAddress(parentInterface.mACAddress());
+    MacAddressIntf::mACAddress(parentInterface.mACAddress());
 
     emit_object_added();
 }
diff --git a/vlan_interface.hpp b/vlan_interface.hpp
index d9ea078..3f273b7 100644
--- a/vlan_interface.hpp
+++ b/vlan_interface.hpp
@@ -63,6 +63,12 @@
                    and creates the vlan interface.*/
         void writeDeviceFile();
 
+        /** @brief copy the mac address from the parent interface.*/
+        void updateMacAddress()
+        {
+            MacAddressIntf::mACAddress(parentInterface.mACAddress());
+        }
+
     private:
 
         /** @brief VLAN Identifier. */