WIP add xsock

Move setting (non)block mode to a single static function.

.gitignore

@@ -36,6 +36,7 @@ examples/bot
 examples/component
 examples/roster
 examples/uuid
+examples/vcard
 test_stamp
 test-suite.log
 tests/*.o

.travis.yml

@@ -1,11 +1,15 @@
 language: c
 install:
     - sudo apt-get update
-    - sudo apt-get -y install libtool pkg-config libexpat1-dev libxml2-dev libssl-dev check
-script:
+    - sudo apt-get -y install libtool pkg-config libexpat1-dev libxml2-dev libssl-dev libc-ares-dev
+before_script:
     - ./bootstrap.sh
-    - ./configure --without-libxml2 && make CFLAGS="-Wall -Werror" && make CFLAGS="-Wall -Werror" check-TESTS
-    - make clean
-    - ./configure --with-libxml2 && make CFLAGS="-Wall -Werror" && make CFLAGS="-Wall -Werror" check-TESTS
-    - make clean
-    - ./configure --disable-tls && make CFLAGS="-Wall -Werror" && make CFLAGS="-Wall -Werror" check-TESTS
+script:
+    - ./configure ${CONFIGURE_OPT} CFLAGS="-Werror" && make && make check
+env:
+    - CONFIGURE_OPT="--without-libxml2"
+    - CONFIGURE_OPT="--with-libxml2"
+    - CONFIGURE_OPT="--disable-tls"
+    - CONFIGURE_OPT="--enable-cares"
+matrix:
+    fast_finish: true

ChangeLog

@@ -1,3 +1,31 @@
+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
+	- Certificate hostname verification is forced for openssl-1.0.2 and
+	  newer
+	- OpenSSL tls module disables insecure SSLv2 SSLv3 and TLSv1
+	- Support of handlers with the same callback function, but different
+	  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()
+
 0.9.1
 	- Fixed bug #95 (DNS lookup failing on Cygwin)
 	- Removed dependency on the check package

Makefile.am

@@ -1,7 +1,6 @@
 AUTOMAKE_OPTIONS = subdir-objects
 
 ACLOCAL_AMFLAGS = -I m4
-AM_CFLAGS = -g -Wall
 
 PARSER_CFLAGS=@PARSER_CFLAGS@
 PARSER_LIBS=@PARSER_LIBS@
@@ -9,26 +8,55 @@ PARSER_LIBS=@PARSER_LIBS@
 SSL_CFLAGS = @openssl_CFLAGS@
 SSL_LIBS = @openssl_LIBS@
 
+RESOLV_CFLAGS = @RESOLV_CFLAGS@
 RESOLV_LIBS = @RESOLV_LIBS@
 
-STROPHE_FLAGS = -I$(top_srcdir)
+STROPHE_FLAGS = -I$(top_srcdir) -Wall -Wextra -Wno-unused-parameter
 STROPHE_LIBS = libstrophe.la
 
 ## Main build targets
 lib_LTLIBRARIES = libstrophe.la
 
-libstrophe_la_CFLAGS = $(SSL_CFLAGS) $(STROPHE_FLAGS) $(PARSER_CFLAGS)
+libstrophe_la_CFLAGS = $(SSL_CFLAGS) $(STROPHE_FLAGS) $(PARSER_CFLAGS) $(RESOLV_CFLAGS)
 libstrophe_la_LDFLAGS = $(SSL_LIBS) $(PARSER_LIBS) $(RESOLV_LIBS) -no-undefined
 # Export only public API
 libstrophe_la_LDFLAGS += -export-symbols-regex '^xmpp_'
-libstrophe_la_SOURCES = src/auth.c src/conn.c src/crypto.c src/ctx.c \
-	src/event.c src/handler.c src/hash.c src/jid.c src/md5.c \
-	src/resolver.c src/sasl.c src/scram.c src/sha1.c \
-	src/snprintf.c src/sock.c src/stanza.c src/util.c \
-	src/rand.c src/uuid.c \
-	src/common.h src/hash.h src/md5.h src/ostypes.h src/parser.h \
-	src/resolver.h src/sasl.h src/scram.h src/sha1.h src/snprintf.h \
-	src/sock.h src/tls.h src/util.h src/rand.h
+
+libstrophe_la_SOURCES = \
+	src/auth.c \
+	src/conn.c \
+	src/crypto.c \
+	src/ctx.c \
+	src/event.c \
+	src/handler.c \
+	src/hash.c \
+	src/jid.c \
+	src/md5.c \
+	src/rand.c \
+	src/resolver.c \
+	src/sasl.c \
+	src/scram.c \
+	src/sha1.c \
+	src/snprintf.c \
+	src/sock.c \
+	src/stanza.c \
+	src/util.c \
+	src/uuid.c
+libstrophe_la_SOURCES += \
+	src/common.h \
+	src/hash.h \
+	src/md5.h \
+	src/ostypes.h \
+	src/parser.h \
+	src/rand.h \
+	src/resolver.h \
+	src/sasl.h \
+	src/scram.h \
+	src/sha1.h \
+	src/snprintf.h \
+	src/sock.h \
+	src/tls.h \
+	src/util.h
 
 if DISABLE_TLS
 libstrophe_la_SOURCES += src/tls_dummy.c
@@ -47,19 +75,36 @@ noinst_HEADERS = strophepp.h
 
 pkgconfig_DATA = libstrophe.pc
 
-EXTRA_DIST = docs rpm Doxyfile LICENSE.txt GPL-LICENSE.txt MIT-LICENSE.txt \
-	src/tls_dummy.c src/tls_gnutls.c src/tls_schannel.c \
-	examples/README.md
+EXTRA_DIST = \
+	Doxyfile \
+	GPL-LICENSE.txt \
+	LICENSE.txt \
+	MIT-LICENSE.txt \
+	bootstrap.sh \
+	build-android.sh \
+	docs/footer.html \
+	examples/README.md \
+	jni/Android.mk \
+	jni/Application.mk \
+	rpm/README \
+	rpm/libstrophe.spec \
+	src/tls_gnutls.c \
+	src/tls_schannel.c \
+	tests/res_query_dump.c
 
 ## Examples
-noinst_PROGRAMS = examples/active examples/roster examples/basic examples/bot \
-	examples/component examples/uuid
+noinst_PROGRAMS = \
+	examples/active \
+	examples/basic \
+	examples/bot \
+	examples/component \
+	examples/roster \
+	examples/uuid \
+	examples/vcard
+
 examples_active_SOURCES = examples/active.c
 examples_active_CFLAGS = $(STROPHE_FLAGS)
 examples_active_LDADD = $(STROPHE_LIBS)
-examples_roster_SOURCES = examples/roster.c
-examples_roster_CFLAGS = $(STROPHE_FLAGS)
-examples_roster_LDADD = $(STROPHE_LIBS)
 examples_basic_SOURCES = examples/basic.c
 examples_basic_CFLAGS = $(STROPHE_FLAGS)
 examples_basic_LDADD = $(STROPHE_LIBS)
@@ -69,15 +114,32 @@ examples_bot_LDADD = $(STROPHE_LIBS)
 examples_component_SOURCES = examples/component.c
 examples_component_CFLAGS = $(STROPHE_FLAGS)
 examples_component_LDADD = $(STROPHE_LIBS)
+examples_roster_SOURCES = examples/roster.c
+examples_roster_CFLAGS = $(STROPHE_FLAGS)
+examples_roster_LDADD = $(STROPHE_LIBS)
 examples_uuid_SOURCES = examples/uuid.c
 examples_uuid_CFLAGS = $(STROPHE_FLAGS)
 examples_uuid_LDADD = $(STROPHE_LIBS)
+examples_vcard_SOURCES = examples/vcard.c
+examples_vcard_CFLAGS = $(STROPHE_FLAGS)
+examples_vcard_LDADD = $(STROPHE_LIBS)
 
 
 ## Tests
-TESTS = tests/check_parser tests/test_sha1 tests/test_md5 tests/test_rand \
-	tests/test_scram tests/test_ctx tests/test_base64 tests/test_jid \
-	tests/test_snprintf tests/test_string tests/test_resolver
+TESTS = \
+	tests/check_parser \
+	tests/test_sha1 \
+	tests/test_md5 \
+	tests/test_rand \
+	tests/test_scram \
+	tests/test_ctx \
+	tests/test_base64 \
+	tests/test_hash \
+	tests/test_jid \
+	tests/test_snprintf \
+	tests/test_string \
+	tests/test_resolver
+
 check_PROGRAMS = $(TESTS)
 
 tests_check_parser_SOURCES = tests/check_parser.c tests/test.h
@@ -96,6 +158,11 @@ tests_test_base64_CFLAGS = $(STROPHE_FLAGS) -I$(top_srcdir)/src
 tests_test_base64_LDADD = $(STROPHE_LIBS)
 tests_test_base64_LDFLAGS = -static
 
+tests_test_hash_SOURCES = tests/test_hash.c
+tests_test_hash_CFLAGS = $(STROPHE_FLAGS) -I$(top_srcdir)/src
+tests_test_hash_LDADD = $(STROPHE_LIBS)
+tests_test_hash_LDFLAGS = -static
+
 tests_test_jid_SOURCES = tests/test_jid.c
 tests_test_jid_CFLAGS = $(STROPHE_FLAGS) -I$(top_srcdir)/src
 tests_test_jid_LDADD = $(STROPHE_LIBS)

configure.ac

@@ -1,4 +1,4 @@
-AC_INIT([libstrophe], [0.9.1], [jack@metajack.im])
+AC_INIT([libstrophe], [0.9.3], [jack@metajack.im])
 AC_CONFIG_MACRO_DIR([m4])
 AM_INIT_AUTOMAKE([foreign])
 LT_INIT([dlopen])
@@ -21,6 +21,8 @@ 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])])
 
 if test "x$enable_tls" != xno; then
     PKG_CHECK_MODULES([openssl], [openssl],
@@ -84,6 +86,18 @@ AC_MSG_NOTICE([libstrophe will use the $with_parser XML parser])
 
 AC_SEARCH_LIBS([socket], [socket])
 
+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
+
 AS_CASE([$PLATFORM],
     [bsd],     [RESOLV_LIBS=""],
     [qnx],     [RESOLV_LIBS="-lsocket"],
@@ -110,6 +124,8 @@ 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],
@@ -126,6 +142,7 @@ AC_SUBST([PC_LIBS], [${PC_LIBS}])
 
 AC_SUBST(PARSER_CFLAGS)
 AC_SUBST(PARSER_LIBS)
+AC_SUBST(RESOLV_CFLAGS)
 AC_SUBST(RESOLV_LIBS)
 AC_CONFIG_FILES([Makefile libstrophe.pc])
 AC_OUTPUT

examples/active.c

@@ -55,10 +55,7 @@ void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status,
 	fprintf(stderr, "DEBUG: connected\n");
 	
 	/* create iq stanza for request */
-	iq = xmpp_stanza_new(ctx);
-	xmpp_stanza_set_name(iq, "iq");
-	xmpp_stanza_set_type(iq, "get");
-	xmpp_stanza_set_id(iq, "active1");
+	iq = xmpp_iq_new(ctx, "get", "active1");
 	xmpp_stanza_set_to(iq, "xxxxxxxxx.com");
 
 	query = xmpp_stanza_new(ctx);

examples/bot.c

@@ -73,15 +73,19 @@ int version_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void
 int message_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata)
 {
     xmpp_ctx_t *ctx = (xmpp_ctx_t*)userdata;
-    xmpp_stanza_t *reply;
+    xmpp_stanza_t *body, *reply;
+    const char *type;
     char *intext, *replytext;
+    int quit = 0;
 
-    if (!xmpp_stanza_get_child_by_name(stanza, "body"))
+    body = xmpp_stanza_get_child_by_name(stanza, "body");
+    if (body == NULL)
         return 1;
-    if (xmpp_stanza_get_type(stanza) != NULL && !strcmp(xmpp_stanza_get_type(stanza), "error"))
+    type = xmpp_stanza_get_type(stanza);
+    if (type != NULL && strcmp(type, "error") == 0)
         return 1;
 
-    intext = xmpp_stanza_get_text(xmpp_stanza_get_child_by_name(stanza, "body"));
+    intext = xmpp_stanza_get_text(body);
 
     printf("Incoming message from %s: %s\n", xmpp_stanza_get_from(stanza), intext);
 
@@ -89,15 +93,24 @@ int message_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void
     if (xmpp_stanza_get_type(reply) == NULL)
         xmpp_stanza_set_type(reply, "chat");
 
-    replytext = (char *) malloc(strlen(" to you too!") + strlen(intext) + 1);
-    strcpy(replytext, intext);
-    strcat(replytext, " to you too!");
+    if (strcmp(intext, "quit") == 0) {
+        replytext = strdup("bye!");
+        quit = 1;
+    } else {
+        replytext = (char *) malloc(strlen(" to you too!") + strlen(intext) + 1);
+        strcpy(replytext, intext);
+        strcat(replytext, " to you too!");
+    }
     xmpp_free(ctx, intext);
     xmpp_message_set_body(reply, replytext);
 
     xmpp_send(conn, reply);
     xmpp_stanza_release(reply);
     free(replytext);
+
+    if (quit)
+        xmpp_disconnect(conn);
+
     return 1;
 }
 

examples/roster.c

@@ -62,10 +62,7 @@ void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status,
 	fprintf(stderr, "DEBUG: connected\n");
 	
 	/* create iq stanza for request */
-	iq = xmpp_stanza_new(ctx);
-	xmpp_stanza_set_name(iq, "iq");
-	xmpp_stanza_set_type(iq, "get");
-	xmpp_stanza_set_id(iq, "roster1");
+	iq = xmpp_iq_new(ctx, "get", "roster1");
 
 	query = xmpp_stanza_new(ctx);
 	xmpp_stanza_set_name(query, "query");

examples/vcard.c

@@ -0,0 +1,284 @@
+/* vcard.c
+ * strophe XMPP client library -- vCard example
+ *
+ * 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 <assert.h>
+#include <libgen.h> /* basename */
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <strophe.h>
+
+typedef struct {
+    xmpp_ctx_t *ctx;
+    const char *recipient;
+    const char *img_path;
+} vcard_t;
+
+typedef void (*vcard_cb_t)(vcard_t *, xmpp_stanza_t *);
+
+#define REQ_TIMEOUT 5000
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+
+static void vcard_photo(vcard_t *vc, xmpp_stanza_t *stanza)
+{
+    xmpp_stanza_t *tmp;
+    char *s;
+    char *tok;
+    char *saveptr = NULL;
+    char *copy;
+    unsigned char *img;
+    size_t img_size;
+    size_t written;
+    FILE *fd;
+
+    tmp = xmpp_stanza_get_child_by_name(stanza, "TYPE");
+    assert(tmp != NULL);
+    s = xmpp_stanza_get_text(tmp);
+    assert(s != NULL);
+    printf("PHOTO: %s, saving to file %s\n", s, vc->img_path);
+    xmpp_free(vc->ctx, s);
+
+    tmp = xmpp_stanza_get_child_by_name(stanza, "BINVAL");
+    assert(tmp != NULL);
+    s = xmpp_stanza_get_text(tmp);
+    assert(s != NULL);
+
+    /* remove \n and \r */
+    copy = (char *)malloc(strlen(s) + 1);
+    assert(copy != NULL);
+    copy[0] = '\0';
+    tok = strtok_r(s, "\n\r", &saveptr);
+    while (tok != NULL) {
+        strcat(copy, tok);
+        tok = strtok_r(NULL, "\n\r", &saveptr);
+    }
+
+    xmpp_base64_decode_bin(vc->ctx, copy, strlen(copy), &img, &img_size);
+    assert(img != NULL);
+
+    fd = fopen(vc->img_path, "w");
+    assert(fd != NULL);
+    written = fwrite(img, 1, img_size, fd);
+    if (written < img_size)
+        printf("Saving photo failed\n");
+    fclose(fd);
+
+    free(copy);
+    xmpp_free(vc->ctx, s);
+    xmpp_free(vc->ctx, img);
+}
+
+static void vcard_print_string(vcard_t *vc, xmpp_stanza_t *stanza,
+                               const char *info)
+{
+    char *s = xmpp_stanza_get_text(stanza);
+
+    assert(s != NULL);
+    printf("%s: %s\n", info, s);
+    xmpp_free(vc->ctx, s);
+}
+
+static void vcard_bday(vcard_t *vc, xmpp_stanza_t *stanza)
+{
+    vcard_print_string(vc, stanza, "Birthday");
+}
+
+static void vcard_desc(vcard_t *vc, xmpp_stanza_t *stanza)
+{
+    vcard_print_string(vc, stanza, "Description");
+}
+
+static void vcard_email(vcard_t *vc, xmpp_stanza_t *stanza)
+{
+    xmpp_stanza_t *userid = xmpp_stanza_get_child_by_name(stanza, "USERID");
+
+    if (userid != NULL)
+        vcard_print_string(vc, userid, "E-mail");
+}
+
+static void vcard_fn(vcard_t *vc, xmpp_stanza_t *stanza)
+{
+    vcard_print_string(vc, stanza, "Full name");
+}
+
+static void vcard_name(vcard_t *vc, xmpp_stanza_t *stanza)
+{
+    xmpp_stanza_t *name = xmpp_stanza_get_child_by_name(stanza, "GIVEN");
+    xmpp_stanza_t *family = xmpp_stanza_get_child_by_name(stanza, "FAMILY");
+
+    if (name != NULL)
+        vcard_print_string(vc, name, "Given name");
+    if (family != NULL)
+        vcard_print_string(vc, family, "Family name");
+}
+
+static void vcard_nick(vcard_t *vc, xmpp_stanza_t *stanza)
+{
+    vcard_print_string(vc, stanza, "Nickname");
+}
+
+static void vcard_url(vcard_t *vc, xmpp_stanza_t *stanza)
+{
+    vcard_print_string(vc, stanza, "URL");
+}
+
+static vcard_cb_t vcard_cb_get(xmpp_stanza_t *stanza)
+{
+    vcard_cb_t cb = NULL;
+    const char *tag;
+    size_t i;
+
+    static struct {
+        const char *tag;
+        vcard_cb_t cb;
+    } vcard_tbl[] = {
+        { "PHOTO", vcard_photo },
+        { "BDAY", vcard_bday },
+        { "DESC", vcard_desc },
+        { "EMAIL", vcard_email },
+        { "FN", vcard_fn },
+        { "N", vcard_name },
+        { "NICKNAME", vcard_nick },
+        { "URL", vcard_url },
+    };
+
+    tag = xmpp_stanza_get_name(stanza);
+    if (tag == NULL)
+        goto exit;
+
+    for (i = 0; i < ARRAY_SIZE(vcard_tbl); ++i) {
+        if (strcmp(tag, vcard_tbl[i].tag) == 0) {
+            cb = vcard_tbl[i].cb;
+            break;
+        }
+    }
+
+exit:
+    return cb;
+}
+
+static int timedout(xmpp_conn_t * const conn, void * const userdata)
+{
+    fprintf(stderr, "Timeout reached.\n");
+    xmpp_disconnect(conn);
+
+    return 0;
+}
+
+static int recv_vcard(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza,
+                      void * const userdata)
+{
+    vcard_t *vc = userdata;
+    vcard_cb_t cb;
+    xmpp_stanza_t *child;
+    char *s;
+    size_t s_size;
+    int rc;
+
+    printf("Received vCard.\n\n");
+
+    child = xmpp_stanza_get_child_by_name(stanza, "error");
+    if (child != NULL) {
+        rc = xmpp_stanza_to_text(child, &s, &s_size);
+        assert(rc == XMPP_EOK);
+        printf("Error returned: %s.\n", s);
+        xmpp_free(vc->ctx, s);
+        goto exit;
+    }
+
+    child = xmpp_stanza_get_child_by_name(stanza, "vCard");
+    assert(child != NULL);
+    child = xmpp_stanza_get_children(child);
+    while (child != NULL) {
+        cb = vcard_cb_get(child);
+        if (cb != NULL)
+            cb(vc, child);
+        child = xmpp_stanza_get_next(child);
+    }
+
+exit:
+    xmpp_disconnect(conn);
+
+    return 0;
+}
+
+static void send_vcard_req(xmpp_conn_t *conn, const char *to, const char *id)
+{
+    printf("Requesting vCard from %s.\n", to);
+    xmpp_send_raw_string(conn, "<iq from='%s' to='%s' type='get' id='%s'>"
+                               "<vCard xmlns='vcard-temp'/></iq>",
+                               xmpp_conn_get_bound_jid(conn), to, id);
+}
+
+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)
+{
+    vcard_t *vc = userdata;
+
+    if (status == XMPP_CONN_CONNECT) {
+        send_vcard_req(conn, vc->recipient, "vc1");
+        xmpp_id_handler_add(conn, recv_vcard, "vc1", vc);
+        xmpp_timed_handler_add(conn, timedout, REQ_TIMEOUT, NULL);
+    } else {
+        if (error != 0)
+            fprintf(stderr, "Disconnected with error=%d.\n", error);
+        if (stream_error != NULL)
+            fprintf(stderr, "Stream error type=%d text=%s.\n",
+                            stream_error->type, stream_error->text);
+        xmpp_stop(vc->ctx);
+    }
+}
+
+int main(int argc, char **argv)
+{
+    xmpp_log_t  *log;
+    xmpp_ctx_t  *ctx;
+    xmpp_conn_t *conn;
+    const char  *jid;
+    const char  *pass;
+    char        *prog;
+    vcard_t      vcard;
+
+    if (argc < 4 || argc > 5) {
+        prog = argc > 0 ? strdup(argv[0]) : NULL;
+        printf("Usage: %s <login-jid> <password> <recipient-jid> "
+               "[image-file]\n\n", prog == NULL ? "vcard" : basename(prog));
+        printf("If vCard contains a photo it will be stored to "
+               "image-file. If you don't provide the image-file "
+               "default filename will be generated.\n");
+        free(prog);
+        return 1;
+    }
+
+    jid = argv[1];
+    pass = argv[2];
+    vcard.recipient = argv[3];
+    vcard.img_path = argc > 4 ? argv[4] : "vcard.jpg";
+
+    xmpp_initialize();
+    log = xmpp_get_default_logger(XMPP_LEVEL_INFO);
+    ctx = xmpp_ctx_new(NULL, log);
+    conn = xmpp_conn_new(ctx);
+    xmpp_conn_set_jid(conn, jid);
+    xmpp_conn_set_pass(conn, pass);
+    vcard.ctx = ctx;
+    xmpp_connect_client(conn, NULL, 0, conn_handler, &vcard);
+    xmpp_run(ctx);
+    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
+LOCAL_CFLAGS := -DHAVE_MEMMOVE -DXML_DEV_URANDOM
 #LOCAL_C_INCLUDES := \
 #	$(LOCAL_PATH)/expat
 

jni/Application.mk

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

rpm/README

@@ -1,6 +1,6 @@
 1. Setup
 
-yum install gcc make expat-devel libstrophe
+yum install gcc make autoconf automake expat-devel openssl-devel
 
 Fedora:
 

rpm/libstrophe.spec

@@ -8,10 +8,12 @@ License:	MIT/GPLv3
 URL:		http://strophe.im/libstrophe/
 Source0:	libstrophe_git.tar.gz
 
+BuildRequires:	autoconf
 BuildRequires:	automake
 BuildRequires:	libtool
 BuildRequires:	openssl-devel
 BuildRequires:	expat-devel
+Requires:	openssl
 Requires:	expat
 
 %description

src/auth.c

@@ -61,18 +61,15 @@
 #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);
 
 static int _handle_component_auth(xmpp_conn_t * const conn);
 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);
@@ -218,6 +215,7 @@ 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 */
@@ -227,8 +225,10 @@ 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 && (strcmp(xmpp_stanza_get_ns(child), XMPP_NS_TLS) == 0))
-                conn->tls_support = 1;
+            if (child) {
+                ns = xmpp_stanza_get_ns(child);
+                conn->tls_support = ns != NULL && strcmp(ns, XMPP_NS_TLS) == 0;
+            }
         } else {
             conn->tls_support = 0;
         }
@@ -236,11 +236,15 @@ static int _handle_features(xmpp_conn_t * const conn,
 
     /* check for SASL */
     child = xmpp_stanza_get_child_by_name(stanza, "mechanisms");
-    if (child && (strcmp(xmpp_stanza_get_ns(child), XMPP_NS_SASL) == 0)) {
+    ns = child ? xmpp_stanza_get_ns(child) : NULL;
+    if (child && ns && strcmp(ns, 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)
@@ -255,6 +259,10 @@ 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;
@@ -288,7 +296,7 @@ static int _handle_proceedtls_default(xmpp_conn_t * const conn,
         xmpp_debug(conn->ctx, "xmpp", "proceeding with TLS");
 
         if (conn_tls_start(conn) == 0) {
-            conn_prepare_reset(conn, auth_handle_open);
+            conn_prepare_reset(conn, _handle_open_tls);
             conn_open_stream(conn);
         } else {
             /* failed tls spoils the connection, so disconnect */
@@ -315,7 +323,7 @@ static int _handle_sasl_result(xmpp_conn_t * const conn,
 	/* fall back to next auth method */
 	_auth(conn);
     } else if (strcmp(name, "success") == 0) {
-	/* SASL PLAIN auth successful, we need to restart the stream */
+	/* SASL auth successful, we need to restart the stream */
 	xmpp_debug(conn->ctx, "xmpp", "SASL %s auth successful",
 		   (char *)userdata);
 
@@ -549,9 +557,11 @@ static xmpp_stanza_t *_make_sasl_auth(xmpp_conn_t * const conn,
  */
 static void _auth(xmpp_conn_t * const conn)
 {
-    xmpp_stanza_t *auth, *authdata, *query, *child, *iq;
-    char *str, *authid;
+    xmpp_stanza_t *auth;
+    xmpp_stanza_t *authdata;
+    char *authid;
     char *scram_init;
+    char *str;
     int anonjid;
 
     /* if there is no node in conn->jid, we assume anonymous connect */
@@ -564,7 +574,7 @@ static void _auth(xmpp_conn_t * const conn)
     }
 
     if (conn->tls_support) {
-	tls_t *tls = tls_new(conn->ctx, conn->sock);
+	tls_t *tls = tls_new(conn);
 
 	/* If we couldn't init tls, it isn't there, so go on */
 	if (!tls) {
@@ -718,108 +728,12 @@ static void _auth(xmpp_conn_t * const conn)
 
 	/* SASL PLAIN was tried */
 	conn->sasl_support &= ~SASL_MASK_PLAIN;
-    } else if (conn->type == XMPP_CLIENT) {
-	/* legacy client authentication */
-
-	iq = xmpp_stanza_new(conn->ctx);
-	if (!iq) {
-	    disconnect_mem_error(conn);
-	    return;
-	}
-	xmpp_stanza_set_name(iq, "iq");
-	xmpp_stanza_set_type(iq, "set");
-	xmpp_stanza_set_id(iq, "_xmpp_auth1");
-
-	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);
+    } 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);
     }
 }
 
@@ -838,15 +752,23 @@ void auth_handle_open(xmpp_conn_t * const conn)
     /* reset all timed handlers */
     handler_reset_timed(conn, 0);
 
-    /* setup handler for stream:error */
-    handler_add(conn, _handle_error,
-		XMPP_NS_STREAMS, "error", NULL, NULL);
+    /* setup handler for stream:error, we will keep this handler
+     * for reopened streams until connection is disconnected */
+    handler_add(conn, _handle_error, XMPP_NS_STREAMS, "error", NULL, NULL);
 
     /* setup handlers for incoming <stream:features> */
     handler_add(conn, _handle_features,
 		XMPP_NS_STREAMS, "features", NULL, NULL);
-    handler_add_timed(conn, _handle_missing_features,
-		      FEATURES_TIMEOUT, NULL);
+    handler_add_timed(conn, _handle_missing_features, FEATURES_TIMEOUT, NULL);
+}
+
+/* called when stream:stream tag received after TLS establishment */
+static void _handle_open_tls(xmpp_conn_t * const conn)
+{
+    /* setup handlers for incoming <stream:features> */
+    handler_add(conn, _handle_features,
+		XMPP_NS_STREAMS, "features", NULL, NULL);
+    handler_add_timed(conn, _handle_missing_features, FEATURES_TIMEOUT, NULL);
 }
 
 /* called when stream:stream tag received after SASL auth */
@@ -865,7 +787,8 @@ 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;
+    xmpp_stanza_t *bind, *session, *iq, *res, *text, *opt;
+    const char *ns;
     char *resource;
 
     /* remove missing features handler */
@@ -874,16 +797,21 @@ 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 && strcmp(xmpp_stanza_get_ns(bind), XMPP_NS_BIND) == 0) {
-	/* resource binding is required */
-	conn->bind_required = 1;
+    if (bind) {
+        ns = xmpp_stanza_get_ns(bind);
+	conn->bind_required = ns != NULL && strcmp(ns, XMPP_NS_BIND) == 0;
     }
 
+    /* check whether session establishment is required */
     session = xmpp_stanza_get_child_by_name(stanza, "session");
-    if (session && strcmp(xmpp_stanza_get_ns(session), XMPP_NS_SESSION) == 0) {
-	/* session establishment required */
-	conn->session_required = 1;
+    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 bind is required, go ahead and start it */
@@ -896,16 +824,12 @@ static int _handle_features_sasl(xmpp_conn_t * const conn,
 			  BIND_TIMEOUT, NULL);
 
 	/* send bind request */
-	iq = xmpp_stanza_new(conn->ctx);
+	iq = xmpp_iq_new(conn->ctx, "set", "_xmpp_bind1");
 	if (!iq) {
 	    disconnect_mem_error(conn);
 	    return 0;
 	}
 
-	xmpp_stanza_set_name(iq, "iq");
-	xmpp_stanza_set_type(iq, "set");
-	xmpp_stanza_set_id(iq, "_xmpp_bind1");
-
 	bind = xmpp_stanza_copy(bind);
 	if (!bind) {
 	    xmpp_stanza_release(iq);
@@ -1008,20 +932,17 @@ static int _handle_bind(xmpp_conn_t * const conn,
 			      SESSION_TIMEOUT, NULL);
 
 	    /* send session request */
-	    iq = xmpp_stanza_new(conn->ctx);
+            iq = xmpp_iq_new(conn->ctx, "set", "_xmpp_session1");
 	    if (!iq) {
 		disconnect_mem_error(conn);
 		return 0;
 	    }
 
-	    xmpp_stanza_set_name(iq, "iq");
-	    xmpp_stanza_set_type(iq, "set");
-	    xmpp_stanza_set_id(iq, "_xmpp_session1");
-
 	    session = xmpp_stanza_new(conn->ctx);
 	    if (!session) {
 		xmpp_stanza_release(iq);
 		disconnect_mem_error(conn);
+                return 0;
 	    }
 
 	    xmpp_stanza_set_name(session, "session");
@@ -1093,6 +1014,15 @@ 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)
@@ -1129,13 +1059,97 @@ static int _handle_legacy(xmpp_conn_t * const conn,
     return 0;
 }
 
-static int _handle_missing_legacy(xmpp_conn_t * const conn,
-				  void * const userdata)
+static void _auth_legacy(xmpp_conn_t *conn)
 {
-    xmpp_error(conn->ctx, "xmpp", "Server did not reply to legacy "\
-	       "authentication request.");
-    xmpp_disconnect(conn);
-    return 0;
+    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);
 }
 
 void auth_handle_component_open(xmpp_conn_t * const conn)

src/common.h

@@ -1,7 +1,7 @@
 /* common.h
 ** strophe XMPP client library -- internal common structures
 **
-** 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.
@@ -50,38 +50,40 @@ struct _xmpp_ctx_t {
     xmpp_rand_t *rand;
     xmpp_loop_status_t loop_status;
     xmpp_connlist_t *connlist;
+
+    unsigned long timeout;
 };
 
 
 /* convenience functions for accessing the context */
 void *xmpp_alloc(const xmpp_ctx_t * const ctx, const size_t size);
 void *xmpp_realloc(const xmpp_ctx_t * const ctx, void *p, 
-		   const size_t size);
+                   const size_t size);
 char *xmpp_strdup(const xmpp_ctx_t * const ctx, const char * const s);
 
-void xmpp_log(const xmpp_ctx_t * const ctx, 
-	      const xmpp_log_level_t level,
-	      const char * const area,
-	      const char * const fmt, 
-	      va_list ap);
+void xmpp_log(const xmpp_ctx_t * const ctx,
+              const xmpp_log_level_t level,
+              const char * const area,
+              const char * const fmt,
+              va_list ap);
 
 /* wrappers for xmpp_log at specific levels */
 void xmpp_error(const xmpp_ctx_t * const ctx,
-		const char * const area,
-		const char * const fmt,
-		...);
+                const char * const area,
+                const char * const fmt,
+                ...);
 void xmpp_warn(const xmpp_ctx_t * const ctx,
-		const char * const area,
-		const char * const fmt,
-		...);
+                const char * const area,
+                const char * const fmt,
+                ...);
 void xmpp_info(const xmpp_ctx_t * const ctx,
-		const char * const area,
-		const char * const fmt,
-		...);
+                const char * const area,
+                const char * const fmt,
+                ...);
 void xmpp_debug(const xmpp_ctx_t * const ctx,
-		const char * const area,
-		const char * const fmt,
-		...);
+                const char * const area,
+                const char * const fmt,
+                ...);
 
 /** connection **/
 
@@ -105,29 +107,29 @@ typedef struct _xmpp_handlist_t xmpp_handlist_t;
 struct _xmpp_handlist_t {
     /* common members */
     int user_handler;
-    void *handler;
+    int (*handler)();
     void *userdata;
     int enabled; /* handlers are added disabled and enabled after the
-		  * handler chain is processed to prevent stanzas from
-		  * getting processed by newly added handlers */
+                  * handler chain is processed to prevent stanzas from
+                  * getting processed by newly added handlers */
     xmpp_handlist_t *next;
 
     union {
-	/* timed handlers */
-	struct {
-	    unsigned long period;
-	    uint64_t last_stamp;
-	};
-	/* id handlers */
-	struct {
-	    char *id;
-	};
-	/* normal handlers */
-	struct {
-	    char *ns;
-	    char *name;
-	    char *type;
-	};
+        /* timed handlers */
+        struct {
+            unsigned long period;
+            uint64_t last_stamp;
+        };
+        /* id handlers */
+        struct {
+            char *id;
+        };
+        /* normal handlers */
+        struct {
+            char *ns;
+            char *name;
+            char *type;
+        };
     };
 };
 
@@ -158,6 +160,7 @@ struct _xmpp_conn_t {
     xmpp_stream_error_t *stream_error;
 
     sock_t sock;
+    xmpp_sock_t *xsock;
     int ka_timeout; /* TCP keepalive timeout */
     int ka_interval; /* TCP keepalive interval */
 
@@ -166,9 +169,11 @@ struct _xmpp_conn_t {
     int tls_disabled;
     int tls_mandatory;
     int tls_legacy_ssl;
+    int tls_trust;
     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 */ 
+                         mechanisms */
+    int auth_legacy_enabled;
     int secured; /* set when stream is secured with TLS */
 
     /* if server returns <bind/> or <session/> we must do them */
@@ -196,7 +201,7 @@ struct _xmpp_conn_t {
     /* timeouts */
     unsigned int connect_timeout;
 
-    /* event handlers */    
+    /* event handlers */
 
     /* stream open handler */
     xmpp_open_handler open_handler;
@@ -247,23 +252,24 @@ struct _xmpp_stanza_t {
 
 /* handler management */
 void handler_fire_stanza(xmpp_conn_t * const conn,
-			 xmpp_stanza_t * const stanza);
+                         xmpp_stanza_t * const stanza);
 uint64_t handler_fire_timed(xmpp_ctx_t * const ctx);
 void handler_reset_timed(xmpp_conn_t *conn, int user_only);
 void handler_add_timed(xmpp_conn_t * const conn,
-		       xmpp_timed_handler handler,
-		       const unsigned long period,
-		       void * const userdata);
+                       xmpp_timed_handler handler,
+                       const unsigned long period,
+                       void * const userdata);
 void handler_add_id(xmpp_conn_t * const conn,
-		    xmpp_handler handler,
-		    const char * const id,
-		    void * const userdata);
+                    xmpp_handler handler,
+                    const char * const id,
+                    void * const userdata);
 void handler_add(xmpp_conn_t * const conn,
-		 xmpp_handler handler,
-		 const char * const ns,
-		 const char * const name,
-		 const char * const type,
-		 void * const userdata);
+                 xmpp_handler handler,
+                 const char * const ns,
+                 const char * const name,
+                 const char * const type,
+                 void * const userdata);
+void handler_system_delete_all(xmpp_conn_t *conn);
 
 /* utility functions */
 void disconnect_mem_error(xmpp_conn_t * const conn);

src/conn.c

@@ -73,6 +73,15 @@ 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
@@ -128,8 +137,10 @@ xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t * const ctx)
         conn->tls_disabled = 0;
         conn->tls_mandatory = 0;
         conn->tls_legacy_ssl = 0;
+        conn->tls_trust = 0;
         conn->tls_failed = 0;
         conn->sasl_support = 0;
+        conn->auth_legacy_enabled = 0;
         conn->secured = 0;
 
         conn->bind_required = 0;
@@ -264,6 +275,8 @@ int xmpp_conn_release(xmpp_conn_t * const conn)
             }
         }
 
+        _conn_reset(conn);
+
         /* free handler stuff
          * note that userdata is the responsibility of the client
          * and the handler pointers don't need to be freed since they
@@ -305,7 +318,6 @@ int xmpp_conn_release(xmpp_conn_t * const conn)
         }
 
         parser_free(conn->parser);
-        _conn_reset(conn);
 
         if (conn->jid) xmpp_free(ctx, conn->jid);
         if (conn->pass) xmpp_free(ctx, conn->pass);
@@ -677,7 +689,8 @@ void conn_disconnect(xmpp_conn_t * const conn)
         tls_free(conn->tls);
         conn->tls = NULL;
     }
-    sock_close(conn->sock);
+    if (conn->sock >= 0)
+        sock_close(conn->sock);
 
     /* fire off connection handler */
     conn->conn_handler(conn, XMPP_CONN_DISCONNECT, conn->error,
@@ -702,7 +715,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 CONNECTING or CONNECTED.
+ *  if the connection state is different from CONNECTING or CONNECTED.
  *
  *  @param conn a Strophe connection object
  *
@@ -744,10 +757,10 @@ void xmpp_send_raw_string(xmpp_conn_t * const conn,
     char *bigbuf;
 
     va_start(ap, fmt);
-    len = xmpp_vsnprintf(buf, 1024, fmt, ap);
+    len = xmpp_vsnprintf(buf, sizeof(buf), fmt, ap);
     va_end(ap);
 
-    if (len >= 1024) {
+    if (len >= sizeof(buf)) {
         /* we need more space for this data, so we allocate a big
          * enough buffer and print to that */
         len++; /* account for trailing \0 */
@@ -768,7 +781,6 @@ 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);
     }
 }
@@ -833,10 +845,9 @@ void xmpp_send(xmpp_conn_t * const conn,
 {
     char *buf;
     size_t len;
-    int ret;
 
     if (conn->state == XMPP_STATE_CONNECTED) {
-        if ((ret = xmpp_stanza_to_text(stanza, &buf, &len)) == 0) {
+        if (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);
@@ -874,7 +885,7 @@ int conn_tls_start(xmpp_conn_t * const conn)
         conn->tls = NULL;
         rc = XMPP_EINVOP;
     } else {
-        conn->tls = tls_new(conn->ctx, conn->sock);
+        conn->tls = tls_new(conn);
         rc = conn->tls == NULL ? XMPP_EMEM : 0;
     }
 
@@ -910,7 +921,9 @@ 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_LEGACY_SSL * conn->tls_legacy_ssl |
+            XMPP_CONN_FLAG_TRUST_TLS * conn->tls_trust |
+            XMPP_CONN_FLAG_LEGACY_AUTH * conn->auth_legacy_enabled;;
 
     return flags;
 }
@@ -927,6 +940,8 @@ long xmpp_conn_get_flags(const xmpp_conn_t * const conn)
  *    - XMPP_CONN_FLAG_DISABLE_TLS
  *    - 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
@@ -943,7 +958,8 @@ int xmpp_conn_set_flags(xmpp_conn_t * const conn, long flags)
         return XMPP_EINVOP;
     }
     if (flags & XMPP_CONN_FLAG_DISABLE_TLS &&
-        flags & (XMPP_CONN_FLAG_MANDATORY_TLS | XMPP_CONN_FLAG_LEGACY_SSL)) {
+        flags & (XMPP_CONN_FLAG_MANDATORY_TLS | XMPP_CONN_FLAG_LEGACY_SSL |
+                 XMPP_CONN_FLAG_TRUST_TLS)) {
         xmpp_error(conn->ctx, "conn", "Flags 0x%04lx conflict", flags);
         return XMPP_EINVOP;
     }
@@ -951,6 +967,8 @@ int xmpp_conn_set_flags(xmpp_conn_t * const conn, long flags)
     conn->tls_disabled = (flags & XMPP_CONN_FLAG_DISABLE_TLS) ? 1 : 0;
     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;
 }
@@ -1196,6 +1214,9 @@ 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);
@@ -1215,6 +1236,12 @@ static void _conn_reset(xmpp_conn_t * const conn)
     conn->secured = 0;
     conn->tls_failed = 0;
     conn->error = 0;
+
+    conn->tls_support = 0;
+    conn->bind_required = 0;
+    conn->session_required = 0;
+
+    handler_system_delete_all(conn);
 }
 
 static int _conn_connect(xmpp_conn_t * const conn,
@@ -1237,7 +1264,8 @@ static int _conn_connect(xmpp_conn_t * const conn,
     conn->domain = xmpp_strdup(conn->ctx, domain);
     if (!conn->domain) return XMPP_EMEM;
 
-    conn->sock = sock_connect(host, port);
+    conn->xsock = sock_new(conn->ctx, host, port);
+    conn->sock = sock_connect(conn->xsock);
     xmpp_debug(conn->ctx, "xmpp", "sock_connect() to %s:%u returned %d",
                host, port, conn->sock);
     if (conn->sock == -1) return XMPP_EINT;

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,9 +81,37 @@ char *xmpp_sha1(xmpp_ctx_t *ctx, const unsigned char *data, size_t len)
     return digest_to_string_alloc(ctx, digest);
 }
 
-/** Create new SHA1 object
+/** Compute SHA1 message digest.
+ *  Stores digest in user's buffer which must be at least XMPP_SHA1_DIGEST_SIZE
+ *  bytes long.
  *
- *  @param ctx a Strophe context onject
+ *  @param data buffer for digest computation
+ *  @param len size of the data buffer
+ *  @param digest output buffer of XMPP_SHA1_DIGEST_SIZE bytes
+ *
+ *  @ingroup Digests
+ */
+void xmpp_sha1_digest(const unsigned char *data, size_t len,
+                      unsigned char *digest)
+{
+    crypto_SHA1((const uint8_t *)data, len, digest);
+}
+
+/** 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().
+ *  Follow the next use-case for xmpp_sha1_t object:
+ *  @code
+ *      xmpp_sha1_t *sha1 = xmpp_sha1_new(ctx);
+ *      // Repeat update for all chunks of data
+ *      xmpp_sha1_update(sha1, data, len);
+ *      xmpp_sha1_final(sha1);
+ *      char *digest = xmpp_sha1_to_string_alloc(sha1);
+ *      xmpp_sha1_free(sha1);
+ *  @endcode
+ *
+ *  @param ctx a Strophe context object
  *
  *  @return new SHA1 object
  *
@@ -102,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
  *
@@ -113,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
@@ -127,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().
  *
@@ -140,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().
  *
@@ -157,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().
@@ -173,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
@@ -391,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
@@ -407,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.
@@ -443,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/ctx.c

@@ -1,9 +1,9 @@
 /* ctx.c
 ** strophe XMPP client library -- run-time context implementation
 **
-** Copyright (C) 2005-2009 Collecta, Inc. 
+** Copyright (C) 2005-2009 Collecta, Inc.
 **
-**  This software is provided AS-IS with no warranty, either express 
+**  This software is provided AS-IS with no warranty, either express
 **  or implied.
 **
 **  This program is dual licensed under the MIT and GPLv3 licenses.
@@ -36,7 +36,7 @@
  *  result in strange (and platform dependent) behavior.
  *
  *  Specifically, the socket library on Win32 platforms must be initialized
- *  before use (although this is not the case on POSIX systems).  The TLS 
+ *  before use (although this is not the case on POSIX systems).  The TLS
  *  subsystem must also seed the random number generator.
  */
 
@@ -47,6 +47,7 @@
 
 #include "strophe.h"
 #include "common.h"
+#include "resolver.h"
 #include "util.h"
 
 /* Workaround for visual studio without va_copy support. */
@@ -63,6 +64,7 @@
  void xmpp_initialize(void)
 {
     sock_initialize();
+    resolver_initialize();
     tls_initialize();
 }
 
@@ -73,6 +75,7 @@
 void xmpp_shutdown(void)
 {
     tls_shutdown();
+    resolver_shutdown();
     sock_shutdown();
 }
 
@@ -91,6 +94,14 @@ void xmpp_shutdown(void)
 #define LIBXMPP_VERSION_MINOR (0)
 #endif
 
+#ifndef EVENT_LOOP_DEFAULT_TIMEOUT
+/** @def EVENT_LOOP_DEFAULT_TIMEOUT
+ *  The default timeout in milliseconds for the event loop.
+ *  This is set to 1 second.
+ */
+#define EVENT_LOOP_DEFAULT_TIMEOUT 1000
+#endif
+
 /** Check that Strophe supports a specific API version.
  *
  *  @param major the major version number
@@ -103,12 +114,12 @@ void xmpp_shutdown(void)
 int xmpp_version_check(int major, int minor)
 {
     return (major == LIBXMPP_VERSION_MAJOR) &&
-	   (minor >= LIBXMPP_VERSION_MINOR);
+           (minor >= LIBXMPP_VERSION_MINOR);
 }
 
 /* We define the global default allocator, logger, and context here. */
 
-/* Wrap stdlib routines malloc, free, and realloc for default memory 
+/* Wrap stdlib routines malloc, free, and realloc for default memory
  * management. 
  */
 static void *_malloc(const size_t size, void * const userdata)
@@ -137,9 +148,9 @@ static xmpp_mem_t xmpp_default_mem = {
 /* log levels and names */
 static const char * const _xmpp_log_level_name[4] = {"DEBUG", "INFO", "WARN", "ERROR"};
 static const xmpp_log_level_t _xmpp_default_logger_levels[] = {XMPP_LEVEL_DEBUG,
-							       XMPP_LEVEL_INFO,
-							       XMPP_LEVEL_WARN,
-							       XMPP_LEVEL_ERROR};
+                                                               XMPP_LEVEL_INFO,
+                                                               XMPP_LEVEL_WARN,
+                                                               XMPP_LEVEL_ERROR};
 
 /** Log a message.
  *  The default logger writes to stderr.
@@ -151,20 +162,20 @@ static const xmpp_log_level_t _xmpp_default_logger_levels[] = {XMPP_LEVEL_DEBUG,
  *  @param msg the log message
  */
 static void xmpp_default_logger(void * const userdata,
-			 const xmpp_log_level_t level,
-			 const char * const area,
-			 const char * const msg)
+                         const xmpp_log_level_t level,
+                         const char * const area,
+                         const char * const msg)
 {
     xmpp_log_level_t filter_level = * (xmpp_log_level_t*)userdata;
     if (level >= filter_level)
-	fprintf(stderr, "%s %s %s\n", area, _xmpp_log_level_name[level], msg);
+        fprintf(stderr, "%s %s %s\n", area, _xmpp_log_level_name[level], msg);
 }
 
 static const xmpp_log_t _xmpp_default_loggers[] = {
-	{&xmpp_default_logger, (void*)&_xmpp_default_logger_levels[XMPP_LEVEL_DEBUG]},
-	{&xmpp_default_logger, (void*)&_xmpp_default_logger_levels[XMPP_LEVEL_INFO]},
-	{&xmpp_default_logger, (void*)&_xmpp_default_logger_levels[XMPP_LEVEL_WARN]},
-	{&xmpp_default_logger, (void*)&_xmpp_default_logger_levels[XMPP_LEVEL_ERROR]}
+        {&xmpp_default_logger, (void*)&_xmpp_default_logger_levels[XMPP_LEVEL_DEBUG]},
+        {&xmpp_default_logger, (void*)&_xmpp_default_logger_levels[XMPP_LEVEL_INFO]},
+        {&xmpp_default_logger, (void*)&_xmpp_default_logger_levels[XMPP_LEVEL_WARN]},
+        {&xmpp_default_logger, (void*)&_xmpp_default_logger_levels[XMPP_LEVEL_ERROR]}
 };
 
 /** Get a default logger with filtering.
@@ -182,7 +193,6 @@ xmpp_log_t *xmpp_get_default_logger(xmpp_log_level_t level)
 {
     /* clamp to the known range */
     if (level > XMPP_LEVEL_ERROR) level = XMPP_LEVEL_ERROR;
-    if (level < XMPP_LEVEL_DEBUG) level = XMPP_LEVEL_DEBUG;
 
     return (xmpp_log_t*)&_xmpp_default_loggers[level];
 }
@@ -192,7 +202,7 @@ static xmpp_log_t xmpp_default_log = { NULL, NULL };
 /* convenience functions for accessing the context */
 
 /** Allocate memory in a Strophe context.
- *  All Strophe functions will use this to allocate memory. 
+ *  All Strophe functions will use this to allocate memory.
  *
  *  @param ctx a Strophe context object
  *  @param size the number of bytes to allocate
@@ -225,7 +235,7 @@ void xmpp_free(const xmpp_ctx_t * const ctx, void *p)
  *  @return a pointer to the reallocated memory or NULL on an error
  */
 void *xmpp_realloc(const xmpp_ctx_t * const ctx, void *p,
-		   const size_t size)
+                   const size_t size)
 {
     return ctx->mem->realloc(p, size, ctx->mem->userdata);
 }
@@ -234,7 +244,7 @@ void *xmpp_realloc(const xmpp_ctx_t * const ctx, void *p,
  *  Write a log message to the logger for the context for the specified
  *  level and area.  This function takes a printf-style format string and a
  *  variable argument list (in va_list) format.  This function is not meant
- *  to be called directly, but is used via xmpp_error, xmpp_warn, xmpp_info, 
+ *  to be called directly, but is used via xmpp_error, xmpp_warn, xmpp_info,
  *  and xmpp_debug.
  *
  *  @param ctx a Strophe context object
@@ -244,10 +254,10 @@ void *xmpp_realloc(const xmpp_ctx_t * const ctx, void *p,
  *  @param ap variable argument list supplied for the format string
  */
 void xmpp_log(const xmpp_ctx_t * const ctx,
-	      const xmpp_log_level_t level,
-	      const char * const area,
-	      const char * const fmt,
-	      va_list ap)
+              const xmpp_log_level_t level,
+              const char * const area,
+              const char * const fmt,
+              va_list ap)
 {
     int oldret, ret;
     char smbuf[1024];
@@ -257,23 +267,23 @@ void xmpp_log(const xmpp_ctx_t * const ctx,
     va_copy(copy, ap);
     ret = xmpp_vsnprintf(smbuf, sizeof(smbuf), fmt, ap);
     if (ret >= (int)sizeof(smbuf)) {
-	buf = (char *)xmpp_alloc(ctx, ret + 1);
-	if (!buf) {
-	    buf = NULL;
-	    xmpp_error(ctx, "log", "Failed allocating memory for log message.");
-	    va_end(copy);
-	    return;
-	}
-	oldret = ret;
-	ret = xmpp_vsnprintf(buf, ret + 1, fmt, copy);
-	if (ret > oldret) {
-	    xmpp_error(ctx, "log", "Unexpected error");
-	    xmpp_free(ctx, buf);
-	    va_end(copy);
-	    return;
-	}
+        buf = (char *)xmpp_alloc(ctx, ret + 1);
+        if (!buf) {
+            buf = NULL;
+            xmpp_error(ctx, "log", "Failed allocating memory for log message.");
+            va_end(copy);
+            return;
+        }
+        oldret = ret;
+        ret = xmpp_vsnprintf(buf, ret + 1, fmt, copy);
+        if (ret > oldret) {
+            xmpp_error(ctx, "log", "Unexpected error");
+            xmpp_free(ctx, buf);
+            va_end(copy);
+            return;
+        }
     } else {
-	buf = smbuf;
+        buf = smbuf;
     }
     va_end(copy);
 
@@ -286,7 +296,7 @@ void xmpp_log(const xmpp_ctx_t * const ctx,
 
 /** Write to the log at the ERROR level.
  *  This is a convenience function for writing to the log at the
- *  ERROR level.  It takes a printf-style format string followed by a 
+ *  ERROR level.  It takes a printf-style format string followed by a
  *  variable list of arguments for formatting.
  *
  *  @param ctx a Strophe context object
@@ -386,34 +396,35 @@ void xmpp_debug(const xmpp_ctx_t * const ctx,
  *
  *  @ingroup Context
  */
-xmpp_ctx_t *xmpp_ctx_new(const xmpp_mem_t * const mem, 
-			 const xmpp_log_t * const log)
+xmpp_ctx_t *xmpp_ctx_new(const xmpp_mem_t * const mem,
+                         const xmpp_log_t * const log)
 {
     xmpp_ctx_t *ctx = NULL;
 
     if (mem == NULL)
-	ctx = xmpp_default_mem.alloc(sizeof(xmpp_ctx_t), NULL);
+        ctx = xmpp_default_mem.alloc(sizeof(xmpp_ctx_t), NULL);
     else
-	ctx = mem->alloc(sizeof(xmpp_ctx_t), mem->userdata);
+        ctx = mem->alloc(sizeof(xmpp_ctx_t), mem->userdata);
 
     if (ctx != NULL) {
-	if (mem != NULL) 
-	    ctx->mem = mem;
-	else 
-	    ctx->mem = &xmpp_default_mem;
+        if (mem != NULL)
+            ctx->mem = mem;
+        else
+            ctx->mem = &xmpp_default_mem;
 
-	if (log == NULL)
-	    ctx->log = &xmpp_default_log;
-	else
-	    ctx->log = log;
+        if (log == NULL)
+            ctx->log = &xmpp_default_log;
+        else
+            ctx->log = log;
 
-	ctx->connlist = NULL;
-	ctx->loop_status = XMPP_LOOP_NOTSTARTED;
-	ctx->rand = xmpp_rand_new(ctx);
-	if (ctx->rand == NULL) {
-	    xmpp_free(ctx, ctx);
-	    ctx = NULL;
-	}
+        ctx->connlist = NULL;
+        ctx->loop_status = XMPP_LOOP_NOTSTARTED;
+        ctx->rand = xmpp_rand_new(ctx);
+        ctx->timeout = EVENT_LOOP_DEFAULT_TIMEOUT;
+        if (ctx->rand == NULL) {
+            xmpp_free(ctx, ctx);
+            ctx = NULL;
+        }
     }
 
     return ctx;
@@ -432,3 +443,14 @@ void xmpp_ctx_free(xmpp_ctx_t * const ctx)
     xmpp_free(ctx, ctx); /* pull the hole in after us */
 }
 
+/** Set the timeout to use when calling xmpp_run().
+ *
+ *  @param ctx a Strophe context object
+ *  @param timeout the time to wait for events in milliseconds
+ *
+ *  @ingroup Context
+ */
+void xmpp_ctx_set_timeout(xmpp_ctx_t * const ctx, const unsigned long timeout)
+{
+    ctx->timeout = timeout;
+}

src/event.c

@@ -51,13 +51,17 @@
 #include "common.h"
 #include "parser.h"
 
-#ifndef DEFAULT_TIMEOUT
-/** @def DEFAULT_TIMEOUT
- *  The default timeout in milliseconds for the event loop.
- *  This is set to 1 millisecond.
- */
-#define DEFAULT_TIMEOUT 1
-#endif
+static int _connect_next(xmpp_conn_t *conn)
+{
+    sock_close(conn->sock);
+    conn->sock = sock_connect(conn->xsock);
+    if (conn->sock < 0)
+        return -1;
+
+    conn->timeout_stamp = time_stamp();
+
+    return 0;
+}
 
 /** Run the event loop once.
  *  This function will run send any data that has been queued by
@@ -104,8 +108,8 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
             ret = tls_clear_pending_write(conn->tls);
 
             if (ret < 0 && !tls_is_recoverable(tls_error(conn->tls))) {
-                /* an error occured */
-                xmpp_debug(ctx, "xmpp", "Send error occured, disconnecting.");
+                /* an error occurred */
+                xmpp_debug(ctx, "xmpp", "Send error occurred, disconnecting.");
                 conn->error = ECONNABORTED;
                 conn_disconnect(conn);
             }
@@ -118,30 +122,17 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
 
             if (conn->tls) {
                 ret = tls_write(conn->tls, &sq->data[sq->written], towrite);
-
-                if (ret < 0 && !tls_is_recoverable(tls_error(conn->tls))) {
-                    /* an error occured */
+                if (ret < 0 && !tls_is_recoverable(tls_error(conn->tls)))
                     conn->error = tls_error(conn->tls);
-                    break;
-                } else if (ret < towrite) {
-                    /* not all data could be sent now */
-                    if (ret >= 0) sq->written += ret;
-                    break;
-                }
-
             } else {
                 ret = sock_write(conn->sock, &sq->data[sq->written], towrite);
-
-                if (ret < 0 && !sock_is_recoverable(sock_error())) {
-                    /* an error occured */
+                if (ret < 0 && !sock_is_recoverable(sock_error()))
                     conn->error = sock_error();
-                    break;
-                } else if (ret < towrite) {
-                    /* not all data could be sent now */
-                    if (ret >= 0) sq->written += ret;
-                    break;
-                }
             }
+            if (ret > 0 && ret < towrite)
+                sq->written += ret; /* not all data could be sent now */
+            if (ret != towrite)
+                break; /* partial write or an error */
 
             /* all data for this queue item written, delete and move on */
             xmpp_free(ctx, sq->data);
@@ -160,7 +151,7 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
         if (conn->error) {
             /* FIXME: need to tear down send queues and random other things
              * maybe this should be abstracted */
-            xmpp_debug(ctx, "xmpp", "Send error occured, disconnecting.");
+            xmpp_debug(ctx, "xmpp", "Send error occurred, disconnecting.");
             conn->error = ECONNABORTED;
             conn_disconnect(conn);
         }
@@ -175,9 +166,8 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
     }
 
 
-    /* fire any ready timed handlers, then
-       make sure we don't wait past the time when timed handlers need
-       to be called */
+    /* fire any ready timed handlers, then make sure we don't wait past
+       the time when timed handlers need to be called */
     next = handler_fire_timed(ctx);
 
     usec = ((next < timeout) ? next : timeout) * 1000;
@@ -202,6 +192,11 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
                 conn->connect_timeout)
                 FD_SET(conn->sock, &wfds);
             else {
+                ret = _connect_next(conn);
+                if (ret == 0) {
+                    FD_SET(conn->sock, &wfds);
+                    break;
+                }
                 conn->error = ETIMEDOUT;
                 xmpp_info(ctx, "xmpp", "Connection attempt timed out.");
                 conn_disconnect(conn);
@@ -209,6 +204,8 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
             break;
         case XMPP_STATE_CONNECTED:
             FD_SET(conn->sock, &rfds);
+            if (conn->send_queue_len > 0)
+                FD_SET(conn->sock, &wfds);
             break;
         case XMPP_STATE_DISCONNECTED:
             /* do nothing */
@@ -217,9 +214,8 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
         }
 
         /* Check if there is something in the SSL buffer. */
-        if (conn->tls) {
+        if (conn->tls)
             tls_read_bytes += tls_pending(conn->tls);
-        }
 
         if (conn->state != XMPP_STATE_DISCONNECTED && conn->sock > max)
             max = conn->sock;
@@ -259,6 +255,11 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
 
                 /* check for error */
                 ret = sock_connect_error(conn->sock);
+                if (ret != 0) {
+                    ret = _connect_next(conn);
+                    if (ret == 0)
+                        break;
+                }
                 if (ret != 0) {
                     /* connection failed */
                     xmpp_debug(ctx, "xmpp", "connection failed, error %d", ret);
@@ -283,15 +284,12 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
                 if (ret > 0) {
                     ret = parser_feed(conn->parser, buf, ret);
                     if (!ret) {
-                        /* parse error, we need to shut down */
-                        /* FIXME */
-                        xmpp_debug(ctx, "xmpp", "parse error, disconnecting");
-                        conn_disconnect(conn);
+                        xmpp_debug(ctx, "xmpp", "parse error [%s]", buf);
+                        xmpp_send_error(conn, XMPP_SE_INVALID_XML, "parse error");
                     }
                 } else {
                     if (conn->tls) {
-                        if (!tls_is_recoverable(tls_error(conn->tls)))
-                        {
+                        if (!tls_is_recoverable(tls_error(conn->tls))) {
                             xmpp_debug(ctx, "xmpp", "Unrecoverable TLS error, %d.", tls_error(conn->tls));
                             conn->error = tls_error(conn->tls);
                             conn_disconnect(conn);
@@ -333,7 +331,7 @@ void xmpp_run(xmpp_ctx_t *ctx)
 
     ctx->loop_status = XMPP_LOOP_RUNNING;
     while (ctx->loop_status == XMPP_LOOP_RUNNING) {
-        xmpp_run_once(ctx, DEFAULT_TIMEOUT);
+        xmpp_run_once(ctx, ctx->timeout);
     }
 
     /* make it possible to start event loop again */

src/handler.c

@@ -1,7 +1,7 @@
 /* handler.c
 ** strophe XMPP client library -- event handler management
 **
-** 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.
@@ -24,6 +24,31 @@
 #include "common.h"
 #include "ostypes.h"
 
+/* Remove item from the list pointed by head, but don't free it.
+ * There can be a situation when user's handler deletes another handler which
+ * is the previous in the list. handler_fire_stanza() and handler_fire_timed()
+ * must handle this situation correctly. Current function helps to avoid
+ * list corruption in described scenario.
+ *
+ * TODO Convert handler lists to double-linked lists. Current implementation
+ * works for O(n).
+ */
+static void _handler_item_remove(xmpp_handlist_t **head,
+                                 xmpp_handlist_t *item)
+{
+    xmpp_handlist_t *i = *head;
+
+    if (i == item)
+        *head = item->next;
+    else if (i != NULL) {
+        while (i->next != NULL && i->next != item)
+            i = i->next;
+        if (i->next == item) {
+            i->next = item->next;
+        }
+    }
+}
+
 /** Fire off all stanza handlers that match.
  *  This function is called internally by the event loop whenever stanzas
  *  are received from the XMPP server.
@@ -32,92 +57,83 @@
  *  @param stanza a Strophe stanza object
  */
 void handler_fire_stanza(xmpp_conn_t * const conn,
-			 xmpp_stanza_t * const stanza)
+                         xmpp_stanza_t * const stanza)
 {
-    xmpp_handlist_t *item, *prev;
+    xmpp_handlist_t *item, *next, *head, *head_old;
     const char *id, *ns, *name, *type;
-    
+    int ret;
+
     /* call id handlers */
     id = xmpp_stanza_get_id(stanza);
     if (id) {
-	prev = NULL;
- 	item = (xmpp_handlist_t *)hash_get(conn->id_handlers, id);
-	while (item) {
-	    xmpp_handlist_t *next = item->next;
+        head = (xmpp_handlist_t *)hash_get(conn->id_handlers, id);
+        /* enable all added handlers */
+        for (item = head; item; item = item->next)
+            item->enabled = 1;
 
-	    if (item->user_handler && !conn->authenticated) {
-		item = next;
- 		continue;
-	    }
+        item = head;
+        while (item) {
+            /* don't fire user handlers until authentication succeeds and
+               and skip newly added handlers */
+            if ((item->user_handler && !conn->authenticated) || !item->enabled) {
+                item = item->next;
+                continue;
+            }
 
-	    if (!((xmpp_handler)(item->handler))(conn, stanza, item->userdata)) {
-		/* handler is one-shot, so delete it */
-		if (prev)
-		    prev->next = next;
-		else {
-		    hash_drop(conn->id_handlers, id);
-		    hash_add(conn->id_handlers, id, next);
-		}
+            ret = ((xmpp_handler)(item->handler))(conn, stanza, item->userdata);
+            next = item->next;
+            if (!ret) {
+                /* handler is one-shot, so delete it */
+                head_old = head;
+                _handler_item_remove(&head, item);
+                if (head != head_old) {
+                    /* replace old value */
+                    hash_add(conn->id_handlers, id, head);
+                }
                 xmpp_free(conn->ctx, item->id);
-		xmpp_free(conn->ctx, item);
-		item = NULL;
-	    }
-	    if (item)
-		prev = item;
-	    item = next;
-	}
+                xmpp_free(conn->ctx, item);
+            }
+            item = next;
+        }
     }
-    
+
     /* call handlers */
     ns = xmpp_stanza_get_ns(stanza);
     name = xmpp_stanza_get_name(stanza);
     type = xmpp_stanza_get_type(stanza);
-    
+
     /* enable all added handlers */
     for (item = conn->handlers; item; item = item->next)
-	item->enabled = 1;
+        item->enabled = 1;
 
-    prev = NULL;
     item = conn->handlers;
     while (item) {
-	/* skip newly added handlers */
-	if (!item->enabled) {
-	    prev = item;
-	    item = item->next;
-	    continue;
-	}
+        /* don't fire user handlers until authentication succeeds and
+           skip newly added handlers */
+        if ((item->user_handler && !conn->authenticated) || !item->enabled) {
+            item = item->next;
+            continue;
+        }
 
-	/* don't call user handlers until authentication succeeds */
-	if (item->user_handler && !conn->authenticated) {
-	    prev = item;
-	    item = item->next;
-	    continue;
-	}
+        next = item->next;
+        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))) {
 
-	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)))
-	    if (!((xmpp_handler)(item->handler))(conn, stanza, item->userdata)) {
-		/* handler is one-shot, so delete it */
-		if (prev)
-		    prev->next = item->next;
-		else
-		    conn->handlers = item->next;
+            ret = ((xmpp_handler)(item->handler))(conn, stanza, item->userdata);
+            /* list may be changed during execution of a handler */
+            next = item->next;
+            if (!ret) {
+                /* handler is one-shot, so delete it */
+                _handler_item_remove(&conn->handlers, item);
                 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 = NULL;
-	    }
-	
-	if (item) {
-	    prev = item;
-	    item = item->next;
-	} else if (prev)
-	    item = prev->next;
-	else
-	    item = conn->handlers;
+                xmpp_free(conn->ctx, item);
+            }
+        }
+        item = next;
     }
 }
 
@@ -131,57 +147,56 @@ void handler_fire_stanza(xmpp_conn_t * const conn,
 uint64_t handler_fire_timed(xmpp_ctx_t * const ctx)
 {
     xmpp_connlist_t *connitem;
-    xmpp_handlist_t *handitem, *temp;
-    int ret, fired;
+    xmpp_handlist_t *item, *next;
+    xmpp_conn_t *conn;
     uint64_t elapsed, min;
+    uint64_t timestamp;
+    int ret;
 
     min = (uint64_t)(-1);
 
     connitem = ctx->connlist;
     while (connitem) {
-	if (connitem->conn->state != XMPP_STATE_CONNECTED) {
-	    connitem = connitem->next;
-	    continue;
-	}
-	
-	/* enable all handlers that were added */
-	for (handitem = connitem->conn->timed_handlers; handitem;
-	     handitem = handitem->next)
-	    handitem->enabled = 1;
+        conn = connitem->conn;
+        if (conn->state != XMPP_STATE_CONNECTED) {
+            connitem = connitem->next;
+            continue;
+        }
 
-	handitem = connitem->conn->timed_handlers;
-	while (handitem) {
-	    /* skip newly added handlers */
-	    if (!handitem->enabled) {
-		handitem = handitem->next;
-		continue;
-	    }
+        /* enable all handlers that were added */
+        for (item = conn->timed_handlers; item; item = item->next)
+            item->enabled = 1;
 
-	    /* only fire user handlers after authentication */
-	    if (handitem->user_handler && !connitem->conn->authenticated) {
-		handitem = handitem->next;
-		continue;
-	    }
+        item = conn->timed_handlers;
+        while (item) {
+            /* don't fire user handlers until authentication succeeds and
+               skip newly added handlers */
+            if ((item->user_handler && !conn->authenticated) || !item->enabled) {
+                item = item->next;
+                continue;
+            }
 
-	    fired = 0;
-	    elapsed = time_elapsed(handitem->last_stamp, time_stamp());
-	    if (elapsed >= handitem->period) {
-		/* fire! */
-		fired = 1;
-		handitem->last_stamp = time_stamp();
-		ret = ((xmpp_timed_handler)handitem->handler)(connitem->conn, handitem->userdata);
-	    } else if (min > (handitem->period - elapsed))
-		min = handitem->period - elapsed;
-		
-	    temp = handitem;
-	    handitem = handitem->next;
+            next = item->next;
+            timestamp = time_stamp();
+            elapsed = time_elapsed(item->last_stamp, timestamp);
+            if (elapsed >= item->period) {
+                /* fire! */
+                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;
+                if (!ret) {
+                    /* delete handler if it returned false */
+                    _handler_item_remove(&conn->timed_handlers, item);
+                    xmpp_free(conn->ctx, item);
+                }
+            } else if (min > (item->period - elapsed))
+                min = item->period - elapsed;
 
-	    /* delete handler if it returned false */
-	    if (fired && !ret)
-		xmpp_timed_handler_delete(connitem->conn, temp->handler);
-	}
+            item = next;
+        }
 
-	connitem = connitem->next;
+        connitem = connitem->next;
     }
 
     return min;
@@ -199,25 +214,27 @@ 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->last_stamp = time_stamp();
-	
-	handitem = handitem->next;
+        if ((user_only && handitem->user_handler) || !user_only)
+            handitem->last_stamp = time_stamp();
+
+        handitem = handitem->next;
     }
 }
 
 static void _timed_handler_add(xmpp_conn_t * const conn,
-			       xmpp_timed_handler handler,
-			       const unsigned long period,
-			       void * const userdata, 
-			       const int user_handler)
+                               xmpp_timed_handler handler,
+                               const unsigned long period,
+                               void * const userdata,
+                               const int user_handler)
 {
     xmpp_handlist_t *item, *tail;
 
     /* check if handler is already in the list */
     for (item = conn->timed_handlers; item; item = item->next) {
-	if (item->handler == (void *)handler)
-	    break;
+        if (item->handler == handler && item->userdata == userdata) {
+            xmpp_warn(conn->ctx, "xmpp", "Timed handler already exists.");
+            break;
+        }
     }
     if (item) return;
 
@@ -226,7 +243,7 @@ static void _timed_handler_add(xmpp_conn_t * const conn,
     if (!item) return;
 
     item->user_handler = user_handler;
-    item->handler = (void *)handler;
+    item->handler = handler;
     item->userdata = userdata;
     item->enabled = 0;
     item->next = NULL;
@@ -236,12 +253,12 @@ static void _timed_handler_add(xmpp_conn_t * const conn,
 
     /* append item to list */
     if (!conn->timed_handlers)
-	conn->timed_handlers = item;
+        conn->timed_handlers = item;
     else {
-	tail = conn->timed_handlers;
-	while (tail->next) 
-	    tail = tail->next;
-	tail->next = item;
+        tail = conn->timed_handlers;
+        while (tail->next)
+            tail = tail->next;
+        tail->next = item;
     }
 }
 
@@ -253,7 +270,7 @@ static void _timed_handler_add(xmpp_conn_t * const conn,
  *  @ingroup Handlers
  */
 void xmpp_timed_handler_delete(xmpp_conn_t * const conn,
-			       xmpp_timed_handler handler)
+                               xmpp_timed_handler handler)
 {
     xmpp_handlist_t *item, *prev;
 
@@ -262,35 +279,36 @@ void xmpp_timed_handler_delete(xmpp_conn_t * const conn,
     prev = NULL;
     item = conn->timed_handlers;
     while (item) {
-	if (item->handler == (void *)handler)
-	    break;
-	prev = item;
-	item = item->next;
-    }
+        if (item->handler == handler) {
+            if (prev)
+                prev->next = item->next;
+            else
+                conn->timed_handlers = item->next;
 
-    if (item) {
-	if (prev)
-	    prev->next = item->next;
-	else
-	    conn->timed_handlers = item->next;
-	
-	xmpp_free(conn->ctx, item);
+            xmpp_free(conn->ctx, item);
+            item = prev ? prev->next : conn->timed_handlers;
+        } else {
+            prev = item;
+            item = item->next;
+        }
     }
 }
 
 static void _id_handler_add(xmpp_conn_t * const conn,
-			 xmpp_handler handler,
-			 const char * const id,
-			 void * const userdata, int user_handler)
+                         xmpp_handler handler,
+                         const char * const id,
+                         void * const userdata, int user_handler)
 {
     xmpp_handlist_t *item, *tail;
 
     /* check if handler is already in the list */
     item = (xmpp_handlist_t *)hash_get(conn->id_handlers, id);
     while (item) {
-	if (item->handler == (void *)handler)
-	    break;
-	item = item->next;
+        if (item->handler == handler && item->userdata == userdata) {
+            xmpp_warn(conn->ctx, "xmpp", "Id handler already exists.");
+            break;
+        }
+        item = item->next;
     }
     if (item) return;
 
@@ -299,25 +317,25 @@ static void _id_handler_add(xmpp_conn_t * const conn,
     if (!item) return;
 
     item->user_handler = user_handler;
-    item->handler = (void *)handler;
+    item->handler = handler;
     item->userdata = userdata;
     item->enabled = 0;
     item->next = NULL;
 
     item->id = xmpp_strdup(conn->ctx, id);
     if (!item->id) {
-	xmpp_free(conn->ctx, item);
-	return;
+        xmpp_free(conn->ctx, item);
+        return;
     }
 
     /* put on list in hash table */
     tail = (xmpp_handlist_t *)hash_get(conn->id_handlers, id);
     if (!tail)
-	hash_add(conn->id_handlers, id, item);
+        hash_add(conn->id_handlers, id, item);
     else {
-	while (tail->next) 
-	    tail = tail->next;
-	tail->next = item;
+        while (tail->next)
+            tail = tail->next;
+        tail->next = item;
     }
 }
 
@@ -330,49 +348,54 @@ static void _id_handler_add(xmpp_conn_t * const conn,
  *  @ingroup Handlers
  */
 void xmpp_id_handler_delete(xmpp_conn_t * const conn,
-			    xmpp_handler handler,
-			    const char * const id)
+                            xmpp_handler handler,
+                            const char * const id)
 {
-    xmpp_handlist_t *item, *prev;
+    xmpp_handlist_t *item, *prev, *next;
 
     prev = NULL;
     item = (xmpp_handlist_t *)hash_get(conn->id_handlers, id);
     if (!item) return;
 
     while (item) {
-	if (item->handler == (void *)handler)
-	    break;
+        next = item->next;
 
-	prev = item;
-	item = item->next;
-    }
+        if (item->handler == handler) {
+            if (prev)
+                prev->next = next;
+            else {
+                hash_drop(conn->id_handlers, id);
+                hash_add(conn->id_handlers, id, next);
+            }
 
-    if (item) {
-	if (prev)
-	    prev->next = item->next;
-	else {
-	    hash_drop(conn->id_handlers, id);
-	    hash_add(conn->id_handlers, id, item->next);
-	}
-	xmpp_free(conn->ctx, item->id);
-	xmpp_free(conn->ctx, item);
+            xmpp_free(conn->ctx, item->id);
+            xmpp_free(conn->ctx, item);
+            item = next;
+        } else {
+            prev = item;
+            item = next;
+        }
     }
 }
 
 /* add a stanza handler */
 static void _handler_add(xmpp_conn_t * const conn,
-			 xmpp_handler handler,
-			 const char * const ns,
-			 const char * const name,
-			 const char * const type,
-			 void * const userdata, int user_handler)
+                         xmpp_handler handler,
+                         const char * const ns,
+                         const char * const name,
+                         const char * const type,
+                         void * const userdata, int user_handler)
 {
     xmpp_handlist_t *item, *tail;
 
     /* check if handler already in list */
     for (item = conn->handlers; item; item = item->next) {
-	if (item->handler == (void *)handler)
-	    break;
+        /* same handler function can process different stanzas and
+           distinguish them according to userdata. */
+        if (item->handler == handler && item->userdata == userdata) {
+            xmpp_warn(conn->ctx, "xmpp", "Stanza handler already exists.");
+            break;
+        }
     }
     if (item) return;
 
@@ -381,46 +404,46 @@ static void _handler_add(xmpp_conn_t * const conn,
     if (!item) return;
 
     item->user_handler = user_handler;
-    item->handler = (void *)handler;
+    item->handler = handler;
     item->userdata = userdata;
     item->enabled = 0;
     item->next = NULL;
-    
+
     if (ns) {
-	item->ns = xmpp_strdup(conn->ctx, ns);
-	if (!item->ns) {
-	    xmpp_free(conn->ctx, item);
-	    return;
-	}
+        item->ns = xmpp_strdup(conn->ctx, ns);
+        if (!item->ns) {
+            xmpp_free(conn->ctx, item);
+            return;
+        }
     } else
-	item->ns = NULL;
+        item->ns = NULL;
     if (name) {
-	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;
-	}
+        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->name = NULL;
+        item->name = NULL;
     if (type) {
-	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);
-	}
+        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->type = NULL;
+        item->type = NULL;
 
     /* append to list */
     if (!conn->handlers)
-	conn->handlers = item;
+        conn->handlers = item;
     else {
-	tail = conn->handlers;
-	while (tail->next) 
-	    tail = tail->next;
-	tail->next = item;
+        tail = conn->handlers;
+        while (tail->next)
+            tail = tail->next;
+        tail->next = item;
     }
 }
 
@@ -432,7 +455,7 @@ static void _handler_add(xmpp_conn_t * const conn,
  *  @ingroup Handlers
  */
 void xmpp_handler_delete(xmpp_conn_t * const conn,
-			 xmpp_handler handler)
+                         xmpp_handler handler)
 {
     xmpp_handlist_t *prev, *item;
 
@@ -441,23 +464,21 @@ void xmpp_handler_delete(xmpp_conn_t * const conn,
     prev = NULL;
     item = conn->handlers;
     while (item) {
-	if (item->handler == (void *)handler)
-	    break;
-	
-	prev = item;
-	item = item->next;
-    }
+        if (item->handler == handler) {
+            if (prev)
+                prev->next = item->next;
+            else
+                conn->handlers = item->next;
 
-    if (item) {
-	if (prev)
-	    prev->next = item->next;
-	else
-	    conn->handlers = item->next;
-
-	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);
+            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 {
+            prev = item;
+            item = item->next;
+        }
     }
 }
 
@@ -466,7 +487,7 @@ void xmpp_handler_delete(xmpp_conn_t * const conn,
  *  and continue firing regularly after that.  Strophe will try its best
  *  to fire handlers as close to the period times as it can, but accuracy
  *  will vary depending on the resolution of the event loop.
- *   
+ *
  *  If the handler function returns true, it will be kept, and if it
  *  returns false, it will be deleted from the list of handlers.
  *
@@ -478,9 +499,9 @@ void xmpp_handler_delete(xmpp_conn_t * const conn,
  *  @ingroup Handlers
  */
 void xmpp_timed_handler_add(xmpp_conn_t * const conn,
-			    xmpp_timed_handler handler,
-			    const unsigned long period,
-			    void * const userdata)
+                            xmpp_timed_handler handler,
+                            const unsigned long period,
+                            void * const userdata)
 {
     _timed_handler_add(conn, handler, period, userdata, 1);
 }
@@ -495,9 +516,9 @@ void xmpp_timed_handler_add(xmpp_conn_t * const conn,
  *  @param userdata an opaque data pointer that will be passed to the handler
  */
 void handler_add_timed(xmpp_conn_t * const conn,
-		       xmpp_timed_handler handler,
-		       const unsigned long period,
-		       void * const userdata)
+                       xmpp_timed_handler handler,
+                       const unsigned long period,
+                       void * const userdata)
 {
     _timed_handler_add(conn, handler, period, userdata, 0);
 }
@@ -519,9 +540,9 @@ void handler_add_timed(xmpp_conn_t * const conn,
  *  @ingroup Handlers
  */
 void xmpp_id_handler_add(xmpp_conn_t * const conn,
-			 xmpp_handler handler,
-			 const char * const id,
-			 void * const userdata)
+                         xmpp_handler handler,
+                         const char * const id,
+                         void * const userdata)
 {
     _id_handler_add(conn, handler, id, userdata, 1);
 }
@@ -536,9 +557,9 @@ void xmpp_id_handler_add(xmpp_conn_t * const conn,
  *  @param userdata an opaque data pointer that will be passed to the handler
  */
 void handler_add_id(xmpp_conn_t * const conn,
-		    xmpp_handler handler,
-		    const char * const id,
-		    void * const userdata)
+                    xmpp_handler handler,
+                    const char * const id,
+                    void * const userdata)
 {
     _id_handler_add(conn, handler, id, userdata, 0);
 }
@@ -566,11 +587,11 @@ void handler_add_id(xmpp_conn_t * const conn,
  *  @ingroup Handlers
  */
 void xmpp_handler_add(xmpp_conn_t * const conn,
-		      xmpp_handler handler,
-		      const char * const ns,
-		      const char * const name,
-		      const char * const type,
-		      void * const userdata)
+                      xmpp_handler handler,
+                      const char * const ns,
+                      const char * const name,
+                      const char * const type,
+                      void * const userdata)
 {
     _handler_add(conn, handler, ns, name, type, userdata, 1);
 }
@@ -587,11 +608,83 @@ void xmpp_handler_add(xmpp_conn_t * const conn,
  *  @param userdata an opaque data pointer that will be passed to the handler
  */
 void handler_add(xmpp_conn_t * const conn,
-		 xmpp_handler handler,
-		 const char * const ns,
-		 const char * const name,
-		 const char * const type,
-		 void * const userdata)
+                 xmpp_handler handler,
+                 const char * const ns,
+                 const char * const name,
+                 const char * const type,
+                 void * const userdata)
 {
     _handler_add(conn, handler, ns, name, type, userdata, 0);
 }
+
+/** Delete all system handlers.
+ *  This function is used to reset conn object before re-connecting.
+ *
+ *  @param conn a Strophe connection object
+ */
+void handler_system_delete_all(xmpp_conn_t *conn)
+{
+    xmpp_handlist_t *item, *next, *head, *head_old;
+    hash_iterator_t *iter;
+    const char *key;
+    char *key2 = NULL;
+
+    /* TODO unify all kinds of handlers and avoid copy-paste below */
+
+    item = conn->handlers;
+    while (item) {
+        if (!item->user_handler) {
+            next = item->next;
+            _handler_item_remove(&conn->handlers, item);
+            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
+            item = item->next;
+    }
+
+    item = conn->timed_handlers;
+    while (item) {
+        if (!item->user_handler) {
+            next = item->next;
+            _handler_item_remove(&conn->timed_handlers, item);
+            xmpp_free(conn->ctx, item);
+            item = next;
+        } else
+            item = item->next;
+    }
+
+    iter = hash_iter_new(conn->id_handlers);
+    key = iter == NULL ? NULL : hash_iter_next(iter);
+    while (key != NULL) {
+        head = head_old = (xmpp_handlist_t *)hash_get(conn->id_handlers, key);
+        item = head;
+        while (item) {
+            if (!item->user_handler) {
+                next = item->next;
+                _handler_item_remove(&head, item);
+                xmpp_free(conn->ctx, item->id);
+                xmpp_free(conn->ctx, item);
+                item = next;
+            } else
+                item = item->next;
+        }
+        if (head != head_old)
+            key2 = xmpp_strdup(conn->ctx, key);
+        /* Hash table implementation is not perfect, so we need to find next
+           key before dropping current one. Otherwise, we will get access to
+           freed memory. */
+        key = hash_iter_next(iter);
+        if (head != head_old) {
+            /* hash_add() replaces value if the key exists */
+            if (head != NULL)
+                hash_add(conn->id_handlers, key2, head);
+            else
+                hash_drop(conn->id_handlers, key2);
+            xmpp_free(conn->ctx, key2);
+        }
+    }
+    if (iter) hash_iter_release(iter);
+}

src/hash.c

@@ -106,18 +106,35 @@ void hash_release(hash_t * const table)
 /** hash a key for our table lookup */
 static int _hash_key(hash_t *table, const char *key)
 {
-   int hash = 0;
-   int shift = 0;
-   const char *c = key;
+   unsigned hash = 0;
+   unsigned shift = 0;
+   const unsigned char *c = (const unsigned char *)key;
 
-   while (*c != '\0') {
+   while (*c != 0) {
 	/* assume 32 bit ints */
-	hash ^= ((int)*c++ << shift);
+	hash ^= ((unsigned)*c++ << shift);
 	shift += 8;
 	if (shift > 24) shift = 0;
    }
+   return hash % (unsigned)table->length;
+}
 
-   return hash % table->length;
+hashentry_t *_hash_entry_find(hash_t *table, const char *key)
+{
+   hashentry_t *entry;
+   int table_index = _hash_key(table, key);
+
+   /* look up the hash entry */
+   entry = table->entries[table_index];
+   while (entry != NULL) {
+	/* traverse the linked list looking for the key */
+	if (!strcmp(key, entry->key)) {
+	  /* match */
+          break;
+	}
+	entry = entry->next;
+   }
+   return entry;
 }
 
 /** add a key, value pair to a hash table.
@@ -130,23 +147,27 @@ int hash_add(hash_t *table, const char * const key, void *data)
    hashentry_t *entry = NULL;
    int table_index = _hash_key(table, key);
 
-   /* drop existing entry, if any */
-   hash_drop(table, key);
+   /* find and replace existing entry, if any */
+   entry = _hash_entry_find(table, key);
 
-   /* allocate and fill a new entry */
-   entry = xmpp_alloc(ctx, sizeof(hashentry_t));
-   if (!entry) return -1;
-   entry->key = xmpp_strdup(ctx, key);
-   if (!entry->key) {
-       xmpp_free(ctx, entry);
-       return -1;
+   if (entry == NULL) {
+      /* allocate and fill a new entry */
+      entry = xmpp_alloc(ctx, sizeof(hashentry_t));
+      if (!entry) return -1;
+      entry->key = xmpp_strdup(ctx, key);
+      if (!entry->key) {
+         xmpp_free(ctx, entry);
+         return -1;
+      }
+      /* insert ourselves in the linked list */
+      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;
-   /* insert ourselves in the linked list */
-   /* TODO: this leaks duplicate keys */
-   entry->next = table->entries[table_index];
-   table->entries[table_index] = entry;
-   table->num_keys++;
 
    return 0;
 }
@@ -155,22 +176,9 @@ int hash_add(hash_t *table, const char * const key, void *data)
 void *hash_get(hash_t *table, const char *key)
 {
    hashentry_t *entry;
-   int table_index = _hash_key(table, key);
-   void *result = NULL;
 
-   /* look up the hash entry */
-   entry = table->entries[table_index];
-   while (entry != NULL) {
-	/* traverse the linked list looking for the key */
-	if (!strcmp(key, entry->key)) {
-	  /* match */
-	  result = entry->value;
-	  return result;
-	}
-	entry = entry->next;
-   }
-   /* no match */
-   return result;
+   entry = _hash_entry_find(table, key);
+   return entry == NULL ? NULL : entry->value;
 }
 
 /** delete a key from a hash table */
@@ -235,7 +243,7 @@ void hash_iter_release(hash_iterator_t *iter)
 
     iter->ref--;
 
-    if (iter->ref <= 0) {
+    if (iter->ref == 0) { // ref is unsigned!!!
 	hash_release(iter->table);
 	xmpp_free(ctx, iter);
     }
@@ -273,4 +281,3 @@ const char * hash_iter_next(hash_iterator_t *iter)
     iter->entry = entry;
     return entry->key;
 }
-

src/jid.c

@@ -72,15 +72,13 @@ char *xmpp_jid_new(xmpp_ctx_t *ctx, const char *node,
 char *xmpp_jid_bare(xmpp_ctx_t *ctx, const char *jid)
 {
     char *result;
-    const char *c;
+    size_t len;
 
-    c = strchr(jid, '/');
-    if (c == NULL) return xmpp_strdup(ctx, jid);
-
-    result = xmpp_alloc(ctx, c-jid+1);
+    len = strcspn(jid, "/");
+    result = xmpp_alloc(ctx, len + 1);
     if (result != NULL) {
-	memcpy(result, jid, c-jid);
-	result[c-jid] = '\0';
+	memcpy(result, jid, len);
+	result[len] = '\0';
     }
 
     return result;
@@ -121,7 +119,8 @@ char *xmpp_jid_node(xmpp_ctx_t *ctx, const char *jid)
 char *xmpp_jid_domain(xmpp_ctx_t *ctx, const char *jid)
 {
     char *result = NULL;
-    const char *c,*s;
+    const char *c;
+    size_t dlen;
 
     c = strchr(jid, '@');
     if (c == NULL) {
@@ -131,15 +130,11 @@ char *xmpp_jid_domain(xmpp_ctx_t *ctx, const char *jid)
 	/* advance past the separator */
 	c++;
     }
-    s = strchr(c, '/');
-    if (s == NULL) {
-	/* no resource */
-	s = c + strlen(c);
-    }
-    result = xmpp_alloc(ctx, (s-c) + 1);
+    dlen = strcspn(c, "/"); /* do not include resource */
+    result = xmpp_alloc(ctx, dlen + 1);
     if (result != NULL) {
-	memcpy(result, c, (s-c));
-	result[s-c] = '\0';
+	memcpy(result, c, dlen);
+	result[dlen] = '\0';
     }
 
     return result;
@@ -155,20 +150,8 @@ char *xmpp_jid_domain(xmpp_ctx_t *ctx, const char *jid)
  */
 char *xmpp_jid_resource(xmpp_ctx_t *ctx, const char *jid)
 {
-    char *result = NULL;
     const char *c;
-    size_t len;
 
     c = strchr(jid, '/');
-    if (c != NULL)  {
-	c++;
-	len = strlen(c);
-	result = xmpp_alloc(ctx, len + 1);
-	if (result != NULL) {
-	    memcpy(result, c, len);
-	    result[len] = '\0';
-	}
-    }
-
-    return result;
+    return c != NULL ? xmpp_strdup(ctx, c + 1) : NULL;
 }

src/oocontext.cpp

@@ -1,7 +1,7 @@
 /* oocontext.cpp
 ** strophe XMPP client library -- C++ context implementation
-** 
-** 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.
@@ -14,7 +14,7 @@
 #include "strophe.h"
 #include "strophepp.h"
 
-XMPP::Context::Context() 
+XMPP::Context::Context()
 {
     m_mem.alloc = callAlloc;
     m_mem.realloc = callRealloc;
@@ -48,8 +48,8 @@ void XMPP::Context::free(void *p)
 }
 
 void XMPP::Context::log(const xmpp_log_level_t level,
-			const char * const area,
-			const char * const msg)
+                        const char * const area,
+                        const char * const msg)
 {
     /* do nothing by default */
 }
@@ -65,7 +65,7 @@ void *XMPP::Context::callAlloc(const size_t size, void * const userdata)
 }
 
 void *XMPP::Context::callRealloc(void *p, const size_t size,
-				 void * const userdata)
+                                 void * const userdata)
 {
     return reinterpret_cast<Context *>(userdata)->realloc(p, size);
 }
@@ -76,10 +76,9 @@ void XMPP::Context::callFree(void *p, void * const userdata)
 }
 
 void XMPP::Context::callLog(void * const userdata,
-			    const xmpp_log_level_t level,
-			    const char * const area,
-			    const char * const msg)
+                            const xmpp_log_level_t level,
+                            const char * const area,
+                            const char * const msg)
 {
     reinterpret_cast<Context *>(userdata)->log(level, area, msg);
 }
-

src/oostanza.cpp

@@ -1,7 +1,7 @@
 /* oostanza.cpp
 ** strophe XMPP client library -- C++ context implementation
-** 
-** 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.
@@ -28,8 +28,8 @@ void *Stanza::operator new(size_t size, Context *ctx)
     if (!p) return p;
 
     *reinterpret_cast<Context **>(p) = ctx;
-    p = reinterpret_cast<void *>(reinterpret_cast<char *>(p) + 
-				 sizeof(Context *));
+    p = reinterpret_cast<void *>(reinterpret_cast<char *>(p) +
+                                 sizeof(Context *));
 
     return p;
 }
@@ -61,7 +61,7 @@ Stanza *Stanza::create(Context *ctx)
 void Stanza::release()
 {
     if (::xmpp_stanza_release(m_stanza))
-	delete this;
+        delete this;
 }
 
 Stanza *Stanza::clone()
@@ -75,5 +75,3 @@ Stanza *Stanza::copy()
     // TODO
     return NULL;
 }
-
-

src/parser_expat.c

@@ -26,6 +26,12 @@
 /* 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
+ * number of re-allocations in 2 times for multi-line texts. */
+#define INNER_TEXT_PADDING 2
+
 struct _parser_t {
     xmpp_ctx_t *ctx;
     XML_Parser expat;
@@ -35,6 +41,11 @@ struct _parser_t {
     void *userdata;
     int depth;
     xmpp_stanza_t *stanza;
+    char* inner_text;
+    /* number of allocated bytes */
+    int inner_text_size;
+    /* excluding terminal '\0' */
+    int inner_text_used;
 };
 
 /* return allocated string with the name from a delimited
@@ -92,6 +103,26 @@ static void _set_attributes(xmpp_stanza_t *stanza, const XML_Char **attrs)
     }
 }
 
+static void complete_inner_text(parser_t *parser)
+{
+    xmpp_stanza_t *stanza;
+
+    if (parser->inner_text) {
+        /* create and populate stanza */
+        stanza = xmpp_stanza_new(parser->ctx);
+        /* FIXME: disconnect on allocation error */
+        if (stanza) {
+            xmpp_stanza_set_text(stanza, parser->inner_text);
+            xmpp_stanza_add_child(parser->stanza, stanza);
+            xmpp_stanza_release(stanza);
+        }
+        xmpp_free(parser->ctx, parser->inner_text);
+        parser->inner_text = NULL;
+        parser->inner_text_size = 0;
+        parser->inner_text_used = 0;
+    }
+}
+
 static void _start_element(void *userdata,
                            const XML_Char *nsname,
                            const XML_Char **attrs)
@@ -106,7 +137,7 @@ static void _start_element(void *userdata,
     if (parser->depth == 0) {
         /* notify the owner */
         if (parser->startcb)
-            parser->startcb((char *)name, (char **)attrs, 
+            parser->startcb(name, (char **)attrs,
                             parser->userdata);
     } else {
         /* build stanzas at depth 1 */
@@ -125,6 +156,7 @@ static void _start_element(void *userdata,
                 xmpp_stanza_set_ns(child, ns);
 
             if (parser->stanza != NULL) {
+                complete_inner_text(parser);
                 xmpp_stanza_add_child(parser->stanza, child);
                 xmpp_stanza_release(child);
             }
@@ -149,36 +181,46 @@ static void _end_element(void *userdata, const XML_Char *name)
         if (parser->endcb)
             parser->endcb((char *)name, parser->userdata);
     } else {
-	if (parser->stanza->parent) {
-	    /* we're finishing a child stanza, so set current to the parent */
-	    parser->stanza = parser->stanza->parent;
-	} else {
+        complete_inner_text(parser);
+        if (parser->stanza->parent) {
+            /* we're finishing a child stanza, so set current to the parent */
+            parser->stanza = parser->stanza->parent;
+        } else {
             if (parser->stanzacb)
                 parser->stanzacb(parser->stanza,
                                  parser->userdata);
-	    xmpp_stanza_release(parser->stanza);
-	    parser->stanza = NULL;
-	}
+            xmpp_stanza_release(parser->stanza);
+            parser->stanza = NULL;
+        }
     }
 }
 
 static void _characters(void *userdata, const XML_Char *s, int len)
 {
     parser_t *parser = (parser_t *)userdata;
-    xmpp_stanza_t *stanza;
+    char *p;
 
     if (parser->depth < 2) return;
 
-    /* create and populate stanza */
-    stanza = xmpp_stanza_new(parser->ctx);
-    if (!stanza) {
-	/* FIXME: allocation error, disconnect */
-	return;
+    /* Join all parts to a single resulting string. Stanza is created in
+     * _start_element() and _end_element(). */
+    if (parser->inner_text_used + len >= parser->inner_text_size) {
+        parser->inner_text_size = parser->inner_text_used + len + 1 +
+                                  INNER_TEXT_PADDING;
+        p = xmpp_realloc(parser->ctx, parser->inner_text,
+                         parser->inner_text_size);
+        if (p == NULL) {
+            xmpp_free(parser->ctx, parser->inner_text);
+            parser->inner_text = NULL;
+            parser->inner_text_used = 0;
+            parser->inner_text_size = 0;
+            return;
+        }
+        parser->inner_text = p;
+        parser->inner_text[parser->inner_text_used] = '\0';
     }
-    xmpp_stanza_set_text_with_size(stanza, s, len);
-
-    xmpp_stanza_add_child(parser->stanza, stanza);
-    xmpp_stanza_release(stanza);
+    parser->inner_text_used += len;
+    strncat(parser->inner_text, s, len);
 }
 
 parser_t *parser_new(xmpp_ctx_t *ctx,
@@ -199,6 +241,9 @@ parser_t *parser_new(xmpp_ctx_t *ctx,
         parser->userdata = userdata;
         parser->depth = 0;
         parser->stanza = NULL;
+        parser->inner_text = NULL;
+        parser->inner_text_size = 0;
+        parser->inner_text_used = 0;
 
         parser_reset(parser);
     }
@@ -217,6 +262,11 @@ void parser_free(parser_t *parser)
     if (parser->expat)
         XML_ParserFree(parser->expat);
 
+    if (parser->inner_text) {
+        xmpp_free (parser->ctx, parser->inner_text);
+        parser->inner_text = NULL;
+    }
+
     xmpp_free(parser->ctx, parser);
 }
 
@@ -235,6 +285,11 @@ int parser_reset(parser_t *parser)
     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);
     XML_SetCharacterDataHandler(parser->expat, _characters);

src/parser_libxml2.c

@@ -116,11 +116,12 @@ static void _start_element(void *userdata,
 
     if (parser->depth == 0) {
         /* notify the owner */
-        if (parser->startcb)
+        if (parser->startcb) {
             cbattrs = _convert_attrs(parser, nattrs, attrs);
             parser->startcb((char *)name, cbattrs, 
                             parser->userdata);
             _free_cbattrs(parser, cbattrs);
+	}
     } else {
 	/* build stanzas at depth 1 */
 	if (!parser->stanza && parser->depth != 1) {
@@ -248,6 +249,8 @@ 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);
 }
 
@@ -256,28 +259,22 @@ 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;
 
-    parser->depth = 0;
-    parser->stanza = NULL;
-
-    return 1;
+    return parser->xmlctx ? 1 : 0;
 }
 
 /* feed a chunk of data to the parser */
 int parser_feed(parser_t *parser, char *chunk, int len)
 {
-     /* xmlParseChunk API returns 0 on success which is opposite logic to
+    /* xmlParseChunk API returns 0 on success which is opposite logic to
        the status returned by parser_feed */
-    if(!xmlParseChunk(parser->xmlctx, chunk, len, 0)) {
-        return 1;
-    } else {
-        return 0;
-    }
+    return !xmlParseChunk(parser->xmlctx, chunk, len, 0);
 }

src/rand.c

@@ -127,9 +127,11 @@ 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);
-    memcpy(seed_material + entropy_input_len, nonce, nonce_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

@@ -1,4 +1,4 @@
-/* resolver.h
+/* resolver.c
  * strophe XMPP client library -- DNS resolver
  *
  * Copyright (C) 2015 Dmitry Podgorny <pasis.ua@gmail.com>
@@ -13,11 +13,15 @@
  *  DNS resolver.
  */
 
-#ifndef _WIN32
+#if !defined(_WIN32) && !defined(HAVE_CARES)
 #include <netinet/in.h>
 #include <arpa/nameser.h>
 #include <resolv.h>             /* res_query */
-#endif /* _WIN32 */
+#endif /* _WIN32 && HAVE_CARES */
+
+#ifdef HAVE_CARES
+#include <ares.h>
+#endif /* HAVE_CARES */
 
 #include <string.h>             /* strncpy */
 
@@ -31,6 +35,189 @@
 #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;
@@ -41,13 +228,6 @@ 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)
 {
@@ -80,7 +260,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)
-        strncpy(&name[name_len], tail, copy_len);
+        memcpy(&name[name_len], tail, copy_len);
 
     return name_len + tail_len;
 }
@@ -160,63 +340,6 @@ 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)                 \
@@ -226,8 +349,10 @@ static void resolver_srv_list_sort(resolver_srv_rr_t **srv_rr_list)
     }                                             \
 } while (0)
 
-int resolver_srv_lookup_buf(xmpp_ctx_t *ctx, const unsigned char *buf,
-                            size_t len, resolver_srv_rr_t **srv_rr_list)
+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)
 {
     unsigned i;
     unsigned j;
@@ -292,52 +417,110 @@ int resolver_srv_lookup_buf(xmpp_ctx_t *ctx, const unsigned char *buf,
         }
         j += rdlength;
     }
-    resolver_srv_list_sort(srv_rr_list);
 
     return *srv_rr_list != NULL ? XMPP_DOMAIN_FOUND : XMPP_DOMAIN_NOT_FOUND;
 }
 
-int resolver_srv_lookup(xmpp_ctx_t *ctx, const char *service, const char *proto,
-                        const char *domain, resolver_srv_rr_t **srv_rr_list)
-{
-    char fulldomain[2048];
-    unsigned char buf[65535];
-    int len;
-    int set = XMPP_DOMAIN_NOT_FOUND;
+#endif /* !HAVE_CARES */
 
-    xmpp_snprintf(fulldomain, sizeof(fulldomain),
-                  "_%s._%s.%s", service, proto, domain);
+#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)
+{
+    struct ares_srv_reply *srv;
+    struct ares_srv_reply *item;
+    resolver_srv_rr_t *rr;
+    int rc;
 
     *srv_rr_list = NULL;
 
-#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 */
+    rc = ares_parse_srv_reply(buf, len, &srv);
+    if (rc != ARES_SUCCESS)
+        return XMPP_DOMAIN_NOT_FOUND;
 
-    if (len > 0)
-        set = resolver_srv_lookup_buf(ctx, buf, (size_t)len, srv_rr_list);
-
-    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;
+    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);
+
+    return *srv_rr_list == NULL ? XMPP_DOMAIN_NOT_FOUND : XMPP_DOMAIN_FOUND;
 }
 
-#ifdef _WIN32
+static void ares_srv_lookup_callback(void *arg, int status, int timeouts,
+                                     unsigned char *buf, int len)
+{
+    struct resolver_ares_ctx *actx = arg;
 
+    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);
+    }
+
+    *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.
  *
@@ -431,7 +614,7 @@ static void netbuf_add_domain_name(unsigned char *buf, int buflen, int *offset,
 
 	*p++ = '\0';
 
-	*offset += p - start;
+	*offset += (int)(p - start);
 }
 
 static void netbuf_add_dnsquery_header(unsigned char *buf, int buflen, int *offset, struct dnsquery_header *header)
@@ -470,21 +653,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, PDNS_RECORD*, PVOID*);
-    void (WINAPI * pDnsRecordListFree)(PDNS_RECORD, DNS_FREE_TYPE);
+    DNS_STATUS (WINAPI * pDnsQuery_A)(PCSTR, WORD, DWORD, PIP4_ARRAY, DNS_RECORDA**, PVOID*);
+    void (WINAPI * pDnsRecordListFree)(DNS_RECORDA*, DNS_FREE_TYPE);
 
     if (hdnsapi = LoadLibrary("dnsapi.dll")) {
         pDnsQuery_A = (void *)GetProcAddress(hdnsapi, "DnsQuery_A");
         pDnsRecordListFree = (void *)GetProcAddress(hdnsapi, "DnsRecordListFree");
 
         if (pDnsQuery_A && pDnsRecordListFree) {
-            PDNS_RECORD dnsrecords = NULL;
+            DNS_RECORDA *dnsrecords = NULL;
             DNS_STATUS error;
 
             error = pDnsQuery_A(fulldomain, DNS_TYPE_SRV, DNS_QUERY_STANDARD, NULL, &dnsrecords, NULL);
 
             if (error == 0) {
-                PDNS_RECORD current = dnsrecords;
+                DNS_RECORDA *current = dnsrecords;
 
                 while (current) {
                     if (current->wType == DNS_TYPE_SRV) {
@@ -517,7 +700,7 @@ static int resolver_win32_srv_query(const char *fulldomain,
                                     unsigned char *buf, size_t len)
 {
     int set = 0;
-    int insize;
+    int insize = 0;
 
     /* if dnsapi didn't work/isn't there, try querying the dns server manually */
     if (!set)
@@ -550,7 +733,7 @@ static int resolver_win32_srv_query(const char *fulldomain,
 				char buffer[65535];
 
 				len = 65535;
-				fi = buffer;
+				fi = (FIXED_INFO *)buffer;
 
 				if ((error = pGetNetworkParams(fi, &len)) == ERROR_SUCCESS)
 				{
@@ -711,14 +894,14 @@ static int resolver_win32_srv_query(const char *fulldomain,
 		header.rd = 1;
 		header.qdcount = 1;
 
-		netbuf_add_dnsquery_header(buf, len, &offset, &header);
+		netbuf_add_dnsquery_header(buf, (int)len, &offset, &header);
 
 		memset(&question, 0, sizeof(question));
 		strncpy(question.qname, fulldomain, 1024);
 		question.qtype = 33; /* SRV */
 		question.qclass = 1; /* INTERNET! */
 
-		netbuf_add_dnsquery_question(buf, len, &offset, &question);
+		netbuf_add_dnsquery_question(buf, (int)len, &offset, &question);
 
 		insize = 0;
 		for (i = 0; i < numdnsservers && insize <= 0; i++)
@@ -736,7 +919,7 @@ static int resolver_win32_srv_query(const char *fulldomain,
 			sendto(sock, (char *)buf, offset, 0, (struct sockaddr *)&dnsaddr, addrlen);
 			for (j = 0; j < 50; j++)
 			{
-				insize = recvfrom(sock, (char *)buf, len, 0, (struct sockaddr *)&dnsaddr, &addrlen);
+				insize = recvfrom(sock, (char *)buf, (int)len, 0, (struct sockaddr *)&dnsaddr, &addrlen);
 				if (insize == SOCKET_ERROR)
 				{
 					if (sock_error() == WSAEWOULDBLOCK)

src/resolver.h

@@ -33,6 +33,9 @@ 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.
  *

src/sasl.c

@@ -264,7 +264,8 @@ 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"));
-    hash_add(table, "qop", xmpp_strdup(ctx, "auth"));
+    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);
     memcpy(value+5, domain, strlen(domain));

src/sha1.c

@@ -197,8 +197,9 @@ 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] += len << 3) < (len << 3)) context->count[1]++;
-    context->count[1] += (len >> 29);
+    if ((context->count[0] += (uint32_t)len << 3) < ((uint32_t)len << 3))
+        context->count[1]++;
+    context->count[1] += (uint32_t)(len >> 29);
     if ((j + len) > 63) {
         memcpy(&context->buffer[j], data, (i = 64-j));
         SHA1_Transform(context->state, context->buffer);

src/snprintf.c

@@ -286,6 +286,7 @@ static int dopr (char *buffer, size_t maxlen, const char *format, va_list args)
 	break;
       case 'X':
 	flags |= DP_F_UP;
+	//-fallthrough
       case 'x':
 	flags |= DP_F_UNSIGNED;
 	if (cflags == DP_C_SHORT)
@@ -306,6 +307,7 @@ static int dopr (char *buffer, size_t maxlen, const char *format, va_list args)
 	break;
       case 'E':
 	flags |= DP_F_UP;
+	//-fallthrough
       case 'e':
 	if (cflags == DP_C_LDOUBLE)
 	  fvalue = va_arg (args, LDOUBLE);
@@ -314,6 +316,7 @@ static int dopr (char *buffer, size_t maxlen, const char *format, va_list args)
 	break;
       case 'G':
 	flags |= DP_F_UP;
+	//-fallthrough
       case 'g':
 	if (cflags == DP_C_LDOUBLE)
 	  fvalue = va_arg (args, LDOUBLE);

src/sock.c

@@ -33,9 +33,17 @@
 #include <fcntl.h>
 #endif
 
+#include "common.h"
 #include "sock.h"
 #include "snprintf.h"
 
+struct _xmpp_sock_t {
+    xmpp_ctx_t *ctx;
+    struct addrinfo *ainfo_list;
+    struct addrinfo *current;
+    sock_t sock;
+};
+
 void sock_initialize(void)
 {
 #ifdef _WIN32
@@ -69,13 +77,23 @@ static int _in_progress(int error)
 #endif
 }
 
-sock_t sock_connect(const char * const host, const unsigned short port)
+xmpp_sock_t *sock_new(xmpp_ctx_t *ctx, const char *host, unsigned short port)
 {
-    sock_t sock;
+    xmpp_sock_t *xsock;
     char service[6];
-    struct addrinfo *res, *ainfo, hints;
+    struct addrinfo hints;
     int err;
 
+    xsock = xmpp_alloc(ctx, sizeof *xsock);
+    if (xsock == NULL) {
+        xmpp_error(ctx, "sock", "Memory allocation error.");
+        return NULL;
+    }
+    xsock->ctx = ctx;
+    xsock->ainfo_list = NULL;
+    xsock->current = NULL;
+    xsock->sock = -1;
+
     xmpp_snprintf(service, 6, "%u", port);
 
     memset(&hints, 0, sizeof(struct addrinfo));
@@ -86,11 +104,33 @@ sock_t sock_connect(const char * const host, const unsigned short port)
     hints.ai_protocol = IPPROTO_TCP;
     hints.ai_socktype = SOCK_STREAM;
 
-    err = getaddrinfo(host, service, &hints, &res);
-    if (err != 0)
-        return -1;
+    err = getaddrinfo(host, service, &hints, &xsock->ainfo_list);
+    if (err != 0) {
+        xmpp_free(ctx, xsock);
+        xsock = NULL;
+    }
+    return xsock;
+}
 
-    for (ainfo = res; ainfo != NULL; ainfo = ainfo->ai_next) {
+void sock_free(xmpp_sock_t *xsock)
+{
+    if (xsock->ainfo_list != NULL)
+        freeaddrinfo(xsock->ainfo_list);
+    xmpp_free(xsock->ctx, xsock);
+}
+
+sock_t sock_connect(xmpp_sock_t *xsock)
+{
+    struct addrinfo *ainfo;
+    sock_t sock = -1;
+    int err;
+
+    if (xsock->current == NULL)
+        ainfo = xsock->ainfo_list;
+    else
+        ainfo = xsock->current->ai_next;
+
+    for (; ainfo != NULL; ainfo = ainfo->ai_next) {
         sock = socket(ainfo->ai_family, ainfo->ai_socktype, ainfo->ai_protocol);
         if (sock < 0)
             continue;
@@ -103,9 +143,13 @@ sock_t sock_connect(const char * const host, const unsigned short port)
         }
         sock_close(sock);
     }
-    freeaddrinfo(res);
-    sock = ainfo == NULL ? -1 : sock;
 
+    xsock->sock = sock;
+    xsock->current = ainfo;
+    if (ainfo == NULL) {
+        freeaddrinfo(xsock->ainfo_list);
+        xsock->ainfo_list = NULL;
+    }
     return sock;
 }
 
@@ -158,38 +202,33 @@ int sock_close(const sock_t sock)
 #endif
 }
 
-int sock_set_blocking(const sock_t sock)
+static int _sock_set_blocking_mode(sock_t sock, int blocking)
 {
 #ifdef _WIN32
-    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;
+    u_long nonblock = blocking ? 0 : 1;
     return ioctlsocket(sock, FIONBIO, &nonblock);
 #else
     int rc;
 
     rc = fcntl(sock, F_GETFL, NULL);
     if (rc >= 0) {
-        rc = fcntl(sock, F_SETFL, rc | O_NONBLOCK);
+        rc = blocking ? rc & (~O_NONBLOCK) : rc | O_NONBLOCK;
+        rc = fcntl(sock, F_SETFL, rc);
     }
     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);

src/sock.h

@@ -25,12 +25,16 @@ typedef int sock_t;
 typedef SOCKET sock_t;
 #endif
 
+typedef struct _xmpp_sock_t xmpp_sock_t;
+
 void sock_initialize(void);
 void sock_shutdown(void);
 
 int sock_error(void);
 
-sock_t sock_connect(const char * const host, const unsigned short port);
+xmpp_sock_t *sock_new(xmpp_ctx_t *ctx, const char *host, unsigned short port);
+void sock_free(xmpp_sock_t *xsock);
+sock_t sock_connect(xmpp_sock_t *xsock);
 int sock_close(const sock_t sock);
 
 int sock_set_blocking(const sock_t sock);

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; 
@@ -76,35 +76,27 @@ xmpp_stanza_t *xmpp_stanza_clone(xmpp_stanza_t * const stanza)
 static int _stanza_copy_attributes(xmpp_stanza_t * dst,
                                    const xmpp_stanza_t * const src)
 {
-    hash_iterator_t *iter = NULL;
+    hash_iterator_t *iter;
     const char *key;
-    void *val;
+    const char *val;
+    int rc = XMPP_EOK;
 
-    dst->attributes = hash_new(src->ctx, 8, xmpp_free);
-    if (!dst->attributes)
-        return -1;
     iter = hash_iter_new(src->attributes);
-    if (!iter)
-        goto error;
-    while ((key = hash_iter_next(iter))) {
-        val = xmpp_strdup(src->ctx,
-                          (char *)hash_get(src->attributes, key));
-        if (!val)
-            goto error;
+    if (!iter) rc = XMPP_EMEM;
 
-        if (hash_add(dst->attributes, key, val)) {
-            xmpp_free(src->ctx, val);
-            goto error;
-        }
+    while (rc == XMPP_EOK && (key = hash_iter_next(iter))) {
+        val = hash_get(src->attributes, key);
+        if (!val) rc = XMPP_EINT;
+        if (rc == XMPP_EOK)
+            rc = xmpp_stanza_set_attribute(dst, key, val);
     }
     hash_iter_release(iter);
-    return 0;
 
-error:
-    if (iter != NULL)
-        hash_iter_release(iter);
-    hash_release(dst->attributes);
-    return -1;
+    if (rc != XMPP_EOK && dst->attributes) {
+        hash_release(dst->attributes);
+        dst->attributes = NULL;
+    }
+    return rc;
 }
 
 /** Copy a stanza and its children.
@@ -129,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;
@@ -161,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
@@ -177,20 +169,20 @@ 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;
@@ -282,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];
     }
 }
 
@@ -302,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;
@@ -317,80 +309,86 @@ 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) 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->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->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);
-	    
-	    /* iterate and recurse over child stanzas */
-	    child = stanza->children;
-	    while (child) {
-		ret = _render_stanza_recursive(child, ptr, left);
-		if (ret < 0) return ret;
+            /* write end of start tag */
+            ret = xmpp_snprintf(ptr, left, ">");
+            if (ret < 0) return XMPP_EMEM;
+            _render_update(&written, buflen, ret, &left, &ptr);
 
-		_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;
 
-		child = child->next;
-	    }
+                _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);
-	}
+                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);
+        }
     }
 
     return written;
@@ -423,27 +421,37 @@ 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) return ret;
+    if (ret < 0) {
+        xmpp_free(stanza->ctx, buffer);
+        *buf = NULL;
+        *buflen = 0;
+        return ret;
+    }
 
-    if (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;
+    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;
 
-	ret = _render_stanza_recursive(stanza, buffer, length);
-	if (ret > length - 1) return XMPP_EMEM;
+        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;
+        }
     }
     
     buffer[length - 1] = 0;
@@ -465,7 +473,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;
 
@@ -504,7 +512,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);
@@ -525,30 +533,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);
@@ -566,25 +574,29 @@ 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;
 
     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;
     }
 
-    hash_add(stanza->attributes, key, val);
+    rc = hash_add(stanza->attributes, key, val);
+    if (rc < 0) {
+        xmpp_free(stanza->ctx, val);
+        return XMPP_EMEM;
+    }
 
     return XMPP_EOK;
 }
@@ -601,7 +613,7 @@ 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);
 }
@@ -627,12 +639,12 @@ int xmpp_stanza_add_child(xmpp_stanza_t *stanza, xmpp_stanza_t *child)
     child->parent = stanza;
 
     if (!stanza->children)
-	stanza->children = child;
+        stanza->children = child;
     else {
-	s = stanza->children;
-	while (s->next) s = s->next;
-	s->next = child;
-	child->prev = s;
+        s = stanza->children;
+        while (s->next) s = s->next;
+        s->next = child;
+        child->prev = s;
     }
 
     return XMPP_EOK;
@@ -652,7 +664,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;
     
@@ -679,8 +691,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;
 
@@ -783,14 +795,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;
@@ -809,14 +821,15 @@ 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) {
-	if (xmpp_stanza_get_ns(child) &&
-	    strcmp(ns, xmpp_stanza_get_ns(child)) == 0)
-	    break;
+        child_ns = xmpp_stanza_get_ns(child);
+        if (child_ns && strcmp(ns, child_ns) == 0)
+            break;
     }
     
     return child;
@@ -869,16 +882,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;
 
@@ -887,11 +900,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;
 
@@ -914,7 +927,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;
 }
 
@@ -931,7 +944,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);
 }
@@ -948,7 +961,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);
 }
@@ -1004,10 +1017,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);
 }
@@ -1047,7 +1060,12 @@ int xmpp_stanza_del_attribute(xmpp_stanza_t * const stanza,
  */
 xmpp_stanza_t *xmpp_stanza_reply(xmpp_stanza_t * const stanza)
 {
-    xmpp_stanza_t *copy;
+    xmpp_stanza_t *copy = NULL;
+    const char *from;
+    int rc;
+
+    from = xmpp_stanza_get_from(stanza);
+    if (!from) goto copy_error;
 
     copy = xmpp_stanza_new(stanza->ctx);
     if (!copy) goto copy_error;
@@ -1060,12 +1078,14 @@ xmpp_stanza_t *xmpp_stanza_reply(xmpp_stanza_t * const stanza)
     }
 
     if (stanza->attributes) {
-        if (_stanza_copy_attributes(copy, stanza) == -1)
+        if (_stanza_copy_attributes(copy, stanza) < 0)
             goto copy_error;
     }
 
-    xmpp_stanza_set_to(copy, xmpp_stanza_get_from(stanza));
+    xmpp_stanza_del_attribute(copy, "to");
     xmpp_stanza_del_attribute(copy, "from");
+    rc = xmpp_stanza_set_to(copy, from);
+    if (rc != XMPP_EOK) goto copy_error;
 
     return copy;
 
@@ -1214,3 +1234,122 @@ 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/thread.c

@@ -1,116 +0,0 @@
-/* thread.c
-** strophe XMPP client library -- thread abstraction
-**
-** Copyright (C) 2005-2009 Collecta, Inc. 
-**
-**  This software is provided AS-IS with no warranty, either express
-**  or implied.
-**
-**  This program is dual licensed under the MIT and GPLv3 licenses.
-*/
-
-/** @file
- *  Thread absraction.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#ifdef _WIN32
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#else
-#include <pthread.h>
-#endif
-
-#include "strophe.h"
-#include "common.h"
-#include "thread.h"
-
-struct _mutex_t {
-    const xmpp_ctx_t *ctx;
-
-#ifdef _WIN32
-    HANDLE mutex;
-#else
-    pthread_mutex_t *mutex;
-#endif
-};
-
-/* mutex functions */
-
-mutex_t *mutex_create(const xmpp_ctx_t * ctx)
-{
-    mutex_t *mutex;
-
-    mutex = xmpp_alloc(ctx, sizeof(mutex_t));
-    if (mutex) {
-	mutex->ctx = ctx;
-#ifdef _WIN32
-	mutex->mutex = CreateMutex(NULL, FALSE, NULL);
-#else
-	mutex->mutex = xmpp_alloc(ctx, sizeof(pthread_mutex_t));
-	if (mutex->mutex)
-	    if (pthread_mutex_init(mutex->mutex, NULL) != 0) {
-		xmpp_free(ctx, mutex->mutex);
-		mutex->mutex = NULL;
-	    }
-#endif
-	if (!mutex->mutex) {
-	    xmpp_free(ctx, mutex);
-	    mutex = NULL;
-	}
-    }
-
-    return mutex;
-}
-
-int mutex_destroy(mutex_t *mutex)
-{
-    int ret = 1;
-    const xmpp_ctx_t *ctx;
-
-#ifdef _WIN32
-    if (mutex->mutex)
-	ret = CloseHandle(mutex->mutex);
-#else
-    if (mutex->mutex)
-	ret = pthread_mutex_destroy(mutex->mutex) == 0;
-#endif
-    ctx = mutex->ctx;
-    xmpp_free(ctx, mutex);
-
-    return ret;
-}
-
-int mutex_lock(mutex_t *mutex)
-{
-    int ret;
-
-#ifdef _WIN32
-    ret = WaitForSingleObject(mutex->mutex, INFINITE) == 0;
-#else
-    ret = pthread_mutex_lock(mutex->mutex) == 0;
-#endif
-
-    return ret;
-}
-
-int mutex_trylock(mutex_t *mutex)
-{
-    /* TODO */
-    return 0;
-}
-
-int mutex_unlock(mutex_t *mutex)
-{
-    int ret;
-
-#ifdef _WIN32
-    ret = ReleaseMutex(mutex->mutex);
-#else
-    ret = pthread_mutex_unlock(mutex->mutex) == 0;
-#endif
-
-    return ret;
-}

src/thread.h

@@ -1,40 +0,0 @@
-/* thread.h
-** strophe XMPP client library -- thread abstraction header
-**
-** Copyright (C) 2005-2009 Collecta, Inc. 
-**
-**  This software is provided AS-IS with no warranty, either express
-**  or implied.
-**
-**  This program is dual licensed under the MIT and GPLv3 licenses.
-*/
-
-/** @file
- *  Threading abstraction API.
- */
-
-#ifndef __LIBSTROPHE_THREAD_H__
-#define __LIBSTROPHE_THREAD_H__
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <pthread.h>
-#endif
-
-#include "strophe.h"
-
-typedef struct _mutex_t mutex_t;
-
-/* mutex functions */
-
-mutex_t *mutex_create(const xmpp_ctx_t *ctx);
-int mutex_destroy(mutex_t *mutex);
-int mutex_lock(mutex_t *mutex);
-int mutex_trylock(mutex_t *mutex);
-int mutex_unlock(mutex_t *mutex);
-
-#endif /* __LIBSTROPHE_THREAD_H__ */

src/tls.h

@@ -24,7 +24,7 @@ typedef struct _tls tls_t;
 void tls_initialize(void);
 void tls_shutdown(void);
 
-tls_t *tls_new(xmpp_ctx_t *ctx, sock_t sock);
+tls_t *tls_new(xmpp_conn_t *conn);
 void tls_free(tls_t *tls);
 
 int tls_set_credentials(tls_t *tls, const char *cafilename);

src/tls_dummy.c

@@ -33,7 +33,7 @@ void tls_shutdown(void)
     return;
 }
 
-tls_t *tls_new(xmpp_ctx_t *ctx, sock_t sock)
+tls_t *tls_new(xmpp_conn_t *conn)
 {
     /* always fail */
     return NULL;

src/tls_gnutls.c

@@ -46,13 +46,13 @@ void tls_shutdown(void)
     gnutls_global_deinit();
 }
 
-tls_t *tls_new(xmpp_ctx_t *ctx, sock_t sock)
+tls_t *tls_new(xmpp_conn_t *conn)
 {
-    tls_t *tls = xmpp_alloc(ctx, sizeof(tls_t));
+    tls_t *tls = xmpp_alloc(conn->ctx, sizeof(tls_t));
 
     if (tls) {
-        tls->ctx = ctx;
-        tls->sock = sock;
+        tls->ctx = conn->ctx;
+        tls->sock = conn->sock;
         gnutls_init(&tls->session, GNUTLS_CLIENT);
 
         gnutls_certificate_allocate_credentials(&tls->cred);
@@ -61,7 +61,7 @@ tls_t *tls_new(xmpp_ctx_t *ctx, sock_t sock)
         gnutls_set_default_priority(tls->session);
 
         /* fixme: this may require setting a callback on win32? */
-        gnutls_transport_set_int(tls->session, sock);
+        gnutls_transport_set_int(tls->session, conn->sock);
     }
 
     return tls;

src/tls_openssl.c

@@ -24,11 +24,29 @@
 
 #include <openssl/ssl.h>
 #include <openssl/err.h>
+#include <openssl/opensslv.h>
+#include <openssl/x509v3.h>
 
 #include "common.h"
 #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;
@@ -46,16 +64,38 @@ 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)
 {
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
     SSL_library_init();
     SSL_load_error_strings();
+#else
+    OPENSSL_init_ssl(OPENSSL_INIT_LOAD_SSL_STRINGS, NULL);
+#endif
 }
 
 void tls_shutdown(void)
 {
-    return;
+    /*
+     * FIXME: Don't free global tables, program or other libraries may use
+     * openssl after libstrophe finalization. Maybe better leak some fixed
+     * memory rather than cause random crashes of the main program.
+     */
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
+    ERR_free_strings();
+    EVP_cleanup();
+    CRYPTO_cleanup_all_ex_data();
+#if OPENSSL_VERSION_NUMBER >= 0x10002000L
+    SSL_COMP_free_compression_methods();
+#endif
+#if OPENSSL_VERSION_NUMBER < 0x10000000L
+    ERR_remove_state(0);
+#else
+    ERR_remove_thread_state(NULL);
+#endif
+#endif
 }
 
 int tls_error(tls_t *tls)
@@ -63,29 +103,55 @@ int tls_error(tls_t *tls)
     return tls->lasterror;
 }
 
-tls_t *tls_new(xmpp_ctx_t *ctx, sock_t sock)
+tls_t *tls_new(xmpp_conn_t *conn)
 {
-    tls_t *tls = xmpp_alloc(ctx, sizeof(*tls));
+    tls_t *tls = xmpp_alloc(conn->ctx, sizeof(*tls));
+    int mode;
 
     if (tls) {
         int ret;
         memset(tls, 0, sizeof(*tls));
 
-        tls->ctx = ctx;
-        tls->sock = sock;
+        tls->ctx = conn->ctx;
+        tls->sock = conn->sock;
         tls->ssl_ctx = SSL_CTX_new(SSLv23_client_method());
         if (tls->ssl_ctx == NULL)
             goto err;
 
+        /* Enable bug workarounds. */
+        SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_ALL);
+
+        /* Disable insecure SSL/TLS versions. */
+        SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_NO_SSLv2); /* DROWN */
+        SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_NO_SSLv3); /* POODLE */
+        SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_NO_TLSv1); /* BEAST */
+
         SSL_CTX_set_client_cert_cb(tls->ssl_ctx, NULL);
         SSL_CTX_set_mode(tls->ssl_ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
-        SSL_CTX_set_verify(tls->ssl_ctx, SSL_VERIFY_NONE, NULL);
+        SSL_CTX_set_default_verify_paths(tls->ssl_ctx);
 
         tls->ssl = SSL_new(tls->ssl_ctx);
         if (tls->ssl == NULL)
             goto err_free_ctx;
 
-        ret = SSL_set_fd(tls->ssl, sock);
+        /* 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. */
+        X509_VERIFY_PARAM *param = SSL_get0_param(tls->ssl);
+
+        /*
+         * Allow only complete wildcards.  RFC 6125 discourages wildcard usage
+         * completely, and lists internationalized domain names as a reason
+         * against partial wildcards.
+         * See https://tools.ietf.org/html/rfc6125#section-7.2 for more information.
+         */
+        X509_VERIFY_PARAM_set_hostflags(param, X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS);
+        X509_VERIFY_PARAM_set1_host(param, conn->domain, 0);
+#endif
+
+        ret = SSL_set_fd(tls->ssl, conn->sock);
         if (ret <= 0)
             goto err_free_ssl;
     }
@@ -97,8 +163,8 @@ err_free_ssl:
 err_free_ctx:
     SSL_CTX_free(tls->ssl_ctx);
 err:
-    xmpp_free(ctx, tls);
-    _tls_log_error(ctx);
+    xmpp_free(conn->ctx, tls);
+    _tls_log_error(conn->ctx);
     return NULL;
 }
 
@@ -118,6 +184,7 @@ int tls_start(tls_t *tls)
 {
     int error;
     int ret;
+    long x509_res;
 
     /* Since we're non-blocking, loop the connect call until it
        succeeds or fails */
@@ -134,8 +201,13 @@ int tls_start(tls_t *tls)
         /* success or fatal error */
         break;
     }
-    _tls_set_error(tls, error);
 
+    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;
 }
 
@@ -145,6 +217,11 @@ 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);
@@ -155,6 +232,14 @@ 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;
@@ -206,6 +291,8 @@ 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)
@@ -224,6 +311,7 @@ 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;
@@ -242,3 +330,26 @@ 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);
+    }
+}

src/tls_schannel.c

@@ -23,6 +23,7 @@
 
 struct _tls {
     xmpp_ctx_t *ctx;
+    xmpp_conn_t *conn;
     sock_t sock;
 
     HANDLE hsec32;
@@ -60,8 +61,10 @@ void tls_shutdown(void)
     return;
 }
 
-tls_t *tls_new(xmpp_ctx_t *ctx, sock_t sock)
+tls_t *tls_new(xmpp_conn_t *conn)
 {
+    xmpp_ctx_t *ctx = conn->ctx;
+    sock_t sock = conn->sock;
     tls_t *tls;
     PSecurityFunctionTable (*pInitSecurityInterface)(void);
     SCHANNEL_CRED scred;
@@ -92,6 +95,7 @@ tls_t *tls_new(xmpp_ctx_t *ctx, sock_t sock)
 
     memset(tls, 0, sizeof(*tls));
     tls->ctx = ctx;
+    tls->conn = conn;
     tls->sock = sock;
 
     if (!(tls->hsec32 = LoadLibrary ("secur32.dll"))) {
@@ -216,24 +220,10 @@ int tls_start(tls_t *tls)
     SecBuffer sbin[2], sbout[1];
     SECURITY_STATUS ret;
     int sent;
-    char *name = NULL;
+    char *name;
 
-    /* search the ctx's conns for our sock, and use the domain there as our
-     * name */
-    {
-	xmpp_connlist_t *listentry = tls->ctx->connlist;
-
-	while (listentry) {
-	    xmpp_conn_t *conn = listentry->conn;
-
-	    if (conn->sock == tls->sock) {
-		name = strdup(conn->domain);
-		listentry = NULL;
-	    } else {
-		listentry = listentry->next;
-	    }
-	}
-    }
+    /* use the domain there as our name */
+    name = tls->conn->domain;
 
     ctxtreq = ISC_REQ_SEQUENCE_DETECT | ISC_REQ_REPLAY_DETECT
 	    | ISC_REQ_CONFIDENTIALITY | ISC_RET_EXTENDED_ERROR
@@ -265,10 +255,18 @@ 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) {
-	unsigned char *p = sbin[0].pvBuffer;
-	int len = 0, inbytes = 0;
+	   || 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;
+  }
 
 	if (sbdout.pBuffers[0].cbBuffer) {
 	    unsigned char *writebuff = sbdout.pBuffers[0].pvBuffer;

strophe.h

@@ -165,6 +165,14 @@ typedef struct _xmpp_stanza_t xmpp_stanza_t;
 #define XMPP_CONN_FLAG_DISABLE_TLS   (1UL << 0)
 #define XMPP_CONN_FLAG_MANDATORY_TLS (1UL << 1)
 #define XMPP_CONN_FLAG_LEGACY_SSL    (1UL << 2)
+/** @def XMPP_CONN_FLAG_TRUST_TLS
+ *  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 {
@@ -213,6 +221,7 @@ 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);
@@ -377,6 +386,8 @@ 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 */
 
@@ -394,6 +405,7 @@ char *xmpp_jid_resource(xmpp_ctx_t *ctx, const char *jid);
 void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long  timeout);
 void xmpp_run(xmpp_ctx_t *ctx);
 void xmpp_stop(xmpp_ctx_t *ctx);
+void xmpp_ctx_set_timeout(xmpp_ctx_t * const ctx, const unsigned long timeout);
 
 /* UUID */
 
@@ -409,6 +421,8 @@ char *xmpp_uuid_gen(xmpp_ctx_t *ctx);
 typedef struct _xmpp_sha1_t xmpp_sha1_t;
 
 char *xmpp_sha1(xmpp_ctx_t *ctx, const unsigned char *data, size_t len);
+void xmpp_sha1_digest(const unsigned char *data, size_t len,
+                      unsigned char *digest);
 
 xmpp_sha1_t *xmpp_sha1_new(xmpp_ctx_t *ctx);
 void xmpp_sha1_free(xmpp_sha1_t *sha1);

strophepp.h

@@ -5,7 +5,7 @@
 **
 **  This software is provided AS-IS with no warranty, either express or
 **  implied.
-** 
+**
 **  This program is dual licensed under the MIT and GPLv3 licenses.
 */
 
@@ -21,112 +21,112 @@
 namespace XMPP {
     class Context {
     private:
-	xmpp_mem_t m_mem;
-	xmpp_log_t m_log;
-	xmpp_ctx_t *m_ctx;
+        xmpp_mem_t m_mem;
+        xmpp_log_t m_log;
+        xmpp_ctx_t *m_ctx;
 
     public:
-	Context();
-	virtual ~Context();
+        Context();
+        virtual ~Context();
 
-	virtual void *alloc(const size_t size);
-	virtual void *realloc(void *p, const size_t size);
-	virtual void free(void *p);
-	virtual void log(const xmpp_log_level_t level,
-			 const char * const area,
-			 const char * const msg);
+        virtual void *alloc(const size_t size);
+        virtual void *realloc(void *p, const size_t size);
+        virtual void free(void *p);
+        virtual void log(const xmpp_log_level_t level,
+                         const char * const area,
+                         const char * const msg);
 
-	xmpp_ctx_t *getContext();
+        xmpp_ctx_t *getContext();
 
     private:
-	static void *callAlloc(const size_t size, void * const userdata);
-	static void *callRealloc(void *p, const size_t size, 
-				 void * const userdata);
-	static void callFree(void *p, void * const userdata);
-	static void callLog(void * const userdata, 
-			    const xmpp_log_level_t level,
-			    const char * const area,
-			    const char * const msg);
+        static void *callAlloc(const size_t size, void * const userdata);
+        static void *callRealloc(void *p, const size_t size,
+                                 void * const userdata);
+        static void callFree(void *p, void * const userdata);
+        static void callLog(void * const userdata,
+                            const xmpp_log_level_t level,
+                            const char * const area,
+                            const char * const msg);
     };
 
     class Stanza {
     private:
-	Context *m_ctx;
-	xmpp_stanza_t *m_stanza;
+        Context *m_ctx;
+        xmpp_stanza_t *m_stanza;
 
-	void *operator new(size_t size, Context *ctx);
-	void operator delete(void *p);
-	Stanza(Context *ctx);
-	virtual ~Stanza();
+        void *operator new(size_t size, Context *ctx);
+        void operator delete(void *p);
+        Stanza(Context *ctx);
+        virtual ~Stanza();
 
     public:
-	static Stanza *create(Context *ctx);
-	void release();
-	Stanza *clone();
-	Stanza *copy();
-	
-	int toText(const char ** const buf, size_t * const buflen);
-	Stanza *getChildren();
-	Stanza *getChildByName(const char * const name);
-	Stanza *getNext();
+        static Stanza *create(Context *ctx);
+        void release();
+        Stanza *clone();
+        Stanza *copy();
+
+        int toText(const char ** const buf, size_t * const buflen);
+        Stanza *getChildren();
+        Stanza *getChildByName(const char * const name);
+        Stanza *getNext();
         char *getAttribute(const char * const name);
-	char *getNamespace();
-	char *getText();
-	char *getName();
-	void addChild(Stanza *child);
-	void setNamespace(const char * const ns);
-	void setAttribute(const char * const key, const char * const value);
-	void setName(const char * const name);
-	void setText(const char * const text);
-	void setText(const char * const text, const size_t size);
-	char *getType();
-	char *getId();
-	char *getTo();
-	char *getFrom();
-	void setType(const char * const type);
-	void setId(const char * const id);
-	void setTo(const char * const to);
-	void setFrom(const char * const from);
+        char *getNamespace();
+        char *getText();
+        char *getName();
+        void addChild(Stanza *child);
+        void setNamespace(const char * const ns);
+        void setAttribute(const char * const key, const char * const value);
+        void setName(const char * const name);
+        void setText(const char * const text);
+        void setText(const char * const text, const size_t size);
+        char *getType();
+        char *getId();
+        char *getTo();
+        char *getFrom();
+        void setType(const char * const type);
+        void setId(const char * const id);
+        void setTo(const char * const to);
+        void setFrom(const char * const from);
     };
 
     class Connection {
     private:
-	Context *m_ctx;
-	xmpp_conn_t *conn;
+        Context *m_ctx;
+        xmpp_conn_t *conn;
 
-	void *operator new(size_t size, Context *ctx);
-	Connection(Context *ctx);
+        void *operator new(size_t size, Context *ctx);
+        Connection(Context *ctx);
 
     public:
-	static Connection *create(Context *ctx);
-	virtual ~Connection();
-	Connection *clone();
-	void operator delete(void *p);
+        static Connection *create(Context *ctx);
+        virtual ~Connection();
+        Connection *clone();
+        void operator delete(void *p);
 
-	const char *getJID();
-	void setJID(const char * const jid);
-	const char *getPass();
-	void setPass(const char * const pass);
-	bool connectClient(const char * const domain,
-			   xmpp_conn_handler callback,
-			   void * const userdata);
-	void disconnect();
-	void send(Stanza *stanza);
+        const char *getJID();
+        void setJID(const char * const jid);
+        const char *getPass();
+        void setPass(const char * const pass);
+        bool connectClient(const char * const domain,
+                           xmpp_conn_handler callback,
+                           void * const userdata);
+        void disconnect();
+        void send(Stanza *stanza);
 
-	void addTimedHandler(xmpp_timed_handler handler,
-			     const unsigned long perdio,
-			     void * const userdata);
-	void deleteTimedHandler(xmpp_timed_handler handler);
-	void addHandler(xmpp_handler handler,
-			const char * const ns,
-			const char * const name,
-			const char * const type,
-			void * const userdata);
-	void deleteHandler(xmpp_handler handler);
-	void addIdHandler(xmpp_handler handler,
-			  const char * const id,
-			  void * const userdata);
-	void deleteIdHandler(xmpp_handler handler);
+        void addTimedHandler(xmpp_timed_handler handler,
+                             const unsigned long perdio,
+                             void * const userdata);
+        void deleteTimedHandler(xmpp_timed_handler handler);
+        void addHandler(xmpp_handler handler,
+                        const char * const ns,
+                        const char * const name,
+                        const char * const type,
+                        void * const userdata);
+        void deleteHandler(xmpp_handler handler);
+        void addIdHandler(xmpp_handler handler,
+                          const char * const id,
+                          void * const userdata);
+        void deleteIdHandler(xmpp_handler handler);
     };
 }
 

tests/res_query_dump.c

@@ -61,7 +61,7 @@ int main(int argc, char **argv)
     len = res_query(fulldomain, C_IN, T_SRV, buf, sizeof(buf));
 
     if (len < 0) {
-        fprintf(stderr, "res_query(): Error occured (errno=%d)\n", errno);
+        fprintf(stderr, "res_query(): Error occurred (errno=%d)\n", errno);
     }
     if (len == 0) {
         fprintf(stderr, "res_query(): Empty result\n");

tests/test_base64.c

@@ -134,8 +134,7 @@ int main(int argc, char *argv[])
     unsigned char *udec;
     char *dec;
     char *enc;
-    size_t len;
-    int i;
+    size_t len, i;
 
     printf("BASE64 tests.\n");
 

tests/test_hash.c

@@ -16,18 +16,19 @@
 #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)
 {
@@ -58,7 +59,7 @@ int main(int argc, char **argv)
     }
 
     /* allocate a hash table */
-    table = hash_new(ctx, TABLESIZE, NULL);
+    table = hash_new(ctx, TABLESIZE, xmpp_free);
     if (table == NULL) {
 	/* table allocation failed! */
 	return 1;
@@ -66,7 +67,7 @@ int main(int argc, char **argv)
 
     /* test insertion */
     for (i = 0; i < nkeys; i++) {
-	err = hash_add(table, keys[i], (void*)values[i]);
+	err = hash_add(table, keys[i], xmpp_strdup(ctx, values[i]));
 	if (err) return err;
     }
 
@@ -76,6 +77,18 @@ int main(int argc, char **argv)
 	return 1;
     }
 
+    /* test replacing old values */
+    for (i = 0; i < nkeys; i++) {
+        err = hash_add(table, keys[0], xmpp_strdup(ctx, values[i]));
+        if (err) return err;
+        if (hash_num_keys(table) != nkeys) return 1;
+        result = hash_get(table, keys[0]);
+        if (result == NULL) return 1;
+        if (strcmp(result, values[i]) != 0) return 1;
+    }
+    /* restore value for the 1st key */
+    hash_add(table, keys[0], xmpp_strdup(ctx, values[0]));
+
     /* test cloning */
     clone = hash_clone(table);
 

tests/test_jid.c

@@ -27,54 +27,67 @@ static const char *_s(const char *s)
 
 int test_jid(xmpp_ctx_t *ctx)
 {
+    char *bare;
     char *node;
     char *domain;
     char *resource;
 
+    bare = xmpp_jid_bare(ctx, jid1);
     node = xmpp_jid_node(ctx, jid1);
     domain = xmpp_jid_domain(ctx, jid1);
     resource = xmpp_jid_resource(ctx, jid1);
     printf("jid '%s' parsed to %s, %s, %s\n",
            jid1, _s(node), _s(domain), _s(resource));
+    if (bare == NULL || strcmp(bare, "foo@bar.com")) return 1;
     if (node == NULL || strcmp(node, "foo")) return 1;
     if (domain == NULL || strcmp(domain, "bar.com")) return 1;
     if (resource != NULL) return 1;
+    if (bare) xmpp_free(ctx, bare);
     if (node) xmpp_free(ctx, node);
     if (domain) xmpp_free(ctx, domain);
     if (resource) xmpp_free(ctx, resource);
 
+    bare = xmpp_jid_bare(ctx, jid2);
     node = xmpp_jid_node(ctx, jid2);
     domain = xmpp_jid_domain(ctx, jid2);
     resource = xmpp_jid_resource(ctx, jid2);
     printf("jid '%s' parsed to %s, %s, %s\n",
            jid2, _s(node), _s(domain), _s(resource));
+    if (bare == NULL || strcmp(bare, "anyone@example.com")) return 1;
     if (node == NULL || strcmp(node, "anyone")) return 1;
     if (domain == NULL || strcmp(domain, "example.com")) return 1;
     if (resource == NULL || strcmp(resource, "hullo")) return 1;
+    if (bare) xmpp_free(ctx, bare);
     if (node) xmpp_free(ctx, node);
     if (domain) xmpp_free(ctx, domain);
     if (resource) xmpp_free(ctx, resource);
 
+    bare = xmpp_jid_bare(ctx, jid3);
     node = xmpp_jid_node(ctx, jid3);
     domain = xmpp_jid_domain(ctx, jid3);
     resource = xmpp_jid_resource(ctx, jid3);
     printf("jid '%s' parsed to %s, %s, %s\n",
            jid3, _s(node), _s(domain), _s(resource));
+    if (bare == NULL || strcmp(bare, "manic.porter@xyz.net")) return 1;
     if (node == NULL || strcmp(node, "manic.porter")) return 1;
     if (domain == NULL || strcmp(domain, "xyz.net")) return 1;
     if (resource == NULL || strcmp(resource, "frob")) return 1;
+    if (bare) xmpp_free(ctx, bare);
     if (node) xmpp_free(ctx, node);
     if (domain) xmpp_free(ctx, domain);
     if (resource) xmpp_free(ctx, resource);
 
+    bare = xmpp_jid_bare(ctx, jid4);
     node = xmpp_jid_node(ctx, jid4);
     domain = xmpp_jid_domain(ctx, jid4);
     resource = xmpp_jid_resource(ctx, jid4);
     printf("jid '%s' parsed to %s, %s, %s\n",
            jid4, _s(node), _s(domain), _s(resource));
+    if (bare == NULL || strcmp(bare, "domain.tld")) return 1;
     if (node != NULL) return 1;
     if (domain == NULL || strcmp(domain, "domain.tld")) return 1;
     if (resource != NULL) return 1;
+    if (bare) xmpp_free(ctx, bare);
     if (node) xmpp_free(ctx, node);
     if (domain) xmpp_free(ctx, domain);
     if (resource) xmpp_free(ctx, resource);

tests/test_string.c

@@ -20,6 +20,16 @@
 
 #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--";
@@ -79,7 +89,7 @@ static int test_strdup_one(xmpp_ctx_t *ctx, const char *s)
 static int test_strdup(void)
 {
     xmpp_ctx_t *ctx;
-    int i;
+    size_t i;
     int rc = 0;
 
     static const char *tests[] = { "", "\0", "test", "s p a c e", "\n\r" };