diff --git a/src/main/java/org/opencord/dhcpl2relay/DhcpL2Relay.java b/src/main/java/org/opencord/dhcpl2relay/DhcpL2Relay.java
index cdffe4e..a3c8e4b 100755
--- a/src/main/java/org/opencord/dhcpl2relay/DhcpL2Relay.java
+++ b/src/main/java/org/opencord/dhcpl2relay/DhcpL2Relay.java
@@ -17,6 +17,7 @@
 
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
 
 import org.apache.felix.scr.annotations.Activate;
 import org.apache.felix.scr.annotations.Component;
@@ -31,11 +32,15 @@
 import org.onlab.packet.DHCPPacketType;
 import org.onlab.packet.Ethernet;
 import org.onlab.packet.IPv4;
-import org.onlab.packet.Ip4Address;
 import org.onlab.packet.MacAddress;
 import org.onlab.packet.TpPort;
 import org.onlab.packet.UDP;
 import org.onlab.packet.VlanId;
+import org.onosproject.mastership.MastershipEvent;
+import org.onosproject.mastership.MastershipListener;
+import org.onosproject.mastership.MastershipService;
+import org.onosproject.net.device.DeviceEvent;
+import org.onosproject.net.device.DeviceListener;
 import org.opencord.dhcpl2relay.packet.DhcpEthernet;
 import org.opencord.dhcpl2relay.packet.DhcpOption82;
 import org.onlab.util.Tools;
@@ -72,8 +77,8 @@
 import java.nio.ByteBuffer;
 import java.util.Dictionary;
 import java.util.List;
-import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
 
 import static org.onlab.packet.DHCP.DHCPOptionCode.OptionCode_MessageType;
@@ -123,6 +128,9 @@
     @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
     protected DeviceService deviceService;
 
+    @Reference(cardinality = ReferenceCardinality.MANDATORY_UNARY)
+    protected MastershipService mastershipService;
+
     @Property(name = "option82", boolValue = true,
             label = "Add option 82 to relayed packets")
     protected boolean option82 = true;
@@ -130,8 +138,12 @@
     private DhcpRelayPacketProcessor dhcpRelayPacketProcessor =
             new DhcpRelayPacketProcessor();
 
+    private InnerMastershipListener changeListener = new InnerMastershipListener();
+    private InnerDeviceListener deviceListener = new InnerDeviceListener();
 
-    private ConnectPoint dhcpServerConnectPoint = null;
+    // connect points to the DHCP server
+    Set<ConnectPoint> dhcpConnectPoints;
+    private AtomicReference<ConnectPoint> dhcpServerConnectPoint = new AtomicReference<>();
     private MacAddress dhcpConnectMac = MacAddress.BROADCAST;
     private ApplicationId appId;
 
@@ -142,6 +154,9 @@
         componentConfigService.registerProperties(getClass());
 
         cfgService.addListener(cfgListener);
+        mastershipService.addListener(changeListener);
+        deviceService.addListener(deviceListener);
+
         factories.forEach(cfgService::registerConfigFactory);
         //update the dhcp server configuration.
         updateConfig();
@@ -185,23 +200,49 @@
      * @return true if all information we need have been initialized
      */
     private boolean configured() {
-        return dhcpServerConnectPoint != null;
+        return dhcpServerConnectPoint.get() != null;
     }
 
+    /**
+     * Selects a connect point through an available device for which it is the master.
+     */
+    private void selectServerConnectPoint() {
+        synchronized (this) {
+            dhcpServerConnectPoint.set(null);
+            if (dhcpConnectPoints != null) {
+                // find a connect point through a device for which we are master
+                for (ConnectPoint cp: dhcpConnectPoints) {
+                    if (mastershipService.isLocalMaster(cp.deviceId())) {
+                        if (deviceService.isAvailable(cp.deviceId())) {
+                            dhcpServerConnectPoint.set(cp);
+                        }
+                        log.info("DHCP connectPoint selected is {}", cp);
+                        break;
+                    }
+                }
+            }
+
+            log.info("DHCP Server connectPoint is {}", dhcpServerConnectPoint.get());
+
+            if (dhcpServerConnectPoint.get() == null) {
+                log.error("Master of none, can't relay DHCP Message to server");
+            }
+        }
+    }
+
+    /**
+     * Updates the network configuration.
+     */
     private void updateConfig() {
         DhcpL2RelayConfig cfg = cfgService.getConfig(appId, DhcpL2RelayConfig.class);
         if (cfg == null) {
             log.warn("Dhcp Server info not available");
             return;
         }
-        if (dhcpServerConnectPoint == null) {
-            dhcpServerConnectPoint = cfg.getDhcpServerConnectPoint();
-            requestDhcpPackets();
-        } else {
-            cancelDhcpPackets();
-            dhcpServerConnectPoint = cfg.getDhcpServerConnectPoint();
-            requestDhcpPackets();
-        }
+
+        dhcpConnectPoints = Sets.newConcurrentHashSet(cfg.getDhcpServerConnectPoint());
+
+        selectServerConnectPoint();
 
         log.info("dhcp server connect point: " + dhcpServerConnectPoint);
     }
@@ -210,44 +251,39 @@
      * Request DHCP packet in via PacketService.
      */
     private void requestDhcpPackets() {
-        if (dhcpServerConnectPoint != null) {
-            TrafficSelector.Builder selectorServer = DefaultTrafficSelector.builder()
-                    .matchEthType(Ethernet.TYPE_IPV4)
-                    .matchIPProtocol(IPv4.PROTOCOL_UDP)
-                    .matchUdpSrc(TpPort.tpPort(UDP.DHCP_SERVER_PORT));
-            packetService.requestPackets(selectorServer.build(),
-                    PacketPriority.CONTROL, appId,
-                    Optional.of(dhcpServerConnectPoint.deviceId()));
+        TrafficSelector.Builder selectorServer = DefaultTrafficSelector.builder()
+                .matchEthType(Ethernet.TYPE_IPV4)
+                .matchIPProtocol(IPv4.PROTOCOL_UDP)
+                .matchUdpSrc(TpPort.tpPort(UDP.DHCP_SERVER_PORT));
+        packetService.requestPackets(selectorServer.build(),
+                PacketPriority.CONTROL, appId);
 
-            TrafficSelector.Builder selectorClient = DefaultTrafficSelector.builder()
-                    .matchEthType(Ethernet.TYPE_IPV4)
-                    .matchIPProtocol(IPv4.PROTOCOL_UDP)
-                    .matchUdpSrc(TpPort.tpPort(UDP.DHCP_CLIENT_PORT));
-            packetService.requestPackets(selectorClient.build(),
-                    PacketPriority.CONTROL, appId,
-                    Optional.of(dhcpServerConnectPoint.deviceId()));
-        }
+        TrafficSelector.Builder selectorClient = DefaultTrafficSelector.builder()
+                .matchEthType(Ethernet.TYPE_IPV4)
+                .matchIPProtocol(IPv4.PROTOCOL_UDP)
+                .matchUdpSrc(TpPort.tpPort(UDP.DHCP_CLIENT_PORT));
+        packetService.requestPackets(selectorClient.build(),
+                PacketPriority.CONTROL, appId);
+
     }
 
     /**
      * Cancel requested DHCP packets in via packet service.
      */
     private void cancelDhcpPackets() {
-        if (dhcpServerConnectPoint != null) {
-            TrafficSelector.Builder selectorServer = DefaultTrafficSelector.builder()
-                    .matchEthType(Ethernet.TYPE_IPV4)
-                    .matchIPProtocol(IPv4.PROTOCOL_UDP)
-                    .matchUdpSrc(TpPort.tpPort(UDP.DHCP_SERVER_PORT));
-            packetService.cancelPackets(selectorServer.build(),
-                    PacketPriority.CONTROL, appId, Optional.of(dhcpServerConnectPoint.deviceId()));
+        TrafficSelector.Builder selectorServer = DefaultTrafficSelector.builder()
+                .matchEthType(Ethernet.TYPE_IPV4)
+                .matchIPProtocol(IPv4.PROTOCOL_UDP)
+                .matchUdpSrc(TpPort.tpPort(UDP.DHCP_SERVER_PORT));
+        packetService.cancelPackets(selectorServer.build(),
+                PacketPriority.CONTROL, appId);
 
-            TrafficSelector.Builder selectorClient = DefaultTrafficSelector.builder()
-                    .matchEthType(Ethernet.TYPE_IPV4)
-                    .matchIPProtocol(IPv4.PROTOCOL_UDP)
-                    .matchUdpSrc(TpPort.tpPort(UDP.DHCP_CLIENT_PORT));
-            packetService.cancelPackets(selectorClient.build(),
-                    PacketPriority.CONTROL, appId, Optional.of(dhcpServerConnectPoint.deviceId()));
-        }
+        TrafficSelector.Builder selectorClient = DefaultTrafficSelector.builder()
+                .matchEthType(Ethernet.TYPE_IPV4)
+                .matchIPProtocol(IPv4.PROTOCOL_UDP)
+                .matchUdpSrc(TpPort.tpPort(UDP.DHCP_CLIENT_PORT));
+        packetService.cancelPackets(selectorClient.build(),
+                PacketPriority.CONTROL, appId);
     }
 
     private SubscriberAndDeviceInformation getDevice(PacketContext context) {
@@ -263,16 +299,6 @@
 
         return subsService.get(serialNo);
     }
-    private Ip4Address relayAgentIPv4Address(ConnectPoint cp) {
-
-        SubscriberAndDeviceInformation device = getDevice(cp);
-        if (device == null) {
-            log.warn("Device not found for {}", cp);
-            return null;
-        }
-
-        return device.ipAddress();
-    }
 
     private MacAddress relayAgentMacAddress(PacketContext context) {
 
@@ -287,7 +313,11 @@
     }
 
     private String nasPortId(PacketContext context) {
-        Port p = deviceService.getPort(context.inPacket().receivedFrom());
+        return nasPortId(context.inPacket().receivedFrom());
+    }
+
+    private String nasPortId(ConnectPoint cp) {
+        Port p = deviceService.getPort(cp);
         return p.annotations().value(AnnotationKeys.PORT_NAME);
     }
 
@@ -305,6 +335,26 @@
         return sub.cTag();
     }
 
+    private VlanId cTag(ConnectPoint cp) {
+        String portId = nasPortId(cp);
+        SubscriberAndDeviceInformation sub = subsService.get(portId);
+        if (sub == null) {
+            log.warn("Subscriber info not found for {} looking for C-TAG", cp);
+            return VlanId.NONE;
+        }
+        return sub.cTag();
+    }
+
+    private VlanId sTag(ConnectPoint cp) {
+        String portId = nasPortId(cp);
+        SubscriberAndDeviceInformation sub = subsService.get(portId);
+        if (sub == null) {
+            log.warn("Subscriber info not found for {} looking for S-TAG", cp);
+            return VlanId.NONE;
+        }
+        return sub.sTag();
+    }
+
     private VlanId sTag(PacketContext context) {
         SubscriberAndDeviceInformation sub = getSubscriber(context);
         if (sub == null) {
@@ -358,15 +408,15 @@
         //forward the packet to ConnectPoint where the DHCP server is attached.
         private void forwardPacket(DhcpEthernet packet) {
 
-            if (dhcpServerConnectPoint != null) {
+            if (dhcpServerConnectPoint.get() != null) {
                 TrafficTreatment t = DefaultTrafficTreatment.builder()
-                        .setOutput(dhcpServerConnectPoint.port()).build();
+                        .setOutput(dhcpServerConnectPoint.get().port()).build();
                 OutboundPacket o = new DefaultOutboundPacket(
-                        dhcpServerConnectPoint.deviceId(), t,
+                        dhcpServerConnectPoint.get().deviceId(), t,
                         ByteBuffer.wrap(packet.serialize()));
                 if (log.isTraceEnabled()) {
                 log.trace("Relaying packet to dhcp server {} at {}",
-                        packet, dhcpServerConnectPoint);
+                        packet, dhcpServerConnectPoint.get());
                 }
                 packetService.emit(o);
             } else {
@@ -458,11 +508,12 @@
             etherReply.setSourceMacAddress(relayAgentMac);
             etherReply.setDestinationMacAddress(dhcpConnectMac);
 
+            etherReply.setPriorityCode(ethernetPacket.getPriorityCode());
             etherReply.setVlanID(cTag(context).toShort());
             etherReply.setQinQtpid(DhcpEthernet.TYPE_QINQ);
             etherReply.setQinQVid(sTag(context).toShort());
 
-            log.info("Finished processing packet");
+            log.info("Finished processing packet -- sending packet {}", etherReply);
             return etherReply;
         }
 
@@ -475,7 +526,6 @@
             UDP udpPacket = (UDP) ipv4Packet.getPayload();
             DHCP dhcpPayload = (DHCP) udpPacket.getPayload();
 
-
             MacAddress dstMac = valueOf(dhcpPayload.getClientHardwareAddress());
             Set<Host> hosts = hostService.getHostsByMac(dstMac);
             if (hosts == null || hosts.isEmpty()) {
@@ -490,28 +540,15 @@
             }
             Host host = hosts.iterator().next();
 
-            etherReply.setDestinationMacAddress(dstMac);
-            etherReply.setQinQVid(Ethernet.VLAN_UNTAGGED);
-            etherReply.setPriorityCode(ethernetPacket.getPriorityCode());
-            etherReply.setVlanID((short) 0);
+            ConnectPoint subsCp = new ConnectPoint(host.location().deviceId(),
+                    host.location().port());
 
             // we leave the srcMac from the original packet
+            etherReply.setDestinationMacAddress(dstMac);
+            etherReply.setQinQVid(sTag(subsCp).toShort());
+            etherReply.setPriorityCode(ethernetPacket.getPriorityCode());
+            etherReply.setVlanID((cTag(subsCp).toShort()));
 
-            // figure out the relay agent IP corresponding to the original request
-            Ip4Address relayAgentIP = relayAgentIPv4Address(
-                    new ConnectPoint(host.location().deviceId(),
-                            host.location().port()));
-            if (relayAgentIP == null) {
-                log.warn("Cannot determine relay agent Ipv4 addr for host {}. "
-                                + "Aborting relay for dhcp packet from server {}",
-                        host, ethernetPacket);
-                return null;
-            }
-
-            ipv4Packet.setSourceAddress(relayAgentIP.toInt());
-            ipv4Packet.setDestinationAddress(dhcpPayload.getYourIPAddress());
-
-            udpPacket.setDestinationPort(UDP.DHCP_CLIENT_PORT);
             if (option82) {
                 udpPacket.setPayload(removeOption82(dhcpPayload));
             } else {
@@ -561,6 +598,7 @@
 
         options.add(options.size() - 1, option);
         dhcpPacket.setOptions(options);
+
         return dhcpPacket;
 
     }
@@ -590,6 +628,58 @@
         }
     }
 
+    /**
+     * Handles Mastership changes for the devices which connect
+     * to the DHCP server.
+     */
+    private class InnerMastershipListener implements MastershipListener {
+        @Override
+        public void event(MastershipEvent event) {
+            if (dhcpServerConnectPoint.get() != null &&
+                    dhcpServerConnectPoint.get().deviceId().
+                            equals(event.subject())) {
+                log.trace("Mastership Event recevived for {}", event.subject());
+                // mastership of the device for our connect point has changed
+                // reselect
+                selectServerConnectPoint();
+            }
+        }
+    }
 
-
+    /**
+     * Handles Device status change for the devices which connect
+     * to the DHCP server.
+     */
+    private class InnerDeviceListener implements DeviceListener {
+        @Override
+        public void event(DeviceEvent event) {
+            log.trace("Device Event recevived for {} event {}", event.subject(), event.type());
+            if (dhcpServerConnectPoint.get() == null) {
+                switch (event.type()) {
+                    case DEVICE_ADDED:
+                    case DEVICE_AVAILABILITY_CHANGED:
+                        // some device is available check if we can get one
+                        selectServerConnectPoint();
+                        break;
+                    default:
+                        break;
+                }
+                return;
+            }
+            if (dhcpServerConnectPoint.get().deviceId().
+                    equals(event.subject().id())) {
+                switch (event.type()) {
+                    case DEVICE_AVAILABILITY_CHANGED:
+                    case DEVICE_REMOVED:
+                    case DEVICE_SUSPENDED:
+                        // state of our device has changed, check if we need
+                        // to re-select
+                        selectServerConnectPoint();
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+    }
 }
diff --git a/src/main/java/org/opencord/dhcpl2relay/DhcpL2RelayConfig.java b/src/main/java/org/opencord/dhcpl2relay/DhcpL2RelayConfig.java
index c263149..eb60c7f 100755
--- a/src/main/java/org/opencord/dhcpl2relay/DhcpL2RelayConfig.java
+++ b/src/main/java/org/opencord/dhcpl2relay/DhcpL2RelayConfig.java
@@ -15,32 +15,59 @@
  */
 package org.opencord.dhcpl2relay;
 
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+
+import com.google.common.collect.ImmutableSet;
+
 import org.onosproject.core.ApplicationId;
 import org.onosproject.net.ConnectPoint;
 import org.onosproject.net.config.Config;
 
-import static org.onosproject.net.config.Config.FieldPresence.MANDATORY;
+import java.util.HashSet;
+import java.util.Set;
+
 
 /**
  * DHCP Relay Config class.
  */
 public class DhcpL2RelayConfig extends Config<ApplicationId> {
 
-    private static final String DHCP_CONNECT_POINT = "dhcpserverConnectPoint";
+    private static final String DHCP_CONNECT_POINTS = "dhcpServerConnectPoints";
 
     @Override
     public boolean isValid() {
 
-        return hasOnlyFields(DHCP_CONNECT_POINT) &&
-                isConnectPoint(DHCP_CONNECT_POINT, MANDATORY);
+        return hasOnlyFields(DHCP_CONNECT_POINTS);
     }
 
     /**
-     * Returns the dhcp server connect point.
+     * Returns the dhcp server connect points.
      *
-     * @return dhcp server connect point
+     * @return dhcp server connect points
      */
-    public ConnectPoint getDhcpServerConnectPoint() {
-        return ConnectPoint.deviceConnectPoint(object.path(DHCP_CONNECT_POINT).asText());
+    public Set<ConnectPoint> getDhcpServerConnectPoint() {
+        if (object == null) {
+            return new HashSet<ConnectPoint>();
+        }
+
+        if (!object.has(DHCP_CONNECT_POINTS)) {
+            return ImmutableSet.of();
+        }
+
+        ImmutableSet.Builder<ConnectPoint> builder = ImmutableSet.builder();
+        ArrayNode arrayNode = (ArrayNode) object.path(DHCP_CONNECT_POINTS);
+        for (JsonNode jsonNode : arrayNode) {
+            String portName = jsonNode.asText(null);
+            if (portName == null) {
+                return null;
+            }
+            try {
+                builder.add(ConnectPoint.deviceConnectPoint(portName));
+            } catch (IllegalArgumentException e) {
+                return null;
+            }
+        }
+        return builder.build();
     }
 }
diff --git a/src/main/java/org/opencord/dhcpl2relay/packet/DhcpOption82.java b/src/main/java/org/opencord/dhcpl2relay/packet/DhcpOption82.java
index b673f94..7f39258 100644
--- a/src/main/java/org/opencord/dhcpl2relay/packet/DhcpOption82.java
+++ b/src/main/java/org/opencord/dhcpl2relay/packet/DhcpOption82.java
@@ -45,7 +45,7 @@
 
     /**
      * sets AgentRemoteId.
-     * @param value
+     * @param value   Value to be set
      */
     public void setAgentRemoteId(String value) {
         this.agentRemoteId = value;