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);
    }
}

EPRT<space><d><net-prt><d><net-addr><d><tcp-port><d>

여기서 <d>는 구분자로써 '|'을 사용하는것으로 되어 있습니다.
<net-prt>는 '1'은 IPv4를 의미하고 '2'는 IPv6를 의미합니다.

EPSV<space><net-prt>
229 Entering Extended Passive Mode (|||<tcp-port>|)

EPSV에 대한 응답형식은 EPRT와 유사합니다. EPSV의 <net-prt>에는 '1', '2', 'ALL'이 사용될수 있다고 합니다. 하지만 실험결과 'ALL'은 제대로 동작하지 않는 경우가 많았습니다.

/*
s_ipv6hdr : IPv6 Header에 대한 pointer 입력 
s_nexthdr_ptr : nexthdr 가 명시된 부분에 대한 pointer 입력
반환 : IPv6 extension header 의 크기 반환
*/
size_t hwport_ipv6_extension_header_size(struct ipv6hdr *s_ipv6hdr, u8 *s_nexthdr_ptr)
{
    size_t s_offset = (size_t)0; /* payload start offset == 40 */
    u8 *s_u8_ptr = (u8 *)(&s_ipv6hdr[1]); /* payload start entry */
    u8 s_nexthdr = s_ipv6hdr->nexthdr;
    struct ipv6_opt_hdr *s_exthdr;
    size_t s_exthdr_size;

    while(ipv6_ext_hdr(s_nexthdr)) {
        if(s_nexthdr == NEXTHDR_NONE) {
            break;
        }

        if(unlikely((s_offset + sizeof(struct ipv6_opt_hdr)) > ((size_t)s_ipv6hdr->payload_len))) {
            /* invalid extension header coding */
            s_offset = (size_t)s_ipv6hdr->payload_len;
            s_nexthdr = NEXTHDR_NONE;
            break;
        }

        s_exthdr = (struct ipv6_opt_hdr *)(&s_u8_ptr[s_offset]);
        if(s_nexthdr == NEXTHDR_FRAGMENT) {
            s_exthdr_size = (size_t)8u;
        }
        else if(s_nexthdr == NEXTHDR_AUTH) { /* AH header */
            s_exthdr_size = (s_exthdr->hdrlen + 2) << 2;
        }
        else {
            s_exthdr_size = ipv6_optlen(s_exthdr);
        }

        if(unlikely((s_offset + s_exthdr_size) > ((size_t)s_ipv6hdr->payload_len))) {
            /* invalid extension header size coding */
            s_offset = (size_t)s_ipv6hdr->payload_len;
            s_nexthdr = NEXTHDR_NONE;
            break;
        }

        s_nexthdr = s_exthdr->nexthdr;
        s_offset += s_exthdr_size;
    }

    if(s_nexthdr_ptr != ((u8 *)0)) {
        *s_nexthdr_ptr = s_nexthdr;
    }

    return(s_offset);
}

/*
s_ipv6hdr : IPv6 Header에 대한 pointer 입력 
s_transport_size_ptr : Transport layer 의 크기를 반환 (IPv6 Header 및 IPv6 extension header를 제외한 IPv6 payload 의 크기)
s_nexthdr_ptr : nexthdr 가 명시된 부분에 대한 pointer 입력
반환 : Transport layer에 대한 pointer 반환
*/
void *hwport_ipv6_transport_entry(struct ipv6hdr *s_ipv6hdr, size_t *s_transport_size_ptr, u8 *s_nexthdr_ptr)
{
    u8 *s_u8_ptr = (u8 *)s_ipv6hdr;
    size_t s_header_size = sizeof(struct ipv6hdr);
    size_t s_ext_header_size = hwport_ipv6_extension_header_size(s_ipv6hdr, s_nexthdr_ptr);

    if(s_transport_size_ptr != ((size_t *)0)) {
        *s_transport_size_ptr = ((size_t)s_ipv6hdr->payload_len) - s_ext_header_size;
    }

    return((void *)(&s_u8_ptr[s_header_size + s_ext_header_size]));
}

/* 사용예 */
struct sk_buff *skb; /* 인입된 패킷을 담고 있는 skbuff pointer */
size_t s_ipv6h_size = sizeof(struct ipv6hdr); /* IPv6 Header 크기 (IPv6 extension header는 제외) */
struct ipv6hdr *s_ipv6hdr = ip_hdr(skb); /* skb로부터 IPv4/IPv6 Header 위치 pointer */

u8 s_nexthdr; /* IPv6 externsion header 를 건너뛰고 마지막 nexthdr */
size_t s_ipv6h_ext_size; /* IPv6 extension header 크기 */
void *s_transport_entry; /* Transport layer entry pointer */
size_t s_transport_size; /* Transport layer 크기 */

ASSERT(s_ipv6hdr->version == 6);

s_ipv6h_ext_size = hwport_ipv6_extension_header_size(s_ipv6hdr, (u8 *)(&s_nexthdr));
s_transport_entry = hwport_ipv6_transport_entry(s_ipv6hdr, (size_t *)(&s_transport_size), (u8 *)(&s_nexthdr));
if(s_nexthdr == IPPROTO_TCP) {
    struct tcphdr *s_tcphdr = (struct tcphdr *)s_transport_entry;
}
else if(s_nexthdr == IPPROTO_UDP) {
}
else {
    ...
}