From f1db17ff093935d68179ba330d80d02b2124a81f Mon Sep 17 00:00:00 2001
From: kellyyeh <kellyyeh@microsoft.com>
Date: Thu, 22 Jul 2021 20:26:31 +0000
Subject: [PATCH 01/16] Added DHCPv6 Relay

---
 src/dhcp6relay/.gitignore              |   5 +
 src/dhcp6relay/Makefile                |  42 ++
 src/dhcp6relay/debian/changelog        |   5 +
 src/dhcp6relay/debian/compat           |   1 +
 src/dhcp6relay/debian/control          |  15 +
 src/dhcp6relay/debian/rules            |   7 +
 src/dhcp6relay/src/configInterface.cpp | 137 +++++
 src/dhcp6relay/src/configInterface.h   |  16 +
 src/dhcp6relay/src/main.cpp            |  18 +
 src/dhcp6relay/src/relay.cpp           | 665 +++++++++++++++++++++++++
 src/dhcp6relay/src/relay.h             | 175 +++++++
 src/dhcp6relay/src/subdir.mk           |  23 +
 12 files changed, 1109 insertions(+)
 create mode 100644 src/dhcp6relay/.gitignore
 create mode 100644 src/dhcp6relay/Makefile
 create mode 100644 src/dhcp6relay/debian/changelog
 create mode 100644 src/dhcp6relay/debian/compat
 create mode 100644 src/dhcp6relay/debian/control
 create mode 100755 src/dhcp6relay/debian/rules
 create mode 100644 src/dhcp6relay/src/configInterface.cpp
 create mode 100644 src/dhcp6relay/src/configInterface.h
 create mode 100644 src/dhcp6relay/src/main.cpp
 create mode 100644 src/dhcp6relay/src/relay.cpp
 create mode 100644 src/dhcp6relay/src/relay.h
 create mode 100644 src/dhcp6relay/src/subdir.mk

diff --git a/src/dhcp6relay/.gitignore b/src/dhcp6relay/.gitignore
new file mode 100644
index 000000000000..9d09ae6b3f1a
--- /dev/null
+++ b/src/dhcp6relay/.gitignore
@@ -0,0 +1,5 @@
+debian/*
+!debian/changelog
+!debian/compat
+!debian/control
+!debian/rules
diff --git a/src/dhcp6relay/Makefile b/src/dhcp6relay/Makefile
new file mode 100644
index 000000000000..afb76932065c
--- /dev/null
+++ b/src/dhcp6relay/Makefile
@@ -0,0 +1,42 @@
+RM := rm -rf
+DHCP6RELAY_TARGET := dhcp6relay
+CP := cp
+MKDIR := mkdir
+CC := g++
+MV := mv
+LIBS := -levent -lhiredis -lswsscommon -pthread -lboost_thread -lboost_system -I $(PWD)/../sonic-swss-common/common
+CFLAGS  = -g -Wall
+PWD := $(shell pwd)
+
+ifneq ($(MAKECMDGOALS),clean)
+ifneq ($(strip $(C_DEPS)),)
+-include $(C_DEPS) $(OBJS)
+endif
+endif
+
+-include src/subdir.mk
+ 
+all: sonic-dhcp6relay
+
+sonic-dhcp6relay: $(OBJS)
+	@echo 'Building target: $@'
+	@echo 'Invoking: G++ Linker'
+	$(CC) -o $(DHCP6RELAY_TARGET) $(OBJS) $(LIBS) 
+	@echo 'Finished building target: $@'
+	@echo ' '
+
+install:
+	$(MKDIR) -p $(DESTDIR)/usr/sbin
+	$(MV) $(DHCP6RELAY_TARGET) $(DESTDIR)/usr/sbin
+
+deinstall:
+	$(RM) $(DESTDIR)/usr/sbin/$(DHCP6RELAY_TARGET)
+	$(RM) -rf $(DESTDIR)/usr/sbin
+
+clean:
+	-$(RM) $(EXECUTABLES) $(C_DEPS) $(OBJS) $(DHCP6RELAY_TARGET)
+	-@echo ' '
+
+.PHONY: all clean dependents
+
+
diff --git a/src/dhcp6relay/debian/changelog b/src/dhcp6relay/debian/changelog
new file mode 100644
index 000000000000..1a1c6482d640
--- /dev/null
+++ b/src/dhcp6relay/debian/changelog
@@ -0,0 +1,5 @@
+sonic-dhcp6relay (1.0.0-0) UNRELEASED; urgency=medium
+
+  * Initial release.
+
+ -- Kelly Yeh <kellyyeh@microsoft.com>  Mon, 09 Dec 2019 12:00:00 -0700
diff --git a/src/dhcp6relay/debian/compat b/src/dhcp6relay/debian/compat
new file mode 100644
index 000000000000..ec635144f600
--- /dev/null
+++ b/src/dhcp6relay/debian/compat
@@ -0,0 +1 @@
+9
diff --git a/src/dhcp6relay/debian/control b/src/dhcp6relay/debian/control
new file mode 100644
index 000000000000..1e383a8515bf
--- /dev/null
+++ b/src/dhcp6relay/debian/control
@@ -0,0 +1,15 @@
+Source: sonic-dhcp6relay
+Section: devel
+Priority: optional
+Maintainer: Kelly Yeh <kellyyeh@microsoft.com>
+Build-Depends: debhelper (>= 8.0.0),
+               dh-systemd
+Standards-Version: 3.9.3
+Homepage: https://github.com/Azure/sonic-buildimage
+XS-Go-Import-Path: github.com/Azure/sonic-buildimage
+
+Package: sonic-dhcp6relay
+Architecture: any
+Built-Using: ${misc:Built-Using}
+Depends: libevent-2.1-6
+Description: SONiC DHCPv6 Relay
\ No newline at end of file
diff --git a/src/dhcp6relay/debian/rules b/src/dhcp6relay/debian/rules
new file mode 100755
index 000000000000..00c628b6625f
--- /dev/null
+++ b/src/dhcp6relay/debian/rules
@@ -0,0 +1,7 @@
+#!/usr/bin/make -f
+
+DEB_CFLAGS_APPEND=-std=gnu11
+export DEB_CFLAGS_APPEND
+
+%:
+	dh $@ --parallel
diff --git a/src/dhcp6relay/src/configInterface.cpp b/src/dhcp6relay/src/configInterface.cpp
new file mode 100644
index 000000000000..315fedd925c9
--- /dev/null
+++ b/src/dhcp6relay/src/configInterface.cpp
@@ -0,0 +1,137 @@
+#include <sstream>
+#include <syslog.h>
+#include <algorithm>
+#include "configInterface.h"
+
+constexpr auto DEFAULT_TIMEOUT_MSEC = 1000;
+
+bool mPollSwssNotifcation = true;
+std::shared_ptr<boost::thread> mSwssThreadPtr;
+
+//
+// ---> initialize();
+//
+// initialize DB tables and start SWSS listening thread
+//
+void initialize_swss(arg_config *context)
+{
+    try {
+        mSwssThreadPtr = std::make_shared<boost::thread> (&handleSwssNotification, context);
+    }
+    catch (const std::bad_alloc &e) {
+        syslog(LOG_ERR, "Failed allocate memory. Exception details: %s", e.what());
+    }
+}
+
+//
+// ---> deinitialize();
+//
+// deinitialize DB interface and join SWSS listening thread
+//
+void deinitialize_swss()
+{
+    stopSwssNotificationPoll();
+    mSwssThreadPtr->interrupt();
+}
+
+/**
+ * @code                void handleSwssNotification(arg_config *context)
+ * 
+ * @brief               main thread for handling SWSS notification
+ *
+ * @param context       argument config that contains strings of server and option
+ *
+ * @return              none
+ */
+void handleSwssNotification(arg_config *context)
+{
+    std::shared_ptr<swss::DBConnector> configDbPtr = std::make_shared<swss::DBConnector> ("CONFIG_DB", 0);
+    swss::SubscriberStateTable ipHelpersTable(configDbPtr.get(), "DHCP");
+
+    swss::Select swssSelect;
+    swssSelect.addSelectable(&ipHelpersTable);
+    while (mPollSwssNotifcation) {
+        swss::Selectable *selectable;
+        int ret = swssSelect.select(&selectable, DEFAULT_TIMEOUT_MSEC);
+        if (ret == swss::Select::ERROR) {
+            syslog(LOG_WARNING, "Select: returned ERROR");
+            continue;
+        } else if (ret == swss::Select::TIMEOUT) {
+            continue;
+        } 
+        if (selectable == static_cast<swss::Selectable *> (&ipHelpersTable)) {
+            handleRelayNotification(ipHelpersTable, context);
+        }
+    } 
+}
+
+/**
+ * @code                    void handleRelayNotification(swss::SubscriberStateTable &ipHelpersTable, arg_config context)
+ * 
+ * @brief                   handles DHCPv6 relay configuration change notification
+ *
+ * @param ipHelpersTable    DHCP table
+ * @param context           argument config that contains strings of server and option
+ *
+ * @return                  none
+ */
+void handleRelayNotification(swss::SubscriberStateTable &ipHelpersTable, arg_config *context)
+{
+    std::deque<swss::KeyOpFieldsValuesTuple> entries;
+
+    ipHelpersTable.pops(entries);
+    processRelayNotification(entries, context);
+}
+
+/**
+ * @code                    void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, arg_config context)
+ * 
+ * @brief                   process DHCPv6 relay servers and options configuration change notification
+ *
+ * @param entries           queue of std::tuple<std::string, std::string, std::vector<FieldValueTuple>> entries in DHCP table
+ * @param context           argument config that contains strings of server and option
+ *
+ * @return                  none
+ */
+void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, arg_config *context)
+{
+    std::vector<std::string> servers;
+
+    for (auto &entry: entries) {
+        std::string vlan = kfvKey(entry);
+        std::vector<swss::FieldValueTuple> fieldValues = kfvFieldsValues(entry);
+
+        for (auto &fieldValue: fieldValues) {
+            std::string f = fvField(fieldValue);
+            std::string v = fvValue(fieldValue);
+            if(f == "dhcpv6_servers") {
+                std::stringstream ss(v);
+                while (ss.good()) {
+                    std::string substr;
+                    getline(ss, substr, ',');
+                    context->servers.push_back(substr);
+                }
+            }
+            if(f == "options") {
+                std::stringstream ss(v);
+                while (ss.good()) {
+                    std::string substr;
+                    getline(ss, substr, ',');
+                    if(substr == "79")
+                        context->is_option_79 = true;
+                }
+            }
+        }
+    }
+}
+
+/**
+*@code      stopSwssNotificationPoll
+*
+*@brief     stop SWSS listening thread
+*
+*@return    none
+*/
+void stopSwssNotificationPoll() {
+    mPollSwssNotifcation = false;
+};
\ No newline at end of file
diff --git a/src/dhcp6relay/src/configInterface.h b/src/dhcp6relay/src/configInterface.h
new file mode 100644
index 000000000000..4008821e6061
--- /dev/null
+++ b/src/dhcp6relay/src/configInterface.h
@@ -0,0 +1,16 @@
+#include <boost/thread.hpp>
+#include "subscriberstatetable.h"
+#include "select.h"
+#include "relay.h"
+
+void initialize_swss(arg_config *context);
+
+void deinitialize_swss();
+
+void handleSwssNotification(arg_config *context);
+
+void handleRelayNotification(swss::SubscriberStateTable &configMuxTable, arg_config *context);
+
+void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, arg_config *context);
+
+void stopSwssNotificationPoll();
\ No newline at end of file
diff --git a/src/dhcp6relay/src/main.cpp b/src/dhcp6relay/src/main.cpp
new file mode 100644
index 000000000000..77135e5507f8
--- /dev/null
+++ b/src/dhcp6relay/src/main.cpp
@@ -0,0 +1,18 @@
+#include <stdlib.h>
+#include "configInterface.h"
+
+int main(int argc, char *argv[]) {
+    try {
+        auto parser = ArgumentParser();
+        parser.parse_args(argc, argv);
+        auto context = parser.get_arg();
+        initialize_swss(&context);
+        loop_relay(&context);
+    }
+    catch (std::exception &e)
+    {
+        printf("Usage: -i <interface> -o <option>\n");
+        return 1;
+    }
+    return 0;
+}
\ No newline at end of file
diff --git a/src/dhcp6relay/src/relay.cpp b/src/dhcp6relay/src/relay.cpp
new file mode 100644
index 000000000000..5c347758a4ee
--- /dev/null
+++ b/src/dhcp6relay/src/relay.cpp
@@ -0,0 +1,665 @@
+#include <getopt.h>
+#include <errno.h>
+#include <unistd.h>
+#include <event.h>
+#include <sstream>
+#include <event2/event.h>
+#include <event2/bufferevent.h>
+#include <syslog.h>
+#include <signal.h>
+
+#include "configdb.h"
+#include "sonicv2connector.h"
+#include "dbconnector.h" 
+#include "configInterface.h"
+
+
+struct event *listen_event;
+struct event_base *base;
+struct event *ev_sigint;
+struct event *ev_sigterm;
+
+bool serverListener = true;
+std::shared_ptr<boost::thread> serverPtr;
+
+/**
+ * @code        parse_args(int argc, char *argv[]);
+ *
+ * @brief       parse through argument and define the interface to bind to and to turn off option 79. 
+ *              read from config database and set the ipv6 helper addresses.
+ *
+ * @return      none
+ */
+void ArgumentParser::parse_args(int argc, char *argv[]) {
+    int opt;
+    std::string option;
+    bool is_interface_set = false;
+    m_config.is_option_79 = false; 
+    
+    while ((opt = getopt(argc, argv, "i:o:")) != -1) {
+        switch (opt) {
+            case 'i':
+                if (is_interface_set) {
+                        throw ArgumentException("Interface is already set to : " + this->m_config.interface);
+                }
+                else {
+                    is_interface_set = true;
+                    this->m_config.interface = std::string(optarg);
+                    config_interface = this->m_config.interface;
+                }
+                break;
+            case 'o':
+                if(std::string(optarg) == "79")
+                    m_config.is_option_79 = true;
+            case '?':
+                option = std::string(argv[optind - 1]);
+                throw ArgumentException("Option " + option + " not recognized");
+            default:
+                abort();
+        }
+    }
+
+    if (!is_interface_set) {
+        throw ArgumentException("Must specify an interface");
+    }
+}
+
+arg_config ArgumentParser::get_arg() {
+    return this->m_config;
+}
+
+bool is_addr_gua(in6_addr addr) {
+
+    auto masked = addr.__in6_u.__u6_addr8[0] & 0xe0;
+    return (masked ^ 0x20) == 0x00;
+}
+
+bool is_addr_link_local(in6_addr addr)  {
+    auto masked = ntohs(addr.__in6_u.__u6_addr16[0]) & 0xffc0;
+    return (masked ^ 0xfe80) == 0x0000;
+}
+
+const struct ether_header *parse_ether_frame(const uint8_t *buffer, const uint8_t **out_end) {
+    (*out_end) = buffer + sizeof(struct ether_header);
+    return (const struct ether_header *)buffer;
+}
+
+const struct ip6_hdr *parse_ip6_hdr(const uint8_t *buffer, const uint8_t **out_end) {
+    (*out_end) = buffer + sizeof(struct ip6_hdr);
+    return (struct ip6_hdr *)buffer;
+}
+
+const struct udphdr *parse_udp(const uint8_t *buffer, const uint8_t **out_end) {
+    (*out_end) = buffer + sizeof(struct udphdr);
+    return (const struct udphdr *)buffer;
+}
+
+const struct dhcpv6_msg *parse_dhcpv6_hdr(const uint8_t *buffer) {
+    return (const struct dhcpv6_msg *)buffer;
+}
+
+const struct dhcpv6_relay_msg *parse_dhcpv6_relay(const uint8_t *buffer) {
+    return (const struct dhcpv6_relay_msg *)buffer;
+}
+
+const struct dhcpv6_option *parse_dhcpv6_opt(const uint8_t *buffer, const uint8_t **out_end) {
+    uint32_t size = 4; // option-code + option-len
+    size += ntohs(*(uint16_t *)(buffer + 2));
+    (*out_end) = buffer + size;
+
+    return (const struct dhcpv6_option *)buffer;
+}
+
+void send_udp(int sock, uint8_t *buffer, struct sockaddr_in6 target, uint32_t n) {    
+    if(sendto(sock, buffer, n, 0, (const struct sockaddr *)&target, sizeof(target)) == -1)
+        syslog(LOG_ERR, "sendto: Failed to send to target address\n");
+}
+
+/**
+ * @code                relay_forward(uint8_t *buffer, const struct dhcpv6_msg *msg, uint16_t msg_length);
+ *
+ * @brief               embed the DHCPv6 message received into DHCPv6 relay forward message
+ *
+ * @param buffer        pointer to buffer
+ * @param msg           pointer to parsed DHCPv6 message
+ * @param msg_length    length of DHCPv6 message
+ *
+ * @return              none
+ */
+void relay_forward(uint8_t *buffer, const struct dhcpv6_msg *msg, uint16_t msg_length) {
+    struct dhcpv6_option option;
+    option.option_code = htons(OPTION_RELAY_MSG);
+    option.option_length = htons(msg_length);
+    memcpy(buffer, &option, sizeof(struct dhcpv6_option));
+    memcpy(buffer + sizeof(struct dhcpv6_option), msg, msg_length);
+}
+
+/**
+ * @code                sock_open(int ifindex, const struct sock_fprog *fprog);
+ *
+ * @brief               prepare L2 socket to attach to "udp and port 547" filter 
+ *
+ * @param ifindex       interface index
+ * @param fprog         bpf filter "udp and port 547"
+ *
+ * @return              socket descriptor
+ */
+int sock_open(int ifindex, const struct sock_fprog *fprog)
+{
+	if (!ifindex) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	int s = socket(AF_PACKET, SOCK_RAW, 0);
+	if (s == -1) {
+		syslog(LOG_ERR, "socket: Failed to create socket\n");
+		return -1;
+	}
+
+	struct sockaddr_ll sll = {
+	    .sll_family = AF_PACKET,
+	    .sll_protocol = htons(ETH_P_IPV6),
+	    .sll_ifindex = ifindex
+	};
+
+	if (bind(s, (struct sockaddr *)&sll, sizeof sll) == -1) {
+		syslog(LOG_ERR, "bind: Failed to bind to specified interface\n");
+		(void) close(s);
+	    return -1;
+	}
+
+	struct packet_mreq mreq = {
+	    .mr_ifindex = ifindex,
+	    .mr_type = PACKET_MR_PROMISC
+	};
+
+	if (setsockopt(s, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mreq, sizeof mreq) == -1)
+	{
+		syslog(LOG_ERR, "setsockopt: Failed to send PACkET_MR_PROMISC\n");
+		(void) close(s);
+	    return -1;
+	}
+
+	if (fprog && setsockopt(s, SOL_SOCKET, SO_ATTACH_FILTER, fprog, sizeof *fprog) == -1)
+	{
+		syslog(LOG_ERR, "setsockopt: Failed to attach filter\n");
+		(void) close(s);
+	    return -1;
+	}
+
+	return s;
+}
+
+/**
+ * @code                        prepare_relay_config(relay_config *interface_config, int fd, const arg_config *context);
+ * 
+ * @brief                       prepare for specified relay interface config: server and link address
+ *
+ * @param interface_config      pointer to relay config to be prepared
+ * @param local_sock            L3 socket used for relaying messages
+ * @param filter                socket attached with filter
+ * @param config                argument config that contains strings of server and interface addresses
+ *
+ * @return                      none
+ */
+void prepare_relay_config(relay_config *interface_config, int local_sock, int filter, const arg_config *context) {
+    interface_config->local_sock = local_sock; 
+    interface_config->filter = filter; 
+    interface_config->is_option_79 = context->is_option_79; 
+
+    for(auto server: context->servers) {
+        sockaddr_in6 tmp;
+        if(inet_pton(AF_INET6, server.c_str(), &tmp.sin6_addr) != 1)
+        {
+            syslog(LOG_WARNING, "inet_pton: Failed to convert IPv6 address\n");
+        }
+        tmp.sin6_family = AF_INET6;
+        tmp.sin6_flowinfo = 0;
+        tmp.sin6_port = htons(547);
+        tmp.sin6_scope_id = 0; 
+        interface_config->servers.push_back(tmp);
+    }
+
+    sockaddr_in6 *non_link_local = NULL;    
+    sockaddr_in6 *link_local = NULL;
+    
+    struct ifaddrs *ifa, *ifa_tmp;
+    char addr[INET6_ADDRSTRLEN];
+    addr[0] = 0;
+
+    if (getifaddrs(&ifa) == -1) {
+		    syslog(LOG_WARNING, "getifaddrs: Unable to get network interfaces\n");
+            exit(1);
+	}
+
+    ifa_tmp = ifa;
+	while (ifa_tmp) {
+		if ((ifa_tmp->ifa_addr) && (ifa_tmp->ifa_addr->sa_family == AF_INET6)) {
+            struct sockaddr_in6 *in6 = (struct sockaddr_in6*) ifa_tmp->ifa_addr;
+            inet_ntop(AF_INET6, &in6->sin6_addr, addr, sizeof(addr));
+            if((strcmp(ifa_tmp->ifa_name, interface_config->interface.c_str()) == 0) && is_addr_gua(in6->sin6_addr)) {    
+                non_link_local = in6;
+            }
+            if((strcmp(ifa_tmp->ifa_name, interface_config->interface.c_str()) == 0) && is_addr_link_local(in6->sin6_addr)) {    
+                link_local = in6;
+            }   
+	    }
+	    ifa_tmp = ifa_tmp->ifa_next;
+	}
+	freeifaddrs(ifa);
+
+    if (non_link_local != NULL) {
+        interface_config->link_address = *non_link_local;
+    }
+    else {
+        interface_config->link_address = *link_local;
+    }
+}
+
+/**
+ * @code                prepare_socket(int *local_sock, arg_config *context);
+ * 
+ * @brief               prepare L3 socket for sending
+ *
+ * @param local_sock    pointer to socket to be prepared
+ * @param context       argument config that contains strings of server and interface addresses
+ *
+ * @return              none
+ */
+void prepare_socket(int *local_sock, arg_config *context) {
+    sockaddr_in6 addr;
+    memset(&addr, 0, sizeof(addr));
+    addr.sin6_family = AF_INET6;
+    addr.sin6_addr = in6addr_any;
+    /*TO FIX AFTER TESTING IPV6 ADDR AUTO SELECTION. PLEASE IGNORE THE COMMENTED AREA*/
+    /*struct ifaddrs *ifa, *ifa_tmp;
+     char tmp[INET6_ADDRSTRLEN];
+    tmp[0] = 0;
+
+    if (getifaddrs(&ifa) == -1) {
+            syslog(LOG_WARNING, "getifaddrs: Unable to get network interfaces\n");
+            exit(1);
+    } 
+
+    ifa_tmp = ifa;
+    while (ifa_tmp) {
+            if ((ifa_tmp->ifa_addr) && (ifa_tmp->ifa_addr->sa_family == AF_INET6)) {                  
+                struct sockaddr_in6 *in6 = (struct sockaddr_in6*) ifa_tmp->ifa_addr;
+                inet_ntop(AF_INET6, &in6->sin6_addr, tmp, sizeof(tmp));
+                if(strcmp(ifa_tmp->ifa_name, context->interface.c_str()) == 0 && (is_addr_gua(in6->sin6_addr))) {
+                    inet_pton(AF_INET6, tmp, &addr.sin6_addr);
+                }
+                else {
+                    syslog(LOG_ERR, "inet_pton: interface global address not configured\n");
+                    sleep(10);
+                    continue;
+                }
+            }
+            ifa_tmp = ifa_tmp->ifa_next;
+    }
+    freeifaddrs(ifa);   */
+
+    if ((*local_sock = socket(AF_INET6, SOCK_DGRAM, 0)) == -1) {
+        syslog(LOG_ERR, "scoket: Failed to create socket\n");
+    }
+
+    addr.sin6_port = htons(547);
+    
+    if (bind(*local_sock, (sockaddr *)&addr, sizeof(addr)) == -1) {
+        syslog(LOG_ERR, "bind: Failed to bind to socket\n");
+    }    
+}
+
+
+/**
+ * @code                 relay_client(int sock, const uint8_t *msg, int32_t len, ip6_hdr *ip_hdr, const ether_header *ether_hdr, relay_config *config);
+ * 
+ * @brief                construct relay-forward message
+ *
+ * @param sock           L3 socket for sending data to servers
+ * @param msg            pointer to dhcpv6 message header position
+ * @param len            size of data received
+ * @param ip_hdr         pointer to IPv6 header
+ * @param ether_hdr      pointer to Ethernet header
+ * @param config         pointer to the relay interface config
+ *
+ * @return none
+ */
+void relay_client(int sock, const uint8_t *msg, int32_t len, const ip6_hdr *ip_hdr, const ether_header *ether_hdr, relay_config *config) {    
+    uint8_t buffer[4096];
+    auto current_buffer_position = buffer;
+    dhcpv6_relay_msg new_message;
+    new_message.msg_type = RELAY_FORW;
+    memcpy(&new_message.peer_address, &ip_hdr->ip6_src, sizeof(in6_addr));
+    new_message.hop_count = 0;
+
+    memcpy(&new_message.link_address, &config->link_address.sin6_addr, sizeof(in6_addr));
+    memcpy(current_buffer_position, &new_message, sizeof(dhcpv6_relay_msg));
+    current_buffer_position += sizeof(dhcpv6_relay_msg);
+
+
+    auto dhcp_message_length = len;
+    relay_forward(current_buffer_position, parse_dhcpv6_hdr(msg), dhcp_message_length);
+    current_buffer_position += dhcp_message_length + sizeof(dhcpv6_option);
+
+    if(config->is_option_79) {
+        linklayer_addr_option option79;
+        option79.link_layer_type = htons(1);
+        option79.option_code = htons(OPTION_CLIENT_LINKLAYER_ADDR);
+        option79.option_length = htons(2 + 6); // link_layer_type field + address
+        
+        memcpy(current_buffer_position, &option79, sizeof(linklayer_addr_option));
+        current_buffer_position += sizeof(linklayer_addr_option);
+    }
+
+    memcpy(current_buffer_position, &ether_hdr->ether_shost, sizeof(ether_hdr->ether_shost));
+    current_buffer_position += sizeof(ether_hdr->ether_shost);
+
+    for(auto server: config->servers) {
+        send_udp(sock, buffer, server, current_buffer_position - buffer);
+    }
+}
+
+/**
+ * @code                relay_relay_reply(int sock, const uint8_t *msg, int32_t len, relay_config *configs);
+ * 
+ * @brief               relay and unwrap a relay-reply message
+ *
+ * @param sock          L3 socket for sending data to servers
+ * @param msg           pointer to dhcpv6 message header position
+ * @param len           size of data received
+ * @param config        relay interface config
+ *
+ * @return              none
+ */
+ void relay_relay_reply(int sock, const uint8_t *msg, int32_t len, relay_config *configs) {
+    uint8_t buffer[4096];
+    char ifname[configs->interface.size()];
+    struct sockaddr_in6 target_addr;
+    auto current_buffer_position = buffer;
+    auto current_position = msg;
+    const uint8_t *tmp = NULL;
+    auto dhcp_relay_header = parse_dhcpv6_relay(msg);
+    current_position += sizeof(struct dhcpv6_relay_msg);
+    
+    while ((current_position - msg) != len) {
+        auto option = parse_dhcpv6_opt(current_position, &tmp);
+        current_position = tmp;
+        switch (ntohs(option->option_code)) {
+            case OPTION_RELAY_MSG:
+                memcpy(current_buffer_position, ((uint8_t *)option) + sizeof(struct dhcpv6_option), ntohs(option->option_length));
+                current_buffer_position += ntohs(option->option_length);
+                break;
+            default:
+                break;
+        }
+    }
+
+    strcpy(ifname, configs->interface.c_str());
+    memcpy(&target_addr.sin6_addr, &dhcp_relay_header->peer_address, sizeof(struct in6_addr));
+    target_addr.sin6_family = AF_INET6;
+    target_addr.sin6_flowinfo = 0;
+    target_addr.sin6_port = htons(546);
+    target_addr.sin6_scope_id = if_nametoindex(ifname);
+
+    send_udp(sock, buffer, target_addr, current_buffer_position - buffer);
+} 
+
+
+/**
+ * @code                callback(evutil_socket_t fd, short event, void *arg);
+ * 
+ * @brief               callback for libevent that is called everytime data is received at the filter socket
+ *
+ * @param fd            filter socket
+ * @param event         libevent triggered event  
+ * @param arg           callback argument provided by user
+ *
+ * @return              none
+ */
+void callback(evutil_socket_t fd, short event, void *arg) {
+    struct relay_config *config = (struct relay_config *)arg;
+    uint8_t message_buffer[4096];
+    uint32_t len = recv(config->filter, message_buffer, 4096, 0);
+    if (len <= 0) {
+        syslog(LOG_WARNING, "recv: Failed to receive data at filter socket\n");
+    }
+
+    char* ptr = (char *)message_buffer;
+    const uint8_t *current_position = (uint8_t *)ptr; 
+    const uint8_t *tmp = NULL;
+
+    auto ether_header = parse_ether_frame(current_position, &tmp);
+    current_position = tmp;
+
+    auto ip_header = parse_ip6_hdr(current_position, &tmp);
+    current_position = tmp;
+
+    if (ip_header->ip6_ctlun.ip6_un1.ip6_un1_nxt != IPPROTO_UDP) {
+        const struct ip6_ext *ext_header;
+        do {
+            ext_header = (const struct ip6_ext *)current_position;
+            current_position += ext_header->ip6e_len;
+        }
+        while (ext_header->ip6e_nxt != IPPROTO_UDP);
+    }  
+
+    auto udp_header = parse_udp(current_position, &tmp);
+    current_position = tmp;
+
+    auto dhcp_header = parse_dhcpv6_hdr(current_position);
+
+    if ((ntohs(udp_header->dest)) == 547 ) {
+        if(dhcp_header->msg_type == SOLICIT || REQUEST || CONFIRM || RENEW || REBIND || RELEASE || DECLINE) {
+            relay_client(config->local_sock, current_position, ntohs(udp_header->len) - sizeof(udphdr), ip_header, ether_header, config);
+        }    
+    }
+}
+
+/**
+ * @code                listen_server(void *arg);
+ * 
+ * @brief               listen to the DHCPv6 server
+ *
+ * @param arg           callback argument provided by user
+ *
+ * @return              none
+ */
+void listen_server(relay_config *config) {
+    while (serverListener) {
+        sockaddr_in6 from;
+        int32_t data = 0;
+        uint8_t message_buffer[4096];
+
+        if ((data = recvfrom(config->local_sock, message_buffer, 4096, 0, (sockaddr *)&from, (socklen_t *)sizeof(from))) == -1) {
+            syslog(LOG_WARNING, "recv: Failed to receive data from server\n");
+        }
+
+        auto msg = parse_dhcpv6_hdr(message_buffer);
+        if (msg->msg_type == RELAY_REPL) {
+            relay_relay_reply(config->local_sock, message_buffer, data, config);
+        }
+    }
+}
+
+/**
+*@code      initialize_server(relay_config *config);
+*
+*@brief     initialize server listening thread
+*
+*@return    none
+*/
+void initialize_server(relay_config *config)
+{
+    try {
+        serverPtr = std::make_shared<boost::thread> (&listen_server, config);
+    }
+    catch (const std::bad_alloc &e) {
+        syslog(LOG_ERR, "Failed to allocate memory. Exception details: %s", e.what());
+    }
+}
+
+/**
+*@code      stopServerListener();
+*
+*@brief     stop server listening thread
+*
+*@return    none
+*/
+void stopServerListener() {
+    serverListener = false;
+};
+
+/**
+*@code      deinitialize_server();
+*
+*@brief     join and stop server listening thread
+*
+*@return    none
+*/
+void deinitialize_server() {
+    stopServerListener();
+    serverPtr->interrupt();
+}
+
+/**
+ * @code signal_init();
+ *
+ * @brief initialize DHCPv6 Relay libevent signals
+ */
+int signal_init() {
+    int rv = -1;
+     do {
+        ev_sigint = evsignal_new(base, SIGINT, signal_callback, base);
+        if (ev_sigint == NULL) {
+            syslog(LOG_ERR, "Could not create SIGINT libevent signal\n");
+            break;
+        }
+
+        ev_sigterm = evsignal_new(base, SIGTERM, signal_callback, base);
+        if (ev_sigterm == NULL) {
+            syslog(LOG_ERR, "Could not create SIGTERM libevent signal\n");
+            break;
+        }
+        rv = 0;
+    } while(0);
+    return rv;
+}
+
+/**
+ * @code signal_start();
+ *
+ * @brief start DHCPv6 Relay libevent base and add signals
+ */
+int signal_start()
+{
+    int rv = -1;
+    do
+    {
+        if (evsignal_add(ev_sigint, NULL) != 0) {
+            syslog(LOG_ERR, "Could not add SIGINT libevent signal\n");
+            break;
+        }
+
+        if (evsignal_add(ev_sigterm, NULL) != 0) {
+            syslog(LOG_ERR, "Could not add SIGTERM libevent signal\n");
+            break;
+        }
+
+        if (event_base_dispatch(base) != 0) {
+            syslog(LOG_ERR, "Could not start libevent dispatching loop\n");
+        }
+
+        rv = 0;
+    } while (0);
+
+    return rv;
+}
+
+/**
+ * @code signal_callback(fd, event, arg);
+ *
+ * @brief signal handler for dhcp6relay. Initiate shutdown when signal is caught
+ *
+ * @param fd        libevent socket
+ * @param event     event triggered
+ * @param arg       pointer to libevent base
+ *
+ * @return none
+ */
+void signal_callback(evutil_socket_t fd, short event, void *arg)
+{
+    syslog(LOG_ALERT, "Received signal: '%s'\n", strsignal(fd));
+    if ((fd == SIGTERM) || (fd == SIGINT)) {
+        dhcp6relay_stop();
+    }
+}
+
+/**
+ * @code dhcp6relay_stop();
+ *
+ * @brief stop DHCPv6 Relay libevent loop upon signal
+ */
+void dhcp6relay_stop()
+{
+    event_base_loopexit(base, NULL);
+}
+
+/**
+ * @code                loop_relay(arg_config context);
+ * 
+ * @brief               main loop: configure sockets, create libevent base, start server listener thread
+ *
+ * @param context       user argument that contains input interface and options
+ */
+void loop_relay(arg_config *context) {
+    struct relay_config config;
+    int filter = 0;
+    int local_sock = 0; 
+    const char *ifname = context->interface.c_str();
+    int index = if_nametoindex(ifname);
+
+    filter = sock_open(index, &ether_relay_fprog);
+
+    prepare_socket(&local_sock, context);
+
+    config.interface = context->interface;
+
+    prepare_relay_config(&config, local_sock, filter, context);
+
+    initialize_server(&config);
+
+    evutil_make_listen_socket_reuseable(filter);
+    evutil_make_socket_nonblocking(filter);
+
+    base = event_base_new();
+    if(base == NULL) {
+        syslog(LOG_ERR, "libevent: Failed to create base\n");
+    }
+
+    listen_event = event_new(base, filter, EV_READ|EV_PERSIST, callback, (void *)&config);
+    if (listen_event == NULL) {
+        syslog(LOG_ERR, "libevent: Failed to create libevent\n");
+    }
+    event_add(listen_event, NULL);
+
+    if((signal_init() == 0) && signal_start() == 0) {
+        shutdown();
+        close(local_sock);
+    }
+}
+
+/**
+ * @code shutdown();
+ *
+ * @brief free signals and terminate threads
+ */
+void shutdown() {
+    event_del(ev_sigint);
+    event_del(ev_sigterm);
+    event_free(ev_sigint); 
+    event_free(ev_sigterm);
+    deinitialize_swss();
+    deinitialize_server();
+}
diff --git a/src/dhcp6relay/src/relay.h b/src/dhcp6relay/src/relay.h
new file mode 100644
index 000000000000..4b8926ad3dea
--- /dev/null
+++ b/src/dhcp6relay/src/relay.h
@@ -0,0 +1,175 @@
+#include <arpa/inet.h>
+#include <net/if.h>
+#include <linux/if_packet.h>
+#include <netinet/if_ether.h>	
+#include <netinet/ip6.h>
+#include <netinet/udp.h>
+#include <ifaddrs.h>
+#include <linux/filter.h>
+#include <string>
+#include <vector>
+#include <event2/util.h>
+#include <memory>
+#include <thread>
+
+#define PACKED __attribute__ ((packed))
+
+#define HOP_LIMIT 32
+
+#define lengthof(A) (sizeof (A) / sizeof (A)[0])
+
+#define SOLICIT 1
+#define REQUEST 3
+#define CONFIRM 4
+#define RENEW 5
+#define REBIND 6
+#define RELEASE 8 
+#define DECLINE 9
+#define RELAY_FORW 12
+#define RELAY_REPL 13
+#define OPTION_RELAY_MSG 9
+#define OPTION_CLIENT_LINKLAYER_ADDR 79
+
+
+/* Configuration */
+static std::string config_interface;
+
+struct arg_config {
+    std::vector<std::string> servers;
+    std::string interface;
+    bool is_option_79;
+};
+
+struct relay_config {
+    int local_sock; 
+    int filter;
+    sockaddr_in6 link_address;
+    std::string interface;
+    std::vector<sockaddr_in6> servers;
+    bool is_option_79;
+};
+
+
+/* DHCPv6 messages and options */
+
+struct dhcpv6_msg {
+    uint8_t msg_type;
+};
+
+struct PACKED dhcpv6_relay_msg {
+    uint8_t msg_type;
+    uint8_t hop_count;
+    struct in6_addr link_address;
+    struct in6_addr peer_address;
+};
+
+
+struct dhcpv6_option {
+    uint16_t option_code;
+    uint16_t option_length;
+};
+
+struct linklayer_addr_option  {
+    uint16_t option_code;
+    uint16_t option_length;
+    uint16_t link_layer_type;
+};
+
+class ArgumentParser {
+    public:
+    void parse_args(int argc, char *argv[]);
+    
+    arg_config get_arg();
+
+
+    private:
+    arg_config m_config;
+
+};
+
+
+void initialize_server(relay_config *context);
+
+void deinitialize_server();
+
+void listen_server(relay_config *config);
+
+int sock_open(int ifindex, const struct sock_fprog *fprog);
+
+void prepare_socket(int *local_sock, arg_config *config);
+
+void prepare_relay_config(relay_config *interface_config, int local_sock, int filter, const arg_config *context);
+
+void relay_forward(uint8_t *buffer, const struct dhcpv6_msg *msg, uint16_t msg_length);
+
+void relay_client(int sock, const uint8_t *msg, int32_t len, const ip6_hdr *ip_hdr, const ether_header *ether_hdr, relay_config *config);
+
+void relay_relay_reply(int sock, const uint8_t *msg, int32_t len, relay_config *configs);
+
+void loop_relay(arg_config *config);
+
+int signal_init();
+
+int signal_start();
+
+void dhcp6relay_stop();
+
+void signal_callback(evutil_socket_t fd, short event, void *arg);
+
+void shutdown();
+
+
+/* Helper functions */
+
+bool is_addr_gua(in6_addr addr);
+
+bool is_addr_link_local(in6_addr addr);
+
+const struct ether_header *parse_ether_frame(const uint8_t *buffer, const uint8_t **out_end);
+
+const struct ip6_hdr *parse_ip6_hdr(const uint8_t *buffer, const uint8_t **out_end);
+
+const struct udphdr *parse_udp(const uint8_t *buffer, const uint8_t **out_end);
+
+const struct dhcpv6_msg *parse_dhcpv6_hdr(const uint8_t *buffer);
+
+const struct dhcpv6_relay_msg *parse_dhcpv6_relay(const uint8_t *buffer);
+
+const struct dhcpv6_option *parse_dhcpv6_opt(const uint8_t *buffer, const uint8_t **out_end);
+
+void send_udp(int sock, struct sockaddr_in6 target, uint8_t *buffer, uint32_t n);
+
+struct ArgumentException : std::exception {
+    std::string msg;
+    ArgumentException(std::string message) : msg(message) {}
+    ~ArgumentException() throw() {}
+    const char* what() const throw() { return msg.c_str(); }
+};
+
+
+/* DHCPv6 filter */
+/* sudo tcpdump -dd "ip6 dst ff02::1:2 && udp dst port 547" */
+
+static struct sock_filter ether_relay_filter[] = {
+	
+	{ 0x28, 0, 0, 0x0000000c },
+	{ 0x15, 0, 13, 0x000086dd },
+	{ 0x20, 0, 0, 0x00000026 },
+	{ 0x15, 0, 11, 0xff020000 },
+	{ 0x20, 0, 0, 0x0000002a },
+	{ 0x15, 0, 9, 0x00000000 },
+	{ 0x20, 0, 0, 0x0000002e },
+	{ 0x15, 0, 7, 0x00000000 },
+	{ 0x20, 0, 0, 0x00000032 },
+	{ 0x15, 0, 5, 0x00010002 },
+	{ 0x30, 0, 0, 0x00000014 },
+	{ 0x15, 0, 3, 0x00000011 },
+	{ 0x28, 0, 0, 0x00000038 },
+	{ 0x15, 0, 1, 0x00000223 },
+	{ 0x6, 0, 0, 0x00040000 },
+	{ 0x6, 0, 0, 0x00000000 },
+};
+const struct sock_fprog ether_relay_fprog = {
+	lengthof(ether_relay_filter),
+	ether_relay_filter
+};
diff --git a/src/dhcp6relay/src/subdir.mk b/src/dhcp6relay/src/subdir.mk
new file mode 100644
index 000000000000..af378319d78f
--- /dev/null
+++ b/src/dhcp6relay/src/subdir.mk
@@ -0,0 +1,23 @@
+CC := g++
+
+C_SRCS += \
+../src/relay.c \
+../src/configInterface.c \
+../src/main.c 
+
+OBJS += \
+./src/relay.o \
+./src/configInterface.o \
+./src/main.o 
+
+C_DEPS += \
+./src/relay.d \
+./src/configInterface.d \
+./src/main.d 
+
+src/%.o: src/%.cpp
+	@echo 'Building file: $<'
+	@echo 'Invoking: GCC C++ Compiler'
+	$(CC) -std=c++17 -D__FILENAME__="$(subst src/,,$<)" $(LIBS) -Wall -c -fmessage-length=0 -fPIC -MMD -MP -MF"$(@:%.o=%.d)" -MT"$(@)" -o "$@" "$<"
+	@echo 'Finished building: $<'
+	@echo ' '

From 18a598b72c6a6a62e499b8723cbdf7795c5cba3a Mon Sep 17 00:00:00 2001
From: kellyyeh <kellyyeh@microsoft.com>
Date: Thu, 22 Jul 2021 20:34:07 +0000
Subject: [PATCH 02/16] Added DHCPv6 Relay

---
 src/dhcp6relay/debian/changelog        | 2 +-
 src/dhcp6relay/debian/control          | 6 ++++--
 src/dhcp6relay/src/configInterface.cpp | 2 +-
 src/dhcp6relay/src/configInterface.h   | 2 +-
 src/dhcp6relay/src/main.cpp            | 2 +-
 5 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/dhcp6relay/debian/changelog b/src/dhcp6relay/debian/changelog
index 1a1c6482d640..4ec0148d3362 100644
--- a/src/dhcp6relay/debian/changelog
+++ b/src/dhcp6relay/debian/changelog
@@ -2,4 +2,4 @@ sonic-dhcp6relay (1.0.0-0) UNRELEASED; urgency=medium
 
   * Initial release.
 
- -- Kelly Yeh <kellyyeh@microsoft.com>  Mon, 09 Dec 2019 12:00:00 -0700
+ -- Kelly Yeh <kellyyeh@microsoft.com>  
diff --git a/src/dhcp6relay/debian/control b/src/dhcp6relay/debian/control
index 1e383a8515bf..f470fd98d93a 100644
--- a/src/dhcp6relay/debian/control
+++ b/src/dhcp6relay/debian/control
@@ -11,5 +11,7 @@ XS-Go-Import-Path: github.com/Azure/sonic-buildimage
 Package: sonic-dhcp6relay
 Architecture: any
 Built-Using: ${misc:Built-Using}
-Depends: libevent-2.1-6
-Description: SONiC DHCPv6 Relay
\ No newline at end of file
+Depends: libevent-2.1-6,
+        libboost-thread1.71.0.
+        libboost-system1.71.0
+Description: SONiC DHCPv6 Relay
diff --git a/src/dhcp6relay/src/configInterface.cpp b/src/dhcp6relay/src/configInterface.cpp
index 315fedd925c9..4f85ddbbb265 100644
--- a/src/dhcp6relay/src/configInterface.cpp
+++ b/src/dhcp6relay/src/configInterface.cpp
@@ -134,4 +134,4 @@ void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries,
 */
 void stopSwssNotificationPoll() {
     mPollSwssNotifcation = false;
-};
\ No newline at end of file
+};
diff --git a/src/dhcp6relay/src/configInterface.h b/src/dhcp6relay/src/configInterface.h
index 4008821e6061..6f8589d677f1 100644
--- a/src/dhcp6relay/src/configInterface.h
+++ b/src/dhcp6relay/src/configInterface.h
@@ -13,4 +13,4 @@ void handleRelayNotification(swss::SubscriberStateTable &configMuxTable, arg_con
 
 void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, arg_config *context);
 
-void stopSwssNotificationPoll();
\ No newline at end of file
+void stopSwssNotificationPoll();
diff --git a/src/dhcp6relay/src/main.cpp b/src/dhcp6relay/src/main.cpp
index 77135e5507f8..20b5ac733371 100644
--- a/src/dhcp6relay/src/main.cpp
+++ b/src/dhcp6relay/src/main.cpp
@@ -15,4 +15,4 @@ int main(int argc, char *argv[]) {
         return 1;
     }
     return 0;
-}
\ No newline at end of file
+}

From eccb093858122155041b512c45940af3ca775789 Mon Sep 17 00:00:00 2001
From: kellyyeh <kellyyeh@microsoft.com>
Date: Wed, 28 Jul 2021 19:07:11 +0000
Subject: [PATCH 03/16] Deleted argument parser and fixed port naming and
 indentation

---
 src/dhcp6relay/src/main.cpp  |  4 +--
 src/dhcp6relay/src/relay.cpp | 65 +++++-------------------------------
 src/dhcp6relay/src/relay.h   | 14 ++------
 3 files changed, 12 insertions(+), 71 deletions(-)

diff --git a/src/dhcp6relay/src/main.cpp b/src/dhcp6relay/src/main.cpp
index 20b5ac733371..fca0d0c89c6f 100644
--- a/src/dhcp6relay/src/main.cpp
+++ b/src/dhcp6relay/src/main.cpp
@@ -3,9 +3,7 @@
 
 int main(int argc, char *argv[]) {
     try {
-        auto parser = ArgumentParser();
-        parser.parse_args(argc, argv);
-        auto context = parser.get_arg();
+        arg_config context;
         initialize_swss(&context);
         loop_relay(&context);
     }
diff --git a/src/dhcp6relay/src/relay.cpp b/src/dhcp6relay/src/relay.cpp
index 5c347758a4ee..a643271f4f46 100644
--- a/src/dhcp6relay/src/relay.cpp
+++ b/src/dhcp6relay/src/relay.cpp
@@ -22,52 +22,6 @@ struct event *ev_sigterm;
 bool serverListener = true;
 std::shared_ptr<boost::thread> serverPtr;
 
-/**
- * @code        parse_args(int argc, char *argv[]);
- *
- * @brief       parse through argument and define the interface to bind to and to turn off option 79. 
- *              read from config database and set the ipv6 helper addresses.
- *
- * @return      none
- */
-void ArgumentParser::parse_args(int argc, char *argv[]) {
-    int opt;
-    std::string option;
-    bool is_interface_set = false;
-    m_config.is_option_79 = false; 
-    
-    while ((opt = getopt(argc, argv, "i:o:")) != -1) {
-        switch (opt) {
-            case 'i':
-                if (is_interface_set) {
-                        throw ArgumentException("Interface is already set to : " + this->m_config.interface);
-                }
-                else {
-                    is_interface_set = true;
-                    this->m_config.interface = std::string(optarg);
-                    config_interface = this->m_config.interface;
-                }
-                break;
-            case 'o':
-                if(std::string(optarg) == "79")
-                    m_config.is_option_79 = true;
-            case '?':
-                option = std::string(argv[optind - 1]);
-                throw ArgumentException("Option " + option + " not recognized");
-            default:
-                abort();
-        }
-    }
-
-    if (!is_interface_set) {
-        throw ArgumentException("Must specify an interface");
-    }
-}
-
-arg_config ArgumentParser::get_arg() {
-    return this->m_config;
-}
-
 bool is_addr_gua(in6_addr addr) {
 
     auto masked = addr.__in6_u.__u6_addr8[0] & 0xe0;
@@ -216,7 +170,7 @@ void prepare_relay_config(relay_config *interface_config, int local_sock, int fi
         }
         tmp.sin6_family = AF_INET6;
         tmp.sin6_flowinfo = 0;
-        tmp.sin6_port = htons(547);
+        tmp.sin6_port = htons(RELAY_PORT);
         tmp.sin6_scope_id = 0; 
         interface_config->servers.push_back(tmp);
     }
@@ -229,8 +183,8 @@ void prepare_relay_config(relay_config *interface_config, int local_sock, int fi
     addr[0] = 0;
 
     if (getifaddrs(&ifa) == -1) {
-		    syslog(LOG_WARNING, "getifaddrs: Unable to get network interfaces\n");
-            exit(1);
+		syslog(LOG_WARNING, "getifaddrs: Unable to get network interfaces\n");
+        exit(1);
 	}
 
     ifa_tmp = ifa;
@@ -240,6 +194,7 @@ void prepare_relay_config(relay_config *interface_config, int local_sock, int fi
             inet_ntop(AF_INET6, &in6->sin6_addr, addr, sizeof(addr));
             if((strcmp(ifa_tmp->ifa_name, interface_config->interface.c_str()) == 0) && is_addr_gua(in6->sin6_addr)) {    
                 non_link_local = in6;
+                break;
             }
             if((strcmp(ifa_tmp->ifa_name, interface_config->interface.c_str()) == 0) && is_addr_link_local(in6->sin6_addr)) {    
                 link_local = in6;
@@ -304,7 +259,7 @@ void prepare_socket(int *local_sock, arg_config *context) {
         syslog(LOG_ERR, "scoket: Failed to create socket\n");
     }
 
-    addr.sin6_port = htons(547);
+    addr.sin6_port = htons(RELAY_PORT);
     
     if (bind(*local_sock, (sockaddr *)&addr, sizeof(addr)) == -1) {
         syslog(LOG_ERR, "bind: Failed to bind to socket\n");
@@ -400,7 +355,7 @@ void relay_client(int sock, const uint8_t *msg, int32_t len, const ip6_hdr *ip_h
     memcpy(&target_addr.sin6_addr, &dhcp_relay_header->peer_address, sizeof(struct in6_addr));
     target_addr.sin6_family = AF_INET6;
     target_addr.sin6_flowinfo = 0;
-    target_addr.sin6_port = htons(546);
+    target_addr.sin6_port = htons(CLIENT_PORT);
     target_addr.sin6_scope_id = if_nametoindex(ifname);
 
     send_udp(sock, buffer, target_addr, current_buffer_position - buffer);
@@ -420,7 +375,7 @@ void relay_client(int sock, const uint8_t *msg, int32_t len, const ip6_hdr *ip_h
  */
 void callback(evutil_socket_t fd, short event, void *arg) {
     struct relay_config *config = (struct relay_config *)arg;
-    uint8_t message_buffer[4096];
+    static uint8_t message_buffer[4096];
     uint32_t len = recv(config->filter, message_buffer, 4096, 0);
     if (len <= 0) {
         syslog(LOG_WARNING, "recv: Failed to receive data at filter socket\n");
@@ -450,10 +405,8 @@ void callback(evutil_socket_t fd, short event, void *arg) {
 
     auto dhcp_header = parse_dhcpv6_hdr(current_position);
 
-    if ((ntohs(udp_header->dest)) == 547 ) {
-        if(dhcp_header->msg_type == SOLICIT || REQUEST || CONFIRM || RENEW || REBIND || RELEASE || DECLINE) {
-            relay_client(config->local_sock, current_position, ntohs(udp_header->len) - sizeof(udphdr), ip_header, ether_header, config);
-        }    
+    if (((ntohs(udp_header->dest)) == RELAY_PORT) && (dhcp_header->msg_type == SOLICIT || REQUEST || CONFIRM || RENEW || REBIND || RELEASE || DECLINE)) {
+        relay_client(config->local_sock, current_position, ntohs(udp_header->len) - sizeof(udphdr), ip_header, ether_header, config);
     }
 }
 
diff --git a/src/dhcp6relay/src/relay.h b/src/dhcp6relay/src/relay.h
index 4b8926ad3dea..c6dd218acdfe 100644
--- a/src/dhcp6relay/src/relay.h
+++ b/src/dhcp6relay/src/relay.h
@@ -14,6 +14,8 @@
 
 #define PACKED __attribute__ ((packed))
 
+#define RELAY_PORT 547
+#define CLIENT_PORT 546
 #define HOP_LIMIT 32
 
 #define lengthof(A) (sizeof (A) / sizeof (A)[0])
@@ -75,18 +77,6 @@ struct linklayer_addr_option  {
     uint16_t link_layer_type;
 };
 
-class ArgumentParser {
-    public:
-    void parse_args(int argc, char *argv[]);
-    
-    arg_config get_arg();
-
-
-    private:
-    arg_config m_config;
-
-};
-
 
 void initialize_server(relay_config *context);
 

From 4ba13b97f1ffb82c4a3852f00b30d9e372a0aab6 Mon Sep 17 00:00:00 2001
From: kellyyeh <kellyyeh@microsoft.com>
Date: Mon, 2 Aug 2021 17:46:30 +0000
Subject: [PATCH 04/16] Added server listening to libevent loop

---
 src/dhcp6relay/debian/changelog |   2 +-
 src/dhcp6relay/debian/control   |   2 +-
 src/dhcp6relay/src/relay.cpp    | 102 +++++++++++---------------------
 src/dhcp6relay/src/relay.h      |   9 +--
 4 files changed, 40 insertions(+), 75 deletions(-)

diff --git a/src/dhcp6relay/debian/changelog b/src/dhcp6relay/debian/changelog
index 4ec0148d3362..67ed277049e5 100644
--- a/src/dhcp6relay/debian/changelog
+++ b/src/dhcp6relay/debian/changelog
@@ -2,4 +2,4 @@ sonic-dhcp6relay (1.0.0-0) UNRELEASED; urgency=medium
 
   * Initial release.
 
- -- Kelly Yeh <kellyyeh@microsoft.com>  
+-- Kelly Yeh <kellyyeh@microsoft.com>  
diff --git a/src/dhcp6relay/debian/control b/src/dhcp6relay/debian/control
index f470fd98d93a..31fdb6f41f3b 100644
--- a/src/dhcp6relay/debian/control
+++ b/src/dhcp6relay/debian/control
@@ -12,6 +12,6 @@ Package: sonic-dhcp6relay
 Architecture: any
 Built-Using: ${misc:Built-Using}
 Depends: libevent-2.1-6,
-        libboost-thread1.71.0.
+        libboost-thread1.71.0,
         libboost-system1.71.0
 Description: SONiC DHCPv6 Relay
diff --git a/src/dhcp6relay/src/relay.cpp b/src/dhcp6relay/src/relay.cpp
index a643271f4f46..4d73acdfa62c 100644
--- a/src/dhcp6relay/src/relay.cpp
+++ b/src/dhcp6relay/src/relay.cpp
@@ -15,13 +15,11 @@
 
 
 struct event *listen_event;
+struct event *server_listen_event;
 struct event_base *base;
 struct event *ev_sigint;
 struct event *ev_sigterm;
 
-bool serverListener = true;
-std::shared_ptr<boost::thread> serverPtr;
-
 bool is_addr_gua(in6_addr addr) {
 
     auto masked = addr.__in6_u.__u6_addr8[0] & 0xe0;
@@ -266,6 +264,23 @@ void prepare_socket(int *local_sock, arg_config *context) {
     }    
 }
 
+void prepare_server_socket(int *server_sock, arg_config *context) {
+    sockaddr_in6 addr;
+    memset(&addr, 0, sizeof(addr));
+    addr.sin6_family = AF_INET6;
+    addr.sin6_addr = in6addr_any;
+
+    if ((*server_sock = socket(AF_INET6, SOCK_DGRAM, 0)) == -1) {
+        syslog(LOG_ERR, "scoket: Failed to create socket\n");
+    }
+
+    addr.sin6_port = htons(RELAY_PORT);
+    
+    if (bind(*server_sock, (sockaddr *)&addr, sizeof(addr)) == -1) {
+        syslog(LOG_ERR, "bind: Failed to bind to socket\n");
+    }    
+}
+
 
 /**
  * @code                 relay_client(int sock, const uint8_t *msg, int32_t len, ip6_hdr *ip_hdr, const ether_header *ether_hdr, relay_config *config);
@@ -410,72 +425,22 @@ void callback(evutil_socket_t fd, short event, void *arg) {
     }
 }
 
-/**
- * @code                listen_server(void *arg);
- * 
- * @brief               listen to the DHCPv6 server
- *
- * @param arg           callback argument provided by user
- *
- * @return              none
- */
-void listen_server(relay_config *config) {
-    while (serverListener) {
-        sockaddr_in6 from;
-        int32_t data = 0;
-        uint8_t message_buffer[4096];
-
-        if ((data = recvfrom(config->local_sock, message_buffer, 4096, 0, (sockaddr *)&from, (socklen_t *)sizeof(from))) == -1) {
-            syslog(LOG_WARNING, "recv: Failed to receive data from server\n");
-        }
+void server_callback(evutil_socket_t fd, short event, void *arg) {
+    struct relay_config *config = (struct relay_config *)arg;
+    sockaddr_in6 from;
+    int32_t data = 0;
+    uint8_t message_buffer[4096];
 
-        auto msg = parse_dhcpv6_hdr(message_buffer);
-        if (msg->msg_type == RELAY_REPL) {
-            relay_relay_reply(config->local_sock, message_buffer, data, config);
-        }
+    if ((data = recvfrom(config->local_sock, message_buffer, 4096, 0, (sockaddr *)&from, (socklen_t *)sizeof(from))) == -1) {
+        syslog(LOG_WARNING, "recv: Failed to receive data from server\n");
     }
-}
 
-/**
-*@code      initialize_server(relay_config *config);
-*
-*@brief     initialize server listening thread
-*
-*@return    none
-*/
-void initialize_server(relay_config *config)
-{
-    try {
-        serverPtr = std::make_shared<boost::thread> (&listen_server, config);
-    }
-    catch (const std::bad_alloc &e) {
-        syslog(LOG_ERR, "Failed to allocate memory. Exception details: %s", e.what());
+    auto msg = parse_dhcpv6_hdr(message_buffer);
+    if (msg->msg_type == RELAY_REPL) {
+        relay_relay_reply(config->local_sock, message_buffer, data, config);
     }
 }
 
-/**
-*@code      stopServerListener();
-*
-*@brief     stop server listening thread
-*
-*@return    none
-*/
-void stopServerListener() {
-    serverListener = false;
-};
-
-/**
-*@code      deinitialize_server();
-*
-*@brief     join and stop server listening thread
-*
-*@return    none
-*/
-void deinitialize_server() {
-    stopServerListener();
-    serverPtr->interrupt();
-}
-
 /**
  * @code signal_init();
  *
@@ -570,19 +535,19 @@ void loop_relay(arg_config *context) {
     struct relay_config config;
     int filter = 0;
     int local_sock = 0; 
+    int server_sock = 0;
     const char *ifname = context->interface.c_str();
     int index = if_nametoindex(ifname);
 
     filter = sock_open(index, &ether_relay_fprog);
 
     prepare_socket(&local_sock, context);
+    prepare_server_socket(&server_sock, context);
 
     config.interface = context->interface;
 
     prepare_relay_config(&config, local_sock, filter, context);
 
-    initialize_server(&config);
-
     evutil_make_listen_socket_reuseable(filter);
     evutil_make_socket_nonblocking(filter);
 
@@ -592,10 +557,16 @@ void loop_relay(arg_config *context) {
     }
 
     listen_event = event_new(base, filter, EV_READ|EV_PERSIST, callback, (void *)&config);
+    server_listen_event = event_new(base, server_sock, EV_READ|EV_PERSIST, server_callback, (void *)&config);
     if (listen_event == NULL) {
         syslog(LOG_ERR, "libevent: Failed to create libevent\n");
     }
+    if (server_listen_event == NULL) {
+        syslog(LOG_ERR, "libevent: Failed to create server listening libevent\n");
+    }
     event_add(listen_event, NULL);
+    event_add(server_listen_event, NULL);
+    
 
     if((signal_init() == 0) && signal_start() == 0) {
         shutdown();
@@ -614,5 +585,4 @@ void shutdown() {
     event_free(ev_sigint); 
     event_free(ev_sigterm);
     deinitialize_swss();
-    deinitialize_server();
 }
diff --git a/src/dhcp6relay/src/relay.h b/src/dhcp6relay/src/relay.h
index c6dd218acdfe..5acea33837d4 100644
--- a/src/dhcp6relay/src/relay.h
+++ b/src/dhcp6relay/src/relay.h
@@ -77,17 +77,12 @@ struct linklayer_addr_option  {
     uint16_t link_layer_type;
 };
 
-
-void initialize_server(relay_config *context);
-
-void deinitialize_server();
-
-void listen_server(relay_config *config);
-
 int sock_open(int ifindex, const struct sock_fprog *fprog);
 
 void prepare_socket(int *local_sock, arg_config *config);
 
+void prepare_server_socket(int *server_sock, arg_config *context);
+
 void prepare_relay_config(relay_config *interface_config, int local_sock, int filter, const arg_config *context);
 
 void relay_forward(uint8_t *buffer, const struct dhcpv6_msg *msg, uint16_t msg_length);

From 429e75261db954f07cb26d9b71cc4729bd35155b Mon Sep 17 00:00:00 2001
From: kellyyeh <kellyyeh@microsoft.com>
Date: Tue, 3 Aug 2021 22:14:24 +0000
Subject: [PATCH 05/16] Added operation key to configInterface

---
 src/dhcp6relay/src/configInterface.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/dhcp6relay/src/configInterface.cpp b/src/dhcp6relay/src/configInterface.cpp
index 4f85ddbbb265..08f25367947f 100644
--- a/src/dhcp6relay/src/configInterface.cpp
+++ b/src/dhcp6relay/src/configInterface.cpp
@@ -99,6 +99,7 @@ void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries,
 
     for (auto &entry: entries) {
         std::string vlan = kfvKey(entry);
+        std::string operation = kfvOp(entry);
         std::vector<swss::FieldValueTuple> fieldValues = kfvFieldsValues(entry);
 
         for (auto &fieldValue: fieldValues) {
@@ -111,13 +112,14 @@ void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries,
                     getline(ss, substr, ',');
                     context->servers.push_back(substr);
                 }
+                syslog(LOG_DEBUG, "key: %s, Operation: %s, f: %s, v: %s", vlan.c_str(), operation.c_str(), f.c_str(), v.c_str());
             }
             if(f == "options") {
                 std::stringstream ss(v);
                 while (ss.good()) {
                     std::string substr;
                     getline(ss, substr, ',');
-                    if(substr == "79")
+                    if(substr == "dhcpv6_option|rfc6939_support")
                         context->is_option_79 = true;
                 }
             }

From 6c4ed487dd8eec3ffebebfaac4dac2e7e1b35b72 Mon Sep 17 00:00:00 2001
From: kellyyeh <kellyyeh@microsoft.com>
Date: Thu, 5 Aug 2021 21:08:00 +0000
Subject: [PATCH 06/16] Support multi vlans

---
 src/dhcp6relay/src/configInterface.cpp | 33 +++++-----
 src/dhcp6relay/src/configInterface.h   |  8 +--
 src/dhcp6relay/src/main.cpp            |  6 +-
 src/dhcp6relay/src/relay.cpp           | 86 ++++++++++++++------------
 src/dhcp6relay/src/relay.h             |  2 +-
 5 files changed, 73 insertions(+), 62 deletions(-)

diff --git a/src/dhcp6relay/src/configInterface.cpp b/src/dhcp6relay/src/configInterface.cpp
index 08f25367947f..3c733c5f8a3f 100644
--- a/src/dhcp6relay/src/configInterface.cpp
+++ b/src/dhcp6relay/src/configInterface.cpp
@@ -13,10 +13,10 @@ std::shared_ptr<boost::thread> mSwssThreadPtr;
 //
 // initialize DB tables and start SWSS listening thread
 //
-void initialize_swss(arg_config *context)
+void initialize_swss(std::vector<arg_config> *vlans)
 {
     try {
-        mSwssThreadPtr = std::make_shared<boost::thread> (&handleSwssNotification, context);
+        mSwssThreadPtr = std::make_shared<boost::thread> (&handleSwssNotification, vlans);
     }
     catch (const std::bad_alloc &e) {
         syslog(LOG_ERR, "Failed allocate memory. Exception details: %s", e.what());
@@ -35,15 +35,15 @@ void deinitialize_swss()
 }
 
 /**
- * @code                void handleSwssNotification(arg_config *context)
+ * @code                void handleSwssNotification(std::vector<arg_config> *vlans)
  * 
  * @brief               main thread for handling SWSS notification
  *
- * @param context       argument config that contains strings of server and option
+ * @param context       list of vlans/argument config that contains strings of server and option
  *
  * @return              none
  */
-void handleSwssNotification(arg_config *context)
+void handleSwssNotification(std::vector<arg_config> *vlans)
 {
     std::shared_ptr<swss::DBConnector> configDbPtr = std::make_shared<swss::DBConnector> ("CONFIG_DB", 0);
     swss::SubscriberStateTable ipHelpersTable(configDbPtr.get(), "DHCP");
@@ -60,40 +60,40 @@ void handleSwssNotification(arg_config *context)
             continue;
         } 
         if (selectable == static_cast<swss::Selectable *> (&ipHelpersTable)) {
-            handleRelayNotification(ipHelpersTable, context);
+            handleRelayNotification(ipHelpersTable, vlans);
         }
     } 
 }
 
 /**
- * @code                    void handleRelayNotification(swss::SubscriberStateTable &ipHelpersTable, arg_config context)
+ * @code                    void handleRelayNotification(swss::SubscriberStateTable &ipHelpersTable, std::vector<arg_config> *vlans)
  * 
  * @brief                   handles DHCPv6 relay configuration change notification
  *
  * @param ipHelpersTable    DHCP table
- * @param context           argument config that contains strings of server and option
+ * @param context           list of vlans/argument config that contains strings of server and option
  *
  * @return                  none
  */
-void handleRelayNotification(swss::SubscriberStateTable &ipHelpersTable, arg_config *context)
+void handleRelayNotification(swss::SubscriberStateTable &ipHelpersTable, std::vector<arg_config> *vlans)
 {
     std::deque<swss::KeyOpFieldsValuesTuple> entries;
 
     ipHelpersTable.pops(entries);
-    processRelayNotification(entries, context);
+    processRelayNotification(entries, vlans);
 }
 
 /**
- * @code                    void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, arg_config context)
+ * @code                    void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, std::vector<arg_config> *vlans)
  * 
  * @brief                   process DHCPv6 relay servers and options configuration change notification
  *
  * @param entries           queue of std::tuple<std::string, std::string, std::vector<FieldValueTuple>> entries in DHCP table
- * @param context           argument config that contains strings of server and option
+ * @param context           list of vlans/argument config that contains strings of server and option
  *
  * @return                  none
  */
-void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, arg_config *context)
+void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, std::vector<arg_config> *vlans)
 {
     std::vector<std::string> servers;
 
@@ -102,6 +102,8 @@ void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries,
         std::string operation = kfvOp(entry);
         std::vector<swss::FieldValueTuple> fieldValues = kfvFieldsValues(entry);
 
+        arg_config intf;
+        intf.interface = vlan;
         for (auto &fieldValue: fieldValues) {
             std::string f = fvField(fieldValue);
             std::string v = fvValue(fieldValue);
@@ -110,7 +112,7 @@ void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries,
                 while (ss.good()) {
                     std::string substr;
                     getline(ss, substr, ',');
-                    context->servers.push_back(substr);
+                    intf.servers.push_back(substr);
                 }
                 syslog(LOG_DEBUG, "key: %s, Operation: %s, f: %s, v: %s", vlan.c_str(), operation.c_str(), f.c_str(), v.c_str());
             }
@@ -120,9 +122,10 @@ void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries,
                     std::string substr;
                     getline(ss, substr, ',');
                     if(substr == "dhcpv6_option|rfc6939_support")
-                        context->is_option_79 = true;
+                        intf.is_option_79 = true;
                 }
             }
+            vlans->push_back(intf);
         }
     }
 }
diff --git a/src/dhcp6relay/src/configInterface.h b/src/dhcp6relay/src/configInterface.h
index 6f8589d677f1..66ee3ac74f80 100644
--- a/src/dhcp6relay/src/configInterface.h
+++ b/src/dhcp6relay/src/configInterface.h
@@ -3,14 +3,14 @@
 #include "select.h"
 #include "relay.h"
 
-void initialize_swss(arg_config *context);
+void initialize_swss(std::vector<arg_config> *vlans);
 
 void deinitialize_swss();
 
-void handleSwssNotification(arg_config *context);
+void handleSwssNotification(std::vector<arg_config> *vlans);
 
-void handleRelayNotification(swss::SubscriberStateTable &configMuxTable, arg_config *context);
+void handleRelayNotification(swss::SubscriberStateTable &configMuxTable, std::vector<arg_config> *vlans);
 
-void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, arg_config *context);
+void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, std::vector<arg_config> *vlans);
 
 void stopSwssNotificationPoll();
diff --git a/src/dhcp6relay/src/main.cpp b/src/dhcp6relay/src/main.cpp
index fca0d0c89c6f..2b08d8dd3f2e 100644
--- a/src/dhcp6relay/src/main.cpp
+++ b/src/dhcp6relay/src/main.cpp
@@ -3,9 +3,9 @@
 
 int main(int argc, char *argv[]) {
     try {
-        arg_config context;
-        initialize_swss(&context);
-        loop_relay(&context);
+        std::vector<arg_config> vlans;
+        initialize_swss(&vlans);
+        loop_relay(&vlans);
     }
     catch (std::exception &e)
     {
diff --git a/src/dhcp6relay/src/relay.cpp b/src/dhcp6relay/src/relay.cpp
index 4d73acdfa62c..c6ac084ce57a 100644
--- a/src/dhcp6relay/src/relay.cpp
+++ b/src/dhcp6relay/src/relay.cpp
@@ -418,9 +418,7 @@ void callback(evutil_socket_t fd, short event, void *arg) {
     auto udp_header = parse_udp(current_position, &tmp);
     current_position = tmp;
 
-    auto dhcp_header = parse_dhcpv6_hdr(current_position);
-
-    if (((ntohs(udp_header->dest)) == RELAY_PORT) && (dhcp_header->msg_type == SOLICIT || REQUEST || CONFIRM || RENEW || REBIND || RELEASE || DECLINE)) {
+    if ((ntohs(udp_header->dest)) == RELAY_PORT) {
         relay_client(config->local_sock, current_position, ntohs(udp_header->len) - sizeof(udphdr), ip_header, ether_header, config);
     }
 }
@@ -525,52 +523,61 @@ void dhcp6relay_stop()
 }
 
 /**
- * @code                loop_relay(arg_config context);
+ * @code                loop_relay(std::vector<arg_config> *vlans);
  * 
  * @brief               main loop: configure sockets, create libevent base, start server listener thread
  *
- * @param context       user argument that contains input interface and options
+ * @param vlans         list of vlans retrieved from config_db
  */
-void loop_relay(arg_config *context) {
-    struct relay_config config;
-    int filter = 0;
-    int local_sock = 0; 
-    int server_sock = 0;
-    const char *ifname = context->interface.c_str();
-    int index = if_nametoindex(ifname);
-
-    filter = sock_open(index, &ether_relay_fprog);
-
-    prepare_socket(&local_sock, context);
-    prepare_server_socket(&server_sock, context);
-
-    config.interface = context->interface;
-
-    prepare_relay_config(&config, local_sock, filter, context);
-
-    evutil_make_listen_socket_reuseable(filter);
-    evutil_make_socket_nonblocking(filter);
+void loop_relay(std::vector<arg_config> *vlans) {
+    std::vector<int> sockets;
+    for(std::size_t i = 0; i<vlans->size(); i++) {
+        arg_config context = vlans->at(i);
+        struct relay_config config;
+        int filter = 0;
+        int local_sock = 0; 
+        int server_sock = 0;
+        const char *ifname = context.interface.c_str();
+        int index = if_nametoindex(ifname);
+
+        filter = sock_open(index, &ether_relay_fprog);
+
+        prepare_socket(&local_sock, &context);
+        prepare_server_socket(&server_sock, &context);
+        sockets.push_back(filter);
+        sockets.push_back(local_sock);
+        sockets.push_back(server_sock);
+
+        config.interface = context.interface;
+
+        prepare_relay_config(&config, local_sock, filter, &context);
+
+        evutil_make_listen_socket_reuseable(filter);
+        evutil_make_socket_nonblocking(filter);
+
+        evutil_make_listen_socket_reuseable(server_sock);
+        evutil_make_socket_nonblocking(server_sock);
+
+        base = event_base_new();
+        if(base == NULL) {
+            syslog(LOG_ERR, "libevent: Failed to create base\n");
+        }
 
-    base = event_base_new();
-    if(base == NULL) {
-        syslog(LOG_ERR, "libevent: Failed to create base\n");
-    }
+        listen_event = event_new(base, filter, EV_READ|EV_PERSIST, callback, (void *)&config);
+        server_listen_event = event_new(base, server_sock, EV_READ|EV_PERSIST, server_callback, (void *)&config);
+        if (listen_event == NULL || server_listen_event == NULL) {
+            syslog(LOG_ERR, "libevent: Failed to create libevent\n");
+        }
 
-    listen_event = event_new(base, filter, EV_READ|EV_PERSIST, callback, (void *)&config);
-    server_listen_event = event_new(base, server_sock, EV_READ|EV_PERSIST, server_callback, (void *)&config);
-    if (listen_event == NULL) {
-        syslog(LOG_ERR, "libevent: Failed to create libevent\n");
+        event_add(listen_event, NULL);
+        event_add(server_listen_event, NULL);
     }
-    if (server_listen_event == NULL) {
-        syslog(LOG_ERR, "libevent: Failed to create server listening libevent\n");
-    }
-    event_add(listen_event, NULL);
-    event_add(server_listen_event, NULL);
     
-
     if((signal_init() == 0) && signal_start() == 0) {
         shutdown();
-        close(local_sock);
+        for(std::size_t i = 0; i<sockets.size(); i++) {
+            close(sockets.at(i));
+        }
     }
 }
 
@@ -584,5 +591,6 @@ void shutdown() {
     event_del(ev_sigterm);
     event_free(ev_sigint); 
     event_free(ev_sigterm);
+    event_base_free(base);
     deinitialize_swss();
 }
diff --git a/src/dhcp6relay/src/relay.h b/src/dhcp6relay/src/relay.h
index 5acea33837d4..d32705e0be1b 100644
--- a/src/dhcp6relay/src/relay.h
+++ b/src/dhcp6relay/src/relay.h
@@ -91,7 +91,7 @@ void relay_client(int sock, const uint8_t *msg, int32_t len, const ip6_hdr *ip_h
 
 void relay_relay_reply(int sock, const uint8_t *msg, int32_t len, relay_config *configs);
 
-void loop_relay(arg_config *config);
+void loop_relay(std::vector<arg_config> *vlans);
 
 int signal_init();
 

From 3e9093d793f5940850885e2a45064dfaf33cd345 Mon Sep 17 00:00:00 2001
From: kellyyeh <kellyyeh@microsoft.com>
Date: Thu, 12 Aug 2021 20:00:27 +0000
Subject: [PATCH 07/16] Added DHCPv6 Counter and addressed PR comments

---
 src/dhcp6relay/Makefile                |   2 +-
 src/dhcp6relay/debian/rules            |   3 -
 src/dhcp6relay/src/configInterface.cpp |  35 +++--
 src/dhcp6relay/src/configInterface.h   |  52 ++++++-
 src/dhcp6relay/src/main.cpp            |   7 +-
 src/dhcp6relay/src/relay.cpp           | 130 ++++++++++++----
 src/dhcp6relay/src/relay.h             | 201 +++++++++++++++++++------
 7 files changed, 329 insertions(+), 101 deletions(-)

diff --git a/src/dhcp6relay/Makefile b/src/dhcp6relay/Makefile
index afb76932065c..4cbeb37fd188 100644
--- a/src/dhcp6relay/Makefile
+++ b/src/dhcp6relay/Makefile
@@ -5,7 +5,7 @@ MKDIR := mkdir
 CC := g++
 MV := mv
 LIBS := -levent -lhiredis -lswsscommon -pthread -lboost_thread -lboost_system -I $(PWD)/../sonic-swss-common/common
-CFLAGS  = -g -Wall
+CFLAGS  = -g -Wall -std=gnu11
 PWD := $(shell pwd)
 
 ifneq ($(MAKECMDGOALS),clean)
diff --git a/src/dhcp6relay/debian/rules b/src/dhcp6relay/debian/rules
index 00c628b6625f..ce2eb52beb5d 100755
--- a/src/dhcp6relay/debian/rules
+++ b/src/dhcp6relay/debian/rules
@@ -1,7 +1,4 @@
 #!/usr/bin/make -f
 
-DEB_CFLAGS_APPEND=-std=gnu11
-export DEB_CFLAGS_APPEND
-
 %:
 	dh $@ --parallel
diff --git a/src/dhcp6relay/src/configInterface.cpp b/src/dhcp6relay/src/configInterface.cpp
index 3c733c5f8a3f..68e2fce87dc6 100644
--- a/src/dhcp6relay/src/configInterface.cpp
+++ b/src/dhcp6relay/src/configInterface.cpp
@@ -5,15 +5,17 @@
 
 constexpr auto DEFAULT_TIMEOUT_MSEC = 1000;
 
-bool mPollSwssNotifcation = true;
+bool pollSwssNotifcation = true;
 std::shared_ptr<boost::thread> mSwssThreadPtr;
 
-//
-// ---> initialize();
-//
-// initialize DB tables and start SWSS listening thread
-//
-void initialize_swss(std::vector<arg_config> *vlans)
+/**
+ * @code                void deinitialize_swss()
+ * 
+ * @brief               initialize DB tables and start SWSS listening thread
+ *
+ * @return              none
+ */
+void initialize_swss(std::vector<arg_config> *vlans, swss::DBConnector *db)
 {
     try {
         mSwssThreadPtr = std::make_shared<boost::thread> (&handleSwssNotification, vlans);
@@ -23,11 +25,13 @@ void initialize_swss(std::vector<arg_config> *vlans)
     }
 }
 
-//
-// ---> deinitialize();
-//
-// deinitialize DB interface and join SWSS listening thread
-//
+/**
+ * @code                void deinitialize_swss()
+ * 
+ * @brief               deinitialize DB interface and join SWSS listening thread
+ *
+ * @return              none
+ */
 void deinitialize_swss()
 {
     stopSwssNotificationPoll();
@@ -47,10 +51,9 @@ void handleSwssNotification(std::vector<arg_config> *vlans)
 {
     std::shared_ptr<swss::DBConnector> configDbPtr = std::make_shared<swss::DBConnector> ("CONFIG_DB", 0);
     swss::SubscriberStateTable ipHelpersTable(configDbPtr.get(), "DHCP");
-
     swss::Select swssSelect;
     swssSelect.addSelectable(&ipHelpersTable);
-    while (mPollSwssNotifcation) {
+    while (pollSwssNotifcation) {
         swss::Selectable *selectable;
         int ret = swssSelect.select(&selectable, DEFAULT_TIMEOUT_MSEC);
         if (ret == swss::Select::ERROR) {
@@ -125,8 +128,8 @@ void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries,
                         intf.is_option_79 = true;
                 }
             }
-            vlans->push_back(intf);
         }
+        vlans->push_back(intf);
     }
 }
 
@@ -138,5 +141,5 @@ void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries,
 *@return    none
 */
 void stopSwssNotificationPoll() {
-    mPollSwssNotifcation = false;
+    pollSwssNotifcation = false;
 };
diff --git a/src/dhcp6relay/src/configInterface.h b/src/dhcp6relay/src/configInterface.h
index 66ee3ac74f80..53f529b4fa0f 100644
--- a/src/dhcp6relay/src/configInterface.h
+++ b/src/dhcp6relay/src/configInterface.h
@@ -3,14 +3,64 @@
 #include "select.h"
 #include "relay.h"
 
-void initialize_swss(std::vector<arg_config> *vlans);
+/**
+ * @code                void deinitialize_swss()
+ * 
+ * @brief               initialize DB tables and start SWSS listening thread
+ *
+ * @return              none
+ */
+void initialize_swss(std::vector<arg_config> *vlans, swss::DBConnector *db);
 
+/**
+ * @code                void deinitialize_swss()
+ * 
+ * @brief               deinitialize DB interface and join SWSS listening thread
+ *
+ * @return              none
+ */
 void deinitialize_swss();
 
+/**
+ * @code                void handleSwssNotification(std::vector<arg_config> *vlans)
+ * 
+ * @brief               main thread for handling SWSS notification
+ *
+ * @param context       list of vlans/argument config that contains strings of server and option
+ *
+ * @return              none
+ */
 void handleSwssNotification(std::vector<arg_config> *vlans);
 
+/**
+ * @code                    void handleRelayNotification(swss::SubscriberStateTable &ipHelpersTable, std::vector<arg_config> *vlans)
+ * 
+ * @brief                   handles DHCPv6 relay configuration change notification
+ *
+ * @param ipHelpersTable    DHCP table
+ * @param context           list of vlans/argument config that contains strings of server and option
+ *
+ * @return                  none
+ */
 void handleRelayNotification(swss::SubscriberStateTable &configMuxTable, std::vector<arg_config> *vlans);
 
+/**
+ * @code                    void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, std::vector<arg_config> *vlans)
+ * 
+ * @brief                   process DHCPv6 relay servers and options configuration change notification
+ *
+ * @param entries           queue of std::tuple<std::string, std::string, std::vector<FieldValueTuple>> entries in DHCP table
+ * @param context           list of vlans/argument config that contains strings of server and option
+ *
+ * @return                  none
+ */
 void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, std::vector<arg_config> *vlans);
 
+/**
+*@code      stopSwssNotificationPoll
+*
+*@brief     stop SWSS listening thread
+*
+*@return    none
+*/
 void stopSwssNotificationPoll();
diff --git a/src/dhcp6relay/src/main.cpp b/src/dhcp6relay/src/main.cpp
index 2b08d8dd3f2e..af4894ed3f4a 100644
--- a/src/dhcp6relay/src/main.cpp
+++ b/src/dhcp6relay/src/main.cpp
@@ -4,12 +4,13 @@
 int main(int argc, char *argv[]) {
     try {
         std::vector<arg_config> vlans;
-        initialize_swss(&vlans);
-        loop_relay(&vlans);
+        swss::DBConnector state_db(6, "localhost", 6379, 0);
+        initialize_swss(&vlans, &state_db);
+        loop_relay(&vlans, &state_db);
     }
     catch (std::exception &e)
     {
-        printf("Usage: -i <interface> -o <option>\n");
+        printf("An exception occurred.\n");
         return 1;
     }
     return 0;
diff --git a/src/dhcp6relay/src/relay.cpp b/src/dhcp6relay/src/relay.cpp
index c6ac084ce57a..3f7aa57feb9e 100644
--- a/src/dhcp6relay/src/relay.cpp
+++ b/src/dhcp6relay/src/relay.cpp
@@ -20,6 +20,66 @@ struct event_base *base;
 struct event *ev_sigint;
 struct event *ev_sigterm;
 
+/* DHCPv6 filter */
+/* sudo tcpdump -dd "ip6 dst ff02::1:2 && udp dst port 547" */
+
+static struct sock_filter ether_relay_filter[] = {
+	
+	{ 0x28, 0, 0, 0x0000000c },
+	{ 0x15, 0, 13, 0x000086dd },
+	{ 0x20, 0, 0, 0x00000026 },
+	{ 0x15, 0, 11, 0xff020000 },
+	{ 0x20, 0, 0, 0x0000002a },
+	{ 0x15, 0, 9, 0x00000000 },
+	{ 0x20, 0, 0, 0x0000002e },
+	{ 0x15, 0, 7, 0x00000000 },
+	{ 0x20, 0, 0, 0x00000032 },
+	{ 0x15, 0, 5, 0x00010002 },
+	{ 0x30, 0, 0, 0x00000014 },
+	{ 0x15, 0, 3, 0x00000011 },
+	{ 0x28, 0, 0, 0x00000038 },
+	{ 0x15, 0, 1, 0x00000223 },
+	{ 0x6, 0, 0, 0x00040000 },
+	{ 0x6, 0, 0, 0x00000000 },
+};
+const struct sock_fprog ether_relay_fprog = {
+	lengthof(ether_relay_filter),
+	ether_relay_filter
+};
+
+/* DHCPv6 Counter */
+uint64_t counters[DHCPv6_MESSAGE_TYPE_COUNT];
+
+/**
+ * @code                void update_counter(swss::DBConnector *db);
+ *
+ * @brief               update the counter in state_db with count of each DHCPv6 message type
+ *
+ * @param swss::DBConnector *db     state_db connector
+ * 
+ * @return              none
+ */
+void update_counter(swss::DBConnector *db) {
+    db->hset("DHCPv6_Counter", "Solicit", toString(counters[DHCPv6_MESSAGE_TYPE_SOLICIT]));
+    db->hset("DHCPv6_Counter", "Advertise", toString(counters[DHCPv6_MESSAGE_TYPE_ADVERTISE]));
+    db->hset("DHCPv6_Counter", "Request", toString(counters[DHCPv6_MESSAGE_TYPE_REQUEST]));
+    db->hset("DHCPv6_Counter", "Confirm", toString(counters[DHCPv6_MESSAGE_TYPE_CONFIRM]));
+    db->hset("DHCPv6_Counter", "Renew", toString(counters[DHCPv6_MESSAGE_TYPE_RENEW]));
+    db->hset("DHCPv6_Counter", "Rebind", toString(counters[DHCPv6_MESSAGE_TYPE_REBIND]));
+    db->hset("DHCPv6_Counter", "Reply", toString(counters[DHCPv6_MESSAGE_TYPE_REPLY]));
+    db->hset("DHCPv6_Counter", "Release", toString(counters[DHCPv6_MESSAGE_TYPE_RELEASE]));
+    db->hset("DHCPv6_Counter", "Decline", toString(counters[DHCPv6_MESSAGE_TYPE_DECLINE]));
+    db->hset("DHCPv6_Counter", "Relay-Forward", toString(counters[DHCPv6_MESSAGE_TYPE_RELAY_FORW]));
+    db->hset("DHCPv6_Counter", "Relay-Reply", toString(counters[DHCPv6_MESSAGE_TYPE_RELAY_REPL]));
+}
+
+std::string toString(uint16_t count) {
+    std::stringstream ss;
+    ss << count;
+    std::string countValue = ss.str();
+    return countValue;
+}
+
 bool is_addr_gua(in6_addr addr) {
 
     auto masked = addr.__in6_u.__u6_addr8[0] & 0xe0;
@@ -181,12 +241,12 @@ void prepare_relay_config(relay_config *interface_config, int local_sock, int fi
     addr[0] = 0;
 
     if (getifaddrs(&ifa) == -1) {
-		syslog(LOG_WARNING, "getifaddrs: Unable to get network interfaces\n");
+        syslog(LOG_WARNING, "getifaddrs: Unable to get network interfaces\n");
         exit(1);
-	}
+    }
 
     ifa_tmp = ifa;
-	while (ifa_tmp) {
+    while (ifa_tmp) {
 		if ((ifa_tmp->ifa_addr) && (ifa_tmp->ifa_addr->sa_family == AF_INET6)) {
             struct sockaddr_in6 *in6 = (struct sockaddr_in6*) ifa_tmp->ifa_addr;
             inet_ntop(AF_INET6, &in6->sin6_addr, addr, sizeof(addr));
@@ -231,25 +291,25 @@ void prepare_socket(int *local_sock, arg_config *context) {
     tmp[0] = 0;
 
     if (getifaddrs(&ifa) == -1) {
-            syslog(LOG_WARNING, "getifaddrs: Unable to get network interfaces\n");
-            exit(1);
+        syslog(LOG_WARNING, "getifaddrs: Unable to get network interfaces\n");
+        exit(1);
     } 
 
     ifa_tmp = ifa;
     while (ifa_tmp) {
-            if ((ifa_tmp->ifa_addr) && (ifa_tmp->ifa_addr->sa_family == AF_INET6)) {                  
-                struct sockaddr_in6 *in6 = (struct sockaddr_in6*) ifa_tmp->ifa_addr;
-                inet_ntop(AF_INET6, &in6->sin6_addr, tmp, sizeof(tmp));
-                if(strcmp(ifa_tmp->ifa_name, context->interface.c_str()) == 0 && (is_addr_gua(in6->sin6_addr))) {
-                    inet_pton(AF_INET6, tmp, &addr.sin6_addr);
-                }
-                else {
-                    syslog(LOG_ERR, "inet_pton: interface global address not configured\n");
-                    sleep(10);
-                    continue;
-                }
+        if ((ifa_tmp->ifa_addr) && (ifa_tmp->ifa_addr->sa_family == AF_INET6)) {                  
+            struct sockaddr_in6 *in6 = (struct sockaddr_in6*) ifa_tmp->ifa_addr;
+            inet_ntop(AF_INET6, &in6->sin6_addr, tmp, sizeof(tmp));
+            if(strcmp(ifa_tmp->ifa_name, context->interface.c_str()) == 0 && (is_addr_gua(in6->sin6_addr))) {
+                inet_pton(AF_INET6, tmp, &addr.sin6_addr);
+            }
+            else {
+                syslog(LOG_ERR, "inet_pton: interface global address not configured\n");
+                sleep(10);
+                continue;
             }
-            ifa_tmp = ifa_tmp->ifa_next;
+        }
+        ifa_tmp = ifa_tmp->ifa_next;
     }
     freeifaddrs(ifa);   */
 
@@ -264,6 +324,16 @@ void prepare_socket(int *local_sock, arg_config *context) {
     }    
 }
 
+/**
+ * @code                prepare_server_socket(int *server_sock, arg_config *context);
+ * 
+ * @brief               prepare L3 socket for sending
+ *
+ * @param server_sock   pointer to socket receiving server packets to be prepared
+ * @param context       argument config that contains strings of server and interface addresses
+ *
+ * @return              none
+ */
 void prepare_server_socket(int *server_sock, arg_config *context) {
     sockaddr_in6 addr;
     memset(&addr, 0, sizeof(addr));
@@ -300,7 +370,7 @@ void relay_client(int sock, const uint8_t *msg, int32_t len, const ip6_hdr *ip_h
     uint8_t buffer[4096];
     auto current_buffer_position = buffer;
     dhcpv6_relay_msg new_message;
-    new_message.msg_type = RELAY_FORW;
+    new_message.msg_type = DHCPv6_MESSAGE_TYPE_RELAY_FORW;
     memcpy(&new_message.peer_address, &ip_hdr->ip6_src, sizeof(in6_addr));
     new_message.hop_count = 0;
 
@@ -418,23 +488,27 @@ void callback(evutil_socket_t fd, short event, void *arg) {
     auto udp_header = parse_udp(current_position, &tmp);
     current_position = tmp;
 
-    if ((ntohs(udp_header->dest)) == RELAY_PORT) {
-        relay_client(config->local_sock, current_position, ntohs(udp_header->len) - sizeof(udphdr), ip_header, ether_header, config);
-    }
+    auto msg = parse_dhcpv6_hdr(current_position);
+    counters[msg->msg_type]++;
+    update_counter(config->db);
+    relay_client(config->local_sock, current_position, ntohs(udp_header->len) - sizeof(udphdr), ip_header, ether_header, config);
 }
 
 void server_callback(evutil_socket_t fd, short event, void *arg) {
     struct relay_config *config = (struct relay_config *)arg;
     sockaddr_in6 from;
     int32_t data = 0;
-    uint8_t message_buffer[4096];
+    static uint8_t message_buffer[4096];
 
     if ((data = recvfrom(config->local_sock, message_buffer, 4096, 0, (sockaddr *)&from, (socklen_t *)sizeof(from))) == -1) {
         syslog(LOG_WARNING, "recv: Failed to receive data from server\n");
     }
 
     auto msg = parse_dhcpv6_hdr(message_buffer);
-    if (msg->msg_type == RELAY_REPL) {
+
+    counters[msg->msg_type]++;
+    update_counter(config->db);
+    if (msg->msg_type == DHCPv6_MESSAGE_TYPE_RELAY_REPL) {
         relay_relay_reply(config->local_sock, message_buffer, data, config);
     }
 }
@@ -523,16 +597,17 @@ void dhcp6relay_stop()
 }
 
 /**
- * @code                loop_relay(std::vector<arg_config> *vlans);
+ * @code                loop_relay(std::vector<arg_config> *vlans, swss::DBConnector *db);
  * 
  * @brief               main loop: configure sockets, create libevent base, start server listener thread
- *
+ *  
  * @param vlans         list of vlans retrieved from config_db
+ * @param db            state_db connector
  */
-void loop_relay(std::vector<arg_config> *vlans) {
+void loop_relay(std::vector<arg_config> *vlans, swss::DBConnector *db) {
     std::vector<int> sockets;
     for(std::size_t i = 0; i<vlans->size(); i++) {
-        arg_config context = vlans->at(i);
+        struct arg_config context = vlans->at(i);
         struct relay_config config;
         int filter = 0;
         int local_sock = 0; 
@@ -549,6 +624,7 @@ void loop_relay(std::vector<arg_config> *vlans) {
         sockets.push_back(server_sock);
 
         config.interface = context.interface;
+        config.db = db;
 
         prepare_relay_config(&config, local_sock, filter, &context);
 
diff --git a/src/dhcp6relay/src/relay.h b/src/dhcp6relay/src/relay.h
index d32705e0be1b..1947b7a840bf 100644
--- a/src/dhcp6relay/src/relay.h
+++ b/src/dhcp6relay/src/relay.h
@@ -9,8 +9,7 @@
 #include <string>
 #include <vector>
 #include <event2/util.h>
-#include <memory>
-#include <thread>
+
 
 #define PACKED __attribute__ ((packed))
 
@@ -20,21 +19,26 @@
 
 #define lengthof(A) (sizeof (A) / sizeof (A)[0])
 
-#define SOLICIT 1
-#define REQUEST 3
-#define CONFIRM 4
-#define RENEW 5
-#define REBIND 6
-#define RELEASE 8 
-#define DECLINE 9
-#define RELAY_FORW 12
-#define RELAY_REPL 13
 #define OPTION_RELAY_MSG 9
 #define OPTION_CLIENT_LINKLAYER_ADDR 79
 
-
-/* Configuration */
-static std::string config_interface;
+/* DHCPv6 message types */
+typedef enum
+{
+    DHCPv6_MESSAGE_TYPE_SOLICIT = 1,
+    DHCPv6_MESSAGE_TYPE_ADVERTISE = 2,
+    DHCPv6_MESSAGE_TYPE_REQUEST = 3,
+    DHCPv6_MESSAGE_TYPE_CONFIRM  = 4,
+    DHCPv6_MESSAGE_TYPE_RENEW  = 5,
+    DHCPv6_MESSAGE_TYPE_REBIND = 6,
+    DHCPv6_MESSAGE_TYPE_REPLY = 7,
+    DHCPv6_MESSAGE_TYPE_RELEASE = 8,
+    DHCPv6_MESSAGE_TYPE_DECLINE = 9,
+    DHCPv6_MESSAGE_TYPE_RELAY_FORW = 12,
+    DHCPv6_MESSAGE_TYPE_RELAY_REPL = 13,
+
+    DHCPv6_MESSAGE_TYPE_COUNT
+} dhcp_message_type_t;
 
 struct arg_config {
     std::vector<std::string> servers;
@@ -46,6 +50,7 @@ struct relay_config {
     int local_sock; 
     int filter;
     sockaddr_in6 link_address;
+    swss::DBConnector *db;
     std::string interface;
     std::vector<sockaddr_in6> servers;
     bool is_option_79;
@@ -77,35 +82,165 @@ struct linklayer_addr_option  {
     uint16_t link_layer_type;
 };
 
+/**
+ * @code                sock_open(int ifindex, const struct sock_fprog *fprog);
+ *
+ * @brief               prepare L2 socket to attach to "udp and port 547" filter 
+ *
+ * @param ifindex       interface index
+ * @param fprog         bpf filter "udp and port 547"
+ *
+ * @return              socket descriptor
+ */
 int sock_open(int ifindex, const struct sock_fprog *fprog);
 
+/**
+ * @code                prepare_socket(int *local_sock, arg_config *context);
+ * 
+ * @brief               prepare L3 socket for sending
+ *
+ * @param local_sock    pointer to socket to be prepared
+ * @param context       argument config that contains strings of server and interface addresses
+ *
+ * @return              none
+ */
 void prepare_socket(int *local_sock, arg_config *config);
 
+/**
+ * @code                prepare_server_socket(int *server_sock, arg_config *context);
+ * 
+ * @brief               prepare L3 socket for sending
+ *
+ * @param server_sock   pointer to socket receiving server packets to be prepared
+ * @param context       argument config that contains strings of server and interface addresses
+ *
+ * @return              none
+ */
 void prepare_server_socket(int *server_sock, arg_config *context);
 
+/**
+ * @code                        prepare_relay_config(relay_config *interface_config, int fd, const arg_config *context);
+ * 
+ * @brief                       prepare for specified relay interface config: server and link address
+ *
+ * @param interface_config      pointer to relay config to be prepared
+ * @param local_sock            L3 socket used for relaying messages
+ * @param filter                socket attached with filter
+ * @param config                argument config that contains strings of server and interface addresses
+ *
+ * @return                      none
+ */
 void prepare_relay_config(relay_config *interface_config, int local_sock, int filter, const arg_config *context);
 
+/**
+ * @code                relay_forward(uint8_t *buffer, const struct dhcpv6_msg *msg, uint16_t msg_length);
+ *
+ * @brief               embed the DHCPv6 message received into DHCPv6 relay forward message
+ *
+ * @param buffer        pointer to buffer
+ * @param msg           pointer to parsed DHCPv6 message
+ * @param msg_length    length of DHCPv6 message
+ *
+ * @return              none
+ */
 void relay_forward(uint8_t *buffer, const struct dhcpv6_msg *msg, uint16_t msg_length);
 
+/**
+ * @code                 relay_client(int sock, const uint8_t *msg, int32_t len, ip6_hdr *ip_hdr, const ether_header *ether_hdr, relay_config *config);
+ * 
+ * @brief                construct relay-forward message
+ *
+ * @param sock           L3 socket for sending data to servers
+ * @param msg            pointer to dhcpv6 message header position
+ * @param len            size of data received
+ * @param ip_hdr         pointer to IPv6 header
+ * @param ether_hdr      pointer to Ethernet header
+ * @param config         pointer to the relay interface config
+ *
+ * @return none
+ */
 void relay_client(int sock, const uint8_t *msg, int32_t len, const ip6_hdr *ip_hdr, const ether_header *ether_hdr, relay_config *config);
 
+/**
+ * @code                relay_relay_reply(int sock, const uint8_t *msg, int32_t len, relay_config *configs);
+ * 
+ * @brief               relay and unwrap a relay-reply message
+ *
+ * @param sock          L3 socket for sending data to servers
+ * @param msg           pointer to dhcpv6 message header position
+ * @param len           size of data received
+ * @param config        relay interface config
+ *
+ * @return              none
+ */
 void relay_relay_reply(int sock, const uint8_t *msg, int32_t len, relay_config *configs);
 
-void loop_relay(std::vector<arg_config> *vlans);
-
+/**
+ * @code                loop_relay(std::vector<arg_config> *vlans, swss::DBConnector *db);
+ * 
+ * @brief               main loop: configure sockets, create libevent base, start server listener thread
+ *  
+ * @param vlans         list of vlans retrieved from config_db
+ * @param db            state_db connector
+ */
+void loop_relay(std::vector<arg_config> *vlans, swss::DBConnector *db);
+
+/**
+ * @code signal_init();
+ *
+ * @brief initialize DHCPv6 Relay libevent signals
+ */
 int signal_init();
 
+/**
+ * @code signal_start();
+ *
+ * @brief start DHCPv6 Relay libevent base and add signals
+ */
 int signal_start();
 
+/**
+ * @code dhcp6relay_stop();
+ *
+ * @brief stop DHCPv6 Relay libevent loop upon signal
+ */
 void dhcp6relay_stop();
 
+/**
+ * @code signal_callback(fd, event, arg);
+ *
+ * @brief signal handler for dhcp6relay. Initiate shutdown when signal is caught
+ *
+ * @param fd        libevent socket
+ * @param event     event triggered
+ * @param arg       pointer to libevent base
+ *
+ * @return none
+ */
 void signal_callback(evutil_socket_t fd, short event, void *arg);
 
+/**
+ * @code shutdown();
+ *
+ * @brief free signals and terminate threads
+ */
 void shutdown();
 
+/**
+ * @code                void update_counter(swss::DBConnector *db);
+ *
+ * @brief               update the counter in state_db with count of each DHCPv6 message type
+ *
+ * @param swss::DBConnector *db     state_db connector
+ * 
+ * @return              none
+ */
+void update_counter(swss::DBConnector *db);
 
 /* Helper functions */
 
+std::string toString(uint16_t count);
+
 bool is_addr_gua(in6_addr addr);
 
 bool is_addr_link_local(in6_addr addr);
@@ -124,37 +259,3 @@ const struct dhcpv6_option *parse_dhcpv6_opt(const uint8_t *buffer, const uint8_
 
 void send_udp(int sock, struct sockaddr_in6 target, uint8_t *buffer, uint32_t n);
 
-struct ArgumentException : std::exception {
-    std::string msg;
-    ArgumentException(std::string message) : msg(message) {}
-    ~ArgumentException() throw() {}
-    const char* what() const throw() { return msg.c_str(); }
-};
-
-
-/* DHCPv6 filter */
-/* sudo tcpdump -dd "ip6 dst ff02::1:2 && udp dst port 547" */
-
-static struct sock_filter ether_relay_filter[] = {
-	
-	{ 0x28, 0, 0, 0x0000000c },
-	{ 0x15, 0, 13, 0x000086dd },
-	{ 0x20, 0, 0, 0x00000026 },
-	{ 0x15, 0, 11, 0xff020000 },
-	{ 0x20, 0, 0, 0x0000002a },
-	{ 0x15, 0, 9, 0x00000000 },
-	{ 0x20, 0, 0, 0x0000002e },
-	{ 0x15, 0, 7, 0x00000000 },
-	{ 0x20, 0, 0, 0x00000032 },
-	{ 0x15, 0, 5, 0x00010002 },
-	{ 0x30, 0, 0, 0x00000014 },
-	{ 0x15, 0, 3, 0x00000011 },
-	{ 0x28, 0, 0, 0x00000038 },
-	{ 0x15, 0, 1, 0x00000223 },
-	{ 0x6, 0, 0, 0x00040000 },
-	{ 0x6, 0, 0, 0x00000000 },
-};
-const struct sock_fprog ether_relay_fprog = {
-	lengthof(ether_relay_filter),
-	ether_relay_filter
-};

From 56dcedcd6845bc81e16500054db8781b002a2cf4 Mon Sep 17 00:00:00 2001
From: kellyyeh <kellyyeh@microsoft.com>
Date: Tue, 17 Aug 2021 16:17:14 +0000
Subject: [PATCH 08/16] Addressed PR comments, removed arg_config

---
 src/dhcp6relay/src/configInterface.cpp |  57 +++++---
 src/dhcp6relay/src/configInterface.h   |  23 ++-
 src/dhcp6relay/src/main.cpp            |   7 +-
 src/dhcp6relay/src/relay.cpp           | 186 ++++++++++++++++++-------
 src/dhcp6relay/src/relay.h             | 126 ++++++++++++++---
 5 files changed, 299 insertions(+), 100 deletions(-)

diff --git a/src/dhcp6relay/src/configInterface.cpp b/src/dhcp6relay/src/configInterface.cpp
index 68e2fce87dc6..66af62c54dc0 100644
--- a/src/dhcp6relay/src/configInterface.cpp
+++ b/src/dhcp6relay/src/configInterface.cpp
@@ -8,6 +8,10 @@ constexpr auto DEFAULT_TIMEOUT_MSEC = 1000;
 bool pollSwssNotifcation = true;
 std::shared_ptr<boost::thread> mSwssThreadPtr;
 
+std::shared_ptr<swss::DBConnector> configDbPtr = std::make_shared<swss::DBConnector> ("CONFIG_DB", 0);
+swss::SubscriberStateTable ipHelpersTable(configDbPtr.get(), "DHCP_RELAY");
+swss::Select swssSelect;
+
 /**
  * @code                void deinitialize_swss()
  * 
@@ -15,9 +19,11 @@ std::shared_ptr<boost::thread> mSwssThreadPtr;
  *
  * @return              none
  */
-void initialize_swss(std::vector<arg_config> *vlans, swss::DBConnector *db)
+void initialize_swss(std::vector<relay_config> *vlans, swss::DBConnector *db)
 {
     try {
+        swssSelect.addSelectable(&ipHelpersTable);
+        get_dhcp(vlans);
         mSwssThreadPtr = std::make_shared<boost::thread> (&handleSwssNotification, vlans);
     }
     catch (const std::bad_alloc &e) {
@@ -38,8 +44,27 @@ void deinitialize_swss()
     mSwssThreadPtr->interrupt();
 }
 
+
 /**
- * @code                void handleSwssNotification(std::vector<arg_config> *vlans)
+ * @code                void get_dhcp(std::vector<relay_config> *vlans)
+ * 
+ * @brief               initialize and get vlan table information from DHCP_RELAY
+ *
+ * @return              none
+ */
+void get_dhcp(std::vector<relay_config> *vlans) {
+    swss::Selectable *selectable;
+    int ret = swssSelect.select(&selectable, DEFAULT_TIMEOUT_MSEC);
+    if (ret == swss::Select::ERROR) {
+        syslog(LOG_WARNING, "Select: returned ERROR");
+    } else if (ret == swss::Select::TIMEOUT) {
+    } 
+    if (selectable == static_cast<swss::Selectable *> (&ipHelpersTable)) {
+        handleRelayNotification(ipHelpersTable, vlans);
+    }
+}
+/**
+ * @code                void handleSwssNotification(std::vector<relay_config> *vlans)
  * 
  * @brief               main thread for handling SWSS notification
  *
@@ -47,29 +72,15 @@ void deinitialize_swss()
  *
  * @return              none
  */
-void handleSwssNotification(std::vector<arg_config> *vlans)
+void handleSwssNotification(std::vector<relay_config> *vlans)
 {
-    std::shared_ptr<swss::DBConnector> configDbPtr = std::make_shared<swss::DBConnector> ("CONFIG_DB", 0);
-    swss::SubscriberStateTable ipHelpersTable(configDbPtr.get(), "DHCP");
-    swss::Select swssSelect;
-    swssSelect.addSelectable(&ipHelpersTable);
     while (pollSwssNotifcation) {
-        swss::Selectable *selectable;
-        int ret = swssSelect.select(&selectable, DEFAULT_TIMEOUT_MSEC);
-        if (ret == swss::Select::ERROR) {
-            syslog(LOG_WARNING, "Select: returned ERROR");
-            continue;
-        } else if (ret == swss::Select::TIMEOUT) {
-            continue;
-        } 
-        if (selectable == static_cast<swss::Selectable *> (&ipHelpersTable)) {
-            handleRelayNotification(ipHelpersTable, vlans);
-        }
+        get_dhcp(vlans);
     } 
 }
 
 /**
- * @code                    void handleRelayNotification(swss::SubscriberStateTable &ipHelpersTable, std::vector<arg_config> *vlans)
+ * @code                    void handleRelayNotification(swss::SubscriberStateTable &ipHelpersTable, std::vector<relay_config> *vlans)
  * 
  * @brief                   handles DHCPv6 relay configuration change notification
  *
@@ -78,7 +89,7 @@ void handleSwssNotification(std::vector<arg_config> *vlans)
  *
  * @return                  none
  */
-void handleRelayNotification(swss::SubscriberStateTable &ipHelpersTable, std::vector<arg_config> *vlans)
+void handleRelayNotification(swss::SubscriberStateTable &ipHelpersTable, std::vector<relay_config> *vlans)
 {
     std::deque<swss::KeyOpFieldsValuesTuple> entries;
 
@@ -87,7 +98,7 @@ void handleRelayNotification(swss::SubscriberStateTable &ipHelpersTable, std::ve
 }
 
 /**
- * @code                    void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, std::vector<arg_config> *vlans)
+ * @code                    void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, std::vector<relay_config> *vlans)
  * 
  * @brief                   process DHCPv6 relay servers and options configuration change notification
  *
@@ -96,7 +107,7 @@ void handleRelayNotification(swss::SubscriberStateTable &ipHelpersTable, std::ve
  *
  * @return                  none
  */
-void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, std::vector<arg_config> *vlans)
+void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, std::vector<relay_config> *vlans)
 {
     std::vector<std::string> servers;
 
@@ -105,7 +116,7 @@ void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries,
         std::string operation = kfvOp(entry);
         std::vector<swss::FieldValueTuple> fieldValues = kfvFieldsValues(entry);
 
-        arg_config intf;
+        relay_config intf;
         intf.interface = vlan;
         for (auto &fieldValue: fieldValues) {
             std::string f = fvField(fieldValue);
diff --git a/src/dhcp6relay/src/configInterface.h b/src/dhcp6relay/src/configInterface.h
index 53f529b4fa0f..dfd5eb668e0e 100644
--- a/src/dhcp6relay/src/configInterface.h
+++ b/src/dhcp6relay/src/configInterface.h
@@ -10,7 +10,7 @@
  *
  * @return              none
  */
-void initialize_swss(std::vector<arg_config> *vlans, swss::DBConnector *db);
+void initialize_swss(std::vector<relay_config> *vlans, swss::DBConnector *db);
 
 /**
  * @code                void deinitialize_swss()
@@ -22,7 +22,16 @@ void initialize_swss(std::vector<arg_config> *vlans, swss::DBConnector *db);
 void deinitialize_swss();
 
 /**
- * @code                void handleSwssNotification(std::vector<arg_config> *vlans)
+ * @code                void get_dhcp(std::vector<relay_config> *vlans)
+ * 
+ * @brief               initialize and get vlan information from DHCP_RELAY
+ *
+ * @return              none
+ */
+void get_dhcp(std::vector<relay_config> *vlans);
+
+/**
+ * @code                void handleSwssNotification(std::vector<relay_config> *vlans)
  * 
  * @brief               main thread for handling SWSS notification
  *
@@ -30,10 +39,10 @@ void deinitialize_swss();
  *
  * @return              none
  */
-void handleSwssNotification(std::vector<arg_config> *vlans);
+void handleSwssNotification(std::vector<relay_config> *vlans);
 
 /**
- * @code                    void handleRelayNotification(swss::SubscriberStateTable &ipHelpersTable, std::vector<arg_config> *vlans)
+ * @code                    void handleRelayNotification(swss::SubscriberStateTable &ipHelpersTable, std::vector<relay_config> *vlans)
  * 
  * @brief                   handles DHCPv6 relay configuration change notification
  *
@@ -42,10 +51,10 @@ void handleSwssNotification(std::vector<arg_config> *vlans);
  *
  * @return                  none
  */
-void handleRelayNotification(swss::SubscriberStateTable &configMuxTable, std::vector<arg_config> *vlans);
+void handleRelayNotification(swss::SubscriberStateTable &configMuxTable, std::vector<relay_config> *vlans);
 
 /**
- * @code                    void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, std::vector<arg_config> *vlans)
+ * @code                    void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, std::vector<relay_config> *vlans)
  * 
  * @brief                   process DHCPv6 relay servers and options configuration change notification
  *
@@ -54,7 +63,7 @@ void handleRelayNotification(swss::SubscriberStateTable &configMuxTable, std::ve
  *
  * @return                  none
  */
-void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, std::vector<arg_config> *vlans);
+void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries, std::vector<relay_config> *vlans);
 
 /**
 *@code      stopSwssNotificationPoll
diff --git a/src/dhcp6relay/src/main.cpp b/src/dhcp6relay/src/main.cpp
index af4894ed3f4a..860e4d1346d8 100644
--- a/src/dhcp6relay/src/main.cpp
+++ b/src/dhcp6relay/src/main.cpp
@@ -1,16 +1,17 @@
 #include <stdlib.h>
+#include <syslog.h>
 #include "configInterface.h"
 
 int main(int argc, char *argv[]) {
     try {
-        std::vector<arg_config> vlans;
-        swss::DBConnector state_db(6, "localhost", 6379, 0);
+        std::vector<relay_config> vlans;
+        swss::DBConnector state_db("STATE_DB", 0);
         initialize_swss(&vlans, &state_db);
         loop_relay(&vlans, &state_db);
     }
     catch (std::exception &e)
     {
-        printf("An exception occurred.\n");
+        syslog(LOG_ERR, "An exception occurred.\n");
         return 1;
     }
     return 0;
diff --git a/src/dhcp6relay/src/relay.cpp b/src/dhcp6relay/src/relay.cpp
index 3f7aa57feb9e..7e9cac18bf22 100644
--- a/src/dhcp6relay/src/relay.cpp
+++ b/src/dhcp6relay/src/relay.cpp
@@ -1,4 +1,3 @@
-#include <getopt.h>
 #include <errno.h>
 #include <unistd.h>
 #include <event.h>
@@ -73,6 +72,15 @@ void update_counter(swss::DBConnector *db) {
     db->hset("DHCPv6_Counter", "Relay-Reply", toString(counters[DHCPv6_MESSAGE_TYPE_RELAY_REPL]));
 }
 
+/**
+ * @code                std::string toString(uint16_t count);
+ *
+ * @brief               convert uint16_t to string
+ *
+ * @param count         count of messages in counter
+ * 
+ * @return              count in string
+ */
 std::string toString(uint16_t count) {
     std::stringstream ss;
     ss << count;
@@ -80,40 +88,117 @@ std::string toString(uint16_t count) {
     return countValue;
 }
 
+/**
+ * @code                bool is_addr_gua(in6_addr addr);
+ *
+ * @brief               check if address is global
+ *
+ * @param addr         ipv6 address
+ * 
+ * @return              bool
+ */
 bool is_addr_gua(in6_addr addr) {
-
     auto masked = addr.__in6_u.__u6_addr8[0] & 0xe0;
     return (masked ^ 0x20) == 0x00;
 }
 
+/**
+ * @code                is_addr_link_local(in6_addr addr);
+ *
+ * @brief               check if address is link_local
+ *
+ * @param addr         ipv6 address
+ * 
+ * @return              bool
+ */
 bool is_addr_link_local(in6_addr addr)  {
     auto masked = ntohs(addr.__in6_u.__u6_addr16[0]) & 0xffc0;
     return (masked ^ 0xfe80) == 0x0000;
 }
 
+/**
+ * @code                const struct ether_header *parse_ether_frame(const uint8_t *buffer, const uint8_t **out_end);
+ *
+ * @brief               parse through ethernet frame
+ *
+ * @param *buffer       message buffer
+ * @param **out_end     pointer
+ * 
+ * @return ether_header end of ethernet header position
+ */
 const struct ether_header *parse_ether_frame(const uint8_t *buffer, const uint8_t **out_end) {
     (*out_end) = buffer + sizeof(struct ether_header);
     return (const struct ether_header *)buffer;
 }
 
+/**
+ * @code                const struct ip6_hdr *parse_ip6_hdr(const uint8_t *buffer, const uint8_t **out_end);
+ *
+ * @brief               parse through ipv6 header
+ *
+ * @param *buffer       message buffer
+ * @param **out_end     pointer
+ * 
+ * @return ip6_hdr      end of ipv6 header position
+ */
 const struct ip6_hdr *parse_ip6_hdr(const uint8_t *buffer, const uint8_t **out_end) {
     (*out_end) = buffer + sizeof(struct ip6_hdr);
     return (struct ip6_hdr *)buffer;
 }
 
+/**
+ * @code                const struct udphdr *parse_udp(const uint8_t *buffer, const uint8_t **out_end);
+ *
+ * @brief               parse through udp header
+ *
+ * @param *buffer       message buffer
+ * @param **out_end     pointer
+ * 
+ * @return udphdr      end of udp header position
+ */
 const struct udphdr *parse_udp(const uint8_t *buffer, const uint8_t **out_end) {
     (*out_end) = buffer + sizeof(struct udphdr);
     return (const struct udphdr *)buffer;
 }
 
+/**
+ * @code                const struct dhcpv6_msg *parse_dhcpv6_hdr(const uint8_t *buffer);
+ *
+ * @brief               parse through dhcpv6 header
+ *
+ * @param *buffer       message buffer
+ * @param **out_end     pointer
+ * 
+ * @return dhcpv6_msg   end of dhcpv6 header position
+ */
 const struct dhcpv6_msg *parse_dhcpv6_hdr(const uint8_t *buffer) {
     return (const struct dhcpv6_msg *)buffer;
 }
 
+/**
+ * @code                const struct dhcpv6_relay_msg *parse_dhcpv6_relay(const uint8_t *buffer);
+ *
+ * @brief               parse through dhcpv6 relay message
+ *
+ * @param *buffer       message buffer
+ * @param **out_end     pointer
+ * 
+ * @return dhcpv6_relay_msg   start of dhcpv6 relay message or end of dhcpv6 message type position
+ */
 const struct dhcpv6_relay_msg *parse_dhcpv6_relay(const uint8_t *buffer) {
     return (const struct dhcpv6_relay_msg *)buffer;
 }
 
+/**
+ * @code                const struct dhcpv6_option *parse_dhcpv6_opt(const uint8_t *buffer, const uint8_t **out_end);
+ *
+ * @brief               parse through dhcpv6 option
+ *
+ * @param *buffer       message buffer
+ * @param **out_end     pointer
+ * 
+ * @return dhcpv6_option   end of dhcpv6 message option
+ */
 const struct dhcpv6_option *parse_dhcpv6_opt(const uint8_t *buffer, const uint8_t **out_end) {
     uint32_t size = 4; // option-code + option-len
     size += ntohs(*(uint16_t *)(buffer + 2));
@@ -122,6 +207,17 @@ const struct dhcpv6_option *parse_dhcpv6_opt(const uint8_t *buffer, const uint8_
     return (const struct dhcpv6_option *)buffer;
 }
 
+/**
+ * @code                            void send_udp(int sock, uint8_t *buffer, struct sockaddr_in6 target, uint32_t n);
+ *
+ * @brief                           send udp packet
+ *
+ * @param *buffer                   message buffer
+ * @param sockaddr_in6 target       target socket
+ * @param n                         length of message
+ * 
+ * @return dhcpv6_option   end of dhcpv6 message option
+ */
 void send_udp(int sock, uint8_t *buffer, struct sockaddr_in6 target, uint32_t n) {    
     if(sendto(sock, buffer, n, 0, (const struct sockaddr *)&target, sizeof(target)) == -1)
         syslog(LOG_ERR, "sendto: Failed to send to target address\n");
@@ -204,23 +300,25 @@ int sock_open(int ifindex, const struct sock_fprog *fprog)
 }
 
 /**
- * @code                        prepare_relay_config(relay_config *interface_config, int fd, const arg_config *context);
+ * @code                        prepare_relay_config(relay_config *interface_config, int local_sock, int filter);
  * 
  * @brief                       prepare for specified relay interface config: server and link address
  *
  * @param interface_config      pointer to relay config to be prepared
  * @param local_sock            L3 socket used for relaying messages
  * @param filter                socket attached with filter
- * @param config                argument config that contains strings of server and interface addresses
  *
  * @return                      none
  */
-void prepare_relay_config(relay_config *interface_config, int local_sock, int filter, const arg_config *context) {
+void prepare_relay_config(relay_config *interface_config, int local_sock, int filter) {
+    struct ifaddrs *ifa, *ifa_tmp;
+    sockaddr_in6 non_link_local;
+    sockaddr_in6 link_local;
+    
     interface_config->local_sock = local_sock; 
     interface_config->filter = filter; 
-    interface_config->is_option_79 = context->is_option_79; 
 
-    for(auto server: context->servers) {
+    for(auto server: interface_config->servers) {
         sockaddr_in6 tmp;
         if(inet_pton(AF_INET6, server.c_str(), &tmp.sin6_addr) != 1)
         {
@@ -230,16 +328,9 @@ void prepare_relay_config(relay_config *interface_config, int local_sock, int fi
         tmp.sin6_flowinfo = 0;
         tmp.sin6_port = htons(RELAY_PORT);
         tmp.sin6_scope_id = 0; 
-        interface_config->servers.push_back(tmp);
+        interface_config->servers_sock.push_back(tmp);
     }
 
-    sockaddr_in6 *non_link_local = NULL;    
-    sockaddr_in6 *link_local = NULL;
-    
-    struct ifaddrs *ifa, *ifa_tmp;
-    char addr[INET6_ADDRSTRLEN];
-    addr[0] = 0;
-
     if (getifaddrs(&ifa) == -1) {
         syslog(LOG_WARNING, "getifaddrs: Unable to get network interfaces\n");
         exit(1);
@@ -247,40 +338,39 @@ void prepare_relay_config(relay_config *interface_config, int local_sock, int fi
 
     ifa_tmp = ifa;
     while (ifa_tmp) {
-		if ((ifa_tmp->ifa_addr) && (ifa_tmp->ifa_addr->sa_family == AF_INET6)) {
+        if (ifa_tmp->ifa_addr->sa_family == AF_INET6) {
             struct sockaddr_in6 *in6 = (struct sockaddr_in6*) ifa_tmp->ifa_addr;
-            inet_ntop(AF_INET6, &in6->sin6_addr, addr, sizeof(addr));
             if((strcmp(ifa_tmp->ifa_name, interface_config->interface.c_str()) == 0) && is_addr_gua(in6->sin6_addr)) {    
-                non_link_local = in6;
+                non_link_local = *in6;
                 break;
             }
             if((strcmp(ifa_tmp->ifa_name, interface_config->interface.c_str()) == 0) && is_addr_link_local(in6->sin6_addr)) {    
-                link_local = in6;
+                link_local = *in6;
             }   
-	    }
-	    ifa_tmp = ifa_tmp->ifa_next;
-	}
-	freeifaddrs(ifa);
-
-    if (non_link_local != NULL) {
-        interface_config->link_address = *non_link_local;
+        }
+    ifa_tmp = ifa_tmp->ifa_next;
+    }
+    freeifaddrs(ifa); 
+    
+    if(is_addr_gua(non_link_local.sin6_addr)) {
+        interface_config->link_address = non_link_local;
     }
     else {
-        interface_config->link_address = *link_local;
+        interface_config->link_address = link_local;
     }
 }
 
 /**
- * @code                prepare_socket(int *local_sock, arg_config *context);
+ * @code                prepare_socket(int *local_sock, relay_config *config);
  * 
  * @brief               prepare L3 socket for sending
  *
  * @param local_sock    pointer to socket to be prepared
- * @param context       argument config that contains strings of server and interface addresses
+ * @param config       relay config that contains strings of server and interface addresses
  *
  * @return              none
  */
-void prepare_socket(int *local_sock, arg_config *context) {
+void prepare_socket(int *local_sock, relay_config *config) {
     sockaddr_in6 addr;
     memset(&addr, 0, sizeof(addr));
     addr.sin6_family = AF_INET6;
@@ -300,7 +390,7 @@ void prepare_socket(int *local_sock, arg_config *context) {
         if ((ifa_tmp->ifa_addr) && (ifa_tmp->ifa_addr->sa_family == AF_INET6)) {                  
             struct sockaddr_in6 *in6 = (struct sockaddr_in6*) ifa_tmp->ifa_addr;
             inet_ntop(AF_INET6, &in6->sin6_addr, tmp, sizeof(tmp));
-            if(strcmp(ifa_tmp->ifa_name, context->interface.c_str()) == 0 && (is_addr_gua(in6->sin6_addr))) {
+            if(strcmp(ifa_tmp->ifa_name, config->interface.c_str()) == 0 && (is_addr_gua(in6->sin6_addr))) {
                 inet_pton(AF_INET6, tmp, &addr.sin6_addr);
             }
             else {
@@ -325,26 +415,24 @@ void prepare_socket(int *local_sock, arg_config *context) {
 }
 
 /**
- * @code                prepare_server_socket(int *server_sock, arg_config *context);
+ * @code                prepare_server_socket(int *server_sock);
  * 
  * @brief               prepare L3 socket for sending
  *
  * @param server_sock   pointer to socket receiving server packets to be prepared
- * @param context       argument config that contains strings of server and interface addresses
  *
  * @return              none
  */
-void prepare_server_socket(int *server_sock, arg_config *context) {
+void prepare_server_socket(int *server_sock) {
     sockaddr_in6 addr;
     memset(&addr, 0, sizeof(addr));
     addr.sin6_family = AF_INET6;
     addr.sin6_addr = in6addr_any;
+    addr.sin6_port = htons(RELAY_PORT);
 
     if ((*server_sock = socket(AF_INET6, SOCK_DGRAM, 0)) == -1) {
         syslog(LOG_ERR, "scoket: Failed to create socket\n");
     }
-
-    addr.sin6_port = htons(RELAY_PORT);
     
     if (bind(*server_sock, (sockaddr *)&addr, sizeof(addr)) == -1) {
         syslog(LOG_ERR, "bind: Failed to bind to socket\n");
@@ -367,7 +455,7 @@ void prepare_server_socket(int *server_sock, arg_config *context) {
  * @return none
  */
 void relay_client(int sock, const uint8_t *msg, int32_t len, const ip6_hdr *ip_hdr, const ether_header *ether_hdr, relay_config *config) {    
-    uint8_t buffer[4096];
+    static uint8_t buffer[4096];
     auto current_buffer_position = buffer;
     dhcpv6_relay_msg new_message;
     new_message.msg_type = DHCPv6_MESSAGE_TYPE_RELAY_FORW;
@@ -396,7 +484,7 @@ void relay_client(int sock, const uint8_t *msg, int32_t len, const ip6_hdr *ip_h
     memcpy(current_buffer_position, &ether_hdr->ether_shost, sizeof(ether_hdr->ether_shost));
     current_buffer_position += sizeof(ether_hdr->ether_shost);
 
-    for(auto server: config->servers) {
+    for(auto server: config->servers_sock) {
         send_udp(sock, buffer, server, current_buffer_position - buffer);
     }
 }
@@ -414,7 +502,7 @@ void relay_client(int sock, const uint8_t *msg, int32_t len, const ip6_hdr *ip_h
  * @return              none
  */
  void relay_relay_reply(int sock, const uint8_t *msg, int32_t len, relay_config *configs) {
-    uint8_t buffer[4096];
+    static uint8_t buffer[4096];
     char ifname[configs->interface.size()];
     struct sockaddr_in6 target_addr;
     auto current_buffer_position = buffer;
@@ -491,6 +579,7 @@ void callback(evutil_socket_t fd, short event, void *arg) {
     auto msg = parse_dhcpv6_hdr(current_position);
     counters[msg->msg_type]++;
     update_counter(config->db);
+
     relay_client(config->local_sock, current_position, ntohs(udp_header->len) - sizeof(udphdr), ip_header, ether_header, config);
 }
 
@@ -597,36 +686,33 @@ void dhcp6relay_stop()
 }
 
 /**
- * @code                loop_relay(std::vector<arg_config> *vlans, swss::DBConnector *db);
+ * @code                loop_relay(std::vector<relay_config> *vlans, swss::DBConnector *db);
  * 
  * @brief               main loop: configure sockets, create libevent base, start server listener thread
  *  
  * @param vlans         list of vlans retrieved from config_db
  * @param db            state_db connector
  */
-void loop_relay(std::vector<arg_config> *vlans, swss::DBConnector *db) {
+void loop_relay(std::vector<relay_config> *vlans, swss::DBConnector *db) {
     std::vector<int> sockets;
     for(std::size_t i = 0; i<vlans->size(); i++) {
-        struct arg_config context = vlans->at(i);
-        struct relay_config config;
+        struct relay_config config = vlans->at(i);
         int filter = 0;
         int local_sock = 0; 
         int server_sock = 0;
-        const char *ifname = context.interface.c_str();
+        const char *ifname = config.interface.c_str();
         int index = if_nametoindex(ifname);
+        config.db = db;
 
         filter = sock_open(index, &ether_relay_fprog);
 
-        prepare_socket(&local_sock, &context);
-        prepare_server_socket(&server_sock, &context);
+        prepare_socket(&local_sock, &config);
+        prepare_server_socket(&server_sock);
         sockets.push_back(filter);
         sockets.push_back(local_sock);
         sockets.push_back(server_sock);
 
-        config.interface = context.interface;
-        config.db = db;
-
-        prepare_relay_config(&config, local_sock, filter, &context);
+        prepare_relay_config(&config, local_sock, filter);
 
         evutil_make_listen_socket_reuseable(filter);
         evutil_make_socket_nonblocking(filter);
diff --git a/src/dhcp6relay/src/relay.h b/src/dhcp6relay/src/relay.h
index 1947b7a840bf..6a3b815aed9e 100644
--- a/src/dhcp6relay/src/relay.h
+++ b/src/dhcp6relay/src/relay.h
@@ -40,19 +40,14 @@ typedef enum
     DHCPv6_MESSAGE_TYPE_COUNT
 } dhcp_message_type_t;
 
-struct arg_config {
-    std::vector<std::string> servers;
-    std::string interface;
-    bool is_option_79;
-};
-
 struct relay_config {
     int local_sock; 
     int filter;
     sockaddr_in6 link_address;
     swss::DBConnector *db;
     std::string interface;
-    std::vector<sockaddr_in6> servers;
+    std::vector<std::string> servers;
+    std::vector<sockaddr_in6> servers_sock;
     bool is_option_79;
 };
 
@@ -95,42 +90,41 @@ struct linklayer_addr_option  {
 int sock_open(int ifindex, const struct sock_fprog *fprog);
 
 /**
- * @code                prepare_socket(int *local_sock, arg_config *context);
+ * @code                prepare_socket(int *local_sock, arg_config *config);
  * 
  * @brief               prepare L3 socket for sending
  *
  * @param local_sock    pointer to socket to be prepared
- * @param context       argument config that contains strings of server and interface addresses
+ * @param config       argument config that contains strings of server and interface addresses
  *
  * @return              none
  */
-void prepare_socket(int *local_sock, arg_config *config);
+void prepare_socket(int *local_sock, relay_config *config);
 
 /**
- * @code                prepare_server_socket(int *server_sock, arg_config *context);
+ * @code                prepare_server_socket(int *server_sock, arg_config *config);
  * 
  * @brief               prepare L3 socket for sending
  *
  * @param server_sock   pointer to socket receiving server packets to be prepared
- * @param context       argument config that contains strings of server and interface addresses
+ * @param config        relay config that contains strings of server and interface addresses
  *
  * @return              none
  */
-void prepare_server_socket(int *server_sock, arg_config *context);
+void prepare_server_socket(int *server_sock);
 
 /**
- * @code                        prepare_relay_config(relay_config *interface_config, int fd, const arg_config *context);
+ * @code                        prepare_relay_config(relay_config *interface_config, int local_sock, int filter);
  * 
  * @brief                       prepare for specified relay interface config: server and link address
  *
  * @param interface_config      pointer to relay config to be prepared
  * @param local_sock            L3 socket used for relaying messages
  * @param filter                socket attached with filter
- * @param config                argument config that contains strings of server and interface addresses
  *
  * @return                      none
  */
-void prepare_relay_config(relay_config *interface_config, int local_sock, int filter, const arg_config *context);
+void prepare_relay_config(relay_config *interface_config, int local_sock, int filter);
 
 /**
  * @code                relay_forward(uint8_t *buffer, const struct dhcpv6_msg *msg, uint16_t msg_length);
@@ -183,7 +177,7 @@ void relay_relay_reply(int sock, const uint8_t *msg, int32_t len, relay_config *
  * @param vlans         list of vlans retrieved from config_db
  * @param db            state_db connector
  */
-void loop_relay(std::vector<arg_config> *vlans, swss::DBConnector *db);
+void loop_relay(std::vector<relay_config> *vlans, swss::DBConnector *db);
 
 /**
  * @code signal_init();
@@ -239,23 +233,121 @@ void update_counter(swss::DBConnector *db);
 
 /* Helper functions */
 
+/**
+ * @code                std::string toString(uint16_t count);
+ *
+ * @brief               convert uint16_t to string
+ *
+ * @param count         count of messages in counter
+ * 
+ * @return              count in string
+ */
 std::string toString(uint16_t count);
 
+/**
+ * @code                bool is_addr_gua(in6_addr addr);
+ *
+ * @brief               check if address is global
+ *
+ * @param addr         ipv6 address
+ * 
+ * @return              bool
+ */
 bool is_addr_gua(in6_addr addr);
 
+/**
+ * @code                is_addr_link_local(in6_addr addr);
+ *
+ * @brief               check if address is link_local
+ *
+ * @param addr         ipv6 address
+ * 
+ * @return              bool
+ */
 bool is_addr_link_local(in6_addr addr);
 
+/**
+ * @code                const struct ether_header *parse_ether_frame(const uint8_t *buffer, const uint8_t **out_end);
+ *
+ * @brief               parse through ethernet frame
+ *
+ * @param *buffer       message buffer
+ * @param **out_end     pointer
+ * 
+ * @return ether_header end of ethernet header position
+ */
 const struct ether_header *parse_ether_frame(const uint8_t *buffer, const uint8_t **out_end);
 
+/**
+ * @code                const struct ip6_hdr *parse_ip6_hdr(const uint8_t *buffer, const uint8_t **out_end);
+ *
+ * @brief               parse through ipv6 header
+ *
+ * @param *buffer       message buffer
+ * @param **out_end     pointer
+ * 
+ * @return ip6_hdr      end of ipv6 header position
+ */
 const struct ip6_hdr *parse_ip6_hdr(const uint8_t *buffer, const uint8_t **out_end);
 
+/**
+ * @code                const struct udphdr *parse_udp(const uint8_t *buffer, const uint8_t **out_end);
+ *
+ * @brief               parse through udp header
+ *
+ * @param *buffer       message buffer
+ * @param **out_end     pointer
+ * 
+ * @return udphdr      end of udp header position
+ */
 const struct udphdr *parse_udp(const uint8_t *buffer, const uint8_t **out_end);
 
+/**
+ * @code                const struct dhcpv6_msg *parse_dhcpv6_hdr(const uint8_t *buffer);
+ *
+ * @brief               parse through dhcpv6 header
+ *
+ * @param *buffer       message buffer
+ * @param **out_end     pointer
+ * 
+ * @return dhcpv6_msg   end of dhcpv6 header position
+ */
 const struct dhcpv6_msg *parse_dhcpv6_hdr(const uint8_t *buffer);
 
+/**
+ * @code                const struct dhcpv6_relay_msg *parse_dhcpv6_relay(const uint8_t *buffer);
+ *
+ * @brief               parse through dhcpv6 relay message
+ *
+ * @param *buffer       message buffer
+ * @param **out_end     pointer
+ * 
+ * @return dhcpv6_relay_msg   start of dhcpv6 relay message or end of dhcpv6 message type position
+ */
 const struct dhcpv6_relay_msg *parse_dhcpv6_relay(const uint8_t *buffer);
 
+/**
+ * @code                const struct dhcpv6_option *parse_dhcpv6_opt(const uint8_t *buffer, const uint8_t **out_end);
+ *
+ * @brief               parse through dhcpv6 option
+ *
+ * @param *buffer       message buffer
+ * @param **out_end     pointer
+ * 
+ * @return dhcpv6_option   end of dhcpv6 message option
+ */
 const struct dhcpv6_option *parse_dhcpv6_opt(const uint8_t *buffer, const uint8_t **out_end);
 
+/**
+ * @code                            void send_udp(int sock, uint8_t *buffer, struct sockaddr_in6 target, uint32_t n);
+ *
+ * @brief                           send udp packet
+ *
+ * @param *buffer                   message buffer
+ * @param sockaddr_in6 target       target socket
+ * @param n                         length of message
+ * 
+ * @return dhcpv6_option   end of dhcpv6 message option
+ */
 void send_udp(int sock, struct sockaddr_in6 target, uint8_t *buffer, uint32_t n);
 

From c33927220ad4634345c8d8a54c3ab21747303180 Mon Sep 17 00:00:00 2001
From: kellyyeh <kellyyeh@microsoft.com>
Date: Tue, 17 Aug 2021 17:36:27 +0000
Subject: [PATCH 09/16] Updated counter to support multi-vlan

---
 src/dhcp6relay/src/relay.cpp | 51 +++++++++++++++++++++++++-----------
 src/dhcp6relay/src/relay.h   | 19 ++++++++++++--
 2 files changed, 53 insertions(+), 17 deletions(-)

diff --git a/src/dhcp6relay/src/relay.cpp b/src/dhcp6relay/src/relay.cpp
index 7e9cac18bf22..b5bd44ba99b8 100644
--- a/src/dhcp6relay/src/relay.cpp
+++ b/src/dhcp6relay/src/relay.cpp
@@ -50,26 +50,42 @@ const struct sock_fprog ether_relay_fprog = {
 uint64_t counters[DHCPv6_MESSAGE_TYPE_COUNT];
 
 /**
- * @code                void update_counter(swss::DBConnector *db);
+ * @code                void initialize_counter(swss::DBConnector *db, std::string counterVlan);
+ *
+ * @brief               initialize the counter by each Vlan
+ *
+ * @param swss::DBConnector *db     state_db connector
+ * @param counterVlan   counter table with interface name
+ * 
+ * @return              none
+ */
+void initialize_counter(swss::DBConnector *db, std::string counterVlan) {
+    db->hset(counterVlan, "Solicit", toString(counters[DHCPv6_MESSAGE_TYPE_SOLICIT]));
+    db->hset(counterVlan, "Advertise", toString(counters[DHCPv6_MESSAGE_TYPE_ADVERTISE]));
+    db->hset(counterVlan, "Request", toString(counters[DHCPv6_MESSAGE_TYPE_REQUEST]));
+    db->hset(counterVlan, "Confirm", toString(counters[DHCPv6_MESSAGE_TYPE_CONFIRM]));
+    db->hset(counterVlan, "Renew", toString(counters[DHCPv6_MESSAGE_TYPE_RENEW]));
+    db->hset(counterVlan, "Rebind", toString(counters[DHCPv6_MESSAGE_TYPE_REBIND]));
+    db->hset(counterVlan, "Reply", toString(counters[DHCPv6_MESSAGE_TYPE_REPLY]));
+    db->hset(counterVlan, "Release", toString(counters[DHCPv6_MESSAGE_TYPE_RELEASE]));
+    db->hset(counterVlan, "Decline", toString(counters[DHCPv6_MESSAGE_TYPE_DECLINE]));
+    db->hset(counterVlan, "Relay-Forward", toString(counters[DHCPv6_MESSAGE_TYPE_RELAY_FORW]));
+    db->hset(counterVlan, "Relay-Reply", toString(counters[DHCPv6_MESSAGE_TYPE_RELAY_REPL]));
+}
+
+/**
+ * @code                void update_counter(swss::DBConnector *db, std::string CounterVlan, uint8_t msg_type);
  *
  * @brief               update the counter in state_db with count of each DHCPv6 message type
  *
  * @param swss::DBConnector *db     state_db connector
+ * @param counterVlan   counter table with interface name
+ * @param msg_type      dhcpv6 message type to be updated in counter
  * 
  * @return              none
  */
-void update_counter(swss::DBConnector *db) {
-    db->hset("DHCPv6_Counter", "Solicit", toString(counters[DHCPv6_MESSAGE_TYPE_SOLICIT]));
-    db->hset("DHCPv6_Counter", "Advertise", toString(counters[DHCPv6_MESSAGE_TYPE_ADVERTISE]));
-    db->hset("DHCPv6_Counter", "Request", toString(counters[DHCPv6_MESSAGE_TYPE_REQUEST]));
-    db->hset("DHCPv6_Counter", "Confirm", toString(counters[DHCPv6_MESSAGE_TYPE_CONFIRM]));
-    db->hset("DHCPv6_Counter", "Renew", toString(counters[DHCPv6_MESSAGE_TYPE_RENEW]));
-    db->hset("DHCPv6_Counter", "Rebind", toString(counters[DHCPv6_MESSAGE_TYPE_REBIND]));
-    db->hset("DHCPv6_Counter", "Reply", toString(counters[DHCPv6_MESSAGE_TYPE_REPLY]));
-    db->hset("DHCPv6_Counter", "Release", toString(counters[DHCPv6_MESSAGE_TYPE_RELEASE]));
-    db->hset("DHCPv6_Counter", "Decline", toString(counters[DHCPv6_MESSAGE_TYPE_DECLINE]));
-    db->hset("DHCPv6_Counter", "Relay-Forward", toString(counters[DHCPv6_MESSAGE_TYPE_RELAY_FORW]));
-    db->hset("DHCPv6_Counter", "Relay-Reply", toString(counters[DHCPv6_MESSAGE_TYPE_RELAY_REPL]));
+void update_counter(swss::DBConnector *db, std::string counterVlan, uint8_t msg_type) {
+    db->hset(counterVlan, "Solicit", toString(counters[msg_type]));
 }
 
 /**
@@ -578,7 +594,7 @@ void callback(evutil_socket_t fd, short event, void *arg) {
 
     auto msg = parse_dhcpv6_hdr(current_position);
     counters[msg->msg_type]++;
-    update_counter(config->db);
+    update_counter(config->db, config->counterVlan, msg->msg_type);
 
     relay_client(config->local_sock, current_position, ntohs(udp_header->len) - sizeof(udphdr), ip_header, ether_header, config);
 }
@@ -596,7 +612,7 @@ void server_callback(evutil_socket_t fd, short event, void *arg) {
     auto msg = parse_dhcpv6_hdr(message_buffer);
 
     counters[msg->msg_type]++;
-    update_counter(config->db);
+    update_counter(config->db, config->counterVlan, msg->msg_type);
     if (msg->msg_type == DHCPv6_MESSAGE_TYPE_RELAY_REPL) {
         relay_relay_reply(config->local_sock, message_buffer, data, config);
     }
@@ -695,6 +711,7 @@ void dhcp6relay_stop()
  */
 void loop_relay(std::vector<relay_config> *vlans, swss::DBConnector *db) {
     std::vector<int> sockets;
+    
     for(std::size_t i = 0; i<vlans->size(); i++) {
         struct relay_config config = vlans->at(i);
         int filter = 0;
@@ -704,6 +721,10 @@ void loop_relay(std::vector<relay_config> *vlans, swss::DBConnector *db) {
         int index = if_nametoindex(ifname);
         config.db = db;
 
+        config.counterVlan = "DHCPv6_Counter|";
+        config.counterVlan.append(ifname);
+        initialize_counter(config.db, config.counterVlan);
+
         filter = sock_open(index, &ether_relay_fprog);
 
         prepare_socket(&local_sock, &config);
diff --git a/src/dhcp6relay/src/relay.h b/src/dhcp6relay/src/relay.h
index 6a3b815aed9e..0b12d9fa8986 100644
--- a/src/dhcp6relay/src/relay.h
+++ b/src/dhcp6relay/src/relay.h
@@ -49,6 +49,7 @@ struct relay_config {
     std::vector<std::string> servers;
     std::vector<sockaddr_in6> servers_sock;
     bool is_option_79;
+    std::string counterVlan;
 };
 
 
@@ -221,15 +222,29 @@ void signal_callback(evutil_socket_t fd, short event, void *arg);
 void shutdown();
 
 /**
- * @code                void update_counter(swss::DBConnector *db);
+ * @code                void initialize_counter(swss::DBConnector *db, std::string counterVlan);
+ *
+ * @brief               initialize the counter by each Vlan
+ *
+ * @param swss::DBConnector *db     state_db connector
+ * @param counterVlan   counter table with interface name
+ * 
+ * @return              none
+ */
+void initialize_counter(swss::DBConnector *db, std::string counterVlan);
+
+/**
+ * @code                void update_counter(swss::DBConnector *db, std::string CounterVlan, uint8_t msg_type);
  *
  * @brief               update the counter in state_db with count of each DHCPv6 message type
  *
  * @param swss::DBConnector *db     state_db connector
+ * @param counterVlan   counter table with interface name
+ * @param msg_type      dhcpv6 message type to be updated in counter
  * 
  * @return              none
  */
-void update_counter(swss::DBConnector *db);
+void update_counter(swss::DBConnector *db, std::string counterVlan, uint8_t msg_type);
 
 /* Helper functions */
 

From 96664c5fcf79e19b27dbf7c8f60af639b1a672b7 Mon Sep 17 00:00:00 2001
From: kellyyeh <kellyyeh@microsoft.com>
Date: Tue, 17 Aug 2021 18:09:52 +0000
Subject: [PATCH 10/16] Updated update_counter

---
 src/dhcp6relay/src/relay.cpp | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/dhcp6relay/src/relay.cpp b/src/dhcp6relay/src/relay.cpp
index b5bd44ba99b8..1cb2eacb1f63 100644
--- a/src/dhcp6relay/src/relay.cpp
+++ b/src/dhcp6relay/src/relay.cpp
@@ -48,6 +48,17 @@ const struct sock_fprog ether_relay_fprog = {
 
 /* DHCPv6 Counter */
 uint64_t counters[DHCPv6_MESSAGE_TYPE_COUNT];
+std::map<int, std::string> counterMap = {{1, "Solicit"},
+                                      {2, "Advertise"},
+                                      {3, "Request"},
+                                      {4, "Confirm"},
+                                      {5, "Renew"},
+                                      {6, "Rebind"},
+                                      {7, "Reply"},
+                                      {8, "Release"},
+                                      {9, "Decline"},
+                                      {12, "Relay-Forward"},
+                                      {13, "Relay-Reply"}};
 
 /**
  * @code                void initialize_counter(swss::DBConnector *db, std::string counterVlan);
@@ -85,7 +96,7 @@ void initialize_counter(swss::DBConnector *db, std::string counterVlan) {
  * @return              none
  */
 void update_counter(swss::DBConnector *db, std::string counterVlan, uint8_t msg_type) {
-    db->hset(counterVlan, "Solicit", toString(counters[msg_type]));
+    db->hset(counterVlan, counterMap.find(msg_type)->second, toString(counters[msg_type]));
 }
 
 /**

From 308658fe2eaa2e7ace0b0e96388cee1718ee66cd Mon Sep 17 00:00:00 2001
From: kellyyeh <kellyyeh@microsoft.com>
Date: Tue, 17 Aug 2021 18:51:04 +0000
Subject: [PATCH 11/16] Changed counter table name

---
 src/dhcp6relay/src/relay.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dhcp6relay/src/relay.cpp b/src/dhcp6relay/src/relay.cpp
index 1cb2eacb1f63..55408e4fde36 100644
--- a/src/dhcp6relay/src/relay.cpp
+++ b/src/dhcp6relay/src/relay.cpp
@@ -732,7 +732,7 @@ void loop_relay(std::vector<relay_config> *vlans, swss::DBConnector *db) {
         int index = if_nametoindex(ifname);
         config.db = db;
 
-        config.counterVlan = "DHCPv6_Counter|";
+        config.counterVlan = "DHCPv6_COUNTER|";
         config.counterVlan.append(ifname);
         initialize_counter(config.db, config.counterVlan);
 

From f61c7dba28a803106acf52fffabf065c074e7513 Mon Sep 17 00:00:00 2001
From: kellyyeh <kellyyeh@microsoft.com>
Date: Wed, 18 Aug 2021 21:36:10 +0000
Subject: [PATCH 12/16] Use specified intf address instead of ipv6 auto
 selection for now

---
 src/dhcp6relay/src/relay.cpp | 49 ++++++------------------------------
 src/dhcp6relay/src/relay.h   | 12 ---------
 2 files changed, 8 insertions(+), 53 deletions(-)

diff --git a/src/dhcp6relay/src/relay.cpp b/src/dhcp6relay/src/relay.cpp
index 55408e4fde36..e4c20b266f9f 100644
--- a/src/dhcp6relay/src/relay.cpp
+++ b/src/dhcp6relay/src/relay.cpp
@@ -401,10 +401,10 @@ void prepare_socket(int *local_sock, relay_config *config) {
     sockaddr_in6 addr;
     memset(&addr, 0, sizeof(addr));
     addr.sin6_family = AF_INET6;
-    addr.sin6_addr = in6addr_any;
+    //addr.sin6_addr = in6addr_any;
     /*TO FIX AFTER TESTING IPV6 ADDR AUTO SELECTION. PLEASE IGNORE THE COMMENTED AREA*/
-    /*struct ifaddrs *ifa, *ifa_tmp;
-     char tmp[INET6_ADDRSTRLEN];
+    struct ifaddrs *ifa, *ifa_tmp;
+    char tmp[INET6_ADDRSTRLEN];
     tmp[0] = 0;
 
     if (getifaddrs(&ifa) == -1) {
@@ -420,18 +420,13 @@ void prepare_socket(int *local_sock, relay_config *config) {
             if(strcmp(ifa_tmp->ifa_name, config->interface.c_str()) == 0 && (is_addr_gua(in6->sin6_addr))) {
                 inet_pton(AF_INET6, tmp, &addr.sin6_addr);
             }
-            else {
-                syslog(LOG_ERR, "inet_pton: interface global address not configured\n");
-                sleep(10);
-                continue;
-            }
         }
         ifa_tmp = ifa_tmp->ifa_next;
     }
-    freeifaddrs(ifa);   */
+    freeifaddrs(ifa);   
 
     if ((*local_sock = socket(AF_INET6, SOCK_DGRAM, 0)) == -1) {
-        syslog(LOG_ERR, "scoket: Failed to create socket\n");
+        syslog(LOG_ERR, "socket: Failed to create socket\n");
     }
 
     addr.sin6_port = htons(RELAY_PORT);
@@ -441,31 +436,6 @@ void prepare_socket(int *local_sock, relay_config *config) {
     }    
 }
 
-/**
- * @code                prepare_server_socket(int *server_sock);
- * 
- * @brief               prepare L3 socket for sending
- *
- * @param server_sock   pointer to socket receiving server packets to be prepared
- *
- * @return              none
- */
-void prepare_server_socket(int *server_sock) {
-    sockaddr_in6 addr;
-    memset(&addr, 0, sizeof(addr));
-    addr.sin6_family = AF_INET6;
-    addr.sin6_addr = in6addr_any;
-    addr.sin6_port = htons(RELAY_PORT);
-
-    if ((*server_sock = socket(AF_INET6, SOCK_DGRAM, 0)) == -1) {
-        syslog(LOG_ERR, "scoket: Failed to create socket\n");
-    }
-    
-    if (bind(*server_sock, (sockaddr *)&addr, sizeof(addr)) == -1) {
-        syslog(LOG_ERR, "bind: Failed to bind to socket\n");
-    }    
-}
-
 
 /**
  * @code                 relay_client(int sock, const uint8_t *msg, int32_t len, ip6_hdr *ip_hdr, const ether_header *ether_hdr, relay_config *config);
@@ -727,7 +697,6 @@ void loop_relay(std::vector<relay_config> *vlans, swss::DBConnector *db) {
         struct relay_config config = vlans->at(i);
         int filter = 0;
         int local_sock = 0; 
-        int server_sock = 0;
         const char *ifname = config.interface.c_str();
         int index = if_nametoindex(ifname);
         config.db = db;
@@ -739,18 +708,16 @@ void loop_relay(std::vector<relay_config> *vlans, swss::DBConnector *db) {
         filter = sock_open(index, &ether_relay_fprog);
 
         prepare_socket(&local_sock, &config);
-        prepare_server_socket(&server_sock);
         sockets.push_back(filter);
         sockets.push_back(local_sock);
-        sockets.push_back(server_sock);
 
         prepare_relay_config(&config, local_sock, filter);
 
         evutil_make_listen_socket_reuseable(filter);
         evutil_make_socket_nonblocking(filter);
 
-        evutil_make_listen_socket_reuseable(server_sock);
-        evutil_make_socket_nonblocking(server_sock);
+        evutil_make_listen_socket_reuseable(local_sock);
+        evutil_make_socket_nonblocking(local_sock);
 
         base = event_base_new();
         if(base == NULL) {
@@ -758,7 +725,7 @@ void loop_relay(std::vector<relay_config> *vlans, swss::DBConnector *db) {
         }
 
         listen_event = event_new(base, filter, EV_READ|EV_PERSIST, callback, (void *)&config);
-        server_listen_event = event_new(base, server_sock, EV_READ|EV_PERSIST, server_callback, (void *)&config);
+        server_listen_event = event_new(base, local_sock, EV_READ|EV_PERSIST, server_callback, (void *)&config);
         if (listen_event == NULL || server_listen_event == NULL) {
             syslog(LOG_ERR, "libevent: Failed to create libevent\n");
         }
diff --git a/src/dhcp6relay/src/relay.h b/src/dhcp6relay/src/relay.h
index 0b12d9fa8986..1d669a585321 100644
--- a/src/dhcp6relay/src/relay.h
+++ b/src/dhcp6relay/src/relay.h
@@ -102,18 +102,6 @@ int sock_open(int ifindex, const struct sock_fprog *fprog);
  */
 void prepare_socket(int *local_sock, relay_config *config);
 
-/**
- * @code                prepare_server_socket(int *server_sock, arg_config *config);
- * 
- * @brief               prepare L3 socket for sending
- *
- * @param server_sock   pointer to socket receiving server packets to be prepared
- * @param config        relay config that contains strings of server and interface addresses
- *
- * @return              none
- */
-void prepare_server_socket(int *server_sock);
-
 /**
  * @code                        prepare_relay_config(relay_config *interface_config, int local_sock, int filter);
  * 

From 99f91c0e7bbb2f7915e0d4a8fca352c8b25f23d9 Mon Sep 17 00:00:00 2001
From: kellyyeh <kellyyeh@microsoft.com>
Date: Wed, 18 Aug 2021 21:45:29 +0000
Subject: [PATCH 13/16] Updated counter table name

---
 src/dhcp6relay/src/relay.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dhcp6relay/src/relay.cpp b/src/dhcp6relay/src/relay.cpp
index e4c20b266f9f..52fe3a077c5e 100644
--- a/src/dhcp6relay/src/relay.cpp
+++ b/src/dhcp6relay/src/relay.cpp
@@ -701,7 +701,7 @@ void loop_relay(std::vector<relay_config> *vlans, swss::DBConnector *db) {
         int index = if_nametoindex(ifname);
         config.db = db;
 
-        config.counterVlan = "DHCPv6_COUNTER|";
+        config.counterVlan = "DHCPv6_COUNTER_TABLE|";
         config.counterVlan.append(ifname);
         initialize_counter(config.db, config.counterVlan);
 

From e345890c73751168d867aa514eff17f83a18061c Mon Sep 17 00:00:00 2001
From: kellyyeh <kellyyeh@microsoft.com>
Date: Wed, 18 Aug 2021 22:48:20 +0000
Subject: [PATCH 14/16] Updated option parsing

---
 src/dhcp6relay/src/configInterface.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/dhcp6relay/src/configInterface.cpp b/src/dhcp6relay/src/configInterface.cpp
index 66af62c54dc0..f428b7704c4b 100644
--- a/src/dhcp6relay/src/configInterface.cpp
+++ b/src/dhcp6relay/src/configInterface.cpp
@@ -130,13 +130,15 @@ void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries,
                 }
                 syslog(LOG_DEBUG, "key: %s, Operation: %s, f: %s, v: %s", vlan.c_str(), operation.c_str(), f.c_str(), v.c_str());
             }
-            if(f == "options") {
+            if(f == "dhcpv6_option|rfc6939_support") {
                 std::stringstream ss(v);
                 while (ss.good()) {
                     std::string substr;
                     getline(ss, substr, ',');
-                    if(substr == "dhcpv6_option|rfc6939_support")
+                    if(substr == "true")
                         intf.is_option_79 = true;
+                    else if(substr == "false")
+                        intf.is_option_79 = false;
                 }
             }
         }

From f7b7d4ae6d61ddac0cc4a8be9f842e8ea96189c3 Mon Sep 17 00:00:00 2001
From: kellyyeh <kellyyeh@microsoft.com>
Date: Wed, 18 Aug 2021 22:52:35 +0000
Subject: [PATCH 15/16] Updated option parsing

---
 src/dhcp6relay/src/configInterface.cpp | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/src/dhcp6relay/src/configInterface.cpp b/src/dhcp6relay/src/configInterface.cpp
index f428b7704c4b..db2c67656a76 100644
--- a/src/dhcp6relay/src/configInterface.cpp
+++ b/src/dhcp6relay/src/configInterface.cpp
@@ -131,15 +131,10 @@ void processRelayNotification(std::deque<swss::KeyOpFieldsValuesTuple> &entries,
                 syslog(LOG_DEBUG, "key: %s, Operation: %s, f: %s, v: %s", vlan.c_str(), operation.c_str(), f.c_str(), v.c_str());
             }
             if(f == "dhcpv6_option|rfc6939_support") {
-                std::stringstream ss(v);
-                while (ss.good()) {
-                    std::string substr;
-                    getline(ss, substr, ',');
-                    if(substr == "true")
-                        intf.is_option_79 = true;
-                    else if(substr == "false")
-                        intf.is_option_79 = false;
-                }
+                if(v == "true")
+                    intf.is_option_79 = true;
+                else if(v == "false")
+                    intf.is_option_79 = false;
             }
         }
         vlans->push_back(intf);

From 6a42ef21d364fe479c988b869d7301e00cedf395 Mon Sep 17 00:00:00 2001
From: kellyyeh <kellyyeh@microsoft.com>
Date: Fri, 20 Aug 2021 04:14:02 +0000
Subject: [PATCH 16/16] Updated relay.cpp

---
 src/dhcp6relay/src/relay.cpp | 54 +++++++++---------------------------
 src/dhcp6relay/src/relay.h   |  5 ++--
 2 files changed, 16 insertions(+), 43 deletions(-)

diff --git a/src/dhcp6relay/src/relay.cpp b/src/dhcp6relay/src/relay.cpp
index 52fe3a077c5e..d9c7114a7937 100644
--- a/src/dhcp6relay/src/relay.cpp
+++ b/src/dhcp6relay/src/relay.cpp
@@ -286,7 +286,7 @@ int sock_open(int ifindex, const struct sock_fprog *fprog)
 		return -1;
 	}
 
-	int s = socket(AF_PACKET, SOCK_RAW, 0);
+	int s = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
 	if (s == -1) {
 		syslog(LOG_ERR, "socket: Failed to create socket\n");
 		return -1;
@@ -294,7 +294,7 @@ int sock_open(int ifindex, const struct sock_fprog *fprog)
 
 	struct sockaddr_ll sll = {
 	    .sll_family = AF_PACKET,
-	    .sll_protocol = htons(ETH_P_IPV6),
+	    .sll_protocol = htons(ETH_P_ALL),
 	    .sll_ifindex = ifindex
 	};
 
@@ -304,18 +304,6 @@ int sock_open(int ifindex, const struct sock_fprog *fprog)
 	    return -1;
 	}
 
-	struct packet_mreq mreq = {
-	    .mr_ifindex = ifindex,
-	    .mr_type = PACKET_MR_PROMISC
-	};
-
-	if (setsockopt(s, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mreq, sizeof mreq) == -1)
-	{
-		syslog(LOG_ERR, "setsockopt: Failed to send PACkET_MR_PROMISC\n");
-		(void) close(s);
-	    return -1;
-	}
-
 	if (fprog && setsockopt(s, SOL_SOCKET, SO_ATTACH_FILTER, fprog, sizeof *fprog) == -1)
 	{
 		syslog(LOG_ERR, "setsockopt: Failed to attach filter\n");
@@ -397,39 +385,22 @@ void prepare_relay_config(relay_config *interface_config, int local_sock, int fi
  *
  * @return              none
  */
-void prepare_socket(int *local_sock, relay_config *config) {
+void prepare_socket(int *local_sock, relay_config *config, int index) {
+    int flag = 1;
     sockaddr_in6 addr;
     memset(&addr, 0, sizeof(addr));
     addr.sin6_family = AF_INET6;
-    //addr.sin6_addr = in6addr_any;
-    /*TO FIX AFTER TESTING IPV6 ADDR AUTO SELECTION. PLEASE IGNORE THE COMMENTED AREA*/
-    struct ifaddrs *ifa, *ifa_tmp;
-    char tmp[INET6_ADDRSTRLEN];
-    tmp[0] = 0;
-
-    if (getifaddrs(&ifa) == -1) {
-        syslog(LOG_WARNING, "getifaddrs: Unable to get network interfaces\n");
-        exit(1);
-    } 
-
-    ifa_tmp = ifa;
-    while (ifa_tmp) {
-        if ((ifa_tmp->ifa_addr) && (ifa_tmp->ifa_addr->sa_family == AF_INET6)) {                  
-            struct sockaddr_in6 *in6 = (struct sockaddr_in6*) ifa_tmp->ifa_addr;
-            inet_ntop(AF_INET6, &in6->sin6_addr, tmp, sizeof(tmp));
-            if(strcmp(ifa_tmp->ifa_name, config->interface.c_str()) == 0 && (is_addr_gua(in6->sin6_addr))) {
-                inet_pton(AF_INET6, tmp, &addr.sin6_addr);
-            }
-        }
-        ifa_tmp = ifa_tmp->ifa_next;
-    }
-    freeifaddrs(ifa);   
+    addr.sin6_addr = in6addr_any;
+    addr.sin6_scope_id = index;
+    addr.sin6_port = htons(RELAY_PORT);
 
     if ((*local_sock = socket(AF_INET6, SOCK_DGRAM, 0)) == -1) {
         syslog(LOG_ERR, "socket: Failed to create socket\n");
     }
 
-    addr.sin6_port = htons(RELAY_PORT);
+    if((setsockopt(*local_sock, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag))) == -1) {
+		syslog(LOG_ERR, "setsockopt: Unable to set socket option\n");
+	}
     
     if (bind(*local_sock, (sockaddr *)&addr, sizeof(addr)) == -1) {
         syslog(LOG_ERR, "bind: Failed to bind to socket\n");
@@ -583,10 +554,11 @@ void callback(evutil_socket_t fd, short event, void *arg) {
 void server_callback(evutil_socket_t fd, short event, void *arg) {
     struct relay_config *config = (struct relay_config *)arg;
     sockaddr_in6 from;
+    socklen_t len = sizeof(from);
     int32_t data = 0;
     static uint8_t message_buffer[4096];
 
-    if ((data = recvfrom(config->local_sock, message_buffer, 4096, 0, (sockaddr *)&from, (socklen_t *)sizeof(from))) == -1) {
+    if ((data = recvfrom(config->local_sock, message_buffer, 4096, 0, (sockaddr *)&from, &len)) == -1) {
         syslog(LOG_WARNING, "recv: Failed to receive data from server\n");
     }
 
@@ -707,7 +679,7 @@ void loop_relay(std::vector<relay_config> *vlans, swss::DBConnector *db) {
 
         filter = sock_open(index, &ether_relay_fprog);
 
-        prepare_socket(&local_sock, &config);
+        prepare_socket(&local_sock, &config, index);
         sockets.push_back(filter);
         sockets.push_back(local_sock);
 
diff --git a/src/dhcp6relay/src/relay.h b/src/dhcp6relay/src/relay.h
index 1d669a585321..eb97f06cd690 100644
--- a/src/dhcp6relay/src/relay.h
+++ b/src/dhcp6relay/src/relay.h
@@ -96,11 +96,12 @@ int sock_open(int ifindex, const struct sock_fprog *fprog);
  * @brief               prepare L3 socket for sending
  *
  * @param local_sock    pointer to socket to be prepared
- * @param config       argument config that contains strings of server and interface addresses
+ * @param config        argument config that contains strings of server and interface addresses
+ * @param index         interface id
  *
  * @return              none
  */
-void prepare_socket(int *local_sock, relay_config *config);
+void prepare_socket(int *local_sock, relay_config *config, int index);
 
 /**
  * @code                        prepare_relay_config(relay_config *interface_config, int local_sock, int filter);