diff --git a/src/conn.c b/src/conn.c
index f586a59d..2e855364 100644
--- a/src/conn.c
+++ b/src/conn.c
@@ -103,11 +103,11 @@ static void _conn_sm_handle_stanza(xmpp_conn_t *const conn,
 static unsigned short _conn_default_port(xmpp_conn_t *conn,
                                          xmpp_conn_type_t type);
 static void _conn_reset(xmpp_conn_t *conn);
-static int _conn_connect(xmpp_conn_t *conn,
-                         const char *domain,
-                         xmpp_conn_type_t type,
-                         xmpp_conn_handler callback,
-                         void *userdata);
+static int _conn_preconnect(xmpp_conn_t *conn,
+                            char *domain,
+                            xmpp_conn_type_t type,
+                            xmpp_conn_handler callback,
+                            void *userdata);
 static void _send_valist(xmpp_conn_t *conn,
                          const char *fmt,
                          va_list ap,
@@ -709,14 +709,14 @@ int xmpp_connect_client(xmpp_conn_t *conn,
 
     if (conn->xsock)
         sock_free(conn->xsock);
-    conn->xsock = sock_new(conn, domain, altdomain, altport);
-    if (!conn->xsock)
-        goto err_mem;
 
-    rc = _conn_connect(conn, domain, XMPP_CLIENT, callback, userdata);
-    strophe_free(conn->ctx, domain);
+    /* domain ownership transfers to conn */
+    if ((rc =
+             _conn_preconnect(conn, domain, XMPP_CLIENT, callback, userdata))) {
+        return rc;
+    }
 
-    return rc;
+    return sock_new(conn, domain, altdomain, altport);
 
 err_mem:
     strophe_free(conn->ctx, domain);
@@ -752,6 +752,7 @@ int xmpp_connect_component(xmpp_conn_t *conn,
                            xmpp_conn_handler callback,
                            void *userdata)
 {
+    int rc;
     /*  The server domain, jid and password MUST be specified. */
     if (!(server && conn->jid && conn->pass))
         return XMPP_EINVOP;
@@ -769,13 +770,15 @@ int xmpp_connect_component(xmpp_conn_t *conn,
     port = port ? port : _conn_default_port(conn, XMPP_COMPONENT);
     if (conn->xsock)
         sock_free(conn->xsock);
-    conn->xsock = sock_new(conn, NULL, server, port);
-    if (!conn->xsock)
-        return XMPP_EMEM;
 
     /* JID serves as an identifier here and will be used as "to" attribute
        of the stream */
-    return _conn_connect(conn, conn->jid, XMPP_COMPONENT, callback, userdata);
+    if ((rc = _conn_preconnect(conn, strophe_strdup(conn->ctx, conn->jid),
+                               XMPP_COMPONENT, callback, userdata))) {
+        return rc;
+    }
+
+    return sock_new(conn, NULL, server, port);
 }
 
 /** Initiate a raw connection to the XMPP server.
@@ -2170,11 +2173,11 @@ static void _conn_reset(xmpp_conn_t *conn)
     handler_system_delete_all(conn);
 }
 
-static int _conn_connect(xmpp_conn_t *conn,
-                         const char *domain,
-                         xmpp_conn_type_t type,
-                         xmpp_conn_handler callback,
-                         void *userdata)
+static int _conn_preconnect(xmpp_conn_t *conn,
+                            char *domain,
+                            xmpp_conn_type_t type,
+                            xmpp_conn_handler callback,
+                            void *userdata)
 {
     xmpp_open_handler open_handler;
 
@@ -2186,14 +2189,10 @@ static int _conn_connect(xmpp_conn_t *conn,
     _conn_reset(conn);
 
     conn->type = type;
-    conn->domain = strophe_strdup(conn->ctx, domain);
+    conn->domain = domain;
     if (!conn->domain)
         return XMPP_EMEM;
 
-    conn->sock = sock_connect(conn->xsock);
-    if (conn->sock == INVALID_SOCKET)
-        return XMPP_EINT;
-
     /* setup handler */
     conn->conn_handler = callback;
     conn->userdata = userdata;
@@ -2208,6 +2207,7 @@ static int _conn_connect(xmpp_conn_t *conn,
      * hard to fix, since we'd have to detect and fire off the callback
      * from within the event loop */
 
+    conn->sock = INVALID_SOCKET;
     conn->state = XMPP_STATE_CONNECTING;
     conn->timeout_stamp = time_stamp();
 
diff --git a/src/event.c b/src/event.c
index 56d0a24c..0fa5a62a 100644
--- a/src/event.c
+++ b/src/event.c
@@ -57,22 +57,19 @@
 #include "strophe.h"
 #include "common.h"
 #include "parser.h"
+#include "resolver.h"
 
 #ifndef STROPHE_MESSAGE_BUFFER_SIZE
 /** Max buffer size for receiving messages. */
 #define STROPHE_MESSAGE_BUFFER_SIZE 4096
 #endif
 
-static int _connect_next(xmpp_conn_t *conn)
+static void _connect_next(xmpp_conn_t *conn)
 {
     sock_close(conn->sock);
-    conn->sock = sock_connect(conn->xsock);
-    if (conn->sock == INVALID_SOCKET)
-        return -1;
-
+    conn->sock = INVALID_SOCKET;
     conn->timeout_stamp = time_stamp();
-
-    return 0;
+    sock_connect(conn->xsock);
 }
 
 /** Run the event loop once.
@@ -220,17 +217,14 @@ void xmpp_run_once(xmpp_ctx_t *ctx, unsigned long timeout)
 
             /* make sure the timeout hasn't expired */
             if (time_elapsed(conn->timeout_stamp, time_stamp()) <=
-                conn->connect_timeout)
-                FD_SET(conn->sock, &wfds);
-            else {
+                conn->connect_timeout) {
+                if (conn->sock != INVALID_SOCKET)
+                    FD_SET(conn->sock, &wfds);
+            } else {
                 strophe_info(ctx, "xmpp", "Connection attempt timed out.");
-                ret = _connect_next(conn);
-                if (ret != 0) {
-                    conn->error = ETIMEDOUT;
-                    conn_disconnect(conn);
-                } else {
+                _connect_next(conn);
+                if (conn->sock != INVALID_SOCKET)
                     FD_SET(conn->sock, &wfds);
-                }
             }
             break;
         case XMPP_STATE_CONNECTED:
@@ -254,6 +248,15 @@ void xmpp_run_once(xmpp_ctx_t *ctx, unsigned long timeout)
         connitem = connitem->next;
     }
 
+#ifdef HAVE_CARES
+    if (ares_chan) {
+        int ares_max = ares_fds(ares_chan, &rfds, &wfds);
+        if (ares_max > max)
+            max = ares_max;
+        ares_timeout(ares_chan, &tv, &tv);
+    }
+#endif
+
     /* check for events */
     if (max > 0)
         ret = select(max + 1, &rfds, &wfds, NULL, &tv);
@@ -271,6 +274,11 @@ void xmpp_run_once(xmpp_ctx_t *ctx, unsigned long timeout)
         return;
     }
 
+#ifdef HAVE_CARES
+    if (ares_chan)
+        ares_process(ares_chan, &rfds, &wfds);
+#endif
+
     /* no events happened */
     if (ret == 0 && tls_read_bytes == 0)
         return;
@@ -292,11 +300,7 @@ void xmpp_run_once(xmpp_ctx_t *ctx, unsigned long timeout)
                     /* connection failed */
                     strophe_debug(ctx, "xmpp", "connection failed, error %d",
                                   ret);
-                    ret = _connect_next(conn);
-                    if (ret != 0) {
-                        conn->error = ret;
-                        conn_disconnect(conn);
-                    }
+                    _connect_next(conn);
                     break;
                 }
 
diff --git a/src/resolver.c b/src/resolver.c
index 028320a0..f9aabe21 100644
--- a/src/resolver.c
+++ b/src/resolver.c
@@ -18,10 +18,10 @@
 #include <netinet/in.h>
 #include <arpa/nameser.h>
 #include <resolv.h>
+#include <netdb.h>
 #endif /* _WIN32 && HAVE_CARES */
 
 #ifdef HAVE_CARES
-#include <ares.h>
 /* for select(2) */
 #ifdef _WIN32
 #include <winsock2.h>
@@ -48,14 +48,22 @@
  * Forward declarations.
  ******************************************************************************/
 
+struct resolver_ctx {
+    xmpp_ctx_t *ctx;
+    const char *domain;
+    resolver_srv_rr_t **srv_rr_list;
+    void (*callback)(xmpp_sock_t *xsock, const char *domain);
+    xmpp_sock_t *xsock;
+};
+
 #ifdef HAVE_CARES
+ares_channel ares_chan = NULL;
 static int resolver_ares_srv_lookup_buf(xmpp_ctx_t *ctx,
                                         const unsigned char *buf,
                                         size_t len,
                                         resolver_srv_rr_t **srv_rr_list);
-static int resolver_ares_srv_lookup(xmpp_ctx_t *ctx,
-                                    const char *fulldomain,
-                                    resolver_srv_rr_t **srv_rr_list);
+static void resolver_ares_srv_lookup(const char *fulldomain,
+                                     struct resolver_ctx *rctx);
 #endif /* HAVE_CARES */
 
 #ifndef HAVE_CARES
@@ -81,13 +89,19 @@ static int resolver_win32_srv_query(const char *fulldomain,
 void resolver_initialize(void)
 {
 #ifdef HAVE_CARES
+    int rc;
     ares_library_init(ARES_LIB_INIT_ALL);
+    rc = ares_init(&ares_chan);
+    if (rc != ARES_SUCCESS) {
+        /* This is bad */
+    }
 #endif
 }
 
 void resolver_shutdown(void)
 {
 #ifdef HAVE_CARES
+    ares_destroy(ares_chan);
     ares_library_cleanup();
 #endif
 }
@@ -188,11 +202,14 @@ int resolver_srv_lookup_buf(xmpp_ctx_t *ctx,
     return set;
 }
 
-int resolver_srv_lookup(xmpp_ctx_t *ctx,
-                        const char *service,
-                        const char *proto,
-                        const char *domain,
-                        resolver_srv_rr_t **srv_rr_list)
+void resolver_srv_lookup(xmpp_ctx_t *ctx,
+                         const char *service,
+                         const char *proto,
+                         const char *domain,
+                         resolver_srv_rr_t **srv_rr_list,
+                         void (*callback)(xmpp_sock_t *xsock,
+                                          const char *domain),
+                         xmpp_sock_t *xsock)
 {
 #define RESOLVER_BUF_MAX 65536
     unsigned char *buf;
@@ -210,19 +227,33 @@ int resolver_srv_lookup(xmpp_ctx_t *ctx,
 
 #ifdef HAVE_CARES
 
-    set = resolver_ares_srv_lookup(ctx, fulldomain, srv_rr_list);
+    struct resolver_ctx *rctx = strophe_alloc(ctx, sizeof(*rctx));
+    rctx->ctx = ctx;
+    rctx->domain = domain;
+    rctx->srv_rr_list = srv_rr_list;
+    rctx->callback = callback;
+    rctx->xsock = xsock;
+
+    (void)set;
+    resolver_ares_srv_lookup(fulldomain, rctx);
 
 #else /* HAVE_CARES */
 
 #ifdef _WIN32
     set = resolver_win32_srv_lookup(ctx, fulldomain, srv_rr_list);
-    if (set == XMPP_DOMAIN_FOUND)
-        return set;
+    if (set != XMPP_DOMAIN_FOUND) {
+        *srv_rr_list = NULL;
+        callback(xsock, domain);
+        return;
+    }
 #endif /* _WIN32 */
 
     buf = strophe_alloc(ctx, RESOLVER_BUF_MAX);
-    if (buf == NULL)
-        return XMPP_DOMAIN_NOT_FOUND;
+    if (buf == NULL) {
+        *srv_rr_list = NULL;
+        callback(xsock, domain);
+        return;
+    }
 
 #ifdef _WIN32
     len = resolver_win32_srv_query(fulldomain, buf, RESOLVER_BUF_MAX);
@@ -236,9 +267,13 @@ int resolver_srv_lookup(xmpp_ctx_t *ctx,
 
     strophe_free(ctx, buf);
 
-#endif /* HAVE_CARES */
+    if (set != XMPP_DOMAIN_FOUND) {
+        *srv_rr_list = NULL;
+    }
 
-    return set;
+    callback(xsock, domain);
+
+#endif /* HAVE_CARES */
 }
 
 void resolver_srv_free(xmpp_ctx_t *ctx, resolver_srv_rr_t *srv_rr_list)
@@ -478,6 +513,18 @@ static int resolver_raw_srv_lookup_buf(xmpp_ctx_t *ctx,
     return *srv_rr_list != NULL ? XMPP_DOMAIN_FOUND : XMPP_DOMAIN_NOT_FOUND;
 }
 
+/* WARNING this version is blocking */
+void resolver_getaddrinfo(const char *name,
+                          const char *service,
+                          const resolver_addrinfo_hints *hints,
+                          resolver_addrinfo_callback callback,
+                          void *arg)
+{
+    struct addrinfo *result;
+    int rc = getaddrinfo(name, service, hints, &result);
+    callback(arg, rc, 0, result);
+}
+
 #endif /* !HAVE_CARES */
 
 #ifdef HAVE_CARES
@@ -485,12 +532,6 @@ static int resolver_raw_srv_lookup_buf(xmpp_ctx_t *ctx,
  * Resolver implementation using c-ares library.
  ******************************************************************************/
 
-struct resolver_ares_ctx {
-    xmpp_ctx_t *ctx;
-    int result;
-    resolver_srv_rr_t *srv_rr_list;
-};
-
 static int resolver_ares_srv_lookup_buf(xmpp_ctx_t *ctx,
                                         const unsigned char *buf,
                                         size_t len,
@@ -529,53 +570,33 @@ static int resolver_ares_srv_lookup_buf(xmpp_ctx_t *ctx,
 static void ares_srv_lookup_callback(
     void *arg, int status, int timeouts, unsigned char *buf, int len)
 {
-    struct resolver_ares_ctx *actx = arg;
+    struct resolver_ctx *rctx = arg;
 
     (void)timeouts;
 
     if (status != ARES_SUCCESS)
-        actx->result = XMPP_DOMAIN_NOT_FOUND;
+        *rctx->srv_rr_list = NULL;
     else
-        actx->result = resolver_ares_srv_lookup_buf(actx->ctx, buf, len,
-                                                    &actx->srv_rr_list);
+        resolver_ares_srv_lookup_buf(rctx->ctx, buf, len, rctx->srv_rr_list);
+
+    rctx->callback(rctx->xsock, rctx->domain);
+    strophe_free(rctx->ctx, rctx);
 }
 
-static int resolver_ares_srv_lookup(xmpp_ctx_t *ctx,
-                                    const char *fulldomain,
-                                    resolver_srv_rr_t **srv_rr_list)
+static void resolver_ares_srv_lookup(const char *fulldomain,
+                                     struct resolver_ctx *rctx)
 {
-    struct resolver_ares_ctx actx;
-    ares_channel chan;
-    struct timeval tv;
-    struct timeval *tvp;
-    fd_set rfds;
-    fd_set wfds;
-    int nfds;
-    int rc;
-
-    actx.ctx = ctx;
-    actx.result = XMPP_DOMAIN_NOT_FOUND;
-    actx.srv_rr_list = NULL;
-
-    rc = ares_init(&chan);
-    if (rc == ARES_SUCCESS) {
-        ares_query(chan, fulldomain, MESSAGE_C_IN, MESSAGE_T_SRV,
-                   ares_srv_lookup_callback, &actx);
-        while (1) {
-            FD_ZERO(&rfds);
-            FD_ZERO(&wfds);
-            nfds = ares_fds(chan, &rfds, &wfds);
-            if (nfds == 0)
-                break;
-            tvp = ares_timeout(chan, NULL, &tv);
-            select(nfds, &rfds, &wfds, NULL, tvp);
-            ares_process(chan, &rfds, &wfds);
-        }
-        ares_destroy(chan);
-    }
+    ares_query(ares_chan, fulldomain, MESSAGE_C_IN, MESSAGE_T_SRV,
+               ares_srv_lookup_callback, rctx);
+}
 
-    *srv_rr_list = actx.srv_rr_list;
-    return actx.result;
+void resolver_getaddrinfo(const char *name,
+                          const char *service,
+                          const resolver_addrinfo_hints *hints,
+                          resolver_addrinfo_callback callback,
+                          void *arg)
+{
+    ares_getaddrinfo(ares_chan, name, service, hints, callback, arg);
 }
 
 #endif /* HAVE_CARES */
diff --git a/src/resolver.h b/src/resolver.h
index 7c7eb42d..53519dd7 100644
--- a/src/resolver.h
+++ b/src/resolver.h
@@ -20,6 +20,31 @@
 #include "ostypes.h"
 #include "common.h"
 
+#ifdef HAVE_CARES
+#include <ares.h>
+
+extern ares_channel ares_chan;
+#define resolver_freeaddrinfo ares_freeaddrinfo
+typedef struct ares_addrinfo resolver_addrinfo;
+typedef struct ares_addrinfo_node resolver_addrinfo_node;
+typedef struct ares_addrinfo_hints resolver_addrinfo_hints;
+typedef ares_addrinfo_callback resolver_addrinfo_callback;
+#define RESOLVER_SUCCESS ARES_SUCCESS
+#define RESOLVER_ADDRINFO_HEAD(x) ((x)->nodes)
+#else
+#define resolver_freeaddrinfo freeaddrinfo
+typedef struct addrinfo resolver_addrinfo_hints;
+typedef struct addrinfo resolver_addrinfo;
+typedef struct addrinfo resolver_addrinfo_node;
+typedef void (*resolver_addrinfo_callback)(void *arg,
+                                           int status,
+                                           int timeouts,
+                                           resolver_addrinfo *result);
+#define RESOLVER_SUCCESS 0
+#define RESOLVER_ADDRINFO_HEAD(x) x
+typedef struct addrinfo resolver_addrinfo;
+#endif
+
 typedef enum {
     XMPP_DOMAIN_NOT_FOUND,
     XMPP_DOMAIN_FOUND,
@@ -64,14 +89,17 @@ int resolver_srv_lookup_buf(xmpp_ctx_t *ctx,
  *  @param proto protocol of the SRV record
  *  @param domain resolving domain
  *  @param srv_rr_list is the result
- *
- *  @return XMPP_DOMAIN_FOUND on success or XMPP_DOMAIN_NOT_FOUND on fail
+ *  @param callback is called when the resolve is complete
+ *  @param xsock gets passed to the callback
  */
-int resolver_srv_lookup(xmpp_ctx_t *ctx,
-                        const char *service,
-                        const char *proto,
-                        const char *domain,
-                        resolver_srv_rr_t **srv_rr_list);
+void resolver_srv_lookup(xmpp_ctx_t *ctx,
+                         const char *service,
+                         const char *proto,
+                         const char *domain,
+                         resolver_srv_rr_t **srv_rr_list,
+                         void (*callback)(xmpp_sock_t *xsock,
+                                          const char *domain),
+                         xmpp_sock_t *xsock);
 
 /** Release a list returned by resolver_srv_lookup() or
  *  resolver_srv_lookup_buf().
@@ -81,4 +109,19 @@ int resolver_srv_lookup(xmpp_ctx_t *ctx,
  */
 void resolver_srv_free(xmpp_ctx_t *ctx, resolver_srv_rr_t *srv_rr_list);
 
+/** Resolve a DNS name, just like getaddrinfo
+ *  Async safe when using c-ares
+ *
+ *  @param name a DNS name to resolve
+ *  @param service a DNS service
+ *  @param hints options for the resolver
+ *  @param callback is called when the resolve is complete
+ *  @param arg is passed to callback
+ */
+void resolver_getaddrinfo(const char *name,
+                          const char *service,
+                          const resolver_addrinfo_hints *hints,
+                          resolver_addrinfo_callback callback,
+                          void *arg);
+
 #endif /* __LIBSTROPHE_RESOLVER_H__ */
diff --git a/src/sock.c b/src/sock.c
index 90b0431f..d9c03001 100644
--- a/src/sock.c
+++ b/src/sock.c
@@ -53,12 +53,13 @@ const struct conn_interface sock_intf = {
 struct _xmpp_sock_t {
     xmpp_ctx_t *ctx;
     xmpp_conn_t *conn;
-    struct addrinfo *ainfo_list;
-    struct addrinfo *ainfo_cur;
+    resolver_addrinfo *ainfo_list;
+    resolver_addrinfo_node *ainfo_cur;
     resolver_srv_rr_t *srv_rr_list;
     resolver_srv_rr_t *srv_rr_cur;
     const char *host;
     unsigned short port;
+    void (*getaddrinfo_cb)(xmpp_sock_t *xsock);
 };
 
 void sock_initialize(void)
@@ -95,14 +96,43 @@ static int _in_progress(int error)
 #endif
 }
 
-static void sock_getaddrinfo(xmpp_sock_t *xsock)
+void sock_getaddrinfo_cb(void *arg,
+                         int status,
+                         int timeouts,
+                         resolver_addrinfo *result)
+{
+    xmpp_sock_t *xsock = arg;
+    (void)status;
+    (void)timeouts;
+
+    if (status == RESOLVER_SUCCESS) {
+        xsock->ainfo_list = result;
+    } else {
+        strophe_debug(xsock->ctx, "sock",
+                      "resolver_getaddrinfo() failed with %d (%d)", status,
+                      timeouts);
+        xsock->ainfo_list = NULL;
+    }
+
+    xsock->ainfo_cur = RESOLVER_ADDRINFO_HEAD(xsock->ainfo_list);
+    if (xsock->srv_rr_cur)
+        xsock->srv_rr_cur = xsock->srv_rr_cur->next;
+
+    if (xsock->getaddrinfo_cb) {
+        void (*callback)(xmpp_sock_t *sock) = xsock->getaddrinfo_cb;
+        xsock->getaddrinfo_cb = NULL;
+        callback(xsock);
+    }
+}
+
+static void sock_getaddrinfo(xmpp_sock_t *xsock,
+                             void (*callback)(xmpp_sock_t *xsock))
 {
     char service[6];
-    struct addrinfo hints;
-    int rc;
+    resolver_addrinfo_hints hints;
 
     if (xsock->ainfo_list) {
-        freeaddrinfo(xsock->ainfo_list);
+        resolver_freeaddrinfo(xsock->ainfo_list);
         xsock->ainfo_list = NULL;
     }
 
@@ -112,7 +142,7 @@ static void sock_getaddrinfo(xmpp_sock_t *xsock)
         xsock->port = xsock->srv_rr_cur->port;
 
         strophe_snprintf(service, 6, "%u", xsock->srv_rr_cur->port);
-        memset(&hints, 0, sizeof(struct addrinfo));
+        memset(&hints, 0, sizeof(hints));
         hints.ai_family = AF_UNSPEC;
 #ifdef AI_ADDRCONFIG
         hints.ai_flags = AI_ADDRCONFIG;
@@ -120,58 +150,56 @@ static void sock_getaddrinfo(xmpp_sock_t *xsock)
         hints.ai_protocol = IPPROTO_TCP;
         hints.ai_socktype = SOCK_STREAM;
 
-        rc = getaddrinfo(xsock->srv_rr_cur->target, service, &hints,
-                         &xsock->ainfo_list);
-        if (rc != 0) {
-            strophe_debug(xsock->ctx, "sock",
-                          "getaddrinfo() failed with %s (%d)", gai_strerror(rc),
-                          rc);
-            xsock->ainfo_list = NULL;
-        }
+        xsock->getaddrinfo_cb = callback;
+        resolver_getaddrinfo(xsock->srv_rr_cur->target, service, &hints,
+                             &sock_getaddrinfo_cb, xsock);
+    } else {
+        callback(xsock);
     }
+}
 
-    xsock->ainfo_cur = xsock->ainfo_list;
+static void sock_new_after_dns(xmpp_sock_t *xsock, const char *domain)
+{
+    if (!xsock->srv_rr_list) {
+        strophe_debug(xsock->ctx, "sock",
+                      "SRV lookup failed, connecting via domain.");
+        xsock->srv_rr_list =
+            resolver_srv_rr_new(xsock->ctx, domain, xsock->port, 0, 0);
+    }
+    xsock->srv_rr_cur = xsock->srv_rr_list;
+
+    sock_getaddrinfo(xsock, &sock_connect);
 }
 
-xmpp_sock_t *sock_new(xmpp_conn_t *conn,
-                      const char *domain,
-                      const char *host,
-                      unsigned short port)
+int sock_new(xmpp_conn_t *conn,
+             const char *domain,
+             const char *host,
+             unsigned short port)
 {
     xmpp_ctx_t *ctx = conn->ctx;
     xmpp_sock_t *xsock;
-    int found = XMPP_DOMAIN_NOT_FOUND;
 
     xsock = strophe_alloc(ctx, sizeof(*xsock));
     if (!xsock) {
-        return NULL;
+        conn->xsock = NULL;
+        return XMPP_EMEM;
     }
 
     xsock->ctx = ctx;
     xsock->conn = conn;
     xsock->host = NULL;
-    xsock->port = 0;
-
-    if (!host) {
-        found = resolver_srv_lookup(ctx, "xmpp-client", "tcp", domain,
-                                    &xsock->srv_rr_list);
-        if (XMPP_DOMAIN_NOT_FOUND == found)
-            strophe_debug(ctx, "sock",
-                          "SRV lookup failed, connecting via domain.");
-    }
-    if (XMPP_DOMAIN_NOT_FOUND == found) {
-        /* Resolution failed or the host is provided explicitly. */
-        xsock->srv_rr_list =
-            resolver_srv_rr_new(ctx, host ? host : domain, port, 0, 0);
-    }
-    xsock->srv_rr_cur = xsock->srv_rr_list;
-
+    xsock->port = port;
     xsock->ainfo_list = NULL;
-    sock_getaddrinfo(xsock);
-    if (xsock->srv_rr_cur)
-        xsock->srv_rr_cur = xsock->srv_rr_cur->next;
+    conn->xsock = xsock;
+
+    if (host) {
+        xsock->srv_rr_list = resolver_srv_rr_new(ctx, host, port, 0, 0);
+    } else {
+        resolver_srv_lookup(ctx, "xmpp-client", "tcp", domain,
+                            &xsock->srv_rr_list, &sock_new_after_dns, xsock);
+    }
 
-    return xsock;
+    return 0;
 }
 
 void sock_free(xmpp_sock_t *xsock)
@@ -180,7 +208,7 @@ void sock_free(xmpp_sock_t *xsock)
         return;
 
     if (xsock->ainfo_list)
-        freeaddrinfo(xsock->ainfo_list);
+        resolver_freeaddrinfo(xsock->ainfo_list);
     if (xsock->srv_rr_list)
         resolver_srv_free(xsock->ctx, xsock->srv_rr_list);
     strophe_free(xsock->ctx, xsock);
@@ -204,22 +232,26 @@ static const char *_sockaddr2str(struct sockaddr *sa, char *buf, size_t buflen)
     return buf;
 }
 
-sock_t sock_connect(xmpp_sock_t *xsock)
+void sock_connect(xmpp_sock_t *xsock)
 {
-    struct addrinfo *ainfo;
-    sock_t sock;
+    xmpp_conn_t *conn = xsock->conn;
+    resolver_addrinfo_node *ainfo;
     int rc;
     char buf[64];
+    sock_t sock = INVALID_SOCKET;
 
+    conn->sock = INVALID_SOCKET;
     do {
-        if (!xsock->ainfo_cur) {
-            sock_getaddrinfo(xsock);
-            if (xsock->srv_rr_cur)
-                xsock->srv_rr_cur = xsock->srv_rr_cur->next;
+        if (!xsock->ainfo_cur && !xsock->srv_rr_cur) {
+            /* We tried all available addresses. */
+            conn->error = XMPP_EINT;
+            conn_disconnect(conn);
+            return;
         }
+
         if (!xsock->ainfo_cur) {
-            /* We tried all available addresses. */
-            return INVALID_SOCKET;
+            sock_getaddrinfo(xsock, &sock_connect);
+            return;
         }
 
         ainfo = xsock->ainfo_cur;
@@ -256,7 +288,7 @@ sock_t sock_connect(xmpp_sock_t *xsock)
         xsock->ainfo_cur = xsock->ainfo_cur->ai_next;
     } while (sock == INVALID_SOCKET);
 
-    return sock;
+    conn->sock = sock;
 }
 
 int sock_set_keepalive(sock_t sock,
diff --git a/src/sock.h b/src/sock.h
index 096ad9e7..00f60063 100644
--- a/src/sock.h
+++ b/src/sock.h
@@ -39,12 +39,12 @@ void sock_shutdown(void);
 
 int sock_error(struct conn_interface *intf);
 
-xmpp_sock_t *sock_new(xmpp_conn_t *conn,
-                      const char *domain,
-                      const char *host,
-                      unsigned short port);
+int sock_new(xmpp_conn_t *conn,
+             const char *domain,
+             const char *host,
+             unsigned short port);
 void sock_free(xmpp_sock_t *xsock);
-sock_t sock_connect(xmpp_sock_t *xsock);
+void sock_connect(xmpp_sock_t *xsock);
 int sock_close(sock_t sock);
 
 int sock_set_blocking(sock_t sock);