diff --git a/phosphor-rsyslog-config/server-conf.cpp b/phosphor-rsyslog-config/server-conf.cpp
index 61bfaf0..9ed18e8 100644
--- a/phosphor-rsyslog-config/server-conf.cpp
+++ b/phosphor-rsyslog-config/server-conf.cpp
@@ -13,6 +13,7 @@
 #include <arpa/inet.h>
 #include <netdb.h>
 
+#include <optional>
 #include <string>
 
 namespace phosphor
@@ -24,6 +25,82 @@
 using namespace phosphor::logging;
 using namespace sdbusplus::xyz::openbmc_project::Common::Error;
 
+namespace internal
+{
+
+bool isIPv6Address(const std::string& addr)
+{
+    struct in6_addr result;
+    return inet_pton(AF_INET6, addr.c_str(), &result) == 1;
+}
+
+std::optional<std::pair<std::string, uint32_t>> parseConfig(std::istream& ss)
+{
+    std::string line;
+    std::getline(ss, line);
+
+    //"*.* @@<address>:<port>" or
+    //"*.* @@[<ipv6-address>:<port>"
+    constexpr auto start = 6; // Skip "*.* @@"
+    std::string serverAddress;
+    std::string serverPort;
+
+    // Ignore if line is commented
+    if (!line.empty() && '#' != line.at(0))
+    {
+        // Check if there is "[]", and make IPv6 address from it
+        auto posColonLeft = line.find('[');
+        auto posColonRight = line.find(']');
+        if (posColonLeft != std::string::npos ||
+            posColonRight != std::string::npos)
+        {
+            // It contains [ or ], so it should be an IPv6 address
+            if (posColonLeft == std::string::npos ||
+                posColonRight == std::string::npos)
+            {
+                // There either '[' or ']', invalid config
+                return {};
+            }
+            if (line.size() < posColonRight + 2 ||
+                line.at(posColonRight + 1) != ':')
+            {
+                // There is no ':', or no more content after ':', invalid config
+                return {};
+            }
+            serverAddress =
+                line.substr(posColonLeft + 1, posColonRight - posColonLeft - 1);
+            serverPort = line.substr(posColonRight + 2);
+        }
+        else
+        {
+            auto pos = line.find(':');
+            if (pos == std::string::npos)
+            {
+                // There is no ':', invalid config
+                return {};
+            }
+            serverAddress = line.substr(start, pos - start);
+            serverPort = line.substr(pos + 1);
+        }
+    }
+    if (serverAddress.empty() || serverPort.empty())
+    {
+        return {};
+    }
+    try
+    {
+        uint32_t port = std::stoul(serverPort);
+        return std::make_pair(std::move(serverAddress), port);
+    }
+    catch (const std::exception& ex)
+    {
+        log<level::ERR>("Invalid config", entry("ERR=%s", ex.what()));
+        return {};
+    }
+}
+
+} // namespace internal
+
 std::string Server::address(std::string value)
 {
     using Argument = xyz::openbmc_project::Common::InvalidArgument;
@@ -99,7 +176,14 @@
     if (serverPort && !serverAddress.empty())
     {
         // write '*.* @@<remote-host>:<port>'
-        stream << "*.* @@" << serverAddress << ":" << serverPort;
+        if (internal::isIPv6Address(serverAddress))
+        {
+            stream << "*.* @@[" << serverAddress << "]:" << serverPort;
+        }
+        else
+        {
+            stream << "*.* @@" << serverAddress << ":" << serverPort;
+        }
     }
     else // this is a disable request
     {
@@ -133,23 +217,12 @@
 void Server::restore(const char* filePath)
 {
     std::fstream stream(filePath, std::fstream::in);
-    std::string line;
 
-    std::getline(stream, line);
-
-    // Ignore if line is commented
-    if ('#' != line.at(0))
+    auto ret = internal::parseConfig(stream);
+    if (ret)
     {
-        auto pos = line.find(':');
-        if (pos != std::string::npos)
-        {
-            //"*.* @@<address>:<port>"
-            constexpr auto start = 6; // Skip "*.* @@"
-            auto serverAddress = line.substr(start, pos - start);
-            auto serverPort = line.substr(pos + 1);
-            NetworkClient::address(std::move(serverAddress));
-            NetworkClient::port(std::stoul(serverPort));
-        }
+        NetworkClient::address(ret->first);
+        NetworkClient::port(ret->second);
     }
 }
 
diff --git a/test/remote_logging_test_address.cpp b/test/remote_logging_test_address.cpp
index 16d560c..274ac7c 100644
--- a/test/remote_logging_test_address.cpp
+++ b/test/remote_logging_test_address.cpp
@@ -14,6 +14,9 @@
 {
     config->address("1.1.1.1");
     EXPECT_EQ(config->address(), "1.1.1.1");
+
+    config->address("abcd:ef01::01");
+    EXPECT_EQ(config->address(), "abcd:ef01::01");
 }
 
 TEST_F(TestRemoteLogging, testBadAddress)
diff --git a/test/remote_logging_test_config.cpp b/test/remote_logging_test_config.cpp
index cba54ea..53298c6 100644
--- a/test/remote_logging_test_config.cpp
+++ b/test/remote_logging_test_config.cpp
@@ -5,6 +5,13 @@
 
 namespace phosphor
 {
+
+namespace rsyslog_config::internal
+{
+extern std::optional<std::pair<std::string, uint32_t>>
+    parseConfig(std::istream& ss);
+}
+
 namespace logging
 {
 namespace test
@@ -55,6 +62,78 @@
     EXPECT_EQ(getConfig(configFilePath.c_str()), "*.* ~");
 }
 
+TEST_F(TestRemoteLogging, testGoodIPv6Config)
+{
+    config->address("abcd:ef01::01");
+    config->port(50000);
+    EXPECT_EQ(getConfig(configFilePath.c_str()), "*.* @@[abcd:ef01::01]:50000");
+}
+
+TEST_F(TestRemoteLogging, parseConfigGoodIpv6)
+{
+    // A good case
+    std::string str = "*.* @@[abcd:ef01::01]:50000";
+    std::stringstream ss(str);
+    auto ret = phosphor::rsyslog_config::internal::parseConfig(ss);
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(ret->first, "abcd:ef01::01");
+    EXPECT_EQ(ret->second, 50000);
+}
+
+TEST_F(TestRemoteLogging, parseConfigBadIpv6WithoutRightBracket)
+{
+    // Bad case: without ]
+    std::string str = "*.* @@[abcd:ef01::01:50000";
+    std::stringstream ss(str);
+    auto ret = phosphor::rsyslog_config::internal::parseConfig(ss);
+    EXPECT_FALSE(ret);
+}
+
+TEST_F(TestRemoteLogging, parseConfigBadIpv6WithoutLeftBracket)
+{
+    // Bad case: without [
+    std::string str = "*.* @@abcd:ef01::01]:50000";
+    std::stringstream ss(str);
+    auto ret = phosphor::rsyslog_config::internal::parseConfig(ss);
+    EXPECT_FALSE(ret);
+}
+
+TEST_F(TestRemoteLogging, parseConfigBadIpv6WithoutPort)
+{
+    // Bad case: without port
+    std::string str = "*.* @@[abcd:ef01::01]:";
+    std::stringstream ss(str);
+    auto ret = phosphor::rsyslog_config::internal::parseConfig(ss);
+    EXPECT_FALSE(ret);
+}
+
+TEST_F(TestRemoteLogging, parseConfigBadIpv6InvalidPort)
+{
+    // Bad case: without port
+    std::string str = "*.* @@[abcd:ef01::01]:xxx";
+    std::stringstream ss(str);
+    auto ret = phosphor::rsyslog_config::internal::parseConfig(ss);
+    EXPECT_FALSE(ret);
+}
+
+TEST_F(TestRemoteLogging, parseConfigBadIpv6WihtoutColon)
+{
+    // Bad case: invalid IPv6 address
+    std::string str = "*.* @@[abcd:ef01::01]";
+    std::stringstream ss(str);
+    auto ret = phosphor::rsyslog_config::internal::parseConfig(ss);
+    EXPECT_FALSE(ret);
+}
+
+TEST_F(TestRemoteLogging, parseConfigBadEmpty)
+{
+    // Bad case: invalid IPv6 address
+    std::string str = "";
+    std::stringstream ss(str);
+    auto ret = phosphor::rsyslog_config::internal::parseConfig(ss);
+    EXPECT_FALSE(ret);
+}
+
 } // namespace test
 } // namespace logging
 } // namespace phosphor