WIP examples: PLAIN auth mechanism over raw connection

2017-07-15 21:38:46 +03:00
36 changed files with 887 additions and 1856 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -34,7 +34,7 @@ examples/active
 examples/basic
 examples/bot
 examples/component
-examples/register
+examples/ext_auth
 examples/roster
 examples/uuid
 examples/vcard
@@ -55,9 +55,8 @@ tests/test_sasl
 tests/test_scram
 tests/test_sha1
 tests/test_snprintf
-tests/test_sock
-tests/test_stanza
 tests/test_string
+tests/test_sock
 m4/
 libstrophe.project
 libs/
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,15 +1,15 @@
 language: c
 install:
    - sudo apt-get update
-    - sudo apt-get -y install libtool pkg-config libexpat1-dev libxml2-dev libssl-dev libc-ares-dev
+    - sudo apt-get -y install libtool pkg-config libexpat1-dev libxml2-dev libssl-dev check
 before_script:
    - ./bootstrap.sh
 script:
-    - ./configure ${CONFIGURE_OPT} CFLAGS="-Werror" && make && make check
+    - ./configure ${CONFIGURE_OPT} && make && make check-TESTS
 env:
    - CONFIGURE_OPT="--without-libxml2"
    - CONFIGURE_OPT="--with-libxml2"
-    - CONFIGURE_OPT="--disable-tls"
-    - CONFIGURE_OPT="--enable-cares"
+    - CONFIGURE_OPT="--disable-tls --without-libxml2"
+    - CONFIGURE_OPT="--disable-tls --with-libxml2"
 matrix:
    fast_finish: true
--- a/26
+++ b/26
@@ -1,24 +1,3 @@
-0.10.0
-	- c-ares support
-	- LibreSSL support
-	- examples/register implements XEP-0077
-	- New API:
-		- xmpp_stanza_get_child_by_name_and_ns()
-		- xmpp_conn_is_connecting()
-		- xmpp_conn_is_connected()
-		- xmpp_conn_is_disconnected()
-		- xmpp_stanza_add_child_ex()
-		- xmpp_stanza_get_context()
-
-0.9.3
-	- PLAIN mechanism is used only when no other mechanisms are supported
-	- Legacy authentication is disabled by default, can be enabled with
-	  connection flag XMPP_CONN_FLAG_LEGACY_AUTH
-	- Session is not established if it is optional
-	- Fixed a bug causing a reused connection not to cleanup properly
-	- Improved debug logging in OpenSSL module
-	- Few memory leaks fixed
-
 0.9.2
 	- OpenSSL tls module verifies certificate by default. Set flag
 	  XMPP_CONN_FLAG_TRUST_TLS to ignore result of the verification
@@ -29,12 +8,7 @@
 	  userdata
 	- System handlers are deleted on xmpp_conn_t reconnection. Old system
 	  handlers could cause problems
-	- Default timeout for xmpp_run() is increased from 1 millisecond to 1
-	  second in order to reduce CPU consumption
-	- Reduced memory usage in expat module
 	- New functions:
-		- xmpp_error_new()
-		- xmpp_send_error()
 		- xmpp_ctx_set_timeout()
 		- xmpp_sha1_digest()

--- a/Makefile.am
+++ b/Makefile.am
@@ -1,6 +1,7 @@
 AUTOMAKE_OPTIONS = subdir-objects

 ACLOCAL_AMFLAGS = -I m4
+AM_CFLAGS = -g -Wall

 PARSER_CFLAGS=@PARSER_CFLAGS@
 PARSER_LIBS=@PARSER_LIBS@
@@ -8,17 +9,15 @@ PARSER_LIBS=@PARSER_LIBS@
 SSL_CFLAGS = @openssl_CFLAGS@
 SSL_LIBS = @openssl_LIBS@

-RESOLV_CFLAGS = @RESOLV_CFLAGS@
 RESOLV_LIBS = @RESOLV_LIBS@

-WARNING_FLAGS = @WARNING_FLAGS@
-STROPHE_FLAGS = -I$(top_srcdir) $(WARNING_FLAGS)
+STROPHE_FLAGS = -I$(top_srcdir) -Wall -Wextra -Werror -Wno-unused-parameter
 STROPHE_LIBS = libstrophe.la

 ## Main build targets
 lib_LTLIBRARIES = libstrophe.la

-libstrophe_la_CFLAGS = $(SSL_CFLAGS) $(STROPHE_FLAGS) $(PARSER_CFLAGS) $(RESOLV_CFLAGS)
+libstrophe_la_CFLAGS = $(SSL_CFLAGS) $(STROPHE_FLAGS) $(PARSER_CFLAGS)
 libstrophe_la_LDFLAGS = $(SSL_LIBS) $(PARSER_LIBS) $(RESOLV_LIBS) -no-undefined
 # Export only public API
 libstrophe_la_LDFLAGS += -export-symbols-regex '^xmpp_'
@@ -99,10 +98,10 @@ noinst_PROGRAMS = \
 	examples/basic \
 	examples/bot \
 	examples/component \
+	examples/ext_auth \
 	examples/roster \
 	examples/uuid \
-	examples/vcard \
-	examples/register
+	examples/vcard

 examples_active_SOURCES = examples/active.c
 examples_active_CFLAGS = $(STROPHE_FLAGS)
@@ -116,6 +115,9 @@ examples_bot_LDADD = $(STROPHE_LIBS)
 examples_component_SOURCES = examples/component.c
 examples_component_CFLAGS = $(STROPHE_FLAGS)
 examples_component_LDADD = $(STROPHE_LIBS)
+examples_ext_auth_SOURCES = examples/ext_auth.c
+examples_ext_auth_CFLAGS = $(STROPHE_FLAGS)
+examples_ext_auth_LDADD = $(STROPHE_LIBS)
 examples_roster_SOURCES = examples/roster.c
 examples_roster_CFLAGS = $(STROPHE_FLAGS)
 examples_roster_LDADD = $(STROPHE_LIBS)
@@ -125,9 +127,6 @@ examples_uuid_LDADD = $(STROPHE_LIBS)
 examples_vcard_SOURCES = examples/vcard.c
 examples_vcard_CFLAGS = $(STROPHE_FLAGS)
 examples_vcard_LDADD = $(STROPHE_LIBS)
-examples_register_SOURCES = examples/register.c
-examples_register_CFLAGS = $(STROPHE_FLAGS)
-examples_register_LDADD = $(STROPHE_LIBS)


 ## Tests
@@ -143,7 +142,6 @@ TESTS = \
 	tests/test_jid \
 	tests/test_snprintf \
 	tests/test_string \
-	tests/test_stanza \
 	tests/test_resolver

 check_PROGRAMS = $(TESTS)
@@ -198,8 +196,3 @@ tests_test_string_SOURCES = tests/test_string.c tests/test.h
 tests_test_string_CFLAGS = $(STROPHE_FLAGS) -I$(top_srcdir)/src
 tests_test_string_LDADD = $(STROPHE_LIBS)
 tests_test_string_LDFLAGS = -static
-
-tests_test_stanza_SOURCES = tests/test_stanza.c
-tests_test_stanza_CFLAGS = $(STROPHE_FLAGS)
-tests_test_stanza_LDADD = $(STROPHE_LIBS)
-tests_test_stanza_LDFLAGS = -static
--- a/configure.ac
+++ b/configure.ac
@@ -1,4 +1,4 @@
-AC_INIT([libstrophe], [0.9.3], [jack@metajack.im])
+AC_INIT([libstrophe], [0.9.1], [jack@metajack.im])
 AC_CONFIG_MACRO_DIR([m4])
 AM_INIT_AUTOMAKE([foreign])
 LT_INIT([dlopen])
@@ -15,24 +15,12 @@ AS_CASE([$host_os],
    [*nto*|*qnx*], [PLATFORM="qnx"],
    [*solaris*],   [PLATFORM="solaris"],
    [*android*],   [PLATFORM="android"],
-    [*haiku*],     [PLATFORM="haiku"],
                   [PLATFORM="nix"])

-WARNING_FLAGS="-Wall"
-
-AS_CASE([$PLATFORM],
-    [haiku],   [],
-               [WARNING_FLAGS="$WARNING_FLAGS -Wextra -Wno-unused-parameter"])
-
 AC_ARG_WITH([libxml2],
    [AS_HELP_STRING([--with-libxml2], [use libxml2 for XML parsing, expat is the default])])
 AC_ARG_ENABLE([tls],
    [AS_HELP_STRING([--disable-tls], [disable TLS support])])
-AC_ARG_ENABLE([cares],
-    [AS_HELP_STRING([--enable-cares], [use c-ares for DNS resolution])])
-
-AC_SEARCH_LIBS([socket], [network socket])
-#AC_CHECK_FUNCS([snprintf vsnprintf])

 if test "x$enable_tls" != xno; then
    PKG_CHECK_MODULES([openssl], [openssl],
@@ -74,7 +62,7 @@ if test "x$with_libxml2" != xno -a "x$with_parser" = x; then
                [
                    with_parser="libxml2"
                    libxml2_CFLAGS="-I${includedir}/libxml2"
-                    libxml2_LIBS="-lxml2 -lm"
+                    libxml2_LIBS="-lxml2"
                    PC_LIBS="${libxml2_LIBS} ${PC_LIBS}"
                    PC_CFLAGS="${libxml2_CFLAGS} ${PC_CFLAGS}"
                ])
@@ -94,24 +82,13 @@ fi

 AC_MSG_NOTICE([libstrophe will use the $with_parser XML parser])

-if test "x$enable_cares" = xyes; then
-    PKG_CHECK_MODULES([libcares], [libcares >= 1.7.0],
-        [
-            PC_REQUIRES="libcares ${PC_REQUIRES}"
-            RESOLV_CFLAGS=$libcares_CFLAGS
-            RESOLV_LIBS=$libcares_LIBS
-            AC_DEFINE([HAVE_CARES])
-        ],
-        [AC_MSG_ERROR([libcares not found])])
-        # TODO: if pkg-config doesn't find, check the library manually
-else
+AC_SEARCH_LIBS([socket], [socket])

 AS_CASE([$PLATFORM],
    [bsd],     [RESOLV_LIBS=""],
    [qnx],     [RESOLV_LIBS="-lsocket"],
    [solaris], [RESOLV_LIBS="-lresolv -lsocket -lnsl"],
    [android], [RESOLV_LIBS=""],
-    [haiku],   [RESOLV_LIBS="-lnetwork"],
               [RESOLV_LIBS="-lresolv"])

 LIBS_TMP="${LIBS}"
@@ -133,8 +110,6 @@ AC_LINK_IFELSE([AC_LANG_SOURCE([
 LIBS="${LIBS_TMP}"
 PC_LIBS="${RESOLV_LIBS} ${PC_LIBS}"

-fi
-
 m4_ifdef([PKG_INSTALLDIR], [PKG_INSTALLDIR],
    [AC_ARG_WITH([pkgconfigdir],
        [AS_HELP_STRING([--with-pkgconfigdir],
@@ -151,8 +126,6 @@ AC_SUBST([PC_LIBS], [${PC_LIBS}])

 AC_SUBST(PARSER_CFLAGS)
 AC_SUBST(PARSER_LIBS)
-AC_SUBST(RESOLV_CFLAGS)
 AC_SUBST(RESOLV_LIBS)
-AC_SUBST(WARNING_FLAGS)
 AC_CONFIG_FILES([Makefile libstrophe.pc])
 AC_OUTPUT
--- a/examples/ext_auth.c
+++ b/examples/ext_auth.c
@@ -0,0 +1,290 @@
+/* ext_auth.c
+ * strophe XMPP client library -- PLAIN mechanism example with a raw connection
+ *
+ * Copyright (C) 2016 Dmitry Podgorny <pasis.ua@gmail.com>
+ *
+ *  This software is provided AS-IS with no warranty, either express
+ *  or implied.
+ *
+ *  This program is dual licensed under the MIT and GPLv3 licenses.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <strophe.h>
+
+typedef struct {
+    xmpp_ctx_t *ctx;
+    const char *jid;
+    const char *pass;
+    char *domain;
+    int authenticated;
+} xmpp_auth_t;
+
+#define FEATURES_TIMEOUT 5000 /* 5 seconds */
+
+static int _handle_error(xmpp_conn_t * const conn,
+                         xmpp_stanza_t * const stanza,
+                         void * const userdata)
+{
+    fprintf(stderr, "DEBUG: received stream error\n");
+    xmpp_disconnect(conn);
+
+    return 0;
+}
+
+static int _handle_proceedtls_default(xmpp_conn_t * const conn,
+                                      xmpp_stanza_t * const stanza,
+                                      void * const userdata)
+{
+    xmpp_auth_t *auth = (xmpp_auth_t *)userdata;
+    const char *name = xmpp_stanza_get_name(stanza);
+
+    (void)auth;
+    if (strcmp(name, "proceed") == 0) {
+        if (xmpp_conn_tls_start(conn) == 0) {
+            xmpp_handler_delete(conn, _handle_error);
+            xmpp_conn_open_stream_default(conn);
+        } else {
+            /* failed tls spoils the connection, so disconnect */
+            xmpp_disconnect(conn);
+        }
+    } else
+        xmpp_disconnect(conn);
+
+    return 0;
+}
+
+static int _plain_mechanim_exists(xmpp_ctx_t *ctx, xmpp_stanza_t *features)
+{
+    xmpp_stanza_t *mechanisms;
+    xmpp_stanza_t *child;
+    char *text;
+    int found = 0;
+
+    mechanisms = xmpp_stanza_get_child_by_name(features, "mechanisms");
+    child = mechanisms ? xmpp_stanza_get_children(mechanisms) : NULL;
+    while (!found && mechanisms && child) {
+        /* TODO xmpp_stanza_get_name(child) is "mechanism" */
+        text = xmpp_stanza_get_text(child);
+        found = text && strcmp(text, "PLAIN") == 0;
+        xmpp_free(ctx, text);
+        child = xmpp_stanza_get_next(child);
+    }
+    return found;
+}
+
+static char *_plain_mechanism_authdata(xmpp_auth_t *auth)
+{
+    char *node, *b64;
+    unsigned char *msg;
+    size_t node_len, pass_len;
+
+    node = xmpp_jid_node(auth->ctx, auth->jid);
+    node_len = strlen(node);
+    pass_len = strlen(auth->pass);
+    msg = malloc(node_len + pass_len + 2);
+    msg[0] = '\0';
+    memcpy(msg + 1, node, node_len);
+    msg[node_len + 1] = '\0';
+    memcpy(msg + node_len + 2, auth->pass, pass_len);
+    b64 = xmpp_base64_encode(auth->ctx, msg, node_len + pass_len + 2);
+
+    free(msg);
+    xmpp_free(auth->ctx, node);
+
+    return b64;
+}
+
+static int _plain_mechanism_handle_result(xmpp_conn_t * const conn,
+                                          xmpp_stanza_t * const stanza,
+                                          void * const userdata)
+{
+    xmpp_auth_t *auth = (xmpp_auth_t *)userdata;
+    const char *name;
+
+    name = xmpp_stanza_get_name(stanza);
+
+    if (strcmp(name, "success") == 0) {
+        /* SASL PLAIN auth successful, we need to restart the stream */
+        fprintf(stderr, "DEBUG: SASL PLAIN auth successful\n");
+        auth->authenticated = 1;
+        xmpp_handler_delete(conn, _handle_error);
+        xmpp_conn_open_stream_default(conn);
+    } else {
+        fprintf(stderr, "DEBUG: SASL authentication failed: %s\n", name);
+        xmpp_disconnect(conn);
+    }
+    return 0;
+}
+
+static int _handle_missing_features(xmpp_conn_t * const conn,
+                                    void * const userdata)
+{
+    fprintf(stderr, "DEBUG: timeout\n");
+    xmpp_disconnect(conn);
+
+    return 0;
+}
+
+static int _handle_features(xmpp_conn_t * const conn,
+                            xmpp_stanza_t * const stanza,
+                            void * const userdata)
+{
+    xmpp_auth_t *auth = (xmpp_auth_t *)userdata;
+    xmpp_ctx_t *ctx = auth->ctx;
+    xmpp_stanza_t *plain, *child;
+    char *str;
+
+    xmpp_timed_handler_delete(conn, _handle_missing_features);
+
+    if (auth->authenticated) {
+        /* after successful SASL authentication */
+        /* TODO bind, session and we'are done */
+        xmpp_disconnect(conn); /* XXX */
+        return 0;
+    }
+
+    /* secure connection if possible */
+    child = xmpp_stanza_get_child_by_name(stanza, "starttls");
+    if (child && (strcmp(xmpp_stanza_get_ns(child), XMPP_NS_TLS) == 0)) {
+        child = xmpp_stanza_new(ctx);
+        xmpp_stanza_set_name(child, "starttls");
+        xmpp_stanza_set_ns(child, XMPP_NS_TLS);
+        xmpp_handler_add(conn, _handle_proceedtls_default,
+                         XMPP_NS_TLS, NULL, NULL, userdata);
+        xmpp_send(conn, child);
+        xmpp_stanza_release(child);
+        return 0;
+    }
+
+    /* check if PLAIN mechanism is supported */
+    if (!_plain_mechanim_exists(ctx, stanza)) {
+        fprintf(stderr, "DEBUG: PLAIN mechanism is NOT supported\n");
+        xmpp_disconnect(conn);
+        return 0;
+    }
+
+    /* perform authentication */
+    plain = xmpp_stanza_new(ctx);
+    xmpp_stanza_set_name(plain, "auth");
+    xmpp_stanza_set_ns(plain, XMPP_NS_SASL);
+    xmpp_stanza_set_attribute(plain, "mechanism", "PLAIN");
+    str = _plain_mechanism_authdata(auth);
+    child = xmpp_stanza_new(ctx);
+    xmpp_stanza_set_text(child, str);
+    xmpp_free(ctx, str);
+    xmpp_stanza_add_child(plain, child);
+    xmpp_stanza_release(child);
+
+    xmpp_handler_add(conn, _plain_mechanism_handle_result,
+                     XMPP_NS_SASL, NULL, NULL, userdata);
+    xmpp_send(conn, plain);
+    xmpp_stanza_release(plain);
+
+    return 0;
+}
+
+static void conn_handler(xmpp_conn_t * const conn,
+                         const xmpp_conn_event_t status,
+                         const int error,
+                         xmpp_stream_error_t * const stream_error,
+                         void * const userdata)
+{
+    xmpp_auth_t *auth = (xmpp_auth_t *)userdata;
+    xmpp_ctx_t *ctx = auth->ctx;
+    int secured;
+
+    if (status == XMPP_CONN_RAW_CONNECT) {
+        fprintf(stderr, "DEBUG: raw connection established\n");
+        xmpp_conn_open_stream_default(conn);
+    } else if (status == XMPP_CONN_CONNECT) {
+        fprintf(stderr, "DEBUG: stream opened\n");
+        secured = xmpp_conn_is_secured(conn);
+        fprintf(stderr, "DEBUG: connection is %s.\n",
+                secured ? "secured" : "NOT secured");
+
+        /* setup handler for stream:error */
+        xmpp_handler_add(conn, _handle_error, XMPP_NS_STREAMS,
+                         "error", NULL, NULL);
+
+        /* setup handlers for incoming <stream:features> */
+        xmpp_handler_add(conn, _handle_features, XMPP_NS_STREAMS,
+                         "features", NULL, auth);
+        xmpp_timed_handler_add(conn, _handle_missing_features,
+                               FEATURES_TIMEOUT, NULL);
+    } else {
+        fprintf(stderr, "DEBUG: disconnected\n");
+        xmpp_stop(ctx);
+    }
+}
+
+static xmpp_auth_t *xmpp_auth_new(void)
+{
+    xmpp_auth_t *auth;
+
+    auth = malloc(sizeof(*auth));
+    if (auth != NULL) {
+        memset(auth, 0, sizeof(*auth));
+    }
+    return auth;
+}
+
+static void xmpp_auth_release(xmpp_auth_t *auth)
+{
+    free(auth);
+}
+
+int main(int argc, char **argv)
+{
+    xmpp_ctx_t *ctx;
+    xmpp_conn_t *conn;
+    xmpp_log_t *log;
+    xmpp_auth_t *auth;
+    const char *jid;
+    const char *pass;
+    const char *host = NULL;
+
+    if (argc < 3 || argc > 4) {
+        fprintf(stderr, "Usage: %s <jid> <pass> [<host>]\n", argv[0]);
+        return 1;
+    }
+
+    jid = argv[1];
+    pass = argv[2];
+    if (argc > 3)
+        host = argv[3];
+
+    /*
+     * Note, this example doesn't handle errors. Applications should check
+     * return values of non-void functions.
+     */
+
+    xmpp_initialize();
+    log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG);
+    ctx = xmpp_ctx_new(NULL, log);
+    conn = xmpp_conn_new(ctx);
+
+    xmpp_conn_set_jid(conn, jid);
+
+    /* private data */
+    auth = xmpp_auth_new();
+    auth->ctx = ctx;
+    auth->jid = jid;
+    auth->pass = pass;
+    auth->domain = xmpp_jid_domain(ctx, jid);
+
+    xmpp_connect_raw(conn, host, 0, conn_handler, auth);
+    xmpp_run(ctx);
+
+    /* release private data */
+    xmpp_auth_release(auth);
+
+    xmpp_conn_release(conn);
+    xmpp_ctx_free(ctx);
+    xmpp_shutdown();
+
+    return 0;
+}
--- a/examples/register.c
+++ b/examples/register.c
@@ -1,357 +0,0 @@
-/* register.c
- * strophe XMPP client library -- In-band registration (XEP-0077)
- *
- * Copyright (C) 2020 Dmitry Podgorny <pasis.ua@gmail.com>
- *
- *  This software is provided AS-IS with no warranty, either express
- *  or implied.
- *
- *  This program is dual licensed under the MIT and GPLv3 licenses.
- */
-
-/*
- * This example uses a "raw" connection to establish connection to a server
- * without account. Then it queries server to register new account according
- * to XEP-0077.
- *
- * How to use it. After the application connects and receives instructions
- * from the server, user will be prompted to type information such as
- * username, password, etc. Press enter without typing if you want to skip
- * a field and not to send it to the server.
- *
- * Notice, the example doesn't implement forms. Therefore, it won't work
- * in complicated scenarios.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <strophe.h>
-
-typedef struct {
-    xmpp_ctx_t *ctx;
-    const char *jid;
-} xmpp_reg_t;
-
-#define FEATURES_TIMEOUT 5000 /* 5 seconds */
-
-static void iq_reg_send_form(xmpp_reg_t *reg,
-                             xmpp_conn_t *conn,
-                             xmpp_stanza_t *stanza)
-{
-    xmpp_ctx_t *ctx = reg->ctx;
-    xmpp_stanza_t *query;
-    xmpp_stanza_t *next;
-    xmpp_stanza_t *elem;
-    xmpp_stanza_t *text;
-    xmpp_stanza_t *iq;
-    const char *name;
-    ssize_t rc;
-    size_t size;
-    char *s;
-
-    query = xmpp_stanza_get_child_by_name(stanza, "query");
-    if (!query) {
-        xmpp_disconnect(conn);
-        return;
-    }
-
-    next = xmpp_stanza_get_children(query);
-    query = xmpp_stanza_new(ctx);
-    xmpp_stanza_set_name(query, "query");
-    xmpp_stanza_set_ns(query, XMPP_NS_REGISTER);
-    while (next) {
-        name = xmpp_stanza_get_name(next);
-        if (name && strcmp(name, "instructions") == 0) {
-            s = xmpp_stanza_get_text(next);
-            printf("instructions: %s\n", s);
-            xmpp_free(ctx, s);
-        } else {
-            printf("%s: ", name);
-            s = NULL;
-            size = 0;
-            rc = getline(&s, &size, stdin);
-            if (rc > 0 && s[rc - 1] == '\n')
-                s[rc - 1] = '\0';
-            if (rc > 0 && strlen(s) > 0) {
-                elem = xmpp_stanza_new(ctx);
-                text = xmpp_stanza_new(ctx);
-                xmpp_stanza_set_text(text, s);
-                xmpp_stanza_set_name(elem, name);
-                xmpp_stanza_add_child(elem, text);
-                xmpp_stanza_add_child(query, elem);
-                xmpp_stanza_release(text);
-                xmpp_stanza_release(elem);
-            }
-            free(s);
-        }
-        next = xmpp_stanza_get_next(next);
-    }
-
-    if (xmpp_stanza_get_children(query) == NULL) {
-        fprintf(stderr, "DEBUG: nothing to send\n");
-        xmpp_disconnect(conn);
-    } else {
-        iq = xmpp_iq_new(ctx, "set", "reg2");
-        xmpp_stanza_add_child(iq, query);
-        xmpp_stanza_release(query);
-        xmpp_send(conn, iq);
-        xmpp_stanza_release(iq);
-    }
-}
-
-static int iq_reg2_cb(xmpp_conn_t * const conn,
-                      xmpp_stanza_t * const stanza,
-                      void * const userdata)
-{
-    const char *type;
-
-    type = xmpp_stanza_get_type(stanza);
-    if (!type || strcmp(type, "error") == 0) {
-        fprintf(stderr, "DEBUG: error during registration\n");
-        goto quit;
-    }
-
-    if (strcmp(type, "result") != 0) {
-        fprintf(stderr, "DEBUG: expected type 'result', but got %s\n", type);
-        goto quit;
-    }
-
-    fprintf(stderr, "DEBUG: successful registration\n");
-
-quit:
-    xmpp_disconnect(conn);
-
-    return 0;
-}
-
-static int iq_reg_cb(xmpp_conn_t * const conn,
-                     xmpp_stanza_t * const stanza,
-                     void * const userdata)
-{
-    xmpp_reg_t *reg = (xmpp_reg_t *)userdata;
-    xmpp_stanza_t *registered = NULL;
-    xmpp_stanza_t *query;
-    const char *type;
-
-    type = xmpp_stanza_get_type(stanza);
-    if (!type || strcmp(type, "error") == 0) {
-        fprintf(stderr, "DEBUG: error during registration\n");
-        xmpp_disconnect(conn);
-        goto quit;
-    }
-
-    if (strcmp(type, "result") != 0) {
-        fprintf(stderr, "DEBUG: expected type 'result', but got %s\n", type);
-        xmpp_disconnect(conn);
-        goto quit;
-    }
-
-    query = xmpp_stanza_get_child_by_name(stanza, "query");
-    if (query)
-        registered = xmpp_stanza_get_child_by_name(query, "registered");
-    if (registered != NULL) {
-        fprintf(stderr, "DEBUG: already registered\n");
-        xmpp_disconnect(conn);
-        goto quit;
-    }
-    xmpp_id_handler_add(conn, iq_reg2_cb, "reg2", reg);
-    iq_reg_send_form(reg, conn, stanza);
-
-quit:
-    return 0;
-}
-
-static int _handle_error(xmpp_conn_t * const conn,
-                         xmpp_stanza_t * const stanza,
-                         void * const userdata)
-{
-    fprintf(stderr, "DEBUG: received stream error\n");
-    xmpp_disconnect(conn);
-
-    return 0;
-}
-
-static int _handle_proceedtls_default(xmpp_conn_t * const conn,
-                                      xmpp_stanza_t * const stanza,
-                                      void * const userdata)
-{
-    const char *name = xmpp_stanza_get_name(stanza);
-
-    if (strcmp(name, "proceed") == 0) {
-        fprintf(stderr, "DEBUG: proceeding with TLS\n");
-        if (xmpp_conn_tls_start(conn) == 0) {
-            xmpp_handler_delete(conn, _handle_error);
-            xmpp_conn_open_stream_default(conn);
-        } else {
-            fprintf(stderr, "DEBUG: TLS failed\n");
-            /* failed tls spoils the connection, so disconnect */
-            xmpp_disconnect(conn);
-        }
-    }
-    return 0;
-}
-
-static int _handle_missing_features(xmpp_conn_t * const conn,
-                                    void * const userdata)
-{
-    fprintf(stderr, "DEBUG: timeout\n");
-    xmpp_disconnect(conn);
-
-    return 0;
-}
-
-static int _handle_features(xmpp_conn_t * const conn,
-                            xmpp_stanza_t * const stanza,
-                            void * const userdata)
-{
-    xmpp_reg_t *reg = (xmpp_reg_t *)userdata;
-    xmpp_ctx_t *ctx = reg->ctx;
-    xmpp_stanza_t *child;
-    xmpp_stanza_t *iq;
-    char *domain;
-
-    xmpp_timed_handler_delete(conn, _handle_missing_features);
-
-    /* secure connection if possible */
-    child = xmpp_stanza_get_child_by_name(stanza, "starttls");
-    if (child && (strcmp(xmpp_stanza_get_ns(child), XMPP_NS_TLS) == 0)) {
-        fprintf(stderr, "DEBUG: server supports TLS, try to establish\n");
-        child = xmpp_stanza_new(ctx);
-        xmpp_stanza_set_name(child, "starttls");
-        xmpp_stanza_set_ns(child, XMPP_NS_TLS);
-        xmpp_handler_add(conn, _handle_proceedtls_default,
-                         XMPP_NS_TLS, NULL, NULL, NULL);
-        xmpp_send(conn, child);
-        xmpp_stanza_release(child);
-        return 0;
-    }
-
-    /* check whether server supports in-band registration */
-    child = xmpp_stanza_get_child_by_name(stanza, "register");
-    if (child && strcmp(xmpp_stanza_get_ns(child), XMPP_NS_REGISTER) == 0) {
-        fprintf(stderr, "DEBUG: server doesn't support in-band registration\n");
-        xmpp_disconnect(conn);
-        return 0;
-    }
-
-    fprintf(stderr, "DEBUG: server supports in-band registration\n");
-    domain = xmpp_jid_domain(ctx, reg->jid);
-    iq = xmpp_iq_new(ctx, "get", "reg1");
-    xmpp_stanza_set_to(iq, domain);
-    child = xmpp_stanza_new(ctx);
-    xmpp_stanza_set_name(child, "query");
-    xmpp_stanza_set_ns(child, XMPP_NS_REGISTER);
-    xmpp_stanza_add_child(iq, child);
-
-    xmpp_handler_add(conn, iq_reg_cb, XMPP_NS_REGISTER, "iq", NULL, reg);
-    xmpp_send(conn, iq);
-
-    xmpp_free(ctx, domain);
-    xmpp_stanza_release(child);
-    xmpp_stanza_release(iq);
-
-    return 0;
-}
-
-static void conn_handler(xmpp_conn_t * const conn,
-                         const xmpp_conn_event_t status,
-                         const int error,
-                         xmpp_stream_error_t * const stream_error,
-                         void * const userdata)
-{
-    xmpp_reg_t *reg = (xmpp_reg_t *)userdata;
-    int secured;
-
-    if (status == XMPP_CONN_RAW_CONNECT) {
-        fprintf(stderr, "DEBUG: raw connection established\n");
-        xmpp_conn_open_stream_default(conn);
-    } else if (status == XMPP_CONN_CONNECT) {
-        fprintf(stderr, "DEBUG: stream opened\n");
-        secured = xmpp_conn_is_secured(conn);
-        fprintf(stderr, "DEBUG: connection is %s.\n",
-                secured ? "secured" : "NOT secured");
-
-        /* setup handler for stream:error */
-        xmpp_handler_add(conn, _handle_error, XMPP_NS_STREAMS,
-                         "error", NULL, NULL);
-
-        /* setup handlers for incoming <stream:features> */
-        xmpp_handler_add(conn, _handle_features, XMPP_NS_STREAMS,
-                         "features", NULL, reg);
-        xmpp_timed_handler_add(conn, _handle_missing_features,
-                               FEATURES_TIMEOUT, NULL);
-    } else {
-        fprintf(stderr, "DEBUG: disconnected\n");
-        xmpp_stop(reg->ctx);
-    }
-}
-
-xmpp_reg_t *xmpp_reg_new(void)
-{
-    xmpp_reg_t *reg;
-
-    reg = malloc(sizeof(*reg));
-    if (reg != NULL) {
-        memset(reg, 0, sizeof(*reg));
-    }
-    return reg;
-}
-
-void xmpp_reg_release(xmpp_reg_t *reg)
-{
-    free(reg);
-}
-
-int main(int argc, char **argv)
-{
-    xmpp_ctx_t *ctx;
-    xmpp_conn_t *conn;
-    xmpp_log_t *log;
-    xmpp_reg_t *reg;
-    const char *jid;
-    const char *host = NULL;
-    char *domain;
-
-    if (argc < 2 || argc > 3) {
-        fprintf(stderr, "Usage: %s <jid> [<host>]\n", argv[0]);
-        return 1;
-    }
-
-    jid = argv[1];
-    if (argc > 2)
-        host = argv[2];
-
-    /*
-     * Note, this example doesn't handle errors. Applications should check
-     * return values of non-void functions.
-     */
-
-    xmpp_initialize();
-    log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG);
-    ctx = xmpp_ctx_new(NULL, log);
-    conn = xmpp_conn_new(ctx);
-
-    /* jid can be a jid or domain for "raw" connection */
-    domain = xmpp_jid_domain(ctx, jid);
-    xmpp_conn_set_jid(conn, domain);
-    xmpp_free(ctx, domain);
-
-    /* private data */
-    reg = xmpp_reg_new();
-    reg->ctx = ctx;
-    reg->jid = jid;
-
-    xmpp_connect_raw(conn, host, 0, conn_handler, reg);
-    xmpp_run(ctx);
-
-    /* release private data */
-    xmpp_reg_release(reg);
-
-    xmpp_conn_release(conn);
-    xmpp_ctx_free(ctx);
-    xmpp_shutdown();
-
-    return 0;
-}
--- a/jni/Android.mk
+++ b/jni/Android.mk
@@ -62,7 +62,7 @@ include $(BUILD_STATIC_LIBRARY)

 include $(CLEAR_VARS)
 LOCAL_MODULE := libexpat
-LOCAL_CFLAGS := -DHAVE_MEMMOVE -DXML_DEV_URANDOM
+LOCAL_CFLAGS := -DHAVE_MEMMOVE
 #LOCAL_C_INCLUDES := \
 #	$(LOCAL_PATH)/expat

--- a/jni/Application.mk
+++ b/jni/Application.mk
@@ -1,2 +1,2 @@
-APP_ABI := armeabi-v7a arm64-v8a
+APP_ABI := armeabi armeabi-v7a mips x86
 APP_PLATFORM := android-19
--- a/src/auth.c
+++ b/src/auth.c
@@ -24,7 +24,7 @@
 #include "rand.h"

 #ifdef _MSC_VER
-#define strcasecmp _stricmp
+#define strcasecmp stricmp
 #endif

 /* TODO: these should configurable at runtime on a per connection basis  */
@@ -61,7 +61,6 @@
 #endif

 static void _auth(xmpp_conn_t * const conn);
-static void _auth_legacy(xmpp_conn_t *conn);
 static void _handle_open_sasl(xmpp_conn_t * const conn);
 static void _handle_open_tls(xmpp_conn_t * const conn);

@@ -70,6 +69,11 @@ static int _handle_component_hs_response(xmpp_conn_t * const conn,
            xmpp_stanza_t * const stanza,
            void * const userdata);

+static int _handle_missing_legacy(xmpp_conn_t * const conn,
+				  void * const userdata);
+static int _handle_legacy(xmpp_conn_t * const conn,
+			  xmpp_stanza_t * const stanza,
+			  void * const userdata);
 static int _handle_features_sasl(xmpp_conn_t * const conn,
 				 xmpp_stanza_t * const stanza,
 				 void * const userdata);
@@ -99,9 +103,6 @@ static int _handle_session(xmpp_conn_t * const conn,
 			   void * const userdata);
 static int _handle_missing_session(xmpp_conn_t * const conn,
 				   void * const userdata);
-static int _handle_sm(xmpp_conn_t * const conn,
-                      xmpp_stanza_t * const stanza,
-                      void * const userdata);
 static int _handle_missing_handshake(xmpp_conn_t * const conn,
                                     void * const userdata);

@@ -218,7 +219,6 @@ static int _handle_features(xmpp_conn_t * const conn,
 			    void * const userdata)
 {
    xmpp_stanza_t *child, *mech;
-    const char *ns;
    char *text;

    /* remove the handler that detects missing stream:features */
@@ -228,10 +228,8 @@ static int _handle_features(xmpp_conn_t * const conn,
    if (!conn->secured) {
        if (!conn->tls_disabled) {
            child = xmpp_stanza_get_child_by_name(stanza, "starttls");
-            if (child) {
-                ns = xmpp_stanza_get_ns(child);
-                conn->tls_support = ns != NULL && strcmp(ns, XMPP_NS_TLS) == 0;
-            }
+            if (child && (strcmp(xmpp_stanza_get_ns(child), XMPP_NS_TLS) == 0))
+                conn->tls_support = 1;
        } else {
            conn->tls_support = 0;
        }
@@ -239,15 +237,11 @@ static int _handle_features(xmpp_conn_t * const conn,

    /* check for SASL */
    child = xmpp_stanza_get_child_by_name(stanza, "mechanisms");
-    ns = child ? xmpp_stanza_get_ns(child) : NULL;
-    if (child && ns && strcmp(ns, XMPP_NS_SASL) == 0) {
+    if (child && (strcmp(xmpp_stanza_get_ns(child), XMPP_NS_SASL) == 0)) {
 	for (mech = xmpp_stanza_get_children(child); mech;
 	     mech = xmpp_stanza_get_next(mech)) {
 	    if (xmpp_stanza_get_name(mech) && strcmp(xmpp_stanza_get_name(mech), "mechanism") == 0) {
 		text = xmpp_stanza_get_text(mech);
-                if (text == NULL)
-                    continue;
-
 		if (strcasecmp(text, "PLAIN") == 0)
 		    conn->sasl_support |= SASL_MASK_PLAIN;
 		else if (strcasecmp(text, "DIGEST-MD5") == 0)
@@ -262,10 +256,6 @@ static int _handle_features(xmpp_conn_t * const conn,
 	}
    }

-    /* Disable PLAIN when other secure mechanisms are supported */
-    if (conn->sasl_support & ~(SASL_MASK_PLAIN | SASL_MASK_ANONYMOUS))
-        conn->sasl_support &= ~SASL_MASK_PLAIN;
-
    _auth(conn);

    return 0;
@@ -560,11 +550,9 @@ static xmpp_stanza_t *_make_sasl_auth(xmpp_conn_t * const conn,
 */
 static void _auth(xmpp_conn_t * const conn)
 {
-    xmpp_stanza_t *auth;
-    xmpp_stanza_t *authdata;
-    char *authid;
+    xmpp_stanza_t *auth, *authdata, *query, *child, *iq;
+    char *str, *authid;
    char *scram_init;
-    char *str;
    int anonjid;

    /* if there is no node in conn->jid, we assume anonymous connect */
@@ -731,12 +719,105 @@ static void _auth(xmpp_conn_t * const conn)

 	/* SASL PLAIN was tried */
 	conn->sasl_support &= ~SASL_MASK_PLAIN;
-    } else if (conn->type == XMPP_CLIENT && conn->auth_legacy_enabled) {
-        /* legacy client authentication */
-        _auth_legacy(conn);
-    } else {
-        xmpp_error(conn->ctx, "auth", "Cannot authenticate with known methods");
-        xmpp_disconnect(conn);
+    } else if (conn->type == XMPP_CLIENT) {
+	/* legacy client authentication */
+
+	iq = xmpp_iq_new(conn->ctx, "set", "_xmpp_auth1");
+	if (!iq) {
+	    disconnect_mem_error(conn);
+	    return;
+	}
+
+	query = xmpp_stanza_new(conn->ctx);
+	if (!query) {
+	    xmpp_stanza_release(iq);
+	    disconnect_mem_error(conn);
+	    return;
+	}
+	xmpp_stanza_set_name(query, "query");
+	xmpp_stanza_set_ns(query, XMPP_NS_AUTH);
+	xmpp_stanza_add_child(iq, query);
+	xmpp_stanza_release(query);
+
+	child = xmpp_stanza_new(conn->ctx);
+	if (!child) {
+	    xmpp_stanza_release(iq);
+	    disconnect_mem_error(conn);
+	    return;
+	}
+	xmpp_stanza_set_name(child, "username");
+	xmpp_stanza_add_child(query, child);
+	xmpp_stanza_release(child);
+
+	authdata = xmpp_stanza_new(conn->ctx);
+	if (!authdata) {
+	    xmpp_stanza_release(iq);
+	    disconnect_mem_error(conn);
+	    return;
+	}
+	str = xmpp_jid_node(conn->ctx, conn->jid);
+	xmpp_stanza_set_text(authdata, str);
+	xmpp_free(conn->ctx, str);
+	xmpp_stanza_add_child(child, authdata);
+	xmpp_stanza_release(authdata);
+
+	child = xmpp_stanza_new(conn->ctx);
+	if (!child) {
+	    xmpp_stanza_release(iq);
+	    disconnect_mem_error(conn);
+	    return;
+	}
+	xmpp_stanza_set_name(child, "password");
+	xmpp_stanza_add_child(query, child);
+	xmpp_stanza_release(child);
+
+	authdata = xmpp_stanza_new(conn->ctx);
+	if (!authdata) {
+	    xmpp_stanza_release(iq);
+	    disconnect_mem_error(conn);
+	    return;
+	}
+	xmpp_stanza_set_text(authdata, conn->pass);
+	xmpp_stanza_add_child(child, authdata);
+	xmpp_stanza_release(authdata);
+
+	child = xmpp_stanza_new(conn->ctx);
+	if (!child) {
+	    xmpp_stanza_release(iq);
+	    disconnect_mem_error(conn);
+	    return;
+	}
+	xmpp_stanza_set_name(child, "resource");
+	xmpp_stanza_add_child(query, child);
+	xmpp_stanza_release(child);
+
+	authdata = xmpp_stanza_new(conn->ctx);
+	if (!authdata) {
+	    xmpp_stanza_release(iq);
+	    disconnect_mem_error(conn);
+	    return;
+	}
+	str = xmpp_jid_resource(conn->ctx, conn->jid);
+	if (str) {
+	    xmpp_stanza_set_text(authdata, str);
+	    xmpp_free(conn->ctx, str);
+	} else {
+	    xmpp_stanza_release(authdata);
+	    xmpp_stanza_release(iq);
+	    xmpp_error(conn->ctx, "auth",
+		       "Cannot authenticate without resource");
+	    xmpp_disconnect(conn);
+	    return;
+	}
+	xmpp_stanza_add_child(child, authdata);
+	xmpp_stanza_release(authdata);
+
+	handler_add_id(conn, _handle_legacy, "_xmpp_auth1", NULL);
+	handler_add_timed(conn, _handle_missing_legacy,
+			  LEGACY_TIMEOUT, NULL);
+
+	xmpp_send(conn, iq);
+	xmpp_stanza_release(iq);
    }
 }

@@ -790,8 +871,7 @@ static int _handle_features_sasl(xmpp_conn_t * const conn,
 				 xmpp_stanza_t * const stanza,
 				 void * const userdata)
 {
-    xmpp_stanza_t *bind, *session, *iq, *res, *text, *opt;
-    const char *ns;
+    xmpp_stanza_t *bind, *session, *iq, *res, *text;
    char *resource;

    /* remove missing features handler */
@@ -800,27 +880,16 @@ static int _handle_features_sasl(xmpp_conn_t * const conn,
    /* we are expecting <bind/> and <session/> since this is a
       XMPP style connection */

-    /* check whether resource binding is required */
    bind = xmpp_stanza_get_child_by_name(stanza, "bind");
-    if (bind) {
-        ns = xmpp_stanza_get_ns(bind);
-	conn->bind_required = ns != NULL && strcmp(ns, XMPP_NS_BIND) == 0;
+    if (bind && strcmp(xmpp_stanza_get_ns(bind), XMPP_NS_BIND) == 0) {
+	/* resource binding is required */
+	conn->bind_required = 1;
    }

-    /* check whether session establishment is required */
    session = xmpp_stanza_get_child_by_name(stanza, "session");
-    if (session) {
-        ns = xmpp_stanza_get_ns(session);
-        opt = xmpp_stanza_get_child_by_name(session, "optional");
-	if (!opt)
-            conn->session_required = ns != NULL &&
-                                     strcmp(ns, XMPP_NS_SESSION) == 0;
-    }
-
-    opt = xmpp_stanza_get_child_by_ns(stanza, XMPP_NS_SM);
-    if (opt && strcmp(xmpp_stanza_get_name(opt), "sm") == 0) {
-        /* stream management supported */
-        conn->sm_support = 1;
+    if (session && strcmp(xmpp_stanza_get_ns(session), XMPP_NS_SESSION) == 0) {
+	/* session establishment required */
+	conn->session_required = 1;
    }

    /* if bind is required, go ahead and start it */
@@ -911,7 +980,7 @@ static int _handle_bind(xmpp_conn_t * const conn,
 			void * const userdata)
 {
    const char *type;
-    xmpp_stanza_t *iq, *enable, *session, *binding, *jid_stanza;
+    xmpp_stanza_t *iq, *session;

    /* delete missing bind handler */
    xmpp_timed_handler_delete(conn, _handle_missing_bind);
@@ -922,11 +991,12 @@ static int _handle_bind(xmpp_conn_t * const conn,
 	xmpp_error(conn->ctx, "xmpp", "Binding failed.");
 	xmpp_disconnect(conn);
    } else if (type && strcmp(type, "result") == 0) {
-        binding = xmpp_stanza_get_child_by_name(stanza, "bind");
+        xmpp_stanza_t *binding = xmpp_stanza_get_child_by_name(stanza, "bind");
 	xmpp_debug(conn->ctx, "xmpp", "Bind successful.");

        if (binding) {
-            jid_stanza = xmpp_stanza_get_child_by_name(binding, "jid");
+            xmpp_stanza_t *jid_stanza = xmpp_stanza_get_child_by_name(binding,
+                                                                      "jid");
            if (jid_stanza) {
                conn->bound_jid = xmpp_stanza_get_text(jid_stanza);
            }
@@ -962,23 +1032,7 @@ static int _handle_bind(xmpp_conn_t * const conn,
 	    /* send session establishment request */
 	    xmpp_send(conn, iq);
 	    xmpp_stanza_release(iq);
-	}
-
-        if (conn->sm_support) {
-            enable = xmpp_stanza_new(conn->ctx);
-            if (!enable) {
-                disconnect_mem_error(conn);
-                return 0;
-            }
-            xmpp_stanza_set_name(enable, "enable");
-            xmpp_stanza_set_ns(enable, XMPP_NS_SM);
-            handler_add(conn, _handle_sm, XMPP_NS_SM, NULL, NULL, NULL);
-            xmpp_send(conn, enable);
-            xmpp_stanza_release(enable);
-            conn->sm_sent_nr = 0;
-        }
-
-	if (!conn->session_required) {
+	} else {
 	    conn->authenticated = 1;

 	    /* call connection handler */
@@ -1038,32 +1092,6 @@ static int _handle_missing_session(xmpp_conn_t * const conn,
    return 0;
 }

-static int _handle_missing_legacy(xmpp_conn_t * const conn,
-				  void * const userdata)
-{
-    xmpp_error(conn->ctx, "xmpp", "Server did not reply to legacy "\
-	       "authentication request.");
-    xmpp_disconnect(conn);
-    return 0;
-}
-
-static int _handle_sm(xmpp_conn_t * const conn,
-                      xmpp_stanza_t * const stanza,
-                      void * const userdata)
-{
-    const char *name;
-
-    name = xmpp_stanza_get_name(stanza);
-    if (name && strcmp(name, "enabled") == 0) {
-        conn->sm_enabled = 1;
-        conn->sm_handled_nr = 0;
-    } else {
-        conn->sm_enabled = 0;
-        xmpp_warn(conn->ctx, "auth", "Stream management failed.");
-    }
-    return 0;
-}
-
 static int _handle_legacy(xmpp_conn_t * const conn,
 			  xmpp_stanza_t * const stanza,
 			  void * const userdata)
@@ -1100,97 +1128,13 @@ static int _handle_legacy(xmpp_conn_t * const conn,
    return 0;
 }

-static void _auth_legacy(xmpp_conn_t *conn)
+static int _handle_missing_legacy(xmpp_conn_t * const conn,
+				  void * const userdata)
 {
-    xmpp_stanza_t *iq;
-    xmpp_stanza_t *authdata;
-    xmpp_stanza_t *query;
-    xmpp_stanza_t *child;
-    char *str;
-
-    xmpp_debug(conn->ctx, "auth", "Legacy authentication request");
-
-    iq = xmpp_iq_new(conn->ctx, "set", "_xmpp_auth1");
-    if (!iq)
-        goto err;
-
-    query = xmpp_stanza_new(conn->ctx);
-    if (!query)
-        goto err_free;
-    xmpp_stanza_set_name(query, "query");
-    xmpp_stanza_set_ns(query, XMPP_NS_AUTH);
-    xmpp_stanza_add_child(iq, query);
-    xmpp_stanza_release(query);
-
-    child = xmpp_stanza_new(conn->ctx);
-    if (!child)
-        goto err_free;
-    xmpp_stanza_set_name(child, "username");
-    xmpp_stanza_add_child(query, child);
-    xmpp_stanza_release(child);
-
-    authdata = xmpp_stanza_new(conn->ctx);
-    if (!authdata)
-        goto err_free;
-    str = xmpp_jid_node(conn->ctx, conn->jid);
-    if (!str) {
-        xmpp_stanza_release(authdata);
-        goto err_free;
-    }
-    xmpp_stanza_set_text(authdata, str);
-    xmpp_free(conn->ctx, str);
-    xmpp_stanza_add_child(child, authdata);
-    xmpp_stanza_release(authdata);
-
-    child = xmpp_stanza_new(conn->ctx);
-    if (!child)
-        goto err_free;
-    xmpp_stanza_set_name(child, "password");
-    xmpp_stanza_add_child(query, child);
-    xmpp_stanza_release(child);
-
-    authdata = xmpp_stanza_new(conn->ctx);
-    if (!authdata)
-        goto err_free;
-    xmpp_stanza_set_text(authdata, conn->pass);
-    xmpp_stanza_add_child(child, authdata);
-    xmpp_stanza_release(authdata);
-
-    child = xmpp_stanza_new(conn->ctx);
-    if (!child)
-        goto err_free;
-    xmpp_stanza_set_name(child, "resource");
-    xmpp_stanza_add_child(query, child);
-    xmpp_stanza_release(child);
-
-    authdata = xmpp_stanza_new(conn->ctx);
-    if (!authdata)
-        goto err_free;
-    str = xmpp_jid_resource(conn->ctx, conn->jid);
-    if (str) {
-        xmpp_stanza_set_text(authdata, str);
-        xmpp_free(conn->ctx, str);
-    } else {
-        xmpp_stanza_release(authdata);
-        xmpp_stanza_release(iq);
-        xmpp_error(conn->ctx, "auth", "Cannot authenticate without resource");
-        xmpp_disconnect(conn);
-        return;
-    }
-    xmpp_stanza_add_child(child, authdata);
-    xmpp_stanza_release(authdata);
-
-    handler_add_id(conn, _handle_legacy, "_xmpp_auth1", NULL);
-    handler_add_timed(conn, _handle_missing_legacy, LEGACY_TIMEOUT, NULL);
-
-    xmpp_send(conn, iq);
-    xmpp_stanza_release(iq);
-    return;
-
-err_free:
-    xmpp_stanza_release(iq);
-err:
-    disconnect_mem_error(conn);
+    xmpp_error(conn->ctx, "xmpp", "Server did not reply to legacy "\
+	       "authentication request.");
+    xmpp_disconnect(conn);
+    return 0;
 }

 void auth_handle_component_open(xmpp_conn_t * const conn)
--- a/src/common.h
+++ b/src/common.h
@@ -130,7 +130,7 @@ struct _xmpp_handlist_t {
            char *name;
            char *type;
        };
-    } u;
+    };
 };

 #define MAX_DOMAIN_LEN 256
@@ -172,16 +172,11 @@ struct _xmpp_conn_t {
    int tls_failed; /* set when tls fails, so we don't try again */
    int sasl_support; /* if true, field is a bitfield of supported 
                         mechanisms */
-    int auth_legacy_enabled;
    int secured; /* set when stream is secured with TLS */

    /* if server returns <bind/> or <session/> we must do them */
    int bind_required;
    int session_required;
-    int sm_support;
-    int sm_enabled;
-    uint32_t sm_handled_nr;
-    uint32_t sm_sent_nr;

    char *lang;
    char *domain;
--- a/src/conn.c
+++ b/src/conn.c
@@ -62,8 +62,6 @@ static void _handle_stream_end(char *name,
                               void * const userdata);
 static void _handle_stream_stanza(xmpp_stanza_t *stanza,
                                  void * const userdata);
-static void _conn_sm_handle_stanza(xmpp_conn_t * const conn,
-                                   xmpp_stanza_t *stanza);
 static unsigned short _conn_default_port(xmpp_conn_t * const conn,
                                         xmpp_conn_type_t type);
 static void _conn_reset(xmpp_conn_t * const conn);
@@ -75,15 +73,6 @@ static int _conn_connect(xmpp_conn_t * const conn,
                         xmpp_conn_handler callback,
                         void * const userdata);

-void xmpp_send_error(xmpp_conn_t * const conn, xmpp_error_type_t const type, char * const text)
-{
-    xmpp_stanza_t *error = xmpp_error_new(conn->ctx, type, text);
-
-    xmpp_send(conn, error);
-
-    xmpp_stanza_release(error);
-}
-
 /** Create a new Strophe connection object.
 *
 *  @param ctx a Strophe context object
@@ -142,15 +131,10 @@ xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t * const ctx)
        conn->tls_trust = 0;
        conn->tls_failed = 0;
        conn->sasl_support = 0;
-        conn->auth_legacy_enabled = 0;
        conn->secured = 0;

        conn->bind_required = 0;
        conn->session_required = 0;
-        conn->sm_support = 0;
-        conn->sm_enabled = 0;
-        conn->sm_handled_nr = 0;
-        conn->sm_sent_nr = 0;

        conn->parser = parser_new(conn->ctx,
                                  _handle_stream_start,
@@ -260,12 +244,6 @@ int xmpp_conn_release(xmpp_conn_t * const conn)
    else {
        ctx = conn->ctx;

-        if (conn->state == XMPP_STATE_CONNECTING ||
-            conn->state == XMPP_STATE_CONNECTED)
-        {
-            conn_disconnect(conn);
-        }
-
        /* remove connection from context's connlist */
        if (ctx->connlist->conn == conn) {
            item = ctx->connlist;
@@ -311,7 +289,7 @@ int xmpp_conn_release(xmpp_conn_t * const conn)
            while (hlitem) {
                thli = hlitem;
                hlitem = hlitem->next;
-                xmpp_free(conn->ctx, thli->u.id);
+                xmpp_free(conn->ctx, thli->id);
                xmpp_free(conn->ctx, thli);
            }
        }
@@ -323,9 +301,9 @@ int xmpp_conn_release(xmpp_conn_t * const conn)
            thli = hlitem;
            hlitem = hlitem->next;

-            if (thli->u.ns) xmpp_free(ctx, thli->u.ns);
-            if (thli->u.name) xmpp_free(ctx, thli->u.name);
-            if (thli->u.type) xmpp_free(ctx, thli->u.type);
+            if (thli->ns) xmpp_free(ctx, thli->ns);
+            if (thli->name) xmpp_free(ctx, thli->name);
+            if (thli->type) xmpp_free(ctx, thli->type);
            xmpp_free(ctx, thli);
        }

@@ -726,7 +704,7 @@ void conn_parser_reset(xmpp_conn_t * const conn)
 /** Initiate termination of the connection to the XMPP server.
 *  This function starts the disconnection sequence by sending
 *  </stream:stream> to the XMPP server.  This function will do nothing
- *  if the connection state is different from CONNECTING or CONNECTED.
+ *  if the connection state is CONNECTING or CONNECTED.
 *
 *  @param conn a Strophe connection object
 *
@@ -768,10 +746,10 @@ void xmpp_send_raw_string(xmpp_conn_t * const conn,
    char *bigbuf;

    va_start(ap, fmt);
-    len = xmpp_vsnprintf(buf, sizeof(buf), fmt, ap);
+    len = xmpp_vsnprintf(buf, 1024, fmt, ap);
    va_end(ap);

-    if (len >= sizeof(buf)) {
+    if (len >= 1024) {
        /* we need more space for this data, so we allocate a big
         * enough buffer and print to that */
        len++; /* account for trailing \0 */
@@ -792,6 +770,7 @@ void xmpp_send_raw_string(xmpp_conn_t * const conn,
        xmpp_free(conn->ctx, bigbuf);
    } else {
        xmpp_debug(conn->ctx, "conn", "SENT: %s", buf);
+
        xmpp_send_raw(conn, buf, len);
    }
 }
@@ -856,9 +835,10 @@ void xmpp_send(xmpp_conn_t * const conn,
 {
    char *buf;
    size_t len;
+    int ret;

    if (conn->state == XMPP_STATE_CONNECTED) {
-        if (xmpp_stanza_to_text(stanza, &buf, &len) == 0) {
+        if ((ret = xmpp_stanza_to_text(stanza, &buf, &len)) == 0) {
            xmpp_send_raw(conn, buf, len);
            xmpp_debug(conn->ctx, "conn", "SENT: %s", buf);
            xmpp_free(conn->ctx, buf);
@@ -933,8 +913,7 @@ long xmpp_conn_get_flags(const xmpp_conn_t * const conn)
    flags = XMPP_CONN_FLAG_DISABLE_TLS * conn->tls_disabled |
            XMPP_CONN_FLAG_MANDATORY_TLS * conn->tls_mandatory |
            XMPP_CONN_FLAG_LEGACY_SSL * conn->tls_legacy_ssl |
-            XMPP_CONN_FLAG_TRUST_TLS * conn->tls_trust |
-            XMPP_CONN_FLAG_LEGACY_AUTH * conn->auth_legacy_enabled;;
+            XMPP_CONN_FLAG_TRUST_TLS * conn->tls_trust;

    return flags;
 }
@@ -952,7 +931,6 @@ long xmpp_conn_get_flags(const xmpp_conn_t * const conn)
 *    - XMPP_CONN_FLAG_MANDATORY_TLS
 *    - XMPP_CONN_FLAG_LEGACY_SSL
 *    - XMPP_CONN_FLAG_TRUST_TLS
- *    - XMPP_CONN_FLAG_LEGACY_AUTH
 *
 *  @param conn a Strophe connection object
 *  @param flags ORed connection flags
@@ -979,7 +957,6 @@ int xmpp_conn_set_flags(xmpp_conn_t * const conn, long flags)
    conn->tls_mandatory = (flags & XMPP_CONN_FLAG_MANDATORY_TLS) ? 1 : 0;
    conn->tls_legacy_ssl = (flags & XMPP_CONN_FLAG_LEGACY_SSL) ? 1 : 0;
    conn->tls_trust = (flags & XMPP_CONN_FLAG_TRUST_TLS) ? 1 : 0;
-    conn->auth_legacy_enabled = (flags & XMPP_CONN_FLAG_LEGACY_AUTH) ? 1 : 0;

    return 0;
 }
@@ -1014,37 +991,6 @@ int xmpp_conn_is_secured(xmpp_conn_t * const conn)
    return conn->secured && !conn->tls_failed && conn->tls != NULL ? 1 : 0;
 }

-/**
- *  @return TRUE if connection is in connecting state and FALSE otherwise
- *
- *  @ingroup Connections
- */
-int xmpp_conn_is_connecting(xmpp_conn_t * const conn)
-{
-    return conn->state == XMPP_STATE_CONNECTING ? 1 : 0;
-}
-
-/**
- *  @return TRUE if connection is in connected state and FALSE otherwise
- *
- *  @ingroup Connections
- */
-int xmpp_conn_is_connected(xmpp_conn_t * const conn)
-{
-    return conn->state == XMPP_STATE_CONNECTED ? 1 : 0;
-}
-
-/**
- *  @return TRUE if connection is in disconnected state and FALSE otherwise
- *
- *  @ingroup Connections
- */
-int xmpp_conn_is_disconnected(xmpp_conn_t * const conn)
-{
-    return conn->state == XMPP_STATE_DISCONNECTED ? 1 : 0;
-}
-
-
 /* timed handler for cleanup if normal disconnect procedure takes too long */
 static int _disconnect_cleanup(xmpp_conn_t * const conn,
                               void * const userdata)
@@ -1222,36 +1168,6 @@ static void _handle_stream_stanza(xmpp_stanza_t *stanza,
    }

    handler_fire_stanza(conn, stanza);
-    if (conn->sm_enabled)
-        _conn_sm_handle_stanza(conn, stanza);
-}
-
-/* XEP-0198 stream management */
-static void _conn_sm_handle_stanza(xmpp_conn_t * const conn,
-                                   xmpp_stanza_t *stanza)
-{
-    xmpp_stanza_t *a;
-    const char *name;
-    const char *ns;
-    char h[11];
-
-    ns = xmpp_stanza_get_ns(stanza);
-    if (ns && strcmp(ns, XMPP_NS_SM) != 0)
-        ++conn->sm_handled_nr;
-    else {
-        name = xmpp_stanza_get_name(stanza);
-        if (name && strcmp(name, "r") == 0) {
-            a = xmpp_stanza_new(conn->ctx);
-            if (!a)
-                return; /* XXX */
-            xmpp_stanza_set_name(a, "a");
-            xmpp_stanza_set_ns(a, XMPP_NS_SM);
-            xmpp_snprintf(h, sizeof(h), "%u", conn->sm_handled_nr);
-            xmpp_stanza_set_attribute(a, "h", h);
-            xmpp_send(conn, a);
-            xmpp_stanza_release(a);
-        }
-    }
 }

 static unsigned short _conn_default_port(xmpp_conn_t * const conn,
@@ -1286,9 +1202,6 @@ static void _conn_reset(xmpp_conn_t * const conn)
        xmpp_free(ctx, tsq->data);
        xmpp_free(ctx, tsq);
    }
-    conn->send_queue_head = NULL;
-    conn->send_queue_tail = NULL;
-    conn->send_queue_len = 0;

    if (conn->stream_error) {
        xmpp_stanza_release(conn->stream_error->stanza);
@@ -1310,8 +1223,6 @@ static void _conn_reset(xmpp_conn_t * const conn)
    conn->error = 0;

    conn->tls_support = 0;
-    conn->sm_support = 0;
-    conn->sm_enabled = 0;
    conn->bind_required = 0;
    conn->session_required = 0;

--- a/src/crypto.c
+++ b/src/crypto.c
@@ -61,7 +61,7 @@ static char *digest_to_string_alloc(xmpp_ctx_t *ctx, const uint8_t *digest)
    return s;
 }

-/** Compute SHA1 message digest.
+/** Compute SHA1 message digest
 *  Returns an allocated string which represents SHA1 message digest in
 *  hexadecimal notation. The string must be freed with xmpp_free().
 *
@@ -81,7 +81,7 @@ char *xmpp_sha1(xmpp_ctx_t *ctx, const unsigned char *data, size_t len)
    return digest_to_string_alloc(ctx, digest);
 }

-/** Compute SHA1 message digest.
+/** Compute SHA1 message digest
 *  Stores digest in user's buffer which must be at least XMPP_SHA1_DIGEST_SIZE
 *  bytes long.
 *
@@ -97,7 +97,7 @@ void xmpp_sha1_digest(const unsigned char *data, size_t len,
    crypto_SHA1((const uint8_t *)data, len, digest);
 }

-/** Create new SHA1 object.
+/** Create new SHA1 object
 *  SHA1 object is used to compute SHA1 digest of a buffer that is split
 *  in multiple chunks or provided in stream mode. A single buffer can be
 *  processed by short functions xmpp_sha1() and xmpp_sha1_digest().
@@ -111,7 +111,7 @@ void xmpp_sha1_digest(const unsigned char *data, size_t len,
 *      xmpp_sha1_free(sha1);
 *  @endcode
 *
- *  @param ctx a Strophe context object
+ *  @param ctx a Strophe context onject
 *
 *  @return new SHA1 object
 *
@@ -130,7 +130,7 @@ xmpp_sha1_t *xmpp_sha1_new(xmpp_ctx_t *ctx)
    return sha1;
 }

-/** Destroy SHA1 object.
+/** Destroy SHA1 object
 *
 *  @param sha1 a SHA1 object
 *
@@ -141,7 +141,7 @@ void xmpp_sha1_free(xmpp_sha1_t *sha1)
    xmpp_free(sha1->xmpp_ctx, sha1);
 }

-/** Update SHA1 context with the next portion of data.
+/** Update SHA1 context with the next portion of data
 *  Can be called repeatedly.
 *
 *  @param sha1 a SHA1 object
@@ -155,7 +155,7 @@ void xmpp_sha1_update(xmpp_sha1_t *sha1, const unsigned char *data, size_t len)
    crypto_SHA1_Update(&sha1->ctx, data, len);
 }

-/** Finish SHA1 computation.
+/** Finish SHA1 computation
 *  Don't call xmpp_sha1_update() after this function. Retrieve resulting
 *  message digest with xmpp_sha1_to_string() or xmpp_sha1_to_digest().
 *
@@ -168,7 +168,7 @@ void xmpp_sha1_final(xmpp_sha1_t *sha1)
    crypto_SHA1_Final(&sha1->ctx, sha1->digest);
 }

-/** Return message digest rendered as a string.
+/** Return message digest rendered as a string
 *  Stores the string to a user's buffer and returns the buffer. Call this
 *  function after xmpp_sha1_final().
 *
@@ -185,7 +185,7 @@ char *xmpp_sha1_to_string(xmpp_sha1_t *sha1, char *s, size_t slen)
    return digest_to_string(sha1->digest, s, slen);
 }

-/** Return message digest rendered as a string.
+/** Return message digest rendered as a string
 *  Returns an allocated string. Free the string using the Strophe context
 *  which is passed to xmpp_sha1_new(). Call this function after
 *  xmpp_sha1_final().
@@ -201,7 +201,7 @@ char *xmpp_sha1_to_string_alloc(xmpp_sha1_t *sha1)
    return digest_to_string_alloc(sha1->xmpp_ctx, sha1->digest);
 }

-/** Stores message digest to a user's buffer.
+/** Stores message digest to a user's buffer
 *
 *  @param sha1 a SHA1 object
 *  @param digest output buffer of XMPP_SHA1_DIGEST_SIZE bytes
@@ -419,7 +419,7 @@ _base64_error:
    *outlen = 0;
 }

-/** Base64 encoding routine.
+/** Base64 encoding routine
 *  Returns an allocated string which must be freed with xmpp_free().
 *
 *  @param ctx a Strophe context
@@ -435,7 +435,7 @@ char *xmpp_base64_encode(xmpp_ctx_t *ctx, const unsigned char *data, size_t len)
    return base64_encode(ctx, data, len);
 }

-/** Base64 decoding routine.
+/** Base64 decoding routine
 *  Returns an allocated string which must be freed with xmpp_free(). User
 *  calls this function when the result must be a string. When decoded buffer
 *  contains '\0' NULL is returned.
@@ -471,7 +471,7 @@ char *xmpp_base64_decode_str(xmpp_ctx_t *ctx, const char *base64, size_t len)
    return (char *)buf;
 }

-/** Base64 decoding routine.
+/** Base64 decoding routine
 *  Returns an allocated buffer which must be freed with xmpp_free().
 *
 *  @param ctx a Strophe context
--- a/src/ctx.c
+++ b/src/ctx.c
@@ -47,11 +47,10 @@

 #include "strophe.h"
 #include "common.h"
-#include "resolver.h"
 #include "util.h"

 /* Workaround for visual studio without va_copy support. */
-#if defined(_MSC_VER) && _MSC_VER < 1800 || defined(__HAIKU__)
+#if defined(_MSC_VER) && _MSC_VER < 1800
 #define va_copy(d,s) ((d) = (s))
 #endif

@@ -64,7 +63,6 @@
 void xmpp_initialize(void)
 {
    sock_initialize();
-    resolver_initialize();
    tls_initialize();
 }

@@ -75,7 +73,6 @@
 void xmpp_shutdown(void)
 {
    tls_shutdown();
-    resolver_shutdown();
    sock_shutdown();
 }

--- a/src/event.c
+++ b/src/event.c
@@ -41,25 +41,16 @@
 #define _sleep(x) usleep((x) * 1000)
 #else
 #include <winsock2.h>
-#ifndef ETIMEDOUT
 #define ETIMEDOUT WSAETIMEDOUT
-#endif
-#ifndef ECONNRESET
 #define ECONNRESET WSAECONNRESET
-#endif
-#ifndef ECONNABORTED
 #define ECONNABORTED WSAECONNABORTED
-#endif
 #define _sleep(x) Sleep(x)
 #endif

-#include "strophe.h"
+#include <strophe.h>
 #include "common.h"
 #include "parser.h"

-/** Max buffer size for receiving messages. */
-#define STROPE_MESSAGE_BUFFER_SIZE 4096
-
 /** Run the event loop once.
 *  This function will run send any data that has been queued by
 *  xmpp_send and related functions and run through the Strophe even
@@ -83,7 +74,7 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
    struct timeval tv;
    xmpp_send_queue_t *sq, *tsq;
    int towrite;
-    char buf[STROPE_MESSAGE_BUFFER_SIZE];
+    char buf[4096];
    uint64_t next;
    uint64_t usec;
    int tls_read_bytes = 0;
@@ -263,16 +254,18 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
        case XMPP_STATE_CONNECTED:
            if (FD_ISSET(conn->sock, &rfds) || (conn->tls && tls_pending(conn->tls))) {
                if (conn->tls) {
-                    ret = tls_read(conn->tls, buf, STROPE_MESSAGE_BUFFER_SIZE);
+                    ret = tls_read(conn->tls, buf, 4096);
                } else {
-                    ret = sock_read(conn->sock, buf, STROPE_MESSAGE_BUFFER_SIZE);
+                    ret = sock_read(conn->sock, buf, 4096);
                }

                if (ret > 0) {
                    ret = parser_feed(conn->parser, buf, ret);
                    if (!ret) {
-                        xmpp_debug(ctx, "xmpp", "parse error [%s]", buf);
-                        xmpp_send_error(conn, XMPP_SE_INVALID_XML, "parse error");
+                        /* parse error, we need to shut down */
+                        /* FIXME */
+                        xmpp_debug(ctx, "xmpp", "parse error, disconnecting");
+                        conn_disconnect(conn);
                    }
                } else {
                    if (conn->tls) {
--- a/src/handler.c
+++ b/src/handler.c
@@ -90,7 +90,7 @@ void handler_fire_stanza(xmpp_conn_t * const conn,
                    /* replace old value */
                    hash_add(conn->id_handlers, id, head);
                }
-                xmpp_free(conn->ctx, item->u.id);
+                xmpp_free(conn->ctx, item->id);
                xmpp_free(conn->ctx, item);
            }
            item = next;
@@ -116,10 +116,10 @@ void handler_fire_stanza(xmpp_conn_t * const conn,
        }

        next = item->next;
-        if ((!item->u.ns || (ns && strcmp(ns, item->u.ns) == 0) ||
-             xmpp_stanza_get_child_by_ns(stanza, item->u.ns)) &&
-            (!item->u.name || (name && strcmp(name, item->u.name) == 0)) &&
-            (!item->u.type || (type && strcmp(type, item->u.type) == 0))) {
+        if ((!item->ns || (ns && strcmp(ns, item->ns) == 0) ||
+             xmpp_stanza_get_child_by_ns(stanza, item->ns)) &&
+            (!item->name || (name && strcmp(name, item->name) == 0)) &&
+            (!item->type || (type && strcmp(type, item->type) == 0))) {

            ret = ((xmpp_handler)(item->handler))(conn, stanza, item->userdata);
            /* list may be changed during execution of a handler */
@@ -127,9 +127,9 @@ void handler_fire_stanza(xmpp_conn_t * const conn,
            if (!ret) {
                /* handler is one-shot, so delete it */
                _handler_item_remove(&conn->handlers, item);
-                if (item->u.ns) xmpp_free(conn->ctx, item->u.ns);
-                if (item->u.name) xmpp_free(conn->ctx, item->u.name);
-                if (item->u.type) xmpp_free(conn->ctx, item->u.type);
+                if (item->ns) xmpp_free(conn->ctx, item->ns);
+                if (item->name) xmpp_free(conn->ctx, item->name);
+                if (item->type) xmpp_free(conn->ctx, item->type);
                xmpp_free(conn->ctx, item);
            }
        }
@@ -178,10 +178,10 @@ uint64_t handler_fire_timed(xmpp_ctx_t * const ctx)

            next = item->next;
            timestamp = time_stamp();
-            elapsed = time_elapsed(item->u.last_stamp, timestamp);
-            if (elapsed >= item->u.period) {
+            elapsed = time_elapsed(item->last_stamp, timestamp);
+            if (elapsed >= item->period) {
                /* fire! */
-                item->u.last_stamp = timestamp;
+                item->last_stamp = timestamp;
                ret = ((xmpp_timed_handler)item->handler)(conn, item->userdata);
                /* list may be changed during execution of a handler */
                next = item->next;
@@ -190,8 +190,8 @@ uint64_t handler_fire_timed(xmpp_ctx_t * const ctx)
                    _handler_item_remove(&conn->timed_handlers, item);
                    xmpp_free(conn->ctx, item);
                }
-            } else if (min > (item->u.period - elapsed))
-                min = item->u.period - elapsed;
+            } else if (min > (item->period - elapsed))
+                min = item->period - elapsed;

            item = next;
        }
@@ -215,7 +215,7 @@ void handler_reset_timed(xmpp_conn_t *conn, int user_only)
    handitem = conn->timed_handlers;
    while (handitem) {
        if ((user_only && handitem->user_handler) || !user_only)
-            handitem->u.last_stamp = time_stamp();
+            handitem->last_stamp = time_stamp();

        handitem = handitem->next;
    }
@@ -248,8 +248,8 @@ static void _timed_handler_add(xmpp_conn_t * const conn,
    item->enabled = 0;
    item->next = NULL;

-    item->u.period = period;
-    item->u.last_stamp = time_stamp();
+    item->period = period;
+    item->last_stamp = time_stamp();

    /* append item to list */
    if (!conn->timed_handlers)
@@ -322,8 +322,8 @@ static void _id_handler_add(xmpp_conn_t * const conn,
    item->enabled = 0;
    item->next = NULL;

-    item->u.id = xmpp_strdup(conn->ctx, id);
-    if (!item->u.id) {
+    item->id = xmpp_strdup(conn->ctx, id);
+    if (!item->id) {
        xmpp_free(conn->ctx, item);
        return;
    }
@@ -368,7 +368,7 @@ void xmpp_id_handler_delete(xmpp_conn_t * const conn,
                hash_add(conn->id_handlers, id, next);
            }

-            xmpp_free(conn->ctx, item->u.id);
+            xmpp_free(conn->ctx, item->id);
            xmpp_free(conn->ctx, item);
            item = next;
        } else {
@@ -410,31 +410,31 @@ static void _handler_add(xmpp_conn_t * const conn,
    item->next = NULL;

    if (ns) {
-        item->u.ns = xmpp_strdup(conn->ctx, ns);
-        if (!item->u.ns) {
+        item->ns = xmpp_strdup(conn->ctx, ns);
+        if (!item->ns) {
            xmpp_free(conn->ctx, item);
            return;
        }
    } else
-        item->u.ns = NULL;
+        item->ns = NULL;
    if (name) {
-        item->u.name = xmpp_strdup(conn->ctx, name);
-        if (!item->u.name) {
-            if (item->u.ns) xmpp_free(conn->ctx, item->u.ns);
+        item->name = xmpp_strdup(conn->ctx, name);
+        if (!item->name) {
+            if (item->ns) xmpp_free(conn->ctx, item->ns);
            xmpp_free(conn->ctx, item);
            return;
        }
    } else
-        item->u.name = NULL;
+        item->name = NULL;
    if (type) {
-        item->u.type = xmpp_strdup(conn->ctx, type);
-        if (!item->u.type) {
-            if (item->u.ns) xmpp_free(conn->ctx, item->u.ns);
-            if (item->u.name) xmpp_free(conn->ctx, item->u.name);
+        item->type = xmpp_strdup(conn->ctx, type);
+        if (!item->type) {
+            if (item->ns) xmpp_free(conn->ctx, item->ns);
+            if (item->name) xmpp_free(conn->ctx, item->name);
            xmpp_free(conn->ctx, item);
        }
    } else
-        item->u.type = NULL;
+        item->type = NULL;

    /* append to list */
    if (!conn->handlers)
@@ -470,9 +470,9 @@ void xmpp_handler_delete(xmpp_conn_t * const conn,
            else
                conn->handlers = item->next;

-            if (item->u.ns) xmpp_free(conn->ctx, item->u.ns);
-            if (item->u.name) xmpp_free(conn->ctx, item->u.name);
-            if (item->u.type) xmpp_free(conn->ctx, item->u.type);
+            if (item->ns) xmpp_free(conn->ctx, item->ns);
+            if (item->name) xmpp_free(conn->ctx, item->name);
+            if (item->type) xmpp_free(conn->ctx, item->type);
            xmpp_free(conn->ctx, item);
            item = prev ? prev->next : conn->handlers;
        } else {
@@ -636,9 +636,9 @@ void handler_system_delete_all(xmpp_conn_t *conn)
        if (!item->user_handler) {
            next = item->next;
            _handler_item_remove(&conn->handlers, item);
-            if (item->u.ns) xmpp_free(conn->ctx, item->u.ns);
-            if (item->u.name) xmpp_free(conn->ctx, item->u.name);
-            if (item->u.type) xmpp_free(conn->ctx, item->u.type);
+            if (item->ns) xmpp_free(conn->ctx, item->ns);
+            if (item->name) xmpp_free(conn->ctx, item->name);
+            if (item->type) xmpp_free(conn->ctx, item->type);
            xmpp_free(conn->ctx, item);
            item = next;
        } else
@@ -665,7 +665,7 @@ void handler_system_delete_all(xmpp_conn_t *conn)
            if (!item->user_handler) {
                next = item->next;
                _handler_item_remove(&head, item);
-                xmpp_free(conn->ctx, item->u.id);
+                xmpp_free(conn->ctx, item->id);
                xmpp_free(conn->ctx, item);
                item = next;
            } else
--- a/src/hash.c
+++ b/src/hash.c
@@ -163,8 +163,6 @@ int hash_add(hash_t *table, const char * const key, void *data)
      entry->next = table->entries[table_index];
      table->entries[table_index] = entry;
      table->num_keys++;
-   } else {
-      if (table->free) table->free(ctx, entry->value);
   }

   entry->value = data;
@@ -243,7 +241,7 @@ void hash_iter_release(hash_iterator_t *iter)

    iter->ref--;

-    if (iter->ref == 0) { // ref is unsigned!!!
+    if (iter->ref <= 0) {
 	hash_release(iter->table);
 	xmpp_free(ctx, iter);
    }
--- a/src/md5.c
+++ b/src/md5.c
@@ -43,7 +43,8 @@
        (cp)[3] = ((value) >> 24) & 0xFF; \
    } while(0)

-static void MD5Transform(uint32_t buf[4], const unsigned char inext[64]);
+static void MD5Transform(uint32_t buf[4], const unsigned char inext[64],
+                         struct MD5Context *ctx);

 /*
 * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
@@ -90,7 +91,7 @@ void MD5Update(struct MD5Context *ctx, unsigned char const *buf, uint32_t len)
            return;
        }
        memcpy(p, buf, t);
-        MD5Transform(ctx->buf, ctx->in);
+        MD5Transform(ctx->buf, ctx->in, ctx);
        buf += t;
        len -= t;
    }
@@ -98,7 +99,7 @@ void MD5Update(struct MD5Context *ctx, unsigned char const *buf, uint32_t len)

    while (len >= 64) {
        memcpy(ctx->in, buf, 64);
-        MD5Transform(ctx->buf, ctx->in);
+        MD5Transform(ctx->buf, ctx->in, ctx);
        buf += 64;
        len -= 64;
    }
@@ -132,7 +133,7 @@ void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
    if (count < 8) {
        /* Two lots of padding:  Pad the first block to 64 bytes */
        memset(p, 0, count);
-        MD5Transform(ctx->buf, ctx->in);
+        MD5Transform(ctx->buf, ctx->in, ctx);

        /* Now fill the next block with 56 bytes */
        memset(ctx->in, 0, 56);
@@ -145,7 +146,7 @@ void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
    PUT_32BIT_LSB_FIRST(ctx->in + 56, ctx->bits[0]);
    PUT_32BIT_LSB_FIRST(ctx->in + 60, ctx->bits[1]);

-    MD5Transform(ctx->buf, ctx->in);
+    MD5Transform(ctx->buf, ctx->in, ctx);
    PUT_32BIT_LSB_FIRST(digest, ctx->buf[0]);
    PUT_32BIT_LSB_FIRST(digest + 4, ctx->buf[1]);
    PUT_32BIT_LSB_FIRST(digest + 8, ctx->buf[2]);
@@ -179,7 +180,8 @@ void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
 * reflect the addition of 16 longwords of new data.  MD5Update blocks
 * the data and converts bytes into longwords for this routine.
 */
-static void MD5Transform(uint32_t buf[4], const unsigned char inext[64])
+static void MD5Transform(uint32_t buf[4], const unsigned char inext[64],
+                         struct MD5Context *ctx)
 {
    register uint32_t a, b, c, d, i;
    uint32_t in[16];
--- a/src/parser_expat.c
+++ b/src/parser_expat.c
@@ -19,10 +19,13 @@

 #include <expat.h>

-#include "strophe.h"
+#include <strophe.h>
 #include "common.h"
 #include "parser.h"

+/* Use the Unit Separator to delimit namespace and name in our XML*/
+#define NAMESPACE_SEP ('\x1F')
+
 /* Allocate inner text by this number bytes more. Expat splits string
 * "new\nline" into 3 strings: "new" "\n" "line". Expecting this pattern,
 * we can leave few bytes in the inner_text for "\n". It should reduce
@@ -45,46 +48,6 @@ struct _parser_t {
    int inner_text_used;
 };

-/* Use the Unit Separator to delimit namespace and name in our XML */
-const XML_Char namespace_sep = '\x1F';
-
-/*
- * Cached strophe ctx. It is used for memory suite.
- * Note, expat doesn't support userdata in memory suite, therefore,
- * we can support only one strophe context. If user creates more than one
- * context, this module will fallback to default library allocator for all
- * contexts other than mem_ctx.
- */
-static xmpp_ctx_t *mem_ctx = NULL;
-
-static void *parser_mem_malloc(size_t size)
-{
-    if (mem_ctx != NULL)
-        return xmpp_alloc(mem_ctx, size);
-    else
-        return NULL;
-}
-
-static void *parser_mem_realloc(void *ptr, size_t size)
-{
-    if (mem_ctx != NULL)
-        return xmpp_realloc(mem_ctx, ptr, size);
-    else
-        return NULL;
-}
-
-static void parser_mem_free(void *ptr)
-{
-    if (mem_ctx != NULL)
-        xmpp_free(mem_ctx, ptr);
-}
-
-static const XML_Memory_Handling_Suite parser_mem_suite = {
-    .malloc_fcn = &parser_mem_malloc,
-    .realloc_fcn = &parser_mem_realloc,
-    .free_fcn = &parser_mem_free,
-};
-
 /* return allocated string with the name from a delimited
 * namespace/name string */
 static char *_xml_name(xmpp_ctx_t *ctx, const char *nsname)
@@ -93,7 +56,7 @@ static char *_xml_name(xmpp_ctx_t *ctx, const char *nsname)
    const char *c;
    size_t len;

-    c = strchr(nsname, namespace_sep);
+    c = strchr(nsname, NAMESPACE_SEP);
    if (c == NULL) return xmpp_strdup(ctx, nsname);

    c++;
@@ -113,7 +76,7 @@ static char *_xml_namespace(xmpp_ctx_t *ctx, const char *nsname)
    char *result = NULL;
    const char *c;

-    c = strchr(nsname, namespace_sep);
+    c = strchr(nsname, NAMESPACE_SEP);
    if (c != NULL) {
 	result = xmpp_alloc(ctx, (c-nsname) + 1);
 	if (result != NULL) {
@@ -174,7 +137,7 @@ static void _start_element(void *userdata,
    if (parser->depth == 0) {
        /* notify the owner */
        if (parser->startcb)
-            parser->startcb(name, (char **)attrs,
+            parser->startcb((char *)name, (char **)attrs, 
                            parser->userdata);
    } else {
        /* build stanzas at depth 1 */
@@ -310,37 +273,22 @@ void parser_free(parser_t *parser)
 /* shuts down and restarts XML parser.  true on success */
 int parser_reset(parser_t *parser)
 {
-    XML_Bool ret;
-    const XML_Memory_Handling_Suite *mem = NULL;
+    if (parser->expat)
+	XML_ParserFree(parser->expat);

-    if (parser->expat) {
-        ret = XML_ParserReset(parser->expat, NULL);
-        if (ret != XML_TRUE) {
-            XML_ParserFree(parser->expat);
-            parser->expat = NULL;
-        }
-    } else {
-        if (mem_ctx == NULL)
-            mem_ctx = parser->ctx;
-        if (parser->ctx == mem_ctx)
-            mem = &parser_mem_suite;
-        parser->expat = XML_ParserCreate_MM(NULL, mem, &namespace_sep);
-    }
+    if (parser->stanza) 
+	xmpp_stanza_release(parser->stanza);

-    if (parser->stanza) {
-        xmpp_stanza_release(parser->stanza);
-        parser->stanza = NULL;
-    }
-
-    if (parser->inner_text) {
-        xmpp_free(parser->ctx, parser->inner_text);
-        parser->inner_text = NULL;
-    }
-
-    if (!parser->expat)
-        return 0;
+    parser->expat = XML_ParserCreateNS(NULL, NAMESPACE_SEP);
+    if (!parser->expat) return 0;

    parser->depth = 0;
+    parser->stanza = NULL;
+
+    if (parser->inner_text) {
+        xmpp_free (parser->ctx, parser->inner_text);
+        parser->inner_text = NULL;
+    }

    XML_SetUserData(parser->expat, parser);
    XML_SetElementHandler(parser->expat, _start_element, _end_element);
--- a/src/parser_libxml2.c
+++ b/src/parser_libxml2.c
@@ -20,7 +20,7 @@
 #include <libxml/parser.h>
 #include <libxml/tree.h>

-#include "strophe.h"
+#include <strophe.h>
 #include "common.h"
 #include "parser.h"

@@ -249,8 +249,6 @@ void parser_free(parser_t *parser)
 {
    if (parser->xmlctx)
        xmlFreeParserCtxt(parser->xmlctx);
-    if (parser->stanza)
-        xmpp_stanza_release(parser->stanza);
    xmpp_free(parser->ctx, parser);
 }

@@ -259,16 +257,18 @@ int parser_reset(parser_t *parser)
 {
    if (parser->xmlctx)
        xmlFreeParserCtxt(parser->xmlctx);
+
    if (parser->stanza) 
 	xmpp_stanza_release(parser->stanza);

-    parser->stanza = NULL;
-    parser->depth = 0;
-
    parser->xmlctx = xmlCreatePushParserCtxt(&parser->handlers, 
                                             parser, NULL, 0, NULL);
+    if (!parser->xmlctx) return 0;

-    return parser->xmlctx ? 1 : 0;
+    parser->depth = 0;
+    parser->stanza = NULL;
+
+    return 1;
 }

 /* feed a chunk of data to the parser */
--- a/src/rand.c
+++ b/src/rand.c
@@ -127,11 +127,9 @@ static void Hash_DRBG_Instantiate(Hash_DRBG_CTX *ctx,

    assert(entropy_input_len <= ENTROPY_MAX);
    assert(nonce_len <= NONCE_MAX);
-    assert(nonce != NULL || nonce_len == 0);

    memcpy(seed_material, entropy_input, entropy_input_len);
-    if (nonce != NULL)
-        memcpy(seed_material + entropy_input_len, nonce, nonce_len);
+    memcpy(seed_material + entropy_input_len, nonce, nonce_len);
    Hash_df(seed_material, entropy_input_len + nonce_len, seed, seedlen);
    seed0[0] = 0;

@@ -289,32 +287,25 @@ int xmpp_rand(xmpp_rand_t *rand)
    return result;
 }

-static void rand_byte2hex(unsigned char byte, char *hex)
-{
-    static const char hex_tbl[16] = { '0', '1', '2', '3', '4', '5', '6', '7',
-                                      '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
-
-    hex[0] = hex_tbl[(byte >> 4) & 0x0f];
-    hex[1] = hex_tbl[byte & 0x0f];
-}
-
 void xmpp_rand_nonce(xmpp_rand_t *rand, char *output, size_t len)
 {
    size_t i;
-    const size_t rand_len = len / 2;
+    size_t rand_len = len / 2;
+#ifndef _MSC_VER
+    unsigned char rand_buf[rand_len];
+#else
+    unsigned char *rand_buf = (unsigned char *)_alloca(rand_len);
+#endif

-    /*
-     * We don't want to use any allocation here, because this function
-     * can't fail. Also we want to avoid VLA.
-     * Current implementation uses half of the output buffer for random buffer
-     * generation and then converts it to HEX representation.
+    /* current implementation returns printable HEX representation of
+     * a random buffer, however base64 encoding can be used instead;
+     * the only problem is that base64_encode() allocates memory and
+     * as result can fail.
     */

-    if (rand_len > 0) {
-        xmpp_rand_bytes(rand, (unsigned char *)output, rand_len);
-        for (i = rand_len; i > 0; --i)
-            rand_byte2hex(output[i - 1], &output[(i - 1) * 2]);
+    xmpp_rand_bytes(rand, rand_buf, rand_len);
+    for (i = 0; i < rand_len; ++i) {
+        xmpp_snprintf(output + i * 2, len, "%02x", rand_buf[i]);
+        len -= 2;
    }
-    if (len > 0)
-        output[len - 1] = '\0';
 }
--- a/src/rand.h
+++ b/src/rand.h
@@ -36,7 +36,7 @@ xmpp_rand_t *xmpp_rand_new(xmpp_ctx_t *ctx);
 */
 void xmpp_rand_free(xmpp_ctx_t *ctx, xmpp_rand_t *rand);

-/** Generate random integer.
+/** Generate random integer
 *  Analogue of rand(3).
 *
 *  @ingroup Random
--- a/src/resolver.c
+++ b/src/resolver.c
@@ -1,4 +1,4 @@
-/* resolver.c
+/* resolver.h
 * strophe XMPP client library -- DNS resolver
 *
 * Copyright (C) 2015 Dmitry Podgorny <pasis.ua@gmail.com>
@@ -13,23 +13,11 @@
 *  DNS resolver.
 */

-#if !defined(_WIN32) && !defined(HAVE_CARES)
+#ifndef _WIN32
 #include <netinet/in.h>
 #include <arpa/nameser.h>
 #include <resolv.h>             /* res_query */
-#endif /* _WIN32 && HAVE_CARES */
-
-#ifdef HAVE_CARES
-#include <ares.h>
-/* for select(2) */
-#ifdef _WIN32
-#include <winsock2.h>
-#else /* _WIN32 */
-#include <sys/time.h>
-#include <sys/types.h>
-#include <unistd.h>
-#endif /* !_WIN32 */
-#endif /* HAVE_CARES */
+#endif /* _WIN32 */

 #include <string.h>             /* strncpy */

@@ -43,189 +31,6 @@
 #define MESSAGE_T_SRV 33
 #define MESSAGE_C_IN 1

-/*******************************************************************************
- * Forward declarations.
- ******************************************************************************/
-
-#ifdef HAVE_CARES
-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);
-#endif /* HAVE_CARES */
-
-#ifndef HAVE_CARES
-static int resolver_raw_srv_lookup_buf(xmpp_ctx_t *ctx,
-                                       const unsigned char *buf,
-                                       size_t len,
-                                       resolver_srv_rr_t **srv_rr_list);
-#endif /* !HAVE_CARES */
-
-#ifdef _WIN32
-static int resolver_win32_srv_lookup(xmpp_ctx_t *ctx, const char *fulldomain,
-                                     resolver_srv_rr_t **srv_rr_list);
-static int resolver_win32_srv_query(const char *fulldomain,
-                                    unsigned char *buf, size_t len);
-#endif /* _WIN32 */
-
-/*******************************************************************************
- * Implementation.
- ******************************************************************************/
-
-void resolver_initialize(void)
-{
-#ifdef HAVE_CARES
-    ares_library_init(ARES_LIB_INIT_ALL);
-#endif
-}
-
-void resolver_shutdown(void)
-{
-#ifdef HAVE_CARES
-    ares_library_cleanup();
-#endif
-}
-
-static void resolver_srv_list_sort(resolver_srv_rr_t **srv_rr_list)
-{
-    resolver_srv_rr_t *rr_head;
-    resolver_srv_rr_t *rr_current;
-    resolver_srv_rr_t *rr_next;
-    resolver_srv_rr_t *rr_prev;
-    int swap;
-
-    rr_head = *srv_rr_list;
-
-    if ((rr_head == NULL) || (rr_head->next == NULL)) {
-        /* Empty or single record list */
-        return;
-    }
-
-    do {
-        rr_prev = NULL;
-        rr_current = rr_head;
-        rr_next = rr_head->next;
-        swap = 0;
-        while (rr_next != NULL) {
-            /*
-             * RFC2052: A client MUST attempt to contact the target host
-             * with the lowest-numbered priority it can reach.
-             * RFC2052: When selecting a target host among the
-             * those that have the same priority, the chance of trying
-             * this one first SHOULD be proportional to its weight.
-             */
-            if ((rr_current->priority > rr_next->priority) ||
-                (rr_current->priority == rr_next->priority &&
-                 rr_current->weight < rr_next->weight))
-            {
-                /* Swap node */
-                swap = 1;
-                if (rr_prev != NULL) {
-                    rr_prev->next = rr_next;
-                } else {
-                    /* Swap head node */
-                    rr_head = rr_next;
-                }
-                rr_current->next = rr_next->next;
-                rr_next->next = rr_current;
-
-                rr_prev = rr_next;
-                rr_next = rr_current->next;
-            } else {
-                /* Next node */
-                rr_prev = rr_current;
-                rr_current = rr_next;
-                rr_next = rr_next->next;
-            }
-        }
-    } while (swap != 0);
-
-    *srv_rr_list = rr_head;
-}
-
-int resolver_srv_lookup_buf(xmpp_ctx_t *ctx, const unsigned char *buf,
-                            size_t len, resolver_srv_rr_t **srv_rr_list)
-{
-    int set;
-
-#ifdef HAVE_CARES
-    set = resolver_ares_srv_lookup_buf(ctx, buf, len, srv_rr_list);
-#else
-    set = resolver_raw_srv_lookup_buf(ctx, buf, len, srv_rr_list);
-#endif
-    resolver_srv_list_sort(srv_rr_list);
-
-    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)
-{
-#define RESOLVER_BUF_MAX 65536
-    unsigned char *buf;
-    char fulldomain[2048];
-    int len;
-    int set = XMPP_DOMAIN_NOT_FOUND;
-
-    (void)buf;
-    (void)len;
-
-    xmpp_snprintf(fulldomain, sizeof(fulldomain),
-                  "_%s._%s.%s", service, proto, domain);
-
-    *srv_rr_list = NULL;
-
-#ifdef HAVE_CARES
-    set = resolver_ares_srv_lookup(ctx, fulldomain, srv_rr_list);
-#else /* HAVE_CARES */
-
-#ifdef _WIN32
-    set = resolver_win32_srv_lookup(ctx, fulldomain, srv_rr_list);
-    if (set == XMPP_DOMAIN_FOUND)
-        return set;
-#endif /* _WIN32 */
-
-    buf = xmpp_alloc(ctx, RESOLVER_BUF_MAX);
-    if (buf == NULL)
-        return XMPP_DOMAIN_NOT_FOUND;
-
-#ifdef _WIN32
-    len = resolver_win32_srv_query(fulldomain, buf, RESOLVER_BUF_MAX);
-#else /* _WIN32 */
-    len = res_query(fulldomain, MESSAGE_C_IN, MESSAGE_T_SRV, buf,
-                    RESOLVER_BUF_MAX);
-#endif /* _WIN32 */
-
-    if (len > 0)
-        set = resolver_srv_lookup_buf(ctx, buf, (size_t)len, srv_rr_list);
-
-    xmpp_free(ctx, buf);
-
-#endif /* HAVE_CARES */
-
-    return set;
-}
-
-void resolver_srv_free(xmpp_ctx_t *ctx, resolver_srv_rr_t *srv_rr_list)
-{
-    resolver_srv_rr_t *rr;
-
-    while (srv_rr_list != NULL) {
-        rr = srv_rr_list->next;
-        xmpp_free(ctx, srv_rr_list);
-        srv_rr_list = rr;
-    }
-}
-
-#ifndef HAVE_CARES
-/*******************************************************************************
- * Resolver raw implementation.
- *
- * This code is common for both unix and win32.
- ******************************************************************************/
-
 struct message_header {
    uint16_t id;
    uint8_t octet2;
@@ -236,6 +41,13 @@ struct message_header {
    uint16_t arcount;
 };

+#ifdef _WIN32
+static int resolver_win32_srv_lookup(xmpp_ctx_t *ctx, const char *fulldomain,
+                                     resolver_srv_rr_t **srv_rr_list);
+static int resolver_win32_srv_query(const char *fulldomain,
+                                    unsigned char *buf, size_t len);
+#endif /* _WIN32 */
+
 /* the same as ntohs(), but receives pointer to the value */
 static uint16_t xmpp_ntohs_ptr(const void *ptr)
 {
@@ -268,7 +80,7 @@ static size_t message_name_append_safe(char *name, size_t name_len,
    copy_len = name_max > name_len ? name_max - name_len : 0;
    copy_len = xmpp_min(tail_len, copy_len);
    if (copy_len > 0)
-        memcpy(&name[name_len], tail, copy_len);
+        strncpy(&name[name_len], tail, copy_len);

    return name_len + tail_len;
 }
@@ -348,6 +160,63 @@ static unsigned message_name_len(const unsigned char *buf, size_t buf_len,
    return message_name_get(buf, buf_len, buf_offset, NULL, SIZE_MAX);
 }

+static void resolver_srv_list_sort(resolver_srv_rr_t **srv_rr_list)
+{
+    resolver_srv_rr_t * rr_head;
+    resolver_srv_rr_t * rr_current;
+    resolver_srv_rr_t * rr_next;
+    resolver_srv_rr_t * rr_prev;
+    int swap;
+
+    rr_head = *srv_rr_list;
+
+    if ((rr_head == NULL) || (rr_head->next == NULL)) {
+        /* Empty or single record list */
+        return;
+    }
+
+    do {
+        rr_prev = NULL;
+        rr_current = rr_head;
+        rr_next = rr_head->next;
+        swap = 0;
+        while (rr_next != NULL) {
+            /*
+             * RFC2052: A client MUST attempt to contact the target host
+             * with the lowest-numbered priority it can reach.
+             * RFC2052: When selecting a target host among the
+             * those that have the same priority, the chance of trying
+             * this one first SHOULD be proportional to its weight.
+             */
+            if ((rr_current->priority > rr_next->priority) ||
+                (rr_current->priority == rr_next->priority &&
+                 rr_current->weight < rr_next->weight))
+            {
+                /* Swap node */
+                swap = 1;
+                if (rr_prev != NULL) {
+                    rr_prev->next = rr_next;
+                } else {
+                    /* Swap head node */
+                    rr_head = rr_next;
+                }
+                rr_current->next = rr_next->next;
+                rr_next->next = rr_current;
+
+                rr_prev = rr_next;
+                rr_next = rr_current->next;
+            } else {
+                /* Next node */
+                rr_prev = rr_current;
+                rr_current = rr_next;
+                rr_next = rr_next->next;
+            }
+        }
+    } while (swap != 0);
+
+    *srv_rr_list = rr_head;
+}
+
 #define BUF_OVERFLOW_CHECK(ptr, len) do {         \
    if ((ptr) >= (len)) {                         \
        if (*srv_rr_list != NULL)                 \
@@ -357,10 +226,8 @@ static unsigned message_name_len(const unsigned char *buf, size_t buf_len,
    }                                             \
 } while (0)

-static int resolver_raw_srv_lookup_buf(xmpp_ctx_t *ctx,
-                                       const unsigned char *buf,
-                                       size_t len,
-                                       resolver_srv_rr_t **srv_rr_list)
+int resolver_srv_lookup_buf(xmpp_ctx_t *ctx, const unsigned char *buf,
+                            size_t len, resolver_srv_rr_t **srv_rr_list)
 {
    unsigned i;
    unsigned j;
@@ -425,110 +292,52 @@ static int resolver_raw_srv_lookup_buf(xmpp_ctx_t *ctx,
        }
        j += rdlength;
    }
+    resolver_srv_list_sort(srv_rr_list);

    return *srv_rr_list != NULL ? XMPP_DOMAIN_FOUND : XMPP_DOMAIN_NOT_FOUND;
 }

-#endif /* !HAVE_CARES */
-
-#ifdef HAVE_CARES
-/*******************************************************************************
- * 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,
-                                        resolver_srv_rr_t **srv_rr_list)
+int resolver_srv_lookup(xmpp_ctx_t *ctx, const char *service, const char *proto,
+                        const char *domain, resolver_srv_rr_t **srv_rr_list)
 {
-    struct ares_srv_reply *srv;
-    struct ares_srv_reply *item;
-    resolver_srv_rr_t *rr;
-    int rc;
+    char fulldomain[2048];
+    unsigned char buf[65535];
+    int len;
+    int set = XMPP_DOMAIN_NOT_FOUND;
+
+    xmpp_snprintf(fulldomain, sizeof(fulldomain),
+                  "_%s._%s.%s", service, proto, domain);

    *srv_rr_list = NULL;

-    rc = ares_parse_srv_reply(buf, len, &srv);
-    if (rc != ARES_SUCCESS)
-        return XMPP_DOMAIN_NOT_FOUND;
+#ifdef _WIN32
+    set = resolver_win32_srv_lookup(ctx, fulldomain, srv_rr_list);
+    if (set == XMPP_DOMAIN_FOUND)
+        return set;
+    len = resolver_win32_srv_query(fulldomain, buf, sizeof(buf));
+#else /* _WIN32 */
+    len = res_query(fulldomain, MESSAGE_C_IN, MESSAGE_T_SRV, buf, sizeof(buf));
+#endif /* _WIN32 */

-    item = srv;
-    while (item != NULL) {
-        rr = xmpp_alloc(ctx, sizeof(*rr));
-        if (rr == NULL)
-            break;
-        rr->next = *srv_rr_list;
-        rr->priority = item->priority;
-        rr->weight = item->weight;
-        rr->port = item->port;
-        strncpy(rr->target, item->host, sizeof(rr->target) - 1);
-        rr->target[sizeof(rr->target) - 1] = '\0';
-        *srv_rr_list = rr;
-        item = item->next;
-    }
-    ares_free_data(srv);
+    if (len > 0)
+        set = resolver_srv_lookup_buf(ctx, buf, (size_t)len, srv_rr_list);

-    return *srv_rr_list == NULL ? XMPP_DOMAIN_NOT_FOUND : XMPP_DOMAIN_FOUND;
+    return set;
 }

-static void ares_srv_lookup_callback(void *arg, int status, int timeouts,
-                                     unsigned char *buf, int len)
+void resolver_srv_free(xmpp_ctx_t *ctx, resolver_srv_rr_t *srv_rr_list)
 {
-    struct resolver_ares_ctx *actx = arg;
+    resolver_srv_rr_t *rr;

-    if (status != ARES_SUCCESS)
-        actx->result = XMPP_DOMAIN_NOT_FOUND;
-    else
-        actx->result = resolver_ares_srv_lookup_buf(actx->ctx, buf, len,
-                                                    &actx->srv_rr_list);
-}
-
-static int resolver_ares_srv_lookup(xmpp_ctx_t *ctx, const char *fulldomain,
-                                    resolver_srv_rr_t **srv_rr_list)
-{
-    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);
+    while (srv_rr_list != NULL) {
+        rr = srv_rr_list->next;
+        xmpp_free(ctx, srv_rr_list);
+        srv_rr_list = rr;
    }
-
-    *srv_rr_list = actx.srv_rr_list;
-    return actx.result;
 }

-#endif /* HAVE_CARES */
-
 #ifdef _WIN32
+
 /*******************************************************************************
 * Next part was copied from sock.c and contains old win32 code.
 *
@@ -661,21 +470,21 @@ static int resolver_win32_srv_lookup(xmpp_ctx_t *ctx, const char *fulldomain,
    resolver_srv_rr_t *rr;
    HINSTANCE hdnsapi = NULL;

-    DNS_STATUS (WINAPI * pDnsQuery_A)(PCSTR, WORD, DWORD, PIP4_ARRAY, DNS_RECORDA**, PVOID*);
-    void (WINAPI * pDnsRecordListFree)(DNS_RECORDA*, DNS_FREE_TYPE);
+    DNS_STATUS (WINAPI * pDnsQuery_A)(PCSTR, WORD, DWORD, PIP4_ARRAY, PDNS_RECORD*, PVOID*);
+    void (WINAPI * pDnsRecordListFree)(PDNS_RECORD, DNS_FREE_TYPE);

    if (hdnsapi = LoadLibrary("dnsapi.dll")) {
        pDnsQuery_A = (void *)GetProcAddress(hdnsapi, "DnsQuery_A");
        pDnsRecordListFree = (void *)GetProcAddress(hdnsapi, "DnsRecordListFree");

        if (pDnsQuery_A && pDnsRecordListFree) {
-            DNS_RECORDA *dnsrecords = NULL;
+            PDNS_RECORD dnsrecords = NULL;
            DNS_STATUS error;

            error = pDnsQuery_A(fulldomain, DNS_TYPE_SRV, DNS_QUERY_STANDARD, NULL, &dnsrecords, NULL);

            if (error == 0) {
-                DNS_RECORDA *current = dnsrecords;
+                PDNS_RECORD current = dnsrecords;

                while (current) {
                    if (current->wType == DNS_TYPE_SRV) {
@@ -708,7 +517,7 @@ static int resolver_win32_srv_query(const char *fulldomain,
                                    unsigned char *buf, size_t len)
 {
    int set = 0;
-    int insize = 0;
+    int insize;

    /* if dnsapi didn't work/isn't there, try querying the dns server manually */
    if (!set)
@@ -741,7 +550,7 @@ static int resolver_win32_srv_query(const char *fulldomain,
 				char buffer[65535];

 				len = 65535;
-				fi = (FIXED_INFO *)buffer;
+				fi = buffer;

 				if ((error = pGetNetworkParams(fi, &len)) == ERROR_SUCCESS)
 				{
--- a/src/resolver.h
+++ b/src/resolver.h
@@ -33,9 +33,6 @@ typedef struct resolver_srv_rr_struc {
    struct resolver_srv_rr_struc *next;
 } resolver_srv_rr_t;

-void resolver_initialize(void);
-void resolver_shutdown(void);
-
 /** Perform lookup for RFC1035 message format.
 *  This function allocates all elements.
 *
--- a/src/sasl.c
+++ b/src/sasl.c
@@ -264,8 +264,7 @@ char *sasl_digest_md5(xmpp_ctx_t *ctx, const char *challenge,
    xmpp_rand_nonce(ctx->rand, cnonce, sizeof(cnonce));
    hash_add(table, "cnonce", xmpp_strdup(ctx, cnonce));
    hash_add(table, "nc", xmpp_strdup(ctx, "00000001"));
-    if (hash_get(table, "qop") == NULL)
-        hash_add(table, "qop", xmpp_strdup(ctx, "auth"));
+    hash_add(table, "qop", xmpp_strdup(ctx, "auth"));
    value = xmpp_alloc(ctx, 5 + strlen(domain) + 1);
    memcpy(value, "xmpp/", 5);
    memcpy(value+5, domain, strlen(domain));
--- a/src/sha1.c
+++ b/src/sha1.c
@@ -197,9 +197,8 @@ void crypto_SHA1_Update(SHA1_CTX* context, const uint8_t* data,
    size_t i, j;

    j = (context->count[0] >> 3) & 63;
-    if ((context->count[0] += (uint32_t)len << 3) < ((uint32_t)len << 3))
-        context->count[1]++;
-    context->count[1] += (uint32_t)(len >> 29);
+    if ((context->count[0] += len << 3) < (len << 3)) context->count[1]++;
+    context->count[1] += (len >> 29);
    if ((j + len) > 63) {
        memcpy(&context->buffer[j], data, (i = 64-j));
        SHA1_Transform(context->state, context->buffer);
@@ -234,6 +233,7 @@ void crypto_SHA1_Final(SHA1_CTX* context, uint8_t* digest)
    }
    
    /* Wipe variables */
+    i = 0;
    memset(context->buffer, 0, 64);
    memset(context->state, 0, 20);
    memset(context->count, 0, 8);
--- a/src/sock.c
+++ b/src/sock.c
@@ -158,33 +158,38 @@ int sock_close(const sock_t sock)
 #endif
 }

-static int _sock_set_blocking_mode(sock_t sock, int blocking)
+int sock_set_blocking(const sock_t sock)
 {
 #ifdef _WIN32
-    u_long nonblock = blocking ? 0 : 1;
+    u_long block = 0;
+    return ioctlsocket(sock, FIONBIO, &block);
+#else
+    int rc;
+
+    rc = fcntl(sock, F_GETFL, NULL);
+    if (rc >= 0) {
+        rc = fcntl(sock, F_SETFL, rc & (~O_NONBLOCK));
+    }
+    return rc;
+#endif
+}
+
+int sock_set_nonblocking(const sock_t sock)
+{
+#ifdef _WIN32
+    u_long nonblock = 1;
    return ioctlsocket(sock, FIONBIO, &nonblock);
 #else
    int rc;

    rc = fcntl(sock, F_GETFL, NULL);
    if (rc >= 0) {
-        rc = blocking ? rc & (~O_NONBLOCK) : rc | O_NONBLOCK;
-        rc = fcntl(sock, F_SETFL, rc);
+        rc = fcntl(sock, F_SETFL, rc | O_NONBLOCK);
    }
    return rc;
 #endif
 }

-int sock_set_blocking(const sock_t sock)
-{
-    return _sock_set_blocking_mode(sock, 1);
-}
-
-int sock_set_nonblocking(const sock_t sock)
-{
-    return _sock_set_blocking_mode(sock, 0);
-}
-
 int sock_read(const sock_t sock, void * const buff, const size_t len)
 {
    return recv(sock, buff, len, 0);
--- a/src/stanza.c
+++ b/src/stanza.c
@@ -1,7 +1,7 @@
 /* stanza.c
 ** strophe XMPP client library -- XMPP stanza object and utilities
 **
-** Copyright (C) 2005-2009 Collecta, Inc.
+** Copyright (C) 2005-2009 Collecta, Inc. 
 **
 **  This software is provided AS-IS with no warranty, either express
 **  or implied.
@@ -40,15 +40,15 @@ xmpp_stanza_t *xmpp_stanza_new(xmpp_ctx_t *ctx)

    stanza = xmpp_alloc(ctx, sizeof(xmpp_stanza_t));
    if (stanza != NULL) {
-        stanza->ref = 1;
-        stanza->ctx = ctx;
-        stanza->type = XMPP_STANZA_UNKNOWN;
-        stanza->prev = NULL;
-        stanza->next = NULL;
-        stanza->children = NULL;
-        stanza->parent = NULL;
-        stanza->data = NULL;
-        stanza->attributes = NULL;
+	stanza->ref = 1;
+	stanza->ctx = ctx;
+	stanza->type = XMPP_STANZA_UNKNOWN;
+	stanza->prev = NULL;
+	stanza->next = NULL;
+	stanza->children = NULL;
+	stanza->parent = NULL;
+	stanza->data = NULL;
+	stanza->attributes = NULL;
    }

    return stanza; 
@@ -121,27 +121,27 @@ xmpp_stanza_t *xmpp_stanza_copy(const xmpp_stanza_t * const stanza)
    copy->type = stanza->type;

    if (stanza->data) {
-        copy->data = xmpp_strdup(stanza->ctx, stanza->data);
-        if (!copy->data) goto copy_error;
+	copy->data = xmpp_strdup(stanza->ctx, stanza->data);
+	if (!copy->data) goto copy_error;
    }

    if (stanza->attributes) {
-        if (_stanza_copy_attributes(copy, stanza) == -1)
+	if (_stanza_copy_attributes(copy, stanza) == -1)
            goto copy_error;
    }

    tail = copy->children;
    for (child = stanza->children; child; child = child->next) {
-        copychild = xmpp_stanza_copy(child);
-        if (!copychild) goto copy_error;
-        copychild->parent = copy;
+	copychild = xmpp_stanza_copy(child);
+	if (!copychild) goto copy_error;
+	copychild->parent = copy;

-        if (tail) {
-            copychild->prev = tail;
-            tail->next = copychild;
-        } else
-            copy->children = copychild;
-        tail = copychild;
+	if (tail) {
+	    copychild->prev = tail;
+	    tail->next = copychild;
+	} else
+	    copy->children = copychild;
+	tail = copychild;
    }

    return copy;
@@ -153,7 +153,7 @@ copy_error:
 }

 /** Release a stanza object and all of its children.
- *  This function releases a stanza object and potentially all of its
+ *  This function releases a stanza object and potentially all of its 
 *  children, which may cause the object(s) to be freed.
 *
 *  @param stanza a Strophe stanza object
@@ -169,38 +169,25 @@ int xmpp_stanza_release(xmpp_stanza_t * const stanza)

    /* release stanza */
    if (stanza->ref > 1)
-        stanza->ref--;
+	stanza->ref--;
    else {
-        /* release all children */
-        child = stanza->children;
-        while (child) {
-            tchild = child;
-            child = child->next;
-            xmpp_stanza_release(tchild);
-        }
+	/* release all children */
+	child = stanza->children;
+	while (child) {
+	    tchild = child;
+	    child = child->next;
+	    xmpp_stanza_release(tchild);
+	}

-        if (stanza->attributes) hash_release(stanza->attributes);
-        if (stanza->data) xmpp_free(stanza->ctx, stanza->data);
-        xmpp_free(stanza->ctx, stanza);
-        released = 1;
+	if (stanza->attributes) hash_release(stanza->attributes);
+	if (stanza->data) xmpp_free(stanza->ctx, stanza->data);
+	xmpp_free(stanza->ctx, stanza);
+	released = 1;
    }

    return released;
 }

-/** Get the strophe context that the stanza is associated with.
- *
- *  @param stanza a Strophe stanza object
- *
- *  @return a Strophe context
- *
- *  @ingroup Stanza
- */
-xmpp_ctx_t *xmpp_stanza_get_context(const xmpp_stanza_t * const stanza)
-{
-    return stanza->ctx;
-}
-
 /** Determine if a stanza is a text node.
 *  
 *  @param stanza a Strophe stanza object
@@ -287,17 +274,17 @@ static char *_escape_xml(xmpp_ctx_t * const ctx, char *text)

 /* small helper function */
 static void _render_update(int *written, const int length,
-                           const int lastwrite,
-                           size_t *left, char **ptr)
+			   const int lastwrite,
+			   size_t *left, char **ptr)
 {
    *written += lastwrite;

    if (*written >= length) {
-        *left = 0;
-        *ptr = NULL;
+	*left = 0;
+	*ptr = NULL;
    } else {
-        *left -= lastwrite;
-        *ptr = &(*ptr)[lastwrite];
+	*left -= lastwrite;
+	*ptr = &(*ptr)[lastwrite];
    }
 }

@@ -307,7 +294,7 @@ static void _render_update(int *written, const int length,
 * and return values > buflen indicate buffer was not large enough
 */
 static int _render_stanza_recursive(xmpp_stanza_t *stanza,
-                             char * const buf, size_t const buflen)
+			     char * const buf, size_t const buflen)
 {
    char *ptr = buf;
    size_t left = buflen;
@@ -322,86 +309,80 @@ static int _render_stanza_recursive(xmpp_stanza_t *stanza,
    if (stanza->type == XMPP_STANZA_UNKNOWN) return XMPP_EINVOP;

    if (stanza->type == XMPP_STANZA_TEXT) {
-        if (!stanza->data) return XMPP_EINVOP;
+	if (!stanza->data) return XMPP_EINVOP;

-        tmp = _escape_xml(stanza->ctx, stanza->data);
-        if (tmp == NULL) return XMPP_EMEM;
-        ret = xmpp_snprintf(ptr, left, "%s", tmp);
-        xmpp_free(stanza->ctx, tmp);
-        if (ret < 0) return XMPP_EMEM;
-        _render_update(&written, buflen, ret, &left, &ptr);
+	tmp = _escape_xml(stanza->ctx, stanza->data);
+	if (tmp == NULL) return XMPP_EMEM;
+	ret = xmpp_snprintf(ptr, left, "%s", tmp);
+	xmpp_free(stanza->ctx, tmp);
+	if (ret < 0) return XMPP_EMEM;
+	_render_update(&written, buflen, ret, &left, &ptr);
    } else { /* stanza->type == XMPP_STANZA_TAG */
-        if (!stanza->data) return XMPP_EINVOP;
+	if (!stanza->data) return XMPP_EINVOP;

-        /* write beginning of tag and attributes */
-        ret = xmpp_snprintf(ptr, left, "<%s", stanza->data);
-        if (ret < 0) return XMPP_EMEM;
-        _render_update(&written, buflen, ret, &left, &ptr);
+	/* write beginning of tag and attributes */
+	ret = xmpp_snprintf(ptr, left, "<%s", stanza->data);
+	if (ret < 0) return XMPP_EMEM;
+	_render_update(&written, buflen, ret, &left, &ptr);

-        if (stanza->attributes && hash_num_keys(stanza->attributes) > 0) {
-            iter = hash_iter_new(stanza->attributes);
-            while ((key = hash_iter_next(iter))) {
-                if (!strcmp(key, "xmlns")) {
-                    /* don't output namespace if parent stanza is the same */
-                    if (stanza->parent &&
-                        stanza->parent->attributes &&
-                        hash_get(stanza->parent->attributes, key) &&
-                        !strcmp((char*)hash_get(stanza->attributes, key),
-                            (char*)hash_get(stanza->parent->attributes, key)))
-                        continue;
-                    /* or if this is the stream namespace */
-                    if (!stanza->parent &&
-                        !strcmp((char*)hash_get(stanza->attributes, key),
-                            XMPP_NS_CLIENT))
-                        continue;
-                }
-                tmp = _escape_xml(stanza->ctx,
-                    (char *)hash_get(stanza->attributes, key));
-                if (tmp == NULL) {
-                    hash_iter_release(iter);
-                    return XMPP_EMEM;
-                }
-                ret = xmpp_snprintf(ptr, left, " %s=\"%s\"", key, tmp);
-                xmpp_free(stanza->ctx, tmp);
-                if (ret < 0) {
-                    hash_iter_release(iter);
-                    return XMPP_EMEM;
-                }
-                _render_update(&written, buflen, ret, &left, &ptr);
-            }
-            hash_iter_release(iter);
-        }
+	if (stanza->attributes && hash_num_keys(stanza->attributes) > 0) {
+	    iter = hash_iter_new(stanza->attributes);
+	    while ((key = hash_iter_next(iter))) {
+		if (!strcmp(key, "xmlns")) {
+		    /* don't output namespace if parent stanza is the same */
+		    if (stanza->parent &&
+			stanza->parent->attributes &&
+			hash_get(stanza->parent->attributes, key) &&
+			!strcmp((char*)hash_get(stanza->attributes, key),
+			    (char*)hash_get(stanza->parent->attributes, key)))
+			continue;
+		    /* or if this is the stream namespace */
+		    if (!stanza->parent &&
+			!strcmp((char*)hash_get(stanza->attributes, key),
+			    XMPP_NS_CLIENT))
+			continue;
+		}
+		tmp = _escape_xml(stanza->ctx,
+		    (char *)hash_get(stanza->attributes, key));
+		if (tmp == NULL) return XMPP_EMEM;
+		ret = xmpp_snprintf(ptr, left, " %s=\"%s\"", key, tmp);
+		xmpp_free(stanza->ctx, tmp);
+		if (ret < 0) return XMPP_EMEM;
+		_render_update(&written, buflen, ret, &left, &ptr);
+	    }
+	    hash_iter_release(iter);
+	}

-        if (!stanza->children) {
-            /* write end if singleton tag */
-            ret = xmpp_snprintf(ptr, left, "/>");
-            if (ret < 0) return XMPP_EMEM;
-            _render_update(&written, buflen, ret, &left, &ptr);
-        } else {
-            /* this stanza has child stanzas */
+	if (!stanza->children) {
+	    /* write end if singleton tag */
+	    ret = xmpp_snprintf(ptr, left, "/>");
+	    if (ret < 0) return XMPP_EMEM;
+	    _render_update(&written, buflen, ret, &left, &ptr);
+	} else {
+	    /* this stanza has child stanzas */

-            /* write end of start tag */
-            ret = xmpp_snprintf(ptr, left, ">");
-            if (ret < 0) return XMPP_EMEM;
-            _render_update(&written, buflen, ret, &left, &ptr);
+	    /* write end of start tag */
+	    ret = xmpp_snprintf(ptr, left, ">");
+	    if (ret < 0) return XMPP_EMEM;
+	    _render_update(&written, buflen, ret, &left, &ptr);
+	    
+	    /* iterate and recurse over child stanzas */
+	    child = stanza->children;
+	    while (child) {
+		ret = _render_stanza_recursive(child, ptr, left);
+		if (ret < 0) return ret;

-            /* iterate and recurse over child stanzas */
-            child = stanza->children;
-            while (child) {
-                ret = _render_stanza_recursive(child, ptr, left);
-                if (ret < 0) return ret;
+		_render_update(&written, buflen, ret, &left, &ptr);

-                _render_update(&written, buflen, ret, &left, &ptr);
+		child = child->next;
+	    }

-                child = child->next;
-            }
-
-            /* write end tag */
-            ret = xmpp_snprintf(ptr, left, "</%s>", stanza->data);
-            if (ret < 0) return XMPP_EMEM;
-
-            _render_update(&written, buflen, ret, &left, &ptr);
-        }
+	    /* write end tag */
+	    ret = xmpp_snprintf(ptr, left, "</%s>", stanza->data);
+	    if (ret < 0) return XMPP_EMEM;
+	    
+	    _render_update(&written, buflen, ret, &left, &ptr);
+	}
    }

    return written;
@@ -434,37 +415,27 @@ int xmpp_stanza_to_text(xmpp_stanza_t *stanza,
    length = 1024;
    buffer = xmpp_alloc(stanza->ctx, length);
    if (!buffer) {
-        *buf = NULL;
-        *buflen = 0;
-        return XMPP_EMEM;
+	*buf = NULL;
+	*buflen = 0;
+	return XMPP_EMEM;
    }

    ret = _render_stanza_recursive(stanza, buffer, length);
-    if (ret < 0) {
-        xmpp_free(stanza->ctx, buffer);
-        *buf = NULL;
-        *buflen = 0;
-        return ret;
-    }
+    if (ret < 0) return ret;

    if ((size_t)ret > length - 1) {
-        tmp = xmpp_realloc(stanza->ctx, buffer, ret + 1);
-        if (!tmp) {
-            xmpp_free(stanza->ctx, buffer);
-            *buf = NULL;
-            *buflen = 0;
-            return XMPP_EMEM;
-        }
-        length = ret + 1;
-        buffer = tmp;
+	tmp = xmpp_realloc(stanza->ctx, buffer, ret + 1);
+	if (!tmp) {
+	    xmpp_free(stanza->ctx, buffer);
+	    *buf = NULL;
+	    *buflen = 0;
+	    return XMPP_EMEM;
+	}
+	length = ret + 1;
+	buffer = tmp;

-        ret = _render_stanza_recursive(stanza, buffer, length);
-        if ((size_t)ret > length - 1) {
-            xmpp_free(stanza->ctx, buffer);
-            *buf = NULL;
-            *buflen = 0;
-            return XMPP_EMEM;
-        }
+	ret = _render_stanza_recursive(stanza, buffer, length);
+	if ((size_t)ret > length - 1) return XMPP_EMEM;
    }
    
    buffer[length - 1] = 0;
@@ -486,7 +457,7 @@ int xmpp_stanza_to_text(xmpp_stanza_t *stanza,
 *  @ingroup Stanza
 */
 int xmpp_stanza_set_name(xmpp_stanza_t *stanza, 
-                         const char * const name)
+			 const char * const name)
 {
    if (stanza->type == XMPP_STANZA_TEXT) return XMPP_EINVOP;

@@ -525,7 +496,7 @@ const char *xmpp_stanza_get_name(xmpp_stanza_t * const stanza)
 int xmpp_stanza_get_attribute_count(xmpp_stanza_t * const stanza)
 {
    if (stanza->attributes == NULL) {
-        return 0;
+	return 0;
    }

    return hash_num_keys(stanza->attributes);
@@ -546,30 +517,30 @@ int xmpp_stanza_get_attribute_count(xmpp_stanza_t * const stanza)
 *  @ingroup Stanza
 */
 int xmpp_stanza_get_attributes(xmpp_stanza_t * const stanza,
-                               const char **attr, int attrlen)
+			       const char **attr, int attrlen)
 {
    hash_iterator_t *iter;
    const char *key;
    int num = 0;

    if (stanza->attributes == NULL) {
-        return 0;
+	return 0;
    }

    iter = hash_iter_new(stanza->attributes);
    while ((key = hash_iter_next(iter)) != NULL && attrlen) {
-        attr[num++] = key;
-        attrlen--;
-        if (attrlen == 0) {
-            hash_iter_release(iter);
-            return num;
-        }
-        attr[num++] = hash_get(stanza->attributes, key);
-        attrlen--;
-        if (attrlen == 0) {
-            hash_iter_release(iter);
-            return num;
-        }
+	attr[num++] = key;
+	attrlen--;
+	if (attrlen == 0) {
+	    hash_iter_release(iter);
+	    return num;
+	}
+	attr[num++] = hash_get(stanza->attributes, key);
+	attrlen--;
+	if (attrlen == 0) {
+	    hash_iter_release(iter);
+	    return num;
+	}
    }

    hash_iter_release(iter);
@@ -587,8 +558,8 @@ int xmpp_stanza_get_attributes(xmpp_stanza_t * const stanza,
 *  @ingroup Stanza
 */
 int xmpp_stanza_set_attribute(xmpp_stanza_t * const stanza,
-                              const char * const key,
-                              const char * const value)
+			      const char * const key,
+			      const char * const value)
 {
    char *val;
    int rc;
@@ -596,12 +567,13 @@ int xmpp_stanza_set_attribute(xmpp_stanza_t * const stanza,
    if (stanza->type != XMPP_STANZA_TAG) return XMPP_EINVOP;

    if (!stanza->attributes) {
-        stanza->attributes = hash_new(stanza->ctx, 8, xmpp_free);
-        if (!stanza->attributes) return XMPP_EMEM;
+	stanza->attributes = hash_new(stanza->ctx, 8, xmpp_free);
+	if (!stanza->attributes) return XMPP_EMEM;
    }

    val = xmpp_strdup(stanza->ctx, value);
    if (!val) {
+        hash_release(stanza->attributes);
        return XMPP_EMEM;
    }

@@ -626,50 +598,11 @@ int xmpp_stanza_set_attribute(xmpp_stanza_t * const stanza,
 *  @ingroup Stanza
 */
 int xmpp_stanza_set_ns(xmpp_stanza_t * const stanza,
-                       const char * const ns)
+		       const char * const ns)
 {
    return xmpp_stanza_set_attribute(stanza, "xmlns", ns);
 }

-/** Add a child stanza to a stanza object.
- *  If do_clone is TRUE, user keeps reference to the child stanza and must call
- *  xmpp_stanza_release() to release the reference. If do_clone is FALSE, user
- *  transfers ownership and must not neither call xmpp_stanza_release() for
- *  the child stanza nor use it.
- *
- *  @param stanza a Strophe stanza object
- *  @param child the child stanza object
- *  @param do_clone TRUE to increase ref count of child (default for
- *                  xmpp_stanza_add_child())
- *
- *  @return XMPP_EOK (0) on success or a number less than 0 on failure
- *
- *  @ingroup Stanza
- */
-int xmpp_stanza_add_child_ex(xmpp_stanza_t *stanza, xmpp_stanza_t *child,
-                             int do_clone)
-{
-    xmpp_stanza_t *s;
-
-    if (do_clone) {
-        /* get a reference to the child */
-        xmpp_stanza_clone(child);
-    }
-
-    child->parent = stanza;
-
-    if (!stanza->children)
-        stanza->children = child;
-    else {
-        s = stanza->children;
-        while (s->next) s = s->next;
-        s->next = child;
-        child->prev = s;
-    }
-
-    return XMPP_EOK;
-}
-
 /** Add a child stanza to a stanza object.
 *  This function clones the child and appends it to the stanza object's
 *  children.
@@ -683,7 +616,23 @@ int xmpp_stanza_add_child_ex(xmpp_stanza_t *stanza, xmpp_stanza_t *child,
 */
 int xmpp_stanza_add_child(xmpp_stanza_t *stanza, xmpp_stanza_t *child)
 {
-    return xmpp_stanza_add_child_ex(stanza, child, 1);
+    xmpp_stanza_t *s;
+
+    /* get a reference to the child */
+    xmpp_stanza_clone(child);
+
+    child->parent = stanza;
+
+    if (!stanza->children)
+	stanza->children = child;
+    else {
+	s = stanza->children;
+	while (s->next) s = s->next;
+	s->next = child;
+	child->prev = s;
+    }
+
+    return XMPP_EOK;
 }

 /** Set the text data for a text stanza.
@@ -700,7 +649,7 @@ int xmpp_stanza_add_child(xmpp_stanza_t *stanza, xmpp_stanza_t *child)
 *  @ingroup Stanza
 */
 int xmpp_stanza_set_text(xmpp_stanza_t *stanza,
-                         const char * const text)
+			 const char * const text)
 {
    if (stanza->type == XMPP_STANZA_TAG) return XMPP_EINVOP;
    
@@ -727,8 +676,8 @@ int xmpp_stanza_set_text(xmpp_stanza_t *stanza,
 *  @ingroup Stanza
 */
 int xmpp_stanza_set_text_with_size(xmpp_stanza_t *stanza,
-                                   const char * const text,
-                                   const size_t size)
+				   const char * const text,
+				   const size_t size)
 {
    if (stanza->type == XMPP_STANZA_TAG) return XMPP_EINVOP;

@@ -831,14 +780,14 @@ const char *xmpp_stanza_get_from(xmpp_stanza_t * const stanza)
 *  @ingroup Stanza
 */
 xmpp_stanza_t *xmpp_stanza_get_child_by_name(xmpp_stanza_t * const stanza, 
-                                             const char * const name)
+					     const char * const name)
 {
    xmpp_stanza_t *child;
    
    for (child = stanza->children; child; child = child->next) {
-        if (child->type == XMPP_STANZA_TAG &&
-            (strcmp(name, xmpp_stanza_get_name(child)) == 0))
-            break;
+	if (child->type == XMPP_STANZA_TAG &&
+	    (strcmp(name, xmpp_stanza_get_name(child)) == 0))
+	    break;
    }

    return child;
@@ -857,53 +806,19 @@ xmpp_stanza_t *xmpp_stanza_get_child_by_name(xmpp_stanza_t * const stanza,
 *  @ingroup Stanza
 */
 xmpp_stanza_t *xmpp_stanza_get_child_by_ns(xmpp_stanza_t * const stanza,
-                                           const char * const ns)
+					   const char * const ns)
 {
    xmpp_stanza_t *child;
-    const char *child_ns;

    for (child = stanza->children; child; child = child->next) {
-        child_ns = xmpp_stanza_get_ns(child);
-        if (child_ns && strcmp(ns, child_ns) == 0)
-            break;
+	if (xmpp_stanza_get_ns(child) &&
+	    strcmp(ns, xmpp_stanza_get_ns(child)) == 0)
+	    break;
    }
    
    return child;
 }

-/** Get the first child of stanza with name and a given namespace.
- *  This function searches all the immediate children of stanza for a child
- *  stanza that matches the name and namespace provided.
- *  The first matching child is returned.
- *
- *  @param stanza a Strophe stanza object
- *  @param name a string with the name to match
- *  @param ns a string with the namespace to match
- *
- *  @return the matching child stanza object or NULL if no match was found
- *
- *  @ingroup Stanza
- */
-xmpp_stanza_t *xmpp_stanza_get_child_by_name_and_ns(xmpp_stanza_t * const stanza,
-                                             const char * const name,
-                                             const char * const ns)
-{
-    xmpp_stanza_t *child;
-    const char *child_ns;
-
-    for (child = stanza->children; child; child = child->next) {
-        if (child->type == XMPP_STANZA_TAG &&
-            (strcmp(name, xmpp_stanza_get_name(child)) == 0)) {
-            child_ns = xmpp_stanza_get_ns(child);
-            if (child_ns && strcmp(ns, child_ns) == 0) {
-                break;
-            }
-        }
-    }
-
-    return child;
-}
-
 /** Get the list of children.
 *  This function returns the first child of the stanza object.  The rest
 *  of the children can be obtained by calling xmpp_stanza_get_next() to
@@ -951,16 +866,16 @@ char *xmpp_stanza_get_text(xmpp_stanza_t * const stanza)
    char *text;

    if (stanza->type == XMPP_STANZA_TEXT) {
-        if (stanza->data)
-            return xmpp_strdup(stanza->ctx, stanza->data);
-        else
-            return NULL;
+	if (stanza->data)
+	    return xmpp_strdup(stanza->ctx, stanza->data);
+	else
+	    return NULL;
    }

    len = 0;
    for (child = stanza->children; child; child = child->next)
-        if (child->type == XMPP_STANZA_TEXT)
-            len += strlen(child->data);
+	if (child->type == XMPP_STANZA_TEXT)
+	    len += strlen(child->data);

    if (len == 0) return NULL;

@@ -969,11 +884,11 @@ char *xmpp_stanza_get_text(xmpp_stanza_t * const stanza)

    len = 0;
    for (child = stanza->children; child; child = child->next)
-        if (child->type == XMPP_STANZA_TEXT) {
-            clen = strlen(child->data);
-            memcpy(&text[len], child->data, clen);
-            len += clen;
-        }
+	if (child->type == XMPP_STANZA_TEXT) {
+	    clen = strlen(child->data);
+	    memcpy(&text[len], child->data, clen);
+	    len += clen;
+	}

    text[len] = 0;

@@ -996,7 +911,7 @@ char *xmpp_stanza_get_text(xmpp_stanza_t * const stanza)
 const char *xmpp_stanza_get_text_ptr(xmpp_stanza_t * const stanza)
 {
    if (stanza->type == XMPP_STANZA_TEXT)
-        return stanza->data;
+	return stanza->data;
    return NULL;
 }

@@ -1013,7 +928,7 @@ const char *xmpp_stanza_get_text_ptr(xmpp_stanza_t * const stanza)
 *  @ingroup Stanza
 */
 int xmpp_stanza_set_id(xmpp_stanza_t * const stanza,
-                       const char * const id)
+		       const char * const id)
 {
    return xmpp_stanza_set_attribute(stanza, "id", id);
 }
@@ -1030,7 +945,7 @@ int xmpp_stanza_set_id(xmpp_stanza_t * const stanza,
 *  @ingroup Stanza
 */
 int xmpp_stanza_set_type(xmpp_stanza_t * const stanza,
-                         const char * const type)
+			 const char * const type)
 {
    return xmpp_stanza_set_attribute(stanza, "type", type);
 }
@@ -1086,10 +1001,10 @@ const char *xmpp_stanza_get_attribute(xmpp_stanza_t * const stanza,
                                      const char * const name)
 {
    if (stanza->type != XMPP_STANZA_TAG)
-        return NULL;
+	return NULL;
    
    if (!stanza->attributes)
-        return NULL;
+	return NULL;

    return hash_get(stanza->attributes, name);
 }
@@ -1303,122 +1218,3 @@ xmpp_stanza_t *xmpp_presence_new(xmpp_ctx_t *ctx)
 {
    return _stanza_new_with_attrs(ctx, "presence", NULL, NULL, NULL);
 }
-
-/** Create an <stream:error/> stanza object with given type and error text.
- *  The error text is optional and may be NULL.
- *
- *  @param ctx a Strophe context object
- *  @param type enum of xmpp_error_type_t
- *  @param text content of a 'text'
- *
- *  @return a new Strophe stanza object
- *
- *  @todo Handle errors in this function
- *
- *  @ingroup Stanza
- */
-xmpp_stanza_t *xmpp_error_new(xmpp_ctx_t *ctx, xmpp_error_type_t const type,
-                              const char * const text)
-{
-    xmpp_stanza_t *error = _stanza_new_with_attrs(ctx, "stream:error", NULL, NULL, NULL);
-    xmpp_stanza_t *error_type = xmpp_stanza_new(ctx);
-
-    switch(type) {
-        case XMPP_SE_BAD_FORMAT:
-            xmpp_stanza_set_name(error_type, "bad-format");
-            break;
-        case XMPP_SE_BAD_NS_PREFIX:
-            xmpp_stanza_set_name(error_type, "bad-namespace-prefix");
-            break;
-        case XMPP_SE_CONFLICT:
-            xmpp_stanza_set_name(error_type, "conflict");
-            break;
-        case XMPP_SE_CONN_TIMEOUT:
-            xmpp_stanza_set_name(error_type, "connection-timeout");
-            break;
-        case XMPP_SE_HOST_GONE:
-            xmpp_stanza_set_name(error_type, "host-gone");
-            break;
-        case XMPP_SE_HOST_UNKNOWN:
-            xmpp_stanza_set_name(error_type, "host-unknown");
-            break;
-        case XMPP_SE_IMPROPER_ADDR:
-            xmpp_stanza_set_name(error_type, "improper-addressing");
-            break;
-        case XMPP_SE_INTERNAL_SERVER_ERROR:
-            xmpp_stanza_set_name(error_type, "internal-server-error");
-            break;
-        case XMPP_SE_INVALID_FROM:
-            xmpp_stanza_set_name(error_type, "invalid-from");
-            break;
-        case XMPP_SE_INVALID_ID:
-            xmpp_stanza_set_name(error_type, "invalid-id");
-            break;
-        case XMPP_SE_INVALID_NS:
-            xmpp_stanza_set_name(error_type, "invalid-namespace");
-            break;
-        case XMPP_SE_INVALID_XML:
-            xmpp_stanza_set_name(error_type, "invalid-xml");
-            break;
-        case XMPP_SE_NOT_AUTHORIZED:
-            xmpp_stanza_set_name(error_type, "not-authorized");
-            break;
-        case XMPP_SE_POLICY_VIOLATION:
-            xmpp_stanza_set_name(error_type, "policy-violation");
-            break;
-        case XMPP_SE_REMOTE_CONN_FAILED:
-            xmpp_stanza_set_name(error_type, "remote-connection-failed");
-            break;
-        case XMPP_SE_RESOURCE_CONSTRAINT:
-            xmpp_stanza_set_name(error_type, "resource-constraint");
-            break;
-        case XMPP_SE_RESTRICTED_XML:
-            xmpp_stanza_set_name(error_type, "restricted-xml");
-            break;
-        case XMPP_SE_SEE_OTHER_HOST:
-            xmpp_stanza_set_name(error_type, "see-other-host");
-            break;
-        case XMPP_SE_SYSTEM_SHUTDOWN:
-            xmpp_stanza_set_name(error_type, "system-shutdown");
-            break;
-        case XMPP_SE_UNDEFINED_CONDITION:
-            xmpp_stanza_set_name(error_type, "undefined-condition");
-            break;
-        case XMPP_SE_UNSUPPORTED_ENCODING:
-            xmpp_stanza_set_name(error_type, "unsupported-encoding");
-            break;
-        case XMPP_SE_UNSUPPORTED_STANZA_TYPE:
-            xmpp_stanza_set_name(error_type, "unsupported-stanza-type");
-            break;
-        case XMPP_SE_UNSUPPORTED_VERSION:
-            xmpp_stanza_set_name(error_type, "unsupported-version");
-            break;
-        case XMPP_SE_XML_NOT_WELL_FORMED:
-            xmpp_stanza_set_name(error_type, "xml-not-well-formed");
-            break;
-        default:
-            xmpp_stanza_set_name(error_type, "internal-server-error");
-            break;
-    }
-
-    xmpp_stanza_set_ns(error_type, XMPP_NS_STREAMS_IETF);
-    xmpp_stanza_add_child(error, error_type);
-    xmpp_stanza_release(error_type);
-
-    if (text) {
-        xmpp_stanza_t *error_text = xmpp_stanza_new(ctx);
-        xmpp_stanza_t *content = xmpp_stanza_new(ctx);
-
-        xmpp_stanza_set_name(error_text, "text");
-        xmpp_stanza_set_ns(error_text, XMPP_NS_STREAMS_IETF);
-
-        xmpp_stanza_set_text(content, text);
-        xmpp_stanza_add_child(error_text, content);
-        xmpp_stanza_release(content);
-
-        xmpp_stanza_add_child(error, error_text);
-        xmpp_stanza_release(error_text);
-    }
-
-    return error;
-}
--- a/src/tls_openssl.c
+++ b/src/tls_openssl.c
@@ -31,22 +31,6 @@
 #include "tls.h"
 #include "sock.h"

-/*
- * Redefine OPENSSL_VERSION_NUMBER for LibreSSL.
- * LibreSSL and OpenSSL use different and incompatible version schemes. Solve
- * this issue in the way how nginx project did.
- */
-#if (defined LIBRESSL_VERSION_NUMBER && OPENSSL_VERSION_NUMBER == 0x20000000L)
-#undef OPENSSL_VERSION_NUMBER
-#if (LIBRESSL_VERSION_NUMBER >= 0x2080000fL)
-#define OPENSSL_VERSION_NUMBER  0x1010000fL
-#elif (LIBRESSL_VERSION_NUMBER >= 0x2070000fL)
-#define OPENSSL_VERSION_NUMBER  0x1000200fL
-#else
-#define OPENSSL_VERSION_NUMBER  0x1000107fL
-#endif
-#endif
-
 struct _tls {
    xmpp_ctx_t *ctx;
    sock_t sock;
@@ -64,7 +48,6 @@ enum {
 static void _tls_sock_wait(tls_t *tls, int error);
 static void _tls_set_error(tls_t *tls, int error);
 static void _tls_log_error(xmpp_ctx_t *ctx);
-static void _tls_dump_cert_info(tls_t *tls);

 void tls_initialize(void)
 {
@@ -110,19 +93,11 @@ tls_t *tls_new(xmpp_conn_t *conn)

    if (tls) {
        int ret;
-#if OPENSSL_VERSION_NUMBER >= 0x10002000L
-        /* Hostname verification is supported in OpenSSL 1.0.2 and newer. */
-        X509_VERIFY_PARAM *param;
-#endif
        memset(tls, 0, sizeof(*tls));

        tls->ctx = conn->ctx;
        tls->sock = conn->sock;
-#if OPENSSL_VERSION_NUMBER < 0x10100000L
        tls->ssl_ctx = SSL_CTX_new(SSLv23_client_method());
-#else
-        tls->ssl_ctx = SSL_CTX_new(TLS_client_method());
-#endif
        if (tls->ssl_ctx == NULL)
            goto err;

@@ -136,34 +111,18 @@ tls_t *tls_new(xmpp_conn_t *conn)

        SSL_CTX_set_client_cert_cb(tls->ssl_ctx, NULL);
        SSL_CTX_set_mode(tls->ssl_ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
-
-        ret = SSL_CTX_set_default_verify_paths(tls->ssl_ctx);
-        if (ret == 0 && !conn->tls_trust) {
-            /*
-             * Returns 1 on success and 0 on failure. A missing default
-             * location is still treated as a success.
-             * Ignore errors when XMPP_CONN_FLAG_TRUST_TLS is set.
-             */
-            xmpp_error(tls->ctx, "tls",
-                       "SSL_CTX_set_default_verify_paths() failed");
-            goto err_free_ctx;
-        }
+        SSL_CTX_set_default_verify_paths(tls->ssl_ctx);

        tls->ssl = SSL_new(tls->ssl_ctx);
        if (tls->ssl == NULL)
            goto err_free_ctx;

-#if OPENSSL_VERSION_NUMBER >= 0x0908060L && !defined(OPENSSL_NO_TLSEXT)
-        /* Enable SNI. */
-        SSL_set_tlsext_host_name(tls->ssl, conn->domain);
-#endif
-
        /* Trust server's certificate when user sets the flag explicitly. */
        mode = conn->tls_trust ? SSL_VERIFY_NONE : SSL_VERIFY_PEER;
        SSL_set_verify(tls->ssl, mode, 0);
 #if OPENSSL_VERSION_NUMBER >= 0x10002000L
        /* Hostname verification is supported in OpenSSL 1.0.2 and newer. */
-        param = SSL_get0_param(tls->ssl);
+        X509_VERIFY_PARAM *param = SSL_get0_param(tls->ssl);

        /*
         * Allow only complete wildcards.  RFC 6125 discourages wildcard usage
@@ -229,7 +188,6 @@ int tls_start(tls_t *tls)
    x509_res = SSL_get_verify_result(tls->ssl);
    xmpp_debug(tls->ctx, "tls", "Certificate verification %s",
               x509_res == X509_V_OK ? "passed" : "FAILED");
-    _tls_dump_cert_info(tls);

    _tls_set_error(tls, error);
    return ret <= 0 ? 0 : 1;
@@ -241,11 +199,6 @@ int tls_stop(tls_t *tls)
    int error;
    int ret;

-    /* According to OpenSSL.org, we must not call SSL_shutdown(3)
-       if a previous fatal error has occurred on a connection. */
-    if (tls->lasterror == SSL_ERROR_SYSCALL || tls->lasterror == SSL_ERROR_SSL)
-        return 1;
-
    while (1) {
        ++retries;
        ret = SSL_shutdown(tls->ssl);
@@ -256,14 +209,6 @@ int tls_stop(tls_t *tls)
        }
        _tls_sock_wait(tls, error);
    }
-    if (error == SSL_ERROR_SYSCALL && errno == 0) {
-        /*
-         * Handle special case when peer closes connection instead of
-         * proper shutdown.
-         */
-        error = 0;
-        ret = 1;
-    }
    _tls_set_error(tls, error);

    return ret <= 0 ? 0 : 1;
@@ -315,8 +260,6 @@ static void _tls_sock_wait(tls_t *tls, int error)
    int nfds;
    int ret;

-    if (error == SSL_ERROR_NONE) return;
-
    FD_ZERO(&rfds);
    FD_ZERO(&wfds);
    if (error == SSL_ERROR_WANT_READ)
@@ -335,7 +278,6 @@ static void _tls_sock_wait(tls_t *tls, int error)
 static void _tls_set_error(tls_t *tls, int error)
 {
    if (error != 0 && !tls_is_recoverable(error)) {
-        xmpp_debug(tls->ctx, "tls", "error=%d errno=%d", error, errno);
        _tls_log_error(tls->ctx);
    }
    tls->lasterror = error;
@@ -354,26 +296,3 @@ static void _tls_log_error(xmpp_ctx_t *ctx)
        }
    } while (e != 0);
 }
-
-static void _tls_dump_cert_info(tls_t *tls)
-{
-    X509 *cert;
-    char *name;
-
-    cert = SSL_get_peer_certificate(tls->ssl);
-    if (cert == NULL)
-        xmpp_debug(tls->ctx, "tls", "Certificate was not presented by peer");
-    else {
-        name = X509_NAME_oneline(X509_get_subject_name(cert), NULL, 0);
-        if (name != NULL) {
-            xmpp_debug(tls->ctx, "tls", "Subject=%s", name);
-            OPENSSL_free(name);
-        }
-        name = X509_NAME_oneline(X509_get_issuer_name(cert), NULL, 0);
-        if (name != NULL) {
-            xmpp_debug(tls->ctx, "tls", "Issuer=%s", name);
-            OPENSSL_free(name);
-        }
-        X509_free(cert);
-    }
-}
--- a/src/tls_schannel.c
+++ b/src/tls_schannel.c
@@ -255,18 +255,10 @@ int tls_start(tls_t *tls)
 					  NULL, 0, &(tls->hctxt), &sbdout,
 					  &ctxtattr, NULL);

-    unsigned char *p = sbin[0].pvBuffer;
-    int len = 0;
-
    while (ret == SEC_I_CONTINUE_NEEDED
-	   || ret == SEC_I_INCOMPLETE_CREDENTIALS
-     || ret == SEC_E_INCOMPLETE_MESSAGE) {
-	int inbytes = 0;
-
-  if (ret != SEC_E_INCOMPLETE_MESSAGE) {
-    len = 0;
-    p = sbin[0].pvBuffer;
-  }
+	   || ret == SEC_I_INCOMPLETE_CREDENTIALS) {
+	unsigned char *p = sbin[0].pvBuffer;
+	int len = 0, inbytes = 0;

 	if (sbdout.pBuffers[0].cbBuffer) {
 	    unsigned char *writebuff = sbdout.pBuffers[0].pvBuffer;
--- a/src/util.c
+++ b/src/util.c
@@ -86,12 +86,7 @@ char *xmpp_strtok_r(char *s, const char *delim, char **saveptr)
 */
 uint64_t time_stamp(void)
 {
-#if defined(_XBOX_ONE)
-    uint64_t SystemTime;
-    GetSystemTimeAsFileTime((FILETIME*)&SystemTime);
-    /* Convert 100 nanosec ticks to milliseconds */
-    return (SystemTime / 10000);
-#elif defined(_WIN32)
+#ifdef _WIN32
    return timeGetTime();
 #else
    struct timeval tv;
--- a/strophe.h
+++ b/strophe.h
@@ -71,14 +71,6 @@ extern "C" {
 *  Namespace definition for 'jabber:iq:roster'.
 */
 #define XMPP_NS_ROSTER "jabber:iq:roster"
-/** @def XMPP_NS_REGISTER
- *  Namespace definition for 'jabber:iq:register'.
- */
-#define XMPP_NS_REGISTER "jabber:iq:register"
-/** @def XMPP_NS_SM
- *  Namespace definition for Stream Management.
- */
-#define XMPP_NS_SM "urn:xmpp:sm:3"

 /* error defines */
 /** @def XMPP_EOK
@@ -177,10 +169,6 @@ typedef struct _xmpp_stanza_t xmpp_stanza_t;
 *  Trust server's certificate even if it is invalid.
 */
 #define XMPP_CONN_FLAG_TRUST_TLS     (1UL << 3)
-/** @def XMPP_CONN_FLAG_LEGACY_AUTH
- *  Enable legacy authentication support.
- */
-#define XMPP_CONN_FLAG_LEGACY_AUTH   (1UL << 4)

 /* connect callback */
 typedef enum {
@@ -229,7 +217,6 @@ typedef void (*xmpp_conn_handler)(xmpp_conn_t * const conn,
 				  xmpp_stream_error_t * const stream_error,
 				  void * const userdata);

-void xmpp_send_error(xmpp_conn_t * const conn, xmpp_error_type_t const type, char * const text);
 xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t * const ctx);
 xmpp_conn_t *xmpp_conn_clone(xmpp_conn_t * const conn);
 int xmpp_conn_release(xmpp_conn_t * const conn);
@@ -245,9 +232,6 @@ xmpp_ctx_t *xmpp_conn_get_context(xmpp_conn_t * const conn);
 void xmpp_conn_disable_tls(xmpp_conn_t * const conn);
 int xmpp_conn_is_secured(xmpp_conn_t * const conn);
 void xmpp_conn_set_keepalive(xmpp_conn_t * const conn, int timeout, int interval);
-int xmpp_conn_is_connecting(xmpp_conn_t * const conn);
-int xmpp_conn_is_connected(xmpp_conn_t * const conn);
-int xmpp_conn_is_disconnected(xmpp_conn_t * const conn);

 int xmpp_connect_client(xmpp_conn_t * const conn, 
 			  const char * const altdomain,
@@ -334,8 +318,6 @@ xmpp_stanza_t *xmpp_stanza_copy(const xmpp_stanza_t * const stanza);
 /* free a stanza object and it's contents */
 int xmpp_stanza_release(xmpp_stanza_t * const stanza);

-xmpp_ctx_t *xmpp_stanza_get_context(const xmpp_stanza_t * const stanza);
-
 int xmpp_stanza_is_text(xmpp_stanza_t * const stanza);
 int xmpp_stanza_is_tag(xmpp_stanza_t * const stanza);

@@ -348,13 +330,8 @@ xmpp_stanza_t *xmpp_stanza_get_child_by_name(xmpp_stanza_t * const stanza,
 					     const char * const name);
 xmpp_stanza_t *xmpp_stanza_get_child_by_ns(xmpp_stanza_t * const stanza,
 					   const char * const ns);
-xmpp_stanza_t *xmpp_stanza_get_child_by_name_and_ns(xmpp_stanza_t * const stanza,
-                                                    const char * const name,
-                                                    const char * const ns);
 xmpp_stanza_t *xmpp_stanza_get_next(xmpp_stanza_t * const stanza);
 int xmpp_stanza_add_child(xmpp_stanza_t *stanza, xmpp_stanza_t *child);
-int xmpp_stanza_add_child_ex(xmpp_stanza_t *stanza, xmpp_stanza_t *child,
-                             int do_clone);

 const char *xmpp_stanza_get_attribute(xmpp_stanza_t * const stanza,
 				      const char * const name);
@@ -404,8 +381,6 @@ int xmpp_message_set_body(xmpp_stanza_t *msg, const char * const text);
 xmpp_stanza_t *xmpp_iq_new(xmpp_ctx_t *ctx, const char * const type,
                           const char * const id);
 xmpp_stanza_t *xmpp_presence_new(xmpp_ctx_t *ctx);
-xmpp_stanza_t *xmpp_error_new(xmpp_ctx_t *ctx, xmpp_error_type_t const type,
-                              const char * const text);

 /* jid */

--- a/tests/test_hash.c
+++ b/tests/test_hash.c
@@ -16,19 +16,18 @@
 #include "strophe.h"
 #include "common.h"
 #include "hash.h"
-#include "test.h"

 #define TABLESIZE 100
 #define TESTSIZE 500

 /* static test data */
+const int nkeys = 5;
 const char *keys[] = {
  "foo", "bar", "baz", "quux", "xyzzy"
 };
 const char *values[] = {
  "wuzzle", "mug", "canonical", "rosebud", "lottery"
 };
-const int nkeys = ARRAY_SIZE(keys);

 int main(int argc, char **argv)
 {
@@ -59,7 +58,7 @@ int main(int argc, char **argv)
    }

    /* allocate a hash table */
-    table = hash_new(ctx, TABLESIZE, xmpp_free);
+    table = hash_new(ctx, TABLESIZE, NULL);
    if (table == NULL) {
 	/* table allocation failed! */
 	return 1;
@@ -67,7 +66,7 @@ int main(int argc, char **argv)

    /* test insertion */
    for (i = 0; i < nkeys; i++) {
-	err = hash_add(table, keys[i], xmpp_strdup(ctx, values[i]));
+	err = hash_add(table, keys[i], (void*)values[i]);
 	if (err) return err;
    }

@@ -79,7 +78,7 @@ int main(int argc, char **argv)

    /* test replacing old values */
    for (i = 0; i < nkeys; i++) {
-        err = hash_add(table, keys[0], xmpp_strdup(ctx, values[i]));
+        err = hash_add(table, keys[0], (void*)values[i]);
        if (err) return err;
        if (hash_num_keys(table) != nkeys) return 1;
        result = hash_get(table, keys[0]);
@@ -87,7 +86,7 @@ int main(int argc, char **argv)
        if (strcmp(result, values[i]) != 0) return 1;
    }
    /* restore value for the 1st key */
-    hash_add(table, keys[0], xmpp_strdup(ctx, values[0]));
+    hash_add(table, keys[0], (void*)values[0]);

    /* test cloning */
    clone = hash_clone(table);
--- a/tests/test_sha1.c
+++ b/tests/test_sha1.c
@@ -41,7 +41,7 @@ static void digest_to_hex(const uint8_t *digest, char *output)

 int main(int argc, char** argv)
 {
-    size_t k;
+    int k;
    SHA1_CTX context;
    uint8_t digest[20];
    char output[80];
--- a/tests/test_stanza.c
+++ b/tests/test_stanza.c
@@ -1,96 +0,0 @@
-/* test_stanza.c
- * libstrophe XMPP client library -- test routines for stanza functions
- *
- * Copyright (C) 2020 Dmitry Podgorny <pasis.ua@gmail.com>
- *
- *  This software is provided AS-IS with no warranty, either express
- *  or implied.
- *
- *  This program is dual licensed under the MIT and GPLv3 licenses.
- */
-
-/* gcc -o test_stanza -I./src tests/test_stanza.c -lstrophe */
-
-#include <strophe.h>
-
-#include <assert.h>
-#include <stdlib.h>
-
-#define MAGICPTR ((void *)0xfeedbeef)
-static unsigned long used_blocks = 0;
-
-static void *stanza_alloc(size_t size, void *userdata)
-{
-    assert(userdata == MAGICPTR);
-
-    ++used_blocks;
-    return malloc(size);
-}
-
-static void stanza_free(void *ptr, void *userdata)
-{
-    assert(userdata == MAGICPTR);
-
-    --used_blocks;
-    free(ptr);
-}
-
-static void *stanza_realloc(void *ptr, size_t size, void *userdata)
-{
-    assert(userdata == MAGICPTR);
-
-    return realloc(ptr, size);
-}
-
-static const xmpp_mem_t stanza_mem = {
-    .alloc = &stanza_alloc,
-    .free = &stanza_free,
-    .realloc = &stanza_realloc,
-    .userdata = MAGICPTR,
-};
-
-static void test_stanza_add_child(xmpp_ctx_t *ctx)
-{
-    xmpp_stanza_t *stanza;
-    xmpp_stanza_t *child;
-    unsigned long baseline = used_blocks;
-
-    /* xmpp_stanza_add_child */
-
-    stanza = xmpp_stanza_new(ctx);
-    child = xmpp_stanza_new(ctx);
-    assert(stanza != NULL);
-    assert(child != NULL);
-    xmpp_stanza_add_child(stanza, child);
-    xmpp_stanza_release(stanza);
-    assert(used_blocks > baseline);
-    xmpp_stanza_release(child);
-    assert(used_blocks == baseline);
-
-    /* xmpp_stanza_add_child_ex */
-
-    stanza = xmpp_stanza_new(ctx);
-    child = xmpp_stanza_new(ctx);
-    assert(stanza != NULL);
-    assert(child != NULL);
-    xmpp_stanza_add_child_ex(stanza, child, 0);
-    xmpp_stanza_release(stanza);
-    assert(used_blocks == baseline);
-}
-
-int main()
-{
-    xmpp_ctx_t *ctx;
-
-    xmpp_initialize();
-    ctx = xmpp_ctx_new(&stanza_mem, NULL);
-    assert(ctx != NULL);
-
-    test_stanza_add_child(ctx);
-
-    xmpp_ctx_free(ctx);
-    xmpp_shutdown();
-
-    /* All allocated blocks must be freed. */
-    assert(used_blocks == 0);
-}
--- a/tests/test_string.c
+++ b/tests/test_string.c
@@ -20,16 +20,6 @@

 #include "test.h" /* ARRAY_SIZE */

-/* strtok_s() has appeared in visual studio 2005.
-   Use own implementation for older versions. */
-#ifdef _MSC_VER
-# if (_MSC_VER >= 1400)
-# define strtok_r strtok_s
-# else
-# define strtok_r xmpp_strtok_r
-# endif
-#endif /* _MSC_VER */
-
 static int test_strtok_r(void)
 {
    const char *test = "-abc-=-def--";