[WIP]feat: support ipv6

etc/conf/kiwi.conf

@@ -349,4 +349,4 @@ rocksdb-periodic-second 259200;
 ############################### RAFT ###############################
 use-raft no
 # Braft relies on brpc to communicate via the default port number plus the port offset
-raft-port-offset 10
+raft-port-offset 10

src/net/base_socket.cc

@@ -14,7 +14,14 @@
 
 namespace net {
 
-int BaseSocket::CreateTCPSocket() { return ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); }
+int BaseSocket::CreateTCPSocket(const SocketAddr &addr) {
+  if (addr.IsIpv4()) {
+    return ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  } else {
+    return ::socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
+  }
+}
+
 
 int BaseSocket::CreateUDPSocket() { return ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); }
 
@@ -87,6 +94,15 @@ bool BaseSocket::SetReusePort() {
   return false;
 }
 
+bool BaseSocket::SetDisableIpv6Only() {
+  int ipv6only = 0;
+  if (::setsockopt(Fd(), IPPROTO_IPV6, IPV6_V6ONLY, reinterpret_cast<const char *>(&ipv6only), sizeof(ipv6only)) == -1) {
+    WARN("SetIpv6Only fd:{} error:{}", Fd(), errno);
+    return false;
+  }
+  return true;
+}
+
 bool BaseSocket::GetLocalAddr(SocketAddr &addr) {
   sockaddr_in localAddr{};
   socklen_t len = sizeof(localAddr);

src/net/base_socket.h

@@ -9,10 +9,6 @@
 
 #include <sys/socket.h>
 
-#include <functional>
-#include <string>
-
-#include "base_event.h"
 #include "net_event.h"
 #include "socket_addr.h"
 
@@ -34,11 +30,11 @@ class BaseSocket : public NetEvent {
 
   ~BaseSocket() override = default;
 
-  void OnError() override{};
+  void OnError() override {};
 
   void Close() override;
 
-  static int CreateTCPSocket();
+  static int CreateTCPSocket(const SocketAddr &addr);
 
   static int CreateUDPSocket();
 
@@ -57,6 +53,8 @@ class BaseSocket : public NetEvent {
 
   bool SetReusePort();
 
+  bool SetDisableIpv6Only();
+
   bool GetLocalAddr(SocketAddr &);
 
   bool GetPeerAddr(SocketAddr &);

src/net/callback_function.h

@@ -62,7 +62,7 @@ class NetEvent;
 
 // Auxiliary structure
 struct Connection {
-  explicit Connection(std::unique_ptr<NetEvent> netEvent) : netEvent_(std::move(netEvent)), addr_(0, 0) {}
+  explicit Connection(std::unique_ptr<NetEvent> netEvent) : netEvent_(std::move(netEvent)) {}
 
   ~Connection() = default;
 

src/net/client_socket.cc

@@ -7,12 +7,13 @@
 
 #include <sstream>
 
+#include <sys/socket.h>
 #include "client_socket.h"
 
 namespace net {
 
 bool ClientSocket::Connect() {
-  fd_ = CreateTCPSocket();
+  fd_ = CreateTCPSocket(addr_);
   if (fd_ == -1) {
     onConnectFail_("CreateTCPSocket open socket failed");
     return false;
@@ -22,7 +23,7 @@ bool ClientSocket::Connect() {
   SetRcvBuf();
   SetSndBuf();
 
-  auto ret = connect(Fd(), (sockaddr*)&addr_.GetAddr(), sizeof(sockaddr_in));
+  int ret = connect(Fd(), addr_.GetAddr(), addr_.GetAddrLen());
   if (0 != ret) {
     if (EINPROGRESS == errno) {
       return true;

src/net/listen_socket.cc

@@ -6,6 +6,7 @@
  */
 
 #include <netinet/tcp.h>
+#include <sys/socket.h>
 
 #include "config.h"
 #include "listen_socket.h"
@@ -19,7 +20,7 @@ const int ListenSocket::LISTENQ = 1024;
 bool ListenSocket::REUSE_PORT = true;
 
 int ListenSocket::OnReadable(const std::shared_ptr<Connection> &conn, std::string *readBuff) {
-  struct sockaddr_in clientAddr {};
+  struct sockaddr_in clientAddr{};
   auto newConnFd = Accept(&clientAddr);
   if (newConnFd == 0) {
     ERROR("ListenSocket fd:{},Accept error:{}", Fd(), errno);
@@ -68,7 +69,7 @@ bool ListenSocket::Open() {
   }
 
   if (SocketType() == SOCKET_LISTEN_TCP) {
-    fd_ = CreateTCPSocket();
+    fd_ = CreateTCPSocket(addr_);
   } else if (SocketType() == SOCKET_LISTEN_UDP) {
     fd_ = CreateUDPSocket();
   } else {
@@ -88,15 +89,17 @@ bool ListenSocket::Bind() {
   if (!SetReusePort()) {
     REUSE_PORT = false;
   }
+  if (addr_.IsIpv6()) {
+    SetDisableIpv6Only();
+  }
 
-  struct sockaddr_in serv = addr_.GetAddr();
-
-  int ret = ::bind(Fd(), reinterpret_cast<struct sockaddr *>(&serv), sizeof serv);
+  int ret = ::bind(Fd(), addr_.GetAddr(), addr_.GetAddrLen());
   if (0 != ret) {
     ERROR("ListenSocket fd:{},Bind error:{}", Fd(), errno);
     Close();
     return false;
   }
+
   return true;
 }
 

src/net/socket_addr.h

@@ -18,57 +18,118 @@ namespace net {
 struct SocketAddr {
   SocketAddr() { Clear(); }
 
-  SocketAddr(const SocketAddr &other) { memcpy(&addr_, &other.addr_, sizeof addr_); }
+  SocketAddr(const SocketAddr &other) { memcpy(&addr_, &other.addr_, sizeof(addr_)); }
 
   SocketAddr &operator=(const SocketAddr &other) {
     if (this != &other) {
-      memcpy(&addr_, &other.addr_, sizeof addr_);
+      memcpy(&addr_, &other.addr_, sizeof(addr_));
     }
     return *this;
   }
 
   explicit SocketAddr(const sockaddr_in &addr) { Init(addr); }
 
-  SocketAddr(uint32_t netip, uint16_t netport) { Init(netip, netport); }
+  explicit SocketAddr(const sockaddr_in6 &addr) { Init(addr); }
 
   SocketAddr(const std::string &ip, uint16_t hostport) { Init(ip, hostport); }
 
   void Init(const sockaddr_in &addr) { memcpy(&addr_, &addr, sizeof(addr)); }
 
-  void Init(uint32_t netIp, uint16_t netPort) {
-    addr_.sin_family = AF_INET;
-    addr_.sin_addr.s_addr = netIp;
-    addr_.sin_port = netPort;
-  }
+  void Init(const sockaddr_in6 &addr) { memcpy(&addr_, &addr, sizeof(addr)); }
 
   void Init(const std::string &ip, uint16_t hostPort) {
-    addr_.sin_family = AF_INET;
-    addr_.sin_addr.s_addr = ::inet_addr(ip.data());
-    addr_.sin_port = htons(hostPort);
+    if (::inet_pton(AF_INET, ip.c_str(), &addr_.addr4_.sin_addr) == 1) {
+      addr_.addr4_.sin_family = AF_INET;
+      addr_.addr4_.sin_port = htons(hostPort);
+    } else if (::inet_pton(AF_INET6, ip.c_str(), &addr_.addr6_.sin6_addr) == 1) {
+      addr_.addr6_.sin6_family = AF_INET6;
+      addr_.addr6_.sin6_port = htons(hostPort);
+    }
+  }
+
+  const sockaddr *GetAddr() const {
+    if (IsIpv4()) {
+      return reinterpret_cast<const sockaddr *>(&addr_.addr4_);
+    } else if (IsIpv6()) {
+      return reinterpret_cast<const sockaddr *>(&addr_.addr6_);
+    }
+    return nullptr;
   }
 
-  const sockaddr_in &GetAddr() const { return addr_; }
+  socklen_t GetAddrLen() const {
+    if (IsIpv4()) {
+      return sizeof(addr_.addr4_);
+    } else if (IsIpv6()) {
+      return sizeof(addr_.addr6_);
+    }
+    return 0;
+  }
+
+  std::string GetIP() const {
+    if (IsIpv4()) {
+      char ipv4_buf[INET_ADDRSTRLEN] = {0};
+      if (::inet_ntop(AF_INET, &addr_.addr4_.sin_addr, ipv4_buf, sizeof(ipv4_buf))) {
+        return ipv4_buf;
+      }
+    } else if (IsIpv6()) {
+      char ipv6_buf[INET6_ADDRSTRLEN] = {0};
+      if (::inet_ntop(AF_INET6, &addr_.addr6_.sin6_addr, ipv6_buf, sizeof(ipv6_buf))) {
+        return ipv6_buf;
+      }
+    }
+    return {};
+  }
 
-  inline std::string GetIP() const { return ::inet_ntoa(addr_.sin_addr); }
+  std::string GetIP(char *buf, socklen_t size) const {
+    if (IsIpv4()) {
+      if (::inet_ntop(AF_INET, &addr_.addr4_.sin_addr, buf, size)) {
+        return buf;
+      }
+    } else if (IsIpv6()) {
+      if (::inet_ntop(AF_INET6, &addr_.addr6_.sin6_addr, buf, size)) {
+        return buf;
+      }
+    }
+    return {};
+  }
 
-  inline std::string GetIP(char *buf, socklen_t size) const {
-    return ::inet_ntop(AF_INET, reinterpret_cast<const char *>(&addr_.sin_addr), buf, size);
+  uint16_t GetPort() const {
+    if (IsIpv4()) {
+      return ntohs(addr_.addr4_.sin_port);
+    } else if (IsIpv6()) {
+      return ntohs(addr_.addr6_.sin6_port);
+    }
+    return 0;
   }
 
-  inline uint16_t GetPort() const { return ntohs(addr_.sin_port); }
+  bool IsValid() const { return addr_.addr4_.sin_family != 0 || addr_.addr6_.sin6_family != 0; }
+
+  bool IsIpv6() const { return addr_.addr6_.sin6_family == AF_INET6; }
 
-  inline bool IsValid() const { return 0 != addr_.sin_family; }
+  bool IsIpv4() const { return addr_.addr4_.sin_family == AF_INET; }
 
-  void Clear() { memset(&addr_, 0, sizeof addr_); }
+  void Clear() { memset(&addr_, 0, sizeof(addr_)); }
+
+  friend bool operator==(const SocketAddr &a, const SocketAddr &b) {
+    if (a.IsIpv4() != b.IsIpv4()) {
+      return false;
+    }
+
+    if (a.IsIpv4()) {
+      return a.addr_.addr4_.sin_addr.s_addr == b.addr_.addr4_.sin_addr.s_addr &&
+             a.addr_.addr4_.sin_port == b.addr_.addr4_.sin_port;
+    }
 
-  inline friend bool operator==(const SocketAddr &a, const SocketAddr &b) {
-    return a.addr_.sin_family == b.addr_.sin_family && a.addr_.sin_addr.s_addr == b.addr_.sin_addr.s_addr &&
-           a.addr_.sin_port == b.addr_.sin_port;
+    return memcmp(&a.addr_.addr6_.sin6_addr, &b.addr_.addr6_.sin6_addr, sizeof(in6_addr)) == 0 &&
+           a.addr_.addr6_.sin6_port == b.addr_.addr6_.sin6_port;
   }
 
-  inline friend bool operator!=(const SocketAddr &a, const SocketAddr &b) { return !(a == b); }
+  friend bool operator!=(const SocketAddr &a, const SocketAddr &b) { return !(a == b); }
 
-  sockaddr_in addr_{};
+  union {
+    sockaddr_in addr4_;
+    sockaddr_in6 addr6_;
+  } addr_;
 };
 
 }  // namespace net