/*

 * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>

 *

 * SPDX-License-Identifier: AGPL-3.0-or-later

 *

 * This program is free software: you can use, redistribute, and/or modify

 * it under the terms of the GNU Affero General Public License, version 3

 * or later ("AGPL"), as published by the Free Software Foundation.

 *

 * This program is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.

 *

 * You should have received a copy of the GNU Affero General Public License

 * along with this program. If not, see <http://www.gnu.org/licenses/>.

 */

#define _DEFAULT_SOURCE

#define ALLOW_FORBID_FUNC

#include "os.h"

#if defined(WINDOWS)

#include <IPHlpApi.h>

#include <WS2tcpip.h>

#include <Winsock2.h>

#include <stdio.h>

#include <string.h>

#include <tchar.h>

#include <winbase.h>

#else

#include <arpa/inet.h>

#include <fcntl.h>

#include <net/if.h>

#include <netdb.h>

#include <netinet/in.h>

#include <netinet/ip.h>

#include <netinet/tcp.h>

#include <netinet/udp.h>

#include <sys/socket.h>

#include <unistd.h>

#if defined(DARWIN)

#include <dispatch/dispatch.h>

#include "osEok.h"

#elif !defined(TD_ASTRA)

#include <sys/epoll.h>

#endif

#endif

#ifdef TD_ASTRA

#ifndef __BYTE_ORDER

#define __BYTE_ORDER _BYTE_ORDER

#endif

#ifndef __BIG_ENDIAN

#define __BIG_ENDIAN _BIG_ENDIAN

#endif

#ifndef __LITTLE_ENDIAN

#define __LITTLE_ENDIAN _LITTLE_ENDIAN

#endif

#endif  // TD_ASTRA

#ifndef INVALID_SOCKET

#define INVALID_SOCKET -1

#endif

typedef struct TdSocket {

#if SOCKET_WITH_LOCK

  TdThreadRwlock rwlock;

#endif

  int      refId;

  SocketFd fd;

} * TdSocketPtr, TdSocket;

typedef struct TdSocketServer {

#if SOCKET_WITH_LOCK

  TdThreadRwlock rwlock;

#endif

  int      refId;

  SocketFd fd;

} * TdSocketServerPtr, TdSocketServer;

typedef struct TdEpoll {

#if SOCKET_WITH_LOCK

  TdThreadRwlock rwlock;

#endif

  int     refId;

  EpollFd fd;

} * TdEpollPtr, TdEpoll;

int32_t taosCloseSocketNoCheck1(SocketFd fd) {

#ifdef WINDOWS

  int ret = closesocket(fd);

  if (ret == SOCKET_ERROR) {

    int errorCode = WSAGetLastError();

    return terrno = TAOS_SYSTEM_WINSOCKET_ERROR(errorCode);

  }

  return 0;

#else

  int32_t code = close(fd);

  if (-1 == code) {

    terrno = TAOS_SYSTEM_ERROR(ERRNO);

    return terrno;

  }

  return code;

#endif

}

int32_t taosCloseSocket(TdSocketPtr *ppSocket) {

  int32_t code;

  if (ppSocket == NULL || *ppSocket == NULL || (*ppSocket)->fd < 0) {

    terrno = TSDB_CODE_INVALID_PARA;

    return terrno;

  }

  code = taosCloseSocketNoCheck1((*ppSocket)->fd);

  (*ppSocket)->fd = -1;

  taosMemoryFree(*ppSocket);

  return code;

}

int32_t taosSetSockOpt(TdSocketPtr pSocket, int32_t level, int32_t optname, void *optval, int32_t optlen) {

  if (pSocket == NULL || pSocket->fd < 0) {

    terrno = TSDB_CODE_INVALID_PARA;

    return terrno;

  }

#ifdef WINDOWS

#ifdef TCP_KEEPCNT

  if (level == SOL_SOCKET && optname == TCP_KEEPCNT) {

    return 0;

  }

#endif

#ifdef TCP_KEEPIDLE

  if (level == SOL_TCP && optname == TCP_KEEPIDLE) {

    return 0;

  }

#endif

#ifdef TCP_KEEPINTVL

  if (level == SOL_TCP && optname == TCP_KEEPINTVL) {

    return 0;

  }

#endif

#ifdef TCP_KEEPCNT

  if (level == SOL_TCP && optname == TCP_KEEPCNT) {

    return 0;

  }

#endif

  int ret = setsockopt(pSocket->fd, level, optname, optval, optlen);

  if (ret == SOCKET_ERROR) {

    int errorCode = WSAGetLastError();

    return terrno = TAOS_SYSTEM_WINSOCKET_ERROR(errorCode);

  }

#else

  int32_t code = setsockopt(pSocket->fd, level, optname, optval, (int)optlen);

  if (-1 == code) {

    terrno = TAOS_SYSTEM_ERROR(ERRNO);

    return terrno;

  }

  return 0;

#endif

}

const char *taosInetNtop(struct in_addr ipInt, char *dstStr, int32_t len) {

  const char *r = inet_ntop(AF_INET, &ipInt, dstStr, len);

  if (NULL == r) {

    terrno = TAOS_SYSTEM_ERROR(ERRNO);

  }

  return r;

}

#ifndef SIGPIPE

#define SIGPIPE EPIPE

#endif

#define TCP_CONN_TIMEOUT 3000  // conn timeout

int8_t taosValidIpAndPort(uint32_t ip, uint16_t port) {

  struct sockaddr_in serverAdd;

  SocketFd           fd;

  int32_t            reuse;

  int32_t            code = 0;

  // printf("open tcp server socket:0x%x:%hu", ip, port);

  bzero((char *)&serverAdd, sizeof(serverAdd));

  serverAdd.sin_family = AF_INET;

#ifdef WINDOWS

  serverAdd.sin_addr.s_addr = INADDR_ANY;

#else

  serverAdd.sin_addr.s_addr = ip;

#endif

  serverAdd.sin_port = (uint16_t)htons(port);

  fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

  if (-1 == fd) {  // exception

    terrno = TAOS_SYSTEM_ERROR(ERRNO);

    return 0;

  }

  TdSocketPtr pSocket = (TdSocketPtr)taosMemoryMalloc(sizeof(TdSocket));

  if (pSocket == NULL) {

    TAOS_SKIP_ERROR(taosCloseSocketNoCheck1(fd));

    return 0;

  }

  pSocket->refId = 0;

  pSocket->fd = fd;

  /* set REUSEADDR option, so the portnumber can be re-used */

  reuse = 1;

  if (taosSetSockOpt(pSocket, SOL_SOCKET, SO_REUSEADDR, (void *)&reuse, sizeof(reuse)) < 0) {

    TAOS_SKIP_ERROR(taosCloseSocket(&pSocket));

    return 0;

  }

  /* bind socket to server address */

  if (-1 == bind(pSocket->fd, (struct sockaddr *)&serverAdd, sizeof(serverAdd))) {

    terrno = TAOS_SYSTEM_ERROR(ERRNO);

    TAOS_SKIP_ERROR(taosCloseSocket(&pSocket));

    return 0;

  }

  TAOS_SKIP_ERROR(taosCloseSocket(&pSocket));

  return 1;

}

int32_t taosBlockSIGPIPE() {

#ifdef WINDOWS

  return 0;

#else

  sigset_t signal_mask;

  (void)sigemptyset(&signal_mask);

  (void)sigaddset(&signal_mask, SIGPIPE);

  int32_t rc = pthread_sigmask(SIG_BLOCK, &signal_mask, NULL);

  if (rc != 0) {

    terrno = TAOS_SYSTEM_ERROR(rc);

    return terrno;

  }

  return 0;

#endif

}

// Classify a socket address as private/internal or public.

// Recognizes RFC-1918, loopback, link-local, CGNAT, ULA, and other reserved ranges.

// Used as the core validation primitive by taosIsPrivateUrl (DNS check) and by the

// libcurl opensocket callback in tanalytics.c (connection-time check). Cross-platform:

// works identically on POSIX and Winsock2 (sockaddr_in, sockaddr_in6, ntohl, memcmp are

// standard).

// Fail-closed: returns true (block) for NULL, unknown address families (AF_UNIX,

// AF_UNSPEC, etc.), and all private/reserved ranges; returns false only for

// recognized public IPv4/IPv6 addresses.

bool taosIsPrivateIp(const struct sockaddr *addr) {

  if (addr == NULL) return true;

  if (addr->sa_family == AF_INET) {

    uint32_t ip = ntohl(((const struct sockaddr_in *)addr)->sin_addr.s_addr);

    return (ip >> 24) == 0 ||                    /* 0.0.0.0/8      this-network  */

           (ip >> 24) == 10 ||                   /* 10.0.0.0/8     RFC-1918      */

           (ip >> 24) == 127 ||                  /* 127.0.0.0/8    loopback      */

           (ip & 0xffc00000U) == 0x64400000U ||  /* 100.64.0.0/10  CGNAT         */

           (ip & 0xffff0000U) == 0xa9fe0000U ||  /* 169.254.0.0/16 link-local    */

           (ip & 0xfff00000U) == 0xac100000U ||  /* 172.16.0.0/12  RFC-1918      */

           (ip & 0xffffff00U) == 0xc0000000U ||  /* 192.0.0.0/24   IETF protocol */

           (ip & 0xffff0000U) == 0xc0a80000U ||  /* 192.168.0.0/16 RFC-1918      */

           (ip & 0xff000000U) == 0xe0000000U ||  /* 224.0.0.0/4    multicast     */

           (ip & 0xf0000000U) == 0xf0000000U ||  /* 240.0.0.0/4    reserved      */

           (ip & 0xfffe0000U) == 0xc6120000U ||  /* 198.18.0.0/15  benchmarking  */

           ip == 0xffffffffU;                    /* 255.255.255.255 broadcast    */

  }

  if (addr->sa_family == AF_INET6) {

    const uint8_t       *b = ((const struct sockaddr_in6 *)addr)->sin6_addr.s6_addr;

    static const uint8_t v4mapped[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff};

    /* ::ffff:a.b.c.d  IPv4-mapped address, apply the IPv4 rules to the low 32 bits */

    if (memcmp(b, v4mapped, sizeof(v4mapped)) == 0) {

      struct sockaddr_in v4 = {0};

      v4.sin_family = AF_INET;

      memcpy(&v4.sin_addr, b + 12, 4);

      return taosIsPrivateIp((const struct sockaddr *)&v4);

    }

    static const uint8_t loopback6[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};

    bool                 isUnspecified = true;

    for (int32_t i = 0; i < 16; ++i) {

      if (b[i] != 0) {

        isUnspecified = false;

        break;

      }

    }

    return isUnspecified ||                            /* ::      unspecified  */

           memcmp(b, loopback6, sizeof(loopback6)) == 0 || /* ::1  loopback    */

           (b[0] == 0xfe && (b[1] & 0xc0) == 0x80) ||  /* fe80::/10 link-local */

           (b[0] == 0xfe && (b[1] & 0xc0) == 0xc0) ||  /* fec0::/10 site-local */

           (b[0] == 0xff) ||                           /* ff00::/8  multicast  */

           (b[0] & 0xfe) == 0xfc;                      /* fc00::/7  ULA        */

  }

  // fail-closed: unknown address families (AF_UNIX, AF_UNSPEC, etc.) are treated as

  // internal/blocked rather than allowed through as "public".

  return true;

}

/*

 * Extract the host part from a url into host.

 * Handles the optional "userinfo@" prefix, the optional ":port" suffix and

 * bracketed IPv6 literals such as http://[fe80::1]:6041/path.

 * IPv6 zone IDs (e.g. http://[fe80::1%25eth0]:6041) are stripped before

 * returning so that getaddrinfo receives a bare address without the zone suffix.

 * Returns 0 on success, -1 when the authority component can not be parsed.

 */

static int32_t taosParseUrlHost(const char *url, char *host, int32_t hostLen) {

  if (url == NULL || host == NULL || hostLen <= 0) return -1;

  const char *p = strstr(url, "://");

  if (p == NULL) return -1;

  p += 3;

  /* the authority component ends at the first '/', '?' or '#' */

  const char *authEnd = p + strcspn(p, "/?#");

  /* the host starts after the last '@' of the userinfo part */

  const char *hostStart = p;

  for (const char *q = p; q < authEnd; ++q) {

    if (*q == '@') hostStart = q + 1;

  }

  if (hostStart >= authEnd) return -1;

  if (*hostStart == '[') {

    /* bracketed IPv6 literal, the port follows the closing ']' */

    const char *close = memchr(hostStart + 1, ']', (size_t)(authEnd - hostStart - 1));

    if (close == NULL) return -1;

    int32_t len = (int32_t)(close - hostStart - 1);

    if (len <= 0 || len >= hostLen) return -1;

    memcpy(host, hostStart + 1, len);

    host[len] = '\0';

    /* strip IPv6 zone ID: "fe80::1%25eth0" -> "fe80::1" (RFC 6874 percent-encodes '%' as %25) */

    char *zone = strchr(host, '%');

    if (zone != NULL) *zone = '\0';

    return 0;

  }

  /* plain host name or IPv4 literal, exclude the optional ":port" */

  int32_t     len   = (int32_t)(authEnd - hostStart);

  const char *colon = memchr(hostStart, ':', (size_t)len);

  if (colon != NULL) len = (int32_t)(colon - hostStart);

  if (len <= 0 || len >= hostLen) return -1;

  memcpy(host, hostStart, len);

  host[len] = '\0';

  return 0;

}

// Perform a fast, early rejection of URLs that resolve to private/internal addresses.

// IMPORTANT: This is a front-gate check only, not a complete SSRF defense.

// DNS rebinding (TOCTOU window) can occur between this check and actual connection:

// - At check time, getaddrinfo(host) may resolve to a public IP, passing this check.

// - At connection time (curl), the same hostname may resolve to a private IP.

// Mitigation: all callers MUST validate the peer address at connection time.

// For curl-based transports, install a CURLOPT_OPENSOCKETFUNCTION callback: it runs

// before connect() and is handed the resolved peer address (see taosCurlOpensocketCb

// in tanalytics.c), so rejecting there closes this window and no connection to the

// internal address is ever made. CURLOPT_SOCKOPTFUNCTION can not be used for that:

// it also runs before connect(), where getpeername() reports no peer yet.

bool taosIsPrivateUrl(const char *url) {

  if (url == NULL) return true;

  char host[256] = {0};

  if (taosParseUrlHost(url, host, (int32_t)sizeof(host)) != 0) return true;

  /* fail closed: only a resolved public address clears the verdict */

  bool blocked = true;

#ifdef WINDOWS

  // Initialize Winsock, getaddrinfo is a Winsock 2 API and fails with

  // WSANOTINITIALISED when no WSAStartup 2.x has been performed in this process

  // (taosWinSocketInit negotiates 1.1 only), which would block every URL.

  WSADATA wsaData;

  int     iResult;

  iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);

  if (iResult != 0) {

    uError("taosIsPrivateUrl: WSAStartup failed: %d, treating '%s' as blocked", iResult, host);

    return true;

  }

#endif

  struct addrinfo hints = {0}, *res = NULL, *rp;

  hints.ai_family   = AF_UNSPEC;

  hints.ai_socktype = SOCK_STREAM;

  int rc = getaddrinfo(host, NULL, &hints, &res);

  if (rc != 0) {

    uError("taosIsPrivateUrl: DNS resolution failed for '%s': %s; treating as blocked", host, gai_strerror(rc));

    goto _err;

  }

  blocked = false;

  for (rp = res; rp != NULL; rp = rp->ai_next) {

    if (taosIsPrivateIp(rp->ai_addr)) {

      uDebug("taosIsPrivateUrl: '%s' resolves to a private/internal address, blocked", host);

      blocked = true;

      break;

    }

  }

  freeaddrinfo(res);

_err:

#ifdef WINDOWS

  WSACleanup();

#endif

  return blocked;

}

int32_t taosGetIpv4FromFqdn(const char *fqdn, uint32_t *ip) {

  int32_t code = 0;

  OS_PARAM_CHECK(fqdn);

  OS_PARAM_CHECK(ip);

  int64_t limitMs = 1000;

  int64_t st = taosGetTimestampMs(), cost = 0;

#ifdef WINDOWS

  // Initialize Winsock

  WSADATA wsaData;

  int     iResult;

  iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);

  if (iResult != 0) {

    code = TAOS_SYSTEM_WINSOCKET_ERROR(WSAGetLastError());

    goto _err;

  }

#endif

#if defined(LINUX)

  struct addrinfo hints = {0};

  hints.ai_family = AF_INET;

  hints.ai_socktype = SOCK_STREAM;

  struct addrinfo *result = NULL;

  bool             inRetry = false;

  while (true) {

    int32_t ret = getaddrinfo(fqdn, NULL, &hints, &result);

    if (ret) {

      if (EAI_AGAIN == ret && !inRetry) {

        inRetry = true;

        continue;

      } else if (EAI_SYSTEM == ret) {

        code = TAOS_SYSTEM_ERROR(ERRNO);

        goto _err;

      }

      code = TAOS_SYSTEM_ERROR(ERRNO);

      goto _err;

    }

    struct sockaddr    *sa = result->ai_addr;

    struct sockaddr_in *si = (struct sockaddr_in *)sa;

    struct in_addr      ia = si->sin_addr;

    *ip = ia.s_addr;

    freeaddrinfo(result);

    goto _err;

  }

#else

  struct addrinfo hints = {0};

  hints.ai_family = AF_INET;

  hints.ai_socktype = SOCK_STREAM;

  struct addrinfo *result = NULL;

  int32_t ret = getaddrinfo(fqdn, NULL, &hints, &result);

  if (result) {

    struct sockaddr    *sa = result->ai_addr;

    struct sockaddr_in *si = (struct sockaddr_in *)sa;

    struct in_addr      ia = si->sin_addr;

    *ip = ia.s_addr;

    freeaddrinfo(result);

    goto _err;

  } else {

#ifdef EAI_SYSTEM

    if (ret == EAI_SYSTEM) {

      // printf("failed to get the ip address, fqdn:%s, errno:%d, since:%s", fqdn, ERRNO, strerror(ERRNO));

    } else {

      // printf("failed to get the ip address, fqdn:%s, ret:%d, since:%s", fqdn, ret, gai_strerror(ret));

    }

#else

    // printf("failed to get the ip address, fqdn:%s, ret:%d, since:%s", fqdn, ret, gai_strerror(ret));

#endif

    *ip = 0xFFFFFFFF;

    code = TSDB_CODE_RPC_FQDN_ERROR;

    goto _err;

  }

#endif

_err:

  cost = taosGetTimestampMs() - st;

  if (cost >= limitMs) {

    uWarn("get ip from fqdn:%s, cost:%" PRId64 "ms", fqdn, cost);

  }

  return code;

}

int32_t taosGetIpv6FromFqdn(const char *fqdn, SIpAddr *pAddr) {

  int32_t code = 0;

  OS_PARAM_CHECK(fqdn);

  int64_t limitMs = 1000;

  int64_t st = taosGetTimestampMs(), cost = 0;

#ifdef WINDOWS

  // Initialize Winsock

  WSADATA wsaData;

  int     iResult;

  iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);

  if (iResult != 0) {

    code = TAOS_SYSTEM_WINSOCKET_ERROR(WSAGetLastError());

    goto _err;

  }

#endif

#if defined(LINUX)

  struct addrinfo hints = {0};

  hints.ai_family = AF_UNSPEC;

  hints.ai_socktype = SOCK_STREAM;

  struct addrinfo *result = NULL;

  bool             inRetry = false;

  char ipStr[INET6_ADDRSTRLEN];

  while (true) {

    int32_t ret = getaddrinfo(fqdn, NULL, &hints, &result);

    if (ret) {

      if (EAI_AGAIN == ret && !inRetry) {

        inRetry = true;

        continue;

      } else if (EAI_SYSTEM == ret) {

        code = TAOS_SYSTEM_ERROR(ERRNO);

        goto _err;

      }

      code = TAOS_SYSTEM_ERROR(ERRNO);

      goto _err;

    }

    if (result->ai_family == AF_INET6) {

      struct sockaddr_in6 *p6 = (struct sockaddr_in6 *)result->ai_addr;

      const char *t = inet_ntop(AF_INET6, &p6->sin6_addr, pAddr->ipv6, sizeof(pAddr->ipv6));

      TAOS_UNUSED(t);

      pAddr->type = 1;

    } else if (result->ai_family == AF_INET) {

      struct sockaddr_in *p4 = (struct sockaddr_in *)result->ai_addr;

      const char *t = inet_ntop(AF_INET, &p4->sin_addr, pAddr->ipv4, sizeof(pAddr->ipv4));

      TAOS_UNUSED(t);

      pAddr->type = 0;

    } else {

      code = TSDB_CODE_RPC_FQDN_ERROR;

      goto _err;

    }

    freeaddrinfo(result);

    goto _err;

  }

#else

  struct addrinfo hints = {0};

  hints.ai_family = AF_UNSPEC;

  hints.ai_socktype = SOCK_STREAM;

  struct addrinfo *result = NULL;

  int32_t ret = getaddrinfo(fqdn, NULL, &hints, &result);

  if (result) {

    if (result->ai_family == AF_INET6) {

      struct sockaddr_in6 *p6 = (struct sockaddr_in6 *)result->ai_addr;

      inet_ntop(AF_INET6, &p6->sin6_addr, pAddr->ipv6, sizeof(pAddr->ipv6));

      pAddr->type = 1;

    } else if (result->ai_family == AF_INET) {

      struct sockaddr_in *p4 = (struct sockaddr_in *)result->ai_addr;

      inet_ntop(AF_INET, &p4->sin_addr, pAddr->ipv4, sizeof(pAddr->ipv4));

      pAddr->type = 0;

    } else {

      code = TSDB_CODE_RPC_FQDN_ERROR;

      goto _err;

    }

    freeaddrinfo(result);

    goto _err;

  } else {

#ifdef EAI_SYSTEM

    if (ret == EAI_SYSTEM) {

      // printf("failed to get the ip address, fqdn:%s, errno:%d, since:%s", fqdn, ERRNO, strerror(ERRNO));

    } else {

      // printf("failed to get the ip address, fqdn:%s, ret:%d, since:%s", fqdn, ret, gai_strerror(ret));

    }

#else

    // printf("failed to get the ip address, fqdn:%s, ret:%d, since:%s", fqdn, ret, gai_strerror(ret));

#endif

  }

#endif

_err:

  cost = taosGetTimestampMs() - st;

  if (cost >= limitMs) {

    uWarn("get ip from fqdn:%s, cost:%" PRId64 "ms", fqdn, cost);

  }

#ifdef WINDOWS

  WSACleanup();

#endif

  return code;

}

int32_t taosGetIp4FromFqdn(const char *fqdn, SIpAddr *pAddr) {

  int32_t code = 0;

  OS_PARAM_CHECK(fqdn);

  int64_t limitMs = 1000;

  int64_t st = taosGetTimestampMs(), cost = 0;

#ifdef WINDOWS

  // Initialize Winsock

  WSADATA wsaData;

  int     iResult;

  iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);

  if (iResult != 0) {

    code = TAOS_SYSTEM_WINSOCKET_ERROR(WSAGetLastError());

    goto _err;

  }

#endif

#if defined(LINUX)

  struct addrinfo hints = {0};

  hints.ai_family = AF_INET;

  hints.ai_socktype = SOCK_STREAM;

  struct addrinfo *result = NULL;

  bool             inRetry = false;

  char ipStr[INET6_ADDRSTRLEN];

  while (true) {

    int32_t ret = getaddrinfo(fqdn, NULL, &hints, &result);

    if (ret) {

      if (EAI_AGAIN == ret && !inRetry) {

        inRetry = true;

        continue;

      } else if (EAI_SYSTEM == ret) {

        code = TAOS_SYSTEM_ERROR(ERRNO);

        goto _err;

      }

      code = TAOS_SYSTEM_ERROR(ERRNO);

      goto _err;

    }

    if (result->ai_family == AF_INET) {

      struct sockaddr_in *p4 = (struct sockaddr_in *)result->ai_addr;

      const char         *t = inet_ntop(AF_INET, &p4->sin_addr, pAddr->ipv4, sizeof(pAddr->ipv4));

      TAOS_UNUSED(t);

      pAddr->type = 0;

    } else {

      code = TSDB_CODE_RPC_FQDN_ERROR;

      goto _err;

    }

    freeaddrinfo(result);

    goto _err;

  }

#else

  struct addrinfo hints = {0};

  hints.ai_family = AF_INET;

  hints.ai_socktype = SOCK_STREAM;

  struct addrinfo *result = NULL;

  int32_t ret = getaddrinfo(fqdn, NULL, &hints, &result);

  if (result) {

    struct sockaddr_in *p4 = (struct sockaddr_in *)result->ai_addr;

    inet_ntop(AF_INET, &p4->sin_addr, pAddr->ipv4, sizeof(pAddr->ipv4));

    freeaddrinfo(result);

    pAddr->type = 0;

    goto _err;

  } else {

#ifdef EAI_SYSTEM

    if (ret == EAI_SYSTEM) {

      // printf("failed to get the ip address, fqdn:%s, errno:%d, since:%s", fqdn, ERRNO, strerror(ERRNO));

    } else {

      // printf("failed to get the ip address, fqdn:%s, ret:%d, since:%s", fqdn, ret, gai_strerror(ret));

    }

    code = TSDB_CODE_RPC_FQDN_ERROR;

#else

    // printf("failed to get the ip address, fqdn:%s, ret:%d, since:%s", fqdn, ret, gai_strerror(ret));

#endif

  }

#endif

_err:

  cost = taosGetTimestampMs() - st;

  if (cost >= limitMs) {

    uWarn("get ip from fqdn:%s, cost:%" PRId64 "ms", fqdn, cost);

  }

#ifdef WINDOWS

  WSACleanup();

#endif

  return code;

}

int32_t taosGetIpFromFqdn(int8_t enableIpv6, const char *fqdn, SIpAddr *addr) {

  int32_t code = 0;

  if (enableIpv6) {

    code = taosGetIpv6FromFqdn(fqdn, addr);

  } else {

    code = taosGetIp4FromFqdn(fqdn, addr);

  }

  return code;

}

int8_t taosIpAddrIsEqual(SIpAddr *ip1, SIpAddr *ip2) {

  if (ip1->type == ip2->type) {

    if (ip1->type == 0) {

      return (strcmp(ip1->ipv4, ip2->ipv4) == 0 ? 1 : 0);

    } else {

      return (strcmp(ip1->ipv6, ip2->ipv6) == 0 ? 1 : 0);

    }

  }

  return 0;

}

int32_t taosGetFqdnWithTimeCost(char *fqdn, int64_t *timeoutMs) {

  int32_t code = 0;

  int64_t startMs = taosGetTimestampMs();

  code = taosGetFqdn(fqdn);

  int64_t cost = taosGetTimestampMs() - startMs;

  if (timeoutMs != NULL) {

    *timeoutMs = cost;

  }

  return code;

}

int32_t taosGetFqdn(char *fqdn) {

  OS_PARAM_CHECK(fqdn);

#ifdef WINDOWS

  // Initialize Winsock

  WSADATA wsaData;

  int     iResult;

  iResult = WSAStartup(MAKEWORD(2, 2), &wsaData);

  if (iResult != 0) {

    // printf("WSAStartup failed: %d\n", iResult);

    return TAOS_SYSTEM_WINSOCKET_ERROR(WSAGetLastError());

  }

#endif

  char hostname[1024];

  hostname[1023] = '\0';

  int32_t code = taosGetlocalhostname(hostname, 1023);

  if (code) {

    return code;

  }

#ifdef __APPLE__

  // on macosx, hostname -f has the form of xxx.local

  // which will block getaddrinfo for a few seconds if AI_CANONNAME is set

  // thus, we choose AF_INET (ipv4 for the moment) to make getaddrinfo return

  // immediately

  // hints.ai_family = AF_INET;

  tstrncpy(fqdn, hostname, TD_FQDN_LEN);

  tstrncpy(fqdn + strlen(hostname), ".local", TD_FQDN_LEN - strlen(hostname));

#else  // linux

#endif  // linux

#if defined(TD_ASTRA)

  tstrncpy(fqdn, hostname, TD_FQDN_LEN);

#elif defined(LINUX)

  struct addrinfo  hints = {0};

  struct addrinfo *result = NULL;

  hints.ai_flags = AI_CANONNAME;

  bool inRetry = false;

  while (true) {

    int32_t ret = getaddrinfo(hostname, NULL, &hints, &result);

    if (ret) {

      if (EAI_AGAIN == ret && !inRetry) {

        inRetry = true;

        continue;

      } else if (EAI_SYSTEM == ret) {

        terrno = TAOS_SYSTEM_ERROR(ERRNO);

        return terrno;

      }

      terrno = TAOS_SYSTEM_ERROR(ret);

      return terrno;

    }

    break;

  }

  tstrncpy(fqdn, result->ai_canonname, TD_FQDN_LEN);

  freeaddrinfo(result);

#elif WINDOWS

  struct addrinfo  hints = {0};

  struct addrinfo *result = NULL;

  hints.ai_flags = AI_CANONNAME;

  int32_t ret = getaddrinfo(hostname, NULL, &hints, &result);

  if (!result) {

    // fprintf(stderr, "failed to get fqdn, code:%d, hostname:%s, reason:%s\n", ret, hostname, gai_strerror(ret));

    return TAOS_SYSTEM_WINSOCKET_ERROR(WSAGetLastError());

  }

  tstrncpy(fqdn, result->ai_canonname, TD_FQDN_LEN);

  freeaddrinfo(result);

#endif

  return 0;

}

void taosInetNtoa(char *ipstr, uint32_t ip) {

  if (ipstr == NULL) {

    return;

  }

  unsigned char *bytes = (unsigned char *)&ip;

  (void)snprintf(ipstr, TD_IP_LEN, "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3]);

}

uint32_t taosInetAddr(const char *ipstr) {

  if (ipstr == NULL) {

    return 0;

  }

  return inet_addr(ipstr);

}

int32_t taosIgnSIGPIPE() {

  sighandler_t h = signal(SIGPIPE, SIG_IGN);

  if (SIG_ERR == h) {

    terrno = TAOS_SYSTEM_ERROR(ERRNO);

    return terrno;

  }

  return 0;

}

/*

 * Set TCP connection timeout per-socket level.

 * ref [https://github.com/libuv/help/issues/54]

 */

int32_t taosCreateSocketWithTimeout(uint32_t timeout, int8_t t) {

#if defined(WINDOWS)

  SOCKET fd;

#else

  int fd;

#endif

  int32_t type = t == 0 ? AF_INET : AF_INET6;

  if ((fd = socket(type, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET) {

    terrno = TAOS_SYSTEM_ERROR(ERRNO);

    return terrno;

  }

#if defined(WINDOWS)

  if (0 != setsockopt(fd, IPPROTO_TCP, TCP_MAXRT, (char *)&timeout, sizeof(timeout))) {

    taosCloseSocketNoCheck1(fd);

    return TAOS_SYSTEM_WINSOCKET_ERROR(WSAGetLastError());

  }

#elif defined(_TD_DARWIN_64)

  // invalid config

  // uint32_t conn_timeout_ms = timeout * 1000;

  // if (0 != setsockopt(fd, IPPROTO_TCP, TCP_CONNECTIONTIMEOUT, (char *)&conn_timeout_ms, sizeof(conn_timeout_ms))) {

  //  taosCloseSocketNoCheck1(fd);

  //  return -1;

  //}

#elif defined(TD_ASTRA)  // TD_ASTRA_TODO

  uint32_t conn_timeout_ms = timeout;

  if (0 != setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, (char *)&conn_timeout_ms, sizeof(conn_timeout_ms)) ||

      0 != setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (char *)&conn_timeout_ms, sizeof(conn_timeout_ms))) {

    terrno = TAOS_SYSTEM_ERROR(ERRNO);

    TAOS_SKIP_ERROR(taosCloseSocketNoCheck1(fd));

    return terrno;

  }

#else                    // Linux like systems

  uint32_t conn_timeout_ms = timeout;

  if (-1 == setsockopt(fd, IPPROTO_TCP, TCP_USER_TIMEOUT, (char *)&conn_timeout_ms, sizeof(conn_timeout_ms))) {

    terrno = TAOS_SYSTEM_ERROR(ERRNO);

    TAOS_SKIP_ERROR(taosCloseSocketNoCheck1(fd));

    return terrno;

  }

#endif

  return (int)fd;

}

int32_t taosWinSocketInit() {

#ifdef WINDOWS

  static int8_t flag = 0;

  if (atomic_val_compare_exchange_8(&flag, 0, 1) == 0) {

    WORD    wVersionRequested;

    WSADATA wsaData;

    wVersionRequested = MAKEWORD(1, 1);

    if (WSAStartup(wVersionRequested, &wsaData) != 0) {

      atomic_store_8(&flag, 0);

      int errorCode = WSAGetLastError();

      return terrno = TAOS_SYSTEM_WINSOCKET_ERROR(errorCode);

    }

  }

  return 0;

#else

#endif

  return 0;

}

uint64_t taosHton64(uint64_t val) {

#if defined(WINDOWS) || defined(DARWIN)

  return ((val & 0x00000000000000ff) << 7 * 8) | ((val & 0x000000000000ff00) << 5 * 8) |

         ((val & 0x0000000000ff0000) << 3 * 8) | ((val & 0x00000000ff000000) << 1 * 8) |

         ((val & 0x000000ff00000000) >> 1 * 8) | ((val & 0x0000ff0000000000) >> 3 * 8) |

         ((val & 0x00ff000000000000) >> 5 * 8) | ((val & 0xff00000000000000) >> 7 * 8);

#else

  if (__BYTE_ORDER == __LITTLE_ENDIAN) {

    return (((uint64_t)htonl((int)((val << 32) >> 32))) << 32) | (unsigned int)htonl((int)(val >> 32));

  } else if (__BYTE_ORDER == __BIG_ENDIAN) {

    return val;

  }

#endif

}

uint64_t taosNtoh64(uint64_t val) {

#if defined(WINDOWS) || defined(DARWIN)