conectar (endereço) {
                encontra IPs do endereço
                tenta se conectar a o endereço IPv6
                enquanto nenhuma conexão se estabelece e timeout não estoura {
                        se passou tempo de vantagem dado ao IPv6 {
                                tenta se conectar a um endereço IPv4 (uma única vez)
                        }
                }
                se conseguiu conectar {
                        mantém a conexão conectada
                        fecha as demais conexões (sockets abertos)
                } caso não conseguiu conectar (timeout) {
                        fecha todas as conexões (sockets abertos)
                }
        }
	

        conectar (endereço) {
                encontra IPs do endereço
                verifica cache (endereço)
                se não existir cache {
                        tenta se conectar a um endereço IPv6
                        enquanto nenhuma conexão se estabelece e timeout não estoura {
                                se passou tempo de vantagem dado ao IPv6 {
                                        tenta se conectar a um endereço IPv4 (uma única vez)
                                }
                                se passou tempo de vantagem e não se conectou nem via IPv6 nem via IPv4 {
                                        tenta se conectar a qualquer outro endereço disponível
                                }
                        }
                } se estiver no cache {
                        tenta se conectar a um endereço com a versão definida no cache
                }
                se conseguiu conectar {
                        mantém a conexão conectada
                        fecha as demais conexões (sockets abertos)
                } caso não conseguiu conectar (timeout) {
                        fecha todas as conexões (sockets abertos)
                }
        }
        
        verifica cache (endereço) {
                verifica se existe o cache para endereço
                se cache existe {
                        se o cache está ativo há mais de 10 minutos {
                                limpa o cache
                        } caso contrario {
                                retorna o cache
        }
                }
        }
	

        struct hostent *gethostbyname(const char *name);
         
        struct  hostent {
                char        *h_name;            /* official name of host */
                char        **h_aliases;        /* alias list */
                int         h_addrtype;         /* host address type */
                int         h_length;           /* length of address */
                char        **h_addr_list;  /* list of addresses from name server */
        };
        
        Porém essa função, assim como outras da biblioteca netdb.h, só possui suporte a IPv4. Para corrigir essa falha, foi criado a função gethostbyname2:
        
        struct hostent *gethostbyname2(const char *name, int af);
	

        
int getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res);
        
struct addrinfo {
                int              ai_flags;     // AI_PASSIVE, AI_CANONNAME, etc.
                int              ai_family;    // AF_INET, AF_INET6, AF_UNSPEC
                int              ai_socktype;  // SOCK_STREAM, SOCK_DGRAM
                int              ai_protocol;  // use 0 for "any"
                size_t           ai_addrlen;   // size of ai_addr in bytes
                struct sockaddr *ai_addr;      // struct sockaddr_in or _in6
                char                *ai_canonname; // full canonical hostname
                struct addrinfo        *ai_next;      // linked list, next node
        };
        
	

        int main(int argc, char *argv[])
        {
                struct addrinfo hints, *res, *p;
                int status;
                char ipstr[INET6_ADDRSTRLEN];
         
                if (argc != 2) {
                        fprintf(stderr, "Usage: %s hostname\n", argv[0]);
                        return 1;
                }
         
                memset(&hints, 0, sizeof hints);
                hints.ai_family = AF_UNSPEC; // AF_INET or AF_INET6 to force version
                hints.ai_socktype = SOCK_STREAM;
         
                if ((status = getaddrinfo(argv[1], NULL, &hints, &res)) != 0) {
                        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(status));
                        return 2;
                }
         
                for(p = res;p != NULL; p = p->ai_next) {
         
                        void *addr;
                         
                        if (p->ai_family == AF_INET) {
                                return 1;
                         
                        } else {
                         
                                struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)p->ai_addr;
                                addr = &(ipv6->sin6_addr);
                                 
                                /* convert the IP to a string and print it: */
                                inet_ntop(p->ai_family, addr, ipstr, sizeof ipstr);
                                 
                                printf("Hostname: %s\n", argv[1]);
                                printf("IP Address: %s\n", ipstr);
                                 
                        }
                }
         
                freeaddrinfo(res); // free the linked list
                 
                return 0;
        }
	

        int socket(int domain, int type, int protocol);
	

        
        int connect(int socket, const struct sockaddr *address, socklen_t address_len);
        
        O parâmetro socket é o mesmo socket id que foi gerado na função socket. O parâmetro address é uma struct retornada pela função getaddrinfo, dentro da struct addrinfo->ai_addr O parâmetro address_len também é um parâmetro retornado pela função getaddrinfo, dentro da struct addrinfo->ai_addrlen. A struct sockaddr pode ser de vários  tipos:
        
        struct sockaddr {
                unsigned short    sa_family;    // address family, AF_xxx
                char              sa_data[14];  // 14 bytes of protocol address
        };
        
        
        // IPv4 AF_INET sockets:
        
        struct sockaddr_in {
                short            sin_family;   // e.g. AF_INET, AF_INET6
                unsigned short   sin_port;     // e.g. htons(3490)
                struct in_addr   sin_addr;     // see struct in_addr, below
                char             sin_zero[8];  // zero this if you want to
        };
        
        struct in_addr {
                unsigned long s_addr;          // load with inet_pton()
        };
        
        
        // IPv6 AF_INET6 sockets:
        
        struct sockaddr_in6 {
                u_int16_t       sin6_family;   // address family, AF_INET6
                u_int16_t       sin6_port;     // port number, Network Byte Order
                u_int32_t       sin6_flowinfo; // IPv6 flow information
                struct in6_addr sin6_addr;     // IPv6 address
                u_int32_t       sin6_scope_id; // Scope ID
        };
        
        struct in6_addr {
                unsigned char   s6_addr[16];   // load with inet_pton()
        };
        
        
        // General socket address holding structure, big enough to hold either
        // struct sockaddr_in or struct sockaddr_in6 data:
        
        struct sockaddr_storage {
                sa_family_t  ss_family;     // address family
        
                // all this is padding, implementation specific, ignore it:
                char      __ss_pad1[_SS_PAD1SIZE];
                int64_t   __ss_align;
                char      __ss_pad2[_SS_PAD2SIZE];
        };
        
        Abaixo um exemplo do uso da função connect:
        
        int sd;
        int rc;
        struct addrinfo ai_hints, *ai;
        
        /* create hints for getaddrinfo for stream socket */
        memset(&ai_hints, 0, sizeof(ai_hints));
        ai_hints.ai_family = AF_INET6;
        ai_hints.ai_socktype = SOCK_STREAM;
        ai_hints.ai_protocol = IPPROTO_TCP;
        /* get list of addresses for nodename from DNS */
        rc = getaddrinfo(szNodename, szService, &ai_hints, &ai);
        if (rc != 0)
        {
        strcpy(szError, "getaddrinfo() failed: ");
                strcat(szError, gai_strerror(rc));
                return -1;
        }
        /* create socket for this address */
        sd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
        if (sd < 0)
        {
        /* fail */
        strcpy(szError, "socket() failed, ");
        strcat(szError, strerror(errno));
        return -1;
        }
        rc = connect(sd, ai->ai_addr, ai->ai_addrlen);
        
	

        int ioctl(int fildes, int request, ... /* arg */);
        
        Note que essa é uma função mais avançada, portanto deve ser utilizado com cuidado. O parâmetro fildes (File Descriptor) indica o id do arquivo a ser modificado (no nosso caso é o socket, portanto seu id). O parâmetro request indica o comando que deverá ser executado, no nosso caso seria a constante FIONBIO. O parâmetro arg são configurações ou informações adicionais específicos da operação e do tipo de fildes utilizado. Um exemplo de como utilizar a função ioctl:
        
        int sd;
        int opt = 1;
        sd = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
        ioctl(sd, FIONBIO, &opt);
        
        Note que nesse caso foi utilizado um parâmetro chamado opt de valor 1. A função ioctl, quando utilizada com o parâmetro FIONBIO, torna o socket non-blocking caso o parâmetro arg seja diferente de zero. Portanto no exemplo a função está tornando o socket criado em um socket non-blocking. Para retornar o socket em modo blocking basta retirar a flag setada anteriormente, utilizando o parâmetro arg com valor igual a zero:
        
        int sd;
        int opt = 1;
        sd = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
        // Seta socket non-blocking
        ioctl(sd, FIONBIO, &opt);
        // Seta socket blocking
        opt = 0;
        ioctl(sd, FIONBIO, &opt);
	

        int fcntl(int fildes, int cmd, ... /* arg */ );
	

        int sd;
        sd = socket(AF_INET6, SOCK_STREAM, IPPROTO_TCP);
        int flags = fcntl(sd, F_GETFL, 0);
        fcntl(sd, F_SETFL, flags | O_NONBLOCK);
	

        int getpeername(int socket, struct sockaddr *address, socklen_t *address_len);
	

        /* Faz as consultas DNS */
        
        sd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
        rc = connect(sd, ai->ai_addr, ai->ai_addrlen);
        // Espera estabelecer a conexão
        while (!connected) {
        rc = getpeername(sd, ai->ai_addr, ai->ai_addrlen);
        if (rc < 0) {
                connected = TRUE;
        }
        }
        // Conexão estabelecida
	

        InetAddress address = InetAddress.getByName(“hostname”);
        System.out.println(address.getHostAddress);
        
        Neste caso o java irá buscar um IP retornado na consulta DNS . Porém ele irá retornar apenas um dos IPs disponíveis. Portanto se quisermos utilizar o Happy Eyeballs precisamos obter todos os IPs retornados pela consulta. Isso pode ser feito da seguinte forma:
        
        InetAddress[] addressArray = InetAddress.getAllByName(“hostname”);
        for (InetAddress address : addressArray) {
                System.out.println(address.getHostAddress);
        }
	

        Socket socket = new Socket(“hostname”, “porta”);
        socket.connect();
        // Faz o que precisa com o socket
        socket.close();
	

        InetAddress address = InetAddress.getByName(“hostname”);
        Socket socket = new Socket(address, “porta”);
        socket.connect();
        // Faz o que precisa com o socket
        socket.close();
	

        InetAddress address = InetAddress.getByName(“hostname”);
        SocketChannel channel = SocketChannel.open();
        channel.configureBlocking(false);
        channel.connect(new InetSocketAddress(address, 80));
	

        InetAddress address = InetAddress.getByName(“hostname”);
        SocketChannel channel = SocketChannel.open();
        channel.configureBlocking(false);
        channel.connect(new InetSocketAddress(address, 80));
        // Espera se conectar
        while (!channel.finishConnect()) {
                // Espera um tempo
        }
        // Faz o que precisa com o socket
        socket.close();
	

        // Pega todos os IPs disponíveis para o hostname em específico
        InetAddress[] addressArray = InetAddress.getAllByName(“hostname”);
        for (InetAddress address : addressArray) {
        // Faz alguma coisa com o IP
        }
	

        // Pega todos os IPs disponíveis para o hostname em específico
        InetAddress[] addressArray = InetAddress.getAllByName(“hostname”);
        for (InetAddress address : addressArray) {
        if (address instanceof Inet6Address) {
                        // O endereço é IPv6
        }
        if (address instanceof Inet4Address) {
                // O endereço é IPv4
        }
        }