efl_net: add Efl.Net.Ip_Address

This is a string parser, serializer and asynchronous resolver.

It's purpose is to convert to and from the strings we use in our
dialers and servers, such as "127.0.0.1:1234" or "[::1]:1234",
properties allow to check the family, port, address bytes (slice) and
even get a struct sockaddr pointer to use with bind()/connect() in
outside code.

It will also offer some utilities present in netinet/in.h in an easy
to use way, after all IN6_IS_ADDR_LOOPBACK() works one way, while
there is no IN_LOOPBACK and comparing with INADDR_LOOPBACK will lead
to errors since it's in network order.

Last but not least, it will do asynchronous resolve of host and port
names using an internal thread and getaddrinfo(). The results are
delivered using a Future with an array of objects.

src/Makefile_Ecore_Con.am

@@ -27,6 +27,7 @@ ecore_con_eolian_files = \
         lib/ecore_con/efl_net_control_technology.eo \
         lib/ecore_con/efl_net_control.eo \
         lib/ecore_con/efl_net_session.eo \
+        lib/ecore_con/efl_net_ip_address.eo \
 	lib/ecore_con/ecore_con_eet_base.eo \
 	lib/ecore_con/ecore_con_eet_server_obj.eo \
 	lib/ecore_con/ecore_con_eet_client_obj.eo
@@ -109,7 +110,8 @@ lib/ecore_con/efl_net_socket_ssl.c \
 lib/ecore_con/efl_net_ssl_context.c \
 lib/ecore_con/efl_net_dialer_ssl.c \
 lib/ecore_con/efl_net_server_ssl.c \
-lib/ecore_con/ecore_con_local.c
+lib/ecore_con/ecore_con_local.c \
+lib/ecore_con/efl_net_ip_address.c
 
 if EFL_NET_CONTROL_BACKEND_CONNMAN
 lib_ecore_con_libecore_con_la_SOURCES += \
@@ -179,6 +181,7 @@ tests/ecore_con/ecore_con_suite.c \
 tests/ecore_con/ecore_con_test_ecore_con.c \
 tests/ecore_con/ecore_con_test_ecore_con_url.c \
 tests/ecore_con/ecore_con_test_ecore_con_eet.c \
+tests/ecore_con/ecore_con_test_efl_net_ip_address.c \
 tests/ecore_con/ecore_con_suite.h
 
 tests_ecore_con_ecore_con_suite_CPPFLAGS = -I$(top_builddir)/src/lib/efl \

src/examples/ecore/.gitignore

@@ -66,5 +66,6 @@
 /*.pem
 /efl_net_session_example
 /efl_net_control_example
+/efl_net_ip_address_example
 /ecore_ipc_server_example
 /ecore_ipc_client_example

src/examples/ecore/Makefile.am

@@ -97,6 +97,7 @@ efl_net_socket_ssl_dialer_example \
 efl_net_socket_ssl_server_example \
 efl_net_session_example \
 efl_net_control_example \
+efl_net_ip_address_example \
 ecore_ipc_server_example \
 ecore_ipc_client_example
 
@@ -366,6 +367,9 @@ efl_net_session_example_LDADD = $(ECORE_CON_COMMON_LDADD)
 efl_net_control_example_SOURCES = efl_net_control_example.c
 efl_net_control_example_LDADD = $(ECORE_CON_COMMON_LDADD)
 
+efl_net_ip_address_example_SOURCES = efl_net_ip_address_example.c
+efl_net_ip_address_example_LDADD = $(ECORE_CON_COMMON_LDADD)
+
 ecore_ipc_server_example_SOURCES = ecore_ipc_server_example.c
 ecore_ipc_server_example_LDADD = $(ECORE_IPC_COMMON_LDADD)
 

src/examples/ecore/efl_net_ip_address_example.c

@@ -0,0 +1,137 @@
+#define EFL_BETA_API_SUPPORT 1
+#define EFL_EO_API_SUPPORT 1
+#include <Ecore.h>
+#include <Ecore_Con.h>
+#include <Ecore_Getopt.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+static int retval = EXIT_SUCCESS;
+static Eina_List *resolving = NULL;
+
+static void
+_print_ip_addr_info(const Eo *o)
+{
+   const Eina_Slice *addr;
+   const struct sockaddr *sa;
+   char buf[INET6_ADDRSTRLEN] = "?";
+   uint16_t port;
+   size_t i;
+
+   printf("INFO: %p = %s\n", o, efl_net_ip_address_string_get(o));
+   printf("INFO:   - family: %d (%s)\n", efl_net_ip_address_family_get(o), efl_net_ip_address_family_get(o) == AF_INET ? "AF_INET" : "AF_INET6");
+   printf("INFO:   - port: %hu\n", efl_net_ip_address_port_get(o));
+
+   addr = efl_net_ip_address_get(o);
+   printf("INFO:   - address %zd bytes:", addr->len);
+   for (i = 0; i < addr->len; i++)
+     printf(" %#hhx", addr->bytes[i]);
+   putchar('\n');
+
+   sa = efl_net_ip_address_sockaddr_get(o);
+   if (sa->sa_family == AF_INET)
+     {
+        struct sockaddr_in *a = (struct sockaddr_in *)sa;
+        inet_ntop(sa->sa_family, &a->sin_addr, buf, sizeof(buf));
+        port = ntohs(a->sin_port);
+     }
+   else
+     {
+        struct sockaddr_in6 *a = (struct sockaddr_in6 *)sa;
+        inet_ntop(sa->sa_family, &a->sin6_addr, buf, sizeof(buf));
+        port = ntohs(a->sin6_port);
+     }
+
+   printf("INFO:   - sockaddr=%p (%d, '%s', %u)\n",
+          sa, sa->sa_family, buf, port);
+
+   printf("INFO:   - ipv4_class_a: %d\n", efl_net_ip_address_ipv4_class_a_check(o));
+   printf("INFO:   - ipv4_class_b: %d\n", efl_net_ip_address_ipv4_class_b_check(o));
+   printf("INFO:   - ipv4_class_c: %d\n", efl_net_ip_address_ipv4_class_c_check(o));
+   printf("INFO:   - ipv4_class_d: %d\n", efl_net_ip_address_ipv4_class_d_check(o));
+   printf("INFO:   - ipv6_v4mapped: %d\n", efl_net_ip_address_ipv6_v4mapped_check(o));
+   printf("INFO:   - ipv6_v4compat: %d\n", efl_net_ip_address_ipv6_v4compat_check(o));
+   printf("INFO:   - ipv6_local_link: %d\n", efl_net_ip_address_ipv6_local_link_check(o));
+   printf("INFO:   - ipv6_local_site: %d\n", efl_net_ip_address_ipv6_local_site_check(o));
+   printf("INFO:   - multicast: %d\n", efl_net_ip_address_multicast_check(o));
+   printf("INFO:   - loopback: %d\n", efl_net_ip_address_loopback_check(o));
+   printf("INFO:   - any: %d\n", efl_net_ip_address_any_check(o));
+}
+
+static void
+_resolved(void *data EINA_UNUSED, const Efl_Event *event)
+{
+   Efl_Future *future = event->object;
+   Efl_Future_Event_Success *f = event->info;
+   Efl_Net_Ip_Address_Resolve_Results *r = f->value;
+   Eina_Array_Iterator it;
+   unsigned int i;
+   const Efl_Net_Ip_Address *o;
+
+   printf("INFO: resolved '%s' to canonical name '%s':\n",
+          r->request_address, r->canonical_name);
+
+   EINA_ARRAY_ITER_NEXT(r->results, i, o, it)
+     _print_ip_addr_info(o);
+
+   putchar('\n');
+
+   resolving = eina_list_remove(resolving, future);
+   if (!resolving) ecore_main_loop_quit();
+}
+
+static void
+_resolve_failed(void *data, const Efl_Event *event)
+{
+   const char *address = data;
+   Efl_Future *future = event->object;
+   Efl_Future_Event_Failure *f = event->info;
+   fprintf(stderr, "ERROR: Failed to resolve '%s': %s\n",
+           address, eina_error_msg_get(f->error));
+   retval = EXIT_FAILURE;
+
+   resolving = eina_list_remove(resolving, future);
+   if (!resolving) ecore_main_loop_quit();
+}
+
+int
+main(int argc, char *argv[])
+{
+   int i;
+
+   ecore_init();
+   ecore_con_init();
+
+   for (i = 1; i < argc; i++)
+     {
+        const char *address = argv[i];
+        Eo *o = efl_net_ip_address_parse(EFL_NET_IP_ADDRESS_CLASS, address);
+        if (o)
+          {
+             _print_ip_addr_info(o);
+             efl_del(o);
+          }
+        else
+          {
+             Efl_Future *f = efl_net_ip_address_resolve(EFL_NET_IP_ADDRESS_CLASS, address, 0, 0);
+             if (!f)
+               {
+                  fprintf(stderr, "ERROR: cannot resolve '%s'!\n", address);
+                  retval = EXIT_FAILURE;
+               }
+             else
+               {
+                  printf("INFO: %s is not numeric, resolving...\n", address);
+                  efl_future_then(f, _resolved, _resolve_failed, NULL, address);
+                  resolving = eina_list_append(resolving, f);
+               }
+          }
+     }
+
+   if (resolving) ecore_main_loop_begin();
+
+   ecore_con_shutdown();
+   ecore_shutdown();
+
+   return retval;
+}

src/lib/ecore_con/Ecore_Con_Eo.h

@@ -43,3 +43,5 @@
 #include "efl_net_control_access_point.eo.h"
 #include "efl_net_control.eo.h"
 #include "efl_net_session.eo.h"
+
+#include "efl_net_ip_address.eo.h"

src/lib/ecore_con/efl_net_ip_address.c

@@ -0,0 +1,569 @@
+#define EFL_NET_IP_ADDRESS_PROTECTED 1
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#ifdef HAVE_ARPA_INET_H
+# include <arpa/inet.h>
+#endif
+
+#ifdef HAVE_EVIL
+# include <Evil.h>
+#endif
+
+#include "Ecore.h"
+#include "Ecore_Con.h"
+#include "ecore_con_private.h"
+
+typedef struct _Efl_Net_Ip_Address_Data {
+   char string[INET6_ADDRSTRLEN + sizeof("[]:65536")];
+   union {
+      struct sockaddr addr;
+      struct sockaddr_in ipv4;
+      struct sockaddr_in6 ipv6;
+   };
+   Eina_Slice addr_slice;
+} Efl_Net_Ip_Address_Data;
+
+#define MY_CLASS EFL_NET_IP_ADDRESS_CLASS
+
+EOLIAN static Eo *
+_efl_net_ip_address_efl_object_finalize(Eo *o, Efl_Net_Ip_Address_Data *pd)
+{
+   const uint16_t *pport;
+
+   o = efl_finalize(efl_super(o, MY_CLASS));
+   if (!o) return NULL;
+
+   EINA_SAFETY_ON_TRUE_RETURN_VAL(pd->addr.sa_family == 0, NULL);
+
+   if (!efl_net_ip_port_fmt(pd->string, sizeof(pd->string), &pd->addr))
+     {
+        ERR("Could not format address!");
+        return NULL;
+     }
+
+   if (pd->addr.sa_family == AF_INET6)
+     pport = &pd->ipv6.sin6_port;
+   else
+     pport = &pd->ipv4.sin_port;
+
+   if (*pport == 0) /* port == 0, no ":0" in the string */
+     {
+        char *d = strrchr(pd->string, ':');
+        EINA_SAFETY_ON_NULL_RETURN_VAL(d, NULL);
+        *d = '\0';
+     }
+
+   return o;
+}
+
+EOLIAN static const char *
+_efl_net_ip_address_string_get(Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd)
+{
+   return pd->string;
+}
+
+EOLIAN static void
+_efl_net_ip_address_family_set(Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd, int family)
+{
+   if (pd->addr.sa_family == family) return;
+   EINA_SAFETY_ON_TRUE_RETURN(pd->addr.sa_family != 0);
+   EINA_SAFETY_ON_TRUE_RETURN((family != AF_INET) && (family != AF_INET6));
+   pd->addr.sa_family = family;
+   if (family == AF_INET6)
+     {
+        pd->addr_slice.mem = &pd->ipv6.sin6_addr;
+        pd->addr_slice.len = sizeof(pd->ipv6.sin6_addr);
+     }
+   else
+     {
+        pd->addr_slice.mem = &pd->ipv4.sin_addr;
+        pd->addr_slice.len = sizeof(pd->ipv4.sin_addr);
+     }
+}
+
+EOLIAN static int
+_efl_net_ip_address_family_get(Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd)
+{
+   return pd->addr.sa_family;
+}
+
+EOLIAN static void
+_efl_net_ip_address_port_set(Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd, uint16_t port)
+{
+   uint16_t *pport, nport = htons(port);
+
+   EINA_SAFETY_ON_TRUE_RETURN(pd->addr.sa_family == 0);
+   if (pd->addr.sa_family == AF_INET6)
+     pport = &pd->ipv6.sin6_port;
+   else
+     pport = &pd->ipv4.sin_port;
+
+   if (*pport == nport) return;
+   if (*pport)
+     {
+        ERR("port already set to %hu, new %hu", ntohs(*pport), port);
+        return;
+     }
+
+   *pport = nport;
+}
+
+EOLIAN static uint16_t
+_efl_net_ip_address_port_get(Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd)
+{
+   const uint16_t *pport;
+
+   EINA_SAFETY_ON_TRUE_RETURN_VAL(pd->addr.sa_family == 0, 0);
+   if (pd->addr.sa_family == AF_INET6)
+     pport = &pd->ipv6.sin6_port;
+   else
+     pport = &pd->ipv4.sin_port;
+
+   return ntohs(*pport);
+}
+
+EOLIAN static void
+_efl_net_ip_address_address_set(Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd, const Eina_Slice *address)
+{
+   Eina_Rw_Slice rw_slice;
+   size_t i;
+
+   EINA_SAFETY_ON_TRUE_RETURN(pd->addr.sa_family == 0);
+   EINA_SAFETY_ON_NULL_RETURN(address);
+
+   rw_slice.mem = (void *)pd->addr_slice.mem;
+   rw_slice.len = pd->addr_slice.len;
+
+   EINA_SAFETY_ON_TRUE_RETURN(rw_slice.len != address->len);
+
+   if (eina_slice_compare(eina_rw_slice_slice_get(rw_slice), *address) == 0)
+     return;
+
+   for (i = 0; i < rw_slice.len; i++)
+     {
+        if (rw_slice.bytes[i])
+          {
+             char old_str[INET6_ADDRSTRLEN] = "";
+             char new_str[INET6_ADDRSTRLEN] = "";
+
+             if (!inet_ntop(pd->addr.sa_family, rw_slice.mem, old_str, sizeof(old_str)))
+               {
+                  old_str[0] = '?';
+                  old_str[1] = '\0';
+               }
+             if (!inet_ntop(pd->addr.sa_family, address->mem, new_str, sizeof(new_str)))
+               {
+                  new_str[0] = '?';
+                  new_str[1] = '\0';
+               }
+             ERR("address already set to %s, new %s", old_str, new_str);
+             return;
+          }
+     }
+
+   eina_rw_slice_copy(rw_slice, *address);
+}
+
+EOLIAN static const Eina_Slice *
+_efl_net_ip_address_address_get(Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd)
+{
+   return &pd->addr_slice;
+}
+
+EOLIAN static void
+_efl_net_ip_address_sockaddr_set(Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd, const void *ptr)
+{
+   const struct sockaddr *sockaddr = ptr;
+
+   EINA_SAFETY_ON_TRUE_RETURN(pd->addr.sa_family != 0);
+   EINA_SAFETY_ON_NULL_RETURN(sockaddr);
+
+   EINA_SAFETY_ON_TRUE_RETURN((sockaddr->sa_family != AF_INET) && (sockaddr->sa_family != AF_INET6));
+
+   if (sockaddr->sa_family == AF_INET6)
+     {
+        memcpy(&pd->ipv6, sockaddr, sizeof(pd->ipv6));
+        pd->addr_slice.mem = &pd->ipv6.sin6_addr;
+        pd->addr_slice.len = sizeof(pd->ipv6.sin6_addr);
+     }
+   else
+     {
+        memcpy(&pd->ipv4, sockaddr, sizeof(pd->ipv4));
+        pd->addr_slice.mem = &pd->ipv4.sin_addr;
+        pd->addr_slice.len = sizeof(pd->ipv4.sin_addr);
+     }
+}
+
+EOLIAN static const void *
+_efl_net_ip_address_sockaddr_get(Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd)
+{
+   return &pd->addr;
+}
+
+#define IPV4_ADDR_GET(pd) ntohl(pd->ipv4.sin_addr.s_addr)
+
+EOLIAN static Eina_Bool
+_efl_net_ip_address_ipv4_class_a_check(const Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd)
+{
+   return (pd->addr.sa_family == AF_INET) && IN_CLASSA(IPV4_ADDR_GET(pd));
+}
+
+EOLIAN static Eina_Bool
+_efl_net_ip_address_ipv4_class_b_check(const Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd)
+{
+   return (pd->addr.sa_family == AF_INET) && IN_CLASSB(IPV4_ADDR_GET(pd));
+}
+
+EOLIAN static Eina_Bool
+_efl_net_ip_address_ipv4_class_c_check(const Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd)
+{
+   return (pd->addr.sa_family == AF_INET) && IN_CLASSC(IPV4_ADDR_GET(pd));
+}
+
+EOLIAN static Eina_Bool
+_efl_net_ip_address_ipv4_class_d_check(const Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd)
+{
+   return (pd->addr.sa_family == AF_INET) && IN_CLASSD(IPV4_ADDR_GET(pd));
+}
+
+EOLIAN static Eina_Bool
+_efl_net_ip_address_ipv6_v4mapped_check(const Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd)
+{
+   return (pd->addr.sa_family == AF_INET6) &&
+     IN6_IS_ADDR_V4MAPPED(&pd->ipv6.sin6_addr);
+}
+
+EOLIAN static Eina_Bool
+_efl_net_ip_address_ipv6_v4compat_check(const Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd)
+{
+   return (pd->addr.sa_family == AF_INET6) &&
+     IN6_IS_ADDR_V4COMPAT(&pd->ipv6.sin6_addr);
+}
+
+EOLIAN static Eina_Bool
+_efl_net_ip_address_ipv6_local_link_check(const Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd)
+{
+   return (pd->addr.sa_family == AF_INET6) &&
+     IN6_IS_ADDR_LINKLOCAL(&pd->ipv6.sin6_addr);
+}
+
+EOLIAN static Eina_Bool
+_efl_net_ip_address_ipv6_local_site_check(const Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd)
+{
+   return (pd->addr.sa_family == AF_INET6) &&
+     IN6_IS_ADDR_SITELOCAL(&pd->ipv6.sin6_addr);
+}
+
+EOLIAN static Eina_Bool
+_efl_net_ip_address_multicast_check(const Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd)
+{
+   if (pd->addr.sa_family == AF_INET6)
+     return IN6_IS_ADDR_MULTICAST(&pd->ipv6.sin6_addr);
+   else
+     return IN_MULTICAST(IPV4_ADDR_GET(pd));
+}
+
+EOLIAN static Eina_Bool
+_efl_net_ip_address_loopback_check(const Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd)
+{
+   if (pd->addr.sa_family == AF_INET6)
+     return IN6_IS_ADDR_LOOPBACK(&pd->ipv6.sin6_addr);
+   else
+     return IPV4_ADDR_GET(pd) == INADDR_LOOPBACK;
+}
+
+EOLIAN static Eina_Bool
+_efl_net_ip_address_any_check(const Eo *o EINA_UNUSED, Efl_Net_Ip_Address_Data *pd)
+{
+   size_t i;
+
+   for (i = 0; i < pd->addr_slice.len; i++)
+     {
+        if (pd->addr_slice.bytes[i])
+          return EINA_FALSE;
+     }
+
+   return i > 0;
+}
+
+EOLIAN static Efl_Net_Ip_Address *
+_efl_net_ip_address_create(Eo *cls, void *pd EINA_UNUSED, uint16_t port, const Eina_Slice address)
+{
+   int family;
+
+   EINA_SAFETY_ON_TRUE_RETURN_VAL(address.len != 4 && address.len != 16, NULL);
+
+   if (address.len == 16)
+     family = AF_INET6;
+   else
+     family = AF_INET;
+
+   return efl_add(cls, NULL,
+                  efl_net_ip_address_family_set(efl_added, family),
+                  efl_net_ip_address_port_set(efl_added, port),
+                  efl_net_ip_address_set(efl_added, &address));
+}
+
+EOLIAN static Efl_Net_Ip_Address *
+_efl_net_ip_address_create_sockaddr(Eo *cls, void *pd EINA_UNUSED, const void *ptr)
+{
+   const struct sockaddr *sockaddr = ptr;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(sockaddr, NULL);
+   EINA_SAFETY_ON_TRUE_RETURN_VAL((sockaddr->sa_family != AF_INET) && (sockaddr->sa_family != AF_INET6), NULL);
+
+   return efl_add(cls, NULL,
+                  efl_net_ip_address_sockaddr_set(efl_added, sockaddr));
+}
+
+EOLIAN static Efl_Net_Ip_Address *
+_efl_net_ip_address_parse(Eo *cls, void *pd EINA_UNUSED, const char *numeric_address)
+{
+   struct sockaddr_storage ss;
+   Eina_Bool r;
+   const char *address = numeric_address;
+   char *tmp = NULL;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(numeric_address, NULL);
+
+   if (numeric_address[0] != '[')
+     {
+        const char *p = strchr(numeric_address, ':');
+        if (p)
+          {
+             p = strchr(p + 1, ':');
+             if (p)
+               {
+                  size_t len = strlen(numeric_address);
+                  /* IPv6 no braces: ::1, etc... no port, add braces */
+                  tmp = malloc(len + sizeof("[]"));
+                  EINA_SAFETY_ON_NULL_RETURN_VAL(tmp, NULL);
+                  tmp[0] = '[';
+                  memcpy(tmp + 1, numeric_address, len);
+                  tmp[1 + len] = ']';
+                  address = tmp;
+               }
+          }
+     }
+
+   r = efl_net_ip_port_parse(address, &ss);
+   free(tmp);
+   if (!r)
+     {
+        DBG("could not parse numeric address: %s", numeric_address);
+        return NULL;
+     }
+
+   return efl_add(cls, NULL,
+                  efl_net_ip_address_sockaddr_set(efl_added, &ss));
+}
+
+typedef struct _Efl_Net_Ip_Address_Resolve_Context {
+   Efl_Net_Ip_Address_Resolve_Results *result;
+   Ecore_Thread *thread;
+   Efl_Promise *promise;
+} Efl_Net_Ip_Address_Resolve_Context;
+
+static void
+_efl_net_ip_address_resolve_results_free(void *data)
+{
+   Efl_Net_Ip_Address_Resolve_Results *r = data;
+
+   if (r->results)
+     {
+        Eina_Array_Iterator it;
+        unsigned int i;
+        Efl_Net_Ip_Address *o;
+
+        EINA_ARRAY_ITER_NEXT(r->results, i, o, it)
+          efl_unref(o);
+
+        eina_array_free(r->results);
+        r->results = NULL;
+     }
+
+   eina_stringshare_replace(&r->canonical_name, NULL);
+   eina_stringshare_replace(&r->request_address, NULL);
+   free(r);
+}
+
+static void
+_efl_net_ip_address_resolve_del(void *data, const Efl_Event *event EINA_UNUSED)
+{
+   Efl_Net_Ip_Address_Resolve_Context *ctx = data;
+
+   ctx->promise = NULL;
+
+   if (ctx->thread)
+     {
+        ecore_thread_cancel(ctx->thread);
+        ctx->thread = NULL;
+     }
+
+   if (ctx->result)
+     {
+        _efl_net_ip_address_resolve_results_free(ctx->result);
+        ctx->result = NULL;
+     }
+
+   free(ctx);
+}
+
+static inline int
+_efl_net_ip_address_find(const Eina_Array *array, const struct sockaddr *addr)
+{
+   Eina_Array_Iterator it;
+   unsigned int i;
+   const Efl_Net_Ip_Address *o;
+
+   if (addr->sa_family == AF_INET6)
+     {
+        EINA_ARRAY_ITER_NEXT(array, i, o, it)
+          {
+             const struct sockaddr *other = efl_net_ip_address_sockaddr_get(o);
+             if (other->sa_family == AF_INET6)
+               {
+                  if (memcmp(other,  addr, sizeof(struct sockaddr_in6)) == 0)
+                    return (int)i;
+               }
+          }
+     }
+   else
+     {
+        EINA_ARRAY_ITER_NEXT(array, i, o, it)
+          {
+             const struct sockaddr *other = efl_net_ip_address_sockaddr_get(o);
+             if (other->sa_family == AF_INET)
+               {
+                  if (memcmp(other,  addr, sizeof(struct sockaddr_in)) == 0)
+                    return (int)i;
+               }
+          }
+     }
+   return -1;
+}
+
+static void
+_efl_net_ip_address_resolve_done(void *data, const char *host, const char *port, const struct addrinfo *hints EINA_UNUSED, struct addrinfo *result, int gai_error)
+{
+   Efl_Net_Ip_Address_Resolve_Context *ctx = data;
+   Efl_Net_Ip_Address_Resolve_Results *r;
+   const struct addrinfo *a;
+
+   DBG("done resolving '%s' (host='%s', port='%s'): %s",
+       ctx->result->request_address, host, port,
+       gai_error ? gai_strerror(gai_error) : "success");
+
+   ctx->thread = NULL;
+
+   if (gai_error)
+     {
+        Eina_Error err = EFL_NET_ERROR_COULDNT_RESOLVE_HOST;
+
+        if (gai_error == EAI_SYSTEM)
+          err = errno;
+
+        efl_promise_failed_set(ctx->promise, err);
+        return;
+     }
+
+   ctx->result->results = eina_array_new(16);
+   if (!ctx->result->results)
+     {
+        efl_promise_failed_set(ctx->promise, ENOMEM);
+        return;
+     }
+
+   r = ctx->result;
+   ctx->result = NULL; /* steal for efl_promise_value_set() */
+
+   for (a = result; a != NULL; a = a->ai_next)
+     {
+        Eo *o;
+
+        if (EINA_UNLIKELY((r->canonical_name == NULL) &&
+                          (a->ai_canonname != NULL)))
+          r->canonical_name = eina_stringshare_add(a->ai_canonname);
+
+        /* some addresses get duplicated with different options that we
+         * do not care, so check for duplicates.
+         */
+        if (EINA_UNLIKELY(_efl_net_ip_address_find(r->results, a->ai_addr) >= 0))
+          continue;
+
+        o = efl_net_ip_address_create_sockaddr(EFL_NET_IP_ADDRESS_CLASS, a->ai_addr);
+        if (o)
+          {
+             if (!eina_array_push(r->results, o))
+               efl_del(o);
+          }
+     }
+   freeaddrinfo(result);
+
+   efl_promise_value_set(ctx->promise, r, _efl_net_ip_address_resolve_results_free);
+}
+
+EOLIAN static Efl_Future *
+_efl_net_ip_address_resolve(Eo *cls EINA_UNUSED, void *pd EINA_UNUSED, const char *address, int family, int flags)
+{
+   Efl_Net_Ip_Address_Resolve_Context *ctx;
+   struct addrinfo hints = { };
+   const char *host = NULL, *port = NULL;
+   char *str;
+
+   EINA_SAFETY_ON_NULL_RETURN_VAL(address, NULL);
+
+   if (family == 0) family = AF_UNSPEC;
+   EINA_SAFETY_ON_TRUE_RETURN_VAL((family != AF_UNSPEC) && (family != AF_INET) && (family != AF_INET6), NULL);
+
+   if (flags == 0) flags = AI_ADDRCONFIG | AI_V4MAPPED | AI_CANONNAME;
+   hints.ai_family = family;
+   hints.ai_flags = flags;
+
+   str = strdup(address);
+   EINA_SAFETY_ON_NULL_RETURN_VAL(str, NULL);
+
+   efl_net_ip_port_split(str, &host, &port);
+   if ((!host) || (host[0] == '\0'))
+     {
+        host = address;
+        port = "0";
+     }
+   if (!port) port = "0";
+
+   ctx = calloc(1, sizeof(Efl_Net_Ip_Address_Resolve_Context));
+   EINA_SAFETY_ON_NULL_GOTO(ctx, error_ctx);
+
+   ctx->result = calloc(1, sizeof(Efl_Net_Ip_Address_Resolve_Results));
+   EINA_SAFETY_ON_NULL_GOTO(ctx->result, error_result);
+
+   ctx->result->request_address = eina_stringshare_add(address);
+   EINA_SAFETY_ON_NULL_GOTO(ctx->result->request_address, error_result_address);
+
+   ctx->thread = efl_net_ip_resolve_async_new(host, port, &hints, _efl_net_ip_address_resolve_done, ctx);
+   EINA_SAFETY_ON_NULL_GOTO(ctx->thread, error_thread);
+
+   ctx->promise = efl_add(EFL_PROMISE_CLASS, ecore_main_loop_get(),
+                          efl_event_callback_add(efl_added, EFL_EVENT_DEL, _efl_net_ip_address_resolve_del, ctx));
+   EINA_SAFETY_ON_NULL_GOTO(ctx->promise, error_promise);
+
+   free(str);
+   return efl_promise_future_get(ctx->promise);
+
+ error_promise:
+   ecore_thread_cancel(ctx->thread);
+ error_thread:
+   eina_stringshare_del(ctx->result->request_address);
+ error_result_address:
+   free(ctx->result);
+ error_result:
+   free(ctx);
+ error_ctx:
+   free(str);
+   return NULL;
+}
+
+#include "efl_net_ip_address.eo.c"

src/lib/ecore_con/efl_net_ip_address.eo

@@ -0,0 +1,246 @@
+import eina_types;
+
+struct Efl.Net.Ip.Address.Resolve_Results {
+    [[The results of @Efl.Net.Ip.Address.resolve call.
+
+      This structure is created by @Efl.Net.Ip.Address.resolve.
+      XXX should be destroyed manually?
+
+      @since 1.19
+    ]]
+    request_address: string; [[The 'address' argument given to Efl.Net.Ip.Address.resolve]]
+    canonical_name: string; [[The canonical name, if it was requested in flags]]
+    results: array<Efl.Net.Ip.Address>; [[The resolved objects. Do not modify this array, but you can keep reference to elements using efl_ref() and efl_unref()]]
+}
+
+class Efl.Net.Ip.Address (Efl.Object) {
+    [[An Internet Protocol (IP) Address.
+
+      This class is a set of helpers to translate to and from address
+      strings used in Efl.Net. For IP they take the formats:
+
+        - IPv4 complete: 127.0.0.1:1234
+        - IPv4 no port: 127.0.0.1
+        - IPv6 complete: [::1]:1234
+        - IPv6 no port: [::1]
+        - IPv6 no braces (implies no port): ::1
+
+      However in other libraries one may use the address numbers or
+      even a 'struct sockaddr' handle and translating by yourself may
+      be too much work. To convert to a string, just create an
+      instance with @.create or @.create_sockaddr and then query
+      @.string. To convert from numeric string to sockaddr, create an
+      instance with @.parse and then query @.sockaddr.
+
+      To resolve a host and port name to numbers use @.resolve, this
+      will asynchronously resolve and return the results in a promise.
+
+      The result of @.string can be passed to @Efl.Net.Dialer.dial and
+      @Efl.Net.Server.serve
+
+      @since 1.19
+    ]]
+
+    methods {
+        create @class {
+            [[Create an object given family, port and address.
+
+              This is a convenience to create an object in a single
+              call. To create based on 'struct sockaddr', see
+              @.create_sockaddr. To create from string, see @.parse.
+            ]]
+            params {
+                port: uint16; [[Port number in Host/Native endianess]]
+                address: const(Eina.Slice); [[Address bytes. If 4 bytes, AF_INET will be used. If 16 bytes, AF_INET6 will be used. All other sizes will result in failure.]]
+            }
+            return: own(Efl.Net.Ip.Address); [[newly created object or $NULL if parameters were invalid.]]
+        }
+
+        create_sockaddr @class {
+            [[Create an object given sockaddr
+
+              This is a convenience to create an object in a single call.
+              To create based on native port and address bytes,
+              use @.create, to create from string use @.parse.
+            ]]
+            params {
+                sockaddr: const(void_ptr) @nonull; [[The pointer to struct sockaddr-compatible handle as per <netinet/in.h>.]]
+            }
+            return: own(Efl.Net.Ip.Address); [[newly created object or $NULL if parameter was invalid.]]
+        }
+
+        parse @class {
+            [[Parse a numeric address and return an object representing it.
+
+              This parses a numeric IPv4 or IPv6 address and optional
+              port, returning an object representing it on success or
+              $NULL on failure.
+
+              The address may be in the formats:
+
+               - IPv4 complete: 127.0.0.1:1234
+               - IPv4 no port: 127.0.0.1
+               - IPv6 complete: [::1]:1234
+               - IPv6 no port: [::1]
+               - IPv6 no braces (implies no port): ::1
+
+              If you want to translate address and port to numbers use
+              @.resolve.
+            ]]
+            params {
+                numeric_address: string; [[The numeric address to parse, such as '127.0.0.1:1234' or '[::1]:1234']]
+            }
+            return: own(Efl.Net.Ip.Address); [[The new IP address object or NULL if it failed to parse]]
+        }
+
+        resolve @class {
+            [[Asynchronously resolve host and port names.
+
+              This will resolve the host and port names, returning the
+              results asynchronously in a Future.
+
+              It's based on getaddrinfo() and will receive extra flags
+              to change its behavior.
+
+              Ports can also be named, for example http resolves to
+              80. Your system database is used (see getaddrinfo()).
+
+              You may try @.parse if you have numeric values for host
+              and port.
+            ]]
+            params {
+                address: string @nonull; [[The address such as enlightenment.org:http or enlightenment.org (port=0)]]
+                family: int @optional; [[Preferred family. AF_UNSPEC or 0 for both, otherwise one of AF_INET or AF_INET6]]
+                flags: int @optional; [[Flags to use with getaddrinfo(). If 0, default flags are used (AI_V4MAPPED | AI_ADDRCONFIG, if these exist in your system).]]
+            }
+            return: future<const(Efl.Net.Ip.Address.Resolve_Results)>; [[The resolve results. It contains a list of Efl.Net.Ip.Address, they will be automatically deleted unless you keep a reference to it.]]
+        }
+
+        @property string {
+            [[Returns the numeric address formatted as a string.
+
+              The format will be:
+
+               - IPv4 with port > 0: 127.0.0.1:1234
+               - IPv4 with port == 0: 127.0.0.1
+               - IPv6 with port > 0: [::1]:1234
+               - IPv6 with port == 0: [::1]
+            ]]
+            get { }
+            values {
+                str: string @nonull;
+            }
+        }
+
+        @property family {
+            [[The address family, one of AF_INET6 or AF_INET.
+
+              May only be set once, afterwards the object is not changing.
+            ]]
+            values {
+                family: int; [[AF_INET or AF_INET6]]
+            }
+        }
+
+        @property port {
+            [[The address port in Host/Native endianess.
+
+              May only be set once, afterwards the object is not changing.
+
+              Must be set after @.family.
+            ]]
+            values {
+                port: uint16; [[Port number in Host/Native endianess]]
+            }
+        }
+
+        @property address {
+            [[The bytes representing the address.
+
+              May only be set once, afterwards the object is not changing.
+
+              Must be set after @.family.
+            ]]
+            values {
+                address: const(ptr(Eina.Slice)) @nonull;
+            }
+        }
+
+        @property sockaddr {
+            [[The <netinet/in.h>-compatible 'struct sockaddr'.
+
+              May only be set once, afterwards the object is not changing.
+            ]]
+            values {
+                sockaddr: const(void_ptr) @nonull;
+            }
+        }
+
+        ipv4_class_a_check @const {
+            [[Check if IPv4 and is CLASS-A]]
+            return: bool(false); [[$true if is a CLASS-A IPv4 address]]
+        }
+
+        ipv4_class_b_check @const {
+            [[Check if IPv4 and is CLASS-B]]
+            return: bool(false); [[$true if is a CLASS-B IPv4 address]]
+        }
+
+        ipv4_class_c_check @const {
+            [[Check if IPv4 and is CLASS-C]]
+            return: bool(false); [[$true if is a CLASS-C IPv4 address]]
+        }
+
+        ipv4_class_d_check @const {
+            [[Check if IPv4 and is CLASS-D]]
+            return: bool(false); [[$true if is a CLASS-D IPv4 address]]
+        }
+
+        ipv6_v4mapped_check @const {
+            [[Check if IPv6 is mapping an IPv4.
+
+              If the IPv6 server is not IPv6-only, then it will take
+              IPv4 addresses and map them inside IPv6. This checks if
+              the given address is an IPv4 mapped inside IPv6.
+            ]]
+            return: bool(false); [[$true if is the IPv6 is IPv4 mapped inside IPv6 address]]
+        }
+
+        ipv6_v4compat_check @const {
+            [[Check if IPv6 is compatible with IPv4.
+
+              This happens if the first 12 bytes of IPv6 are 0.
+            ]]
+            return: bool(false); [[$true if is a IPv6 address is IPv4 compatible.]]
+        }
+
+        ipv6_local_link_check @const {
+            [[Check if IPv6 is link-local.]]
+            return: bool(false); [[$true if is a IPv6 address is link-local]]
+        }
+
+        ipv6_local_site_check @const {
+            [[Check if IPv6 is site-local.]]
+            return: bool(false); [[$true if is a IPv6 address is site-local]]
+        }
+
+        multicast_check @const {
+            [[Check if multicast]]
+            return: bool(false); [[$true if is a multicast address]]
+        }
+
+        loopback_check @const {
+            [[Check if loopback "127.0.0.1" (IPv4) or "::1" (IPv6)]]
+            return: bool(false); [[$true if is a multicast address]]
+        }
+
+        any_check @const {
+            [[Check if "0.0.0.0" (IPv4) or "::" (IPv6)]]
+            return: bool(false); [[$true if address means "any"]]
+        }
+    }
+
+    implements {
+        Efl.Object.finalize;
+    }
+}

src/tests/ecore_con/ecore_con_suite.c

@@ -9,6 +9,7 @@ static const Efl_Test_Case etc[] = {
   { "Ecore_Con", ecore_con_test_ecore_con },
   { "Ecore_Con_Url", ecore_con_test_ecore_con_url },
   { "Ecore_Con_Eet", ecore_con_test_ecore_con_eet },
+  { "Efl_Net_Ip_Address", ecore_con_test_efl_net_ip_address },
   { NULL, NULL }
 };
 

src/tests/ecore_con/ecore_con_suite.h

@@ -6,5 +6,6 @@
 void ecore_con_test_ecore_con(TCase *tc);
 void ecore_con_test_ecore_con_url(TCase *tc);
 void ecore_con_test_ecore_con_eet(TCase *tc);
+void ecore_con_test_efl_net_ip_address(TCase *tc);
 
 #endif /* _ECORE_CON_SUITE_H */