ENABLE_IPV6

base/hsocket.c

@@ -6,7 +6,7 @@
 #include <sys/select.h>
 #endif
 
-char *socket_strerror(int err) {
+const char* socket_strerror(int err) {
 #ifdef OS_WIN
     static char buffer[128];
 
@@ -21,38 +21,54 @@ char *socket_strerror(int err) {
 #endif
 }
 
-int Resolver(const char* host, struct sockaddr* addr) {
-    // IPv4
-    struct sockaddr_in* addr4 = (struct sockaddr_in*)addr;
-    addr4->sin_family = AF_INET;
-    if (inet_pton(AF_INET, host, &addr4->sin_addr) == 1) {
-        return 0; // host is ip, so easy ;)
+int Resolver(const char* host, sockaddr_un* addr) {
+    if (inet_pton(AF_INET, host, &addr->sin.sin_addr) == 1) {
+        addr->sa.sa_family = AF_INET; // host is ipv4, so easy ;)
+        return 0;
     }
+
+#ifdef ENABLE_IPV6
+    if (inet_pton(AF_INET6, host, &addr->sin6.sin6_addr) == 1) {
+        addr->sa.sa_family = AF_INET6; // host is ipv6
+        return 0;
+    }
+    struct addrinfo* ais = NULL;
+    struct addrinfo hint;
+    hint.ai_flags = 0;
+    hint.ai_family = AF_UNSPEC;
+    hint.ai_socktype = 0;
+    hint.ai_protocol = 0;
+    int ret = getaddrinfo(host, NULL, NULL, &ais);
+    if (ret != 0 || ais == NULL || ais->ai_addrlen == 0 || ais->ai_addr == NULL) {
+        printd("unknown host: %s err:%d:%s\n", host, ret, gai_strerror(ret));
+        return ret;
+    }
+    memcpy(addr, ais->ai_addr, ais->ai_addrlen);
+    freeaddrinfo(ais);
+#else
     struct hostent* phe = gethostbyname(host);
     if (phe == NULL) {
-        printd("unknown host %s\n", host);
+        printd("unknown host %s err:%d:%s\n", host, h_errno, hstrerror(h_errno));
         return -h_errno;
     }
-    memcpy(&addr4->sin_addr, phe->h_addr_list[0], phe->h_length);
+    addr->sin.sin_family = AF_INET;
+    memcpy(&addr->sin.sin_addr, phe->h_addr_list[0], phe->h_length);
+#endif
     return 0;
 }
 
 int Bind(int port, const char* host, int type) {
-    struct sockaddr_in localaddr;
+    sockaddr_un localaddr;
     socklen_t addrlen = sizeof(localaddr);
     memset(&localaddr, 0, addrlen);
-    localaddr.sin_family = AF_INET;
-    if (host) {
-        int ret = Resolver(host, (struct sockaddr*)&localaddr);
-        if (ret != 0) return ret;
-    }
-    else {
-        localaddr.sin_addr.s_addr = htonl(INADDR_ANY);
+    int ret = sockaddr_assign(&localaddr, host, port);
+    if (ret != 0) {
+        printf("unknown host: %s\n", host);
+        return ret;
     }
-    localaddr.sin_port = htons(port);
 
     // socket -> setsockopt -> bind
-    int sockfd = socket(AF_INET, type, 0);
+    int sockfd = socket(localaddr.sa.sa_family, type, 0);
     if (sockfd < 0) {
         perror("socket");
         return -socket_errno();
@@ -65,7 +81,7 @@ int Bind(int port, const char* host, int type) {
         goto error;
     }
 
-    if (bind(sockfd, (struct sockaddr*)&localaddr, addrlen) < 0) {
+    if (bind(sockfd, &localaddr.sa, sockaddrlen(&localaddr)) < 0) {
         perror("bind");
         goto error;
     }
@@ -91,13 +107,15 @@ error:
 
 int Connect(const char* host, int port, int nonblock) {
     // Resolver -> socket -> nonblocking -> connect
-    struct sockaddr_in peeraddr;
+    sockaddr_un peeraddr;
     socklen_t addrlen = sizeof(peeraddr);
     memset(&peeraddr, 0, addrlen);
-    int ret = Resolver(host, (struct sockaddr*)&peeraddr);
-    if (ret != 0) return ret;
-    peeraddr.sin_port = htons(port);
-    int connfd = socket(AF_INET, SOCK_STREAM, 0);
+    int ret = sockaddr_assign(&peeraddr, host, port);
+    if (ret != 0) {
+        //printf("unknown host: %s\n", host);
+        return ret;
+    }
+    int connfd = socket(peeraddr.sa.sa_family, SOCK_STREAM, 0);
     if (connfd < 0) {
         perror("socket");
         return -socket_errno();
@@ -105,7 +123,7 @@ int Connect(const char* host, int port, int nonblock) {
     if (nonblock) {
         nonblocking(connfd);
     }
-    ret = connect(connfd, (struct sockaddr*)&peeraddr, addrlen);
+    ret = connect(connfd, &peeraddr.sa, sockaddrlen(&peeraddr));
 #ifdef OS_WIN
     if (ret < 0 && socket_errno() != WSAEWOULDBLOCK) {
 #else
@@ -175,13 +193,13 @@ int Ping(const char* host, int cnt) {
     //min_rtt = MIN(rtt, min_rtt);
     //max_rtt = MAX(rtt, max_rtt);
     // gethostbyname -> socket -> setsockopt -> sendto -> recvfrom -> closesocket
-    struct sockaddr_in peeraddr;
+    sockaddr_un peeraddr;
     socklen_t addrlen = sizeof(peeraddr);
     memset(&peeraddr, 0, addrlen);
-    int ret = Resolver(host, (struct sockaddr*)&peeraddr);
+    int ret = Resolver(host, &peeraddr);
     if (ret != 0) return ret;
-    inet_ntop(peeraddr.sin_family, &peeraddr.sin_addr, ip, sizeof(ip));
-    int sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
+    sockaddr_ip(&peeraddr, ip, sizeof(ip));
+    int sockfd = socket(peeraddr.sa.sa_family, SOCK_RAW, IPPROTO_ICMP);
     if (sockfd < 0) {
         perror("socket");
         if (errno == EPERM) {
@@ -216,14 +234,15 @@ int Ping(const char* host, int cnt) {
         icmp_req->icmp_cksum = 0;
         icmp_req->icmp_cksum = checksum((uint8_t*)icmp_req, sendbytes);
         start_hrtime = gethrtime();
-        int nsend = sendto(sockfd, sendbuf, sendbytes, 0, (struct sockaddr*)&peeraddr, addrlen);
+        addrlen = sockaddrlen(&peeraddr);
+        int nsend = sendto(sockfd, sendbuf, sendbytes, 0, &peeraddr.sa, addrlen);
         if (nsend < 0) {
             perror("sendto");
             continue;
         }
         ++send_cnt;
         addrlen = sizeof(peeraddr);
-        int nrecv = recvfrom(sockfd, recvbuf, sizeof(recvbuf), 0, (struct sockaddr*)&peeraddr, &addrlen);
+        int nrecv = recvfrom(sockfd, recvbuf, sizeof(recvbuf), 0, &peeraddr.sa, &addrlen);
         if (nrecv < 0) {
             perror("recvfrom");
             continue;

base/hsocket.h

@@ -21,34 +21,7 @@ static inline int socket_errno() {
     return errno;
 #endif
 }
-char* socket_strerror(int err);
-
-// @param host: domain or ip
-// @retval 0:succeed
-int Resolver(const char* host, struct sockaddr* addr);
-
-// socket -> setsockopt -> bind
-// @param type: SOCK_STREAM(tcp) SOCK_DGRAM(udp)
-// @return sockfd
-int Bind(int port, const char* host DEFAULT(ANYADDR), int type DEFAULT(SOCK_STREAM));
-
-// Bind -> listen
-// @return sockfd
-int Listen(int port, const char* host DEFAULT(ANYADDR));
-
-// @return sockfd
-// Resolver -> socket -> nonblocking -> connect
-int Connect(const char* host, int port, int nonblock DEFAULT(0));
-// Connect(host, port, 1)
-int ConnectNonblock(const char* host, int port);
-// Connect(host, port, 1) -> select -> blocking
-#define DEFAULT_CONNECT_TIMEOUT 5000 // ms
-int ConnectTimeout(const char* host, int port, int ms DEFAULT(DEFAULT_CONNECT_TIMEOUT));
-
-// @param cnt: ping count
-// @return: ok count
-// @note: printd $CC -DPRINT_DEBUG
-int Ping(const char* host, int cnt DEFAULT(4));
+const char* socket_strerror(int err);
 
 #ifdef OS_WIN
 typedef int socklen_t;
@@ -75,64 +48,122 @@ typedef int         SOCKET;
 #define closesocket close
 #endif
 
-static inline const char* sockaddr_ntop(const struct sockaddr* addr, char *ip, int len) {
-    if (addr->sa_family == AF_INET) {
-        struct sockaddr_in* sin = (struct sockaddr_in*)addr;
-        return inet_ntop(AF_INET, &sin->sin_addr, ip, len);
+typedef union {
+    struct sockaddr     sa;
+    struct sockaddr_in  sin;
+    struct sockaddr_in6 sin6;
+} sockaddr_un;
+
+// @param host: domain or ip
+// @retval 0:succeed
+int Resolver(const char* host, sockaddr_un* addr);
+
+static inline socklen_t sockaddrlen(sockaddr_un* addr) {
+    if (addr->sa.sa_family == AF_INET) {
+        return sizeof(struct sockaddr_in);
+    }
+    else if (addr->sa.sa_family == AF_INET6) {
+        return sizeof(struct sockaddr_in6);
     }
-    else if (addr->sa_family == AF_INET6) {
-        struct sockaddr_in6* sin6 = (struct sockaddr_in6*)addr;
-        return inet_ntop(AF_INET6, &sin6->sin6_addr, ip, len);
+    return sizeof(sockaddr_un);
+}
+
+static inline const char* sockaddr_ip(sockaddr_un* addr, char *ip, int len) {
+    if (addr->sa.sa_family == AF_INET) {
+        return inet_ntop(AF_INET, &addr->sin.sin_addr, ip, len);
+    }
+    else if (addr->sa.sa_family == AF_INET6) {
+        return inet_ntop(AF_INET6, &addr->sin6.sin6_addr, ip, len);
     }
     return ip;
 }
 
-static inline uint16_t sockaddr_htons(const struct sockaddr* addr) {
-    if (addr->sa_family == AF_INET) {
-        struct sockaddr_in* sin = (struct sockaddr_in*)addr;
-        return htons(sin->sin_port);
+static inline uint16_t sockaddr_port(sockaddr_un* addr) {
+    uint16_t port = 0;
+    if (addr->sa.sa_family == AF_INET) {
+        port = htons(addr->sin.sin_port);
     }
-    else if (addr->sa_family == AF_INET6) {
-        struct sockaddr_in6* sin6 = (struct sockaddr_in6*)addr;
-        return htons(sin6->sin6_port);
+    else if (addr->sa.sa_family == AF_INET6) {
+        port = htons(addr->sin6.sin6_port);
     }
-    return 0;
+    return port;
 }
 
-static inline void sockaddr_printf(const struct sockaddr* addr) {
-    char ip[INET6_ADDRSTRLEN] = {0};
-    int port = 0;
-    if (addr->sa_family == AF_INET) {
-        struct sockaddr_in* sin = (struct sockaddr_in*)addr;
-        inet_ntop(AF_INET, &sin->sin_addr, ip, sizeof(ip));
-        port = htons(sin->sin_port);
+static inline void sockaddr_set_port(sockaddr_un* addr, int port) {
+    if (addr->sa.sa_family == AF_INET) {
+        addr->sin.sin_port = ntohs(port);
     }
-    else if (addr->sa_family == AF_INET6) {
-        struct sockaddr_in6* sin6 = (struct sockaddr_in6*)addr;
-        inet_ntop(AF_INET6, &sin6->sin6_addr, ip, sizeof(ip));
-        port = htons(sin6->sin6_port);
+    else if (addr->sa.sa_family == AF_INET6) {
+        addr->sin6.sin6_port = ntohs(port);
     }
-    printf("%s:%d\n", ip, port);
 }
 
-static inline const char* sockaddr_snprintf(const struct sockaddr* addr, char* buf, int len) {
-    int port = 0;
-    if (addr->sa_family == AF_INET) {
-        struct sockaddr_in* sin = (struct sockaddr_in*)addr;
-        inet_ntop(AF_INET, &sin->sin_addr, buf, len);
-        port = htons(sin->sin_port);
+//#define INET_ADDRSTRLEN   16
+//#define INET6_ADDRSTRLEN  46
+#define SOCKADDR_STRLEN     64 // ipv4:port | [ipv6]:port
+#define SOCKADDR_STR(addr, buf) sockaddr_str((sockaddr_un*)addr, buf, sizeof(buf))
+// NOTE: typeof(addr)=[sockaddr*, sockaddr_in*, sockaddr_in6*, sockaddr_un*]
+// char buf[SOCKADDR_STRLEN] = {0};
+// SOCKADDR_STR(addr, buf);
+
+static inline const char* sockaddr_str(sockaddr_un* addr, char* buf, int len) {
+    char ip[SOCKADDR_STRLEN] = {0};
+    uint16_t port = 0;
+    if (addr->sa.sa_family == AF_INET) {
+        inet_ntop(AF_INET, &addr->sin.sin_addr, ip, len);
+        port = htons(addr->sin.sin_port);
+        snprintf(buf, len, "%s:%d", ip, port);
     }
-    else if (addr->sa_family == AF_INET6) {
-        struct sockaddr_in6* sin6 = (struct sockaddr_in6*)addr;
-        inet_ntop(AF_INET6, &sin6->sin6_addr, buf, len);
-        port = htons(sin6->sin6_port);
+    else if (addr->sa.sa_family == AF_INET6) {
+        inet_ntop(AF_INET6, &addr->sin6.sin6_addr, ip, len);
+        port = htons(addr->sin6.sin6_port);
+        snprintf(buf, len, "[%s]:%d", ip, port);
     }
-    char sport[16] = {0};
-    snprintf(sport, sizeof(sport), ":%d", port);
-    safe_strncat(buf, sport, len);
     return buf;
 }
 
+static inline void sockaddr_print(sockaddr_un* addr) {
+    char buf[SOCKADDR_STRLEN] = {0};
+    sockaddr_str(addr, buf, sizeof(buf));
+    puts(buf);
+}
+
+static inline int sockaddr_assign(sockaddr_un* addr, const char* host, int port) {
+    if (host) {
+        int ret = Resolver(host, addr);
+        if (ret != 0) return ret;
+    }
+    else {
+        addr->sin.sin_family = AF_INET;
+        addr->sin.sin_addr.s_addr = htonl(INADDR_ANY);
+    }
+    sockaddr_set_port(addr, port);
+    return 0;
+}
+
+// socket -> setsockopt -> bind
+// @param type: SOCK_STREAM(tcp) SOCK_DGRAM(udp)
+// @return sockfd
+int Bind(int port, const char* host DEFAULT(ANYADDR), int type DEFAULT(SOCK_STREAM));
+
+// Bind -> listen
+// @return sockfd
+int Listen(int port, const char* host DEFAULT(ANYADDR));
+
+// @return sockfd
+// Resolver -> socket -> nonblocking -> connect
+int Connect(const char* host, int port, int nonblock DEFAULT(0));
+// Connect(host, port, 1)
+int ConnectNonblock(const char* host, int port);
+// Connect(host, port, 1) -> select -> blocking
+#define DEFAULT_CONNECT_TIMEOUT 5000 // ms
+int ConnectTimeout(const char* host, int port, int ms DEFAULT(DEFAULT_CONNECT_TIMEOUT));
+
+// @param cnt: ping count
+// @return: ok count
+// @note: printd $CC -DPRINT_DEBUG
+int Ping(const char* host, int cnt DEFAULT(4));
+
 static inline int tcp_nodelay(int sockfd, int on DEFAULT(1)) {
     return setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, (const char*)&on, sizeof(int));
 }

event/hevent.c

@@ -1,4 +1,5 @@
 #include "hevent.h"
+#include "hsocket.h"
 
 int hio_fd(hio_t* io) {
     return io->fd;
@@ -21,7 +22,7 @@ struct sockaddr* hio_peeraddr(hio_t* io) {
 }
 
 void hio_set_readbuf(hio_t* io, void* buf, size_t len) {
-    io->readbuf.base = buf;
+    io->readbuf.base = (char*)buf;
     io->readbuf.len = len;
 }
 
@@ -57,14 +58,14 @@ void hio_set_type(hio_t* io, hio_type_e type) {
 
 void hio_set_localaddr(hio_t* io, struct sockaddr* addr, int addrlen) {
     if (io->localaddr == NULL) {
-        SAFE_ALLOC(io->localaddr, sizeof(struct sockaddr_in6));
+        SAFE_ALLOC(io->localaddr, sizeof(sockaddr_un));
     }
     memcpy(io->localaddr, addr, addrlen);
 }
 
 void hio_set_peeraddr (hio_t* io, struct sockaddr* addr, int addrlen) {
     if (io->peeraddr == NULL) {
-        SAFE_ALLOC(io->peeraddr, sizeof(struct sockaddr_in6));
+        SAFE_ALLOC(io->peeraddr, sizeof(sockaddr_un));
     }
     memcpy(io->peeraddr, addr, addrlen);
 }

event/hloop.c

@@ -426,12 +426,12 @@ static void hio_socket_init(hio_t* io) {
     nonblocking(io->fd);
     // fill io->localaddr io->peeraddr
     if (io->localaddr == NULL) {
-        SAFE_ALLOC(io->localaddr, sizeof(struct sockaddr_in6));
+        SAFE_ALLOC(io->localaddr, sizeof(sockaddr_un));
     }
     if (io->peeraddr == NULL) {
-        SAFE_ALLOC(io->peeraddr, sizeof(struct sockaddr_in6));
+        SAFE_ALLOC(io->peeraddr, sizeof(sockaddr_un));
     }
-    socklen_t addrlen = sizeof(struct sockaddr_in6);
+    socklen_t addrlen = sizeof(sockaddr_un);
     int ret = getsockname(io->fd, io->localaddr, &addrlen);
     printd("getsockname fd=%d ret=%d errno=%d\n", io->fd, ret, socket_errno());
     // NOTE:
@@ -440,7 +440,7 @@ static void hio_socket_init(hio_t* io) {
     // tcp_client/udp_client peeraddr set by hio_setpeeraddr
     if (io->io_type == HIO_TYPE_TCP || io->io_type == HIO_TYPE_SSL) {
         // tcp acceptfd
-        addrlen = sizeof(struct sockaddr_in6);
+        addrlen = sizeof(sockaddr_un);
         ret = getpeername(io->fd, io->peeraddr, &addrlen);
         printd("getpeername fd=%d ret=%d errno=%d\n", io->fd, ret, socket_errno());
     }
@@ -642,26 +642,27 @@ hio_t* create_tcp_server (hloop_t* loop, const char* host, int port, haccept_cb
 }
 
 hio_t* create_tcp_client (hloop_t* loop, const char* host, int port, hconnect_cb connect_cb) {
-    struct sockaddr_in addr;
-    socklen_t addrlen = sizeof(addr);
-    memset(&addr, 0, addrlen);
-    addr.sin_family = AF_INET;
-    int ret = Resolver(host, (struct sockaddr*)&addr);
-    if (ret != 0) return NULL;
-    addr.sin_port = htons(port);
-    int connfd = socket(AF_INET, SOCK_STREAM, 0);
+    sockaddr_un peeraddr;
+    socklen_t addrlen = sizeof(peeraddr);
+    memset(&peeraddr, 0, addrlen);
+    int ret = sockaddr_assign(&peeraddr, host, port);
+    if (ret != 0) {
+        //printf("unknown host: %s\n", host);
+        return NULL;
+    }
+    int connfd = socket(peeraddr.sa.sa_family, SOCK_STREAM, 0);
     if (connfd < 0) {
         perror("socket");
         return NULL;
     }
+
     hio_t* io = hio_get(loop, connfd);
     if (io == NULL) return NULL;
-    hio_set_peeraddr(io, (struct sockaddr*)&addr, addrlen);
+    hio_set_peeraddr(io, &peeraddr.sa, sockaddrlen(&peeraddr));
     hconnect(loop, connfd, connect_cb);
     return io;
 }
 
-
 // @server: socket -> bind -> hrecvfrom
 hio_t* create_udp_server(hloop_t* loop, const char* host, int port) {
     int bindfd = Bind(port, host, SOCK_DGRAM);
@@ -673,16 +674,16 @@ hio_t* create_udp_server(hloop_t* loop, const char* host, int port) {
 
 // @client: Resolver -> socket -> hio_get -> hio_set_peeraddr
 hio_t* create_udp_client(hloop_t* loop, const char* host, int port) {
-    // IPv4
-    struct sockaddr_in peeraddr;
+    sockaddr_un peeraddr;
     socklen_t addrlen = sizeof(peeraddr);
     memset(&peeraddr, 0, addrlen);
-    peeraddr.sin_family = AF_INET;
-    int ret = Resolver(host, (struct sockaddr*)&peeraddr);
-    if (ret != 0) return NULL;
-    peeraddr.sin_port = htons(port);
+    int ret = sockaddr_assign(&peeraddr, host, port);
+    if (ret != 0) {
+        //printf("unknown host: %s\n", host);
+        return NULL;
+    }
 
-    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
+    int sockfd = socket(peeraddr.sa.sa_family, SOCK_DGRAM, 0);
     if (sockfd < 0) {
         perror("socket");
         return NULL;
@@ -690,7 +691,7 @@ hio_t* create_udp_client(hloop_t* loop, const char* host, int port) {
 
     hio_t* io = hio_get(loop, sockfd);
     if (io == NULL) return NULL;
-    hio_set_peeraddr(io, (struct sockaddr*)&peeraddr, addrlen);
+    hio_set_peeraddr(io, &peeraddr.sa, sockaddrlen(&peeraddr));
     return io;
 }
 

event/nio.c

@@ -45,7 +45,7 @@ static void nio_accept(hio_t* io) {
     //printd("nio_accept listenfd=%d\n", io->fd);
     socklen_t addrlen;
 accept:
-    addrlen = sizeof(struct sockaddr_in6);
+    addrlen = sizeof(sockaddr_un);
     int connfd = accept(io->fd, io->peeraddr, &addrlen);
     hio_t* connio = NULL;
     if (connfd < 0) {
@@ -59,7 +59,7 @@ accept:
             goto accept_error;
         }
     }
-    addrlen = sizeof(struct sockaddr_in6);
+    addrlen = sizeof(sockaddr_un);
     getsockname(connfd, io->localaddr, &addrlen);
     connio = hio_get(io->loop, connfd);
     // NOTE: inherit from listenio
@@ -85,11 +85,11 @@ accept:
     if (io->io_type != HIO_TYPE_SSL) {
         // NOTE: SSL call accept_cb after handshark finished
         if (io->accept_cb) {
-            char localaddrstr[INET6_ADDRSTRLEN+16] = {0};
-            char peeraddrstr[INET6_ADDRSTRLEN+16] = {0};
+            char localaddrstr[SOCKADDR_STRLEN] = {0};
+            char peeraddrstr[SOCKADDR_STRLEN] = {0};
             printd("accept listenfd=%d connfd=%d [%s] <= [%s]\n", io->fd, connfd,
-                    sockaddr_snprintf(io->localaddr, localaddrstr, sizeof(localaddrstr)),
-                    sockaddr_snprintf(io->peeraddr, peeraddrstr, sizeof(peeraddrstr)));
+                    SOCKADDR_STR(io->localaddr, localaddrstr),
+                    SOCKADDR_STR(io->peeraddr, peeraddrstr));
             //printd("accept_cb------\n");
             io->accept_cb(connio);
             //printd("accept_cb======\n");
@@ -103,7 +103,7 @@ accept_error:
 
 static void nio_connect(hio_t* io) {
     //printd("nio_connect connfd=%d\n", io->fd);
-    socklen_t addrlen = sizeof(struct sockaddr_in6);
+    socklen_t addrlen = sizeof(sockaddr_un);
     int ret = getpeername(io->fd, io->peeraddr, &addrlen);
     if (ret < 0) {
         io->error = socket_errno();
@@ -111,13 +111,13 @@ static void nio_connect(hio_t* io) {
         goto connect_failed;
     }
     else {
-        addrlen = sizeof(struct sockaddr_in6);
+        addrlen = sizeof(sockaddr_un);
         getsockname(io->fd, io->localaddr, &addrlen);
-        char localaddrstr[INET6_ADDRSTRLEN+16] = {0};
-        char peeraddrstr[INET6_ADDRSTRLEN+16] = {0};
+        char localaddrstr[SOCKADDR_STRLEN] = {0};
+        char peeraddrstr[SOCKADDR_STRLEN] = {0};
         printd("connect connfd=%d [%s] => [%s]\n", io->fd,
-                sockaddr_snprintf(io->localaddr, localaddrstr, sizeof(localaddrstr)),
-                sockaddr_snprintf(io->peeraddr, peeraddrstr, sizeof(peeraddrstr)));
+                SOCKADDR_STR(io->localaddr, localaddrstr),
+                SOCKADDR_STR(io->peeraddr, peeraddrstr));
 #ifdef WITH_OPENSSL
         if (io->io_type == HIO_TYPE_SSL) {
             SSL_CTX* ssl_ctx = (SSL_CTX*)g_ssl_ctx;
@@ -170,7 +170,7 @@ read:
     case HIO_TYPE_UDP:
     case HIO_TYPE_IP:
     {
-        socklen_t addrlen = sizeof(struct sockaddr_in6);
+        socklen_t addrlen = sizeof(sockaddr_un);
         nread = recvfrom(io->fd, buf, len, 0, io->peeraddr, &addrlen);
     }
         break;
@@ -233,7 +233,7 @@ write:
         break;
     case HIO_TYPE_UDP:
     case HIO_TYPE_IP:
-        nwrite = sendto(io->fd, buf, len, 0, io->peeraddr, sizeof(struct sockaddr_in6));
+        nwrite = sendto(io->fd, buf, len, 0, io->peeraddr, sizeof(sockaddr_un));
         break;
     default:
         nwrite = write(io->fd, buf, len);
@@ -309,7 +309,7 @@ int hio_accept(hio_t* io) {
 }
 
 int hio_connect(hio_t* io) {
-    int ret = connect(io->fd, io->peeraddr, sizeof(struct sockaddr_in6));
+    int ret = connect(io->fd, io->peeraddr, sizeof(sockaddr_un));
 #ifdef OS_WIN
     if (ret < 0 && socket_errno() != WSAEWOULDBLOCK) {
 #else
@@ -352,7 +352,7 @@ try_write:
             break;
         case HIO_TYPE_UDP:
         case HIO_TYPE_IP:
-            nwrite = sendto(io->fd, buf, len, 0, io->peeraddr, sizeof(struct sockaddr_in6));
+            nwrite = sendto(io->fd, buf, len, 0, io->peeraddr, sizeof(sockaddr_un));
             break;
         default:
             nwrite = write(io->fd, buf, len);

event/nlog.c

@@ -41,11 +41,11 @@ static void on_read(hio_t* io, void* buf, int readbytes) {
 
 static void on_accept(hio_t* io) {
     printd("on_accept connfd=%d\n", hio_fd(io));
-    char localaddrstr[INET6_ADDRSTRLEN+16] = {0};
-    char peeraddrstr[INET6_ADDRSTRLEN+16] = {0};
+    char localaddrstr[SOCKADDR_STRLEN] = {0};
+    char peeraddrstr[SOCKADDR_STRLEN] = {0};
     printd("accept connfd=%d [%s] <= [%s]\n", hio_fd(io),
-            sockaddr_snprintf(hio_localaddr(io), localaddrstr, sizeof(localaddrstr)),
-            sockaddr_snprintf(hio_peeraddr(io), peeraddrstr, sizeof(peeraddrstr)));
+            SOCKADDR_STR(hio_localaddr(io), localaddrstr),
+            SOCKADDR_STR(hio_peeraddr(io), peeraddrstr));
 
     static char s_readbuf[256] = {0};
     hio_set_readbuf(io, s_readbuf, sizeof(s_readbuf));

event/nmap.cpp

@@ -30,11 +30,11 @@ static void on_timer(htimer_t* timer) {
 
 static void on_recvfrom(hio_t* io, void* buf, int readbytes) {
     //printf("on_recv fd=%d readbytes=%d\n", io->fd, readbytes);
-    //char localaddrstr[INET6_ADDRSTRLEN+16] = {0};
-    //char peeraddrstr[INET6_ADDRSTRLEN+16] = {0};
+    //char localaddrstr[SOCKADDR_STRLEN] = {0};
+    //char peeraddrstr[SOCKADDR_STRLEN] = {0};
     //printf("[%s] <=> [%s]\n",
-            //sockaddr_snprintf(io->localaddr, localaddrstr, sizeof(localaddrstr)),
-            //sockaddr_snprintf(io->peeraddr, peeraddrstr, sizeof(peeraddrstr)));
+            //SOCKADDR_STR(hio_localaddr(io), localaddrstr),
+            //SOCKADDR_STR(hio_peeraddr(io), peeraddrstr));
     nmap_udata_t* udata = (nmap_udata_t*)io->loop->userdata;
     if (++udata->recv_cnt == udata->send_cnt) {
         //hloop_stop(io->loop);

event/overlapio.c

@@ -109,11 +109,11 @@ static void on_acceptex_complete(hio_t* io) {
     */
     if (io->accept_cb) {
         /*
-        char localaddrstr[INET6_ADDRSTRLEN+16] = {0};
-        char peeraddrstr[INET6_ADDRSTRLEN+16] = {0};
+        char localaddrstr[SOCKADDR_STRLEN] = {0};
+        char peeraddrstr[SOCKADDR_STRLEN] = {0};
         printd("accept listenfd=%d connfd=%d [%s] <= [%s]\n", listenfd, connfd,
-                sockaddr_snprintf(io->localaddr, localaddrstr, sizeof(localaddrstr)),
-                sockaddr_snprintf(io->peeraddr, peeraddrstr, sizeof(peeraddrstr)));
+                SOCKADDR_STR(io->localaddr, localaddrstr),
+                SOCKADDR_STR(io->peeraddr, peeraddrstr));
         */
         setsockopt(connfd, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, (const char*)&listenfd, sizeof(int));
         //printd("accept_cb------\n");
@@ -140,11 +140,11 @@ static void on_connectex_complete(hio_t* io) {
         getsockname(io->fd, io->localaddr, &addrlen);
         addrlen = sizeof(struct sockaddr_in6);
         getpeername(io->fd, io->peeraddr, &addrlen);
-        char localaddrstr[INET6_ADDRSTRLEN+16] = {0};
-        char peeraddrstr[INET6_ADDRSTRLEN+16] = {0};
+        char localaddrstr[SOCKADDR_STRLEN] = {0};
+        char peeraddrstr[SOCKADDR_STRLEN] = {0};
         printd("connect connfd=%d [%s] => [%s]\n", io->fd,
-                sockaddr_snprintf(io->localaddr, localaddrstr, sizeof(localaddrstr)),
-                sockaddr_snprintf(io->peeraddr, peeraddrstr, sizeof(peeraddrstr)));
+                SOCKADDR_STR(io->localaddr, localaddrstr),
+                SOCKADDR_STR(io->peeraddr, peeraddrstr));
         //printd("connect_cb------\n");
         io->connect_cb(io);
         //printd("connect_cb======\n");
@@ -285,7 +285,7 @@ int hio_connect (hio_t* io) {
 error:
     hio_close(io);
     return 0;
-};
+}
 
 int hio_read (hio_t* io) {
     post_recv(io, NULL);

examples/nc.c

@@ -20,11 +20,11 @@ int verbose = 0;
 void on_recv(hio_t* io, void* buf, int readbytes) {
     //printf("on_recv fd=%d readbytes=%d\n", hio_fd(io), readbytes);
     if (verbose) {
-        char localaddrstr[INET6_ADDRSTRLEN+16] = {0};
-        char peeraddrstr[INET6_ADDRSTRLEN+16] = {0};
+        char localaddrstr[SOCKADDR_STRLEN] = {0};
+        char peeraddrstr[SOCKADDR_STRLEN] = {0};
         printf("[%s] <=> [%s]\n",
-                sockaddr_snprintf(hio_localaddr(io), localaddrstr, sizeof(localaddrstr)),
-                sockaddr_snprintf(hio_peeraddr(io), peeraddrstr, sizeof(peeraddrstr)));
+            SOCKADDR_STR(hio_localaddr(io), localaddrstr),
+            SOCKADDR_STR(hio_peeraddr(io), peeraddrstr));
     }
     printf("%s", (char*)buf);
     fflush(stdout);
@@ -45,11 +45,11 @@ void on_close(hio_t* io) {
 void on_connect(hio_t* io) {
     //printf("on_connect fd=%d\n", hio_fd(io));
     if (verbose) {
-        char localaddrstr[INET6_ADDRSTRLEN+16] = {0};
-        char peeraddrstr[INET6_ADDRSTRLEN+16] = {0};
+        char localaddrstr[SOCKADDR_STRLEN] = {0};
+        char peeraddrstr[SOCKADDR_STRLEN] = {0};
         printf("connect connfd=%d [%s] => [%s]\n", hio_fd(io),
-                sockaddr_snprintf(hio_localaddr(io), localaddrstr, sizeof(localaddrstr)),
-                sockaddr_snprintf(hio_peeraddr(io), peeraddrstr, sizeof(peeraddrstr)));
+            SOCKADDR_STR(hio_localaddr(io), localaddrstr),
+            SOCKADDR_STR(hio_peeraddr(io), peeraddrstr));
     }
 
     hio_read(io);

examples/tcp.c

@@ -10,11 +10,11 @@ void on_close(hio_t* io) {
 
 void on_recv(hio_t* io, void* buf, int readbytes) {
     printf("on_recv fd=%d readbytes=%d\n", hio_fd(io), readbytes);
-    char localaddrstr[INET6_ADDRSTRLEN+16] = {0};
-    char peeraddrstr[INET6_ADDRSTRLEN+16] = {0};
+    char localaddrstr[SOCKADDR_STRLEN] = {0};
+    char peeraddrstr[SOCKADDR_STRLEN] = {0};
     printf("[%s] <=> [%s]\n",
-            sockaddr_snprintf(hio_localaddr(io), localaddrstr, sizeof(localaddrstr)),
-            sockaddr_snprintf(hio_peeraddr(io), peeraddrstr, sizeof(peeraddrstr)));
+            SOCKADDR_STR(hio_localaddr(io), localaddrstr),
+            SOCKADDR_STR(hio_peeraddr(io), peeraddrstr));
     printf("< %s\n", buf);
     // echo
     printf("> %s\n", buf);
@@ -23,11 +23,11 @@ void on_recv(hio_t* io, void* buf, int readbytes) {
 
 void on_accept(hio_t* io) {
     printf("on_accept connfd=%d\n", hio_fd(io));
-    char localaddrstr[INET6_ADDRSTRLEN+16] = {0};
-    char peeraddrstr[INET6_ADDRSTRLEN+16] = {0};
+    char localaddrstr[SOCKADDR_STRLEN] = {0};
+    char peeraddrstr[SOCKADDR_STRLEN] = {0};
     printf("accept connfd=%d [%s] <= [%s]\n", hio_fd(io),
-            sockaddr_snprintf(hio_localaddr(io), localaddrstr, sizeof(localaddrstr)),
-            sockaddr_snprintf(hio_peeraddr(io), peeraddrstr, sizeof(peeraddrstr)));
+            SOCKADDR_STR(hio_localaddr(io), localaddrstr),
+            SOCKADDR_STR(hio_peeraddr(io), peeraddrstr));
 
     hio_setcb_close(io, on_close);
     hio_setcb_read(io, on_recv);

examples/udp.c

@@ -10,11 +10,11 @@ void on_close(hio_t* io) {
 
 void on_recvfrom(hio_t* io, void* buf, int readbytes) {
     printf("on_recvfrom fd=%d readbytes=%d\n", hio_fd(io), readbytes);
-    char localaddrstr[INET6_ADDRSTRLEN+16] = {0};
-    char peeraddrstr[INET6_ADDRSTRLEN+16] = {0};
+    char localaddrstr[SOCKADDR_STRLEN] = {0};
+    char peeraddrstr[SOCKADDR_STRLEN] = {0};
     printf("[%s] <=> [%s]\n",
-            sockaddr_snprintf(hio_localaddr(io), localaddrstr, sizeof(localaddrstr)),
-            sockaddr_snprintf(hio_peeraddr(io), peeraddrstr, sizeof(peeraddrstr)));
+            SOCKADDR_STR(hio_localaddr(io), localaddrstr),
+            SOCKADDR_STR(hio_peeraddr(io), peeraddrstr));
     printf("< %s\n", buf);
     // echo
     printf("> %s\n", buf);

http/server/HttpServer.cpp

@@ -230,11 +230,11 @@ static void on_close(hio_t* io) {
 static void on_accept(hio_t* io) {
     printd("on_accept connfd=%d\n", hio_fd(io));
     /*
-    char localaddrstr[INET6_ADDRSTRLEN+16] = {0};
-    char peeraddrstr[INET6_ADDRSTRLEN+16] = {0};
+    char localaddrstr[SOCKADDR_STRLEN] = {0};
+    char peeraddrstr[SOCKADDR_STRLEN] = {0};
     printf("accept connfd=%d [%s] <= [%s]\n", hio_fd(io),
-            sockaddr_snprintf(hio_localaddr(io), localaddrstr, sizeof(localaddrstr)),
-            sockaddr_snprintf(hio_peeraddr(io), peeraddrstr, sizeof(peeraddrstr)));
+            SOCKADDR_STR(hio_localaddr(io), localaddrstr),
+            SOCKADDR_STR(hio_peeraddr(io), peeraddrstr));
     */
 
     HBuf* buf = (HBuf*)hloop_userdata(hevent_loop(io));
@@ -247,8 +247,8 @@ static void on_accept(hio_t* io) {
     HttpHandler* handler = new HttpHandler;
     handler->service = (HttpService*)hevent_userdata(io);
     handler->files = &s_filecache;
-    sockaddr_ntop(hio_peeraddr(io), handler->ip, sizeof(handler->ip));
-    handler->port = sockaddr_htons(hio_peeraddr(io));
+    sockaddr_ip((sockaddr_un*)hio_peeraddr(io), handler->ip, sizeof(handler->ip));
+    handler->port = sockaddr_port((sockaddr_un*)hio_peeraddr(io));
     handler->io = io;
     hevent_set_userdata(io, handler);
 }