WIP examples: PLAIN auth mechanism over raw connection

.gitignore

@@ -34,6 +34,7 @@ examples/active
 examples/basic
 examples/bot
 examples/component
+examples/ext_auth
 examples/roster
 examples/uuid
 examples/vcard

.travis.yml

@@ -1,11 +1,11 @@
 language: c
 install:
     - sudo apt-get update
-    - sudo apt-get -y install libtool pkg-config libexpat1-dev libxml2-dev libssl-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"

ChangeLog

@@ -1,12 +1,3 @@
-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
@@ -17,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()
 

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@
@@ -10,7 +11,7 @@ SSL_LIBS = @openssl_LIBS@
 
 RESOLV_LIBS = @RESOLV_LIBS@
 
-STROPHE_FLAGS = -I$(top_srcdir) -Wall -Wextra -Wno-unused-parameter
+STROPHE_FLAGS = -I$(top_srcdir) -Wall -Wextra -Werror -Wno-unused-parameter
 STROPHE_LIBS = libstrophe.la
 
 ## Main build targets
@@ -97,6 +98,7 @@ noinst_PROGRAMS = \
 	examples/basic \
 	examples/bot \
 	examples/component \
+	examples/ext_auth \
 	examples/roster \
 	examples/uuid \
 	examples/vcard
@@ -113,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)

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])

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

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
 

jni/Application.mk

@@ -1,2 +1,2 @@
-APP_ABI := armeabi-v7a arm64-v8a
+APP_ABI := armeabi armeabi-v7a mips x86
 APP_PLATFORM := android-19

src/auth.c

@@ -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);
@@ -215,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 */
@@ -225,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;
         }
@@ -236,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)
@@ -259,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;
@@ -557,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 */
@@ -728,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) {
+    } else if (conn->type == XMPP_CLIENT) {
 	/* legacy client authentication */
-        _auth_legacy(conn);
+
+	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_error(conn->ctx, "auth", "Cannot authenticate with known methods");
+	    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);
     }
 }
 
@@ -787,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 */
@@ -797,21 +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;
+    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 */
@@ -1014,15 +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_legacy(xmpp_conn_t * const conn,
 			  xmpp_stanza_t * const stanza,
 			  void * const userdata)
@@ -1059,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_error(conn->ctx, "xmpp", "Server did not reply to legacy "\
+	       "authentication request.");
     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);
+    return 0;
 }
 
 void auth_handle_component_open(xmpp_conn_t * const conn)

src/common.h

@@ -172,7 +172,6 @@ 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 */

src/conn.c

@@ -73,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
@@ -140,7 +131,6 @@ 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;
@@ -714,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
  *
@@ -756,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 */
@@ -780,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);
     }
 }
@@ -844,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);
@@ -921,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;
 }
@@ -940,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
@@ -967,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;
 }
@@ -1213,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);

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

src/event.c

@@ -262,8 +262,10 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
                 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) {

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

src/parser_expat.c

@@ -137,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 */

src/parser_libxml2.c

@@ -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 */

src/rand.c

@@ -127,10 +127,8 @@ 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);
     Hash_df(seed_material, entropy_input_len + nonce_len, seed, seedlen);
     seed0[0] = 0;

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

src/resolver.c

@@ -517,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)
@@ -550,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)
 				{

src/sasl.c

@@ -264,7 +264,6 @@ 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"));
     value = xmpp_alloc(ctx, 5 + strlen(domain) + 1);
     memcpy(value, "xmpp/", 5);

src/stanza.c

@@ -344,16 +344,10 @@ static int _render_stanza_recursive(xmpp_stanza_t *stanza,
 		}
 		tmp = _escape_xml(stanza->ctx,
 		    (char *)hash_get(stanza->attributes, key));
-                if (tmp == NULL) {
-                    hash_iter_release(iter);
-                    return XMPP_EMEM;
-                }
+		if (tmp == NULL) 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;
-                }
+		if (ret < 0) return XMPP_EMEM;
 		_render_update(&written, buflen, ret, &left, &ptr);
 	    }
 	    hash_iter_release(iter);
@@ -427,12 +421,7 @@ int xmpp_stanza_to_text(xmpp_stanza_t *stanza,
     }
 
     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);
@@ -446,12 +435,7 @@ int xmpp_stanza_to_text(xmpp_stanza_t *stanza,
 	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;
-        }
+	if ((size_t)ret > length - 1) return XMPP_EMEM;
     }
     
     buffer[length - 1] = 0;
@@ -589,6 +573,7 @@ int xmpp_stanza_set_attribute(xmpp_stanza_t * const stanza,
 
     val = xmpp_strdup(stanza->ctx, value);
     if (!val) {
+        hash_release(stanza->attributes);
         return XMPP_EMEM;
     }
 
@@ -824,11 +809,10 @@ xmpp_stanza_t *xmpp_stanza_get_child_by_ns(xmpp_stanza_t * const stanza,
 					   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)
+	if (xmpp_stanza_get_ns(child) &&
+	    strcmp(ns, xmpp_stanza_get_ns(child)) == 0)
 	    break;
     }
     
@@ -1234,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;
-}

src/tls_openssl.c

@@ -48,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)
 {
@@ -189,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;
@@ -201,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);
@@ -216,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;
@@ -275,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)
@@ -295,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;
@@ -314,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);
-    }
-}

strophe.h

@@ -169,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 {
@@ -221,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);
@@ -386,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 */
 

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

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--";