struct addrinfo s_hints;
struct addrinfo *s_result;
struct addrinfo *s_this;
int s_check;

(void)memset((void *)(&s_hints), 0, sizeof(s_hints));
s_hints.ai_family = AF_UNSPEC; /* IPv4 or IPv6 */
s_hints.ai_socktype = SOCK_STREAM; /* UDP or TCP */
s_hints.ai_flags = AI_PASSIVE; /* wildcard IP address */
s_hints.ai_flags = 0; /* wildcard IP address */
s_hints.ai_protocol = IPPROTO_TCP; /* any protocol */
s_hints.ai_canonname = NULL;
s_hints.ai_addr = NULL;
s_hints.ai_next = NULL;
s_check = getaddrinfo((s_argc >= 2) ? s_argv[1] : "ipv6.minzkn.com", "http", (const struct addrinfo *)(&s_hints), (struct addrinfo **)(&s_result));
if(s_check == 0) {

    s_this = s_result;
    while(s_this != ((struct addrinfo *)0)) {
    /* ai_flags */
    if(s_this->ai_flags & AI_PASSIVE) {
        (void)fprintf(stdout, "flags: AI_PASSIVE\n");
    }
    if(s_this->ai_flags & AI_CANONNAME) {
        (void)fprintf(stdout, "flags: AI_CANONNAME\n");
    }
    if(s_this->ai_flags & AI_NUMERICHOST) {
        (void)fprintf(stdout, "flags: AI_NUMERICHOST\n");
    }
    if(s_this->ai_flags & AI_V4MAPPED) {
        (void)fprintf(stdout, "flags: AI_V4MAPPED\n");
    }
    if(s_this->ai_flags & AI_ALL) {
        (void)fprintf(stdout, "flags: AI_ALL\n");
    }
    if(s_this->ai_flags & AI_ADDRCONFIG) {
        (void)fprintf(stdout, "flags: AI_ADDRCONFIG\n");
    }
#if defined(AI_IDN)    
    if(s_this->ai_flags & AI_IDN) {
        (void)fprintf(stdout, "flags: AI_IDN\n");
    }
#endif    
#if defined(AI_CANONIDN)
    if(s_this->ai_flags & AI_CANONIDN) {
        (void)fprintf(stdout, "flags: AI_CANONIDN\n");
    }
#endif
#if defined(AI_IDN_ALLOW_UNASSIGNED)
    if(s_this->ai_flags & AI_IDN_ALLOW_UNASSIGNED) {
        (void)fprintf(stdout, "flags: AI_IDN_ALLOW_UNASSIGNED\n");
    }
#endif
#if defined(AI_IDN_USE_STD3_ASCII_RULES)
    if(s_this->ai_flags & AI_IDN_USE_STD3_ASCII_RULES) {
        (void)fprintf(stdout, "flags: AI_IDN_USE_STD3_ASCII_RULES\n");
    }
#endif
#if defined(AI_NUMERICSERV)
    if(s_this->ai_flags & AI_NUMERICSERV) {
        (void)fprintf(stdout, "flags: NUMERICSERV\n");
    }
#endif    

    /* ai_family */
    if(s_this->ai_family == AF_UNSPEC) {
        (void)fprintf(stdout, "family=%s\n", "UNSPEC");
    }
    else if(s_this->ai_family == AF_LOCAL) {
        (void)fprintf(stdout, "family=%s\n", "LOCAL");
    }
    else if(s_this->ai_family == AF_INET) {
        (void)fprintf(stdout, "family=%s\n", "AF_INET");
    }
    else if(s_this->ai_family == AF_INET6) {
        (void)fprintf(stdout, "family=%s\n", "AF_INET6");
    }
    else {
        (void)fprintf(stdout, "family=%d\n", s_this->ai_family);
    }

    /* ai_socktype */
    if(s_this->ai_socktype == SOCK_DGRAM) {
        (void)fprintf(stdout, "socktype=%s\n", "SOCK_DGRAM");
    }
    else if(s_this->ai_socktype == SOCK_STREAM) {
        (void)fprintf(stdout, "socktype=%s\n", "SOCK_STREAM");
    }
    else {
        (void)fprintf(stdout, "socktype=%d\n", s_this->ai_socktype);
    }

    /* ai_protocol */
    if(s_this->ai_protocol == IPPROTO_IP) {
        (void)fprintf(stdout, "protocol=%s\n", "IPPROTO_IP");
    }
    else if(s_this->ai_protocol == IPPROTO_IPV6) {
        (void)fprintf(stdout, "protocol=%s\n", "IPPROTO_IPV6");
    }
    else if(s_this->ai_protocol == IPPROTO_TCP) {
        (void)fprintf(stdout, "protocol=%s\n", "IPPROTO_TCP");
    }
    else if(s_this->ai_protocol == IPPROTO_UDP) {
        (void)fprintf(stdout, "protocol=%s\n", "IPPROTO_UDP");
    }
    else if(s_this->ai_protocol == IPPROTO_IGMP) {
        (void)fprintf(stdout, "protocol=%s\n", "IPPROTO_IGMP");
    }
    else if(s_this->ai_protocol == IPPROTO_ICMP) {
        (void)fprintf(stdout, "protocol=%s\n", "IPPROTO_ICMP");
    }
    else if(s_this->ai_protocol == IPPROTO_ICMPV6) {
        (void)fprintf(stdout, "protocol=%s\n", "IPPROTO_ICMPV6");
    }
    else {
        (void)fprintf(stdout, "protocol=%d\n", s_this->ai_protocol);
    }

    /* ai_addrlen */
    (void)fprintf(stdout, "addrlen=%lu\n", (unsigned long)s_this->ai_addrlen);

    /* ai_addr */
    if(s_this->ai_addr != ((struct sockaddr *)0)) {
        char s_address_local[ 128 ];
	const char *s_address;
	struct sockaddr_in *s_sockaddr_in;
	struct sockaddr_in6 *s_sockaddr_in6;
	int s_unspec = (-1);

	if(s_this->ai_family == AF_INET) {
	    s_sockaddr_in = (struct sockaddr_in *)s_this->ai_addr;
	    s_address = inet_ntop(s_this->ai_family, (const void *)(&s_sockaddr_in->sin_addr.s_addr), (char *)(&s_address_local[0]), (socklen_t)sizeof(s_address_local));
	}
	else if(s_this->ai_family == AF_INET6) {
	    s_sockaddr_in6 = (struct sockaddr_in6 *)s_this->ai_addr;
	    s_address = inet_ntop(s_this->ai_family, (const void *)(&s_sockaddr_in6->sin6_addr), (char *)(&s_address_local[0]), (socklen_t)sizeof(s_address_local));
	    s_unspec = IN6_IS_ADDR_UNSPECIFIED((const struct in6_addr *)(&s_sockaddr_in6->sin6_addr));
	}
	else {
            s_address = (const char *)0;	
	}

        if(s_address != ((const char *)0)) {
            (void)fprintf(stdout, "addr=\"%s\" (unspec?=%d)\n", s_address, s_unspec);
	}
	else {
            (void)fprintf(stdout, "addr=%s (unspec?=%d)\n", "UNKNOWN", s_unspec);
	}
    }
    else {
        (void)fprintf(stdout, "addr=%s\n", "NULL");
    }

    /* ai_canonname */
    (void)fprintf(stdout, "canonname=%s\n", (s_this->ai_canonname != ((char *)0)) ? s_this->ai_canonname : "NULL");

    (void)fprintf(stdout, "\n");

        s_this = s_this->ai_next;
    }

    freeaddrinfo(s_result);
}
else {
    (void)fprintf(stderr, "getaddrinfo error: %s\n", gai_strerror(s_check));
}

iec_sockaddr_t s_remote, s_bind;
iec_socket_t s_socket;
iec_const_string_t s_remote_address;
iec_socket_t s_socket;

s_remote_address = "http://test.minzkn.com:80/index.php";

/* 먼저 remote 주소의 sockaddr을 설정한다. (node는 uri를 허용한다) */
if(iec_xapi_resolve_sockaddr(AF_UNSPEC, (iec_sockaddr_t *)(&s_remote), s_remote_address, iec_xapi_int_const(80), def_iec_true) == def_iec_true) {
    /* 설정된 s_remote의 family를 bind address family 로 결정한다. (node는 uri를 허용하지 않는다) */
    if(iec_xapi_resolve_sockaddr(s_remote.ss.ss_family, (iec_sockaddr_t *)(&s_bind), def_iec_null_string, iec_xapi_int_const(0), def_iec_false) != def_iec_error) {    
        /* 결정된 bind address family에 맞는 소켓을 연다. */
        s_socket = iec_xapi_socket(s_bind.ss.ss_family, SOCK_STREAM, IPPROTO_TCP);
        if(s_socket != def_iec_invalid_socket) {
            if(iec_xapi_bind(s_socket, (iec_sockaddr_t *)(&s_bind)) == def_iec_true) {
                if(iec_xapi_connect(s_socket, (iec_sockaddr_t *)(&s_remote), s_timeout) == def_iec_true) {
                    /* connected */
                }
            }

            s_socket = iec_xapi_closesocket(s_socket);
        }
    }
}

iec_const_string_t s_bind_address;
iec_int_t s_bind_port;
iec_sockaddr_t s_sockaddr_bind, s_sockaddr_accept;
iec_socket_t s_listen_socket, s_accept_socket;
iec_socklen_t s_socklen;

if(iec_xapi_resolve_sockaddr(AF_UNSPEC, (iec_sockaddr_t *)(&s_sockaddr_bind), s_bind_address, s_bind_port, def_iec_false) == def_iec_true) {
    s_listen_socket = iec_xapi_socket(s_sockaddr_bind.ss_family, SOCK_STREAM, IPPROTO_TCP);
    if(s_listen_socket != def_iec_invalid_socket) {
        if(iec_xapi_bind(s_listen_socket, (iec_sockaddr_t *)(&s_sockaddr_bind), (iec_socklen_t)sizeof(s_sockaddr_bind)) == def_iec_true) {
            if(iec_xapi_listen(s_listen_socket, def_iec_max_backlog) == def_iec_true) {
                for(; /* exit condition */ ;) {
                    s_socklen = (iec_socklen_t)sizeof(s_sockaddr_accept);
                    s_accept_socket = iec_xapi_accept(s_listen_socket, (iec_sockaddr_t *)(&s_sockaddr_accept), (iec_socklen_t *)(&s_socklen), 0/* timeout */);
                    if(s_accept_socket != def_iec_invalid_socket) {
                        if(s_sockaddr_accept.ss_family == AF_INET) {
                            /* IPv4 accept process */
                        }
                        else if(s_sockaddr_accept.ss_family == AF_INET6) {
                            /* IPv6 accept process */
                        }
                        else {
                            /* Unspec accept process */
                        }
                        iec_xapi_closesocket(s_accept_socket);
                    }
                    else {
                        iec_xapi_load_balance();
                    }
                }
            }
        }
        iec_xapi_closesocket(s_listen_socket);
    }
}