WIP Unify error codes returned to the connection handler

Error argument in the connection handler is not always set and in some
cases provides meaningless values. For example, every TLS module returns
its specific error codes.

Current solution unifies error codes and allows to distinguish between
different types of disconnection.

Fixes #123.

.gitignore

@@ -1,8 +1,8 @@
+*.swp
+*.orig
 Makefile
 test-driver
 .libs
-src/*.lo
-*.la
 Makefile.in
 configure
 libtool
@@ -21,23 +21,51 @@ autom4te.cache
 .deps
 .sconsign*
 src/*.o
+src/*.lo
 examples/*.o
-tests/*.o
-tests/check_parser
 *.a
+*.la
+*.pc
 *.tar.gz
 *.zip
 docs/html
 TAGS
-examples/basic
+tags
 examples/active
-examples/roster
+examples/basic
 examples/bot
+examples/component
+examples/register
+examples/roster
+examples/uuid
+examples/vcard
 test_stamp
+test-suite.log
 tests/*.o
+tests/*.log
+tests/*.trs
+tests/check_parser
 tests/test_base64
 tests/test_ctx
 tests/test_hash
 tests/test_jid
+tests/test_md5
+tests/test_rand
+tests/test_resolver
 tests/test_sasl
+tests/test_scram
+tests/test_sha1
+tests/test_sha256
+tests/test_sha512
+tests/test_snprintf
 tests/test_sock
+tests/test_stanza
+tests/test_string
+m4/
+libstrophe.project
+libs/
+obj/
+expat/
+.settings/
+.project
+.cproject

.travis.yml

@@ -0,0 +1,24 @@
+language: c
+install:
+  - sudo apt-get update
+  - sudo apt-get -y install libtool pkg-config libexpat1-dev libxml2-dev libssl-dev libc-ares-dev dos2unix
+stages:
+  - style
+  - test
+before_script:
+  - ./bootstrap.sh
+env:
+  - CONFIGURE_OPT="--without-libxml2"
+  - CONFIGURE_OPT="--with-libxml2"
+  - CONFIGURE_OPT="--disable-tls"
+  - CONFIGURE_OPT="--enable-cares"
+script: ./configure ${CONFIGURE_OPT} CFLAGS="-Werror" && make && make check
+jobs:
+  include:
+    - stage: style
+      name: "Check code style"
+      script: ./configure && make format && git diff --exit-code
+      env:
+        - CONFIGURE_OPT=""
+matrix:
+    fast_finish: true

ChangeLog

@@ -1,3 +1,106 @@
-0.8.5
+0.10.0
- - libtoolize to generate .so
+	- Coding style has been unified
+	- SCRAM-SHA-256 and SCRAM-SHA-512 support
+	- c-ares support
+	- LibreSSL support
+	- Introduced global timed handlers that fire periodically regardless of
+	  connections status, such a handler can be used to implement deferred
+	  re-connection
+	- examples/register implements XEP-0077
+	- Fixed issue with IPv6 on Windows (#153)
+	- Improved portability across systems such as Haiku, Windows
+	- New API:
+		- xmpp_stanza_get_child_by_name_and_ns()
+		- xmpp_conn_is_connecting()
+		- xmpp_conn_is_connected()
+		- xmpp_conn_is_disconnected()
+		- xmpp_stanza_new_from_string()
+		- xmpp_stanza_add_child_ex()
+		- xmpp_stanza_get_context()
+		- xmpp_stanza_reply_error()
+		- xmpp_global_timed_handler_add()
+		- xmpp_global_timed_handler_delete()
 
+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
+
+0.9.0
+	- IPv6 support
+	- Legacy SSL support
+	- Initial Android support
+	- Resolver returns all SRV records instead of one. Lookup is performed
+	  according to RFC2052
+	- xmpp_connect_raw() provides access to a xmpp_conn object just after
+	  establishing TCP connection. This allows to implement in-band
+	  registration, authentication mechanisms or serverless messaging
+	- xmpp_conn_t object is reusable now and can be reconnected with saving
+	  all handlers, flags, jid and password
+	- New API:
+		- xmpp_uuid_gen()
+		- xmpp_connect_raw()
+		- xmpp_conn_open_stream_default()
+		- xmpp_conn_open_stream()
+		- xmpp_conn_tls_start()
+		- xmpp_conn_get_flags()
+		- xmpp_conn_set_flags()
+		- xmpp_conn_set_keepalive()
+		- xmpp_conn_is_secured()
+		- xmpp_stanza_del_attribute()
+		- xmpp_stanza_get_to()
+		- xmpp_stanza_get_from()
+		- xmpp_stanza_set_to()
+		- xmpp_stanza_set_from()
+		- xmpp_stanza_reply()
+		- xmpp_message_new()
+		- xmpp_message_get_body()
+		- xmpp_message_set_body()
+		- xmpp_iq_new()
+		- xmpp_presence_new()
+	- Exposed private API:
+		- xmpp_jid_new()
+		- xmpp_jid_bare()
+		- xmpp_jid_node()
+		- xmpp_jid_domain()
+		- xmpp_jid_resource()
+		- xmpp_stanza_get_attribute_count()
+		- xmpp_stanza_get_attributes()
+
+0.8.8
+	- XML namespace support
+	- XEP-0114 support
+
+0.8.7
+	- SCRAM-SHA-1 authentication mechanism
+	- pkg-config support
+
+0.8.5
+	- libtoolize to generate .so

Makefile.am

@@ -1,27 +1,74 @@
 AUTOMAKE_OPTIONS = subdir-objects
 
-AM_CFLAGS = -g -Wall
+ACLOCAL_AMFLAGS = -I m4
 
 PARSER_CFLAGS=@PARSER_CFLAGS@
 PARSER_LIBS=@PARSER_LIBS@
 
-SSL_LIBS = -lssl -lcrypto -lz
+SSL_CFLAGS = @openssl_CFLAGS@
+SSL_LIBS = @openssl_LIBS@
 
-STROPHE_FLAGS = -I$(top_srcdir)
+RESOLV_CFLAGS = @RESOLV_CFLAGS@
-STROPHE_LIBS = -lstrophe $(PARSER_LIBS) $(SSL_LIBS)
+RESOLV_LIBS = @RESOLV_LIBS@
+
+WARNING_FLAGS = @WARNING_FLAGS@
+STROPHE_FLAGS = -I$(top_srcdir) $(WARNING_FLAGS)
+STROPHE_LIBS = libstrophe.la
 
 ## Main build targets
 lib_LTLIBRARIES = libstrophe.la
 
-libstrophe_la_CFLAGS=$(STROPHE_FLAGS) $(PARSER_CFLAGS)
+libstrophe_la_CFLAGS = $(SSL_CFLAGS) $(STROPHE_FLAGS) $(PARSER_CFLAGS) $(RESOLV_CFLAGS)
-libstrophe_la_LDFLAGS=$(SSL_LIBS) $(PARSER_LIBS)
+libstrophe_la_LDFLAGS = $(SSL_LIBS) $(PARSER_LIBS) $(RESOLV_LIBS) -no-undefined
-libstrophe_la_SOURCES = src/auth.c src/conn.c src/ctx.c \
+# Export only public API
-	src/event.c src/handler.c src/hash.c \
+libstrophe_la_LDFLAGS += -export-symbols-regex '^xmpp_'
-	src/jid.c src/md5.c src/sasl.c src/sha1.c \
+
-	src/snprintf.c src/sock.c src/stanza.c src/thread.c \
+libstrophe_la_SOURCES = \
-	src/tls_openssl.c src/util.c \
+	src/auth.c \
-	src/common.h src/hash.h src/md5.h src/ostypes.h src/parser.h \
+	src/conn.c \
-	src/sasl.h src/sha1.h src/sock.h src/thread.h src/tls.h src/util.h
+	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/sha256.c \
+	src/sha512.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/sha.h \
+	src/sha1.h \
+	src/sha256.h \
+	src/sha512.h \
+	src/snprintf.h \
+	src/sock.h \
+	src/tls.h \
+	src/util.h
+
+if DISABLE_TLS
+libstrophe_la_SOURCES += src/tls_dummy.c
+else
+libstrophe_la_SOURCES += src/tls_openssl.c
+endif
 
 if PARSER_EXPAT
 libstrophe_la_SOURCES += src/parser_expat.c
@@ -30,30 +77,146 @@ libstrophe_la_SOURCES += src/parser_libxml2.c
 endif
 
 include_HEADERS = strophe.h
-noinst_HEADERS = strophepp.h
 
-EXTRA_DIST = docs
+pkgconfig_DATA = libstrophe.pc
+
+EXTRA_DIST = \
+	_clang-format \
+	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 \
+	src/tls_gnutls.c \
+	src/tls_schannel.c \
+	tests/res_query_dump.c
 
 ## Examples
-noinst_PROGRAMS = examples/active examples/roster examples/basic examples/bot
+noinst_PROGRAMS = \
+	examples/active \
+	examples/basic \
+	examples/bot \
+	examples/component \
+	examples/roster \
+	examples/uuid \
+	examples/vcard \
+	examples/register
+
 examples_active_SOURCES = examples/active.c
 examples_active_CFLAGS = $(STROPHE_FLAGS)
-examples_active_LDADD = $(STROPHE_LIBS) 
+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) 
+examples_basic_LDADD = $(STROPHE_LIBS)
 examples_bot_SOURCES = examples/bot.c
 examples_bot_CFLAGS = $(STROPHE_FLAGS)
-examples_bot_LDADD = $(STROPHE_LIBS) 
+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)
+examples_register_SOURCES = examples/register.c
+examples_register_CFLAGS = $(STROPHE_FLAGS)
+examples_register_LDADD = $(STROPHE_LIBS)
 
 
 ## Tests
-TESTS = tests/check_parser
+TESTS = \
-check_PROGRAMS = tests/check_parser
+	tests/check_parser \
+	tests/test_sha1 \
+	tests/test_sha256 \
+	tests/test_sha512 \
+	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_stanza \
+	tests/test_resolver
+
+check_PROGRAMS = $(TESTS)
+
 tests_check_parser_SOURCES = tests/check_parser.c tests/test.h
-tests_check_parser_CFLAGS = @check_CFLAGS@ $(PARSER_CFLAGS) $(STROPHE_FLAGS) \
+tests_check_parser_CFLAGS = $(PARSER_CFLAGS) $(STROPHE_FLAGS) \
 	-I$(top_srcdir)/src
-tests_check_parser_LDADD = @check_LIBS@ $(STROPHE_LIBS)
+tests_check_parser_LDADD = $(STROPHE_LIBS)
+tests_check_parser_LDFLAGS = -static
+
+tests_test_ctx_SOURCES = tests/test_ctx.c
+tests_test_ctx_CFLAGS = $(STROPHE_FLAGS) -I$(top_srcdir)/src
+tests_test_ctx_LDADD = $(STROPHE_LIBS)
+tests_test_ctx_LDFLAGS = -static
+
+tests_test_base64_SOURCES = tests/test_base64.c tests/test.c tests/test.h
+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)
+tests_test_jid_LDFLAGS = -static
+
+tests_test_resolver_SOURCES = tests/test_resolver.c tests/test.h
+tests_test_resolver_CFLAGS = $(STROPHE_FLAGS) -I$(top_srcdir)/src
+tests_test_resolver_LDADD = $(STROPHE_LIBS)
+tests_test_resolver_LDFLAGS = -static
+
+tests_test_rand_SOURCES = tests/test_rand.c tests/test.c src/sha1.c
+tests_test_rand_CFLAGS = $(STROPHE_FLAGS) -I$(top_srcdir)/src
+
+tests_test_scram_SOURCES = tests/test_scram.c tests/test.c src/sha1.c \
+	src/sha256.c src/sha512.c
+tests_test_scram_CFLAGS = $(STROPHE_FLAGS) -I$(top_srcdir)/src
+
+tests_test_sha1_SOURCES = tests/test_sha1.c src/sha1.c
+tests_test_sha1_CFLAGS = -I$(top_srcdir)/src
+
+tests_test_sha256_SOURCES = tests/test_sha256.c tests/test.c src/sha256.c
+tests_test_sha256_CFLAGS = -I$(top_srcdir)/src
+
+tests_test_sha512_SOURCES = tests/test_sha512.c tests/test.c src/sha512.c
+tests_test_sha512_CFLAGS = -I$(top_srcdir)/src
+
+tests_test_md5_SOURCES = tests/test_md5.c tests/test.c src/md5.c
+tests_test_md5_CFLAGS = -I$(top_srcdir)/src
+
+tests_test_snprintf_SOURCES = tests/test_snprintf.c
+tests_test_snprintf_CFLAGS = -I$(top_srcdir)/src
+
+tests_test_string_SOURCES = tests/test_string.c tests/test.h
+tests_test_string_CFLAGS = $(STROPHE_FLAGS) -I$(top_srcdir)/src
+tests_test_string_LDADD = $(STROPHE_LIBS)
+tests_test_string_LDFLAGS = -static
+
+tests_test_stanza_SOURCES = tests/test_stanza.c
+tests_test_stanza_CFLAGS = $(STROPHE_FLAGS)
+tests_test_stanza_LDADD = $(STROPHE_LIBS)
+tests_test_stanza_LDFLAGS = -static
+
+format:
+	@echo "   * run clang-format on all sources"
+	@dos2unix -q src/*.[ch] *.h tests/*.[ch] examples/*.c
+	@clang-format -i src/*.[ch] *.h tests/*.[ch] examples/*.c

README.markdown

@@ -1,16 +1,14 @@
-# libstrophe
+libstrophe [![Build Status](https://travis-ci.org/strophe/libstrophe.png?branch=master)](https://travis-ci.org/strophe/libstrophe)
+==========
 
 libstrophe is a lightweight XMPP client library written in C. It has
 minimal dependencies and is configurable for various environments. It
-runs well on both Linux, Unix, and Windows based platforms.
+runs well on Linux, Unix and Windows based platforms.
 
-Its goals are:
+libstrophe is dual licensed under MIT and GPLv3.
 
-- usable quickly
+Build Instructions
-- well documented
+------------------
-- reliable
-
-## Build Instructions
 
 If you are building from a source control checkout, run:
 
@@ -23,9 +21,7 @@ From the top-level directory, run the following commands:
     ./configure
     make
 
-This will create a static library, also in the top-level
+The public API is defined in `strophe.h` which is in the
-directory, which can be linked into other programs. The 
-public API is defined in `strophe.h` which is also in the
 top-level directory.
 
 The `examples` directory contains some examples of how to
@@ -41,27 +37,31 @@ another path use the `--prefix` option during configure, e.g.:
 
     ./configure --prefix=/usr
 
-## Requirements
+### Android
+
+Run script `build-android.sh` and follow the instructions. You will
+need expat sources and android-ndk.
+
+Requirements
+------------
 
 libstrophe requires:
 
 - expat or libxml2 - expat is the default; use --with-libxml2 to
   switch
-- libresolv on UNIX systems - make sure you include -lresolv
+- openssl on UNIX systems
-  if you are compiling by hand. 
-- libtool
 
-In addition, if you wish to run the unit tests, you will need the
+To build libstrophe using autotools you will need autoconf, automake,
-check package.
+libtool and pkg-config.
 
-### OS X (with Homebrew package manager)
+Installation
+------------
 
-You can install the requirements with:
+libstrophe package has been added to popular Linux distributions,
+BSD systems and OSX package managers.
 
-    brew install expat
+Documentation
-    brew install check
+-------------
-
-## Documentation
 
 API documentation is inline with the code and conforms to Doxygen
 standards. You can generate an HTML version of the API documentation

_clang-format

@@ -0,0 +1,17 @@
+---
+AlignConsecutiveAssignments: 'false'
+AlignEscapedNewlines: Left
+AllowShortBlocksOnASingleLine: 'true'
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: 'false'
+BinPackParameters: 'false'
+BreakBeforeBraces: Linux
+ColumnLimit: '80'
+DerivePointerAlignment: 'false'
+IndentWidth: '4'
+PointerAlignment: Right
+SortIncludes: 'false'
+TabWidth: '4'
+UseTab: Never
+
+...

bootstrap.sh

@@ -1,3 +1,5 @@
 #!/bin/sh
 
+# Some versions of aclocal fail if m4/ doesn't exist
+mkdir -p m4
 autoreconf -i

build-android.sh

@@ -0,0 +1,39 @@
+#!/bin/sh
+
+DIR=`dirname $0`
+EXPAT_PATH="$DIR/expat"
+EXPAT_FILE='lib/expat.h'
+
+echo
+echo Attention: libstrophe will be built without TLS support. To enable TLS
+echo you need to replace \'src/tls_dummy.c\' with \'src/tls_opnessl.c\' in
+echo \'jni/Android.mk\', add path to the openssl headers and link your program
+echo with libssl and libcrypto.
+echo
+
+if [ ! -d $EXPAT_PATH ]; then
+    mkdir $EXPAT_PATH
+fi
+
+# TODO Accept expat tarball as argument and extract it to the right place.
+#      Or download sources from sf.net.
+
+if [ ! -d $EXPAT_PATH/lib -o ! -f "$EXPAT_PATH/$EXPAT_FILE" ]; then
+    cat <<EOT
+    Error: expat sources not found.
+
+    Extract expat sources to $EXPAT_PATH. Make sure $EXPAT_PATH/$EXPAT_FILE and
+    other source files exist.
+EOT
+    exit 1
+fi
+
+ndk-build -C "$DIR" clean || exit 1
+ndk-build -C "$DIR"       || exit 1
+
+echo
+echo "basic example:"
+ls -l "$DIR"/libs/*/basic
+echo
+echo "libstrophe.a:"
+ls -l "$DIR"/obj/local/*/libstrophe.a

configure.ac

@@ -1,55 +1,159 @@
-AC_INIT([libstrophe], [0.8.5], [jack@metajack.im])
+AC_INIT([libstrophe], [0.10.0], [jack@metajack.im])
+AC_CONFIG_MACRO_DIR([m4])
 AM_INIT_AUTOMAKE([foreign])
 LT_INIT([dlopen])
 
 AC_PROG_CC
 AM_PROG_CC_C_O
+PKG_PROG_PKG_CONFIG
 
-AC_CHECK_HEADER(openssl/ssl.h, [], [AC_MSG_ERROR([couldn't find openssl headers, openssl required])])
+AC_CANONICAL_HOST
-PKG_CHECK_MODULES([check], [check >= 0.9.4], [], [AC_MSG_WARN([libcheck not found; unit tests will not be compilable])])
+AS_CASE([$host_os],
+    [freebsd*],    [PLATFORM="bsd"],
+    [openbsd*],    [PLATFORM="bsd"],
+    [netbsd*],     [PLATFORM="bsd"],
+    [*nto*|*qnx*], [PLATFORM="qnx"],
+    [*solaris*],   [PLATFORM="solaris"],
+    [*android*],   [PLATFORM="android"],
+    [*haiku*],     [PLATFORM="haiku"],
+                   [PLATFORM="nix"])
+
+WARNING_FLAGS="-Wall"
+
+AS_CASE([$PLATFORM],
+    [haiku],   [],
+               [WARNING_FLAGS="$WARNING_FLAGS -Wextra"])
 
 AC_ARG_WITH([libxml2],
-            [AS_HELP_STRING([--with-libxml2], [use libxml2 for XML parsing])],
+    [AS_HELP_STRING([--with-libxml2], [use libxml2 for XML parsing, expat is the default])])
-            [with_libxml2=check],
+AC_ARG_ENABLE([tls],
-            [with_libxml2=no])
+    [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$with_libxml2" != xno; then
+AC_SEARCH_LIBS([socket], [network socket])
-  PKG_CHECK_MODULES([libxml2], [libxml-2.0 >= 2.7],
+AC_CHECK_FUNCS([snprintf vsnprintf])
-                    [with_libxml2=yes], [dummy=1])
+AC_CHECK_DECLS([va_copy], [], [], [#include <stdarg.h>])
-  if test "x$with_libxml2" != xyes; then
+
-    old_CFLAGS=$CFLAGS
+if test "x$enable_tls" != xno; then
-    CFLAGS="-I /usr/include/libxml2"
+    PKG_CHECK_MODULES([openssl], [openssl],
-    AC_CHECK_HEADER([libxml/parser.h],
+        [PC_REQUIRES="openssl ${PC_REQUIRES}"],
-                    [with_libxml2=yes; libxml2_CFLAGS="-I /usr/include/libxml2"; libxml2_LIBS="-lxml2"],
+        [AC_CHECK_HEADER([openssl/ssl.h],
-                    [AC_MSG_ERROR([couldn't find libxml2])])
+            [
-    CFLAGS=$old_CFLAGS
+                openssl_LIBS="-lssl -lcrypto"
-  fi
+                PC_LIBS="${openssl_LIBS} ${PC_LIBS}"
-else
+            ],
-  AC_CHECK_HEADER(expat.h, [], [AC_MSG_ERROR([couldn't find expat headers; expat required])])
+            [AC_MSG_ERROR([openssl not found; openssl required])]
+        )])
 fi
 
-if test "x$with_libxml2" = xyes; then
+with_parser=""
-  with_parser=libxml2
+if test "x$with_libxml2" != xyes; then
-  PARSER_NAME=libxml2
+    PKG_CHECK_MODULES([expat], [expat >= 2.0.0],
-  PARSER_CFLAGS=\$\(libxml2_CFLAGS\)
+        [
-  PARSER_LIBS=\$\(libxml2_LIBS\)
+            with_parser="expat"
+            PC_REQUIRES="expat ${PC_REQUIRES}"
+        ],
+        [AC_CHECK_HEADER([expat.h],
+            [
+                with_parser="expat"
+                expat_LIBS="-lexpat"
+                PC_LIBS="${expat_LIBS} ${PC_LIBS}"
+            ])
+        ])
+fi
+if test "x$with_libxml2" != xno -a "x$with_parser" = x; then
+    PKG_CHECK_MODULES([libxml2], [libxml-2.0 >= 2.7],
+        [
+            with_parser="libxml2"
+            PC_REQUIRES="libxml-2.0 ${PC_REQUIRES}"
+        ],
+        [
+            old_CFLAGS=$CFLAGS
+            CFLAGS="-I${includedir}/libxml2"
+            AC_CHECK_HEADER([libxml/parser.h],
+                [
+                    with_parser="libxml2"
+                    libxml2_CFLAGS="-I${includedir}/libxml2"
+                    libxml2_LIBS="-lxml2 -lm"
+                    PC_LIBS="${libxml2_LIBS} ${PC_LIBS}"
+                    PC_CFLAGS="${libxml2_CFLAGS} ${PC_CFLAGS}"
+                ])
+            CFLAGS=$old_CFLAGS
+        ])
+fi
+
+if test "x$with_parser" = xlibxml2; then
+    PARSER_CFLAGS=$libxml2_CFLAGS
+    PARSER_LIBS=$libxml2_LIBS
+elif test "x$with_parser" = xexpat; then
+    PARSER_CFLAGS=$expat_CFLAGS
+    PARSER_LIBS=$expat_LIBS
 else
-  with_parser=expat
+    AC_MSG_ERROR([no XML parser was found, libstrophe requires expat or libxml2])
-  PARSER_NAME=expat
-  PARSER_CFLAGS=
-  PARSER_LIBS=-lexpat
 fi
 
 AC_MSG_NOTICE([libstrophe will use the $with_parser XML parser])
-AC_SEARCH_LIBS([socket], [socket])
 
-AC_LINK_IFELSE([AC_LANG_CALL([#include <resolv.h>], [res_query])], [],[LIBS="$LIBS -lresolv"])
+if test "x$enable_cares" = xyes; then
+    PKG_CHECK_MODULES([libcares], [libcares >= 1.7.0],
+        [
+            PC_REQUIRES="libcares ${PC_REQUIRES}"
+            RESOLV_CFLAGS=$libcares_CFLAGS
+            RESOLV_LIBS=$libcares_LIBS
+            AC_DEFINE([HAVE_CARES])
+        ],
+        [AC_MSG_ERROR([libcares not found])])
+        # TODO: if pkg-config doesn't find, check the library manually
+else
 
-AC_CHECK_HEADERS([arpa/nameser_compat.h])
+AS_CASE([$PLATFORM],
+    [bsd],     [RESOLV_LIBS=""],
+    [qnx],     [RESOLV_LIBS="-lsocket"],
+    [solaris], [RESOLV_LIBS="-lresolv -lsocket -lnsl"],
+    [android], [RESOLV_LIBS=""],
+    [haiku],   [RESOLV_LIBS="-lnetwork"],
+               [RESOLV_LIBS="-lresolv"])
+
+LIBS_TMP="${LIBS}"
+LIBS="${RESOLV_LIBS}"
+AC_LINK_IFELSE([AC_LANG_SOURCE([
+        #include <sys/types.h>
+        #include <netinet/in.h>
+        #include <arpa/nameser.h>
+        #include <resolv.h>
+        #include <netdb.h>
+
+        int main() {
+            (void)res_query(NULL, 0, 0, NULL, 0);
+            return 0;
+        }
+    ])],
+    [],
+    [AC_MSG_ERROR([res_query() not found with LIBS="${LIBS}"])])
+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],
+            [install directory for libstrophe.pc pkg-config file])],
+        [], [with_pkgconfigdir='$(libdir)/pkgconfig'])
+    AC_SUBST([pkgconfigdir], [${with_pkgconfigdir}])])
 
 AM_CONDITIONAL([PARSER_EXPAT], [test x$with_parser != xlibxml2])
-AC_SUBST(PARSER_NAME)
+AM_CONDITIONAL([DISABLE_TLS], [test x$enable_tls = xno])
+
+AC_SUBST([PC_REQUIRES], [${PC_REQUIRES}])
+AC_SUBST([PC_CFLAGS], [${PC_CFLAGS}])
+AC_SUBST([PC_LIBS], [${PC_LIBS}])
+
 AC_SUBST(PARSER_CFLAGS)
 AC_SUBST(PARSER_LIBS)
-AC_CONFIG_FILES([Makefile])
+AC_SUBST(RESOLV_CFLAGS)
+AC_SUBST(RESOLV_LIBS)
+AC_SUBST(WARNING_FLAGS)
+AC_CONFIG_FILES([Makefile libstrophe.pc])
 AC_OUTPUT

examples/README.md

@@ -0,0 +1,7 @@
+Build Instructions
+==================
+
+Compile example files with the following gcc flags:
+```
+gcc -o bot bot.c `pkg-config --cflags --libs libstrophe`
+```

examples/active.c

@@ -1,15 +1,12 @@
 /* active.c
 ** libstrophe XMPP client library -- basic usage example
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+** This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /* This example demonstrates basic handler functions by printing out
@@ -22,23 +19,25 @@
 
 #include <strophe.h>
 
-int handle_reply(xmpp_conn_t * const conn,
+int handle_reply(xmpp_conn_t *const conn,
-		 xmpp_stanza_t * const stanza,
+                 xmpp_stanza_t *const stanza,
-		 void * const userdata)
+                 void *const userdata)
 {
     xmpp_stanza_t *query, *item;
-    char *type;
+    const char *type;
+
+    (void)userdata;
 
     type = xmpp_stanza_get_type(stanza);
     if (strcmp(type, "error") == 0)
-	fprintf(stderr, "ERROR: query failed\n");
+        fprintf(stderr, "ERROR: query failed\n");
     else {
-	query = xmpp_stanza_get_child_by_name(stanza, "query");
+        query = xmpp_stanza_get_child_by_name(stanza, "query");
-	printf("Active Sessions:\n");
+        printf("Active Sessions:\n");
-	for (item = xmpp_stanza_get_children(query); item; 
+        for (item = xmpp_stanza_get_children(query); item;
-	     item = xmpp_stanza_get_next(item))
+             item = xmpp_stanza_get_next(item))
-	    printf("\t %s\n", xmpp_stanza_get_attribute(item, "jid"));
+            printf("\t %s\n", xmpp_stanza_get_attribute(item, "jid"));
-	printf("END OF LIST\n");
+        printf("END OF LIST\n");
     }
 
     /* disconnect */
@@ -47,44 +46,46 @@ int handle_reply(xmpp_conn_t * const conn,
     return 0;
 }
 
-void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status, 
+void conn_handler(xmpp_conn_t *const conn,
-		  const int error, xmpp_stream_error_t * const stream_error,
+                  const xmpp_conn_event_t status,
-		  void * const userdata)
+                  const int error,
+                  xmpp_stream_error_t *const stream_error,
+                  void *const userdata)
 {
     xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
     xmpp_stanza_t *iq, *query;
 
+    (void)error;
+    (void)stream_error;
+
     if (status == XMPP_CONN_CONNECT) {
-	fprintf(stderr, "DEBUG: connected\n");
+        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");
-	xmpp_stanza_set_attribute(iq, "to", "xxxxxxxxx.com");
 
-	query = xmpp_stanza_new(ctx);
+        /* create iq stanza for request */
-	xmpp_stanza_set_name(query, "query");
+        iq = xmpp_iq_new(ctx, "get", "active1");
-	xmpp_stanza_set_ns(query, XMPP_NS_DISCO_ITEMS);
+        xmpp_stanza_set_to(iq, "xxxxxxxxx.com");
-	xmpp_stanza_set_attribute(query, "node", "sessions");
 
-	xmpp_stanza_add_child(iq, query);
+        query = xmpp_stanza_new(ctx);
+        xmpp_stanza_set_name(query, "query");
+        xmpp_stanza_set_ns(query, XMPP_NS_DISCO_ITEMS);
+        xmpp_stanza_set_attribute(query, "node", "sessions");
 
-	/* we can release the stanza since it belongs to iq now */
+        xmpp_stanza_add_child(iq, query);
-	xmpp_stanza_release(query);
 
-	/* set up reply handler */
+        /* we can release the stanza since it belongs to iq now */
-	xmpp_id_handler_add(conn, handle_reply, "active1", ctx);
+        xmpp_stanza_release(query);
 
-	/* send out the stanza */
+        /* set up reply handler */
-	xmpp_send(conn, iq);
+        xmpp_id_handler_add(conn, handle_reply, "active1", ctx);
 
-	/* release the stanza */
+        /* send out the stanza */
-	xmpp_stanza_release(iq);
+        xmpp_send(conn, iq);
+
+        /* release the stanza */
+        xmpp_stanza_release(iq);
     } else {
-	fprintf(stderr, "DEBUG: disconnected\n");
+        fprintf(stderr, "DEBUG: disconnected\n");
-	xmpp_stop(ctx);
+        xmpp_stop(ctx);
     }
 }
 
@@ -94,8 +95,8 @@ int main(int argc, char **argv)
     xmpp_conn_t *conn;
 
     if (argc != 3) {
-	fprintf(stderr, "Usage: active <jid> <pass>\n\n");
+        fprintf(stderr, "Usage: active <jid> <pass>\n\n");
-	return 1;
+        return 1;
     }
 
     /* initialize lib */
@@ -107,6 +108,13 @@ int main(int argc, char **argv)
     /* create a connection */
     conn = xmpp_conn_new(ctx);
 
+    /*
+     * also you can disable TLS support or force legacy SSL
+     * connection without STARTTLS
+     *
+     * see xmpp_conn_set_flags() or examples/basic.c
+     */
+
     /* setup authentication information */
     xmpp_conn_set_jid(conn, argv[1]);
     xmpp_conn_set_pass(conn, argv[2]);

examples/basic.c

@@ -6,30 +6,57 @@
 **  This software is provided AS-IS with no warranty, either express
 **  or implied.
 **
-**  This software is distributed under license and may not be copied,
+** This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 #include <stdio.h>
+#include <string.h>
 
 #include <strophe.h>
 
+/* hardcoded TCP keepalive timeout and interval */
+#define KA_TIMEOUT 60
+#define KA_INTERVAL 1
 
 /* define a handler for connection events */
-void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status,
+void conn_handler(xmpp_conn_t *const conn,
-                  const int error, xmpp_stream_error_t * const stream_error,
+                  const xmpp_conn_event_t status,
-                  void * const userdata)
+                  const int error,
+                  xmpp_stream_error_t *const stream_error,
+                  void *const userdata)
 {
     xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
+    int secured;
+
+    (void)error;
+    (void)stream_error;
 
     if (status == XMPP_CONN_CONNECT) {
         fprintf(stderr, "DEBUG: connected\n");
+        secured = xmpp_conn_is_secured(conn);
+        fprintf(stderr, "DEBUG: connection is %s.\n",
+                secured ? "secured" : "NOT secured");
         xmpp_disconnect(conn);
-    }
+    } else {
-    else {
+        switch (error) {
-        fprintf(stderr, "DEBUG: disconnected\n");
+        case XMPP_EOK:
+            fprintf(stderr, "DEBUG: disconnected successfully.\n");
+            break;
+        case XMPP_EINVOP:
+            /*
+             * This may happen when the requested functionality is not
+             * supported or some data is not provided when it is required (e.g.
+             * resource part).
+             */
+            fprintf(stderr, "DEBUG: disconnected, invalid operation.\n");
+            break;
+        case XMPP_ECERT:
+            /*
+             * In this case, application can reconnect with
+             * XMPP_CONN_FLAG_TRUST_TLS if user permits.
+             */
+            fprintf(stderr, "DEBUG: disconnected, invalid TLS certificate.\n");
+        }
         xmpp_stop(ctx);
     }
 }
@@ -39,31 +66,69 @@ int main(int argc, char **argv)
     xmpp_ctx_t *ctx;
     xmpp_conn_t *conn;
     xmpp_log_t *log;
-    char *jid, *pass, *host;
+    char *jid, *pass, *host = NULL;
+    long flags = 0;
+    int tcp_keepalive = 0;
+    int i;
 
     /* take a jid and password on the command line */
-    if (argc < 3 || argc > 4) {
+    for (i = 1; i < argc; ++i) {
-        fprintf(stderr, "Usage: basic <jid> <pass> [<host>]\n\n");
+        if (strcmp(argv[i], "--disable-tls") == 0)
+            flags |= XMPP_CONN_FLAG_DISABLE_TLS;
+        else if (strcmp(argv[i], "--mandatory-tls") == 0)
+            flags |= XMPP_CONN_FLAG_MANDATORY_TLS;
+        else if (strcmp(argv[i], "--trust-tls") == 0)
+            flags |= XMPP_CONN_FLAG_TRUST_TLS;
+        else if (strcmp(argv[i], "--legacy-ssl") == 0)
+            flags |= XMPP_CONN_FLAG_LEGACY_SSL;
+        else if (strcmp(argv[i], "--legacy-auth") == 0)
+            flags |= XMPP_CONN_FLAG_LEGACY_AUTH;
+        else if (strcmp(argv[i], "--tcp-keepalive") == 0)
+            tcp_keepalive = 1;
+        else
+            break;
+    }
+    if ((argc - i) < 2 || (argc - i) > 3) {
+        fprintf(stderr, "Usage: basic [options] <jid> <pass> [<host>]\n\n"
+                        "Options:\n"
+                        "  --disable-tls        Disable TLS.\n"
+                        "  --mandatory-tls      Deny plaintext connection.\n"
+                        "  --trust-tls          Trust TLS certificate.\n"
+                        "  --legacy-ssl         Use old style SSL.\n"
+                        "  --legacy-auth        Allow legacy authentication.\n"
+                        "  --tcp-keepalive      Configure TCP keepalive.\n\n"
+                        "Note: --disable-tls conflicts with --mandatory-tls or "
+                        "--legacy-ssl\n");
         return 1;
     }
 
-    jid = argv[1];
+    jid = argv[i];
-    pass = argv[2];
+    pass = argv[i + 1];
-    host = NULL;
+    if (i + 2 < argc)
+        host = argv[i + 2];
 
-    if (argc == 4)
+    /*
-        host = argv[3];
+     * Note, this example doesn't handle errors. Applications should check
+     * return values of non-void functions.
+     */
 
     /* init library */
     xmpp_initialize();
 
+    /* pass NULL instead to silence output */
+    log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG);
     /* create a context */
-    log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG); /* pass NULL instead to silence output */
     ctx = xmpp_ctx_new(NULL, log);
 
     /* create a connection */
     conn = xmpp_conn_new(ctx);
 
+    /* configure connection properties (optional) */
+    xmpp_conn_set_flags(conn, flags);
+    /* configure TCP keepalive (optional) */
+    if (tcp_keepalive)
+        xmpp_conn_set_keepalive(conn, KA_TIMEOUT, KA_INTERVAL);
+
     /* setup authentication information */
     xmpp_conn_set_jid(conn, jid);
     xmpp_conn_set_pass(conn, pass);

examples/bot.c

@@ -1,19 +1,16 @@
 /* bot.c
 ** libstrophe XMPP client library -- basic usage example
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+** This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /* simple bot example
-**  
+**
 ** This example was provided by Matthew Wild <mwild1@gmail.com>.
 **
 ** This bot responds to basic messages and iq version requests.
@@ -25,109 +22,127 @@
 
 #include <strophe.h>
 
-
+int version_handler(xmpp_conn_t *const conn,
-int version_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata)
+                    xmpp_stanza_t *const stanza,
+                    void *const userdata)
 {
-	xmpp_stanza_t *reply, *query, *name, *version, *text;
+    xmpp_stanza_t *reply, *query, *name, *version, *text;
-	char *ns;
+    const char *ns;
-	xmpp_ctx_t *ctx = (xmpp_ctx_t*)userdata;
+    xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
-	printf("Received version request from %s\n", xmpp_stanza_get_attribute(stanza, "from"));
+
-	
+    printf("Received version request from %s\n", xmpp_stanza_get_from(stanza));
-	reply = xmpp_stanza_new(ctx);
+
-	xmpp_stanza_set_name(reply, "iq");
+    reply = xmpp_stanza_reply(stanza);
-	xmpp_stanza_set_type(reply, "result");
+    xmpp_stanza_set_type(reply, "result");
-	xmpp_stanza_set_id(reply, xmpp_stanza_get_id(stanza));
+
-	xmpp_stanza_set_attribute(reply, "to", xmpp_stanza_get_attribute(stanza, "from"));
+    query = xmpp_stanza_new(ctx);
-	
+    xmpp_stanza_set_name(query, "query");
-	query = xmpp_stanza_new(ctx);
-	xmpp_stanza_set_name(query, "query");
     ns = xmpp_stanza_get_ns(xmpp_stanza_get_children(stanza));
     if (ns) {
         xmpp_stanza_set_ns(query, ns);
     }
 
-	name = xmpp_stanza_new(ctx);
+    name = xmpp_stanza_new(ctx);
-	xmpp_stanza_set_name(name, "name");
+    xmpp_stanza_set_name(name, "name");
-	xmpp_stanza_add_child(query, name);
+    xmpp_stanza_add_child(query, name);
-	
+    xmpp_stanza_release(name);
-	text = xmpp_stanza_new(ctx);
-	xmpp_stanza_set_text(text, "libstrophe example bot");
-	xmpp_stanza_add_child(name, text);
-	
-	version = xmpp_stanza_new(ctx);
-	xmpp_stanza_set_name(version, "version");
-	xmpp_stanza_add_child(query, version);
-	
-	text = xmpp_stanza_new(ctx);
-	xmpp_stanza_set_text(text, "1.0");
-	xmpp_stanza_add_child(version, text);
-	
-	xmpp_stanza_add_child(reply, query);
 
-	xmpp_send(conn, reply);
+    text = xmpp_stanza_new(ctx);
-	xmpp_stanza_release(reply);
+    xmpp_stanza_set_text(text, "libstrophe example bot");
-	return 1;
+    xmpp_stanza_add_child(name, text);
+    xmpp_stanza_release(text);
+
+    version = xmpp_stanza_new(ctx);
+    xmpp_stanza_set_name(version, "version");
+    xmpp_stanza_add_child(query, version);
+    xmpp_stanza_release(version);
+
+    text = xmpp_stanza_new(ctx);
+    xmpp_stanza_set_text(text, "1.0");
+    xmpp_stanza_add_child(version, text);
+    xmpp_stanza_release(text);
+
+    xmpp_stanza_add_child(reply, query);
+    xmpp_stanza_release(query);
+
+    xmpp_send(conn, reply);
+    xmpp_stanza_release(reply);
+    return 1;
 }
 
-
+int message_handler(xmpp_conn_t *const conn,
-int message_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata)
+                    xmpp_stanza_t *const stanza,
+                    void *const userdata)
 {
-	xmpp_stanza_t *reply, *body, *text;
+    xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
-	char *intext, *replytext;
+    xmpp_stanza_t *body, *reply;
-	xmpp_ctx_t *ctx = (xmpp_ctx_t*)userdata;
+    const char *type;
-	
+    char *intext, *replytext;
-	if(!xmpp_stanza_get_child_by_name(stanza, "body")) return 1;
+    int quit = 0;
-	if(!strcmp(xmpp_stanza_get_attribute(stanza, "type"), "error")) return 1;
+
-	
+    body = xmpp_stanza_get_child_by_name(stanza, "body");
-	intext = xmpp_stanza_get_text(xmpp_stanza_get_child_by_name(stanza, "body"));
+    if (body == NULL)
-	
+        return 1;
-	printf("Incoming message from %s: %s\n", xmpp_stanza_get_attribute(stanza, "from"), intext);
+    type = xmpp_stanza_get_type(stanza);
-	
+    if (type != NULL && strcmp(type, "error") == 0)
-	reply = xmpp_stanza_new(ctx);
+        return 1;
-	xmpp_stanza_set_name(reply, "message");
+
-	xmpp_stanza_set_type(reply, xmpp_stanza_get_type(stanza)?xmpp_stanza_get_type(stanza):"chat");
+    intext = xmpp_stanza_get_text(body);
-	xmpp_stanza_set_attribute(reply, "to", xmpp_stanza_get_attribute(stanza, "from"));
+
-	
+    printf("Incoming message from %s: %s\n", xmpp_stanza_get_from(stanza),
-	body = xmpp_stanza_new(ctx);
+           intext);
-	xmpp_stanza_set_name(body, "body");
+
-	
+    reply = xmpp_stanza_reply(stanza);
-	replytext = malloc(strlen(" to you too!") + strlen(intext) + 1);
+    if (xmpp_stanza_get_type(reply) == NULL)
-	strcpy(replytext, intext);
+        xmpp_stanza_set_type(reply, "chat");
-	strcat(replytext, " to you too!");
+
-	
+    if (strcmp(intext, "quit") == 0) {
-	text = xmpp_stanza_new(ctx);
+        replytext = strdup("bye!");
-	xmpp_stanza_set_text(text, replytext);
+        quit = 1;
-	xmpp_stanza_add_child(body, text);
+    } else {
-	xmpp_stanza_add_child(reply, body);
+        replytext = (char *)malloc(strlen(" to you too!") + strlen(intext) + 1);
-	
+        strcpy(replytext, intext);
-	xmpp_send(conn, reply);
+        strcat(replytext, " to you too!");
-	xmpp_stanza_release(reply);
+    }
-	free(replytext);
+    xmpp_free(ctx, intext);
-	return 1;
+    xmpp_message_set_body(reply, replytext);
+
+    xmpp_send(conn, reply);
+    xmpp_stanza_release(reply);
+    free(replytext);
+
+    if (quit)
+        xmpp_disconnect(conn);
+
+    return 1;
 }
 
 /* define a handler for connection events */
-void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status, 
+void conn_handler(xmpp_conn_t *const conn,
-		  const int error, xmpp_stream_error_t * const stream_error,
+                  const xmpp_conn_event_t status,
-		  void * const userdata)
+                  const int error,
+                  xmpp_stream_error_t *const stream_error,
+                  void *const userdata)
 {
     xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
 
+    (void)error;
+    (void)stream_error;
+
     if (status == XMPP_CONN_CONNECT) {
-	xmpp_stanza_t* pres;
+        xmpp_stanza_t *pres;
-	fprintf(stderr, "DEBUG: connected\n");
+        fprintf(stderr, "DEBUG: connected\n");
-	xmpp_handler_add(conn,version_handler, "jabber:iq:version", "iq", NULL, ctx);
+        xmpp_handler_add(conn, version_handler, "jabber:iq:version", "iq", NULL,
-	xmpp_handler_add(conn,message_handler, NULL, "message", NULL, ctx);
+                         ctx);
-	
+        xmpp_handler_add(conn, message_handler, NULL, "message", NULL, ctx);
-	/* Send initial <presence/> so that we appear online to contacts */
+
-	pres = xmpp_stanza_new(ctx);
+        /* Send initial <presence/> so that we appear online to contacts */
-	xmpp_stanza_set_name(pres, "presence");
+        pres = xmpp_presence_new(ctx);
-	xmpp_send(conn, pres);
+        xmpp_send(conn, pres);
-	xmpp_stanza_release(pres);
+        xmpp_stanza_release(pres);
-    }
+    } else {
-    else {
+        fprintf(stderr, "DEBUG: disconnected\n");
-	fprintf(stderr, "DEBUG: disconnected\n");
+        xmpp_stop(ctx);
-	xmpp_stop(ctx);
     }
 }
 
@@ -140,23 +155,31 @@ int main(int argc, char **argv)
 
     /* take a jid and password on the command line */
     if (argc != 3) {
-	fprintf(stderr, "Usage: bot <jid> <pass>\n\n");
+        fprintf(stderr, "Usage: bot <jid> <pass>\n\n");
-	return 1;
+        return 1;
     }
-    
+
     jid = argv[1];
     pass = argv[2];
 
     /* init library */
     xmpp_initialize();
 
+    /* pass NULL instead to silence output */
+    log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG);
     /* create a context */
-    log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG); /* pass NULL instead to silence output */
     ctx = xmpp_ctx_new(NULL, log);
 
     /* create a connection */
     conn = xmpp_conn_new(ctx);
 
+    /*
+     * also you can disable TLS support or force legacy SSL
+     * connection without STARTTLS
+     *
+     * see xmpp_conn_set_flags() or examples/basic.c
+     */
+
     /* setup authentication information */
     xmpp_conn_set_jid(conn, jid);
     xmpp_conn_set_pass(conn, pass);
@@ -164,7 +187,7 @@ int main(int argc, char **argv)
     /* initiate connection */
     xmpp_connect_client(conn, NULL, 0, conn_handler, ctx);
 
-    /* enter the event loop - 
+    /* enter the event loop -
        our connect handler will trigger an exit */
     xmpp_run(ctx);
 

examples/component.c

@@ -0,0 +1,100 @@
+/* component.c
+** libstrophe XMPP client library -- external component (XEP-0114) example
+**
+** 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.
+*/
+
+/* This example demonstrates simple connection to a server
+** as an external component. See XEP-0114 for more details.
+** This program requires correctly configured server to run.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <strophe.h>
+
+/* define a handler for connection events */
+void conn_handler(xmpp_conn_t *const conn,
+                  const xmpp_conn_event_t status,
+                  const int error,
+                  xmpp_stream_error_t *const stream_error,
+                  void *const userdata)
+{
+    xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
+
+    (void)error;
+    (void)stream_error;
+
+    if (status == XMPP_CONN_CONNECT) {
+        fprintf(stderr, "DEBUG: connected\n");
+        xmpp_disconnect(conn);
+    } else {
+        fprintf(stderr, "DEBUG: disconnected\n");
+        xmpp_stop(ctx);
+    }
+}
+
+int main(int argc, char **argv)
+{
+    xmpp_ctx_t *ctx;
+    xmpp_conn_t *conn;
+    xmpp_log_t *log;
+    char *jid, *pass, *host, *port_err = NULL;
+    unsigned short port = 0;
+
+    /* take a jid and password on the command line */
+    if (argc < 4 || argc > 5) {
+        fprintf(stderr, "Usage: component <jid> <pass> <host> [<port>]\n\n");
+        return 1;
+    }
+
+    jid = argv[1];
+    pass = argv[2];
+    host = argv[3];
+
+    if (argc == 5) {
+        short tmp_port = (short)strtol(argv[4], &port_err, 10);
+        if (tmp_port < 0 || *port_err != '\0') {
+            fprintf(stderr, "Invalid value of <port> [%s].\n", argv[4]);
+            return 1;
+        }
+        port = (unsigned short)tmp_port;
+    }
+
+    /* init library */
+    xmpp_initialize();
+
+    /* pass NULL instead to silence output */
+    log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG);
+    /* create a context */
+    ctx = xmpp_ctx_new(NULL, log);
+
+    /* create a connection */
+    conn = xmpp_conn_new(ctx);
+
+    /* setup authentication information */
+    xmpp_conn_set_jid(conn, jid);
+    xmpp_conn_set_pass(conn, pass);
+
+    /* initiate connection */
+    xmpp_connect_component(conn, host, port, conn_handler, ctx);
+
+    /* enter the event loop -
+       our connect handler will trigger an exit */
+    xmpp_run(ctx);
+
+    /* release our connection and context */
+    xmpp_conn_release(conn);
+    xmpp_ctx_free(ctx);
+
+    /* final shutdown of the library */
+    xmpp_shutdown();
+
+    return 0;
+}

examples/register.c

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

examples/roster.c

@@ -1,15 +1,12 @@
 /* roster.c
 ** libstrophe XMPP client library -- handler example
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+** This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /* This example demonstrates basic handler functions by printing out
@@ -21,31 +18,31 @@
 
 #include <strophe.h>
 
-int handle_reply(xmpp_conn_t * const conn,
+int handle_reply(xmpp_conn_t *const conn,
-		 xmpp_stanza_t * const stanza,
+                 xmpp_stanza_t *const stanza,
-		 void * const userdata)
+                 void *const userdata)
 {
     xmpp_stanza_t *query, *item;
-    char *type, *name;
+    const char *type, *name;
+
+    (void)userdata;
 
     type = xmpp_stanza_get_type(stanza);
     if (strcmp(type, "error") == 0)
-	fprintf(stderr, "ERROR: query failed\n");
+        fprintf(stderr, "ERROR: query failed\n");
     else {
-	query = xmpp_stanza_get_child_by_name(stanza, "query");
+        query = xmpp_stanza_get_child_by_name(stanza, "query");
-	printf("Roster:\n");
+        printf("Roster:\n");
-	for (item = xmpp_stanza_get_children(query); item; 
+        for (item = xmpp_stanza_get_children(query); item;
-	     item = xmpp_stanza_get_next(item))
+             item = xmpp_stanza_get_next(item))
-	    if ((name = xmpp_stanza_get_attribute(item, "name")))
+            if ((name = xmpp_stanza_get_attribute(item, "name")))
-		printf("\t %s (%s) sub=%s\n", 
+                printf("\t %s (%s) sub=%s\n", name,
-		       name,
+                       xmpp_stanza_get_attribute(item, "jid"),
-		       xmpp_stanza_get_attribute(item, "jid"),
+                       xmpp_stanza_get_attribute(item, "subscription"));
-		       xmpp_stanza_get_attribute(item, "subscription"));
+            else
-	    else
+                printf("\t %s sub=%s\n", xmpp_stanza_get_attribute(item, "jid"),
-		printf("\t %s sub=%s\n",
+                       xmpp_stanza_get_attribute(item, "subscription"));
-		       xmpp_stanza_get_attribute(item, "jid"),
+        printf("END OF LIST\n");
-		       xmpp_stanza_get_attribute(item, "subscription"));
-	printf("END OF LIST\n");
     }
 
     /* disconnect */
@@ -54,42 +51,44 @@ int handle_reply(xmpp_conn_t * const conn,
     return 0;
 }
 
-void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status, 
+void conn_handler(xmpp_conn_t *const conn,
-		  const int error, xmpp_stream_error_t * const stream_error,
+                  const xmpp_conn_event_t status,
-		  void * const userdata)
+                  const int error,
+                  xmpp_stream_error_t *const stream_error,
+                  void *const userdata)
 {
     xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
     xmpp_stanza_t *iq, *query;
 
+    (void)error;
+    (void)stream_error;
+
     if (status == XMPP_CONN_CONNECT) {
-	fprintf(stderr, "DEBUG: connected\n");
+        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");
 
-	query = xmpp_stanza_new(ctx);
+        /* create iq stanza for request */
-	xmpp_stanza_set_name(query, "query");
+        iq = xmpp_iq_new(ctx, "get", "roster1");
-	xmpp_stanza_set_ns(query, XMPP_NS_ROSTER);
 
-	xmpp_stanza_add_child(iq, query);
+        query = xmpp_stanza_new(ctx);
+        xmpp_stanza_set_name(query, "query");
+        xmpp_stanza_set_ns(query, XMPP_NS_ROSTER);
 
-	/* we can release the stanza since it belongs to iq now */
+        xmpp_stanza_add_child(iq, query);
-	xmpp_stanza_release(query);
 
-	/* set up reply handler */
+        /* we can release the stanza since it belongs to iq now */
-	xmpp_id_handler_add(conn, handle_reply, "roster1", ctx);
+        xmpp_stanza_release(query);
 
-	/* send out the stanza */
+        /* set up reply handler */
-	xmpp_send(conn, iq);
+        xmpp_id_handler_add(conn, handle_reply, "roster1", ctx);
 
-	/* release the stanza */
+        /* send out the stanza */
-	xmpp_stanza_release(iq);
+        xmpp_send(conn, iq);
+
+        /* release the stanza */
+        xmpp_stanza_release(iq);
     } else {
-	fprintf(stderr, "DEBUG: disconnected\n");
+        fprintf(stderr, "DEBUG: disconnected\n");
-	xmpp_stop(ctx);
+        xmpp_stop(ctx);
     }
 }
 
@@ -99,8 +98,8 @@ int main(int argc, char **argv)
     xmpp_conn_t *conn;
 
     if (argc != 3) {
-	fprintf(stderr, "Usage: roster <jid> <pass>\n\n");
+        fprintf(stderr, "Usage: roster <jid> <pass>\n\n");
-	return 1;
+        return 1;
     }
 
     /* initialize lib */
@@ -112,6 +111,13 @@ int main(int argc, char **argv)
     /* create a connection */
     conn = xmpp_conn_new(ctx);
 
+    /*
+     * also you can disable TLS support or force legacy SSL
+     * connection without STARTTLS
+     *
+     * see xmpp_conn_set_flags() or examples/basic.c
+     */
+
     /* setup authentication information */
     xmpp_conn_set_jid(conn, argv[1]);
     xmpp_conn_set_pass(conn, argv[2]);

examples/uuid.c

@@ -0,0 +1,23 @@
+#include <stdio.h>
+#include <strophe.h>
+
+int main()
+{
+    xmpp_ctx_t *ctx;
+    char *uuid;
+    int rc = 0;
+
+    ctx = xmpp_ctx_new(NULL, NULL);
+
+    uuid = xmpp_uuid_gen(ctx);
+    if (uuid != NULL) {
+        printf("%s\n", uuid);
+        xmpp_free(ctx, uuid);
+    } else {
+        fprintf(stderr, "Couldn't allocate memory.\n");
+        rc = 1;
+    }
+
+    xmpp_ctx_free(ctx);
+    return rc;
+}

examples/vcard.c

@@ -0,0 +1,283 @@
+/* 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)
+{
+    (void)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

@@ -0,0 +1,80 @@
+LOCAL_PATH:= $(call my-dir)
+
+#
+# examples/basic
+#
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := basic
+LOCAL_CFLAGS :=
+LOCAL_C_INCLUDES := \
+	$(LOCAL_PATH)/..
+
+LOCAL_SRC_FILES := \
+	../examples/basic.c
+
+LOCAL_STATIC_LIBRARIES := libstrophe libexpat
+
+include $(BUILD_EXECUTABLE)
+
+#
+# libstrohe (static library)
+#
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := libstrophe
+LOCAL_CFLAGS := -DHAVE_DECL_VA_COPY
+LOCAL_C_INCLUDES := \
+	$(LOCAL_PATH)/.. \
+	$(LOCAL_PATH)/../src \
+	$(LOCAL_PATH)/../expat/lib
+
+LOCAL_SRC_FILES := \
+	../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/parser_expat.c \
+	../src/rand.c \
+	../src/resolver.c \
+	../src/sasl.c \
+	../src/scram.c \
+	../src/sha1.c \
+	../src/sha256.c \
+	../src/sha512.c \
+	../src/snprintf.c \
+	../src/sock.c \
+	../src/stanza.c \
+	../src/tls_dummy.c \
+	../src/util.c \
+	../src/uuid.c
+
+LOCAL_STATIC_LIBRARIES := libstrophe
+
+include $(BUILD_STATIC_LIBRARY)
+
+#
+# expat
+#
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := libexpat
+LOCAL_CFLAGS := -DHAVE_MEMMOVE -DXML_DEV_URANDOM
+#LOCAL_C_INCLUDES := \
+#	$(LOCAL_PATH)/expat
+
+LOCAL_SRC_FILES := \
+	../expat/lib/xmlparse.c \
+	../expat/lib/xmlrole.c \
+	../expat/lib/xmltok.c \
+	../expat/lib/xmltok_impl.c \
+	../expat/lib/xmltok_ns.c
+
+LOCAL_STATIC_LIBRARIES := libexpat
+
+include $(BUILD_STATIC_LIBRARY)

jni/Application.mk

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

libstrophe.pc.in

@@ -0,0 +1,14 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: libstrophe
+Description: A simple, lightweight C library for writing XMPP clients
+URL: http://strophe.im/libstrophe/
+Version: @VERSION@
+Requires:
+Requires.private: @PC_REQUIRES@
+Libs: -L${libdir} -lstrophe
+Libs.private: @PC_LIBS@
+Cflags: -I${includedir} @PC_CFLAGS@

rpm/README

@@ -1,31 +0,0 @@
-1. Setup
-
-yum install gcc make expat-devel libstrophe
-
-Fedora:
-
-yum install fedora-packager
-cd ~
-rpmdev-setuptree
-
-CentOS:
-
-mkdir -p ~/rpmbuild/{BUILD,RPMS,SOURCES,SPECS,SRPMS}
-
-Then make a tarball of sources:
-
-tar czf libstrophe_git.tar.gz libstrophe
-
-2. Build
-
-cp libstrophe.spec ~/rpmbuild/SPECS
-cp libstrophe_git.tar.gz ~/rpmbuild/SOURCES
-rpmbuild -bb ~/rpmbuild/SPECS/libstrophe.spec
-
-3. Install
-
-yum localinstall ~/rpmbuild/RPMS/<arch>/libstrophe-1.1<dist>.<arch>.rpm
-
-Or, if localinstall is not recognised:
-
-rpm -i ~/rpmbuild/RPMS/<arch>/libstrophe-1.1<dist>.<arch>.rpm

rpm/libstrophe.spec

@@ -1,32 +0,0 @@
-Name:		libstrophe
-Version:	1
-Release:	1%{?dist}_git
-Summary:	xmpp library in C
-
-Group:		Application/System
-License:	MIT/GPLv3
-URL:		http://strophe.im/libstrophe/
-Source0:	libstrophe_git.tar.gz
-
-BuildRequires:	expat-devel
-Requires:		expat
-
-%description
-XMPP library in C
-
-%prep
-%setup -n libstrophe
-./bootstrap.sh
-
-%build
-%configure
-make %{?_smp_mflags}
-
-%install
-make install DESTDIR=%{buildroot}
-
-%files
-%{_libdir}/libstrophe.a
-%{_includedir}/strophe.h
-
-%changelog

src/common.h

@@ -1,15 +1,12 @@
 /* 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -21,17 +18,48 @@
 
 #include <stdio.h>
 #include <stdarg.h>
-#ifndef _WIN32
-#include <stdint.h>
-#endif
-
 
 #include "strophe.h"
+#include "ostypes.h"
 #include "sock.h"
 #include "tls.h"
 #include "hash.h"
 #include "util.h"
 #include "parser.h"
+#include "rand.h"
+#include "snprintf.h"
+
+/** handlers **/
+
+typedef struct _xmpp_handlist_t xmpp_handlist_t;
+struct _xmpp_handlist_t {
+    /* common members */
+    int user_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 */
+    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;
+        };
+    } u;
+};
 
 /** run-time context **/
 
@@ -50,51 +78,42 @@ struct _xmpp_ctx_t {
     const xmpp_mem_t *mem;
     const xmpp_log_t *log;
 
+    xmpp_rand_t *rand;
     xmpp_loop_status_t loop_status;
     xmpp_connlist_t *connlist;
+    xmpp_handlist_t *timed_handlers;
+
+    unsigned long timeout;
 };
 
-
 /* convenience functions for accessing the context */
-void *xmpp_alloc(const xmpp_ctx_t * const ctx, const size_t size);
+void *xmpp_alloc(const xmpp_ctx_t *const ctx, const size_t size);
-void *xmpp_realloc(const xmpp_ctx_t * const ctx, void *p, 
+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);
-char *xmpp_strdup(const xmpp_ctx_t * const ctx, const char * const s);
 
-void xmpp_log(const xmpp_ctx_t * const ctx, 
+void xmpp_log(const xmpp_ctx_t *const ctx,
-	      const xmpp_log_level_t level,
+              const xmpp_log_level_t level,
-	      const char * const area,
+              const char *const area,
-	      const char * const fmt, 
+              const char *const fmt,
-	      va_list ap);
+              va_list ap);
 
 /* wrappers for xmpp_log at specific levels */
-void xmpp_error(const xmpp_ctx_t * const ctx,
+void xmpp_error(const xmpp_ctx_t *const ctx,
-		const char * const area,
+                const char *const area,
-		const char * const fmt,
+                const char *const fmt,
-		...);
+                ...);
-void xmpp_warn(const xmpp_ctx_t * const ctx,
+void xmpp_warn(const xmpp_ctx_t *const ctx,
-		const char * const area,
+               const char *const area,
-		const char * const fmt,
+               const char *const fmt,
-		...);
+               ...);
-void xmpp_info(const xmpp_ctx_t * const ctx,
+void xmpp_info(const xmpp_ctx_t *const ctx,
-		const char * const area,
+               const char *const area,
-		const char * const fmt,
+               const char *const fmt,
-		...);
+               ...);
-void xmpp_debug(const xmpp_ctx_t * const ctx,
+void xmpp_debug(const xmpp_ctx_t *const ctx,
-		const char * const area,
+                const char *const area,
-		const char * const fmt,
+                const char *const fmt,
-		...);
+                ...);
-
-/** jid */
-/* these return new strings that must be xmpp_free()'d */
-char *xmpp_jid_new(xmpp_ctx_t *ctx, const char *node,
-                                    const char *domain,
-                                    const char *resource);
-char *xmpp_jid_bare(xmpp_ctx_t *ctx, const char *jid);
-char *xmpp_jid_node(xmpp_ctx_t *ctx, const char *jid);
-char *xmpp_jid_domain(xmpp_ctx_t *ctx, const char *jid);
-char *xmpp_jid_resource(xmpp_ctx_t *ctx, const char *jid);
-
 
 /** connection **/
 
@@ -114,59 +133,53 @@ struct _xmpp_send_queue_t {
     xmpp_send_queue_t *next;
 };
 
-typedef struct _xmpp_handlist_t xmpp_handlist_t;
+#define UNUSED(x) ((void)(x))
-struct _xmpp_handlist_t {
-    /* common members */
-    int user_handler;
-    void *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 */
-    xmpp_handlist_t *next;
 
-    union {
+#define MAX_DOMAIN_LEN 256
-	/* timed handlers */
+
-	struct {
+#define SASL_MASK_PLAIN (1 << 0)
-	    unsigned long period;
+#define SASL_MASK_DIGESTMD5 (1 << 1)
-	    uint64_t last_stamp;
+#define SASL_MASK_ANONYMOUS (1 << 2)
-	};
+#define SASL_MASK_SCRAMSHA1 (1 << 3)
-	/* id handlers */
+#define SASL_MASK_SCRAMSHA256 (1 << 4)
-	struct {
+#define SASL_MASK_SCRAMSHA512 (1 << 5)
-	    char *id;
+
-	};
+#define SASL_MASK_SCRAM \
-	/* normal handlers */
+    (SASL_MASK_SCRAMSHA1 | SASL_MASK_SCRAMSHA256 | SASL_MASK_SCRAMSHA512)
-	struct {
+
-	    char *ns;
+enum {
-	    char *name;
+    XMPP_PORT_CLIENT = 5222,
-	    char *type;
+    XMPP_PORT_CLIENT_LEGACY_SSL = 5223,
-	};
+    XMPP_PORT_COMPONENT = 5347,
-    };
 };
 
-#define SASL_MASK_PLAIN 0x01
+typedef void (*xmpp_open_handler)(xmpp_conn_t *const conn);
-#define SASL_MASK_DIGESTMD5 0x02
-#define SASL_MASK_ANONYMOUS 0x04
-
-typedef void (*xmpp_open_handler)(xmpp_conn_t * const conn);
 
 struct _xmpp_conn_t {
     unsigned int ref;
     xmpp_ctx_t *ctx;
     xmpp_conn_type_t type;
+    int is_raw;
 
     xmpp_conn_state_t state;
     uint64_t timeout_stamp;
     int error;
     xmpp_stream_error_t *stream_error;
-    sock_t sock;
-    tls_t *tls;
 
+    sock_t sock;
+    int ka_timeout;  /* TCP keepalive timeout */
+    int ka_interval; /* TCP keepalive interval */
+
+    tls_t *tls;
     int tls_support;
     int tls_disabled;
-    int tls_failed; /* set when tls fails, so we don't try again */
+    int tls_mandatory;
-    int sasl_support; /* if true, field is a bitfield of supported 
+    int tls_legacy_ssl;
-			 mechanisms */ 
+    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 */
+    int auth_legacy_enabled;
     int secured; /* set when stream is secured with TLS */
 
     /* if server returns <bind/> or <session/> we must do them */
@@ -175,8 +188,6 @@ struct _xmpp_conn_t {
 
     char *lang;
     char *domain;
-    char *connectdomain;
-    char *connectport;
     char *jid;
     char *pass;
     char *bound_jid;
@@ -196,14 +207,14 @@ struct _xmpp_conn_t {
     /* timeouts */
     unsigned int connect_timeout;
 
-    /* event handlers */    
+    /* event handlers */
 
     /* stream open handler */
     xmpp_open_handler open_handler;
 
     /* user handlers only get called after authentication */
     int authenticated;
-    
+
     /* connection events handler */
     xmpp_conn_handler conn_handler;
     void *userdata;
@@ -214,12 +225,13 @@ struct _xmpp_conn_t {
     xmpp_handlist_t *handlers;
 };
 
-void conn_disconnect(xmpp_conn_t * const conn);
+void conn_disconnect(xmpp_conn_t *const conn);
-void conn_disconnect_clean(xmpp_conn_t * const conn);
+void conn_disconnect_clean(xmpp_conn_t *const conn);
-void conn_open_stream(xmpp_conn_t * const conn);
+void conn_established(xmpp_conn_t *const conn);
-void conn_prepare_reset(xmpp_conn_t * const conn, xmpp_open_handler handler);
+void conn_open_stream(xmpp_conn_t *const conn);
-void conn_parser_reset(xmpp_conn_t * const conn);
+int conn_tls_start(xmpp_conn_t *const conn);
-
+void conn_prepare_reset(xmpp_conn_t *const conn, xmpp_open_handler handler);
+void conn_parser_reset(xmpp_conn_t *const conn);
 
 typedef enum {
     XMPP_STANZA_UNKNOWN,
@@ -232,7 +244,7 @@ struct _xmpp_stanza_t {
     xmpp_ctx_t *ctx;
 
     xmpp_stanza_type_t type;
-    
+
     xmpp_stanza_t *prev;
     xmpp_stanza_t *next;
     xmpp_stanza_t *children;
@@ -244,33 +256,33 @@ struct _xmpp_stanza_t {
 };
 
 /* handler management */
-void handler_fire_stanza(xmpp_conn_t * const conn,
+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);
-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,
+void handler_add_timed(xmpp_conn_t *const conn,
-		       xmpp_timed_handler handler,
+                       xmpp_timed_handler handler,
-		       const unsigned long period,
+                       const unsigned long period,
-		       void * const userdata);
+                       void *const userdata);
-void handler_add_id(xmpp_conn_t * const conn,
+void handler_add_id(xmpp_conn_t *const conn,
-		    xmpp_handler handler,
+                    xmpp_handler handler,
-		    const char * const id,
+                    const char *const id,
-		    void * const userdata);
+                    void *const userdata);
-void handler_add(xmpp_conn_t * const conn,
+void handler_add(xmpp_conn_t *const conn,
-		 xmpp_handler handler,
+                 xmpp_handler handler,
-		 const char * const ns,
+                 const char *const ns,
-		 const char * const name,
+                 const char *const name,
-		 const char * const type,
+                 const char *const type,
-		 void * const userdata);
+                 void *const userdata);
+void handler_system_delete_all(xmpp_conn_t *conn);
 
 /* utility functions */
-void disconnect_mem_error(xmpp_conn_t * const conn);
+void disconnect_with_error(xmpp_conn_t *const conn, int error);
+void disconnect_mem_error(xmpp_conn_t *const conn);
 
 /* auth functions */
-void auth_handle_open(xmpp_conn_t * const conn);
+void auth_handle_open(xmpp_conn_t *const conn);
-
+void auth_handle_component_open(xmpp_conn_t *const conn);
-/* replacement snprintf and vsnprintf */
+void auth_handle_open_raw(xmpp_conn_t *const conn);
-int xmpp_snprintf (char *str, size_t count, const char *fmt, ...);
+void auth_handle_open_stub(xmpp_conn_t *const conn);
-int xmpp_vsnprintf (char *str, size_t count, const char *fmt, va_list arg);
 
 #endif /* __LIBSTROPHE_COMMON_H__ */

src/crypto.c

@@ -0,0 +1,509 @@
+/* crypto.c
+ * strophe XMPP client library -- public interface for digests, encodings
+ *
+ * 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.
+ */
+
+/** @file
+ *  Public interface for digests and encodings used in XEPs.
+ */
+
+/** @defgroup Digests Message digests
+ */
+
+/** @defgroup Encodings Encodings
+ */
+
+#include <assert.h>
+#include <string.h> /* memset, memcpy */
+
+#include "common.h"  /* xmpp_alloc */
+#include "ostypes.h" /* uint8_t, size_t */
+#include "sha1.h"
+#include "snprintf.h" /* xmpp_snprintf */
+#include "strophe.h"  /* xmpp_ctx_t, xmpp_free */
+
+struct _xmpp_sha1_t {
+    xmpp_ctx_t *xmpp_ctx;
+    SHA1_CTX ctx;
+    uint8_t digest[SHA1_DIGEST_SIZE];
+};
+
+static char *digest_to_string(const uint8_t *digest, char *s, size_t len)
+{
+    int i;
+
+    if (len < SHA1_DIGEST_SIZE * 2 + 1)
+        return NULL;
+
+    for (i = 0; i < SHA1_DIGEST_SIZE; ++i)
+        xmpp_snprintf(s + i * 2, 3, "%02x", digest[i]);
+
+    return s;
+}
+
+static char *digest_to_string_alloc(xmpp_ctx_t *ctx, const uint8_t *digest)
+{
+    char *s;
+    size_t slen;
+
+    slen = SHA1_DIGEST_SIZE * 2 + 1;
+    s = xmpp_alloc(ctx, slen);
+    if (s) {
+        s = digest_to_string(digest, s, slen);
+        assert(s != NULL);
+    }
+    return s;
+}
+
+/** Compute SHA1 message digest.
+ *  Returns an allocated string which represents SHA1 message digest in
+ *  hexadecimal notation. The string must be freed with xmpp_free().
+ *
+ *  @param ctx a Strophe context object
+ *  @param data buffer for digest computation
+ *  @param len size of the data buffer
+ *
+ *  @return an allocated string or NULL on allocation error
+ *
+ *  @ingroup Digests
+ */
+char *xmpp_sha1(xmpp_ctx_t *ctx, const unsigned char *data, size_t len)
+{
+    uint8_t digest[SHA1_DIGEST_SIZE];
+
+    crypto_SHA1((const uint8_t *)data, len, digest);
+    return digest_to_string_alloc(ctx, digest);
+}
+
+/** Compute SHA1 message digest.
+ *  Stores digest in user's buffer which must be at least XMPP_SHA1_DIGEST_SIZE
+ *  bytes long.
+ *
+ *  @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
+ *
+ *  @ingroup Digests
+ */
+xmpp_sha1_t *xmpp_sha1_new(xmpp_ctx_t *ctx)
+{
+    xmpp_sha1_t *sha1;
+
+    sha1 = xmpp_alloc(ctx, sizeof(*sha1));
+    if (sha1) {
+        memset(sha1, 0, sizeof(*sha1));
+        crypto_SHA1_Init(&sha1->ctx);
+        sha1->xmpp_ctx = ctx;
+    }
+    return sha1;
+}
+
+/** Destroy SHA1 object.
+ *
+ *  @param sha1 a SHA1 object
+ *
+ *  @ingroup Digests
+ */
+void xmpp_sha1_free(xmpp_sha1_t *sha1)
+{
+    xmpp_free(sha1->xmpp_ctx, sha1);
+}
+
+/** Update SHA1 context with the next portion of data.
+ *  Can be called repeatedly.
+ *
+ *  @param sha1 a SHA1 object
+ *  @param data pointer to a buffer to be hashed
+ *  @param len size of the data buffer
+ *
+ *  @ingroup Digests
+ */
+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.
+ *  Don't call xmpp_sha1_update() after this function. Retrieve resulting
+ *  message digest with xmpp_sha1_to_string() or xmpp_sha1_to_digest().
+ *
+ *  @param sha1 a SHA1 object
+ *
+ *  @ingroup Digests
+ */
+void xmpp_sha1_final(xmpp_sha1_t *sha1)
+{
+    crypto_SHA1_Final(&sha1->ctx, sha1->digest);
+}
+
+/** 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().
+ *
+ *  @param sha1 a SHA1 object
+ *  @param s output string
+ *  @param slen size reserved for the string including '\0'
+ *
+ *  @return pointer s or NULL if resulting string is bigger than slen bytes
+ *
+ *  @ingroup Digests
+ */
+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.
+ *  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().
+ *
+ *  @param sha1 a SHA1 object
+ *
+ *  @return an allocated string
+ *
+ *  @ingroup Digests
+ */
+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.
+ *
+ *  @param sha1 a SHA1 object
+ *  @param digest output buffer of XMPP_SHA1_DIGEST_SIZE bytes
+ *
+ *  @ingroup Digests
+ */
+void xmpp_sha1_to_digest(xmpp_sha1_t *sha1, unsigned char *digest)
+{
+    assert(SHA1_DIGEST_SIZE == XMPP_SHA1_DIGEST_SIZE);
+    memcpy(digest, sha1->digest, SHA1_DIGEST_SIZE);
+}
+
+/* Base64 encoding routines. Implemented according to RFC 3548. */
+
+/* map of all byte values to the base64 values, or to
+   '65' which indicates an invalid character. '=' is '64' */
+static const unsigned char _base64_invcharmap[256] = {
+    65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
+    65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
+    65, 65, 65, 65, 65, 62, 65, 65, 65, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60,
+    61, 65, 65, 65, 64, 65, 65, 65, 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10,
+    11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 65, 65, 65, 65,
+    65, 65, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
+    43, 44, 45, 46, 47, 48, 49, 50, 51, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
+    65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
+    65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
+    65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
+    65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
+    65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
+    65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
+    65, 65, 65, 65, 65, 65, 65, 65, 65};
+
+/* map of all 6-bit values to their corresponding byte
+   in the base64 alphabet. Padding char is the value '64' */
+static const char _base64_charmap[65] = {
+    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+    'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/', '='};
+
+static size_t base64_encoded_len(const size_t len)
+{
+    /* encoded steam is 4 bytes for every three, rounded up */
+    return ((len + 2) / 3) << 2;
+}
+
+static char *base64_encode(xmpp_ctx_t *ctx,
+                           const unsigned char *const buffer,
+                           const size_t len)
+{
+    size_t clen;
+    char *cbuf, *c;
+    uint32_t word, hextet;
+    size_t i;
+
+    clen = base64_encoded_len(len);
+    cbuf = xmpp_alloc(ctx, clen + 1);
+    if (cbuf != NULL) {
+        c = cbuf;
+        /* loop over data, turning every 3 bytes into 4 characters */
+        for (i = 0; i + 2 < len; i += 3) {
+            word = buffer[i] << 16 | buffer[i + 1] << 8 | buffer[i + 2];
+            hextet = (word & 0x00FC0000) >> 18;
+            *c++ = _base64_charmap[hextet];
+            hextet = (word & 0x0003F000) >> 12;
+            *c++ = _base64_charmap[hextet];
+            hextet = (word & 0x00000FC0) >> 6;
+            *c++ = _base64_charmap[hextet];
+            hextet = (word & 0x000003F);
+            *c++ = _base64_charmap[hextet];
+        }
+        /* zero, one or two bytes left */
+        switch (len - i) {
+        case 0:
+            break;
+        case 1:
+            hextet = (buffer[len - 1] & 0xFC) >> 2;
+            *c++ = _base64_charmap[hextet];
+            hextet = (buffer[len - 1] & 0x03) << 4;
+            *c++ = _base64_charmap[hextet];
+            *c++ = _base64_charmap[64]; /* pad */
+            *c++ = _base64_charmap[64]; /* pad */
+            break;
+        case 2:
+            hextet = (buffer[len - 2] & 0xFC) >> 2;
+            *c++ = _base64_charmap[hextet];
+            hextet = ((buffer[len - 2] & 0x03) << 4) |
+                     ((buffer[len - 1] & 0xF0) >> 4);
+            *c++ = _base64_charmap[hextet];
+            hextet = (buffer[len - 1] & 0x0F) << 2;
+            *c++ = _base64_charmap[hextet];
+            *c++ = _base64_charmap[64]; /* pad */
+            break;
+        }
+        /* add a terminal null */
+        *c = '\0';
+    }
+    return cbuf;
+}
+
+static size_t base64_decoded_len(const char *const buffer, const size_t len)
+{
+    size_t nudge = 0;
+    unsigned char c;
+    size_t i;
+
+    if (len < 4)
+        return 0;
+
+    /* count the padding characters for the remainder */
+    for (i = len; i > 0; --i) {
+        c = _base64_invcharmap[(unsigned char)buffer[i - 1]];
+        if (c < 64)
+            break;
+        if (c == 64)
+            ++nudge;
+        if (c > 64)
+            return 0;
+    }
+    if (nudge > 2)
+        return 0;
+
+    /* decoded steam is 3 bytes for every four */
+    return 3 * (len >> 2) - nudge;
+}
+
+static void base64_decode(xmpp_ctx_t *ctx,
+                          const char *const buffer,
+                          const size_t len,
+                          unsigned char **out,
+                          size_t *outlen)
+{
+    size_t dlen;
+    unsigned char *dbuf, *d;
+    uint32_t word, hextet = 0;
+    size_t i;
+
+    /* len must be a multiple of 4 */
+    if (len & 0x03)
+        goto _base64_error;
+
+    dlen = base64_decoded_len(buffer, len);
+    if (dlen == 0)
+        goto _base64_error;
+
+    dbuf = xmpp_alloc(ctx, dlen + 1);
+    if (dbuf != NULL) {
+        d = dbuf;
+        /* loop over each set of 4 characters, decoding 3 bytes */
+        for (i = 0; i + 3 < len; i += 4) {
+            hextet = _base64_invcharmap[(unsigned char)buffer[i]];
+            if (hextet & 0xC0)
+                break;
+            word = hextet << 18;
+            hextet = _base64_invcharmap[(unsigned char)buffer[i + 1]];
+            if (hextet & 0xC0)
+                break;
+            word |= hextet << 12;
+            hextet = _base64_invcharmap[(unsigned char)buffer[i + 2]];
+            if (hextet & 0xC0)
+                break;
+            word |= hextet << 6;
+            hextet = _base64_invcharmap[(unsigned char)buffer[i + 3]];
+            if (hextet & 0xC0)
+                break;
+            word |= hextet;
+            *d++ = (word & 0x00FF0000) >> 16;
+            *d++ = (word & 0x0000FF00) >> 8;
+            *d++ = (word & 0x000000FF);
+        }
+        if (hextet > 64)
+            goto _base64_decode_error;
+        /* handle the remainder */
+        switch (dlen % 3) {
+        case 0:
+            /* nothing to do */
+            break;
+        case 1:
+            /* redo the last quartet, checking for correctness */
+            hextet = _base64_invcharmap[(unsigned char)buffer[len - 4]];
+            if (hextet & 0xC0)
+                goto _base64_decode_error;
+            word = hextet << 2;
+            hextet = _base64_invcharmap[(unsigned char)buffer[len - 3]];
+            if (hextet & 0xC0)
+                goto _base64_decode_error;
+            word |= hextet >> 4;
+            *d++ = word & 0xFF;
+            hextet = _base64_invcharmap[(unsigned char)buffer[len - 2]];
+            if (hextet != 64)
+                goto _base64_decode_error;
+            hextet = _base64_invcharmap[(unsigned char)buffer[len - 1]];
+            if (hextet != 64)
+                goto _base64_decode_error;
+            break;
+        case 2:
+            /* redo the last quartet, checking for correctness */
+            hextet = _base64_invcharmap[(unsigned char)buffer[len - 4]];
+            if (hextet & 0xC0)
+                goto _base64_decode_error;
+            word = hextet << 10;
+            hextet = _base64_invcharmap[(unsigned char)buffer[len - 3]];
+            if (hextet & 0xC0)
+                goto _base64_decode_error;
+            word |= hextet << 4;
+            hextet = _base64_invcharmap[(unsigned char)buffer[len - 2]];
+            if (hextet & 0xC0)
+                goto _base64_decode_error;
+            word |= hextet >> 2;
+            *d++ = (word & 0xFF00) >> 8;
+            *d++ = (word & 0x00FF);
+            hextet = _base64_invcharmap[(unsigned char)buffer[len - 1]];
+            if (hextet != 64)
+                goto _base64_decode_error;
+            break;
+        }
+        *d = '\0';
+    }
+    *out = dbuf;
+    *outlen = dbuf == NULL ? 0 : dlen;
+    return;
+
+_base64_decode_error:
+    /* invalid character; abort decoding! */
+    xmpp_free(ctx, dbuf);
+_base64_error:
+    *out = NULL;
+    *outlen = 0;
+}
+
+/** Base64 encoding routine.
+ *  Returns an allocated string which must be freed with xmpp_free().
+ *
+ *  @param ctx a Strophe context
+ *  @param data buffer to encode
+ *  @param len size of the data buffer
+ *
+ *  @return an allocated null-terminated string or NULL on error
+ *
+ *  @ingroup Encodings
+ */
+char *xmpp_base64_encode(xmpp_ctx_t *ctx, const unsigned char *data, size_t len)
+{
+    return base64_encode(ctx, data, len);
+}
+
+/** 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.
+ *
+ *  @param ctx a Strophe context
+ *  @param base64 encoded buffer
+ *  @param len size of the buffer
+ *
+ *  @return an allocated null-terminated string or NULL on error
+ *
+ *  @ingroup Encodings
+ */
+char *xmpp_base64_decode_str(xmpp_ctx_t *ctx, const char *base64, size_t len)
+{
+    unsigned char *buf = NULL;
+    size_t buflen;
+
+    if (len == 0) {
+        /* handle empty string */
+        buf = xmpp_alloc(ctx, 1);
+        if (buf)
+            buf[0] = '\0';
+        buflen = 0;
+    } else {
+        base64_decode(ctx, base64, len, &buf, &buflen);
+    }
+    if (buf) {
+        if (buflen != strlen((char *)buf)) {
+            xmpp_free(ctx, buf);
+            buf = NULL;
+        }
+    }
+    return (char *)buf;
+}
+
+/** Base64 decoding routine.
+ *  Returns an allocated buffer which must be freed with xmpp_free().
+ *
+ *  @param ctx a Strophe context
+ *  @param base64 encoded buffer
+ *  @param len size of the encoded buffer
+ *  @param out allocated buffer is stored here
+ *  @param outlen size of the allocated buffer
+ *
+ *  @note on an error the `*out` will be NULL
+ *
+ *  @ingroup Encodings
+ */
+void xmpp_base64_decode_bin(xmpp_ctx_t *ctx,
+                            const char *base64,
+                            size_t len,
+                            unsigned char **out,
+                            size_t *outlen)
+{
+    base64_decode(ctx, base64, len, out, outlen);
+}

src/ctx.c

@@ -1,15 +1,12 @@
 /* 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 software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -39,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.
  */
 
@@ -50,17 +47,25 @@
 
 #include "strophe.h"
 #include "common.h"
+#include "resolver.h"
 #include "util.h"
 
+/* Workaround for systems without va_copy support. */
+#if defined(_MSC_VER) && _MSC_VER < 1800 || \
+    !defined(_MSC_VER) && !defined(HAVE_DECL_VA_COPY)
+#define va_copy(d, s) (memcpy(&d, &s, sizeof(va_list)))
+#endif
+
 /** Initialize the Strophe library.
  *  This function initializes subcomponents of the Strophe library and must
  *  be called for Strophe to operate correctly.
  *
  *  @ingroup Init
  */
- void xmpp_initialize(void)
+void xmpp_initialize(void)
 {
     sock_initialize();
+    resolver_initialize();
     tls_initialize();
 }
 
@@ -71,6 +76,7 @@
 void xmpp_shutdown(void)
 {
     tls_shutdown();
+    resolver_shutdown();
     sock_shutdown();
 }
 
@@ -89,6 +95,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
@@ -100,44 +114,42 @@ void xmpp_shutdown(void)
  */
 int xmpp_version_check(int major, int minor)
 {
-    return (major == LIBXMPP_VERSION_MAJOR) &&
+    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. 
+ * management.
  */
-static void *_malloc(const size_t size, void * const userdata)
+static void *_malloc(const size_t size, void *const userdata)
 {
+    UNUSED(userdata);
     return malloc(size);
 }
 
-static void _free(void *p, void * const userdata)
+static void _free(void *p, void *const userdata)
 {
+    UNUSED(userdata);
     free(p);
 }
 
-static void *_realloc(void *p, const size_t size, void * const userdata)
+static void *_realloc(void *p, const size_t size, void *const userdata)
 {
+    UNUSED(userdata);
     return realloc(p, size);
 }
 
 /* default memory function map */
 static xmpp_mem_t xmpp_default_mem = {
     _malloc, /* use the thinly wrapped stdlib routines by default */
-    _free,
+    _free, _realloc, NULL};
-    _realloc,
-    NULL
-};
 
 /* log levels and names */
-static const char * const _xmpp_log_level_name[4] = {"DEBUG", "INFO", "WARN", "ERROR"};
+static const char *const _xmpp_log_level_name[4] = {"DEBUG", "INFO", "WARN",
-static const xmpp_log_level_t _xmpp_default_logger_levels[] = {XMPP_LEVEL_DEBUG,
+                                                    "ERROR"};
-							       XMPP_LEVEL_INFO,
+static const xmpp_log_level_t _xmpp_default_logger_levels[] = {
-							       XMPP_LEVEL_WARN,
+    XMPP_LEVEL_DEBUG, XMPP_LEVEL_INFO, XMPP_LEVEL_WARN, XMPP_LEVEL_ERROR};
-							       XMPP_LEVEL_ERROR};
 
 /** Log a message.
  *  The default logger writes to stderr.
@@ -148,22 +160,25 @@ static const xmpp_log_level_t _xmpp_default_logger_levels[] = {XMPP_LEVEL_DEBUG,
  *  @param area the area the log message is for
  *  @param msg the log message
  */
-void xmpp_default_logger(void * const userdata,
+static void xmpp_default_logger(void *const userdata,
-			 const xmpp_log_level_t level,
+                                const xmpp_log_level_t level,
-			 const char * const area,
+                                const char *const area,
-			 const char * const msg)
+                                const char *const msg)
 {
-    xmpp_log_level_t filter_level = * (xmpp_log_level_t*)userdata;
+    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,
-	{&xmpp_default_logger, (void*)&_xmpp_default_logger_levels[XMPP_LEVEL_INFO]},
+     (void *)&_xmpp_default_logger_levels[XMPP_LEVEL_DEBUG]},
-	{&xmpp_default_logger, (void*)&_xmpp_default_logger_levels[XMPP_LEVEL_WARN]},
+    {&xmpp_default_logger,
-	{&xmpp_default_logger, (void*)&_xmpp_default_logger_levels[XMPP_LEVEL_ERROR]}
+     (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.
  *  The default logger provides a basic logging setup which writes log
@@ -179,25 +194,25 @@ static const xmpp_log_t _xmpp_default_loggers[] = {
 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_ERROR)
-    if (level < XMPP_LEVEL_DEBUG) level = XMPP_LEVEL_DEBUG;
+        level = XMPP_LEVEL_ERROR;
 
-    return (xmpp_log_t*)&_xmpp_default_loggers[level];
+    return (xmpp_log_t *)&_xmpp_default_loggers[level];
 }
 
-static xmpp_log_t xmpp_default_log = { NULL, NULL };
+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
  *
  *  @return a pointer to the allocated memory or NULL on an error
  */
-void *xmpp_alloc(const xmpp_ctx_t * const ctx, const size_t size)
+void *xmpp_alloc(const xmpp_ctx_t *const ctx, const size_t size)
 {
     return ctx->mem->alloc(size, ctx->mem->userdata);
 }
@@ -208,7 +223,7 @@ void *xmpp_alloc(const xmpp_ctx_t * const ctx, const size_t size)
  *  @param ctx a Strophe context object
  *  @param p a pointer referencing memory to be freed
  */
-void xmpp_free(const xmpp_ctx_t * const ctx, void *p)
+void xmpp_free(const xmpp_ctx_t *const ctx, void *p)
 {
     ctx->mem->free(p, ctx->mem->userdata);
 }
@@ -222,8 +237,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,
+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);
 }
@@ -232,7 +246,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
@@ -241,45 +255,50 @@ void *xmpp_realloc(const xmpp_ctx_t * const ctx, void *p,
  *  @param fmt a printf-style format string for the message
  *  @param ap variable argument list supplied for the format string
  */
-void xmpp_log(const xmpp_ctx_t * const ctx,
+void xmpp_log(const xmpp_ctx_t *const ctx,
-	      const xmpp_log_level_t level,
+              const xmpp_log_level_t level,
-	      const char * const area,
+              const char *const area,
-	      const char * const fmt,
+              const char *const fmt,
-	      va_list ap)
+              va_list ap)
 {
     int oldret, ret;
     char smbuf[1024];
     char *buf;
     va_list copy;
 
-    buf = smbuf;
     va_copy(copy, ap);
-    ret = xmpp_vsnprintf(buf, 1023, fmt, ap);
+    ret = xmpp_vsnprintf(smbuf, sizeof(smbuf), fmt, ap);
-    if (ret > 1023) {
+    if (ret >= (int)sizeof(smbuf)) {
-	buf = (char *)xmpp_alloc(ctx, ret + 1);
+        buf = (char *)xmpp_alloc(ctx, ret + 1);
-	if (!buf) {
+        if (!buf) {
-	    buf = NULL;
+            buf = NULL;
-	    xmpp_error(ctx, "log", "Failed allocating memory for log message.");
+            xmpp_error(ctx, "log", "Failed allocating memory for log message.");
             va_end(copy);
-	    return;
+            return;
-	}
+        }
-	oldret = ret;
+        oldret = ret;
-	ret = xmpp_vsnprintf(buf, ret + 1, fmt, copy);
+        ret = xmpp_vsnprintf(buf, ret + 1, fmt, copy);
-	if (ret > oldret) {
+        if (ret > oldret) {
-	    xmpp_error(ctx, "log", "Unexpected error");
+            xmpp_error(ctx, "log", "Unexpected error");
-	    return;
+            xmpp_free(ctx, buf);
-	}
+            va_end(copy);
+            return;
+        }
     } else {
-        va_end(copy);
+        buf = smbuf;
     }
+    va_end(copy);
 
     if (ctx->log->handler)
         ctx->log->handler(ctx->log->userdata, level, area, buf);
+
+    if (buf != smbuf)
+        xmpp_free(ctx, buf);
 }
 
 /** 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
@@ -287,9 +306,9 @@ void xmpp_log(const xmpp_ctx_t * const ctx,
  *  @param fmt a printf-style format string followed by a variable list of
  *      arguments to format
  */
-void xmpp_error(const xmpp_ctx_t * const ctx,
+void xmpp_error(const xmpp_ctx_t *const ctx,
-                const char * const area,
+                const char *const area,
-                const char * const fmt,
+                const char *const fmt,
                 ...)
 {
     va_list ap;
@@ -309,10 +328,10 @@ void xmpp_error(const xmpp_ctx_t * const ctx,
  *  @param fmt a printf-style format string followed by a variable list of
  *      arguments to format
  */
-void xmpp_warn(const xmpp_ctx_t * const ctx,
+void xmpp_warn(const xmpp_ctx_t *const ctx,
-                const char * const area,
+               const char *const area,
-                const char * const fmt,
+               const char *const fmt,
-                ...)
+               ...)
 {
     va_list ap;
 
@@ -331,10 +350,10 @@ void xmpp_warn(const xmpp_ctx_t * const ctx,
  *  @param fmt a printf-style format string followed by a variable list of
  *      arguments to format
  */
-void xmpp_info(const xmpp_ctx_t * const ctx,
+void xmpp_info(const xmpp_ctx_t *const ctx,
-                const char * const area,
+               const char *const area,
-                const char * const fmt,
+               const char *const fmt,
-                ...)
+               ...)
 {
     va_list ap;
 
@@ -353,9 +372,9 @@ void xmpp_info(const xmpp_ctx_t * const ctx,
  *  @param fmt a printf-style format string followed by a variable list of
  *      arguments to format
  */
-void xmpp_debug(const xmpp_ctx_t * const ctx,
+void xmpp_debug(const xmpp_ctx_t *const ctx,
-                const char * const area,
+                const char *const area,
-                const char * const fmt,
+                const char *const fmt,
                 ...)
 {
     va_list ap;
@@ -379,29 +398,36 @@ void xmpp_debug(const xmpp_ctx_t * const ctx,
  *
  *  @ingroup Context
  */
-xmpp_ctx_t *xmpp_ctx_new(const xmpp_mem_t * const mem, 
+xmpp_ctx_t *xmpp_ctx_new(const xmpp_mem_t *const mem,
-			 const xmpp_log_t * const log)
+                         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) 
+        if (mem != NULL)
-	    ctx->mem = mem;
+            ctx->mem = mem;
-	else 
+        else
-	    ctx->mem = &xmpp_default_mem;
+            ctx->mem = &xmpp_default_mem;
 
-	if (log == NULL)
+        if (log == NULL)
-	    ctx->log = &xmpp_default_log;
+            ctx->log = &xmpp_default_log;
-	else
+        else
-	    ctx->log = log;
+            ctx->log = log;
 
-	ctx->connlist = NULL;
+        ctx->connlist = NULL;
-	ctx->loop_status = XMPP_LOOP_NOTSTARTED;
+        ctx->timed_handlers = 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;
@@ -413,9 +439,21 @@ xmpp_ctx_t *xmpp_ctx_new(const xmpp_mem_t * const mem,
  *
  *  @ingroup Context
  */
-void xmpp_ctx_free(xmpp_ctx_t * const ctx)
+void xmpp_ctx_free(xmpp_ctx_t *const ctx)
 {
     /* mem and log are owned by their suppliers */
+    xmpp_rand_free(ctx, ctx->rand);
     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

@@ -1,15 +1,12 @@
 /* event.c
 ** strophe XMPP client library -- event loop and 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.
 **
-**  This software is distributed under license and may not be copied,
+** This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -17,15 +14,15 @@
  */
 
 /** @defgroup EventLoop Event loop
- *  These functions manage the Strophe event loop.  
+ *  These functions manage the Strophe event loop.
- *  
+ *
  *  Simple tools can use xmpp_run() and xmpp_stop() to manage the life
  *  cycle of the program.  A common idiom is to set up a few initial
  *  event handers, call xmpp_run(), and then respond and react to
  *  events as they come in.  At some point, one of the handlers will
  *  call xmpp_stop() to quit the event loop which leads to the program
  *  terminating.
- * 
+ *
  *  More complex programs will have their own event loops, and should
  *  ensure that xmpp_run_once() is called regularly from there.  For
  *  example, a GUI program will already include an event loop to
@@ -40,24 +37,19 @@
 #ifndef _WIN32
 #include <sys/select.h>
 #include <errno.h>
+#include <unistd.h>
+#define _sleep(x) usleep((x)*1000)
 #else
 #include <winsock2.h>
-#define ETIMEDOUT WSAETIMEDOUT
+#define _sleep(x) Sleep(x)
-#define ECONNRESET WSAECONNRESET
-#define ECONNABORTED WSAECONNABORTED
 #endif
 
-#include <strophe.h>
+#include "strophe.h"
 #include "common.h"
 #include "parser.h"
 
-#ifndef DEFAULT_TIMEOUT
+/** Max buffer size for receiving messages. */
-/** @def DEFAULT_TIMEOUT
+#define STROPE_MESSAGE_BUFFER_SIZE 4096
- *  The default timeout in milliseconds for the event loop.
- *  This is set to 1 millisecond.
- */
-#define DEFAULT_TIMEOUT 1
-#endif
 
 /** Run the event loop once.
  *  This function will run send any data that has been queued by
@@ -82,232 +74,227 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
     struct timeval tv;
     xmpp_send_queue_t *sq, *tsq;
     int towrite;
-    char buf[4096];
+    char buf[STROPE_MESSAGE_BUFFER_SIZE];
     uint64_t next;
-    long usec;
+    uint64_t usec;
     int tls_read_bytes = 0;
 
-    if (ctx->loop_status == XMPP_LOOP_QUIT) return;
+    if (ctx->loop_status == XMPP_LOOP_QUIT)
-    ctx->loop_status = XMPP_LOOP_RUNNING;
+        return;
 
     /* send queued data */
     connitem = ctx->connlist;
     while (connitem) {
-	conn = connitem->conn;
+        conn = connitem->conn;
-	if (conn->state != XMPP_STATE_CONNECTED) {
+        if (conn->state != XMPP_STATE_CONNECTED) {
-	    connitem = connitem->next;
+            connitem = connitem->next;
-	    continue;
+            continue;
-	}
+        }
 
-	/* if we're running tls, there may be some remaining data waiting to
+        /* if we're running tls, there may be some remaining data waiting to
-	 * be sent, so push that out */
+         * be sent, so push that out */
-	if (conn->tls) {
+        if (conn->tls) {
-	    ret = tls_clear_pending_write(conn->tls);
+            ret = tls_clear_pending_write(conn->tls);
 
-	    if (ret < 0 && !tls_is_recoverable(tls_error(conn->tls))) {
+            if (ret < 0 && !tls_is_recoverable(tls_error(conn->tls))) {
-		/* an error occured */
+                /* an error occurred */
-		xmpp_debug(ctx, "xmpp", "Send error occured, disconnecting.");
+                conn->error = XMPP_EIO;
-		conn->error = ECONNABORTED;
+            }
-		conn_disconnect(conn);
+        }
-	    }
-	}
 
-	/* write all data from the send queue to the socket */
+        /* write all data from the send queue to the socket */
-	sq = conn->send_queue_head;
+        sq = conn->send_queue_head;
-	while (sq) {
+        while (!conn->error && sq) {
-	    towrite = sq->len - sq->written;
+            towrite = sq->len - sq->written;
 
-	    if (conn->tls) {
+            if (conn->tls) {
-		ret = tls_write(conn->tls, &sq->data[sq->written], towrite);
+                ret = tls_write(conn->tls, &sq->data[sq->written], towrite);
+                if (ret < 0 && !tls_is_recoverable(tls_error(conn->tls)))
+                    conn->error = XMPP_EIO;
+            } else {
+                ret = sock_write(conn->sock, &sq->data[sq->written], towrite);
+                if (ret < 0 && !sock_is_recoverable(sock_error()))
+                    conn->error = XMPP_EIO;
+            }
+            if (ret > 0 && ret < towrite)
+                sq->written += ret; /* not all data could be sent now */
+            if (ret != towrite)
+                break; /* partial write or an error */
 
-		if (ret < 0 && !tls_is_recoverable(tls_error(conn->tls))) {
+            /* all data for this queue item written, delete and move on */
-		    /* an error occured */
+            xmpp_free(ctx, sq->data);
-		    conn->error = tls_error(conn->tls);
+            tsq = sq;
-		    break;
+            sq = sq->next;
-		} else if (ret < towrite) {
+            conn->send_queue_len--;
-		    /* not all data could be sent now */
+            xmpp_free(ctx, tsq);
-		    if (ret >= 0) sq->written += ret;
-		    break;
-		}
 
-	    } else {
+            /* pop the top item */
-		ret = sock_write(conn->sock, &sq->data[sq->written], towrite);
+            conn->send_queue_head = sq;
+            /* if we've sent everything update the tail */
+            if (!sq)
+                conn->send_queue_tail = NULL;
+        }
 
-		if (ret < 0 && !sock_is_recoverable(sock_error())) {
+        /* tear down connection on error */
-		    /* an error occured */
+        if (conn->error) {
-		    conn->error = sock_error();
+            /* FIXME: need to tear down send queues and random other things
-		    break;
+             * maybe this should be abstracted */
-		} else if (ret < towrite) {
+            xmpp_debug(ctx, "xmpp", "Send error occurred, disconnecting.");
-		    /* not all data could be sent now */
+            conn_disconnect(conn);
-		    if (ret >= 0) sq->written += ret;
+        }
-		    break;
-		}
-	    }
 
-	    /* all data for this queue item written, delete and move on */
+        connitem = connitem->next;
-	    xmpp_free(ctx, sq->data);
-	    tsq = sq;
-	    sq = sq->next;
-	    xmpp_free(ctx, tsq);
-
-	    /* pop the top item */
-	    conn->send_queue_head = sq;
-	    /* if we've sent everything update the tail */
-	    if (!sq) conn->send_queue_tail = NULL;
-	}
-
-	/* tear down connection on error */
-	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.");
-	    conn->error = ECONNABORTED;
-	    conn_disconnect(conn);
-	}
-	
-	connitem = connitem->next;
     }
 
     /* reset parsers if needed */
     for (connitem = ctx->connlist; connitem; connitem = connitem->next) {
-	if (connitem->conn->reset_parser)
+        if (connitem->conn->reset_parser)
-	    conn_parser_reset(connitem->conn);
+            conn_parser_reset(connitem->conn);
     }
 
-
+    /* fire any ready timed handlers, then make sure we don't wait past
-    /* fire any ready timed handlers, then
+       the time when timed handlers need to be called */
-       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;
-    tv.tv_sec = usec / 1000000;
+    tv.tv_sec = (long)(usec / 1000000);
-    tv.tv_usec = usec % 1000000;
+    tv.tv_usec = (long)(usec % 1000000);
 
-    FD_ZERO(&rfds); 
+    FD_ZERO(&rfds);
     FD_ZERO(&wfds);
 
     /* find events to watch */
     connitem = ctx->connlist;
     while (connitem) {
-	conn = connitem->conn;
+        conn = connitem->conn;
-	
-	switch (conn->state) {
-	case XMPP_STATE_CONNECTING:
-	    /* connect has been called and we're waiting for it to complete */
-	    /* connection will give us write or error events */
-	    
-	    /* make sure the timeout hasn't expired */
-	    if (time_elapsed(conn->timeout_stamp, time_stamp()) <= 
-		conn->connect_timeout)
-		FD_SET(conn->sock, &wfds);
-	    else {
-		conn->error = ETIMEDOUT;
-		xmpp_info(ctx, "xmpp", "Connection attempt timed out.");
-		conn_disconnect(conn);
-	    }
-	    break;
-	case XMPP_STATE_CONNECTED:
-	    FD_SET(conn->sock, &rfds);
-	    break;
-	case XMPP_STATE_DISCONNECTED:
-	    /* do nothing */
-	default:
-	    break;
-	}
-	
-	/* Check if there is something in the SSL buffer. */
-	if (conn->tls) {
-	    tls_read_bytes += tls_pending(conn->tls);
-	}
-	
-	if (conn->sock > max) max = conn->sock;
 
-	connitem = connitem->next;
+        switch (conn->state) {
+        case XMPP_STATE_CONNECTING:
+            /* connect has been called and we're waiting for it to complete */
+            /* connection will give us write or error events */
+
+            /* make sure the timeout hasn't expired */
+            if (time_elapsed(conn->timeout_stamp, time_stamp()) <=
+                conn->connect_timeout)
+                FD_SET(conn->sock, &wfds);
+            else {
+                xmpp_info(ctx, "xmpp", "Connection attempt timed out.");
+                conn->error = XMPP_ETIMEDOUT;
+                conn_disconnect(conn);
+            }
+            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 */
+        default:
+            break;
+        }
+
+        /* Check if there is something in the SSL buffer. */
+        if (conn->tls)
+            tls_read_bytes += tls_pending(conn->tls);
+
+        if (conn->state != XMPP_STATE_DISCONNECTED && conn->sock > max)
+            max = conn->sock;
+
+        connitem = connitem->next;
     }
 
     /* check for events */
-    ret = select(max + 1, &rfds,  &wfds, NULL, &tv);
+    if (max > 0)
+        ret = select(max + 1, &rfds, &wfds, NULL, &tv);
+    else {
+        if (timeout > 0)
+            _sleep(timeout);
+        return;
+    }
 
     /* select errored */
     if (ret < 0) {
-	if (!sock_is_recoverable(sock_error()))
+        if (!sock_is_recoverable(sock_error()))
-	    xmpp_error(ctx, "xmpp", "event watcher internal error %d", 
+            xmpp_error(ctx, "xmpp", "event watcher internal error %d",
-		       sock_error());
+                       sock_error());
-	return;
+        return;
     }
-    
+
     /* no events happened */
-    if (ret == 0 && tls_read_bytes == 0) return;
+    if (ret == 0 && tls_read_bytes == 0)
+        return;
 
     /* process events */
     connitem = ctx->connlist;
     while (connitem) {
-	conn = connitem->conn;
+        conn = connitem->conn;
 
-	switch (conn->state) {
+        switch (conn->state) {
-	case XMPP_STATE_CONNECTING:
+        case XMPP_STATE_CONNECTING:
-	    if (FD_ISSET(conn->sock, &wfds)) {
+            if (FD_ISSET(conn->sock, &wfds)) {
-		/* connection complete */
+                /* connection complete */
 
-		/* check for error */
+                /* check for error */
-		if (sock_connect_error(conn->sock) != 0) {
+                ret = sock_connect_error(conn->sock);
-		    /* connection failed */
+                if (ret != 0) {
-		    xmpp_debug(ctx, "xmpp", "connection failed");
+                    /* connection failed */
-		    conn_disconnect(conn);
+                    xmpp_debug(ctx, "xmpp", "connection failed, error %d", ret);
-		    break;
+                    conn->error = XMPP_EIO;
-		}
+                    conn_disconnect(conn);
+                    break;
+                }
 
-		conn->state = XMPP_STATE_CONNECTED;
+                conn->state = XMPP_STATE_CONNECTED;
-		xmpp_debug(ctx, "xmpp", "connection successful");
+                xmpp_debug(ctx, "xmpp", "connection successful");
+                conn_established(conn);
+            }
 
-		
+            break;
-		/* send stream init */
+        case XMPP_STATE_CONNECTED:
-		conn_open_stream(conn);
+            if (FD_ISSET(conn->sock, &rfds) ||
-	    }
+                (conn->tls && tls_pending(conn->tls))) {
+                if (conn->tls) {
+                    ret = tls_read(conn->tls, buf, STROPE_MESSAGE_BUFFER_SIZE);
+                } else {
+                    ret =
+                        sock_read(conn->sock, buf, STROPE_MESSAGE_BUFFER_SIZE);
+                }
 
-	    break;
+                if (ret > 0) {
-	case XMPP_STATE_CONNECTED:
+                    ret = parser_feed(conn->parser, buf, ret);
-	    if (FD_ISSET(conn->sock, &rfds) || (conn->tls && tls_pending(conn->tls))) {
+                    if (!ret) {
-		if (conn->tls) {
+                        xmpp_debug(ctx, "xmpp", "parse error [%s]", buf);
-		    ret = tls_read(conn->tls, buf, 4096);
+                        xmpp_send_error(conn, XMPP_SE_INVALID_XML,
-		} else {
+                                        "parse error");
-		    ret = sock_read(conn->sock, buf, 4096);
+                    }
-		}
+                } else {
+                    if (conn->tls) {
+                        if (!tls_is_recoverable(tls_error(conn->tls))) {
+                            xmpp_debug(ctx, "xmpp",
+                                       "Unrecoverable TLS error, %d.",
+                                       tls_error(conn->tls));
+                            conn->error = XMPP_EIO;
+                            conn_disconnect(conn);
+                        }
+                    } else {
+                        /* return of 0 means socket closed by server */
+                        xmpp_debug(ctx, "xmpp",
+                                   "Socket closed by remote host.");
+                        conn->error = ret == 0 ? XMPP_ERESET : XMPP_EIO;
+                        conn_disconnect(conn);
+                    }
+                }
+            }
 
-		if (ret > 0) {
+            break;
-		    ret = parser_feed(conn->parser, buf, ret);
+        case XMPP_STATE_DISCONNECTED:
-		    if (!ret) {
+            /* do nothing */
-			/* parse error, we need to shut down */
+        default:
-			/* FIXME */
+            break;
-			xmpp_debug(ctx, "xmpp", "parse error, disconnecting");
+        }
-			conn_disconnect(conn);
-		    }
-		} else {
-		    if (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);
-			}
-		    } else {
-			/* return of 0 means socket closed by server */
-			xmpp_debug(ctx, "xmpp", "Socket closed by remote host.");
-			conn->error = ECONNRESET;
-			conn_disconnect(conn);
-		    }
-		}
-	    }
 
-	    break;
+        connitem = connitem->next;
-	case XMPP_STATE_DISCONNECTED:
-	    /* do nothing */
-	default:
-	    break;
-	}
-
-	connitem = connitem->next;
     }
 
     /* fire any ready handlers */
@@ -324,13 +311,17 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
  */
 void xmpp_run(xmpp_ctx_t *ctx)
 {
-    if (ctx->loop_status != XMPP_LOOP_NOTSTARTED) return;
+    if (ctx->loop_status != XMPP_LOOP_NOTSTARTED)
+        return;
 
     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 */
+    ctx->loop_status = XMPP_LOOP_NOTSTARTED;
+
     xmpp_debug(ctx, "event", "Event loop completed.");
 }
 
@@ -347,5 +338,5 @@ void xmpp_stop(xmpp_ctx_t *ctx)
     xmpp_debug(ctx, "event", "Stopping event loop.");
 
     if (ctx->loop_status == XMPP_LOOP_RUNNING)
-	ctx->loop_status = XMPP_LOOP_QUIT;
+        ctx->loop_status = XMPP_LOOP_QUIT;
 }

src/handler.c

@@ -1,15 +1,12 @@
 /* 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -23,14 +20,31 @@
 #include <stdlib.h>
 #include <string.h>
 
-#ifndef _WIN32
-#include <stdint.h>
-#else
-#include "ostypes.h"
-#endif
-
 #include "strophe.h"
 #include "common.h"
+#include "ostypes.h"
+
+typedef int (*xmpp_void_handler)();
+
+/* 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)
+{
+    while (*head) {
+        if (*head == item) {
+            *head = item->next;
+            break;
+        }
+        head = &(*head)->next;
+    }
+}
 
 /** Fire off all stanza handlers that match.
  *  This function is called internally by the event loop whenever stanzas
@@ -39,93 +53,87 @@
  *  @param conn a Strophe connection object
  *  @param stanza a Strophe stanza object
  */
-void handler_fire_stanza(xmpp_conn_t * const conn,
+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;
-    char *id, *ns, *name, *type;
+    const char *id, *ns, *name, *type;
-    
+    int ret;
+
     /* call id handlers */
     id = xmpp_stanza_get_id(stanza);
     if (id) {
-	prev = NULL;
+        head = (xmpp_handlist_t *)hash_get(conn->id_handlers, id);
- 	item = (xmpp_handlist_t *)hash_get(conn->id_handlers, id);
+        /* enable all added handlers */
-	while (item) {
+        for (item = head; item; item = item->next)
-	    xmpp_handlist_t *next = item->next;
+            item->enabled = 1;
 
-	    if (item->user_handler && !conn->authenticated) {
+        item = head;
-		item = next;
+        while (item) {
- 		continue;
+            /* 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)) {
+            ret = ((xmpp_handler)(item->handler))(conn, stanza, item->userdata);
-		/* handler is one-shot, so delete it */
+            next = item->next;
-		if (prev)
+            if (!ret) {
-		    prev->next = next;
+                /* handler is one-shot, so delete it */
-		else {
+                head_old = head;
-		    hash_drop(conn->id_handlers, id);
+                _handler_item_remove(&head, item);
-		    hash_add(conn->id_handlers, id, next);
+                if (head != head_old) {
-		}
+                    /* replace old value */
-                xmpp_free(conn->ctx, item->id);
+                    hash_add(conn->id_handlers, id, head);
-		xmpp_free(conn->ctx, item);
+                }
-		item = NULL;
+                xmpp_free(conn->ctx, item->u.id);
-	    }
+                xmpp_free(conn->ctx, item);
-	    if (item)
+            }
-		prev = item;
+            item = next;
-	    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 */
+        /* don't fire user handlers until authentication succeeds and
-	if (!item->enabled) {
+           skip newly added handlers */
-	    prev = item;
+        if ((item->user_handler && !conn->authenticated) || !item->enabled) {
-	    item = item->next;
+            item = item->next;
-	    continue;
+            continue;
-	}
+        }
 
-	/* don't call user handlers until authentication succeeds */
+        next = item->next;
-	if (item->user_handler && !conn->authenticated) {
+        if ((!item->u.ns || (ns && strcmp(ns, item->u.ns) == 0) ||
-	    prev = item;
+             xmpp_stanza_get_child_by_ns(stanza, item->u.ns)) &&
-	    item = item->next;
+            (!item->u.name || (name && strcmp(name, item->u.name) == 0)) &&
-	    continue;
+            (!item->u.type || (type && strcmp(type, item->u.type) == 0))) {
-	}
 
-	if ((!item->ns || (ns && strcmp(ns, item->ns) == 0) ||
+            ret = ((xmpp_handler)(item->handler))(conn, stanza, item->userdata);
-	     xmpp_stanza_get_child_by_ns(stanza, item->ns)) &&
+            /* list may be changed during execution of a handler */
-	    (!item->name || (name && strcmp(name, item->name) == 0)) &&
+            next = item->next;
-	    (!item->type || (type && strcmp(type, item->type) == 0)))
+            if (!ret) {
-	    if (!((xmpp_handler)(item->handler))(conn, stanza, item->userdata)) {
+                /* handler is one-shot, so delete it */
-		/* handler is one-shot, so delete it */
+                _handler_item_remove(&conn->handlers, item);
-		if (prev)
+                if (item->u.ns)
-		    prev->next = item->next;
+                    xmpp_free(conn->ctx, item->u.ns);
-		else
+                if (item->u.name)
-		    conn->handlers = item->next;
+                    xmpp_free(conn->ctx, item->u.name);
-                if (item->ns) xmpp_free(conn->ctx, item->ns);
+                if (item->u.type)
-                if (item->name) xmpp_free(conn->ctx, item->name);
+                    xmpp_free(conn->ctx, item->u.type);
-                if (item->type) xmpp_free(conn->ctx, item->type);
+                xmpp_free(conn->ctx, item);
-		xmpp_free(conn->ctx, item);
+            }
-		item = NULL;
+        }
-	    }
+        item = next;
-	
-	if (item) {
-	    prev = item;
-	    item = item->next;
-	} else if (prev)
-	    item = prev->next;
-	else
-	    item = conn->handlers;
     }
 }
 
@@ -136,60 +144,88 @@ void handler_fire_stanza(xmpp_conn_t * const conn,
  *
  *  @return the time in milliseconds until the next handler will be ready
  */
-uint64_t handler_fire_timed(xmpp_ctx_t * const ctx)
+uint64_t handler_fire_timed(xmpp_ctx_t *const ctx)
 {
     xmpp_connlist_t *connitem;
-    xmpp_handlist_t *handitem, *temp;
+    xmpp_handlist_t *item, *next;
-    int ret, fired;
+    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) {
+        conn = connitem->conn;
-	    connitem = connitem->next;
+        if (conn->state != XMPP_STATE_CONNECTED) {
-	    continue;
+            connitem = connitem->next;
-	}
+            continue;
-	
+        }
-	/* enable all handlers that were added */
-	for (handitem = connitem->conn->timed_handlers; handitem;
-	     handitem = handitem->next)
-	    handitem->enabled = 1;
 
-	handitem = connitem->conn->timed_handlers;
+        /* enable all handlers that were added */
-	while (handitem) {
+        for (item = conn->timed_handlers; item; item = item->next)
-	    /* skip newly added handlers */
+            item->enabled = 1;
-	    if (!handitem->enabled) {
-		handitem = handitem->next;
-		continue;
-	    }
 
-	    /* only fire user handlers after authentication */
+        item = conn->timed_handlers;
-	    if (handitem->user_handler && !connitem->conn->authenticated) {
+        while (item) {
-		handitem = handitem->next;
+            /* don't fire user handlers until authentication succeeds and
-		continue;
+               skip newly added handlers */
-	    }
+            if ((item->user_handler && !conn->authenticated) ||
+                !item->enabled) {
+                item = item->next;
+                continue;
+            }
 
-	    fired = 0;
+            next = item->next;
-	    elapsed = time_elapsed(handitem->last_stamp, time_stamp());
+            timestamp = time_stamp();
-	    if (elapsed >= handitem->period) {
+            elapsed = time_elapsed(item->u.last_stamp, timestamp);
-		/* fire! */
+            if (elapsed >= item->u.period) {
-		fired = 1;
+                /* fire! */
-		handitem->last_stamp = time_stamp();
+                item->u.last_stamp = timestamp;
-		ret = ((xmpp_timed_handler)handitem->handler)(connitem->conn, handitem->userdata);
+                ret = ((xmpp_timed_handler)item->handler)(conn, item->userdata);
-	    } else if (min > (handitem->period - elapsed))
+                /* list may be changed during execution of a handler */
-		min = handitem->period - elapsed;
+                next = item->next;
-		
+                if (!ret) {
-	    temp = handitem;
+                    /* delete handler if it returned false */
-	    handitem = handitem->next;
+                    _handler_item_remove(&conn->timed_handlers, item);
+                    xmpp_free(ctx, item);
+                }
+            } else if (min > (item->u.period - elapsed))
+                min = item->u.period - elapsed;
 
-	    /* delete handler if it returned false */
+            item = next;
-	    if (fired && !ret)
+        }
-		xmpp_timed_handler_delete(connitem->conn, temp->handler);
-	}
 
-	connitem = connitem->next;
+        connitem = connitem->next;
+    }
+
+    /*
+     * Check timed handlers in context. These handlers fire periodically
+     * regardless of connections state.
+     * TODO Reduce copy-paste.
+     */
+    item = ctx->timed_handlers;
+    while (item) {
+        next = item->next;
+        timestamp = time_stamp();
+        elapsed = time_elapsed(item->u.last_stamp, timestamp);
+        if (elapsed >= item->u.period) {
+            /* fire! */
+            item->u.last_stamp = timestamp;
+            ret =
+                ((xmpp_global_timed_handler)item->handler)(ctx, 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(&ctx->timed_handlers, item);
+                xmpp_free(ctx, item);
+            }
+        } else if (min > (item->u.period - elapsed))
+            min = item->u.period - elapsed;
+
+        item = next;
     }
 
     return min;
@@ -207,49 +243,64 @@ 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)
+        if ((user_only && handitem->user_handler) || !user_only)
-	    handitem->last_stamp = time_stamp();
+            handitem->u.last_stamp = time_stamp();
-	
+
-	handitem = handitem->next;
+        handitem = handitem->next;
     }
 }
 
-static void _timed_handler_add(xmpp_conn_t * const conn,
+static void _timed_handler_add(xmpp_ctx_t *ctx,
-			       xmpp_timed_handler handler,
+                               xmpp_handlist_t **handlers_list,
-			       const unsigned long period,
+                               xmpp_void_handler handler,
-			       void * const userdata, 
+                               const unsigned long period,
-			       const int user_handler)
+                               void *const userdata,
+                               const int user_handler)
 {
-    xmpp_handlist_t *item, *tail;
+    xmpp_handlist_t *item;
 
     /* check if handler is already in the list */
-    for (item = conn->timed_handlers; item; item = item->next) {
+    for (item = *handlers_list; item; item = item->next) {
-	if (item->handler == (void *)handler)
+        if (item->handler == handler && item->userdata == userdata) {
-	    break;
+            xmpp_warn(ctx, "xmpp", "Timed handler already exists.");
+            break;
+        }
     }
-    if (item) return;
+    if (item)
+        return;
 
     /* build new item */
-    item = xmpp_alloc(conn->ctx, sizeof(xmpp_handlist_t));
+    item = xmpp_alloc(ctx, sizeof(xmpp_handlist_t));
-    if (!item) return;
+    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->period = period;
+    item->u.period = period;
-    item->last_stamp = time_stamp();
+    item->u.last_stamp = time_stamp();
 
     /* append item to list */
-    if (!conn->timed_handlers)
+    item->next = *handlers_list;
-	conn->timed_handlers = item;
+    *handlers_list = item;
-    else {
+}
-	tail = conn->timed_handlers;
+
-	while (tail->next) 
+static void _timed_handler_delete(xmpp_ctx_t *ctx,
-	    tail = tail->next;
+                                  xmpp_handlist_t **handlers_list,
-	tail->next = item;
+                                  xmpp_void_handler handler)
+{
+    xmpp_handlist_t *item;
+
+    while (*handlers_list) {
+        item = *handlers_list;
+        if (item->handler == handler) {
+            *handlers_list = item->next;
+            xmpp_free(ctx, item);
+        } else {
+            handlers_list = &item->next;
+        }
     }
 }
 
@@ -260,72 +311,57 @@ static void _timed_handler_add(xmpp_conn_t * const conn,
  *
  *  @ingroup Handlers
  */
-void xmpp_timed_handler_delete(xmpp_conn_t * const conn,
+void xmpp_timed_handler_delete(xmpp_conn_t *const conn,
-			       xmpp_timed_handler handler)
+                               xmpp_timed_handler handler)
 {
-    xmpp_handlist_t *item, *prev;
+    _timed_handler_delete(conn->ctx, &conn->timed_handlers, handler);
-
-    if (!conn->timed_handlers) return;
-
-    prev = NULL;
-    item = conn->timed_handlers;
-    while (item) {
-	if (item->handler == (void *)handler)
-	    break;
-	prev = item;
-	item = item->next;
-    }
-
-    if (item) {
-	if (prev)
-	    prev->next = item->next;
-	else
-	    conn->timed_handlers = item->next;
-	
-	xmpp_free(conn->ctx, item);
-    }
 }
 
-static void _id_handler_add(xmpp_conn_t * const conn,
+static void _id_handler_add(xmpp_conn_t *const conn,
-			 xmpp_handler handler,
+                            xmpp_handler handler,
-			 const char * const id,
+                            const char *const id,
-			 void * const userdata, int user_handler)
+                            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)
+        if (item->handler == handler && item->userdata == userdata) {
-	    break;
+            xmpp_warn(conn->ctx, "xmpp", "Id handler already exists.");
-	item = item->next;
+            break;
+        }
+        item = item->next;
     }
-    if (item) return;
+    if (item)
+        return;
 
     /* build new item */
     item = xmpp_alloc(conn->ctx, sizeof(xmpp_handlist_t));
-    if (!item) return;
+    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);
+    item->u.id = xmpp_strdup(conn->ctx, id);
-    if (!item->id) {
+    if (!item->u.id) {
-	xmpp_free(conn->ctx, item);
+        xmpp_free(conn->ctx, item);
-	return;
+        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) 
+        while (tail->next)
-	    tail = tail->next;
+            tail = tail->next;
-	tail->next = item;
+        tail->next = item;
     }
 }
 
@@ -337,98 +373,112 @@ static void _id_handler_add(xmpp_conn_t * const conn,
  *
  *  @ingroup Handlers
  */
-void xmpp_id_handler_delete(xmpp_conn_t * const conn,
+void xmpp_id_handler_delete(xmpp_conn_t *const conn,
-			    xmpp_handler handler,
+                            xmpp_handler handler,
-			    const char * const id)
+                            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;
+    if (!item)
+        return;
 
     while (item) {
-	if (item->handler == (void *)handler)
+        next = item->next;
-	    break;
 
-	prev = item;
+        if (item->handler == handler) {
-	item = item->next;
+            if (prev)
-    }
+                prev->next = next;
+            else {
+                hash_drop(conn->id_handlers, id);
+                hash_add(conn->id_handlers, id, next);
+            }
 
-    if (item) {
+            xmpp_free(conn->ctx, item->u.id);
-	if (prev)
+            xmpp_free(conn->ctx, item);
-	    prev->next = item->next;
+            item = next;
-	else {
+        } else {
-	    hash_drop(conn->id_handlers, id);
+            prev = item;
-	    hash_add(conn->id_handlers, id, item->next);
+            item = next;
-	}
+        }
-	xmpp_free(conn->ctx, item->id);
-	xmpp_free(conn->ctx, item);
     }
 }
 
 /* add a stanza handler */
-static void _handler_add(xmpp_conn_t * const conn,
+static void _handler_add(xmpp_conn_t *const conn,
-			 xmpp_handler handler,
+                         xmpp_handler handler,
-			 const char * const ns,
+                         const char *const ns,
-			 const char * const name,
+                         const char *const name,
-			 const char * const type,
+                         const char *const type,
-			 void * const userdata, int user_handler)
+                         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)
+        /* same handler function can process different stanzas and
-	    break;
+           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;
+    if (item)
+        return;
 
     /* build new item */
     item = (xmpp_handlist_t *)xmpp_alloc(conn->ctx, sizeof(xmpp_handlist_t));
-    if (!item) return;
+    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);
+        item->u.ns = xmpp_strdup(conn->ctx, ns);
-	if (!item->ns) {
+        if (!item->u.ns) {
-	    xmpp_free(conn->ctx, item);
+            xmpp_free(conn->ctx, item);
-	    return;
+            return;
-	}
+        }
     } else
-	item->ns = NULL;
+        item->u.ns = NULL;
+
     if (name) {
-	item->name = xmpp_strdup(conn->ctx, name);
+        item->u.name = xmpp_strdup(conn->ctx, name);
-	if (!item->name) {
+        if (!item->u.name) {
-	    if (item->ns) xmpp_free(conn->ctx, item->ns);
+            if (item->u.ns)
-	    xmpp_free(conn->ctx, item);
+                xmpp_free(conn->ctx, item->u.ns);
-	    return;
+            xmpp_free(conn->ctx, item);
-	}
+            return;
+        }
     } else
-	item->name = NULL;
+        item->u.name = NULL;
+
     if (type) {
-	item->type = xmpp_strdup(conn->ctx, type);
+        item->u.type = xmpp_strdup(conn->ctx, type);
-	if (!item->type) {
+        if (!item->u.type) {
-	    if (item->ns) xmpp_free(conn->ctx, item->ns);
+            if (item->u.ns)
-	    if (item->name) xmpp_free(conn->ctx, item->name);
+                xmpp_free(conn->ctx, item->u.ns);
-	    xmpp_free(conn->ctx, item);
+            if (item->u.name)
-	}
+                xmpp_free(conn->ctx, item->u.name);
+            xmpp_free(conn->ctx, item);
+        }
     } else
-	item->type = NULL;
+        item->u.type = NULL;
 
     /* append to list */
     if (!conn->handlers)
-	conn->handlers = item;
+        conn->handlers = item;
     else {
-	tail = conn->handlers;
+        tail = conn->handlers;
-	while (tail->next) 
+        while (tail->next)
-	    tail = tail->next;
+            tail = tail->next;
-	tail->next = item;
+        tail->next = item;
     }
 }
 
@@ -439,33 +489,34 @@ static void _handler_add(xmpp_conn_t * const conn,
  *
  *  @ingroup Handlers
  */
-void xmpp_handler_delete(xmpp_conn_t * const conn,
+void xmpp_handler_delete(xmpp_conn_t *const conn, xmpp_handler handler)
-			 xmpp_handler handler)
 {
     xmpp_handlist_t *prev, *item;
 
-    if (!conn->handlers) return;
+    if (!conn->handlers)
+        return;
 
     prev = NULL;
     item = conn->handlers;
     while (item) {
-	if (item->handler == (void *)handler)
+        if (item->handler == handler) {
-	    break;
+            if (prev)
-	
+                prev->next = item->next;
-	prev = item;
+            else
-	item = item->next;
+                conn->handlers = item->next;
-    }
 
-    if (item) {
+            if (item->u.ns)
-	if (prev)
+                xmpp_free(conn->ctx, item->u.ns);
-	    prev->next = item->next;
+            if (item->u.name)
-	else
+                xmpp_free(conn->ctx, item->u.name);
-	    conn->handlers = item->next;
+            if (item->u.type)
-
+                xmpp_free(conn->ctx, item->u.type);
-	if (item->ns) xmpp_free(conn->ctx, item->ns);
+            xmpp_free(conn->ctx, item);
-	if (item->name) xmpp_free(conn->ctx, item->name);
+            item = prev ? prev->next : conn->handlers;
-	if (item->type) xmpp_free(conn->ctx, item->type);
+        } else {
-	xmpp_free(conn->ctx, item);
+            prev = item;
+            item = item->next;
+        }
     }
 }
 
@@ -474,7 +525,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.
  *
@@ -485,12 +536,13 @@ void xmpp_handler_delete(xmpp_conn_t * const conn,
  *
  *  @ingroup Handlers
  */
-void xmpp_timed_handler_add(xmpp_conn_t * const conn,
+void xmpp_timed_handler_add(xmpp_conn_t *const conn,
-			    xmpp_timed_handler handler,
+                            xmpp_timed_handler handler,
-			    const unsigned long period,
+                            const unsigned long period,
-			    void * const userdata)
+                            void *const userdata)
 {
-    _timed_handler_add(conn, handler, period, userdata, 1);
+    _timed_handler_add(conn->ctx, &conn->timed_handlers, handler, period,
+                       userdata, 1);
 }
 
 /** Add a timed system handler.
@@ -502,12 +554,13 @@ void xmpp_timed_handler_add(xmpp_conn_t * const conn,
  *  @param period the time in milliseconds between firings
  *  @param userdata an opaque data pointer that will be passed to the handler
  */
-void handler_add_timed(xmpp_conn_t * const conn,
+void handler_add_timed(xmpp_conn_t *const conn,
-		       xmpp_timed_handler handler,
+                       xmpp_timed_handler handler,
-		       const unsigned long period,
+                       const unsigned long period,
-		       void * const userdata)
+                       void *const userdata)
 {
-    _timed_handler_add(conn, handler, period, userdata, 0);
+    _timed_handler_add(conn->ctx, &conn->timed_handlers, handler, period,
+                       userdata, 0);
 }
 
 /** Add an id based stanza handler.
@@ -526,10 +579,10 @@ void handler_add_timed(xmpp_conn_t * const conn,
  *
  *  @ingroup Handlers
  */
-void xmpp_id_handler_add(xmpp_conn_t * const conn,
+void xmpp_id_handler_add(xmpp_conn_t *const conn,
-			 xmpp_handler handler,
+                         xmpp_handler handler,
-			 const char * const id,
+                         const char *const id,
-			 void * const userdata)
+                         void *const userdata)
 {
     _id_handler_add(conn, handler, id, userdata, 1);
 }
@@ -543,10 +596,10 @@ void xmpp_id_handler_add(xmpp_conn_t * const conn,
  *  @param id a string with the id
  *  @param userdata an opaque data pointer that will be passed to the handler
  */
-void handler_add_id(xmpp_conn_t * const conn,
+void handler_add_id(xmpp_conn_t *const conn,
-		    xmpp_handler handler,
+                    xmpp_handler handler,
-		    const char * const id,
+                    const char *const id,
-		    void * const userdata)
+                    void *const userdata)
 {
     _id_handler_add(conn, handler, id, userdata, 0);
 }
@@ -573,12 +626,12 @@ void handler_add_id(xmpp_conn_t * const conn,
  *
  *  @ingroup Handlers
  */
-void xmpp_handler_add(xmpp_conn_t * const conn,
+void xmpp_handler_add(xmpp_conn_t *const conn,
-		      xmpp_handler handler,
+                      xmpp_handler handler,
-		      const char * const ns,
+                      const char *const ns,
-		      const char * const name,
+                      const char *const name,
-		      const char * const type,
+                      const char *const type,
-		      void * const userdata)
+                      void *const userdata)
 {
     _handler_add(conn, handler, ns, name, type, userdata, 1);
 }
@@ -594,12 +647,138 @@ void xmpp_handler_add(xmpp_conn_t * const conn,
  *  @param type a string with the 'type' attribute value to match
  *  @param userdata an opaque data pointer that will be passed to the handler
  */
-void handler_add(xmpp_conn_t * const conn,
+void handler_add(xmpp_conn_t *const conn,
-		 xmpp_handler handler,
+                 xmpp_handler handler,
-		 const char * const ns,
+                 const char *const ns,
-		 const char * const name,
+                 const char *const name,
-		 const char * const type,
+                 const char *const type,
-		 void * const userdata)
+                 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->u.ns)
+                xmpp_free(conn->ctx, item->u.ns);
+            if (item->u.name)
+                xmpp_free(conn->ctx, item->u.name);
+            if (item->u.type)
+                xmpp_free(conn->ctx, item->u.type);
+            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->u.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);
+}
+
+/** Add a global timed handler.
+ *  The handler will fire for the first time once the period has elapsed,
+ *  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.
+ *
+ *  The main difference between global and ordinary handlers:
+ *  - Ordinary handler is related to a connection, fires only when the
+ *    connection is in connected state and is removed once the connection is
+ *    destroyed.
+ *  - Global handler fires regardless of connections state and is related to
+ *    a Strophe context.
+ *
+ *  The handler is executed in context of the respective 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.
+ *
+ *  Notice, the same handler pointer may be added multiple times with different
+ *  userdata pointers. However, xmpp_global_timed_handler_delete() deletes
+ *  all occurrences.
+ *
+ *  @param ctx a Strophe context object
+ *  @param handler a function pointer to a timed handler
+ *  @param period the time in milliseconds between firings
+ *  @param userdata an opaque data pointer that will be passed to the handler
+ *
+ *  @ingroup Handlers
+ */
+void xmpp_global_timed_handler_add(xmpp_ctx_t *const ctx,
+                                   xmpp_global_timed_handler handler,
+                                   const unsigned long period,
+                                   void *const userdata)
+{
+    _timed_handler_add(ctx, &ctx->timed_handlers, handler, period, userdata, 1);
+}
+
+/** Delete a global timed handler.
+ *
+ *  @param ctx a Strophe context object
+ *  @param handler function pointer to the handler
+ *
+ *  @ingroup Handlers
+ */
+void xmpp_global_timed_handler_delete(xmpp_ctx_t *const ctx,
+                                      xmpp_global_timed_handler handler)
+{
+    _timed_handler_delete(ctx, &ctx->timed_handlers, handler);
+}

src/hash.c

@@ -1,15 +1,12 @@
 /* hash.c
 ** strophe XMPP client library -- hash table 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -47,165 +44,178 @@ struct _hash_iterator_t {
     hashentry_t *entry;
     int index;
 };
-   
+
 /** allocate and initialize a new hash table */
-hash_t *hash_new(xmpp_ctx_t * const ctx, const int size,
+hash_t *
-		 hash_free_func free)
+hash_new(xmpp_ctx_t *const ctx, const int size, hash_free_func free_func)
 {
     hash_t *result = NULL;
 
     result = xmpp_alloc(ctx, sizeof(hash_t));
     if (result != NULL) {
-	result->entries = xmpp_alloc(ctx, size * sizeof(hashentry_t *));
+        result->entries = xmpp_alloc(ctx, size * sizeof(hashentry_t *));
-	if (result->entries == NULL) {
+        if (result->entries == NULL) {
-	    xmpp_free(ctx, result);
+            xmpp_free(ctx, result);
-	    return NULL;
+            return NULL;
-	}
+        }
-	memset(result->entries, 0, size * sizeof(hashentry_t *));
+        memset(result->entries, 0, size * sizeof(hashentry_t *));
-	result->length = size;
+        result->length = size;
 
-	result->ctx = ctx;
+        result->ctx = ctx;
-	result->free = free;
+        result->free = free_func;
-	result->num_keys = 0;
+        result->num_keys = 0;
-	/* give the caller a reference */
+        /* give the caller a reference */
-	result->ref = 1;
+        result->ref = 1;
     }
-    
+
     return result;
 }
 
 /** obtain a new reference to an existing hash table */
-hash_t *hash_clone(hash_t * const table)
+hash_t *hash_clone(hash_t *const table)
 {
     table->ref++;
     return table;
 }
 
 /** release a hash table that is no longer needed */
-void hash_release(hash_t * const table)
+void hash_release(hash_t *const table)
 {
     xmpp_ctx_t *ctx = table->ctx;
     hashentry_t *entry, *next;
     int i;
-    
+
     if (table->ref > 1)
-	table->ref--;
+        table->ref--;
     else {
-	for (i = 0; i < table->length; i++) {
+        for (i = 0; i < table->length; i++) {
-	    entry = table->entries[i];
+            entry = table->entries[i];
-	    while (entry != NULL) {
+            while (entry != NULL) {
-		next = entry->next;
+                next = entry->next;
-		xmpp_free(ctx, entry->key);
+                xmpp_free(ctx, entry->key);
-		if (table->free) table->free(ctx, entry->value);
+                if (table->free)
-		xmpp_free(ctx, entry);
+                    table->free(ctx, entry->value);
-		entry = next;
+                xmpp_free(ctx, entry);
-	    }
+                entry = next;
-	}
+            }
-	xmpp_free(ctx, table->entries);
+        }
-	xmpp_free(ctx, table);
+        xmpp_free(ctx, table->entries);
+        xmpp_free(ctx, table);
     }
 }
 
 /** hash a key for our table lookup */
 static int _hash_key(hash_t *table, const char *key)
 {
-   int hash = 0;
+    unsigned hash = 0;
-   int shift = 0;
+    unsigned shift = 0;
-   const char *c = key;
+    const unsigned char *c = (const unsigned char *)key;
 
-   while (*c != '\0') {
+    while (*c != 0) {
-	/* assume 32 bit ints */
+        /* assume 32 bit ints */
-	hash ^= ((int)*c++ << shift);
+        hash ^= ((unsigned)*c++ << shift);
-	shift += 8;
+        shift += 8;
-	if (shift > 24) shift = 0;
+        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.
  *  each key can appear only once; the value of any
  *  identical key will be replaced
  */
-int hash_add(hash_t *table, const char * const key, void *data)
+int hash_add(hash_t *table, const char *const key, void *data)
 {
-   xmpp_ctx_t *ctx = table->ctx;
+    xmpp_ctx_t *ctx = table->ctx;
-   hashentry_t *entry = NULL;
+    hashentry_t *entry = NULL;
-   int index = _hash_key(table, key);
+    int table_index = _hash_key(table, key);
 
-   /* drop existing entry, if any */
+    /* find and replace existing entry, if any */
-   hash_drop(table, key);
+    entry = _hash_entry_find(table, key);
 
-   /* allocate and fill a new entry */
+    if (entry == NULL) {
-   entry = xmpp_alloc(ctx, sizeof(hashentry_t));
+        /* allocate and fill a new entry */
-   if (!entry) return -1;
+        entry = xmpp_alloc(ctx, sizeof(hashentry_t));
-   entry->key = xmpp_strdup(ctx, key);
+        if (!entry)
-   if (!entry->key) {
+            return -1;
-       xmpp_free(ctx, entry);
+        entry->key = xmpp_strdup(ctx, key);
-       return -1;
+        if (!entry->key) {
-   }
+            xmpp_free(ctx, entry);
-   entry->value = data;
+            return -1;
-   /* insert ourselves in the linked list */
+        }
-   /* TODO: this leaks duplicate keys */
+        /* insert ourselves in the linked list */
-   entry->next = table->entries[index];
+        entry->next = table->entries[table_index];
-   table->entries[index] = entry;
+        table->entries[table_index] = entry;
-   table->num_keys++;
+        table->num_keys++;
+    } else {
+        if (table->free)
+            table->free(ctx, entry->value);
+    }
 
-   return 0;
+    entry->value = data;
+
+    return 0;
 }
 
 /** look up a key in a hash table */
 void *hash_get(hash_t *table, const char *key)
 {
-   hashentry_t *entry;
+    hashentry_t *entry;
-   int index = _hash_key(table, key);
-   void *result = NULL;
 
-   /* look up the hash entry */
+    entry = _hash_entry_find(table, key);
-   entry = table->entries[index];
+    return entry == NULL ? NULL : entry->value;
-   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;
 }
 
 /** delete a key from a hash table */
 int hash_drop(hash_t *table, const char *key)
 {
-   xmpp_ctx_t *ctx = table->ctx;
+    xmpp_ctx_t *ctx = table->ctx;
-   hashentry_t *entry, *prev;
+    hashentry_t *entry, *prev;
-   int index = _hash_key(table, key);
+    int table_index = _hash_key(table, key);
 
-   /* look up the hash entry */
+    /* look up the hash entry */
-   entry = table->entries[index];
+    entry = table->entries[table_index];
-   prev = NULL;
+    prev = NULL;
-   while (entry != NULL) {
+    while (entry != NULL) {
-	/* traverse the linked list looking for the key */
+        /* traverse the linked list looking for the key */
-	if (!strcmp(key, entry->key)) {
+        if (!strcmp(key, entry->key)) {
-	  /* match, remove the entry */
+            /* match, remove the entry */
-	  xmpp_free(ctx, entry->key);
+            xmpp_free(ctx, entry->key);
-	  if (table->free) table->free(ctx, entry->value);
+            if (table->free)
-	  if (prev == NULL) {
+                table->free(ctx, entry->value);
-	    table->entries[index] = entry->next;
+            if (prev == NULL) {
-	  } else {
+                table->entries[table_index] = entry->next;
-	    prev->next = entry->next;
+            } else {
-	  }
+                prev->next = entry->next;
-	  xmpp_free(ctx, entry);
+            }
-	  table->num_keys--;
+            xmpp_free(ctx, entry);
-	  return 0;
+            table->num_keys--;
-	}
+            return 0;
-	prev = entry;
+        }
-	entry = entry->next;
+        prev = entry;
-   }
+        entry = entry->next;
-   /* no match */
+    }
-   return -1;
+    /* no match */
+    return -1;
 }
 
 int hash_num_keys(hash_t *table)
@@ -221,16 +231,15 @@ hash_iterator_t *hash_iter_new(hash_t *table)
 
     iter = xmpp_alloc(ctx, sizeof(*iter));
     if (iter != NULL) {
-	iter->ref = 1;
+        iter->ref = 1;
-	iter->table = hash_clone(table);
+        iter->table = hash_clone(table);
-	iter->entry = NULL;
+        iter->entry = NULL;
-	iter->index = -1;
+        iter->index = -1;
     }
 
     return iter;
 }
 
-
 /** release an iterator that is no longer needed */
 void hash_iter_release(hash_iterator_t *iter)
 {
@@ -238,41 +247,42 @@ 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);
+        hash_release(iter->table);
-	xmpp_free(ctx, iter);
+        xmpp_free(ctx, iter);
     }
 }
 
 /** return the next hash table key from the iterator.
     the returned key should not be freed */
-const char * hash_iter_next(hash_iterator_t *iter)
+const char *hash_iter_next(hash_iterator_t *iter)
 {
     hash_t *table = iter->table;
     hashentry_t *entry = iter->entry;
-    int i = iter->index + 1;
+    int i;
 
     /* advance until we find the next entry */
-    if (entry != NULL) entry = entry->next;
+    if (entry != NULL)
+        entry = entry->next;
     if (entry == NULL) {
-	/* we're off the end of list, search for a new entry */
+        /* we're off the end of list, search for a new entry */
-	while (i < iter->table->length) {
+        i = iter->index + 1;
-	    entry = table->entries[i];
+        while (i < iter->table->length) {
-	    if (entry != NULL) {
+            entry = table->entries[i];
-		iter->index = i;
+            if (entry != NULL) {
-		break;
+                iter->index = i;
-	    }
+                break;
-	    i++;
+            }
-	}
+            i++;
+        }
     }
 
-    if ((entry == NULL) || (i >= table->length)) {
+    if (entry == NULL) {
-	/* no more keys! */
+        /* no more keys! */
-	return NULL;
+        return NULL;
     }
 
     /* remember our current match */
     iter->entry = entry;
     return entry->key;
 }
-

src/hash.h

@@ -1,15 +1,12 @@
 /* hash.h
 ** strophe XMPP client library -- hash table interface
-** 
+**
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -21,23 +18,23 @@
 
 typedef struct _hash_t hash_t;
 
-typedef void (*hash_free_func)(const xmpp_ctx_t * const ctx, void *p);
+typedef void (*hash_free_func)(const xmpp_ctx_t *const ctx, void *p);
 
 /** allocate and initialize a new hash table */
-hash_t *hash_new(xmpp_ctx_t * const ctx, const int size,
+hash_t *
-		 hash_free_func free);
+hash_new(xmpp_ctx_t *const ctx, const int size, hash_free_func free_func);
 
 /** allocate a new reference to an existing hash table */
-hash_t *hash_clone(hash_t * const table);
+hash_t *hash_clone(hash_t *const table);
 
 /** release a hash table when no longer needed */
-void hash_release(hash_t * const table);
+void hash_release(hash_t *const table);
 
 /** add a key, value pair to a hash table.
  *  each key can appear only once; the value of any
  *  identical key will be replaced
  */
-int hash_add(hash_t *table, const char * const key, void *data);
+int hash_add(hash_t *table, const char *const key, void *data);
 
 /** look up a key in a hash table */
 void *hash_get(hash_t *table, const char *key);
@@ -59,6 +56,6 @@ void hash_iter_release(hash_iterator_t *iter);
 
 /** return the next hash table key from the iterator.
     the returned key should not be freed */
-const char * hash_iter_next(hash_iterator_t *iter);
+const char *hash_iter_next(hash_iterator_t *iter);
 
 #endif /* __LIBXMPPP_HASH_H__ */

src/jid.c

@@ -1,15 +1,12 @@
 /* jid.c
 ** strophe XMPP client library -- helper functions for parsing JIDs
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -31,15 +28,17 @@
  *  @return an allocated string with the full JID or NULL if no domain
  *      is specified
  */
-char *xmpp_jid_new(xmpp_ctx_t *ctx, const char *node,
+char *xmpp_jid_new(xmpp_ctx_t *ctx,
-				    const char *domain,
+                   const char *node,
-				    const char *resource)
+                   const char *domain,
+                   const char *resource)
 {
     char *result;
-    int len,nlen,dlen,rlen;
+    size_t len, nlen, dlen, rlen;
 
     /* jid must at least have a domain */
-    if (domain == NULL) return NULL;
+    if (domain == NULL)
+        return NULL;
 
     /* accumulate lengths */
     dlen = strlen(domain);
@@ -50,23 +49,23 @@ char *xmpp_jid_new(xmpp_ctx_t *ctx, const char *node,
     /* concat components */
     result = xmpp_alloc(ctx, len + 1);
     if (result != NULL) {
-	if (node != NULL) {
+        if (node != NULL) {
-	    memcpy(result, node, nlen - 1);
+            memcpy(result, node, nlen - 1);
-	    result[nlen-1] = '@';
+            result[nlen - 1] = '@';
-	}
+        }
         memcpy(result + nlen, domain, dlen);
-	if (resource != NULL) {
+        if (resource != NULL) {
-	    result[nlen+dlen] = '/';
+            result[nlen + dlen] = '/';
-	    memcpy(result+nlen+dlen+1, resource, rlen - 1);
+            memcpy(result + nlen + dlen + 1, resource, rlen - 1);
-	}
+        }
-	result[nlen+dlen+rlen] = '\0';
+        result[len] = '\0';
     }
 
     return result;
 }
 
 /** Create a bare JID from a JID.
- *  
+ *
  *  @param ctx the Strophe context object
  *  @param jid the JID
  *
@@ -75,22 +74,20 @@ 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, '/');
+    len = strcspn(jid, "/");
-    if (c == NULL) return xmpp_strdup(ctx, jid);
+    result = xmpp_alloc(ctx, len + 1);
-
-    result = xmpp_alloc(ctx, c-jid+1);
     if (result != NULL) {
-	memcpy(result, jid, c-jid);
+        memcpy(result, jid, len);
-	result[c-jid] = '\0';
+        result[len] = '\0';
     }
 
     return result;
 }
 
 /** Create a node string from a JID.
- *  
+ *
  *  @param ctx a Strophe context object
  *  @param jid the JID
  *
@@ -104,11 +101,11 @@ char *xmpp_jid_node(xmpp_ctx_t *ctx, const char *jid)
 
     c = strchr(jid, '@');
     if (c != NULL) {
-	result = xmpp_alloc(ctx, (c-jid) + 1);
+        result = xmpp_alloc(ctx, (c - jid) + 1);
-	if (result != NULL) {
+        if (result != NULL) {
-	    memcpy(result, jid, (c-jid));
+            memcpy(result, jid, (c - jid));
-	    result[c-jid] = '\0';
+            result[c - jid] = '\0';
-	}
+        }
     }
 
     return result;
@@ -124,25 +121,22 @@ 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) {
-	/* no node, assume domain */
+        /* no node, assume domain */
-	c = jid;
+        c = jid;
     } else {
-	/* advance past the separator */
+        /* advance past the separator */
-	c++;
+        c++;
     }
-    s = strchr(c, '/');
+    dlen = strcspn(c, "/"); /* do not include resource */
-    if (s == NULL) {
+    result = xmpp_alloc(ctx, dlen + 1);
-	/* no resource */
-	s = c + strlen(c);
-    }
-    result = xmpp_alloc(ctx, (s-c) + 1);
     if (result != NULL) {
-	memcpy(result, c, (s-c));
+        memcpy(result, c, dlen);
-	result[s-c] = '\0';
+        result[dlen] = '\0';
     }
 
     return result;
@@ -153,25 +147,13 @@ char *xmpp_jid_domain(xmpp_ctx_t *ctx, const char *jid)
  *  @param ctx a Strophe context object
  *  @param jid the JID
  *
- *  @return an allocated string with the resource or NULL if no resource 
+ *  @return an allocated string with the resource or NULL if no resource
  *      is found or an error occurs
  */
 char *xmpp_jid_resource(xmpp_ctx_t *ctx, const char *jid)
 {
-    char *result = NULL;
     const char *c;
-    int len;
 
     c = strchr(jid, '/');
-    if (c != NULL)  {
+    return c != NULL ? xmpp_strdup(ctx, c + 1) : NULL;
-	c++;
-	len = strlen(c);
-	result = xmpp_alloc(ctx, len + 1);
-	if (result != NULL) {
-	    memcpy(result, c, len);
-	    result[len] = '\0';
-	}
-    }
-
-    return result;
 }

src/md5.c

@@ -29,19 +29,21 @@
 #include "md5.h"
 
 /* little-endian word access macros */
-#define GET_32BIT_LSB_FIRST(cp) \
+#define GET_32BIT_LSB_FIRST(cp)                 \
-    (((uint32_t)(unsigned char)(cp)[0]) | \
+    (((uint32_t)(unsigned char)(cp)[0]) |       \
-     ((uint32_t)(unsigned char)(cp)[1] << 8 ) | \
+     ((uint32_t)(unsigned char)(cp)[1] << 8) |  \
      ((uint32_t)(unsigned char)(cp)[2] << 16) | \
      ((uint32_t)(unsigned char)(cp)[3] << 24))
 
-#define PUT_32BIT_LSB_FIRST(cp, value) \
+#define PUT_32BIT_LSB_FIRST(cp, value)    \
-    do { \
+    do {                                  \
-	(cp)[0] = (value) & 0xFF; \
+        (cp)[0] = (value)&0xFF;           \
-	(cp)[1] = ((value) >> 8)  & 0xFF; \
+        (cp)[1] = ((value) >> 8) & 0xFF;  \
-	(cp)[2] = ((value) >> 16) & 0xFF; \
+        (cp)[2] = ((value) >> 16) & 0xFF; \
-	(cp)[3] = ((value) >> 24) & 0xFF; \
+        (cp)[3] = ((value) >> 24) & 0xFF; \
-    } while(0)
+    } while (0)
+
+static void MD5Transform(uint32_t buf[4], const unsigned char inext[64]);
 
 /*
  * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
@@ -57,7 +59,7 @@ void MD5Init(struct MD5Context *ctx)
     ctx->bits[0] = 0;
     ctx->bits[1] = 0;
 
-	memset(ctx->in, 0, 64);
+    memset(ctx->in, 0, 64);
 }
 
 /*
@@ -72,33 +74,33 @@ void MD5Update(struct MD5Context *ctx, unsigned char const *buf, uint32_t len)
 
     t = ctx->bits[0];
     if ((ctx->bits[0] = (t + ((uint32_t)len << 3)) & 0xffffffff) < t)
-	ctx->bits[1]++;		/* Carry from low to high */
+        ctx->bits[1]++; /* Carry from low to high */
     ctx->bits[1] += len >> 29;
 
-    t = (t >> 3) & 0x3f;	/* Bytes already in shsInfo->data */
+    t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
 
     /* Handle any leading odd-sized chunks */
 
     if (t) {
-	unsigned char *p = ctx->in + t;
+        unsigned char *p = ctx->in + t;
 
-	t = 64 - t;
+        t = 64 - t;
-	if (len < t) {
+        if (len < t) {
-	    memcpy(p, buf, len);
+            memcpy(p, buf, len);
-	    return;
+            return;
-	}
+        }
-	memcpy(p, buf, t);
+        memcpy(p, buf, t);
-	MD5Transform(ctx->buf, ctx->in, ctx);
+        MD5Transform(ctx->buf, ctx->in);
-	buf += t;
+        buf += t;
-	len -= t;
+        len -= t;
     }
     /* Process data in 64-byte chunks */
 
     while (len >= 64) {
-	memcpy(ctx->in, buf, 64);
+        memcpy(ctx->in, buf, 64);
-	MD5Transform(ctx->buf, ctx->in, ctx);
+        MD5Transform(ctx->buf, ctx->in);
-	buf += 64;
+        buf += 64;
-	len -= 64;
+        len -= 64;
     }
 
     /* Handle any remaining bytes of data. */
@@ -107,7 +109,7 @@ void MD5Update(struct MD5Context *ctx, unsigned char const *buf, uint32_t len)
 }
 
 /*
- * Final wrapup - pad to 64-byte boundary with the bit pattern 
+ * Final wrapup - pad to 64-byte boundary with the bit pattern
  * 1 0* (64-bit count of bits processed, MSB-first)
  */
 void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
@@ -128,31 +130,29 @@ void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
 
     /* Pad out to 56 mod 64 */
     if (count < 8) {
-	/* Two lots of padding:  Pad the first block to 64 bytes */
+        /* Two lots of padding:  Pad the first block to 64 bytes */
-	memset(p, 0, count);
+        memset(p, 0, count);
-	MD5Transform(ctx->buf, ctx->in, ctx);
+        MD5Transform(ctx->buf, ctx->in);
 
-	/* Now fill the next block with 56 bytes */
+        /* Now fill the next block with 56 bytes */
-	memset(ctx->in, 0, 56);
+        memset(ctx->in, 0, 56);
     } else {
-	/* Pad block to 56 bytes */
+        /* Pad block to 56 bytes */
-	memset(p, 0, count - 8);
+        memset(p, 0, count - 8);
     }
 
     /* Append length in bits and transform */
     PUT_32BIT_LSB_FIRST(ctx->in + 56, ctx->bits[0]);
     PUT_32BIT_LSB_FIRST(ctx->in + 60, ctx->bits[1]);
 
-    MD5Transform(ctx->buf, ctx->in, ctx);
+    MD5Transform(ctx->buf, ctx->in);
     PUT_32BIT_LSB_FIRST(digest, ctx->buf[0]);
     PUT_32BIT_LSB_FIRST(digest + 4, ctx->buf[1]);
     PUT_32BIT_LSB_FIRST(digest + 8, ctx->buf[2]);
     PUT_32BIT_LSB_FIRST(digest + 12, ctx->buf[3]);
-    memset(ctx, 0, sizeof(*ctx));	/* In case it's sensitive */
+    memset(ctx, 0, sizeof(*ctx)); /* In case it's sensitive */
 }
 
-#ifndef ASM_MD5
-
 /* The four core functions - F1 is optimized somewhat */
 
 /* #define F1(x, y, z) (x & y | ~x & z) */
@@ -165,28 +165,27 @@ void MD5Final(unsigned char digest[16], struct MD5Context *ctx)
 /* debugging version: */
 /*
 #define MD5STEP(f, w, x, y, z, data, s) \
-	printf("MD5STEP:  w: %x x: %x y: %x z: %x data: %x s: %x\n", 	\
+        printf("MD5STEP:  w: %x x: %x y: %x z: %x data: %x s: %x\n", \
-		w, x, y, z, data, s); 	\
+                w, x, y, z, data, s); \
-	printf("f(x,y,z) = %x\n", f(x,y,z)+data); \
+        printf("f(x,y,z) = %x\n", f(x,y,z)+data); \
-	( w += f(x, y, z) + data,  printf(" - w: %x ", w), \
+        ( w += f(x, y, z) + data,  printf(" - w: %x ", w), \
-	w = w<<s | w>>(32-s),  printf(" - w: %x\n", w), w += x )
+        w = w<<s | w>>(32-s),  printf(" - w: %x\n", w), w += x )
 */
 #define MD5STEP(f, w, x, y, z, data, s) \
-	( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
+    (w += f(x, y, z) + data, w = w << s | w >> (32 - s), w += x)
 
 /*
  * The core of the MD5 algorithm, this alters an existing MD5 hash to
  * reflect the addition of 16 longwords of new data.  MD5Update blocks
  * the data and converts bytes into longwords for this routine.
  */
-void MD5Transform(uint32_t buf[4], const unsigned char inext[64],
+static void MD5Transform(uint32_t buf[4], const unsigned char inext[64])
-	struct MD5Context *ctx)
 {
     register uint32_t a, b, c, d, i;
     uint32_t in[16];
-    
+
     for (i = 0; i < 16; i++)
-      in[i] = GET_32BIT_LSB_FIRST(inext + 4 * i);
+        in[i] = GET_32BIT_LSB_FIRST(inext + 4 * i);
 
     a = buf[0];
     b = buf[1];
@@ -267,23 +266,3 @@ void MD5Transform(uint32_t buf[4], const unsigned char inext[64],
     buf[2] += c;
     buf[3] += d;
 }
-
-#ifdef DEBUG_MD5
-
-#include <stdio.h>
-
-void MD5DumpBytes(unsigned char *b, int len)
-{
-	int i;
-	for (i=0; i<len; i++) {
-		if (i%32==0 && i!=0) {
-			printf("\n");
-		}
-		printf("%02x", b[i]&0xff);
-	}
-	printf("\n");
-}
-
-#endif /* DEBUG_MD5 */
-
-#endif /* !MD5_ASM */

src/md5.h

@@ -11,31 +11,19 @@
 #ifndef MD5_H
 #define MD5_H
 
-/* we use the uint32_t type from stdint.h
- * if it is not available, add a typedef here:
- */
 /* make sure the stdint.h types are available */
-#if defined(_MSC_VER) /* Microsoft Visual C++ */
+#include "ostypes.h"
-  typedef unsigned int              uint32_t;
-#else
-#include <stdint.h>
-#endif
 
 struct MD5Context {
-	uint32_t buf[4];
+    uint32_t buf[4];
-	uint32_t bits[2];
+    uint32_t bits[2];
-	unsigned char in[64];
+    unsigned char in[64];
 };
 
 void MD5Init(struct MD5Context *context);
-void MD5Update(struct MD5Context *context, unsigned char const *buf,
+void MD5Update(struct MD5Context *context,
-	       uint32_t len);
+               unsigned char const *buf,
+               uint32_t len);
 void MD5Final(unsigned char digest[16], struct MD5Context *context);
-void MD5Transform(uint32_t buf[4], const unsigned char in[64],
-			struct MD5Context *ctx);
-
-#ifdef DEBUG_MD5
-void MD5DumpBytes(unsigned char *b, int len);
-#endif
 
 #endif /* !MD5_H */

src/oocontext.cpp

@@ -1,88 +0,0 @@
-/* oocontext.cpp
-** strophe XMPP client library -- C++ context implementation
-** 
-** Copyright (C) 2005-2009 Collecta, Inc. 
-**
-**  This software is provided AS-IS with no warranty, either express
-**  or implied.
-**
-**  This software is distributed under license and may not be copied,
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
-*/
-
-#include <stdlib.h>
-
-#include "strophe.h"
-#include "strophepp.h"
-
-XMPP::Context::Context() 
-{
-    m_mem.alloc = callAlloc;
-    m_mem.realloc = callRealloc;
-    m_mem.free = callFree;
-    m_mem.userdata = (void *)this;
-
-    m_log.handler = callLog;
-    m_log.userdata = (void *)this;
-
-    m_ctx = ::xmpp_ctx_new(&m_mem, &m_log);
-}
-
-XMPP::Context::~Context()
-{
-    ::xmpp_ctx_free(m_ctx);
-}
-
-void *XMPP::Context::alloc(const size_t size)
-{
-    return ::malloc(size);
-}
-
-void *XMPP::Context::realloc(void *p, const size_t size)
-{
-    return ::realloc(p, size);
-}
-
-void XMPP::Context::free(void *p)
-{
-    ::free(p);
-}
-
-void XMPP::Context::log(const xmpp_log_level_t level,
-			const char * const area,
-			const char * const msg)
-{
-    /* do nothing by default */
-}
-
-xmpp_ctx_t *XMPP::Context::getContext()
-{
-    return m_ctx;
-}
-
-void *XMPP::Context::callAlloc(const size_t size, void * const userdata)
-{
-    return reinterpret_cast<Context *>(userdata)->alloc(size);
-}
-
-void *XMPP::Context::callRealloc(void *p, const size_t size,
-				 void * const userdata)
-{
-    return reinterpret_cast<Context *>(userdata)->realloc(p, size);
-}
-
-void XMPP::Context::callFree(void *p, void * const userdata)
-{
-    reinterpret_cast<Context *>(userdata)->free(p);
-}
-
-void XMPP::Context::callLog(void * const userdata,
-			    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,82 +0,0 @@
-/* oostanza.cpp
-** strophe XMPP client library -- C++ context implementation
-** 
-** Copyright (C) 2005-2009 Collecta, Inc. 
-**
-**  This software is provided AS-IS with no warranty, either express
-**  or implied.
-**
-**  This software is distributed under license and may not be copied,
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
-*/
-
-#include "strophe.h"
-#include "strophepp.h"
-
-using namespace XMPP;
-
-void *Stanza::operator new(size_t size, Context *ctx)
-{
-    void *p;
-
-    /* we must allocate extra room for the Context object so that the
-    destructor can access it to free the object.  C++ does not allow
-    us to access normal members in the destructor, so we have to hide
-    it.  This must be prepended as well, since C++ will add stuff to
-    the end in subclasses. */
-
-    p = ctx->alloc(size + sizeof(Context *));
-    if (!p) return p;
-
-    *reinterpret_cast<Context **>(p) = ctx;
-    p = reinterpret_cast<void *>(reinterpret_cast<char *>(p) + 
-				 sizeof(Context *));
-
-    return p;
-}
-
-void Stanza::operator delete(void *p)
-{
-    Context *ctx;
-
-    ctx = *reinterpret_cast<Context **>(reinterpret_cast<char *>(p) - 4);
-    ctx->free(reinterpret_cast<char *>(p) - 4);
-}
-
-Stanza::Stanza(Context *ctx)
-{
-    m_ctx = ctx;
-    m_stanza = ::xmpp_stanza_new(ctx->getContext());
-    // TODO: check for errors
-}
-
-Stanza::~Stanza()
-{
-}
-
-Stanza *Stanza::create(Context *ctx)
-{
-    return new (ctx) Stanza(ctx);
-}
-
-void Stanza::release()
-{
-    if (::xmpp_stanza_release(m_stanza))
-	delete this;
-}
-
-Stanza *Stanza::clone()
-{
-    ::xmpp_stanza_clone(m_stanza);
-    return this;
-}
-
-Stanza *Stanza::copy()
-{
-    // TODO
-    return NULL;
-}
-
-

src/ostypes.h

@@ -1,16 +1,13 @@
 /* ostypes.h
-** strophe XMPP client library -- type definitions for platforms 
+** strophe XMPP client library -- type definitions for platforms
 **     without stdint.h
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -20,8 +17,31 @@
 #ifndef __LIBSTROPHE_OSTYPES_H__
 #define __LIBSTROPHE_OSTYPES_H__
 
-#ifdef _WIN32
+#include <stddef.h> /* size_t */
-typedef unsigned __int64 uint64_t; 
+
+#if defined(_MSC_VER) && _MSC_VER < 1600
+typedef signed char int8_t;
+typedef short int int16_t;
+typedef int int32_t;
+typedef __int64 int64_t;
+
+typedef unsigned char uint8_t;
+typedef unsigned short int uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned __int64 uint64_t;
+
+#ifndef UINT16_MAX
+#define UINT16_MAX ((uint16_t)0xffff)
+#endif /* UINT16_MAX */
+#ifndef UINT32_MAX
+#define UINT32_MAX ((uint32_t)0xffffffff)
+#endif /* UINT32_MAX */
+#ifndef SIZE_MAX
+#define SIZE_MAX UINT32_MAX
+#endif /* SIZE_MAX */
+
+#else
+#include <stdint.h>
 #endif
 
 #endif /* __LIBSTROPHE_OSTYPES_H__ */

src/parser.h

@@ -1,15 +1,12 @@
 /* parser.h
 ** strophe XMPP client library -- parser structures and functions
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -25,18 +22,18 @@ typedef struct _parser_t parser_t;
 
 typedef void (*parser_start_callback)(char *name,
                                       char **attrs,
-                                      void * const userdata);
+                                      void *const userdata);
-typedef void (*parser_end_callback)(char *name, void * const userdata);
+typedef void (*parser_end_callback)(char *name, void *const userdata);
 typedef void (*parser_stanza_callback)(xmpp_stanza_t *stanza,
-                                       void * const userdata);
+                                       void *const userdata);
 
-
+parser_t *parser_new(xmpp_ctx_t *ctx,
-parser_t *parser_new(xmpp_ctx_t *ctx, 
                      parser_start_callback startcb,
                      parser_end_callback endcb,
                      parser_stanza_callback stanzacb,
                      void *userdata);
-void parser_free(parser_t * const parser);
+void parser_free(parser_t *parser);
+char *parser_attr_name(xmpp_ctx_t *ctx, char *nsname);
 int parser_reset(parser_t *parser);
 int parser_feed(parser_t *parser, char *chunk, int len);
 

src/parser_expat.c

@@ -1,15 +1,12 @@
 /* parser.c
 ** strophe XMPP client library -- xml parser handlers and utility functions
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -22,10 +19,16 @@
 
 #include <expat.h>
 
-#include <strophe.h>
+#include "strophe.h"
 #include "common.h"
 #include "parser.h"
 
+/* 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,65 +38,174 @@ 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;
 };
 
+/* Use the Unit Separator to delimit namespace and name in our XML */
+const XML_Char namespace_sep = '\x1F';
+
+/*
+ * Cached strophe ctx. It is used for memory suite.
+ * Note, expat doesn't support userdata in memory suite, therefore,
+ * we can support only one strophe context. If user creates more than one
+ * context, this module will fallback to default library allocator for all
+ * contexts other than mem_ctx.
+ */
+static xmpp_ctx_t *mem_ctx = NULL;
+
+static void *parser_mem_malloc(size_t size)
+{
+    if (mem_ctx != NULL)
+        return xmpp_alloc(mem_ctx, size);
+    else
+        return NULL;
+}
+
+static void *parser_mem_realloc(void *ptr, size_t size)
+{
+    if (mem_ctx != NULL)
+        return xmpp_realloc(mem_ctx, ptr, size);
+    else
+        return NULL;
+}
+
+static void parser_mem_free(void *ptr)
+{
+    if (mem_ctx != NULL)
+        xmpp_free(mem_ctx, ptr);
+}
+
+static const XML_Memory_Handling_Suite parser_mem_suite = {
+    .malloc_fcn = &parser_mem_malloc,
+    .realloc_fcn = &parser_mem_realloc,
+    .free_fcn = &parser_mem_free,
+};
+
+/* return allocated string with the name from a delimited
+ * namespace/name string */
+static char *_xml_name(xmpp_ctx_t *ctx, const char *nsname)
+{
+    char *result = NULL;
+    const char *c;
+    size_t len;
+
+    c = strchr(nsname, namespace_sep);
+    if (c == NULL)
+        return xmpp_strdup(ctx, nsname);
+
+    c++;
+    len = strlen(c);
+    result = xmpp_alloc(ctx, len + 1);
+    if (result != NULL) {
+        memcpy(result, c, len);
+        result[len] = '\0';
+    }
+
+    return result;
+}
+
+/* return allocated string with the namespace from a delimited string */
+static char *_xml_namespace(xmpp_ctx_t *ctx, const char *nsname)
+{
+    char *result = NULL;
+    const char *c;
+
+    c = strchr(nsname, namespace_sep);
+    if (c != NULL) {
+        result = xmpp_alloc(ctx, (c - nsname) + 1);
+        if (result != NULL) {
+            memcpy(result, nsname, (c - nsname));
+            result[c - nsname] = '\0';
+        }
+    }
+
+    return result;
+}
+
 static void _set_attributes(xmpp_stanza_t *stanza, const XML_Char **attrs)
 {
+    char *attr;
     int i;
 
-    if (!attrs) return;
+    if (!attrs)
+        return;
 
     for (i = 0; attrs[i]; i += 2) {
-        xmpp_stanza_set_attribute(stanza, attrs[i], attrs[i+1]);
+        /* namespaced attributes aren't used in xmpp, discard namespace */
+        attr = _xml_name(stanza->ctx, attrs[i]);
+        xmpp_stanza_set_attribute(stanza, attr, attrs[i + 1]);
+        xmpp_free(stanza->ctx, attr);
     }
 }
 
-static void _start_element(void *userdata,
+static void complete_inner_text(parser_t *parser)
-                           const XML_Char *name,
+{
-                           const XML_Char **attrs)
+    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)
 {
     parser_t *parser = (parser_t *)userdata;
     xmpp_stanza_t *child;
+    char *ns, *name;
+
+    ns = _xml_namespace(parser->ctx, nsname);
+    name = _xml_name(parser->ctx, nsname);
 
     if (parser->depth == 0) {
         /* notify the owner */
         if (parser->startcb)
-            parser->startcb((char *)name, (char **)attrs, 
+            parser->startcb(name, (char **)attrs, parser->userdata);
-                            parser->userdata);
     } else {
-	/* build stanzas at depth 1 */
+        /* build stanzas at depth 1 */
-	if (!parser->stanza && parser->depth != 1) {
+        if (!parser->stanza && parser->depth != 1) {
-	    /* something terrible happened */
+            /* something terrible happened */
-	    /* FIXME: shutdown disconnect */
+            /* FIXME: shutdown disconnect */
-	    xmpp_error(parser->ctx, "parser", "oops, where did our stanza go?");
+            xmpp_error(parser->ctx, "parser", "oops, where did our stanza go?");
-	} else if (!parser->stanza) {
+        } else {
-	    /* starting a new toplevel stanza */
+            child = xmpp_stanza_new(parser->ctx);
-	    parser->stanza = xmpp_stanza_new(parser->ctx);
+            if (!child) {
-	    if (!parser->stanza) {
+                /* FIXME: can't allocate, disconnect */
-		/* FIXME: can't allocate, disconnect */
+            }
-	    }
+            xmpp_stanza_set_name(child, name);
-	    xmpp_stanza_set_name(parser->stanza, name);
+            _set_attributes(child, attrs);
-	    _set_attributes(parser->stanza, attrs);
+            if (ns)
-	} else {
+                xmpp_stanza_set_ns(child, ns);
-	    /* starting a child of parser->stanza */
-	    child = xmpp_stanza_new(parser->ctx);
-	    if (!child) {
-		/* FIXME: can't allocate, disconnect */
-	    }
-	    xmpp_stanza_set_name(child, name);
-	    _set_attributes(child, attrs);
 
-	    /* add child to parent */
+            if (parser->stanza != NULL) {
-	    xmpp_stanza_add_child(parser->stanza, child);
+                complete_inner_text(parser);
-	    
+                xmpp_stanza_add_child(parser->stanza, child);
-	    /* the child is owned by the toplevel stanza now */
+                xmpp_stanza_release(child);
-	    xmpp_stanza_release(child);
+            }
-
+            parser->stanza = child;
-	    /* make child the current stanza */
+        }
-	    parser->stanza = child;
-	}
     }
 
+    if (ns)
+        xmpp_free(parser->ctx, ns);
+    if (name)
+        xmpp_free(parser->ctx, name);
+
     parser->depth++;
 }
 
@@ -108,36 +220,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) {
+        complete_inner_text(parser);
-	    /* we're finishing a child stanza, so set current to the parent */
+        if (parser->stanza->parent) {
-	    parser->stanza = parser->stanza->parent;
+            /* we're finishing a child stanza, so set current to the parent */
-	} else {
+            parser->stanza = parser->stanza->parent;
+        } else {
             if (parser->stanzacb)
-                parser->stanzacb(parser->stanza,
+                parser->stanzacb(parser->stanza, parser->userdata);
-                                 parser->userdata);
+            xmpp_stanza_release(parser->stanza);
-	    xmpp_stanza_release(parser->stanza);
+            parser->stanza = NULL;
-	    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;
+    if (parser->depth < 2)
+        return;
 
-    /* create and populate stanza */
+    /* Join all parts to a single resulting string. Stanza is created in
-    stanza = xmpp_stanza_new(parser->ctx);
+     * _start_element() and _end_element(). */
-    if (!stanza) {
+    if (parser->inner_text_used + len >= parser->inner_text_size) {
-	/* FIXME: allocation error, disconnect */
+        parser->inner_text_size =
-	return;
+            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);
+    parser->inner_text_used += len;
-
+    strncat(parser->inner_text, s, len);
-    xmpp_stanza_add_child(parser->stanza, stanza);
-    xmpp_stanza_release(stanza);
 }
 
 parser_t *parser_new(xmpp_ctx_t *ctx,
@@ -158,6 +280,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);
     }
@@ -165,29 +290,59 @@ parser_t *parser_new(xmpp_ctx_t *ctx,
     return parser;
 }
 
+char *parser_attr_name(xmpp_ctx_t *ctx, char *nsname)
+{
+    return _xml_name(ctx, nsname);
+}
+
 /* free a parser */
 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);
 }
 
 /* shuts down and restarts XML parser.  true on success */
 int parser_reset(parser_t *parser)
 {
-    if (parser->expat)
+    XML_Bool ret;
-	XML_ParserFree(parser->expat);
+    const XML_Memory_Handling_Suite *mem = NULL;
 
-    if (parser->stanza) 
+    if (parser->expat) {
-	xmpp_stanza_release(parser->stanza);
+        ret = XML_ParserReset(parser->expat, NULL);
+        if (ret != XML_TRUE) {
+            XML_ParserFree(parser->expat);
+            parser->expat = NULL;
+        }
+    } else {
+        if (mem_ctx == NULL)
+            mem_ctx = parser->ctx;
+        if (parser->ctx == mem_ctx)
+            mem = &parser_mem_suite;
+        parser->expat = XML_ParserCreate_MM(NULL, mem, &namespace_sep);
+    }
 
-    parser->expat = XML_ParserCreate(NULL);
+    if (parser->stanza) {
-    if (!parser->expat) return 0;
+        xmpp_stanza_release(parser->stanza);
+        parser->stanza = NULL;
+    }
+
+    if (parser->inner_text) {
+        xmpp_free(parser->ctx, parser->inner_text);
+        parser->inner_text = NULL;
+    }
+
+    if (!parser->expat)
+        return 0;
 
     parser->depth = 0;
-    parser->stanza = NULL;
 
     XML_SetUserData(parser->expat, parser);
     XML_SetElementHandler(parser->expat, _start_element, _end_element);

src/parser_libxml2.c

@@ -1,15 +1,12 @@
 /* parser.c
 ** strophe XMPP client library -- xml parser handlers and utility functions
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -23,7 +20,7 @@
 #include <libxml/parser.h>
 #include <libxml/tree.h>
 
-#include <strophe.h>
+#include "strophe.h"
 #include "common.h"
 #include "parser.h"
 
@@ -39,69 +36,156 @@ struct _parser_t {
     xmpp_stanza_t *stanza;
 };
 
-static void _set_attributes(xmpp_stanza_t *stanza, const xmlChar **attrs)
+static void
+_set_attributes(xmpp_stanza_t *stanza, int nattrs, const xmlChar **attrs)
 {
-    int i;
+    int i, len;
+    char *value;
 
-    if (!attrs) return;
+    if (!attrs)
+        return;
 
-    for (i = 0; attrs[i]; i += 2) {
+    /* SAX2 uses array of localname/prefix/uri/value_begin/value_end */
-        xmpp_stanza_set_attribute(stanza, (const char *)attrs[i], (const char *)attrs[i+1]);
+    for (i = 0; i < nattrs * 5; i += 5) {
+        len = attrs[i + 4] - attrs[i + 3];
+        value = xmpp_alloc(stanza->ctx, len + 1);
+        if (value) {
+            memcpy(value, attrs[i + 3], len);
+            value[len] = '\0';
+            xmpp_stanza_set_attribute(stanza, (const char *)attrs[i], value);
+            xmpp_free(stanza->ctx, value);
+        }
     }
 }
 
-static void _start_element(void *userdata, 
+/* SAX2 gives us the attrs in an incredibly inconvenient array,
-                           const xmlChar *name, const xmlChar **attrs)
+ * convert it to what the start callback is expecting */
+static char **
+_convert_attrs(parser_t *parser, int nattrs, const xmlChar **attrs)
+{
+    int c, i, o, len;
+    char *value;
+    char **ret;
+
+    if (!attrs)
+        return NULL;
+
+    ret = xmpp_alloc(parser->ctx, (nattrs + 1) * 2 * sizeof(char *));
+    if (!ret)
+        return NULL;
+    memset(ret, 0, (nattrs + 1) * 2 * sizeof(char *));
+
+    for (c = 0; c < nattrs; c++) {
+        i = c * 5;
+        o = c * 2;
+
+        len = attrs[i + 4] - attrs[i + 3];
+        value = xmpp_alloc(parser->ctx, len + 1);
+        if (value) {
+            memcpy(value, attrs[i + 3], len);
+            value[len] = '\0';
+            ret[o] = xmpp_strdup(parser->ctx, (char *)attrs[i]);
+            ret[o + 1] = value;
+        }
+    }
+
+    return ret;
+}
+
+static void _free_cbattrs(parser_t *parser, char **attrs)
+{
+    int i;
+
+    if (!attrs)
+        return;
+
+    for (i = 0; attrs[i]; i += 2) {
+        if (attrs[i])
+            xmpp_free(parser->ctx, attrs[i]);
+        if (attrs[i + 1])
+            xmpp_free(parser->ctx, attrs[i + 1]);
+    }
+
+    xmpp_free(parser->ctx, attrs);
+}
+
+static void _start_element(void *userdata,
+                           const xmlChar *name,
+                           const xmlChar *prefix,
+                           const xmlChar *uri,
+                           int nnamespaces,
+                           const xmlChar **namespaces,
+                           int nattrs,
+                           int ndefaulted,
+                           const xmlChar **attrs)
 {
     parser_t *parser = (parser_t *)userdata;
     xmpp_stanza_t *child;
+    char **cbattrs;
+
+    UNUSED(prefix);
+    UNUSED(nnamespaces);
+    UNUSED(namespaces);
+    UNUSED(ndefaulted);
 
     if (parser->depth == 0) {
         /* notify the owner */
-        if (parser->startcb)
+        if (parser->startcb) {
-            parser->startcb((char *)name, (char **)attrs, 
+            cbattrs = _convert_attrs(parser, nattrs, attrs);
-                            parser->userdata);
+            parser->startcb((char *)name, cbattrs, parser->userdata);
+            _free_cbattrs(parser, cbattrs);
+        }
     } else {
-	/* build stanzas at depth 1 */
+        /* build stanzas at depth 1 */
-	if (!parser->stanza && parser->depth != 1) {
+        if (!parser->stanza && parser->depth != 1) {
-	    /* something terrible happened */
+            /* something terrible happened */
-	    /* FIXME: we should probably trigger a disconnect */
+            /* FIXME: we should probably trigger a disconnect */
-	    xmpp_error(parser->ctx, "parser", "oops, where did our stanza go?");
+            xmpp_error(parser->ctx, "parser", "oops, where did our stanza go?");
-	} else if (!parser->stanza) {
+        } else if (!parser->stanza) {
-	    /* starting a new toplevel stanza */
+            /* starting a new toplevel stanza */
-	    parser->stanza = xmpp_stanza_new(parser->ctx);
+            parser->stanza = xmpp_stanza_new(parser->ctx);
-	    if (!parser->stanza) {
+            if (!parser->stanza) {
-		/* FIXME: can't allocate, disconnect */
+                /* FIXME: can't allocate, disconnect */
-	    }
+            }
-	    xmpp_stanza_set_name(parser->stanza, (char *)name);
+            xmpp_stanza_set_name(parser->stanza, (char *)name);
-	    _set_attributes(parser->stanza, attrs);
+            _set_attributes(parser->stanza, nattrs, attrs);
-	} else {
+            if (uri)
-	    /* starting a child of conn->stanza */
+                xmpp_stanza_set_ns(parser->stanza, (char *)uri);
-	    child = xmpp_stanza_new(parser->ctx);
+        } else {
-	    if (!child) {
+            /* starting a child of conn->stanza */
-		/* FIXME: can't allocate, disconnect */
+            child = xmpp_stanza_new(parser->ctx);
-	    }
+            if (!child) {
-	    xmpp_stanza_set_name(child, (char *)name);
+                /* FIXME: can't allocate, disconnect */
-	    _set_attributes(child, attrs);
+            }
+            xmpp_stanza_set_name(child, (char *)name);
+            _set_attributes(child, nattrs, attrs);
+            if (uri)
+                xmpp_stanza_set_ns(child, (char *)uri);
 
-	    /* add child to parent */
+            /* add child to parent */
-	    xmpp_stanza_add_child(parser->stanza, child);
+            xmpp_stanza_add_child(parser->stanza, child);
-	    
-	    /* the child is owned by the toplevel stanza now */
-	    xmpp_stanza_release(child);
 
-	    /* make child the current stanza */
+            /* the child is owned by the toplevel stanza now */
-	    parser->stanza = child;
+            xmpp_stanza_release(child);
-	}
+
+            /* make child the current stanza */
+            parser->stanza = child;
+        }
     }
 
     parser->depth++;
 }
 
-static void _end_element(void *userdata, const xmlChar *name)
+static void _end_element(void *userdata,
+                         const xmlChar *name,
+                         const xmlChar *prefix,
+                         const xmlChar *uri)
 {
     parser_t *parser = (parser_t *)userdata;
 
+    UNUSED(prefix);
+    UNUSED(uri);
+
     parser->depth--;
 
     if (parser->depth == 0) {
@@ -109,16 +193,15 @@ static void _end_element(void *userdata, const xmlChar *name)
         if (parser->endcb)
             parser->endcb((char *)name, parser->userdata);
     } else {
-	if (parser->stanza->parent) {
+        if (parser->stanza->parent) {
-	    /* we're finishing a child stanza, so set current to the parent */
+            /* we're finishing a child stanza, so set current to the parent */
-	    parser->stanza = parser->stanza->parent;
+            parser->stanza = parser->stanza->parent;
-	} else {
+        } else {
             if (parser->stanzacb)
-                parser->stanzacb(parser->stanza,
+                parser->stanzacb(parser->stanza, parser->userdata);
-                                 parser->userdata);
             xmpp_stanza_release(parser->stanza);
             parser->stanza = NULL;
-	}
+        }
     }
 }
 
@@ -128,13 +211,14 @@ static void _characters(void *userdata, const xmlChar *chr, int len)
     xmpp_stanza_t *stanza;
 
     /* skip unimportant whitespace, etc */
-    if (parser->depth < 2) return;
+    if (parser->depth < 2)
+        return;
 
     /* create and populate stanza */
     stanza = xmpp_stanza_new(parser->ctx);
     if (!stanza) {
-	/* FIXME: allocation error, disconnect */
+        /* FIXME: allocation error, disconnect */
-	return;
+        return;
     }
     xmpp_stanza_set_text_with_size(stanza, (char *)chr, len);
 
@@ -156,8 +240,9 @@ parser_t *parser_new(xmpp_ctx_t *ctx,
         parser->ctx = ctx;
         parser->xmlctx = NULL;
         memset(&parser->handlers, 0, sizeof(xmlSAXHandler));
-        parser->handlers.startElement = _start_element;
+        parser->handlers.initialized = XML_SAX2_MAGIC;
-        parser->handlers.endElement = _end_element;
+        parser->handlers.startElementNs = _start_element;
+        parser->handlers.endElementNs = _end_element;
         parser->handlers.characters = _characters;
         parser->startcb = startcb;
         parser->endcb = endcb;
@@ -172,11 +257,18 @@ parser_t *parser_new(xmpp_ctx_t *ctx,
     return parser;
 }
 
+char *parser_attr_name(xmpp_ctx_t *ctx, char *nsname)
+{
+    return xmpp_strdup(ctx, nsname);
+}
+
 /* free a parser */
 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);
 }
 
@@ -185,28 +277,22 @@ int parser_reset(parser_t *parser)
 {
     if (parser->xmlctx)
         xmlFreeParserCtxt(parser->xmlctx);
+    if (parser->stanza)
+        xmpp_stanza_release(parser->stanza);
 
-    if (parser->stanza) 
-	xmpp_stanza_release(parser->stanza);
-
-    parser->xmlctx = xmlCreatePushParserCtxt(&parser->handlers, 
-                                             parser, NULL, 0, NULL);
-    if (!parser->xmlctx) return 0;
-
-    parser->depth = 0;
     parser->stanza = NULL;
+    parser->depth = 0;
 
-    return 1;
+    parser->xmlctx =
+        xmlCreatePushParserCtxt(&parser->handlers, parser, NULL, 0, NULL);
+
+    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 !xmlParseChunk(parser->xmlctx, chunk, len, 0);
-        return 1;
-    } else {
-        return 0;
-    }
 }

src/rand.c

@@ -0,0 +1,324 @@
+/* rand.c
+ * strophe XMPP client library -- pseudo-random number generator
+ *
+ * Copyright (C) 2014 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.
+ */
+
+/** @file
+ *  Pseudo-random number generator.
+ *
+ *  Implemented Hash_DRBG mechanism according to NIST SP 800-90A.
+ *  Hash function is SHA1.
+ */
+
+/** @defgroup Random Pseudo-random number generator
+ */
+
+#include <assert.h>
+#include <string.h> /* memeset */
+#include <time.h>   /* clock, time */
+
+#include "common.h"  /* xmpp_alloc, xmpp_free */
+#include "ostypes.h" /* uint8_t, uint32_t, size_t */
+#include "sha1.h"
+#include "snprintf.h" /* xmpp_snprintf */
+
+#include "rand.h" /* xmpp_rand_t */
+
+#define outlen SHA1_DIGEST_SIZE
+#define seedlen (440 / 8)
+#define reseed_interval 0x7fffffff
+
+/* maximum number of bytes that can be generated per call */
+#define GENERATE_MAX (outlen * 10)
+#define ENTROPY_MAX 128
+#define NONCE_MAX 8
+
+#define RESEED_NEEDED (-1)
+
+struct Hash_DRBG_CTX_struc {
+    uint8_t V[seedlen];
+    uint8_t C[seedlen];
+    uint32_t reseed_counter;
+};
+typedef struct Hash_DRBG_CTX_struc Hash_DRBG_CTX;
+
+struct _xmpp_rand_t {
+    int inited;
+    unsigned reseed_count;
+    Hash_DRBG_CTX ctx;
+};
+
+/* returns smallest number mupliple of y that not less than x */
+#define round_up(x, y) (((x) + (y)-1) / (y) * (y))
+/* returns smallest integer number that not less than x/y */
+#define div_round_up(x, y) (((x) + (y)-1) / (y))
+
+/* adds two arrays as numbers in big-endian representation and stores
+ * result in the first one.
+ */
+static void
+arr_add(uint8_t *arr1, size_t arr1_len, uint8_t *arr2, size_t arr2_len)
+{
+    size_t i;
+    uint32_t acc;
+    uint32_t carry = 0;
+
+    assert(arr1_len >= arr2_len);
+
+    for (i = 1; (i <= arr2_len) || (carry != 0 && i <= arr1_len); ++i) {
+        acc = (uint32_t)arr1[arr1_len - i] + carry;
+        if (i <= arr2_len)
+            acc += (uint32_t)arr2[arr2_len - i];
+        carry = acc >> 8;
+        arr1[arr1_len - i] = (uint8_t)(acc & 0xff);
+    }
+}
+
+/* stores 32-bit number in big-endian representation */
+static void store_be32(uint32_t val, uint8_t be[4])
+{
+    be[0] = (uint8_t)((val >> 24) & 0xff);
+    be[1] = (uint8_t)((val >> 16) & 0xff);
+    be[2] = (uint8_t)((val >> 8) & 0xff);
+    be[3] = (uint8_t)(val & 0xff);
+}
+
+static void Hash_df(uint8_t *input_string,
+                    size_t input_string_len,
+                    uint8_t *output_string,
+                    size_t no_of_bytes_to_return)
+{
+    uint8_t counter;
+    uint8_t temp[round_up(seedlen, outlen)];
+    uint8_t conj[ENTROPY_MAX + NONCE_MAX + seedlen + 6];
+    size_t len;
+    size_t i;
+    size_t offset;
+
+    assert(no_of_bytes_to_return <= sizeof(temp));
+    assert(input_string_len + 5 <= sizeof(conj));
+
+    len = div_round_up(no_of_bytes_to_return, outlen);
+    for (i = 1; i <= len; ++i) {
+        offset = (i - 1) * outlen;
+        counter = (uint8_t)i;
+        conj[0] = counter;
+        store_be32((uint32_t)no_of_bytes_to_return * 8, conj + 1);
+        memcpy(conj + 5, input_string, input_string_len);
+        crypto_SHA1(conj, input_string_len + 5, temp + offset);
+    }
+
+    memcpy(output_string, temp, no_of_bytes_to_return);
+}
+
+/* assume personalization_string is zero length string */
+static void Hash_DRBG_Instantiate(Hash_DRBG_CTX *ctx,
+                                  uint8_t *entropy_input,
+                                  size_t entropy_input_len,
+                                  uint8_t *nonce,
+                                  size_t nonce_len)
+{
+    uint8_t seed_material[ENTROPY_MAX + NONCE_MAX];
+    uint8_t seed0[seedlen + 1];
+    uint8_t *seed = seed0 + 1;
+
+    assert(entropy_input_len <= ENTROPY_MAX);
+    assert(nonce_len <= NONCE_MAX);
+    assert(nonce != NULL || nonce_len == 0);
+
+    memcpy(seed_material, entropy_input, entropy_input_len);
+    if (nonce != NULL)
+        memcpy(seed_material + entropy_input_len, nonce, nonce_len);
+    Hash_df(seed_material, entropy_input_len + nonce_len, seed, seedlen);
+    seed0[0] = 0;
+
+    memcpy(ctx->V, seed, seedlen);
+    Hash_df(seed0, sizeof(seed0), ctx->C, seedlen);
+    ctx->reseed_counter = 1;
+}
+
+/* assume additional_input is zero length string */
+static void Hash_DRBG_Reseed(Hash_DRBG_CTX *ctx,
+                             uint8_t *entropy_input,
+                             size_t entropy_input_len)
+{
+    uint8_t seed_material[1 + seedlen + ENTROPY_MAX];
+    uint8_t seed0[seedlen + 1];
+    uint8_t *seed = seed0 + 1;
+
+    assert(entropy_input_len <= ENTROPY_MAX);
+
+    seed_material[0] = 1;
+    memcpy(seed_material + 1, ctx->V, seedlen);
+    memcpy(seed_material + 1 + seedlen, entropy_input, entropy_input_len);
+    Hash_df(seed_material, entropy_input_len + seedlen + 1, seed, seedlen);
+    seed0[0] = 0;
+
+    memcpy(ctx->V, seed, seedlen);
+    Hash_df(seed0, sizeof(seed0), ctx->C, seedlen);
+    ctx->reseed_counter = 1;
+}
+
+static void
+Hashgen(uint8_t *V, uint8_t *output, size_t requested_number_of_bytes)
+{
+    uint8_t data[seedlen];
+    uint8_t W[GENERATE_MAX];
+    uint8_t i1 = 1;
+    size_t m;
+    size_t i;
+    size_t offset;
+
+    assert(requested_number_of_bytes <= sizeof(W));
+
+    m = div_round_up(requested_number_of_bytes, outlen);
+    memcpy(data, V, seedlen);
+    for (i = 1; i <= m; ++i) {
+        offset = (i - 1) * outlen;
+        crypto_SHA1(data, seedlen, W + offset);
+        /* increase data by 1 */
+        arr_add(data, sizeof(data), &i1, 1);
+    }
+
+    memcpy(output, W, requested_number_of_bytes);
+}
+
+/* assume additional_input is zero length string */
+static int Hash_DRBG_Generate(Hash_DRBG_CTX *ctx,
+                              uint8_t *output,
+                              size_t requested_number_of_bytes)
+{
+    uint8_t H[outlen];
+    uint8_t V3[seedlen + 1];
+    uint8_t reseed_counter[4];
+
+    if (ctx->reseed_counter > reseed_interval || ctx->reseed_counter == 0)
+        return RESEED_NEEDED;
+
+    Hashgen(ctx->V, output, requested_number_of_bytes);
+
+    V3[0] = 3;
+    memcpy(V3 + 1, ctx->V, seedlen);
+    crypto_SHA1(V3, sizeof(V3), H);
+    arr_add(ctx->V, sizeof(ctx->V), ctx->C, sizeof(ctx->C));
+    arr_add(ctx->V, sizeof(ctx->V), H, sizeof(H));
+    store_be32(ctx->reseed_counter, reseed_counter);
+    arr_add(ctx->V, sizeof(ctx->V), reseed_counter, sizeof(reseed_counter));
+
+    ++ctx->reseed_counter;
+    return 0;
+}
+
+#define ENTROPY_ACCUMULATE(ptr, last, type, arg)          \
+    do {                                                  \
+        type __arg = (type)(arg);                         \
+        if ((char *)ptr + sizeof(__arg) < (char *)last) { \
+            *(type *)ptr = __arg;                         \
+            ptr = (void *)((char *)ptr + sizeof(__arg));  \
+        }                                                 \
+    } while (0)
+
+static void xmpp_rand_reseed(xmpp_rand_t *rand)
+{
+    uint8_t entropy[ENTROPY_MAX];
+    uint8_t *ptr = entropy;
+    const uint8_t *last = entropy + sizeof(entropy);
+    size_t len;
+
+    /* entropy:
+     *  1. time_stamp()
+     *  2. clock(3)
+     *  3. xmpp_rand_t address to make unique seed within one process
+     *  4. counter to make unique seed within one context
+     *  5. stack address
+     *  6. local ports of every connection in list (getsockname)
+     *  7. other non-constant info that can be retieved from socket
+     *
+     *  rand(3) can't be used as it isn't thread-safe.
+     *  XXX 6 and 7 are not implemented yet.
+     */
+
+    ENTROPY_ACCUMULATE(ptr, last, uint64_t, time_stamp());
+    ENTROPY_ACCUMULATE(ptr, last, clock_t, clock());
+    ENTROPY_ACCUMULATE(ptr, last, void *, rand);
+    ENTROPY_ACCUMULATE(ptr, last, unsigned, ++rand->reseed_count);
+    ENTROPY_ACCUMULATE(ptr, last, void *, &entropy);
+    len = ptr - entropy;
+
+    if (rand->inited) {
+        Hash_DRBG_Reseed(&rand->ctx, entropy, len);
+    } else {
+        Hash_DRBG_Instantiate(&rand->ctx, entropy, len, NULL, 0);
+        rand->inited = 1;
+    }
+}
+
+xmpp_rand_t *xmpp_rand_new(xmpp_ctx_t *ctx)
+{
+    xmpp_rand_t *out = xmpp_alloc(ctx, sizeof(*out));
+    if (out != NULL) {
+        memset(out, 0, sizeof(*out));
+    }
+    return out;
+}
+
+void xmpp_rand_free(xmpp_ctx_t *ctx, xmpp_rand_t *rand)
+{
+    xmpp_free(ctx, rand);
+}
+
+void xmpp_rand_bytes(xmpp_rand_t *rand, unsigned char *output, size_t len)
+{
+    int rc;
+
+    rc = Hash_DRBG_Generate(&rand->ctx, (uint8_t *)output, len);
+    if (rc == RESEED_NEEDED) {
+        xmpp_rand_reseed(rand);
+        rc = Hash_DRBG_Generate(&rand->ctx, (uint8_t *)output, len);
+        assert(rc == 0);
+    }
+}
+
+int xmpp_rand(xmpp_rand_t *rand)
+{
+    int result;
+
+    xmpp_rand_bytes(rand, (unsigned char *)&result, sizeof(result));
+    return result;
+}
+
+static void rand_byte2hex(unsigned char byte, char *hex)
+{
+    static const char hex_tbl[16] = {'0', '1', '2', '3', '4', '5', '6', '7',
+                                     '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
+
+    hex[0] = hex_tbl[(byte >> 4) & 0x0f];
+    hex[1] = hex_tbl[byte & 0x0f];
+}
+
+void xmpp_rand_nonce(xmpp_rand_t *rand, char *output, size_t len)
+{
+    size_t i;
+    const size_t rand_len = len / 2;
+
+    /*
+     * We don't want to use any allocation here, because this function
+     * can't fail. Also we want to avoid VLA.
+     * Current implementation uses half of the output buffer for random buffer
+     * generation and then converts it to HEX representation.
+     */
+
+    if (rand_len > 0) {
+        xmpp_rand_bytes(rand, (unsigned char *)output, rand_len);
+        for (i = rand_len; i > 0; --i)
+            rand_byte2hex(output[i - 1], &output[(i - 1) * 2]);
+    }
+    if (len > 0)
+        output[len - 1] = '\0';
+}

src/rand.h

@@ -0,0 +1,65 @@
+/* rand.h
+ * strophe XMPP client library -- pseudo-random number generator
+ *
+ * Copyright (C) 2014 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.
+ */
+
+/** @file
+ *  Pseudo-random number generator.
+ */
+
+#ifndef __LIBSTROPHE_RAND_H__
+#define __LIBSTROPHE_RAND_H__
+
+#include <stddef.h>  /* size_t */
+#include "strophe.h" /* xmpp_ctx_t */
+
+typedef struct _xmpp_rand_t xmpp_rand_t;
+
+/** Create new xmpp_rand_t object.
+ *
+ *  @param ctx A Strophe context object
+ *
+ *  @ingroup Random
+ */
+xmpp_rand_t *xmpp_rand_new(xmpp_ctx_t *ctx);
+/** Destroy an xmpp_rand_t object.
+ *
+ *  @param ctx A Strophe context object
+ *
+ *  @ingroup Random
+ */
+void xmpp_rand_free(xmpp_ctx_t *ctx, xmpp_rand_t *rand);
+
+/** Generate random integer.
+ *  Analogue of rand(3).
+ *
+ *  @ingroup Random
+ */
+int xmpp_rand(xmpp_rand_t *rand);
+
+/** Generate random bytes.
+ *  Generates len bytes and stores them to the output buffer.
+ *
+ *  @ingroup Random
+ */
+void xmpp_rand_bytes(xmpp_rand_t *rand, unsigned char *output, size_t len);
+
+/** Generate a nonce that is printable randomized string.
+ *  This function doesn't allocate memory and doesn't fail.
+ *
+ *  @param output A buffer where a NULL-terminated string will be placed.
+ *                The string will contain len-1 printable symbols.
+ *  @param len Number of bytes reserved for the output string, including
+ *             end of line '\0'.
+ *
+ *  @ingroup Random
+ */
+void xmpp_rand_nonce(xmpp_rand_t *rand, char *output, size_t len);
+
+#endif /* __LIBSTROPHE_RAND_H__ */

src/resolver.c

@@ -0,0 +1,975 @@
+/* resolver.c
+ * strophe XMPP client library -- DNS resolver
+ *
+ * Copyright (C) 2015 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.
+ */
+
+/** @file
+ *  DNS resolver.
+ */
+
+#if !defined(_WIN32) && !defined(HAVE_CARES)
+#include <netinet/in.h>
+#include <arpa/nameser.h>
+#include <resolv.h>
+#endif /* _WIN32 && HAVE_CARES */
+
+#ifdef HAVE_CARES
+#include <ares.h>
+/* for select(2) */
+#ifdef _WIN32
+#include <winsock2.h>
+#else /* _WIN32 */
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#endif /* !_WIN32 */
+#endif /* HAVE_CARES */
+
+#include <string.h> /* strncpy */
+
+#include "ostypes.h"
+#include "snprintf.h"
+#include "util.h" /* xmpp_min */
+#include "resolver.h"
+
+#define MESSAGE_HEADER_LEN 12
+#define MESSAGE_RESPONSE 1
+#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 */
+
+#if defined(_WIN32) && !defined(HAVE_CARES)
+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 && !HAVE_CARES */
+
+/*******************************************************************************
+ * 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;
+    uint8_t octet3;
+    uint16_t qdcount;
+    uint16_t ancount;
+    uint16_t nscount;
+    uint16_t arcount;
+};
+
+/* the same as ntohs(), but receives pointer to the value */
+static uint16_t xmpp_ntohs_ptr(const void *ptr)
+{
+    const uint8_t *p = (const uint8_t *)ptr;
+
+    return (uint16_t)((p[0] << 8U) + p[1]);
+}
+
+static uint8_t message_header_qr(const struct message_header *header)
+{
+    return (header->octet2 >> 7) & 1;
+}
+
+static uint8_t message_header_rcode(const struct message_header *header)
+{
+    return header->octet3 & 0x0f;
+}
+
+/*
+ * Append a label or a dot to the target name with buffer overflow checks.
+ * Returns length of the non-truncated resulting string, may be bigger than
+ * name_max.
+ */
+static size_t message_name_append_safe(char *name,
+                                       size_t name_len,
+                                       size_t name_max,
+                                       const char *tail,
+                                       size_t tail_len)
+{
+    size_t copy_len;
+
+    copy_len = name_max > name_len ? name_max - name_len : 0;
+    copy_len = xmpp_min(tail_len, copy_len);
+    if (copy_len > 0)
+        memcpy(&name[name_len], tail, copy_len);
+
+    return name_len + tail_len;
+}
+
+/* Returns length of the compressed name. This is NOT the same as strlen(). */
+static unsigned message_name_get(const unsigned char *buf,
+                                 size_t buf_len,
+                                 unsigned buf_offset,
+                                 char *name,
+                                 size_t name_max)
+{
+    size_t name_len = 0;
+    unsigned i = buf_offset;
+    unsigned pointer;
+    unsigned rc;
+    unsigned char label_len;
+
+    while (1) {
+        if (i >= buf_len)
+            return 0;
+        label_len = buf[i++];
+        if (label_len == 0)
+            break;
+
+        /* Label */
+        if ((label_len & 0xc0) == 0) {
+            if (i + label_len - 1 >= buf_len)
+                return 0;
+            if (name != NULL) {
+                name_len = message_name_append_safe(name, name_len, name_max,
+                                                    (char *)&buf[i], label_len);
+                name_len =
+                    message_name_append_safe(name, name_len, name_max, ".", 1);
+            }
+            i += label_len;
+
+            /* Pointer */
+        } else if ((label_len & 0xc0) == 0xc0) {
+            if (i >= buf_len)
+                return 0;
+            pointer = (label_len & 0x3f) << 8 | buf[i++];
+            if (name != NULL && name_len >= name_max && name_max > 0) {
+                /* We have filled the name buffer. Don't pass it recursively. */
+                name[name_max - 1] = '\0';
+                name = NULL;
+                name_max = 0;
+            }
+            rc = message_name_get(
+                buf, buf_len, pointer, name != NULL ? &name[name_len] : NULL,
+                name_max > name_len ? name_max - name_len : 0);
+            if (rc == 0)
+                return 0;
+            /* Pointer is always the last. */
+            break;
+
+            /* The 10 and 01 combinations are reserved for future use. */
+        } else {
+            return 0;
+        }
+    }
+    if (label_len == 0) {
+        if (name_len == 0)
+            name_len = 1;
+        /*
+         * At this point name_len is length of the resulting name,
+         * including '\0'. This value can be exported to allocate buffer
+         * of precise size.
+         */
+        if (name != NULL && name_max > 0) {
+            /*
+             * Overwrite leading '.' with a '\0'. If the resulting name is
+             * bigger than name_max it is truncated.
+             */
+            name[xmpp_min(name_len, name_max) - 1] = '\0';
+        }
+    }
+
+    return i - buf_offset;
+}
+
+static unsigned
+message_name_len(const unsigned char *buf, size_t buf_len, unsigned buf_offset)
+{
+    return message_name_get(buf, buf_len, buf_offset, NULL, SIZE_MAX);
+}
+
+#define BUF_OVERFLOW_CHECK(ptr, len)                  \
+    do {                                              \
+        if ((ptr) >= (len)) {                         \
+            if (*srv_rr_list != NULL)                 \
+                resolver_srv_free(ctx, *srv_rr_list); \
+            *srv_rr_list = NULL;                      \
+            return XMPP_DOMAIN_NOT_FOUND;             \
+        }                                             \
+    } while (0)
+
+static int resolver_raw_srv_lookup_buf(xmpp_ctx_t *ctx,
+                                       const unsigned char *buf,
+                                       size_t len,
+                                       resolver_srv_rr_t **srv_rr_list)
+{
+    unsigned i;
+    unsigned j;
+    unsigned name_len;
+    unsigned rdlength;
+    uint16_t type;
+    uint16_t class;
+    struct message_header header;
+    resolver_srv_rr_t *rr;
+
+    *srv_rr_list = NULL;
+
+    if (len < MESSAGE_HEADER_LEN)
+        return XMPP_DOMAIN_NOT_FOUND;
+
+    header.id = xmpp_ntohs_ptr(&buf[0]);
+    header.octet2 = buf[2];
+    header.octet3 = buf[3];
+    header.qdcount = xmpp_ntohs_ptr(&buf[4]);
+    header.ancount = xmpp_ntohs_ptr(&buf[6]);
+    header.nscount = xmpp_ntohs_ptr(&buf[8]);
+    header.arcount = xmpp_ntohs_ptr(&buf[10]);
+    if (message_header_qr(&header) != MESSAGE_RESPONSE ||
+        message_header_rcode(&header) != 0) {
+        return XMPP_DOMAIN_NOT_FOUND;
+    }
+    j = MESSAGE_HEADER_LEN;
+
+    /* skip question section */
+    for (i = 0; i < header.qdcount; ++i) {
+        BUF_OVERFLOW_CHECK(j, len);
+        name_len = message_name_len(buf, len, j);
+        /* error in name format */
+        if (name_len == 0)
+            return XMPP_DOMAIN_NOT_FOUND;
+        j += name_len + 4;
+    }
+
+    for (i = 0; i < header.ancount; ++i) {
+        BUF_OVERFLOW_CHECK(j, len);
+        name_len = message_name_len(buf, len, j);
+        /* error in name format */
+        if (name_len == 0)
+            return XMPP_DOMAIN_NOT_FOUND;
+        j += name_len;
+        BUF_OVERFLOW_CHECK(j + 16, len);
+        type = xmpp_ntohs_ptr(&buf[j]);
+        class = xmpp_ntohs_ptr(&buf[j + 2]);
+        rdlength = xmpp_ntohs_ptr(&buf[j + 8]);
+        j += 10;
+        if (type == MESSAGE_T_SRV && class == MESSAGE_C_IN) {
+            rr = xmpp_alloc(ctx, sizeof(*rr));
+            rr->next = *srv_rr_list;
+            rr->priority = xmpp_ntohs_ptr(&buf[j]);
+            rr->weight = xmpp_ntohs_ptr(&buf[j + 2]);
+            rr->port = xmpp_ntohs_ptr(&buf[j + 4]);
+            name_len = message_name_get(buf, len, j + 6, rr->target,
+                                        sizeof(rr->target));
+            if (name_len > 0)
+                *srv_rr_list = rr;
+            else
+                xmpp_free(ctx, rr); /* skip broken record */
+        }
+        j += rdlength;
+    }
+
+    return *srv_rr_list != NULL ? XMPP_DOMAIN_FOUND : XMPP_DOMAIN_NOT_FOUND;
+}
+
+#endif /* !HAVE_CARES */
+
+#ifdef HAVE_CARES
+/*******************************************************************************
+ * Resolver implementation using c-ares library.
+ ******************************************************************************/
+
+struct resolver_ares_ctx {
+    xmpp_ctx_t *ctx;
+    int result;
+    resolver_srv_rr_t *srv_rr_list;
+};
+
+static int resolver_ares_srv_lookup_buf(xmpp_ctx_t *ctx,
+                                        const unsigned char *buf,
+                                        size_t len,
+                                        resolver_srv_rr_t **srv_rr_list)
+{
+    struct ares_srv_reply *srv;
+    struct ares_srv_reply *item;
+    resolver_srv_rr_t *rr;
+    int rc;
+
+    *srv_rr_list = NULL;
+
+    rc = ares_parse_srv_reply(buf, len, &srv);
+    if (rc != ARES_SUCCESS)
+        return XMPP_DOMAIN_NOT_FOUND;
+
+    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;
+}
+
+static void ares_srv_lookup_callback(
+    void *arg, int status, int timeouts, unsigned char *buf, int len)
+{
+    struct resolver_ares_ctx *actx = arg;
+
+    (void)timeouts;
+
+    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 */
+
+#if defined(_WIN32) && !defined(HAVE_CARES)
+/*******************************************************************************
+ * Next part was copied from sock.c and contains old win32 code.
+ *
+ * The idea is to get raw response from a name server and pass it to
+ * resolver_srv_lookup_buf(). In fact, resolver_win32_srv_query() replaces
+ * the call of res_query().
+ * Dnsapi code is moved to a separated function resolver_srv_win32_lookup() and
+ * changed to meet new API.
+ *
+ * XXX If the code is compiled it should work like before.
+ ******************************************************************************/
+
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windns.h>
+#include <iphlpapi.h>
+
+struct dnsquery_header {
+    unsigned short id;
+    unsigned char qr;
+    unsigned char opcode;
+    unsigned char aa;
+    unsigned char tc;
+    unsigned char rd;
+    unsigned char ra;
+    unsigned char z;
+    unsigned char rcode;
+    unsigned short qdcount;
+    unsigned short ancount;
+    unsigned short nscount;
+    unsigned short arcount;
+};
+
+struct dnsquery_question {
+    char qname[1024];
+    unsigned short qtype;
+    unsigned short qclass;
+};
+
+static void netbuf_add_16bitnum(unsigned char *buf,
+                                int buflen,
+                                int *offset,
+                                unsigned short num)
+{
+    unsigned char *start = buf + *offset;
+    unsigned char *p = start;
+
+    /* assuming big endian */
+    *p++ = (num >> 8) & 0xff;
+    *p++ = (num)&0xff;
+
+    *offset += 2;
+}
+
+static void
+netbuf_add_domain_name(unsigned char *buf, int buflen, int *offset, char *name)
+{
+    unsigned char *start = buf + *offset;
+    unsigned char *p = start;
+    unsigned char *wordstart, *wordend;
+
+    wordstart = (unsigned char *)name;
+
+    while (*wordstart) {
+        int len;
+        wordend = wordstart;
+        while (*wordend && *wordend != '.') {
+            wordend++;
+        }
+
+        len = (int)(wordend - wordstart);
+
+        if (len > 0x3F) {
+            len = 0x3F;
+        }
+
+        *p++ = len;
+
+        while (wordstart != wordend) {
+            *p++ = *wordstart++;
+        }
+
+        if (*wordstart == '.') {
+            wordstart++;
+        }
+    }
+
+    *p++ = '\0';
+
+    *offset += (int)(p - start);
+}
+
+static void netbuf_add_dnsquery_header(unsigned char *buf,
+                                       int buflen,
+                                       int *offset,
+                                       struct dnsquery_header *header)
+{
+    unsigned char *p;
+
+    netbuf_add_16bitnum(buf, buflen, offset, header->id);
+
+    p = buf + *offset;
+    *p++ = ((header->qr & 0x01) << 7) | ((header->opcode & 0x0F) << 3) |
+           ((header->aa & 0x01) << 2) | ((header->tc & 0x01) << 1) |
+           ((header->rd & 0x01));
+    *p++ = ((header->ra & 0x01) << 7) | ((header->z & 0x07) << 4) |
+           ((header->rcode & 0x0F));
+    *offset += 2;
+
+    netbuf_add_16bitnum(buf, buflen, offset, header->qdcount);
+    netbuf_add_16bitnum(buf, buflen, offset, header->ancount);
+    netbuf_add_16bitnum(buf, buflen, offset, header->nscount);
+    netbuf_add_16bitnum(buf, buflen, offset, header->arcount);
+}
+
+static void netbuf_add_dnsquery_question(unsigned char *buf,
+                                         int buflen,
+                                         int *offset,
+                                         struct dnsquery_question *question)
+{
+    netbuf_add_domain_name(buf, buflen, offset, question->qname);
+    netbuf_add_16bitnum(buf, buflen, offset, question->qtype);
+    netbuf_add_16bitnum(buf, buflen, offset, question->qclass);
+}
+
+static int resolver_win32_srv_lookup(xmpp_ctx_t *ctx,
+                                     const char *fulldomain,
+                                     resolver_srv_rr_t **srv_rr_list)
+{
+    resolver_srv_rr_t *rr;
+    HINSTANCE hdnsapi = NULL;
+
+    DNS_STATUS(WINAPI * pDnsQuery_A)
+    (PCSTR, WORD, DWORD, PIP4_ARRAY, DNS_RECORDA **, PVOID *);
+    void(WINAPI * pDnsRecordListFree)(DNS_RECORDA *, DNS_FREE_TYPE);
+
+    if (hdnsapi = LoadLibrary("dnsapi.dll")) {
+        pDnsQuery_A = (void *)GetProcAddress(hdnsapi, "DnsQuery_A");
+        pDnsRecordListFree =
+            (void *)GetProcAddress(hdnsapi, "DnsRecordListFree");
+
+        if (pDnsQuery_A && pDnsRecordListFree) {
+            DNS_RECORDA *dnsrecords = NULL;
+            DNS_STATUS error;
+
+            error = pDnsQuery_A(fulldomain, DNS_TYPE_SRV, DNS_QUERY_STANDARD,
+                                NULL, &dnsrecords, NULL);
+
+            if (error == 0) {
+                DNS_RECORDA *current = dnsrecords;
+
+                while (current) {
+                    if (current->wType == DNS_TYPE_SRV) {
+                        rr = xmpp_alloc(ctx, sizeof(*rr));
+                        if (rr == NULL)
+                            break;
+                        rr->next = *srv_rr_list;
+                        rr->port = current->Data.Srv.wPort;
+                        rr->priority = current->Data.Srv.wPriority;
+                        rr->weight = current->Data.Srv.wWeight;
+                        xmpp_snprintf(rr->target, sizeof(rr->target), "%s",
+                                      current->Data.Srv.pNameTarget);
+                        *srv_rr_list = rr;
+                    }
+                    current = current->pNext;
+                }
+            }
+
+            pDnsRecordListFree(dnsrecords, DnsFreeRecordList);
+        }
+
+        FreeLibrary(hdnsapi);
+    }
+    resolver_srv_list_sort(srv_rr_list);
+
+    return *srv_rr_list != NULL ? XMPP_DOMAIN_FOUND : XMPP_DOMAIN_NOT_FOUND;
+}
+
+static int
+resolver_win32_srv_query(const char *fulldomain, unsigned char *buf, size_t len)
+{
+    int set = 0;
+    int insize = 0;
+
+    /* if dnsapi didn't work/isn't there, try querying the dns server manually
+     */
+    if (!set) {
+        struct dnsquery_header header;
+        struct dnsquery_question question;
+        int offset = 0;
+        int addrlen;
+        sock_t sock;
+        struct sockaddr_in dnsaddr;
+        char dnsserverips[16][256];
+        int numdnsservers = 0;
+        int j;
+
+        /* Try getting the DNS server ips from GetNetworkParams() in iphlpapi
+         * first */
+        if (!numdnsservers) {
+            HINSTANCE hiphlpapi = NULL;
+            DWORD(WINAPI * pGetNetworkParams)(PFIXED_INFO, PULONG);
+
+            if (hiphlpapi = LoadLibrary("Iphlpapi.dll")) {
+                pGetNetworkParams =
+                    (void *)GetProcAddress(hiphlpapi, "GetNetworkParams");
+
+                if (pGetNetworkParams) {
+                    FIXED_INFO *fi;
+                    ULONG len;
+                    DWORD error;
+                    char buffer[65535];
+
+                    len = 65535;
+                    fi = (FIXED_INFO *)buffer;
+
+                    if ((error = pGetNetworkParams(fi, &len)) ==
+                        ERROR_SUCCESS) {
+                        IP_ADDR_STRING *pias = &(fi->DnsServerList);
+
+                        while (pias && numdnsservers < 16) {
+                            strcpy(dnsserverips[numdnsservers++],
+                                   pias->IpAddress.String);
+                            pias = pias->Next;
+                        }
+                    }
+                }
+            }
+            FreeLibrary(hiphlpapi);
+        }
+
+        /* Next, try getting the DNS server ips from the registry */
+        if (!numdnsservers) {
+            HKEY search;
+            LONG error;
+
+            error = RegOpenKeyEx(
+                HKEY_LOCAL_MACHINE,
+                "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters", 0,
+                KEY_READ, &search);
+
+            if (error != ERROR_SUCCESS) {
+                error = RegOpenKeyEx(
+                    HKEY_LOCAL_MACHINE,
+                    "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP", 0,
+                    KEY_READ, &search);
+            }
+
+            if (error == ERROR_SUCCESS) {
+                char name[512];
+                DWORD len = 512;
+
+                error = RegQueryValueEx(search, "NameServer", NULL, NULL,
+                                        (LPBYTE)name, &len);
+
+                if (error != ERROR_SUCCESS) {
+                    error = RegQueryValueEx(search, "DhcpNameServer", NULL,
+                                            NULL, (LPBYTE)name, &len);
+                }
+
+                if (error == ERROR_SUCCESS) {
+                    char *parse = "0123456789.", *start, *end;
+                    start = name;
+                    end = name;
+                    name[len] = '\0';
+
+                    while (*start && numdnsservers < 16) {
+                        while (strchr(parse, *end)) {
+                            end++;
+                        }
+
+                        strncpy(dnsserverips[numdnsservers++], start,
+                                end - start);
+
+                        while (*end && !strchr(parse, *end)) {
+                            end++;
+                        }
+
+                        start = end;
+                    }
+                }
+            }
+
+            RegCloseKey(search);
+        }
+
+        if (!numdnsservers) {
+            HKEY searchlist;
+            LONG error;
+
+            error = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
+                                 "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\P"
+                                 "arameters\\Interfaces",
+                                 0, KEY_READ, &searchlist);
+
+            if (error == ERROR_SUCCESS) {
+                unsigned int i;
+                DWORD numinterfaces = 0;
+
+                RegQueryInfoKey(searchlist, NULL, NULL, NULL, &numinterfaces,
+                                NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+
+                for (i = 0; i < numinterfaces; i++) {
+                    char name[512];
+                    DWORD len = 512;
+                    HKEY searchentry;
+
+                    RegEnumKeyEx(searchlist, i, (LPTSTR)name, &len, NULL, NULL,
+                                 NULL, NULL);
+
+                    if (RegOpenKeyEx(searchlist, name, 0, KEY_READ,
+                                     &searchentry) == ERROR_SUCCESS) {
+                        if (RegQueryValueEx(searchentry, "DhcpNameServer", NULL,
+                                            NULL, (LPBYTE)name,
+                                            &len) == ERROR_SUCCESS) {
+                            char *parse = "0123456789.", *start, *end;
+                            start = name;
+                            end = name;
+                            name[len] = '\0';
+
+                            while (*start && numdnsservers < 16) {
+                                while (strchr(parse, *end)) {
+                                    end++;
+                                }
+
+                                strncpy(dnsserverips[numdnsservers++], start,
+                                        end - start);
+
+                                while (*end && !strchr(parse, *end)) {
+                                    end++;
+                                }
+
+                                start = end;
+                            }
+                        } else if (RegQueryValueEx(searchentry, "NameServer",
+                                                   NULL, NULL, (LPBYTE)name,
+                                                   &len) == ERROR_SUCCESS) {
+                            char *parse = "0123456789.", *start, *end;
+                            start = name;
+                            end = name;
+                            name[len] = '\0';
+
+                            while (*start && numdnsservers < 16) {
+                                while (strchr(parse, *end)) {
+                                    end++;
+                                }
+
+                                strncpy(dnsserverips[numdnsservers++], start,
+                                        end - start);
+
+                                while (*end && !strchr(parse, *end)) {
+                                    end++;
+                                }
+
+                                start = end;
+                            }
+                        }
+                        RegCloseKey(searchentry);
+                    }
+                }
+                RegCloseKey(searchlist);
+            }
+        }
+
+        /* If we have a DNS server, use it */
+        if (numdnsservers) {
+            ULONG nonblocking = 1;
+            int i;
+
+            memset(&header, 0, sizeof(header));
+            header.id = 12345; /* FIXME: Get a better id here */
+            header.rd = 1;
+            header.qdcount = 1;
+
+            netbuf_add_dnsquery_header(buf, (int)len, &offset, &header);
+
+            memset(&question, 0, sizeof(question));
+            strncpy(question.qname, fulldomain, 1024);
+            question.qtype = MESSAGE_T_SRV; /* SRV */
+            question.qclass = MESSAGE_C_IN; /* INTERNET! */
+
+            netbuf_add_dnsquery_question(buf, (int)len, &offset, &question);
+
+            insize = 0;
+            for (i = 0; i < numdnsservers && insize <= 0; i++) {
+                sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+                ioctlsocket(sock, FIONBIO, &nonblocking);
+
+                memset(&dnsaddr, 0, sizeof(dnsaddr));
+
+                dnsaddr.sin_family = AF_INET;
+                dnsaddr.sin_port = htons(53);
+                dnsaddr.sin_addr.s_addr = inet_addr(dnsserverips[i]);
+
+                addrlen = sizeof(dnsaddr);
+                sendto(sock, (char *)buf, offset, 0,
+                       (struct sockaddr *)&dnsaddr, addrlen);
+                for (j = 0; j < 50; j++) {
+                    insize = recvfrom(sock, (char *)buf, (int)len, 0,
+                                      (struct sockaddr *)&dnsaddr, &addrlen);
+                    if (insize == SOCKET_ERROR) {
+                        if (sock_error() == WSAEWOULDBLOCK) {
+                            Sleep(100);
+                        } else {
+                            break;
+                        }
+                    } else {
+                        break;
+                    }
+                }
+
+                closesocket(sock);
+            }
+            set = insize > 0;
+        }
+    }
+
+    return set ? insize : -1;
+}
+
+#endif /* _WIN32 && !HAVE_CARES */

src/resolver.h

@@ -0,0 +1,77 @@
+/* resolver.h
+ * strophe XMPP client library -- DNS resolver
+ *
+ * Copyright (C) 2015 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.
+ */
+
+/** @file
+ *  DNS resolver.
+ */
+
+#ifndef __LIBSTROPHE_RESOLVER_H__
+#define __LIBSTROPHE_RESOLVER_H__
+
+#include "ostypes.h"
+#include "common.h"
+
+typedef enum {
+    XMPP_DOMAIN_NOT_FOUND,
+    XMPP_DOMAIN_FOUND,
+    XMPP_DOMAIN_ALTDOMAIN
+} xmpp_domain_state_t;
+
+typedef struct resolver_srv_rr_struc {
+    uint16_t priority;
+    uint16_t weight;
+    uint16_t port;
+    char target[MAX_DOMAIN_LEN];
+    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.
+ *
+ *  @param ctx a Strophe context object
+ *  @param buf message in RFC1035 format
+ *  @param len length of the message
+ *  @param srv_rr_list is the result
+ *
+ *  @return XMPP_DOMAIN_FOUND on success or XMPP_DOMAIN_NOT_FOUND on fail
+ */
+int resolver_srv_lookup_buf(xmpp_ctx_t *ctx,
+                            const unsigned char *buf,
+                            size_t len,
+                            resolver_srv_rr_t **srv_rr_list);
+/** Resolve SRV record.
+ *
+ *  @param ctx a Strophe context object
+ *  @param service service of the SRV record
+ *  @param proto protocol of the SRV record
+ *  @param domain resolving domain
+ *  @param srv_rr_list is the result
+ *
+ *  @return XMPP_DOMAIN_FOUND on success or XMPP_DOMAIN_NOT_FOUND on fail
+ */
+int resolver_srv_lookup(xmpp_ctx_t *ctx,
+                        const char *service,
+                        const char *proto,
+                        const char *domain,
+                        resolver_srv_rr_t **srv_rr_list);
+
+/** Release a list returned by resolver_srv_lookup() or
+ *  resolver_srv_lookup_buf().
+ *
+ *  @param ctx a Strophe context object
+ *  @param srv_rr_list a list allocated by lookup functions
+ */
+void resolver_srv_free(xmpp_ctx_t *ctx, resolver_srv_rr_t *srv_rr_list);
+
+#endif /* __LIBSTROPHE_RESOLVER_H__ */

src/sasl.c

@@ -1,63 +1,62 @@
 /* sasl.c
 ** strophe XMPP client library -- SASL authentication helpers
-** 
+**
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
  *  SASL authentication.
  */
 
+#include <stdlib.h>
 #include <string.h>
 
 #include "strophe.h"
 #include "common.h"
+#include "ostypes.h"
 #include "sasl.h"
 #include "md5.h"
+#include "scram.h"
+#include "rand.h"
+#include "util.h"
 
-/* make sure the stdint.h types are available */
+/* strtok_s() has appeared in visual studio 2005.
-#if defined(_MSC_VER) /* Microsoft Visual C++ */
+   Use own implementation for older versions. */
-  typedef signed char             int8_t;
+#ifdef _MSC_VER
-  typedef short int               int16_t;
+#if (_MSC_VER >= 1400)
-  typedef int                     int32_t;
+#define strtok_r strtok_s
-  typedef __int64                 int64_t;
-
-  typedef unsigned char             uint8_t;
-  typedef unsigned short int        uint16_t;
-  typedef unsigned int              uint32_t;
-  /* no uint64_t */
 #else
-#include <stdint.h>
+#define strtok_r xmpp_strtok_r
 #endif
-
+#endif /* _MSC_VER */
 
 /** generate authentication string for the SASL PLAIN mechanism */
-char *sasl_plain(xmpp_ctx_t *ctx, const char *authid, const char *password) {
+char *sasl_plain(xmpp_ctx_t *ctx, const char *authid, const char *password)
-    int idlen, passlen;
+{
+    size_t idlen, passlen;
+    size_t msglen;
     char *result = NULL;
     char *msg;
-    
+
     /* our message is Base64(authzid,\0,authid,\0,password)
        if there is no authzid, that field is left empty */
 
     idlen = strlen(authid);
     passlen = strlen(password);
-    msg = xmpp_alloc(ctx, 2 + idlen + passlen);
+    msglen = 2 + idlen + passlen;
+    msg = xmpp_alloc(ctx, msglen);
     if (msg != NULL) {
-	msg[0] = '\0';
+        msg[0] = '\0';
-	memcpy(msg+1, authid, idlen);
+        memcpy(msg + 1, authid, idlen);
-	msg[1+idlen] = '\0';
+        msg[1 + idlen] = '\0';
-	memcpy(msg+1+idlen+1, password, passlen);
+        memcpy(msg + 1 + idlen + 1, password, passlen);
-	result = base64_encode(ctx, (unsigned char *)msg, 2 + idlen + passlen);
+        result = xmpp_base64_encode(ctx, (unsigned char *)msg, msglen);
-	xmpp_free(ctx, msg);
+        xmpp_free(ctx, msg);
     }
 
     return result;
@@ -72,8 +71,8 @@ static char *_make_string(xmpp_ctx_t *ctx, const char *s, const unsigned len)
 
     result = xmpp_alloc(ctx, len + 1);
     if (result != NULL) {
-	memcpy(result, s, len);
+        memcpy(result, s, len);
-	result[len] = '\0';
+        result[len] = '\0';
     }
     return result;
 }
@@ -82,14 +81,14 @@ static char *_make_string(xmpp_ctx_t *ctx, const char *s, const unsigned len)
 static char *_make_quoted(xmpp_ctx_t *ctx, const char *s)
 {
     char *result;
-    int len = strlen(s);
+    size_t len = strlen(s);
 
     result = xmpp_alloc(ctx, len + 3);
     if (result != NULL) {
-	result[0] = '"';
+        result[0] = '"';
-	memcpy(result+1, s, len);
+        memcpy(result + 1, s, len);
-	result[len+1] = '"';
+        result[len + 1] = '"';
-	result[len+2] = '\0';
+        result[len + 2] = '\0';
     }
     return result;
 }
@@ -102,53 +101,58 @@ static hash_t *_parse_digest_challenge(xmpp_ctx_t *ctx, const char *msg)
     char *key, *value;
     unsigned char *s, *t;
 
-    text = base64_decode(ctx, msg, strlen(msg));
+    text = (unsigned char *)xmpp_base64_decode_str(ctx, msg, strlen(msg));
     if (text == NULL) {
-	xmpp_error(ctx, "SASL", "couldn't Base64 decode challenge!");
+        xmpp_error(ctx, "SASL", "couldn't Base64 decode challenge!");
-	return NULL;
+        return NULL;
     }
 
     result = hash_new(ctx, 10, xmpp_free);
     if (result != NULL) {
-	s = text;
+        s = text;
-	while (*s != '\0') {
+        while (*s != '\0') {
-	    /* skip any leading commas and spaces */
+            /* skip any leading commas and spaces */
-	    while ((*s == ',') || (*s == ' ')) s++;
+            while ((*s == ',') || (*s == ' '))
-	    /* accumulate a key ending at '=' */
+                s++;
-	    t = s;
+            /* accumulate a key ending at '=' */
-	    while ((*t != '=') && (*t != '\0')) t++;
+            t = s;
-	    if (*t == '\0') break; /* bad string */
+            while ((*t != '=') && (*t != '\0'))
-	    key = _make_string(ctx, (char *)s, (t-s));
+                t++;
-	    if (key == NULL) break;
+            if (*t == '\0')
+                break; /* bad string */
+            key = _make_string(ctx, (char *)s, (t - s));
+            if (key == NULL)
+                break;
             /* advance our start pointer past the key */
-	    s = t + 1;
+            s = t + 1;
-	    t = s;
+            t = s;
-	    /* if we see quotes, grab the string in between */
+            /* if we see quotes, grab the string in between */
-	    if ((*s == '\'') || (*s == '"')) {
+            if ((*s == '\'') || (*s == '"')) {
-		t++;
+                t++;
-		while ((*t != *s) && (*t != '\0'))
+                while ((*t != *s) && (*t != '\0'))
-		    t++;
+                    t++;
-		value = _make_string(ctx, (char *)s+1, (t-s-1));
+                value = _make_string(ctx, (char *)s + 1, (t - s - 1));
-		if (*t == *s) {
+                if (*t == *s) {
-		    s = t + 1;
+                    s = t + 1;
-		} else {
+                } else {
-		    s = t;
+                    s = t;
-		}
+                }
-	    /* otherwise, accumulate a value ending in ',' or '\0' */
+                /* otherwise, accumulate a value ending in ',' or '\0' */
-	    } else {
+            } else {
-		while ((*t != ',') && (*t != '\0')) t++;
+                while ((*t != ',') && (*t != '\0'))
-		value = _make_string(ctx, (char *)s, (t-s));
+                    t++;
-		s = t;
+                value = _make_string(ctx, (char *)s, (t - s));
-	    }
+                s = t;
-	    if (value == NULL) {
+            }
-		xmpp_free(ctx, key);
+            if (value == NULL) {
-		break;
+                xmpp_free(ctx, key);
-	    }
+                break;
-	    /* TODO: check for collisions per spec */
+            }
-	    hash_add(result, key, value);
+            /* TODO: check for collisions per spec */
-	    /* hash table now owns the value, free the key */
+            hash_add(result, key, value);
-	    xmpp_free(ctx, key);
+            /* hash table now owns the value, free the key */
-	}
+            xmpp_free(ctx, key);
+        }
     }
     xmpp_free(ctx, text);
 
@@ -162,89 +166,97 @@ static void _digest_to_hex(const char *digest, char *hex)
     const char hexdigit[] = "0123456789abcdef";
 
     for (i = 0; i < 16; i++) {
-	*hex++ = hexdigit[ (digest[i] >> 4) & 0x0F ];
+        *hex++ = hexdigit[(digest[i] >> 4) & 0x0F];
-	*hex++ = hexdigit[ digest[i] & 0x0F ];
+        *hex++ = hexdigit[digest[i] & 0x0F];
     }
 }
 
 /** append 'key="value"' to a buffer, growing as necessary */
-static char *_add_key(xmpp_ctx_t *ctx, hash_t *table, const char *key, 
+static char *
-		      char *buf, int *len, int quote)
+_add_key(xmpp_ctx_t *ctx, hash_t *table, const char *key, char *buf, int quote)
 {
-    int olen,nlen;
+    int olen, nlen;
     int keylen, valuelen;
     const char *value, *qvalue;
     char *c;
 
     /* allocate a zero-length string if necessary */
     if (buf == NULL) {
-	buf = xmpp_alloc(ctx, 1);
+        buf = xmpp_alloc(ctx, 1);
-	buf[0] = '\0';
+        buf[0] = '\0';
     }
-    if (buf == NULL) return NULL;
+    if (buf == NULL)
+        return NULL;
 
     /* get current string length */
     olen = strlen(buf);
     value = hash_get(table, key);
     if (value == NULL) {
-	xmpp_error(ctx, "SASL", "couldn't retrieve value for '%s'", key);
+        xmpp_error(ctx, "SASL", "couldn't retrieve value for '%s'", key);
-	value = "";
+        value = "";
     }
     if (quote) {
-	qvalue = _make_quoted(ctx, value);
+        qvalue = _make_quoted(ctx, value);
     } else {
-	qvalue = value;
+        qvalue = value;
     }
     /* added length is key + '=' + value */
     /*   (+ ',' if we're not the first entry   */
     keylen = strlen(key);
     valuelen = strlen(qvalue);
     nlen = (olen ? 1 : 0) + keylen + 1 + valuelen + 1;
-    buf = xmpp_realloc(ctx, buf, olen+nlen);
+    buf = xmpp_realloc(ctx, buf, olen + nlen);
 
     if (buf != NULL) {
-	c = buf + olen;
+        c = buf + olen;
-	if (olen) *c++ = ',';
+        if (olen)
-	memcpy(c, key, keylen); c += keylen;
+            *c++ = ',';
-	*c++ = '=';
+        memcpy(c, key, keylen);
-	memcpy(c, qvalue, valuelen); c += valuelen;
+        c += keylen;
-	*c++ = '\0';
+        *c++ = '=';
+        memcpy(c, qvalue, valuelen);
+        c += valuelen;
+        *c++ = '\0';
     }
 
-    if (quote) xmpp_free(ctx, (char *)qvalue);
+    if (quote)
+        xmpp_free(ctx, (char *)qvalue);
 
     return buf;
 }
 
 /** generate auth response string for the SASL DIGEST-MD5 mechanism */
-char *sasl_digest_md5(xmpp_ctx_t *ctx, const char *challenge,
+char *sasl_digest_md5(xmpp_ctx_t *ctx,
-			const char *jid, const char *password) {
+                      const char *challenge,
+                      const char *jid,
+                      const char *password)
+{
     hash_t *table;
     char *result = NULL;
     char *node, *domain, *realm;
     char *value;
     char *response;
-    int rlen;
     struct MD5Context MD5;
     unsigned char digest[16], HA1[16], HA2[16];
     char hex[32];
+    char cnonce[13];
 
-    /* our digest response is 
+    /* our digest response is
-	Hex( KD( HEX(MD5(A1)),
+    Hex( KD( HEX(MD5(A1)),
-	  nonce ':' nc ':' cnonce ':' qop ':' HEX(MD5(A2))
+      nonce ':' nc ':' cnonce ':' qop ':' HEX(MD5(A2))
-	))
+    ))
 
        where KD(k, s) = MD5(k ':' s),
-	A1 = MD5( node ':' realm ':' password ) ':' nonce ':' cnonce
+    A1 = MD5( node ':' realm ':' password ) ':' nonce ':' cnonce
-	A2 = "AUTHENTICATE" ':' "xmpp/" domain
+    A2 = "AUTHENTICATE" ':' "xmpp/" domain
 
        If there is an authzid it is ':'-appended to A1 */
 
     /* parse the challenge */
     table = _parse_digest_challenge(ctx, challenge);
     if (table == NULL) {
-	xmpp_error(ctx, "SASL", "couldn't parse digest challenge");
+        xmpp_error(ctx, "SASL", "couldn't parse digest challenge");
-	return NULL;
+        return NULL;
     }
 
     node = xmpp_jid_node(ctx, jid);
@@ -254,22 +266,23 @@ char *sasl_digest_md5(xmpp_ctx_t *ctx, const char *challenge,
        server */
     realm = hash_get(table, "realm");
     if (realm == NULL || strlen(realm) == 0) {
-	hash_add(table, "realm", xmpp_strdup(ctx, domain));
+        hash_add(table, "realm", xmpp_strdup(ctx, domain));
-	realm = hash_get(table, "realm");
+        realm = hash_get(table, "realm");
     }
 
     /* add our response fields */
     hash_add(table, "username", xmpp_strdup(ctx, node));
-    /* TODO: generate a random cnonce */
+    xmpp_rand_nonce(ctx->rand, cnonce, sizeof(cnonce));
-    hash_add(table, "cnonce", xmpp_strdup(ctx, "00DEADBEEF00"));
+    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));
+    memcpy(value + 5, domain, strlen(domain));
-    value[5+strlen(domain)] = '\0';
+    value[5 + strlen(domain)] = '\0';
     hash_add(table, "digest-uri", value);
-    
+
     /* generate response */
 
     /* construct MD5(node : realm : password) */
@@ -302,8 +315,8 @@ char *sasl_digest_md5(xmpp_ctx_t *ctx, const char *challenge,
     value = hash_get(table, "digest-uri");
     MD5Update(&MD5, (unsigned char *)value, strlen(value));
     if (strcmp(hash_get(table, "qop"), "auth") != 0) {
-	MD5Update(&MD5, (unsigned char *)":00000000000000000000000000000000",
+        MD5Update(&MD5, (unsigned char *)":00000000000000000000000000000000",
-		  33);
+                  33);
     }
     MD5Final(digest, &MD5);
 
@@ -330,7 +343,7 @@ char *sasl_digest_md5(xmpp_ctx_t *ctx, const char *challenge,
     MD5Update(&MD5, (unsigned char *)hex, 32);
     MD5Final(digest, &MD5);
 
-    response = xmpp_alloc(ctx, 32+1);
+    response = xmpp_alloc(ctx, 32 + 1);
     _digest_to_hex((char *)digest, hex);
     memcpy(response, hex, 32);
     response[32] = '\0';
@@ -338,278 +351,133 @@ char *sasl_digest_md5(xmpp_ctx_t *ctx, const char *challenge,
 
     /* construct reply */
     result = NULL;
-    rlen = 0;
+    result = _add_key(ctx, table, "username", result, 1);
-    result = _add_key(ctx, table, "username", result, &rlen, 1); 
+    result = _add_key(ctx, table, "realm", result, 1);
-    result = _add_key(ctx, table, "realm", result, &rlen, 1); 
+    result = _add_key(ctx, table, "nonce", result, 1);
-    result = _add_key(ctx, table, "nonce", result, &rlen, 1); 
+    result = _add_key(ctx, table, "cnonce", result, 1);
-    result = _add_key(ctx, table, "cnonce", result, &rlen, 1); 
+    result = _add_key(ctx, table, "nc", result, 0);
-    result = _add_key(ctx, table, "nc", result, &rlen, 0); 
+    result = _add_key(ctx, table, "qop", result, 0);
-    result = _add_key(ctx, table, "qop", result, &rlen, 0); 
+    result = _add_key(ctx, table, "digest-uri", result, 1);
-    result = _add_key(ctx, table, "digest-uri", result, &rlen, 1); 
+    result = _add_key(ctx, table, "response", result, 0);
-    result = _add_key(ctx, table, "response", result, &rlen, 0); 
+    result = _add_key(ctx, table, "charset", result, 0);
-    result = _add_key(ctx, table, "charset", result, &rlen, 0);
+
- 
     xmpp_free(ctx, node);
     xmpp_free(ctx, domain);
     hash_release(table); /* also frees value strings */
 
     /* reuse response for the base64 encode of our result */
-    response = base64_encode(ctx, (unsigned char *)result, strlen(result));
+    response = xmpp_base64_encode(ctx, (unsigned char *)result, strlen(result));
     xmpp_free(ctx, result);
 
     return response;
 }
 
-
+/** generate auth response string for the SASL SCRAM mechanism */
-/** Base64 encoding routines. Implemented according to RFC 3548 */
+char *sasl_scram(xmpp_ctx_t *ctx,
-
+                 const struct hash_alg *alg,
-/** map of all byte values to the base64 values, or to
+                 const char *challenge,
-    '65' which indicates an invalid character. '=' is '64' */
+                 const char *first_bare,
-static const char _base64_invcharmap[256] = {
+                 const char *jid,
-    65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65,
+                 const char *password)
-    65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65,
-    65,65,65,65, 65,65,65,65, 65,65,65,62, 65,65,65,63,
-    52,53,54,55, 56,57,58,59, 60,61,65,65, 65,64,65,65,
-    65, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,
-    15,16,17,18, 19,20,21,22, 23,24,25,65, 65,65,65,65,
-    65,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
-    41,42,43,44, 45,46,47,48, 49,50,51,65, 65,65,65,65,
-    65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65,
-    65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65,
-    65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65,
-    65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65,
-    65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65,
-    65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65,
-    65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65,
-    65,65,65,65, 65,65,65,65, 65,65,65,65, 65,65,65,65 
-};
-
-/** map of all 6-bit values to their corresponding byte
-    in the base64 alphabet. Padding char is the value '64' */
-static const char _base64_charmap[65] = {
-    'A','B','C','D', 'E','F','G','H',
-    'I','J','K','L', 'M','N','O','P',
-    'Q','R','S','T', 'U','V','W','X',
-    'Y','Z','a','b', 'c','d','e','f',
-    'g','h','i','j', 'k','l','m','n',
-    'o','p','q','r', 's','t','u','v',
-    'w','x','y','z', '0','1','2','3',
-    '4','5','6','7', '8','9','+','/',
-    '='
-};
-
-int base64_encoded_len(xmpp_ctx_t *ctx, const unsigned len)
 {
-    /* encoded steam is 4 bytes for every three, rounded up */
+    uint8_t key[SCRAM_DIGEST_SIZE];
-    return ((len + 2)/3) << 2;
+    uint8_t sign[SCRAM_DIGEST_SIZE];
-}
+    char *r = NULL;
+    char *s = NULL;
+    char *i = NULL;
+    unsigned char *sval;
+    size_t sval_len;
+    long ival;
+    char *tmp;
+    char *ptr;
+    char *saveptr = NULL;
+    char *response;
+    char *auth;
+    char *response_b64;
+    char *sign_b64;
+    char *result = NULL;
+    size_t response_len;
+    size_t auth_len;
 
-char *base64_encode(xmpp_ctx_t *ctx, 
+    UNUSED(jid);
-		    const unsigned char * const buffer, const unsigned len)
-{
-    int clen;
-    char *cbuf, *c;
-    uint32_t word, hextet;
-    int i;
 
-    clen = base64_encoded_len(ctx, len);
+    tmp = xmpp_strdup(ctx, challenge);
-    cbuf = xmpp_alloc(ctx, clen + 1);
+    if (!tmp) {
-    if (cbuf != NULL) {
+        return NULL;
-	c = cbuf;
-	/* loop over data, turning every 3 bytes into 4 characters */
-	for (i = 0; i < len - 2; i += 3) {
-	    word = buffer[i] << 16 | buffer[i+1] << 8 | buffer[i+2];
-	    hextet = (word & 0x00FC0000) >> 18;
-	    *c++ = _base64_charmap[hextet];
-	    hextet = (word & 0x0003F000) >> 12;
-	    *c++ = _base64_charmap[hextet];
-	    hextet = (word & 0x00000FC0) >> 6;
-	    *c++ = _base64_charmap[hextet];
-	    hextet = (word & 0x000003F);
-	    *c++ = _base64_charmap[hextet];
-	}
-	/* zero, one or two bytes left */
-	switch (len - i) {
-	    case 0:
-		break;
-	    case 1:
-		hextet = (buffer[len-1] & 0xFC) >> 2;
-		*c++ = _base64_charmap[hextet];
-		hextet = (buffer[len-1] & 0x03) << 4;
-		*c++ = _base64_charmap[hextet];
-		*c++ = _base64_charmap[64]; /* pad */
-		*c++ = _base64_charmap[64]; /* pad */
-		break;
-	    case 2:
-		hextet = (buffer[len-2] & 0xFC) >> 2;
-		*c++ = _base64_charmap[hextet];
-		hextet = ((buffer[len-2] & 0x03) << 4) |
-			 ((buffer[len-1] & 0xF0) >> 4);
-		*c++ = _base64_charmap[hextet];
-		hextet = (buffer[len-1] & 0x0F) << 2;
-		*c++ = _base64_charmap[hextet];
-		*c++ = _base64_charmap[64]; /* pad */
-		break;
-	}
-	/* add a terminal null */
-	*c = '\0';
     }
 
-    return cbuf;
+    ptr = strtok_r(tmp, ",", &saveptr);
-}
+    while (ptr) {
-
+        if (strncmp(ptr, "r=", 2) == 0) {
-int base64_decoded_len(xmpp_ctx_t *ctx, 
+            r = ptr;
-		       const char * const buffer, const unsigned len)
+        } else if (strncmp(ptr, "s=", 2) == 0) {
-{
+            s = ptr + 2;
-    int nudge;
+        } else if (strncmp(ptr, "i=", 2) == 0) {
-    int c;
+            i = ptr + 2;
-
+        }
-    /* count the padding characters for the remainder */
+        ptr = strtok_r(NULL, ",", &saveptr);
-    nudge = -1;
-    c = _base64_invcharmap[(int)buffer[len-1]];
-    if (c < 64) nudge = 0;
-    else if (c == 64) {
-	c = _base64_invcharmap[(int)buffer[len-2]];
-	if (c < 64) nudge = 1;
-	else if (c == 64) {
-	    c = _base64_invcharmap[(int)buffer[len-3]];
-	    if (c < 64) nudge = 2;
-	} 
-    }
-    if (nudge < 0) return 0; /* reject bad coding */
-
-    /* decoded steam is 3 bytes for every four */ 
-    return 3 * (len >> 2) - nudge;
-}
-
-unsigned char *base64_decode(xmpp_ctx_t *ctx,
-			     const char * const buffer, const unsigned len)
-{
-    int dlen;
-    unsigned char *dbuf, *d;
-    uint32_t word, hextet;
-    int i;
-
-    /* len must be a multiple of 4 */
-    if (len & 0x03) return NULL;
-
-    dlen = base64_decoded_len(ctx, buffer, len);
-    dbuf = xmpp_alloc(ctx, dlen + 1);
-    if (dbuf != NULL) {
-	d = dbuf;
-	/* loop over each set of 4 characters, decoding 3 bytes */
-	for (i = 0; i < len - 3; i += 4) {
-	    hextet = _base64_invcharmap[(int)buffer[i]];
-	    if (hextet & 0xC0) break;
-	    word = hextet << 18;
-	    hextet = _base64_invcharmap[(int)buffer[i+1]];
-	    if (hextet & 0xC0) break;
-	    word |= hextet << 12;
-	    hextet = _base64_invcharmap[(int)buffer[i+2]];
-	    if (hextet & 0xC0) break;
-	    word |= hextet << 6;
-	    hextet = _base64_invcharmap[(int)buffer[i+3]];
-	    if (hextet & 0xC0) break;
-	    word |= hextet;
-	    *d++ = (word & 0x00FF0000) >> 16;
-	    *d++ = (word & 0x0000FF00) >> 8;
-	    *d++ = (word & 0x000000FF);
-	}
-	if (hextet > 64) goto _base64_decode_error;
-	/* handle the remainder */
-	switch (dlen % 3) {
-	    case 0:
-		/* nothing to do */
-		break;
-	    case 1:
-		/* redo the last quartet, checking for correctness */
-		hextet = _base64_invcharmap[(int)buffer[len-4]];
-		if (hextet & 0xC0) goto _base64_decode_error;
-		word = hextet << 2;
-		hextet = _base64_invcharmap[(int)buffer[len-3]];
-		if (hextet & 0xC0) goto _base64_decode_error;
-		word |= hextet >> 4;
-		*d++ = word & 0xFF;
-		hextet = _base64_invcharmap[(int)buffer[len-2]];
-		if (hextet != 64) goto _base64_decode_error;
-		hextet = _base64_invcharmap[(int)buffer[len-1]];
-		if (hextet != 64) goto _base64_decode_error;
-		break;
-	    case 2:
-		/* redo the last quartet, checking for correctness */
-		hextet = _base64_invcharmap[(int)buffer[len-4]];
-		if (hextet & 0xC0) goto _base64_decode_error;
-		word = hextet << 10;		
-		hextet = _base64_invcharmap[(int)buffer[len-3]];
-		if (hextet & 0xC0) goto _base64_decode_error;
-		word |= hextet << 4;		
-		hextet = _base64_invcharmap[(int)buffer[len-2]];
-		if (hextet & 0xC0) goto _base64_decode_error;
-		word |= hextet >> 2;
-		*d++ = (word & 0xFF00) >> 8;
-		*d++ = (word & 0x00FF);		
-		hextet = _base64_invcharmap[(int)buffer[len-1]];
-		if (hextet != 64) goto _base64_decode_error;
-		break;
-	}
-    }
-    *d = '\0';
-    return dbuf;
-
-_base64_decode_error:	
-    /* invalid character; abort decoding! */
-    xmpp_free(ctx, dbuf);
-    return NULL;
-}
-
-/*** self tests ***/
-#ifdef TEST
-
-#include <stdio.h>
-
-int test_charmap_identity(void)
-{
-    int i, v, u;
-
-    for (i = 0; i < 65; i++) {
-	v = _base64_charmap[i];
-	if (v > 255) return 1;
-	u = _base64_invcharmap[v];
-/*	printf("map: %d -> %d -> %d\n", i, v, u); */
-	if (u != i) return 1;
     }
 
-    return 0; 
+    if (!r || !s || !i) {
-}
+        goto out;
-
-int test_charmap_range(void)
-{
-    int i, v;
-
-    for (i = 64; i < 256; i++) {
-	v = _base64_invcharmap[i];
-	if (i < 64) return 1;
     }
 
-    return 0;
+    xmpp_base64_decode_bin(ctx, s, strlen(s), &sval, &sval_len);
+    if (!sval) {
+        goto out;
+    }
+    ival = strtol(i, &saveptr, 10);
+
+    auth_len = 10 + strlen(r) + strlen(first_bare) + strlen(challenge);
+    auth = xmpp_alloc(ctx, auth_len);
+    if (!auth) {
+        goto out_sval;
+    }
+
+    /* "c=biws," + r + ",p=" + sign_b64 + '\0' */
+    response_len = 7 + strlen(r) + 3 + ((alg->digest_size + 2) / 3 * 4) + 1;
+    response = xmpp_alloc(ctx, response_len);
+    if (!response) {
+        goto out_auth;
+    }
+
+    xmpp_snprintf(response, response_len, "c=biws,%s", r);
+    xmpp_snprintf(auth, auth_len, "%s,%s,%s", first_bare + 3, challenge,
+                  response);
+
+    SCRAM_ClientKey(alg, (uint8_t *)password, strlen(password), (uint8_t *)sval,
+                    sval_len, (uint32_t)ival, key);
+    SCRAM_ClientSignature(alg, key, (uint8_t *)auth, strlen(auth), sign);
+    SCRAM_ClientProof(alg, sign, key, sign);
+
+    sign_b64 = xmpp_base64_encode(ctx, sign, alg->digest_size);
+    if (!sign_b64) {
+        goto out_response;
+    }
+
+    /* Check for buffer overflow */
+    if (strlen(response) + strlen(sign_b64) + 3 + 1 > response_len) {
+        xmpp_free(ctx, sign_b64);
+        goto out_response;
+    }
+    strcat(response, ",p=");
+    strcat(response, sign_b64);
+    xmpp_free(ctx, sign_b64);
+
+    response_b64 =
+        xmpp_base64_encode(ctx, (unsigned char *)response, strlen(response));
+    if (!response_b64) {
+        goto out_response;
+    }
+    result = response_b64;
+
+out_response:
+    xmpp_free(ctx, response);
+out_auth:
+    xmpp_free(ctx, auth);
+out_sval:
+    xmpp_free(ctx, sval);
+out:
+    xmpp_free(ctx, tmp);
+    return result;
 }
-
-int main(int argc, char *argv[])
-{
-    int ret = 0;
-
-    printf("testing charmap identity...");
-    ret = test_charmap_identity();
-    if (ret) return ret;
-    printf(" ok.\n");
-
-    printf("testing charmap range...");
-    ret = test_charmap_range();
-    if (ret) return ret;
-    printf(" ok.\n");
-
-    printf("no error\n");
-    return 0;
-}
-
-#endif /* TEST */

src/sasl.h

@@ -1,15 +1,12 @@
 /* sasl.h
 ** strophe XMPP client library -- SASL authentication helpers
-** 
+**
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -20,25 +17,20 @@
 #define __LIBSTROPHE_SASL_H__
 
 #include "strophe.h"
+#include "scram.h"
 
 /** low-level sasl routines */
 
 char *sasl_plain(xmpp_ctx_t *ctx, const char *authid, const char *password);
-char *sasl_digest_md5(xmpp_ctx_t *ctx, const char *challenge,
+char *sasl_digest_md5(xmpp_ctx_t *ctx,
-		      const char *jid, const char *password);
+                      const char *challenge,
-
+                      const char *jid,
-
+                      const char *password);
-/** Base64 encoding routines. Implemented according to RFC 3548 */
+char *sasl_scram(xmpp_ctx_t *ctx,
-
+                 const struct hash_alg *alg,
-int base64_encoded_len(xmpp_ctx_t *ctx, const unsigned len);
+                 const char *challenge,
-
+                 const char *first_bare,
-char *base64_encode(xmpp_ctx_t *ctx, 
+                 const char *jid,
-		    const unsigned char * const buffer, const unsigned len);
+                 const char *password);
-
-int base64_decoded_len(xmpp_ctx_t *ctx,
-		       const char * const buffer, const unsigned len);
-
-unsigned char *base64_decode(xmpp_ctx_t *ctx,
-			     const char * const buffer, const unsigned  len);
 
 #endif /* _LIBXMPP_SASL_H__ */

src/scram.c

@@ -0,0 +1,185 @@
+/* scram.c
+ * strophe XMPP client library
+ *
+ * SCRAM-SHA1 helper functions according to RFC5802
+ * HMAC-SHA1 implementation according to RFC2104
+ *
+ * Copyright (C) 2013 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.
+ */
+
+/** @file
+ *  SCRAM-SHA1 helper functions.
+ */
+
+#include <assert.h>
+#include <string.h>
+
+#include "common.h"
+#include "sha1.h"
+#include "sha256.h"
+#include "sha512.h"
+#include "ostypes.h"
+
+#include "scram.h"
+
+#define HMAC_BLOCK_SIZE_MAX 128
+
+static const uint8_t ipad = 0x36;
+static const uint8_t opad = 0x5C;
+
+const struct hash_alg scram_sha1 = {
+    "SCRAM-SHA-1",
+    SASL_MASK_SCRAMSHA1,
+    SHA1_DIGEST_SIZE,
+    (void (*)(const uint8_t *, size_t, uint8_t *))crypto_SHA1,
+    (void (*)(void *))crypto_SHA1_Init,
+    (void (*)(void *, const uint8_t *, size_t))crypto_SHA1_Update,
+    (void (*)(void *, uint8_t *))crypto_SHA1_Final};
+
+const struct hash_alg scram_sha256 = {
+    "SCRAM-SHA-256",
+    SASL_MASK_SCRAMSHA256,
+    SHA256_DIGEST_SIZE,
+    (void (*)(const uint8_t *, size_t, uint8_t *))sha256_hash,
+    (void (*)(void *))sha256_init,
+    (void (*)(void *, const uint8_t *, size_t))sha256_process,
+    (void (*)(void *, uint8_t *))sha256_done};
+
+const struct hash_alg scram_sha512 = {
+    "SCRAM-SHA-512",
+    SASL_MASK_SCRAMSHA512,
+    SHA512_DIGEST_SIZE,
+    (void (*)(const uint8_t *, size_t, uint8_t *))sha512_hash,
+    (void (*)(void *))sha512_init,
+    (void (*)(void *, const uint8_t *, size_t))sha512_process,
+    (void (*)(void *, uint8_t *))sha512_done};
+
+union common_hash_ctx {
+    SHA1_CTX sha1;
+    sha256_context sha256;
+    sha512_context sha512;
+};
+
+static void crypto_HMAC(const struct hash_alg *alg,
+                        const uint8_t *key,
+                        size_t key_len,
+                        const uint8_t *text,
+                        size_t len,
+                        uint8_t *digest)
+{
+    uint8_t key_pad[HMAC_BLOCK_SIZE_MAX];
+    uint8_t key_ipad[HMAC_BLOCK_SIZE_MAX];
+    uint8_t key_opad[HMAC_BLOCK_SIZE_MAX];
+    uint8_t sha_digest[SCRAM_DIGEST_SIZE];
+    size_t blocksize;
+    size_t i;
+    union common_hash_ctx ctx;
+
+    assert(alg->digest_size <= HMAC_BLOCK_SIZE_MAX);
+    blocksize = alg->digest_size < 48 ? 64 : 128;
+
+    memset(key_pad, 0, blocksize);
+    if (key_len <= blocksize) {
+        memcpy(key_pad, key, key_len);
+    } else {
+        /* according to RFC2104 */
+        alg->hash(key, key_len, key_pad);
+    }
+
+    for (i = 0; i < blocksize; i++) {
+        key_ipad[i] = key_pad[i] ^ ipad;
+        key_opad[i] = key_pad[i] ^ opad;
+    }
+
+    alg->init((void *)&ctx);
+    alg->update((void *)&ctx, key_ipad, blocksize);
+    alg->update((void *)&ctx, text, len);
+    alg->final((void *)&ctx, sha_digest);
+
+    alg->init((void *)&ctx);
+    alg->update((void *)&ctx, key_opad, blocksize);
+    alg->update((void *)&ctx, sha_digest, alg->digest_size);
+    alg->final((void *)&ctx, digest);
+}
+
+static void SCRAM_Hi(const struct hash_alg *alg,
+                     const uint8_t *text,
+                     size_t len,
+                     const uint8_t *salt,
+                     size_t salt_len,
+                     uint32_t i,
+                     uint8_t *digest)
+{
+    size_t k;
+    uint32_t j;
+    uint8_t tmp[128];
+
+    static uint8_t int1[] = {0x0, 0x0, 0x0, 0x1};
+
+    /* assume salt + INT(1) isn't longer than sizeof(tmp) */
+    assert(salt_len <= sizeof(tmp) - sizeof(int1));
+
+    memset(digest, 0, alg->digest_size);
+    if (i == 0) {
+        return;
+    }
+
+    memcpy(tmp, salt, salt_len);
+    memcpy(&tmp[salt_len], int1, sizeof(int1));
+
+    /* 'text' for Hi is a 'key' for HMAC */
+    crypto_HMAC(alg, text, len, tmp, salt_len + sizeof(int1), digest);
+    memcpy(tmp, digest, alg->digest_size);
+
+    for (j = 1; j < i; j++) {
+        crypto_HMAC(alg, text, len, tmp, alg->digest_size, tmp);
+        for (k = 0; k < alg->digest_size; k++) {
+            digest[k] ^= tmp[k];
+        }
+    }
+}
+
+void SCRAM_ClientKey(const struct hash_alg *alg,
+                     const uint8_t *password,
+                     size_t len,
+                     const uint8_t *salt,
+                     size_t salt_len,
+                     uint32_t i,
+                     uint8_t *key)
+{
+    uint8_t salted[SCRAM_DIGEST_SIZE];
+
+    /* XXX: Normalize(password) is omitted */
+
+    SCRAM_Hi(alg, password, len, salt, salt_len, i, salted);
+    crypto_HMAC(alg, salted, alg->digest_size, (uint8_t *)"Client Key",
+                strlen("Client Key"), key);
+}
+
+void SCRAM_ClientSignature(const struct hash_alg *alg,
+                           const uint8_t *ClientKey,
+                           const uint8_t *AuthMessage,
+                           size_t len,
+                           uint8_t *sign)
+{
+    uint8_t stored[SCRAM_DIGEST_SIZE];
+
+    alg->hash(ClientKey, alg->digest_size, stored);
+    crypto_HMAC(alg, stored, alg->digest_size, AuthMessage, len, sign);
+}
+
+void SCRAM_ClientProof(const struct hash_alg *alg,
+                       const uint8_t *ClientKey,
+                       const uint8_t *ClientSignature,
+                       uint8_t *proof)
+{
+    size_t i;
+    for (i = 0; i < alg->digest_size; i++) {
+        proof[i] = ClientKey[i] ^ ClientSignature[i];
+    }
+}

src/scram.h

@@ -0,0 +1,59 @@
+/* scram.h
+ * strophe XMPP client library -- SCRAM helper functions
+ *
+ * Copyright (C) 2013 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.
+ */
+
+/** @file
+ *  SCRAM helper functions.
+ */
+
+#ifndef __LIBSTROPHE_SCRAM_H__
+#define __LIBSTROPHE_SCRAM_H__
+
+/* make sure the stdint.h types are available */
+#include "ostypes.h"
+
+/* Maximum possible digest size. Used for buffers allocation. */
+#include "sha512.h"
+#define SCRAM_DIGEST_SIZE SHA512_DIGEST_SIZE
+
+struct hash_alg {
+    const char *scram_name;
+    int mask;
+    size_t digest_size;
+    void (*hash)(const uint8_t *, size_t, uint8_t *);
+    void (*init)(void *);
+    void (*update)(void *, const uint8_t *, size_t);
+    void (*final)(void *, uint8_t *);
+};
+
+extern const struct hash_alg scram_sha1;
+extern const struct hash_alg scram_sha256;
+extern const struct hash_alg scram_sha512;
+
+void SCRAM_ClientKey(const struct hash_alg *alg,
+                     const uint8_t *password,
+                     size_t len,
+                     const uint8_t *salt,
+                     size_t salt_len,
+                     uint32_t i,
+                     uint8_t *key);
+
+void SCRAM_ClientSignature(const struct hash_alg *alg,
+                           const uint8_t *ClientKey,
+                           const uint8_t *AuthMessage,
+                           size_t len,
+                           uint8_t *sign);
+
+void SCRAM_ClientProof(const struct hash_alg *alg,
+                       const uint8_t *ClientKey,
+                       const uint8_t *ClientSignature,
+                       uint8_t *proof);
+
+#endif /* __LIBSTROPHE_SCRAM_H__ */

src/sha.h

@@ -0,0 +1,112 @@
+/* public api for steve reid's public domain SHA-1 implementation */
+/* this file is in the public domain */
+
+/** @file
+ *  SHA-1 hash API.
+ */
+
+#ifndef __LIBSTROPHE_SHA_H__
+#define __LIBSTROPHE_SHA_H__
+
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* make sure the stdint.h types are available */
+#include "ostypes.h"
+
+#if defined(__BIG_ENDIAN__) ||                                   \
+    (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \
+     __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+
+#define STORE32H(x, y)      \
+    do {                    \
+        uint32_t __t = (x); \
+        memcpy(y, &__t, 4); \
+    } while (0)
+
+#define LOAD32H(x, y)       \
+    do {                    \
+        memcpy(&(x), y, 4); \
+        x &= 0xFFFFFFFF;    \
+    } while (0)
+
+#define STORE64H(x, y)      \
+    do {                    \
+        uint64_t __t = (x); \
+        memcpy(y, &__t, 8); \
+    } while (0)
+
+#define LOAD64H(x, y)       \
+    do {                    \
+        memcpy(&(x), y, 8); \
+    } while (0)
+
+#elif defined(__LITTLE_ENDIAN__) ||                                 \
+    (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \
+     __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+
+#define STORE32H(x, y)                         \
+    do {                                       \
+        (y)[0] = (uint8_t)(((x) >> 24) & 255); \
+        (y)[1] = (uint8_t)(((x) >> 16) & 255); \
+        (y)[2] = (uint8_t)(((x) >> 8) & 255);  \
+        (y)[3] = (uint8_t)((x)&255);           \
+    } while (0)
+
+#define LOAD32H(x, y)                                                     \
+    do {                                                                  \
+        x = ((uint32_t)((y)[0] & 255) << 24) |                            \
+            ((uint32_t)((y)[1] & 255) << 16) |                            \
+            ((uint32_t)((y)[2] & 255) << 8) | ((uint32_t)((y)[3] & 255)); \
+    } while (0)
+
+#define STORE64H(x, y)                         \
+    do {                                       \
+        (y)[0] = (uint8_t)(((x) >> 56) & 255); \
+        (y)[1] = (uint8_t)(((x) >> 48) & 255); \
+        (y)[2] = (uint8_t)(((x) >> 40) & 255); \
+        (y)[3] = (uint8_t)(((x) >> 32) & 255); \
+        (y)[4] = (uint8_t)(((x) >> 24) & 255); \
+        (y)[5] = (uint8_t)(((x) >> 16) & 255); \
+        (y)[6] = (uint8_t)(((x) >> 8) & 255);  \
+        (y)[7] = (uint8_t)((x)&255);           \
+    } while (0)
+
+#define LOAD64H(x, y)                                                         \
+    do {                                                                      \
+        x = (((uint64_t)((y)[0] & 255)) << 56) |                              \
+            (((uint64_t)((y)[1] & 255)) << 48) |                              \
+            (((uint64_t)((y)[2] & 255)) << 40) |                              \
+            (((uint64_t)((y)[3] & 255)) << 32) |                              \
+            (((uint64_t)((y)[4] & 255)) << 24) |                              \
+            (((uint64_t)((y)[5] & 255)) << 16) |                              \
+            (((uint64_t)((y)[6] & 255)) << 8) | (((uint64_t)((y)[7] & 255))); \
+    } while (0)
+
+#else
+#error Unknown endianness not supported
+#endif
+
+#ifdef _MSC_VER
+#define CONST64(n) n##ui64
+#else
+#define CONST64(n) n##ULL
+#endif
+
+#define RORc(x, y)                                           \
+    (((((uint32_t)(x)&0xFFFFFFFFUL) >> (uint32_t)((y)&31)) | \
+      ((uint32_t)(x) << (uint32_t)((32 - ((y)&31)) & 31))) & \
+     0xFFFFFFFFUL)
+#define ROR64c(x, y)                                                       \
+    (((((x)&CONST64(0xFFFFFFFFFFFFFFFF)) >> ((uint64_t)(y)&CONST64(63))) | \
+      ((x) << (((uint64_t)64 - ((y)&63)) & 63))) &                         \
+     CONST64(0xFFFFFFFFFFFFFFFF))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __LIBSTROPHE_SHA_H__ */

src/sha1.c

@@ -8,16 +8,16 @@ By Steve Reid <sreid@sea-to-sky.net>
 100% Public Domain
 
 -----------------
-Modified 7/98 
+Modified 7/98
 By James H. Brown <jbrown@burgoyne.com>
 Still 100% Public Domain
 
 Corrected a problem which generated improper hash values on 16 bit machines
 Routine SHA1Update changed from
-	void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int
+    void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int
 len)
 to
-	void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned
+    void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned
 long len)
 
 The 'len' parameter was declared an int which works fine on 32 bit machines.
@@ -30,7 +30,7 @@ Since the file IO in main() reads 16K at a time, any file 8K or larger would
 be guaranteed to generate the wrong hash (e.g. Test Vector #3, a million
 "a"s).
 
-I also changed the declaration of variables i & j in SHA1Update to 
+I also changed the declaration of variables i & j in SHA1Update to
 unsigned long from unsigned int for the same reason.
 
 These changes should make no difference to any 32 bit implementations since
@@ -57,7 +57,7 @@ Still 100% public domain
 Modified 4/01
 By Saul Kravitz <Saul.Kravitz@celera.com>
 Still 100% PD
-Modified to run on Compaq Alpha hardware.  
+Modified to run on Compaq Alpha hardware.
 
 -----------------
 Modified 07/2002
@@ -70,92 +70,82 @@ use SHA1_ prefix for public api
 move public api to sha1.h
 */
 
-/*
-Test Vectors (from FIPS PUB 180-1)
-"abc"
-  A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
-"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
-  84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
-A million repetitions of "a"
-  34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
-*/
-
-/* #define SHA1HANDSOFF  */
-
-#include <stdio.h>
 #include <string.h>
 
-/* make sure the stdint.h types are available */
+#include "ostypes.h"
-#if defined(_MSC_VER) /* Microsoft Visual C++ */
-  typedef signed char             int8_t;
-  typedef short int               int16_t;
-  typedef int                     int32_t;
-  typedef __int64                 int64_t;
- 
-  typedef unsigned char             uint8_t;
-  typedef unsigned short int        uint16_t;
-  typedef unsigned int              uint32_t;
-  /* no uint64_t */
-#else
-#include <stdint.h>
-#endif
-
 #include "sha1.h"
 
-void SHA1_Transform(uint32_t state[5], const uint8_t buffer[64]);
+static uint32_t host_to_be(uint32_t i);
+static void SHA1_Transform(uint32_t state[5], const uint8_t buffer[64]);
 
 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
 
 /* blk0() and blk() perform the initial expand. */
 /* I got the idea of expanding during the round function from SSLeay */
-/* FIXME: can we do this in an endian-proof way? */
+#define blk0(i) (block->l[i] = host_to_be(block->l[i]))
-#ifdef WORDS_BIGENDIAN
+#define blk(i)                                                                 \
-#define blk0(i) block->l[i]
+    (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] ^ \
-#else
+                                block->l[(i + 2) & 15] ^ block->l[i & 15],     \
-#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
+                            1))
-    |(rol(block->l[i],8)&0x00FF00FF))
-#endif
-#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
-    ^block->l[(i+2)&15]^block->l[i&15],1))
 
 /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
-#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
+#define R0(v, w, x, y, z, i)                                     \
-#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
+    z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \
-#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
+    w = rol(w, 30);
-#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
+#define R1(v, w, x, y, z, i)                                    \
-#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
+    z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \
+    w = rol(w, 30);
+#define R2(v, w, x, y, z, i)                            \
+    z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); \
+    w = rol(w, 30);
+#define R3(v, w, x, y, z, i)                                          \
+    z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \
+    w = rol(w, 30);
+#define R4(v, w, x, y, z, i)                            \
+    z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \
+    w = rol(w, 30);
 
-
+static uint32_t host_to_be(uint32_t i)
-#ifdef VERBOSE  /* SAK */
+{
-void SHAPrintContext(SHA1_CTX *context, char *msg){
+#define le_to_be(i) ((rol((i), 24) & 0xFF00FF00) | (rol((i), 8) & 0x00FF00FF))
-  printf("%s (%d,%d) %x %x %x %x %x\n",
+#if defined(__BIG_ENDIAN__) ||                                   \
-	 msg,
+    (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \
-	 context->count[0], context->count[1], 
+     __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-	 context->state[0],
+    return i;
-	 context->state[1],
+#elif defined(__LITTLE_ENDIAN__) ||                                 \
-	 context->state[2],
+    (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \
-	 context->state[3],
+     __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
-	 context->state[4]);
+    return le_to_be(i);
+#else /* fallback to run-time check */
+    static const union {
+        uint32_t u;
+        unsigned char c;
+    } check = {1};
+    return check.c ? le_to_be(i) : i;
+#endif
+#undef le_to_be
+}
+
+static void *(*volatile SHA1_explicit_memset)(void *, int, size_t) = &memset;
+
+static void SHA1_cleanse(void *p, size_t len)
+{
+    SHA1_explicit_memset(p, 0, len);
 }
-#endif /* VERBOSE */
 
 /* Hash a single 512-bit block. This is the core of the algorithm. */
-void SHA1_Transform(uint32_t state[5], const uint8_t buffer[64])
+static void SHA1_Transform(uint32_t state[5], const uint8_t buffer[64])
 {
     uint32_t a, b, c, d, e;
     typedef union {
         uint8_t c[64];
         uint32_t l[16];
     } CHAR64LONG16;
-    CHAR64LONG16* block;
+    CHAR64LONG16 *block;
 
-#ifdef SHA1HANDSOFF
     static uint8_t workspace[64];
-    block = (CHAR64LONG16*)workspace;
+    block = (CHAR64LONG16 *)workspace;
     memcpy(block, buffer, 64);
-#else
-    block = (CHAR64LONG16*)buffer;
-#endif
 
     /* Copy context->state[] to working vars */
     a = state[0];
@@ -165,6 +155,7 @@ void SHA1_Transform(uint32_t state[5], const uint8_t buffer[64])
     e = state[4];
 
     /* 4 rounds of 20 operations each. Loop unrolled. */
+    /* clang-format off */
     R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
     R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
     R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
@@ -185,6 +176,7 @@ void SHA1_Transform(uint32_t state[5], const uint8_t buffer[64])
     R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
     R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
     R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
+    /* clang-format on */
 
     /* Add the working vars back into context.state[] */
     state[0] += a;
@@ -194,12 +186,15 @@ void SHA1_Transform(uint32_t state[5], const uint8_t buffer[64])
     state[4] += e;
 
     /* Wipe variables */
-    a = b = c = d = e = 0;
+    SHA1_cleanse(&a, sizeof(a));
+    SHA1_cleanse(&b, sizeof(b));
+    SHA1_cleanse(&c, sizeof(c));
+    SHA1_cleanse(&d, sizeof(d));
+    SHA1_cleanse(&e, sizeof(e));
 }
 
-
 /* SHA1Init - Initialize new context */
-void SHA1_Init(SHA1_CTX* context)
+void crypto_SHA1_Init(SHA1_CTX *context)
 {
     /* SHA1 initialization constants */
     context->state[0] = 0x67452301;
@@ -210,180 +205,64 @@ void SHA1_Init(SHA1_CTX* context)
     context->count[0] = context->count[1] = 0;
 }
 
-
 /* Run your data through this. */
-void SHA1_Update(SHA1_CTX* context, const uint8_t* data, const size_t len)
+void crypto_SHA1_Update(SHA1_CTX *context,
+                        const uint8_t *data,
+                        const size_t len)
 {
     size_t i, j;
 
-#ifdef VERBOSE
-    SHAPrintContext(context, "before");
-#endif
-
     j = (context->count[0] >> 3) & 63;
-    if ((context->count[0] += len << 3) < (len << 3)) context->count[1]++;
+    if ((context->count[0] += (uint32_t)len << 3) < ((uint32_t)len << 3))
-    context->count[1] += (len >> 29);
+        context->count[1]++;
+    context->count[1] += (uint32_t)(len >> 29);
     if ((j + len) > 63) {
-        memcpy(&context->buffer[j], data, (i = 64-j));
+        memcpy(&context->buffer[j], data, (i = 64 - j));
         SHA1_Transform(context->state, context->buffer);
-        for ( ; i + 63 < len; i += 64) {
+        for (; i + 63 < len; i += 64) {
             SHA1_Transform(context->state, data + i);
         }
         j = 0;
-    }
+    } else
-    else i = 0;
+        i = 0;
     memcpy(&context->buffer[j], &data[i], len - i);
-
-#ifdef VERBOSE
-    SHAPrintContext(context, "after ");
-#endif
 }
 
-
 /* Add padding and return the message digest. */
-void SHA1_Final(SHA1_CTX* context, uint8_t digest[SHA1_DIGEST_SIZE])
+void crypto_SHA1_Final(SHA1_CTX *context, uint8_t *digest)
 {
     uint32_t i;
-    uint8_t  finalcount[8];
+    uint8_t finalcount[8];
 
     for (i = 0; i < 8; i++) {
-        finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
+        finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)] >>
-         >> ((3-(i & 3)) * 8) ) & 255);  /* Endian independent */
+                                         ((3 - (i & 3)) * 8)) &
+                                        255); /* Endian independent */
     }
-    SHA1_Update(context, (uint8_t *)"\200", 1);
+    crypto_SHA1_Update(context, (uint8_t *)"\200", 1);
     while ((context->count[0] & 504) != 448) {
-        SHA1_Update(context, (uint8_t *)"\0", 1);
+        crypto_SHA1_Update(context, (uint8_t *)"\0", 1);
     }
-    SHA1_Update(context, finalcount, 8);  /* Should cause a SHA1_Transform() */
+    /* Should cause a SHA1_Transform() */
+    crypto_SHA1_Update(context, finalcount, 8);
     for (i = 0; i < SHA1_DIGEST_SIZE; i++) {
-        digest[i] = (uint8_t)
+        digest[i] =
-         ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
+            (uint8_t)((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
     }
-    
+
     /* Wipe variables */
-    i = 0;
+    SHA1_cleanse(context->buffer, 64);
-    memset(context->buffer, 0, 64);
+    SHA1_cleanse(context->state, 20);
-    memset(context->state, 0, 20);
+    SHA1_cleanse(context->count, 8);
-    memset(context->count, 0, 8);
+    SHA1_cleanse(finalcount, 8); /* SWR */
-    memset(finalcount, 0, 8);	/* SWR */
 
-#ifdef SHA1HANDSOFF  /* make SHA1Transform overwrite its own static vars */
     SHA1_Transform(context->state, context->buffer);
-#endif
 }
-  
-/*************************************************************/
 
-#if 0
+void crypto_SHA1(const uint8_t *data, size_t len, uint8_t *digest)
-int main(int argc, char** argv)
 {
-int i, j;
+    SHA1_CTX ctx;
-SHA1_CTX context;
+    crypto_SHA1_Init(&ctx);
-unsigned char digest[SHA1_DIGEST_SIZE], buffer[16384];
+    crypto_SHA1_Update(&ctx, data, len);
-FILE* file;
+    crypto_SHA1_Final(&ctx, digest);
-
-    if (argc > 2) {
-        puts("Public domain SHA-1 implementation - by Steve Reid <sreid@sea-to-sky.net>");
-        puts("Modified for 16 bit environments 7/98 - by James H. Brown <jbrown@burgoyne.com>");	/* JHB */
-        puts("Produces the SHA-1 hash of a file, or stdin if no file is specified.");
-        return(0);
-    }
-    if (argc < 2) {
-        file = stdin;
-    }
-    else {
-        if (!(file = fopen(argv[1], "rb"))) {
-            fputs("Unable to open file.", stderr);
-            return(-1);
-        }
-    } 
-    SHA1_Init(&context);
-    while (!feof(file)) {  /* note: what if ferror(file) */
-        i = fread(buffer, 1, 16384, file);
-        SHA1_Update(&context, buffer, i);
-    }
-    SHA1_Final(&context, digest);
-    fclose(file);
-    for (i = 0; i < SHA1_DIGEST_SIZE/4; i++) {
-        for (j = 0; j < 4; j++) {
-            printf("%02X", digest[i*4+j]);
-        }
-        putchar(' ');
-    }
-    putchar('\n');
-    return(0);	/* JHB */
 }
-#endif
-
-/* self test */
-
-#ifdef TEST
-
-static char *test_data[] = {
-    "abc",
-    "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
-    "A million repetitions of 'a'"};
-static char *test_results[] = {
-    "A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D",
-    "84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1",
-    "34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F"};
-    
-
-void digest_to_hex(const uint8_t digest[SHA1_DIGEST_SIZE], char *output)
-{
-    int i,j;
-    char *c = output;
-    
-    for (i = 0; i < SHA1_DIGEST_SIZE/4; i++) {
-        for (j = 0; j < 4; j++) {
-            sprintf(c,"%02X", digest[i*4+j]);
-            c += 2;
-        }
-        sprintf(c, " ");
-        c += 1;
-    }
-    *(c - 1) = '\0';
-}
-    
-int main(int argc, char** argv)
-{
-    int k;
-    SHA1_CTX context;
-    uint8_t digest[20];
-    char output[80];
-
-    fprintf(stdout, "verifying SHA-1 implementation... ");
-    
-    for (k = 0; k < 2; k++){ 
-        SHA1_Init(&context);
-        SHA1_Update(&context, (uint8_t*)test_data[k], strlen(test_data[k]));
-        SHA1_Final(&context, digest);
-	digest_to_hex(digest, output);
-
-        if (strcmp(output, test_results[k])) {
-            fprintf(stdout, "FAIL\n");
-            fprintf(stderr,"* hash of \"%s\" incorrect:\n", test_data[k]);
-            fprintf(stderr,"\t%s returned\n", output);
-            fprintf(stderr,"\t%s is correct\n", test_results[k]);
-            return (1);
-        }    
-    }
-    /* million 'a' vector we feed separately */
-    SHA1_Init(&context);
-    for (k = 0; k < 1000000; k++)
-        SHA1_Update(&context, (uint8_t*)"a", 1);
-    SHA1_Final(&context, digest);
-    digest_to_hex(digest, output);
-    if (strcmp(output, test_results[2])) {
-        fprintf(stdout, "FAIL\n");
-        fprintf(stderr,"* hash of \"%s\" incorrect:\n", test_data[2]);
-        fprintf(stderr,"\t%s returned\n", output);
-        fprintf(stderr,"\t%s is correct\n", test_results[2]);
-        return (1);
-    }
-
-    /* success */
-    fprintf(stdout, "ok\n");
-    return(0);
-}
-#endif /* TEST */

src/sha1.h

@@ -5,27 +5,33 @@
  *  SHA-1 hash API.
  */
 
-#ifndef __SHA1_H
+#ifndef __LIBSTROPHE_SHA1_H__
-#define __SHA1_H
+#define __LIBSTROPHE_SHA1_H__
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+/* make sure the stdint.h types are available */
+#include "ostypes.h"
+
 typedef struct {
     uint32_t state[5];
     uint32_t count[2];
-    uint8_t  buffer[64];
+    uint8_t buffer[64];
 } SHA1_CTX;
 
 #define SHA1_DIGEST_SIZE 20
 
-void SHA1_Init(SHA1_CTX* context);
+void crypto_SHA1_Init(SHA1_CTX *context);
-void SHA1_Update(SHA1_CTX* context, const uint8_t* data, const size_t len);
+void crypto_SHA1_Update(SHA1_CTX *context,
-void SHA1_Final(SHA1_CTX* context, uint8_t digest[SHA1_DIGEST_SIZE]);
+                        const uint8_t *data,
+                        const size_t len);
+void crypto_SHA1_Final(SHA1_CTX *context, uint8_t *digest);
+void crypto_SHA1(const uint8_t *data, size_t len, uint8_t *digest);
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif /* __SHA1_H */
+#endif /* __LIBSTROPHE_SHA1_H__ */

src/sha256.c

@@ -0,0 +1,210 @@
+/*
+ * Code originally from LibTomCrypt -- Licensed under the Public Domain/WTFPL2.0
+ */
+
+#include "sha256.h"
+#include "sha.h"
+
+/* Various logical functions */
+#define Ch(x, y, z) (z ^ (x & (y ^ z)))
+#define Maj(x, y, z) (((x | y) & z) | (x & y))
+#define S(x, n) RORc((x), (n))
+#define R(x, n) (((x)&0xFFFFFFFFUL) >> (n))
+#define Sigma0(x) (S(x, 2) ^ S(x, 13) ^ S(x, 22))
+#define Sigma1(x) (S(x, 6) ^ S(x, 11) ^ S(x, 25))
+#define Gamma0(x) (S(x, 7) ^ S(x, 18) ^ R(x, 3))
+#define Gamma1(x) (S(x, 17) ^ S(x, 19) ^ R(x, 10))
+
+static void sha256_compress(sha256_context *md, const uint8_t *buf)
+{
+    uint32_t S[8], W[64], t0, t1;
+    int i;
+
+    /* copy state into S */
+    for (i = 0; i < 8; i++) {
+        S[i] = md->state[i];
+    }
+
+    /* copy the state into 512-bits into W[0..15] */
+    for (i = 0; i < 16; i++) {
+        LOAD32H(W[i], buf + (4 * i));
+    }
+
+    /* fill W[16..63] */
+    for (i = 16; i < 64; i++) {
+        W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16];
+    }
+
+    /* Compress */
+#define RND(a, b, c, d, e, f, g, h, i, ki)        \
+    t0 = h + Sigma1(e) + Ch(e, f, g) + ki + W[i]; \
+    t1 = Sigma0(a) + Maj(a, b, c);                \
+    d += t0;                                      \
+    h = t0 + t1;
+
+    RND(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], 0, 0x428a2f98);
+    RND(S[7], S[0], S[1], S[2], S[3], S[4], S[5], S[6], 1, 0x71374491);
+    RND(S[6], S[7], S[0], S[1], S[2], S[3], S[4], S[5], 2, 0xb5c0fbcf);
+    RND(S[5], S[6], S[7], S[0], S[1], S[2], S[3], S[4], 3, 0xe9b5dba5);
+    RND(S[4], S[5], S[6], S[7], S[0], S[1], S[2], S[3], 4, 0x3956c25b);
+    RND(S[3], S[4], S[5], S[6], S[7], S[0], S[1], S[2], 5, 0x59f111f1);
+    RND(S[2], S[3], S[4], S[5], S[6], S[7], S[0], S[1], 6, 0x923f82a4);
+    RND(S[1], S[2], S[3], S[4], S[5], S[6], S[7], S[0], 7, 0xab1c5ed5);
+    RND(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], 8, 0xd807aa98);
+    RND(S[7], S[0], S[1], S[2], S[3], S[4], S[5], S[6], 9, 0x12835b01);
+    RND(S[6], S[7], S[0], S[1], S[2], S[3], S[4], S[5], 10, 0x243185be);
+    RND(S[5], S[6], S[7], S[0], S[1], S[2], S[3], S[4], 11, 0x550c7dc3);
+    RND(S[4], S[5], S[6], S[7], S[0], S[1], S[2], S[3], 12, 0x72be5d74);
+    RND(S[3], S[4], S[5], S[6], S[7], S[0], S[1], S[2], 13, 0x80deb1fe);
+    RND(S[2], S[3], S[4], S[5], S[6], S[7], S[0], S[1], 14, 0x9bdc06a7);
+    RND(S[1], S[2], S[3], S[4], S[5], S[6], S[7], S[0], 15, 0xc19bf174);
+    RND(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], 16, 0xe49b69c1);
+    RND(S[7], S[0], S[1], S[2], S[3], S[4], S[5], S[6], 17, 0xefbe4786);
+    RND(S[6], S[7], S[0], S[1], S[2], S[3], S[4], S[5], 18, 0x0fc19dc6);
+    RND(S[5], S[6], S[7], S[0], S[1], S[2], S[3], S[4], 19, 0x240ca1cc);
+    RND(S[4], S[5], S[6], S[7], S[0], S[1], S[2], S[3], 20, 0x2de92c6f);
+    RND(S[3], S[4], S[5], S[6], S[7], S[0], S[1], S[2], 21, 0x4a7484aa);
+    RND(S[2], S[3], S[4], S[5], S[6], S[7], S[0], S[1], 22, 0x5cb0a9dc);
+    RND(S[1], S[2], S[3], S[4], S[5], S[6], S[7], S[0], 23, 0x76f988da);
+    RND(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], 24, 0x983e5152);
+    RND(S[7], S[0], S[1], S[2], S[3], S[4], S[5], S[6], 25, 0xa831c66d);
+    RND(S[6], S[7], S[0], S[1], S[2], S[3], S[4], S[5], 26, 0xb00327c8);
+    RND(S[5], S[6], S[7], S[0], S[1], S[2], S[3], S[4], 27, 0xbf597fc7);
+    RND(S[4], S[5], S[6], S[7], S[0], S[1], S[2], S[3], 28, 0xc6e00bf3);
+    RND(S[3], S[4], S[5], S[6], S[7], S[0], S[1], S[2], 29, 0xd5a79147);
+    RND(S[2], S[3], S[4], S[5], S[6], S[7], S[0], S[1], 30, 0x06ca6351);
+    RND(S[1], S[2], S[3], S[4], S[5], S[6], S[7], S[0], 31, 0x14292967);
+    RND(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], 32, 0x27b70a85);
+    RND(S[7], S[0], S[1], S[2], S[3], S[4], S[5], S[6], 33, 0x2e1b2138);
+    RND(S[6], S[7], S[0], S[1], S[2], S[3], S[4], S[5], 34, 0x4d2c6dfc);
+    RND(S[5], S[6], S[7], S[0], S[1], S[2], S[3], S[4], 35, 0x53380d13);
+    RND(S[4], S[5], S[6], S[7], S[0], S[1], S[2], S[3], 36, 0x650a7354);
+    RND(S[3], S[4], S[5], S[6], S[7], S[0], S[1], S[2], 37, 0x766a0abb);
+    RND(S[2], S[3], S[4], S[5], S[6], S[7], S[0], S[1], 38, 0x81c2c92e);
+    RND(S[1], S[2], S[3], S[4], S[5], S[6], S[7], S[0], 39, 0x92722c85);
+    RND(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], 40, 0xa2bfe8a1);
+    RND(S[7], S[0], S[1], S[2], S[3], S[4], S[5], S[6], 41, 0xa81a664b);
+    RND(S[6], S[7], S[0], S[1], S[2], S[3], S[4], S[5], 42, 0xc24b8b70);
+    RND(S[5], S[6], S[7], S[0], S[1], S[2], S[3], S[4], 43, 0xc76c51a3);
+    RND(S[4], S[5], S[6], S[7], S[0], S[1], S[2], S[3], 44, 0xd192e819);
+    RND(S[3], S[4], S[5], S[6], S[7], S[0], S[1], S[2], 45, 0xd6990624);
+    RND(S[2], S[3], S[4], S[5], S[6], S[7], S[0], S[1], 46, 0xf40e3585);
+    RND(S[1], S[2], S[3], S[4], S[5], S[6], S[7], S[0], 47, 0x106aa070);
+    RND(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], 48, 0x19a4c116);
+    RND(S[7], S[0], S[1], S[2], S[3], S[4], S[5], S[6], 49, 0x1e376c08);
+    RND(S[6], S[7], S[0], S[1], S[2], S[3], S[4], S[5], 50, 0x2748774c);
+    RND(S[5], S[6], S[7], S[0], S[1], S[2], S[3], S[4], 51, 0x34b0bcb5);
+    RND(S[4], S[5], S[6], S[7], S[0], S[1], S[2], S[3], 52, 0x391c0cb3);
+    RND(S[3], S[4], S[5], S[6], S[7], S[0], S[1], S[2], 53, 0x4ed8aa4a);
+    RND(S[2], S[3], S[4], S[5], S[6], S[7], S[0], S[1], 54, 0x5b9cca4f);
+    RND(S[1], S[2], S[3], S[4], S[5], S[6], S[7], S[0], 55, 0x682e6ff3);
+    RND(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], 56, 0x748f82ee);
+    RND(S[7], S[0], S[1], S[2], S[3], S[4], S[5], S[6], 57, 0x78a5636f);
+    RND(S[6], S[7], S[0], S[1], S[2], S[3], S[4], S[5], 58, 0x84c87814);
+    RND(S[5], S[6], S[7], S[0], S[1], S[2], S[3], S[4], 59, 0x8cc70208);
+    RND(S[4], S[5], S[6], S[7], S[0], S[1], S[2], S[3], 60, 0x90befffa);
+    RND(S[3], S[4], S[5], S[6], S[7], S[0], S[1], S[2], 61, 0xa4506ceb);
+    RND(S[2], S[3], S[4], S[5], S[6], S[7], S[0], S[1], 62, 0xbef9a3f7);
+    RND(S[1], S[2], S[3], S[4], S[5], S[6], S[7], S[0], 63, 0xc67178f2);
+
+#undef RND
+
+    /* feedback */
+    for (i = 0; i < 8; i++) {
+        md->state[i] = md->state[i] + S[i];
+    }
+}
+
+void sha256_init(sha256_context *md)
+{
+    md->curlen = 0;
+    md->length = 0;
+    md->state[0] = 0x6A09E667UL;
+    md->state[1] = 0xBB67AE85UL;
+    md->state[2] = 0x3C6EF372UL;
+    md->state[3] = 0xA54FF53AUL;
+    md->state[4] = 0x510E527FUL;
+    md->state[5] = 0x9B05688CUL;
+    md->state[6] = 0x1F83D9ABUL;
+    md->state[7] = 0x5BE0CD19UL;
+}
+
+void sha256_process(sha256_context *md, const uint8_t *in, size_t inlen)
+{
+    size_t n;
+    if (md->curlen > sizeof(md->buf)) {
+        return;
+    }
+    if ((md->length + inlen) < md->length) {
+        return;
+    }
+    while (inlen > 0) {
+        if (md->curlen == 0 && inlen >= 64) {
+            sha256_compress(md, in);
+            md->length += 64 * 8;
+            in += 64;
+            inlen -= 64;
+        } else {
+            n = (((inlen) < ((64 - md->curlen))) ? (inlen)
+                                                 : ((64 - md->curlen)));
+            memcpy(md->buf + md->curlen, in, (size_t)n);
+            md->curlen += n;
+            in += n;
+            inlen -= n;
+            if (md->curlen == 64) {
+                sha256_compress(md, md->buf);
+                md->length += 8 * 64;
+                md->curlen = 0;
+            }
+        }
+    }
+}
+
+void sha256_done(sha256_context *md, uint8_t *out)
+{
+    int i;
+
+    if (md->curlen >= sizeof(md->buf)) {
+        return;
+    }
+
+    /* increase the length of the message */
+    md->length += md->curlen * 8;
+
+    /* append the '1' bit */
+    md->buf[md->curlen++] = (uint8_t)0x80;
+
+    /* if the length is currently above 56 bytes we append zeros
+     * then compress.  Then we can fall back to padding zeros and length
+     * encoding like normal.
+     */
+    if (md->curlen > 56) {
+        while (md->curlen < 64) {
+            md->buf[md->curlen++] = (uint8_t)0;
+        }
+        sha256_compress(md, md->buf);
+        md->curlen = 0;
+    }
+
+    /* pad upto 56 bytes of zeroes */
+    while (md->curlen < 56) {
+        md->buf[md->curlen++] = (uint8_t)0;
+    }
+
+    /* store length */
+    STORE64H(md->length, md->buf + 56);
+    sha256_compress(md, md->buf);
+
+    /* copy output */
+    for (i = 0; i < 8; i++) {
+        STORE32H(md->state[i], out + (4 * i));
+    }
+}
+
+void sha256_hash(const uint8_t *data, size_t len, uint8_t *digest)
+{
+    sha256_context md;
+    sha256_init(&md);
+    sha256_process(&md, data, len);
+    sha256_done(&md, digest);
+}

src/sha256.h

@@ -0,0 +1,34 @@
+/* public api for LibTomCrypt SHA-256 implementation */
+
+/** @file
+ *  SHA-256 hash API.
+ */
+
+#ifndef __LIBSTROPHE_SHA256_H__
+#define __LIBSTROPHE_SHA256_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* make sure the stdint.h types are available */
+#include "ostypes.h"
+
+typedef struct {
+    uint64_t length;
+    uint32_t state[8], curlen;
+    uint8_t buf[64];
+} sha256_context;
+
+#define SHA256_DIGEST_SIZE 32
+
+void sha256_init(sha256_context *md);
+void sha256_process(sha256_context *md, const uint8_t *in, size_t inlen);
+void sha256_done(sha256_context *md, uint8_t *out);
+
+void sha256_hash(const uint8_t *data, size_t len, uint8_t *digest);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __LIBSTROPHE_SHA256_H__ */

src/sha512.c

@@ -0,0 +1,201 @@
+/*
+ * Code originally from LibTomCrypt -- Licensed under the Public Domain/WTFPL2.0
+ */
+
+#include "sha512.h"
+#include "sha.h"
+
+/* the K array */
+static const uint64_t K[80] = {
+    CONST64(0x428a2f98d728ae22), CONST64(0x7137449123ef65cd),
+    CONST64(0xb5c0fbcfec4d3b2f), CONST64(0xe9b5dba58189dbbc),
+    CONST64(0x3956c25bf348b538), CONST64(0x59f111f1b605d019),
+    CONST64(0x923f82a4af194f9b), CONST64(0xab1c5ed5da6d8118),
+    CONST64(0xd807aa98a3030242), CONST64(0x12835b0145706fbe),
+    CONST64(0x243185be4ee4b28c), CONST64(0x550c7dc3d5ffb4e2),
+    CONST64(0x72be5d74f27b896f), CONST64(0x80deb1fe3b1696b1),
+    CONST64(0x9bdc06a725c71235), CONST64(0xc19bf174cf692694),
+    CONST64(0xe49b69c19ef14ad2), CONST64(0xefbe4786384f25e3),
+    CONST64(0x0fc19dc68b8cd5b5), CONST64(0x240ca1cc77ac9c65),
+    CONST64(0x2de92c6f592b0275), CONST64(0x4a7484aa6ea6e483),
+    CONST64(0x5cb0a9dcbd41fbd4), CONST64(0x76f988da831153b5),
+    CONST64(0x983e5152ee66dfab), CONST64(0xa831c66d2db43210),
+    CONST64(0xb00327c898fb213f), CONST64(0xbf597fc7beef0ee4),
+    CONST64(0xc6e00bf33da88fc2), CONST64(0xd5a79147930aa725),
+    CONST64(0x06ca6351e003826f), CONST64(0x142929670a0e6e70),
+    CONST64(0x27b70a8546d22ffc), CONST64(0x2e1b21385c26c926),
+    CONST64(0x4d2c6dfc5ac42aed), CONST64(0x53380d139d95b3df),
+    CONST64(0x650a73548baf63de), CONST64(0x766a0abb3c77b2a8),
+    CONST64(0x81c2c92e47edaee6), CONST64(0x92722c851482353b),
+    CONST64(0xa2bfe8a14cf10364), CONST64(0xa81a664bbc423001),
+    CONST64(0xc24b8b70d0f89791), CONST64(0xc76c51a30654be30),
+    CONST64(0xd192e819d6ef5218), CONST64(0xd69906245565a910),
+    CONST64(0xf40e35855771202a), CONST64(0x106aa07032bbd1b8),
+    CONST64(0x19a4c116b8d2d0c8), CONST64(0x1e376c085141ab53),
+    CONST64(0x2748774cdf8eeb99), CONST64(0x34b0bcb5e19b48a8),
+    CONST64(0x391c0cb3c5c95a63), CONST64(0x4ed8aa4ae3418acb),
+    CONST64(0x5b9cca4f7763e373), CONST64(0x682e6ff3d6b2b8a3),
+    CONST64(0x748f82ee5defb2fc), CONST64(0x78a5636f43172f60),
+    CONST64(0x84c87814a1f0ab72), CONST64(0x8cc702081a6439ec),
+    CONST64(0x90befffa23631e28), CONST64(0xa4506cebde82bde9),
+    CONST64(0xbef9a3f7b2c67915), CONST64(0xc67178f2e372532b),
+    CONST64(0xca273eceea26619c), CONST64(0xd186b8c721c0c207),
+    CONST64(0xeada7dd6cde0eb1e), CONST64(0xf57d4f7fee6ed178),
+    CONST64(0x06f067aa72176fba), CONST64(0x0a637dc5a2c898a6),
+    CONST64(0x113f9804bef90dae), CONST64(0x1b710b35131c471b),
+    CONST64(0x28db77f523047d84), CONST64(0x32caab7b40c72493),
+    CONST64(0x3c9ebe0a15c9bebc), CONST64(0x431d67c49c100d4c),
+    CONST64(0x4cc5d4becb3e42b6), CONST64(0x597f299cfc657e2a),
+    CONST64(0x5fcb6fab3ad6faec), CONST64(0x6c44198c4a475817)};
+
+/* Various logical functions */
+#define Ch(x, y, z) (z ^ (x & (y ^ z)))
+#define Maj(x, y, z) (((x | y) & z) | (x & y))
+#define S(x, n) ROR64c(x, n)
+#define R(x, n) (((x)&CONST64(0xFFFFFFFFFFFFFFFF)) >> ((uint64_t)n))
+#define Sigma0(x) (S(x, 28) ^ S(x, 34) ^ S(x, 39))
+#define Sigma1(x) (S(x, 14) ^ S(x, 18) ^ S(x, 41))
+#define Gamma0(x) (S(x, 1) ^ S(x, 8) ^ R(x, 7))
+#define Gamma1(x) (S(x, 19) ^ S(x, 61) ^ R(x, 6))
+
+/* compress 1024-bits */
+static void sha512_compress(sha512_context *md, const uint8_t *buf)
+{
+    uint64_t S[8], W[80], t0, t1;
+    int i;
+
+    /* copy state into S */
+    for (i = 0; i < 8; i++) {
+        S[i] = md->state[i];
+    }
+
+    /* copy the state into 1024-bits into W[0..15] */
+    for (i = 0; i < 16; i++) {
+        LOAD64H(W[i], buf + (8 * i));
+    }
+
+    /* fill W[16..79] */
+    for (i = 16; i < 80; i++) {
+        W[i] = Gamma1(W[i - 2]) + W[i - 7] + Gamma0(W[i - 15]) + W[i - 16];
+    }
+
+    /* Compress */
+#define RND(a, b, c, d, e, f, g, h, i)              \
+    t0 = h + Sigma1(e) + Ch(e, f, g) + K[i] + W[i]; \
+    t1 = Sigma0(a) + Maj(a, b, c);                  \
+    d += t0;                                        \
+    h = t0 + t1;
+
+    for (i = 0; i < 80; i += 8) {
+        RND(S[0], S[1], S[2], S[3], S[4], S[5], S[6], S[7], i + 0);
+        RND(S[7], S[0], S[1], S[2], S[3], S[4], S[5], S[6], i + 1);
+        RND(S[6], S[7], S[0], S[1], S[2], S[3], S[4], S[5], i + 2);
+        RND(S[5], S[6], S[7], S[0], S[1], S[2], S[3], S[4], i + 3);
+        RND(S[4], S[5], S[6], S[7], S[0], S[1], S[2], S[3], i + 4);
+        RND(S[3], S[4], S[5], S[6], S[7], S[0], S[1], S[2], i + 5);
+        RND(S[2], S[3], S[4], S[5], S[6], S[7], S[0], S[1], i + 6);
+        RND(S[1], S[2], S[3], S[4], S[5], S[6], S[7], S[0], i + 7);
+    }
+
+    /* feedback */
+    for (i = 0; i < 8; i++) {
+        md->state[i] = md->state[i] + S[i];
+    }
+}
+
+void sha512_init(sha512_context *md)
+{
+    md->curlen = 0;
+    md->length = 0;
+    md->state[0] = CONST64(0x6a09e667f3bcc908);
+    md->state[1] = CONST64(0xbb67ae8584caa73b);
+    md->state[2] = CONST64(0x3c6ef372fe94f82b);
+    md->state[3] = CONST64(0xa54ff53a5f1d36f1);
+    md->state[4] = CONST64(0x510e527fade682d1);
+    md->state[5] = CONST64(0x9b05688c2b3e6c1f);
+    md->state[6] = CONST64(0x1f83d9abfb41bd6b);
+    md->state[7] = CONST64(0x5be0cd19137e2179);
+}
+
+void sha512_process(sha512_context *md, const uint8_t *in, size_t inlen)
+{
+    size_t n;
+    if (md->curlen > sizeof(md->buf)) {
+        return;
+    }
+    if ((md->length + inlen) < md->length) {
+        return;
+    }
+    while (inlen > 0) {
+        if (md->curlen == 0 && inlen >= 128) {
+            sha512_compress(md, in);
+            md->length += 128 * 8;
+            in += 128;
+            inlen -= 128;
+        } else {
+            n = (((inlen) < ((128u - md->curlen))) ? (inlen)
+                                                   : ((128u - md->curlen)));
+            memcpy(md->buf + md->curlen, in, (size_t)n);
+            md->curlen += n;
+            in += n;
+            inlen -= n;
+            if (md->curlen == 128) {
+                sha512_compress(md, md->buf);
+                md->length += 8 * 128;
+                md->curlen = 0;
+            }
+        }
+    }
+}
+
+void sha512_done(sha512_context *md, uint8_t *out)
+{
+    int i;
+
+    if (md->curlen >= sizeof(md->buf)) {
+        return;
+    }
+
+    /* increase the length of the message */
+    md->length += md->curlen * CONST64(8);
+
+    /* append the '1' bit */
+    md->buf[md->curlen++] = (uint8_t)0x80;
+
+    /* if the length is currently above 112 bytes we append zeros
+     * then compress.  Then we can fall back to padding zeros and length
+     * encoding like normal.
+     */
+    if (md->curlen > 112) {
+        while (md->curlen < 128) {
+            md->buf[md->curlen++] = (uint8_t)0;
+        }
+        sha512_compress(md, md->buf);
+        md->curlen = 0;
+    }
+
+    /* pad upto 120 bytes of zeroes
+     * note: that from 112 to 120 is the 64 MSB of the length.  We assume that
+     * you won't hash > 2^64 bits of data... :-)
+     */
+    while (md->curlen < 120) {
+        md->buf[md->curlen++] = (uint8_t)0;
+    }
+
+    /* store length */
+    STORE64H(md->length, md->buf + 120);
+    sha512_compress(md, md->buf);
+
+    /* copy output */
+    for (i = 0; i < 8; i++) {
+        STORE64H(md->state[i], out + (8 * i));
+    }
+}
+
+void sha512_hash(const uint8_t *data, size_t len, uint8_t *digest)
+{
+    sha512_context md;
+    sha512_init(&md);
+    sha512_process(&md, data, len);
+    sha512_done(&md, digest);
+}

src/sha512.h

@@ -0,0 +1,34 @@
+/* public api for LibTomCrypt SHA-512 implementation */
+
+/** @file
+ *  SHA-512 hash API.
+ */
+
+#ifndef __LIBSTROPHE_SHA512_H__
+#define __LIBSTROPHE_SHA512_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* make sure the stdint.h types are available */
+#include "ostypes.h"
+
+typedef struct {
+    uint64_t length, state[8];
+    uint8_t curlen;
+    uint8_t buf[128];
+} sha512_context;
+
+#define SHA512_DIGEST_SIZE 64
+
+void sha512_init(sha512_context *cc);
+void sha512_process(sha512_context *cc, const uint8_t *data, size_t len);
+void sha512_done(sha512_context *cc, uint8_t *dst);
+
+void sha512_hash(const uint8_t *data, size_t len, uint8_t *digest);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __LIBSTROPHE_SHA512_H__ */

src/snprintf.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright Patrick Powell 1995
+ * This code is based on code written by Patrick Powell (papowell@astart.com)
+ * It may be used for any purpose as long as this notice remains intact
+ * on all source code distributions
+ */
+
+/** @file
+ *  Compatibility wrappers for OSes lacking snprintf(3) and/or vsnprintf(3).
+ */
+
+#ifndef __LIBSTROPHE_SNPRINTF_H__
+#define __LIBSTROPHE_SNPRINTF_H__
+
+#include <stddef.h>
+#include <stdarg.h>
+
+#if defined(HAVE_SNPRINTF) || defined(HAVE_VSNPRINTF)
+#include <stdio.h>
+#endif
+
+#ifdef HAVE_SNPRINTF
+#define xmpp_snprintf snprintf
+#else
+int xmpp_snprintf(char *str, size_t count, const char *fmt, ...);
+#endif
+
+#ifdef HAVE_VSNPRINTF
+#define xmpp_vsnprintf vsnprintf
+#else
+int xmpp_vsnprintf(char *str, size_t count, const char *fmt, va_list arg);
+#endif
+
+#endif /* __LIBSTROPHE_SNPRINTF_H__ */

src/sock.c

@@ -1,15 +1,12 @@
 /* sock.c
 ** strophe XMPP client library -- socket abstraction 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.
 **
-**  This software is distributed under license and may not be copied,
+** This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -24,24 +21,20 @@
 #ifdef _WIN32
 #include <winsock2.h>
 #include <ws2tcpip.h>
-#include <windns.h>
+#include <iphlpapi.h>
-#include <Iphlpapi.h>
+#include <mstcpip.h> /* tcp_keepalive */
-#define snprintf _snprintf
 #else
 #include <errno.h>
 #include <unistd.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
+#include <netinet/tcp.h>
 #include <netdb.h>
 #include <fcntl.h>
-#include <arpa/nameser.h>
-#ifdef HAVE_ARPA_NAMESER_COMPAT_H
-#include <arpa/nameser_compat.h>
-#endif
-#include <resolv.h>
 #endif
 
 #include "sock.h"
+#include "snprintf.h"
 
 void sock_initialize(void)
 {
@@ -72,49 +65,95 @@ static int _in_progress(int error)
 #ifdef _WIN32
     return (error == WSAEWOULDBLOCK || error == WSAEINPROGRESS);
 #else
-    return (errno == EINPROGRESS);
+    return (error == EINPROGRESS);
 #endif
 }
 
-sock_t sock_connect(const char * const host, const unsigned int port)
+sock_t sock_connect(const char *const host, const unsigned short port)
 {
     sock_t sock;
     char service[6];
     struct addrinfo *res, *ainfo, hints;
     int err;
-    
-    sock = -1;
 
-    snprintf(service, 6, "%u", port);
+    xmpp_snprintf(service, 6, "%u", port);
 
     memset(&hints, 0, sizeof(struct addrinfo));
-    hints.ai_family = AF_INET;
+    hints.ai_family = AF_UNSPEC;
+#ifdef AI_ADDRCONFIG
+    hints.ai_flags = AI_ADDRCONFIG;
+#endif /* AI_ADDRCONFIG */
     hints.ai_protocol = IPPROTO_TCP;
     hints.ai_socktype = SOCK_STREAM;
 
-    if ((err = getaddrinfo(host, service, &hints, &res)) != 0)
+    err = getaddrinfo(host, service, &hints, &res);
-	return -1;
+    if (err != 0)
+        return -1;
 
-    ainfo = res;
+    for (ainfo = res; ainfo != NULL; ainfo = ainfo->ai_next) {
-    while (ainfo) {
+        sock = socket(ainfo->ai_family, ainfo->ai_socktype, ainfo->ai_protocol);
-	if ((sock = socket(ainfo->ai_family, ainfo->ai_socktype, 
+        if (sock < 0)
-		   ainfo->ai_protocol)) >= 0) {
+            continue;
-	    sock_set_nonblocking(sock);
 
-	    err = connect(sock, ainfo->ai_addr, ainfo->ai_addrlen);
+        err = sock_set_nonblocking(sock);
-
+        if (err == 0) {
-	    if ((err == 0) || (err < 0 && _in_progress(sock_error())))
+            err = connect(sock, ainfo->ai_addr, ainfo->ai_addrlen);
-		break;
+            if (err == 0 || _in_progress(sock_error()))
-	}
+                break;
-
+        }
-	ainfo = ainfo->ai_next;
+        sock_close(sock);
     }
-
+    freeaddrinfo(res);
-    if (res) freeaddrinfo(res);
+    sock = ainfo == NULL ? -1 : sock;
 
     return sock;
 }
 
+int sock_set_keepalive(const sock_t sock, int timeout, int interval)
+{
+    int ret;
+    int optval = (timeout && interval) ? 1 : 0;
+
+    /* This function doesn't change maximum number of keepalive probes */
+
+#ifdef _WIN32
+    struct tcp_keepalive ka;
+    DWORD dw = 0;
+
+    ka.onoff = optval;
+    ka.keepalivetime = timeout * 1000;
+    ka.keepaliveinterval = interval * 1000;
+    ret = WSAIoctl(sock, SIO_KEEPALIVE_VALS, &ka, sizeof(ka), NULL, 0, &dw,
+                   NULL, NULL);
+#else
+    ret = setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, &optval, sizeof(optval));
+    if (ret < 0)
+        return ret;
+
+    if (optval) {
+#ifdef TCP_KEEPIDLE
+        ret = setsockopt(sock, IPPROTO_TCP, TCP_KEEPIDLE, &timeout,
+                         sizeof(timeout));
+#elif defined(TCP_KEEPALIVE)
+        /* QNX receives `struct timeval' as argument, but it seems OSX does int
+         */
+        ret = setsockopt(sock, IPPROTO_TCP, TCP_KEEPALIVE, &timeout,
+                         sizeof(timeout));
+#endif /* TCP_KEEPIDLE */
+        if (ret < 0)
+            return ret;
+#ifdef TCP_KEEPINTVL
+        ret = setsockopt(sock, IPPROTO_TCP, TCP_KEEPINTVL, &interval,
+                         sizeof(interval));
+        if (ret < 0)
+            return ret;
+#endif /* TCP_KEEPINTVL */
+    }
+#endif /* _WIN32 */
+
+    return ret;
+}
+
 int sock_close(const sock_t sock)
 {
 #ifdef _WIN32
@@ -124,32 +163,39 @@ 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;
+    u_long nonblock = blocking ? 0 : 1;
-    return ioctlsocket(sock, FIONBIO, &block);
+    return ioctlsocket(sock, FIONBIO, &nonblock);
 #else
-    return fcntl(sock, F_SETFL, 0);
+    int rc;
+
+    rc = fcntl(sock, F_GETFL, NULL);
+    if (rc >= 0) {
+        rc = blocking ? rc & (~O_NONBLOCK) : rc | O_NONBLOCK;
+        rc = fcntl(sock, F_SETFL, rc);
+    }
+    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)
 {
-#ifdef _WIN32
+    return _sock_set_blocking_mode(sock, 0);
-    u_long nonblock = 1;
-    return ioctlsocket(sock, FIONBIO, &nonblock);
-#else
-    return fcntl(sock, F_SETFL, O_NONBLOCK);
-#endif
 }
 
-int sock_read(const sock_t sock, void * const buff, const size_t len)
+int sock_read(const sock_t sock, void *const buff, const size_t len)
 {
     return recv(sock, buff, len, 0);
 }
 
-int sock_write(const sock_t sock, const void * const buff, const size_t len)
+int sock_write(const sock_t sock, const void *const buff, const size_t len)
 {
     return send(sock, buff, len, 0);
 }
@@ -157,8 +203,8 @@ int sock_write(const sock_t sock, const void * const buff, const size_t len)
 int sock_is_recoverable(const int error)
 {
 #ifdef _WIN32
-    return (error == WSAEINTR || error == WSAEWOULDBLOCK || 
+    return (error == WSAEINTR || error == WSAEWOULDBLOCK ||
-	    error == WSAEINPROGRESS);
+            error == WSAEINPROGRESS);
 #else
     return (error == EAGAIN || error == EINTR);
 #endif
@@ -166,27 +212,29 @@ int sock_is_recoverable(const int error)
 
 int sock_connect_error(const sock_t sock)
 {
-    struct sockaddr sa;
+    struct sockaddr_storage ss;
-    unsigned len;
+    struct sockaddr *sa = (struct sockaddr *)&ss;
+    socklen_t len;
     char temp;
 
-    sa.sa_family = AF_INET;
+    memset(&ss, 0, sizeof(ss));
-
+    len = sizeof(ss);
-    len = sizeof(sa);
+    sa->sa_family = AF_UNSPEC;
 
     /* we don't actually care about the peer name, we're just checking if
      * we're connected or not */
-    if (getpeername(sock, &sa, &len) == 0)
+    if (getpeername(sock, sa, &len) == 0) {
-    {
+        return 0;
-	return 0;
     }
 
     /* it's possible that the error wasn't ENOTCONN, so if it wasn't,
      * return that */
 #ifdef _WIN32
-    if (sock_error() != WSAENOTCONN) return sock_error();
+    if (sock_error() != WSAENOTCONN)
+        return sock_error();
 #else
-    if (sock_error() != ENOTCONN) return sock_error();
+    if (sock_error() != ENOTCONN)
+        return sock_error();
 #endif
 
     /* load the correct error into errno through error slippage */
@@ -194,720 +242,3 @@ int sock_connect_error(const sock_t sock)
 
     return sock_error();
 }
-
-struct dnsquery_header
-{
-	unsigned short id;
-	unsigned char qr;
-	unsigned char opcode;
-	unsigned char aa;
-	unsigned char tc;
-	unsigned char rd;
-	unsigned char ra;
-	unsigned char z;
-	unsigned char rcode;
-	unsigned short qdcount;
-	unsigned short ancount;
-	unsigned short nscount;
-	unsigned short arcount;
-};
-
-struct dnsquery_question
-{
-	char qname[1024];
-	unsigned short qtype;
-	unsigned short qclass;
-};
-
-struct dnsquery_srvrdata
-{
-	unsigned short priority;
-	unsigned short weight;
-	unsigned short port;
-	char target[1024];
-};
-
-struct dnsquery_resourcerecord
-{
-	char name[1024];
-	unsigned short type;
-	unsigned short _class;
-	unsigned int ttl;
-	unsigned short rdlength;
-	struct dnsquery_srvrdata rdata;
-};
-
-
-void netbuf_add_32bitnum(unsigned char *buf, int buflen, int *offset, unsigned int num)
-{
-	unsigned char *start = buf + *offset;
-	unsigned char *p = start;
-
-	/* assuming big endian */
-	*p++ = (num >> 24) & 0xff;
-	*p++ = (num >> 16) & 0xff;
-	*p++ = (num >> 8)  & 0xff;
-	*p++ = (num)       & 0xff;
-
-	*offset += 4;
-}
-
-void netbuf_get_32bitnum(unsigned char *buf, int buflen, int *offset, unsigned int *num)
-{
-	unsigned char *start = buf + *offset;
-	unsigned char *p = start;
-	*num = 0;
-
-	/* assuming big endian */
-	*num |= (*p++) << 24;
-	*num |= (*p++) << 16;
-	*num |= (*p++) << 8;
-	*num |= (*p++);
-
-	*offset += 4;
-}
-
-void netbuf_add_16bitnum(unsigned char *buf, int buflen, int *offset, unsigned short num)
-{
-	unsigned char *start = buf + *offset;
-	unsigned char *p = start;
-
-	/* assuming big endian */
-	*p++ = (num >> 8) & 0xff;
-	*p++ = (num)      & 0xff;
-
-	*offset += 2;
-}
-
-void netbuf_get_16bitnum(unsigned char *buf, int buflen, int *offset, unsigned short *num)
-{
-	unsigned char *start = buf + *offset;
-	unsigned char *p = start;
-	*num = 0;
-
-	/* assuming big endian */
-	*num |= (*p++) << 8;
-	*num |= (*p++);
-
-	*offset += 2;
-}
-
-void netbuf_add_domain_name(unsigned char *buf, int buflen, int *offset, 
-			    char *name)
-{
-	unsigned char *start = buf + *offset;
-	unsigned char *p = start;
-	unsigned char *wordstart, *wordend;
-
-	wordstart = (unsigned char *)name;
-	
-	while (*wordstart)
-	{
-		int len;
-		wordend = wordstart;
-		while (*wordend && *wordend != '.')
-		{
-			wordend++;
-		}
-
-		len = (int)(wordend - wordstart);
-
-		if (len > 0x3F)
-		{
-			len = 0x3F;
-		}
-
-		*p++ = len;
-
-		while (wordstart != wordend)
-		{
-			*p++ = *wordstart++;
-		}
-
-		if (*wordstart == '.')
-		{
-			wordstart++;
-		}
-	}
-
-	*p++ = '\0';
-
-	*offset += p - start;
-}
-
-int calc_domain_name_size(unsigned char *buf, int buflen, int offset)
-{
-	unsigned char *p = buf + offset;
-	int len = 0;
-
-	while (*p)
-	{
-		if ((*p & 0xC0) == 0xC0)
-		{
-			int newoffset = 0;
-			newoffset |= (*p++ & 0x3F) << 8;
-			newoffset |= *p;
-
-			p = buf + newoffset;
-		}
-		else
-		{
-			if (len)
-			{
-				len += 1;
-			}
-			len += *p;
-			p += *p + 1;
-		}
-	}
-
-	return len;
-}
-
-int netbuf_get_domain_name(unsigned char *buf, int buflen, int *offset, char *namebuf, int namebuflen)
-{
-	unsigned char *start = buf + *offset;
-	unsigned char *p, *p2;
-	int *curroffset = offset;
-	int len = 0;
-
-	*namebuf = '\0';
-
-	/* measure length */
-	p = start;
-	while (*p)
-	{
-		if ((*p & 0xC0) == 0xC0)
-		{
-			int newoffset = 0;
-			newoffset |= (*p++ & 0x3F) << 8;
-			newoffset |= *p++;
-
-			p = buf + newoffset;
-		}
-		else
-		{
-			len += *p;
-			p += *p + 1;
-		}
-	}
-
-	if (namebuflen < len)
-	{
-		return len;
-	}
-
-	/* actually copy in name */
-	p = start;
-	p2 = (unsigned char *)namebuf;
-	while (*p)
-	{
-		if ((*p & 0xC0) == 0xC0)
-		{
-			int newoffset = 0;
-			newoffset |= (*p++ & 0x3F) << 8;
-			newoffset |= *p++;
-
-			if (curroffset)
-			{
-				*curroffset += (int)(p - start);
-				curroffset = NULL;
-			}
-
-			p = buf + newoffset;
-		}
-		else
-		{
-			int i, partlen;
-
-			if (*namebuf != '\0')
-			{
-				*p2++ = '.';
-			}
-
-			partlen = *p++;
-			
-			for (i=0; i < partlen; i++)
-			{
-                                *p2++ = *p++;
-			}
-		}
-	}
-
-	if (curroffset)
-	{
-		p++;
-		*curroffset += (int)(p - start);
-		curroffset = NULL;
-	}
-
-	*p2 = '\0';
-
-	return 0;
-}
-
-void netbuf_add_dnsquery_header(unsigned char *buf, int buflen, int *offset, struct dnsquery_header *header)
-{
-	unsigned char *p;
-
-	netbuf_add_16bitnum(buf, buflen, offset, header->id);
-	
-	p = buf + *offset;
-	*p++ =    ((header->qr     & 0x01) << 7)
-		| ((header->opcode & 0x0F) << 3)
-		| ((header->aa     & 0x01) << 2)
-		| ((header->tc     & 0x01) << 1)
-		| ((header->rd     & 0x01));
-	*p++ =    ((header->ra     & 0x01) << 7)
-		| ((header->z      & 0x07) << 4)
-		| ((header->rcode  & 0x0F));
-	*offset += 2;
-
-	netbuf_add_16bitnum(buf, buflen, offset, header->qdcount);
-	netbuf_add_16bitnum(buf, buflen, offset, header->ancount);
-	netbuf_add_16bitnum(buf, buflen, offset, header->nscount);
-	netbuf_add_16bitnum(buf, buflen, offset, header->arcount);
-}
-
-void netbuf_get_dnsquery_header(unsigned char *buf, int buflen, int *offset, struct dnsquery_header *header)
-{
-	unsigned char *p;
-		
-	netbuf_get_16bitnum(buf, buflen, offset, &(header->id));
-
-	p = buf + *offset;
-	header->qr =     (*p >> 7) & 0x01;
-	header->opcode = (*p >> 3) & 0x0F;
-	header->aa =     (*p >> 2) & 0x01;
-	header->tc =     (*p >> 1) & 0x01;
-	header->rd =     (*p)      & 0x01;
-	p++;
-	header->ra =     (*p >> 7) & 0x01;
-	header->z =      (*p >> 4) & 0x07;
-	header->rcode =  (*p)      & 0x0F;
-	p++;
-	*offset += 2;
-
-	netbuf_get_16bitnum(buf, buflen, offset, &(header->qdcount));
-	netbuf_get_16bitnum(buf, buflen, offset, &(header->ancount));
-	netbuf_get_16bitnum(buf, buflen, offset, &(header->nscount));
-	netbuf_get_16bitnum(buf, buflen, offset, &(header->arcount));
-}
-
-void netbuf_add_dnsquery_question(unsigned char *buf, int buflen, int *offset, struct dnsquery_question *question)
-{
-	netbuf_add_domain_name(buf, buflen, offset, question->qname);
-	netbuf_add_16bitnum(buf, buflen, offset, question->qtype);
-	netbuf_add_16bitnum(buf, buflen, offset, question->qclass);
-}
-
-void netbuf_get_dnsquery_question(unsigned char *buf, int buflen, int *offset, struct dnsquery_question *question)
-{
-	netbuf_get_domain_name(buf, buflen, offset, question->qname, 1024);
-	netbuf_get_16bitnum(buf, buflen, offset, &(question->qtype));
-	netbuf_get_16bitnum(buf, buflen, offset, &(question->qclass));
-}
-
-void netbuf_get_dnsquery_srvrdata(unsigned char *buf, int buflen, int *offset, struct dnsquery_srvrdata *srvrdata)
-{
-	netbuf_get_16bitnum(buf, buflen, offset, &(srvrdata->priority));
-	netbuf_get_16bitnum(buf, buflen, offset, &(srvrdata->weight));
-	netbuf_get_16bitnum(buf, buflen, offset, &(srvrdata->port));
-	netbuf_get_domain_name(buf, buflen, offset, srvrdata->target, 1024);
-}
-
-void netbuf_get_dnsquery_resourcerecord(unsigned char *buf, int buflen, int *offset, struct dnsquery_resourcerecord *rr)
-{
-	netbuf_get_domain_name(buf, buflen, offset, rr->name, 1024);
-	netbuf_get_16bitnum(buf, buflen, offset, &(rr->type));
-	netbuf_get_16bitnum(buf, buflen, offset, &(rr->_class));
-	netbuf_get_32bitnum(buf, buflen, offset, &(rr->ttl));
-	netbuf_get_16bitnum(buf, buflen, offset, &(rr->rdlength));
-	if (rr->type == 33) /* SRV */
-	{
-		int newoffset = *offset;
-		netbuf_get_dnsquery_srvrdata(buf, buflen, &newoffset, &(rr->rdata));
-	}
-	*offset += rr->rdlength;
-}
-
-
-int sock_srv_lookup(const char *service, const char *proto, const char *domain, char *resulttarget, int resulttargetlength, int *resultport)
-{
-    int set = 0;
-    char fulldomain[2048];
-
-    snprintf(fulldomain, 2048, "_%s._%s.%s", service, proto, domain);
-#ifdef _WIN32
-
-    /* try using dnsapi first */
-    if (!set)
-    {
-        HINSTANCE hdnsapi = NULL;
-	
-	DNS_STATUS (WINAPI * pDnsQuery_A)(PCSTR, WORD, DWORD, PIP4_ARRAY, PDNS_RECORD*, PVOID*);
-	void (WINAPI * pDnsRecordListFree)(PDNS_RECORD, DNS_FREE_TYPE);
-
-	if (hdnsapi = LoadLibrary("dnsapi.dll")) {
-
-	    pDnsQuery_A = (void *)GetProcAddress(hdnsapi, "DnsQuery_A");
-	    pDnsRecordListFree = (void *)GetProcAddress(hdnsapi, "DnsRecordListFree");
-
-	    if (pDnsQuery_A && pDnsRecordListFree) {
-		PDNS_RECORD 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;
-
-		    while (current) {
-			if (current->wType == DNS_TYPE_SRV) {
-			    snprintf(resulttarget, resulttargetlength, "%s", current->Data.Srv.pNameTarget);
-			    *resultport = current->Data.Srv.wPort;
-			    set = 1;
-
-			    current = NULL;
-			} else {
-			    current = current->pNext;
-			}
-		    }
-		}
-
-		pDnsRecordListFree(dnsrecords, DnsFreeRecordList);
-	    }
-	    
-	    FreeLibrary(hdnsapi);
-	}
-    }
-
-    /* if dnsapi didn't work/isn't there, try querying the dns server manually */
-    if (!set)
-    {
-	unsigned char buf[65536];
-	struct dnsquery_header header;
-	struct dnsquery_question question;
-	int offset = 0;
-	int addrlen;
-	sock_t sock;
-	struct sockaddr_in dnsaddr;
-	char dnsserverips[16][256];
-	int numdnsservers = 0;
-	int j;
-
-	/* Try getting the DNS server ips from GetNetworkParams() in iphlpapi first */
-	if (!numdnsservers)
-	{
-		HINSTANCE hiphlpapi = NULL;
-		DWORD (WINAPI * pGetNetworkParams)(PFIXED_INFO, PULONG);
-
-		if (hiphlpapi = LoadLibrary("Iphlpapi.dll"))
-		{
-			pGetNetworkParams = (void *)GetProcAddress(hiphlpapi, "GetNetworkParams");
-
-			if (pGetNetworkParams)
-			{
-				FIXED_INFO *fi;
-				ULONG len;
-				DWORD error;
-				char buffer[65535];
-
-				len = 65535;
-				fi = buffer;
-
-				if ((error = pGetNetworkParams(fi, &len)) == ERROR_SUCCESS)
-				{
-					IP_ADDR_STRING *pias = &(fi->DnsServerList);
-
-					while (pias && numdnsservers < 16)
-					{
-                                                strcpy(dnsserverips[numdnsservers++], pias->IpAddress.String);
-						pias = pias->Next;
-					}
-				}
-			}
-		}
-		FreeLibrary(hiphlpapi);
-	}
-
-	/* Next, try getting the DNS server ips from the registry */
-	if (!numdnsservers)
-	{
-		HKEY search;
-		LONG error;
-
-		error = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters", 0, KEY_READ, &search);
-
-		if (error != ERROR_SUCCESS)
-		{
-			error = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services\\VxD\\MSTCP", 0, KEY_READ, &search);
-		}
-
-		if (error == ERROR_SUCCESS)
-		{
-			char name[512];
-			DWORD len = 512;
-
-			error = RegQueryValueEx(search, "NameServer", NULL, NULL, (LPBYTE)name, &len);
-
-			if (error != ERROR_SUCCESS)
-			{
-				error = RegQueryValueEx(search, "DhcpNameServer", NULL, NULL, (LPBYTE)name, &len);
-			}
-		
-			if (error == ERROR_SUCCESS)
-			{
-				char *parse = "0123456789.", *start, *end;
-				start = name;
-				end = name;
-				name[len] = '\0';
-
-				while (*start && numdnsservers < 16)
-				{
-					while (strchr(parse, *end))
-					{
-						end++;
-					}
-
-					strncpy(dnsserverips[numdnsservers++], start, end - start);
-
-					while (*end && !strchr(parse, *end))
-					{
-						end++;
-					}
-
-					start = end;
-				}
-			}
-		}
-
-		RegCloseKey(search);
-	}
-
-	if (!numdnsservers)
-	{
-		HKEY searchlist;
-		LONG error;
-
-		error = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces", 0, KEY_READ, &searchlist);
-
-		if (error == ERROR_SUCCESS)
-		{
-			unsigned int i;
-			DWORD numinterfaces = 0;
-
-			RegQueryInfoKey(searchlist, NULL, NULL, NULL, &numinterfaces, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
-
-			for (i = 0; i < numinterfaces; i++)
-			{
-				char name[512];
-				DWORD len = 512;
-				HKEY searchentry;
-
-				RegEnumKeyEx(searchlist, i, (LPTSTR)name, &len, NULL, NULL, NULL, NULL);
-
-				if (RegOpenKeyEx(searchlist, name, 0, KEY_READ, &searchentry) == ERROR_SUCCESS)
-				{
-					if (RegQueryValueEx(searchentry, "DhcpNameServer", NULL, NULL, (LPBYTE)name, &len) == ERROR_SUCCESS)
-					{
-						char *parse = "0123456789.", *start, *end;
-						start = name;
-						end = name;
-						name[len] = '\0';
-
-						while (*start && numdnsservers < 16)
-						{
-							while (strchr(parse, *end))
-							{
-								end++;
-							}
-
-							strncpy(dnsserverips[numdnsservers++], start, end - start);
-
-							while (*end && !strchr(parse, *end))
-							{
-								end++;
-							}
-
-							start = end;
-						}
-					}
-					else if (RegQueryValueEx(searchentry, "NameServer", NULL, NULL, (LPBYTE)name, &len) == ERROR_SUCCESS)
-					{
-						char *parse = "0123456789.", *start, *end;
-						start = name;
-						end = name;
-						name[len] = '\0';
-
-						while (*start && numdnsservers < 16)
-						{
-							while (strchr(parse, *end))
-							{
-								end++;
-							}
-
-							strncpy(dnsserverips[numdnsservers++], start, end - start);
-
-							while (*end && !strchr(parse, *end))
-							{
-								end++;
-							}
-
-							start = end;
-						}
-					}
-					RegCloseKey(searchentry);
-				}
-			}
-			RegCloseKey(searchlist);
-		}
-	}
-
-	/* If we have a DNS server, use it */
-	if (numdnsservers)
-	{
-		ULONG nonblocking = 1;
-		int i;
-		int insize;
-
-		memset(&header, 0, sizeof(header));
-		header.id = 12345; /* FIXME: Get a better id here */
-		header.rd = 1;
-		header.qdcount = 1;
-
-		netbuf_add_dnsquery_header(buf, 65536, &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, 65536, &offset, &question);
-
-		insize = 0;
-		for (i = 0; i < numdnsservers && insize <= 0; i++)
-		{
-			sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
-			ioctlsocket(sock, FIONBIO, &nonblocking);
-
-			memset(&dnsaddr, 0, sizeof(dnsaddr));
-
-			dnsaddr.sin_family      = AF_INET;
-			dnsaddr.sin_port        = htons(53);
-			dnsaddr.sin_addr.s_addr = inet_addr(dnsserverips[i]);
-
-			addrlen = sizeof(dnsaddr);
-			sendto(sock, (char *)buf, offset, 0, (struct sockaddr *)&dnsaddr, addrlen);
-			for (j = 0; j < 50; j++)
-			{
-				insize = recvfrom(sock, (char *)buf, 65536, 0, (struct sockaddr *)&dnsaddr, &addrlen);
-				if (insize == SOCKET_ERROR)
-				{
-					if (sock_error() == WSAEWOULDBLOCK)
-					{
-						Sleep(100);
-					}
-					else
-					{
-						break;
-					}
-				}
-				else
-				{
-					break;
-				}
-			}
-
-			closesocket(sock);
-		}
-
-		offset = insize;
-
-		if (offset > 0)
-		{
-			int len = offset;
-			int i;
-			struct dnsquery_header header;
-			struct dnsquery_question question;
-			struct dnsquery_resourcerecord rr;
-
-			offset = 0;
-			netbuf_get_dnsquery_header(buf, 65536, &offset, &header);
-
-			for (i = 0; i < header.qdcount; i++)
-			{
-				netbuf_get_dnsquery_question(buf, 65536, &offset, &question);
-			}
-
-			for (i = 0; i < header.ancount; i++)
-			{
-				netbuf_get_dnsquery_resourcerecord(buf, 65536, &offset, &rr);
-
-				if (rr.type == 33)
-				{
-					struct dnsquery_srvrdata *srvrdata = &(rr.rdata);
-
-					snprintf(resulttarget, resulttargetlength, "%s", srvrdata->target);
-					*resultport = srvrdata->port;
-					set = 1;
-				}
-			}
-
-			for (i = 0; i < header.ancount; i++)
-			{
-				netbuf_get_dnsquery_resourcerecord(buf, 65536, &offset, &rr);
-			}
-		}
-	}
-
-    }
-
-#else
-    if (!set) {
-        unsigned char buf[65535];
-	int len;
-	
-	if ((len = res_query(fulldomain, C_IN, T_SRV, buf, 65535)) > 0) {
-	    int offset;
-	    int i;
-	    struct dnsquery_header header;
-	    struct dnsquery_question question;
-	    struct dnsquery_resourcerecord rr;
-	    
-	    offset = 0;
-	    netbuf_get_dnsquery_header(buf, 65536, &offset, &header);
-	   
-	    for (i = 0; i < header.qdcount; i++) {
-		netbuf_get_dnsquery_question(buf, 65536, &offset, &question);
-	    }
-
-	    for (i = 0; i < header.ancount; i++) {
-		netbuf_get_dnsquery_resourcerecord(buf, 65536, &offset, &rr);
-		
-		if (rr.type == 33) {
-		    struct dnsquery_srvrdata *srvrdata = &(rr.rdata);
-
-		    snprintf(resulttarget, resulttargetlength, "%s",
-			     srvrdata->target);
-		    *resultport = srvrdata->port;
-		    set = 1;
-		}
-	    }
-
-	    for (i = 0; i < header.ancount; i++) {
-		netbuf_get_dnsquery_resourcerecord(buf, 65536, &offset, &rr);
-	    }	    
-	}
-    }
-#endif
-
-    if (!set)
-    {
-	snprintf(resulttarget, resulttargetlength, "%s", domain);
-	*resultport = 5222;
-	return 0;
-    }
-
-    return 1;
-}

src/sock.h

@@ -1,15 +1,12 @@
 /* sock.h
 ** strophe XMPP client library -- socket abstraction header
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -33,19 +30,16 @@ void sock_shutdown(void);
 
 int sock_error(void);
 
-sock_t sock_connect(const char * const host, const unsigned int port);
+sock_t sock_connect(const char *const host, const unsigned short port);
 int sock_close(const sock_t sock);
 
 int sock_set_blocking(const sock_t sock);
 int sock_set_nonblocking(const sock_t sock);
-int sock_read(const sock_t sock, void * const buff, const size_t len);
+int sock_read(const sock_t sock, void *const buff, const size_t len);
-int sock_write(const sock_t sock, const void * const buff, const size_t len);
+int sock_write(const sock_t sock, const void *const buff, const size_t len);
 int sock_is_recoverable(const int error);
 /* checks for an error after connect, return 0 if connect successful */
 int sock_connect_error(const sock_t sock);
-
+int sock_set_keepalive(const sock_t sock, int timeout, int interval);
-int sock_srv_lookup(const char *service, const char *proto,
-		     const char *domain, char *resulttarget,
-		     int resulttargetlength, int *resultport);
 
 #endif /* __LIBSTROPHE_SOCK_H__ */

src/thread.c

@@ -1,119 +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 software is distributed under license and may not be copied,
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
-*/
-
-/** @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,43 +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 software is distributed under license and may not be copied,
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
-*/
-
-/** @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

@@ -1,15 +1,12 @@
 /* tls.h
 ** strophe XMPP client library -- TLS abstraction header
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -27,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);
@@ -38,8 +35,8 @@ int tls_stop(tls_t *tls);
 int tls_error(tls_t *tls);
 
 int tls_pending(tls_t *tls);
-int tls_read(tls_t *tls, void * const buff, const size_t len);
+int tls_read(tls_t *tls, void *const buff, const size_t len);
-int tls_write(tls_t *tls, const void * const buff, const size_t len);
+int tls_write(tls_t *tls, const void *const buff, const size_t len);
 
 int tls_clear_pending_write(tls_t *tls);
 int tls_is_recoverable(int error);

src/tls_dummy.c

@@ -1,15 +1,12 @@
 /* tls_dummy.c
 ** strophe XMPP client library -- TLS abstraction dummy impl.
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -36,59 +33,75 @@ void tls_shutdown(void)
     return;
 }
 
-tls_t *tls_new(xmpp_ctx_t *ctx, sock_t sock)
+tls_t *tls_new(xmpp_conn_t *conn)
 {
+    UNUSED(conn);
     /* always fail */
     return NULL;
 }
 
 void tls_free(tls_t *tls)
 {
+    UNUSED(tls);
     return;
 }
 
 int tls_set_credentials(tls_t *tls, const char *cafilename)
 {
+    UNUSED(tls);
+    UNUSED(cafilename);
     return -1;
 }
 
 int tls_start(tls_t *tls)
 {
+    UNUSED(tls);
     return -1;
 }
 
 int tls_stop(tls_t *tls)
 {
+    UNUSED(tls);
     return -1;
 }
 
 int tls_error(tls_t *tls)
 {
+    UNUSED(tls);
     /* todo: some kind of error polling/dump */
     return 0;
 }
 
 int tls_pending(tls_t *tls)
 {
+    UNUSED(tls);
     return 0;
 }
 
-int tls_read(tls_t *tls, void * const buff, const size_t len)
+int tls_read(tls_t *tls, void *const buff, const size_t len)
 {
+    UNUSED(tls);
+    UNUSED(buff);
+    UNUSED(len);
     return -1;
 }
 
-int tls_write(tls_t *tls, const void * const buff, const size_t len)
+int tls_write(tls_t *tls, const void *const buff, const size_t len)
 {
+    UNUSED(tls);
+    UNUSED(buff);
+    UNUSED(len);
     return -1;
 }
 
 int tls_clear_pending_write(tls_t *tls)
 {
+    UNUSED(tls);
     return -1;
 }
 
 int tls_is_recoverable(int error)
 {
+    UNUSED(error);
     return 0;
 }

src/tls_gnutls.c

@@ -1,15 +1,12 @@
 /* tls.c
 ** strophe XMPP client library -- TLS abstraction header
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -22,11 +19,15 @@
 #include "tls.h"
 #include "sock.h"
 
+/* FIXME this shouldn't be a constant string */
+#define CAFILE "/etc/ssl/certs/ca-certificates.crt"
+
 struct _tls {
     xmpp_ctx_t *ctx; /* do we need this? */
     sock_t sock;
     gnutls_session_t session;
     gnutls_certificate_credentials_t cred;
+    int lasterror;
 };
 
 void tls_initialize(void)
@@ -45,25 +46,22 @@ 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));
-    const int cert_type_priority[3] = { GNUTLS_CRT_X509,
-        GNUTLS_CRT_OPENPGP, 0 };
 
     if (tls) {
-	tls->ctx = ctx;
+        tls->ctx = conn->ctx;
-	tls->sock = sock;
+        tls->sock = conn->sock;
-	gnutls_init(&tls->session, GNUTLS_CLIENT);
+        gnutls_init(&tls->session, GNUTLS_CLIENT);
 
-	gnutls_certificate_allocate_credentials(&tls->cred);
+        gnutls_certificate_allocate_credentials(&tls->cred);
+        tls_set_credentials(tls, CAFILE);
 
-	gnutls_set_default_priority(tls->session);
+        gnutls_set_default_priority(tls->session);
-	gnutls_certificate_type_set_priority(tls->session, cert_type_priority);
 
-	/* fixme: this may require setting a callback on win32? */
+        /* fixme: this may require setting a callback on win32? */
-	gnutls_transport_set_ptr(tls->session, 
+        gnutls_transport_set_int(tls->session, conn->sock);
-		(gnutls_transport_ptr_t)sock);
     }
 
     return tls;
@@ -81,52 +79,69 @@ int tls_set_credentials(tls_t *tls, const char *cafilename)
     int err;
 
     /* set trusted credentials -- takes a .pem filename */
-    err = gnutls_certificate_set_x509_trust_file(tls->cred,
+    err = gnutls_certificate_set_x509_trust_file(tls->cred, cafilename,
-	    cafilename, GNUTLS_X509_FMT_PEM);
+                                                 GNUTLS_X509_FMT_PEM);
-    if (err < 0) return err;
+    if (err >= 0) {
+        err = gnutls_credentials_set(tls->session, GNUTLS_CRD_CERTIFICATE,
+                                     tls->cred);
+    }
+    tls->lasterror = err;
 
-    err = gnutls_credentials_set(tls->session, GNUTLS_CRD_CERTIFICATE, 
+    return err == GNUTLS_E_SUCCESS;
-	    tls->cred);
-
-    return err;
 }
 
 int tls_start(tls_t *tls)
 {
-    return gnutls_handshake(tls->session);
+    sock_set_blocking(tls->sock);
+    tls->lasterror = gnutls_handshake(tls->session);
+    sock_set_nonblocking(tls->sock);
+
+    return tls->lasterror == GNUTLS_E_SUCCESS;
 }
 
 int tls_stop(tls_t *tls)
 {
-    return gnutls_bye(tls->session, GNUTLS_SHUT_RDWR);
+    tls->lasterror = gnutls_bye(tls->session, GNUTLS_SHUT_RDWR);
+    return tls->lasterror == GNUTLS_E_SUCCESS;
 }
 
 int tls_error(tls_t *tls)
 {
-    /* todo: some kind of error polling/dump */
+    return tls->lasterror;
-    return 0;
+}
+
+int tls_is_recoverable(int error)
+{
+    return !gnutls_error_is_fatal(error);
 }
 
 int tls_pending(tls_t *tls)
 {
-    return gnutls_record_check_pending (tls->session);
+    return gnutls_record_check_pending(tls->session);
 }
 
-int tls_read(tls_t *tls, void * const buff, const size_t len)
+int tls_read(tls_t *tls, void *const buff, const size_t len)
 {
     int ret;
 
     ret = gnutls_record_recv(tls->session, buff, len);
+    tls->lasterror = ret < 0 ? ret : 0;
 
     return ret;
 }
 
-int tls_write(tls_t *tls, const void * const buff, const size_t len)
+int tls_write(tls_t *tls, const void *const buff, const size_t len)
 {
     int ret;
 
     ret = gnutls_record_send(tls->session, buff, len);
+    tls->lasterror = ret < 0 ? ret : 0;
 
     return ret;
 }
 
+int tls_clear_pending_write(tls_t *tls)
+{
+    UNUSED(tls);
+    return 0;
+}

src/tls_openssl.c

@@ -1,21 +1,19 @@
 /* tls_openssl.c
 ** strophe XMPP client library -- TLS abstraction openssl impl.
 **
-** Copyright (C) 2005-008 Collecta, Inc. 
+** Copyright (C) 2005-008 Collecta, Inc.
 **
 **  This software is provided AS-IS with no warranty, either express
 **  or implied.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
  *  TLS implementation with OpenSSL.
  */
 
+#include <errno.h> /* EINTR */
 #include <string.h>
 
 #ifndef _WIN32
@@ -25,12 +23,30 @@
 #endif
 
 #include <openssl/ssl.h>
-#include <openssl/rand.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;
@@ -39,15 +55,156 @@ struct _tls {
     int lasterror;
 };
 
+enum {
+    TLS_SHUTDOWN_MAX_RETRIES = 10,
+    TLS_TIMEOUT_SEC = 0,
+    TLS_TIMEOUT_USEC = 100000,
+};
+
+static void _tls_sock_wait(tls_t *tls, int error);
+static const char *_tls_error_str(int error, const char **tbl, size_t tbl_size);
+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);
+
+#define TLS_ERROR_STR(error, table) \
+    _tls_error_str(error, table, ARRAY_SIZE(table))
+
+#define TLS_ERROR_FIELD(x) [x] = #x
+const char *tls_errors[] = {
+    TLS_ERROR_FIELD(SSL_ERROR_NONE),
+    TLS_ERROR_FIELD(SSL_ERROR_SSL),
+    TLS_ERROR_FIELD(SSL_ERROR_WANT_READ),
+    TLS_ERROR_FIELD(SSL_ERROR_WANT_WRITE),
+    TLS_ERROR_FIELD(SSL_ERROR_WANT_X509_LOOKUP),
+    TLS_ERROR_FIELD(SSL_ERROR_SYSCALL),
+    TLS_ERROR_FIELD(SSL_ERROR_ZERO_RETURN),
+    TLS_ERROR_FIELD(SSL_ERROR_WANT_CONNECT),
+    TLS_ERROR_FIELD(SSL_ERROR_WANT_ACCEPT),
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+    TLS_ERROR_FIELD(SSL_ERROR_WANT_ASYNC),
+    TLS_ERROR_FIELD(SSL_ERROR_WANT_ASYNC_JOB),
+#endif
+#if OPENSSL_VERSION_NUMBER >= 0x10101000L
+    TLS_ERROR_FIELD(SSL_ERROR_WANT_CLIENT_HELLO_CB),
+#endif
+};
+const char *cert_errors[] = {
+    TLS_ERROR_FIELD(X509_V_OK),
+#if OPENSSL_VERSION_NUMBER >= 0x10002000L
+    TLS_ERROR_FIELD(X509_V_ERR_UNSPECIFIED),
+#endif
+    TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT),
+    TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_CRL),
+    TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_DECRYPT_CERT_SIGNATURE),
+    TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_DECRYPT_CRL_SIGNATURE),
+    TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY),
+    TLS_ERROR_FIELD(X509_V_ERR_CERT_SIGNATURE_FAILURE),
+    TLS_ERROR_FIELD(X509_V_ERR_CRL_SIGNATURE_FAILURE),
+    TLS_ERROR_FIELD(X509_V_ERR_CERT_NOT_YET_VALID),
+    TLS_ERROR_FIELD(X509_V_ERR_CERT_HAS_EXPIRED),
+    TLS_ERROR_FIELD(X509_V_ERR_CRL_NOT_YET_VALID),
+    TLS_ERROR_FIELD(X509_V_ERR_CRL_HAS_EXPIRED),
+    TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD),
+    TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD),
+    TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD),
+    TLS_ERROR_FIELD(X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD),
+    TLS_ERROR_FIELD(X509_V_ERR_OUT_OF_MEM),
+    TLS_ERROR_FIELD(X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT),
+    TLS_ERROR_FIELD(X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN),
+    TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY),
+    TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE),
+    TLS_ERROR_FIELD(X509_V_ERR_CERT_CHAIN_TOO_LONG),
+    TLS_ERROR_FIELD(X509_V_ERR_CERT_REVOKED),
+    TLS_ERROR_FIELD(X509_V_ERR_INVALID_CA),
+    TLS_ERROR_FIELD(X509_V_ERR_PATH_LENGTH_EXCEEDED),
+    TLS_ERROR_FIELD(X509_V_ERR_INVALID_PURPOSE),
+    TLS_ERROR_FIELD(X509_V_ERR_CERT_UNTRUSTED),
+    TLS_ERROR_FIELD(X509_V_ERR_CERT_REJECTED),
+    TLS_ERROR_FIELD(X509_V_ERR_SUBJECT_ISSUER_MISMATCH),
+    TLS_ERROR_FIELD(X509_V_ERR_AKID_SKID_MISMATCH),
+    TLS_ERROR_FIELD(X509_V_ERR_AKID_ISSUER_SERIAL_MISMATCH),
+    TLS_ERROR_FIELD(X509_V_ERR_KEYUSAGE_NO_CERTSIGN),
+    TLS_ERROR_FIELD(X509_V_ERR_UNABLE_TO_GET_CRL_ISSUER),
+    TLS_ERROR_FIELD(X509_V_ERR_UNHANDLED_CRITICAL_EXTENSION),
+    TLS_ERROR_FIELD(X509_V_ERR_KEYUSAGE_NO_CRL_SIGN),
+    TLS_ERROR_FIELD(X509_V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION),
+    TLS_ERROR_FIELD(X509_V_ERR_INVALID_NON_CA),
+    TLS_ERROR_FIELD(X509_V_ERR_PROXY_PATH_LENGTH_EXCEEDED),
+    TLS_ERROR_FIELD(X509_V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE),
+    TLS_ERROR_FIELD(X509_V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED),
+    TLS_ERROR_FIELD(X509_V_ERR_INVALID_EXTENSION),
+    TLS_ERROR_FIELD(X509_V_ERR_INVALID_POLICY_EXTENSION),
+    TLS_ERROR_FIELD(X509_V_ERR_NO_EXPLICIT_POLICY),
+    TLS_ERROR_FIELD(X509_V_ERR_APPLICATION_VERIFICATION),
+#if OPENSSL_VERSION_NUMBER >= 0x10002000L
+    TLS_ERROR_FIELD(X509_V_ERR_DIFFERENT_CRL_SCOPE),
+    TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_EXTENSION_FEATURE),
+    TLS_ERROR_FIELD(X509_V_ERR_UNNESTED_RESOURCE),
+    TLS_ERROR_FIELD(X509_V_ERR_PERMITTED_VIOLATION),
+    TLS_ERROR_FIELD(X509_V_ERR_EXCLUDED_VIOLATION),
+    TLS_ERROR_FIELD(X509_V_ERR_SUBTREE_MINMAX),
+    TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_CONSTRAINT_TYPE),
+    TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX),
+    TLS_ERROR_FIELD(X509_V_ERR_UNSUPPORTED_NAME_SYNTAX),
+    TLS_ERROR_FIELD(X509_V_ERR_CRL_PATH_VALIDATION_ERROR),
+    TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_VERSION),
+    TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_ALGORITHM),
+    TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_CURVE),
+    TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM),
+    TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_LOS_NOT_ALLOWED),
+    TLS_ERROR_FIELD(X509_V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256),
+    TLS_ERROR_FIELD(X509_V_ERR_HOSTNAME_MISMATCH),
+    TLS_ERROR_FIELD(X509_V_ERR_EMAIL_MISMATCH),
+    TLS_ERROR_FIELD(X509_V_ERR_IP_ADDRESS_MISMATCH),
+#endif
+#if OPENSSL_VERSION_NUMBER >= 0x10100000L
+    TLS_ERROR_FIELD(X509_V_ERR_PATH_LOOP),
+    TLS_ERROR_FIELD(X509_V_ERR_DANE_NO_MATCH),
+    TLS_ERROR_FIELD(X509_V_ERR_EE_KEY_TOO_SMALL),
+    TLS_ERROR_FIELD(X509_V_ERR_CA_KEY_TOO_SMALL),
+    TLS_ERROR_FIELD(X509_V_ERR_CA_MD_TOO_WEAK),
+    TLS_ERROR_FIELD(X509_V_ERR_INVALID_CALL),
+    TLS_ERROR_FIELD(X509_V_ERR_STORE_LOOKUP),
+    TLS_ERROR_FIELD(X509_V_ERR_NO_VALID_SCTS),
+    TLS_ERROR_FIELD(X509_V_ERR_PROXY_SUBJECT_NAME_VIOLATION),
+    TLS_ERROR_FIELD(X509_V_ERR_OCSP_VERIFY_NEEDED),
+    TLS_ERROR_FIELD(X509_V_ERR_OCSP_VERIFY_FAILED),
+    TLS_ERROR_FIELD(X509_V_ERR_OCSP_CERT_UNKNOWN),
+#endif
+};
+#undef TLS_ERROR_FIELD
+
 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)
@@ -55,34 +212,95 @@ 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));
+#if OPENSSL_VERSION_NUMBER >= 0x10002000L
+        /* Hostname verification is supported in OpenSSL 1.0.2 and newer. */
+        X509_VERIFY_PARAM *param;
+#endif
+        memset(tls, 0, sizeof(*tls));
 
-	tls->ctx = ctx;
+        tls->ctx = conn->ctx;
-	tls->sock = sock;
+        tls->sock = conn->sock;
-	tls->ssl_ctx = SSL_CTX_new(SSLv23_client_method());
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
+        tls->ssl_ctx = SSL_CTX_new(SSLv23_client_method());
+#else
+        tls->ssl_ctx = SSL_CTX_new(TLS_client_method());
+#endif
+        if (tls->ssl_ctx == NULL)
+            goto err;
 
-	SSL_CTX_set_client_cert_cb(tls->ssl_ctx, NULL);
+        /* Enable bug workarounds. */
-	SSL_CTX_set_mode (tls->ssl_ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
+        SSL_CTX_set_options(tls->ssl_ctx, SSL_OP_ALL);
-	SSL_CTX_set_verify (tls->ssl_ctx, SSL_VERIFY_NONE, NULL);
 
-	tls->ssl = SSL_new(tls->ssl_ctx);
+        /* 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 */
 
-	ret = SSL_set_fd(tls->ssl, sock);
+        SSL_CTX_set_client_cert_cb(tls->ssl_ctx, NULL);
-	if (ret <= 0) {
+        SSL_CTX_set_mode(tls->ssl_ctx, SSL_MODE_ENABLE_PARTIAL_WRITE);
-	    tls->lasterror = SSL_get_error(tls->ssl, ret);
+
-	    tls_error(tls);
+        ret = SSL_CTX_set_default_verify_paths(tls->ssl_ctx);
-	    tls_free(tls);
+        if (ret == 0 && !conn->tls_trust) {
-	    tls = NULL;
+            /*
-	}
+             * Returns 1 on success and 0 on failure. A missing default
+             * location is still treated as a success.
+             * Ignore errors when XMPP_CONN_FLAG_TRUST_TLS is set.
+             */
+            xmpp_error(tls->ctx, "tls",
+                       "SSL_CTX_set_default_verify_paths() failed");
+            goto err_free_ctx;
+        }
+
+        tls->ssl = SSL_new(tls->ssl_ctx);
+        if (tls->ssl == NULL)
+            goto err_free_ctx;
+
+#if OPENSSL_VERSION_NUMBER >= 0x0908060L && !defined(OPENSSL_NO_TLSEXT)
+        /* Enable SNI. */
+        SSL_set_tlsext_host_name(tls->ssl, conn->domain);
+#endif
+
+        /* Trust server's certificate when user sets the flag explicitly. */
+        mode = conn->tls_trust ? SSL_VERIFY_NONE : SSL_VERIFY_PEER;
+        SSL_set_verify(tls->ssl, mode, NULL);
+#if OPENSSL_VERSION_NUMBER >= 0x10002000L
+        /* Hostname verification is supported in OpenSSL 1.0.2 and newer. */
+        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;
     }
 
     return tls;
+
+err_free_ssl:
+    SSL_free(tls->ssl);
+err_free_ctx:
+    SSL_CTX_free(tls->ssl_ctx);
+err:
+    xmpp_free(conn->ctx, tls);
+    _tls_log_error(conn->ctx);
+    return NULL;
 }
 
 void tls_free(tls_t *tls)
@@ -90,67 +308,90 @@ void tls_free(tls_t *tls)
     SSL_free(tls->ssl);
     SSL_CTX_free(tls->ssl_ctx);
     xmpp_free(tls->ctx, tls);
-    return;
 }
 
 int tls_set_credentials(tls_t *tls, const char *cafilename)
 {
+    UNUSED(tls);
+    UNUSED(cafilename);
     return -1;
 }
 
 int tls_start(tls_t *tls)
 {
-    int ret = -1;
+    int error;
+    int ret;
+    long x509_res;
 
     /* Since we're non-blocking, loop the connect call until it
        succeeds or fails */
-    while (ret == -1) {
+    while (1) {
-	ret = SSL_connect(tls->ssl);
+        ret = SSL_connect(tls->ssl);
+        error = ret <= 0 ? SSL_get_error(tls->ssl, ret) : 0;
 
-	/* wait for something to happen on the sock before looping back */
+        if (ret == -1 && tls_is_recoverable(error)) {
-	if (ret == -1) {
+            /* wait for something to happen on the sock before looping back */
-	    fd_set fds;
+            _tls_sock_wait(tls, error);
-	    struct timeval tv;
+            continue;
+        }
 
-	    tv.tv_sec = 0;
+        /* success or fatal error */
-	    tv.tv_usec = 1000;
+        break;
-
-	    FD_ZERO(&fds); 
-	    FD_SET(tls->sock, &fds);
-    
-	    select(tls->sock + 1, &fds, &fds, NULL, &tv);
-	}
     }
 
-    if (ret <= 0) {
+    x509_res = SSL_get_verify_result(tls->ssl);
-	tls->lasterror = SSL_get_error(tls->ssl, ret);
+    if (x509_res == X509_V_OK) {
-	return 0;
+        xmpp_debug(tls->ctx, "tls", "Certificate verification passed");
+    } else {
+        xmpp_debug(tls->ctx, "tls",
+                   "Certificate verification FAILED, result=%s(%ld)",
+                   TLS_ERROR_STR((int)x509_res, cert_errors), x509_res);
     }
+    _tls_dump_cert_info(tls);
 
-    return 1;
+    _tls_set_error(tls, error);
-
+    return ret <= 0 ? 0 : 1;
 }
 
 int tls_stop(tls_t *tls)
 {
+    int retries = 0;
+    int error;
     int ret;
 
-    ret = SSL_shutdown(tls->ssl);
+    /* 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;
 
-    if (ret <= 0) {
+    while (1) {
-	tls->lasterror = SSL_get_error(tls->ssl, ret);
+        ++retries;
-	return 0;
+        ret = SSL_shutdown(tls->ssl);
+        error = ret < 0 ? SSL_get_error(tls->ssl, ret) : 0;
+        if (ret == 1 || !tls_is_recoverable(error) ||
+            retries >= TLS_SHUTDOWN_MAX_RETRIES) {
+            break;
+        }
+        _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 1;
+    return ret <= 0 ? 0 : 1;
 }
 
 int tls_is_recoverable(int error)
 {
-    return (error == SSL_ERROR_NONE || error == SSL_ERROR_WANT_READ
+    return (error == SSL_ERROR_NONE || error == SSL_ERROR_WANT_READ ||
-	    || error == SSL_ERROR_WANT_WRITE
+            error == SSL_ERROR_WANT_WRITE || error == SSL_ERROR_WANT_CONNECT ||
-	    || error == SSL_ERROR_WANT_CONNECT
+            error == SSL_ERROR_WANT_ACCEPT);
-	    || error == SSL_ERROR_WANT_ACCEPT);
 }
 
 int tls_pending(tls_t *tls)
@@ -158,29 +399,107 @@ int tls_pending(tls_t *tls)
     return SSL_pending(tls->ssl);
 }
 
-int tls_read(tls_t *tls, void * const buff, const size_t len)
+int tls_read(tls_t *tls, void *const buff, const size_t len)
 {
-    int ret = SSL_read(tls->ssl, buff, len);
+    int ret;
 
-    if (ret <= 0) {
+    ret = SSL_read(tls->ssl, buff, len);
-	tls->lasterror = SSL_get_error(tls->ssl, ret);
+    _tls_set_error(tls, ret <= 0 ? SSL_get_error(tls->ssl, ret) : 0);
-    }
 
     return ret;
 }
 
-int tls_write(tls_t *tls, const void * const buff, const size_t len)
+int tls_write(tls_t *tls, const void *const buff, const size_t len)
 {
-    int ret = SSL_write(tls->ssl, buff, len);
+    int ret;
 
-    if (ret <= 0) {
+    ret = SSL_write(tls->ssl, buff, len);
-	tls->lasterror = SSL_get_error(tls->ssl, ret);
+    _tls_set_error(tls, ret <= 0 ? SSL_get_error(tls->ssl, ret) : 0);
-    }
 
     return ret;
 }
 
 int tls_clear_pending_write(tls_t *tls)
 {
+    UNUSED(tls);
     return 0;
 }
+
+static void _tls_sock_wait(tls_t *tls, int error)
+{
+    struct timeval tv;
+    fd_set rfds;
+    fd_set wfds;
+    int nfds;
+    int ret;
+
+    if (error == SSL_ERROR_NONE)
+        return;
+
+    FD_ZERO(&rfds);
+    FD_ZERO(&wfds);
+    if (error == SSL_ERROR_WANT_READ)
+        FD_SET(tls->sock, &rfds);
+    if (error == SSL_ERROR_WANT_WRITE)
+        FD_SET(tls->sock, &wfds);
+    nfds = (error == SSL_ERROR_WANT_READ || error == SSL_ERROR_WANT_WRITE)
+               ? tls->sock + 1
+               : 0;
+    do {
+        tv.tv_sec = TLS_TIMEOUT_SEC;
+        tv.tv_usec = TLS_TIMEOUT_USEC;
+        ret = select(nfds, &rfds, &wfds, NULL, &tv);
+    } while (ret == -1 && errno == EINTR);
+}
+
+static const char *_tls_error_str(int error, const char **tbl, size_t tbl_size)
+{
+    return (error >= 0 && (size_t)error < tbl_size) ? tbl[error] : "UNKNOWN";
+}
+
+static void _tls_set_error(tls_t *tls, int error)
+{
+    if (error != 0 && !tls_is_recoverable(error)) {
+        xmpp_debug(tls->ctx, "tls", "error=%s(%d) errno=%d",
+                   TLS_ERROR_STR(error, tls_errors), error, errno);
+        _tls_log_error(tls->ctx);
+    }
+    tls->lasterror = error;
+}
+
+static void _tls_log_error(xmpp_ctx_t *ctx)
+{
+    unsigned long e;
+    char buf[256];
+
+    do {
+        e = ERR_get_error();
+        if (e != 0) {
+            ERR_error_string_n(e, buf, sizeof(buf));
+            xmpp_debug(ctx, "tls", "%s", buf);
+        }
+    } 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

@@ -1,15 +1,12 @@
 /* tls_schannel.c
 ** strophe XMPP client library -- TLS abstraction schannel impl.
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -26,6 +23,7 @@
 
 struct _tls {
     xmpp_ctx_t *ctx;
+    xmpp_conn_t *conn;
     sock_t sock;
 
     HANDLE hsec32;
@@ -63,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;
@@ -75,52 +75,52 @@ tls_t *tls_new(xmpp_ctx_t *ctx, sock_t sock)
     SecPkgCred_CipherStrengths spc_cs;
     SecPkgCred_SupportedProtocols spc_sp;
 
-    OSVERSIONINFO osvi;
+    OSVERSIONINFO osvi;
-
+
-    memset(&osvi, 0, sizeof(osvi));
+    memset(&osvi, 0, sizeof(osvi));
-    osvi.dwOSVersionInfoSize = sizeof(osvi);
+    osvi.dwOSVersionInfoSize = sizeof(osvi);
-
+
     GetVersionEx(&osvi);
 
     /* no TLS support on win9x/me, despite what anyone says */
     if (osvi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) {
-	return NULL;
+        return NULL;
     }
 
     tls = xmpp_alloc(ctx, sizeof(*tls));
 
     if (!tls) {
-	return NULL;
+        return NULL;
     }
 
     memset(tls, 0, sizeof(*tls));
     tls->ctx = ctx;
+    tls->conn = conn;
     tls->sock = sock;
 
-    if (!(tls->hsec32 = LoadLibrary ("secur32.dll"))) {
+    if (!(tls->hsec32 = LoadLibrary("secur32.dll"))) {
-	tls_free(tls);
+        tls_free(tls);
-	return NULL;
+        return NULL;
     }
 
-    if (!(pInitSecurityInterface = 
+    if (!(pInitSecurityInterface =
-	  (void *)GetProcAddress(tls->hsec32, "InitSecurityInterfaceA"))) {
+              (void *)GetProcAddress(tls->hsec32, "InitSecurityInterfaceA"))) {
-	tls_free(tls);
+        tls_free(tls);
-	return NULL;
+        return NULL;
     }
 
     tls->sft = pInitSecurityInterface();
 
     if (!tls->sft) {
-	tls_free(tls);
+        tls_free(tls);
-	return NULL;
+        return NULL;
     }
 
     ret = tls->sft->QuerySecurityPackageInfo(UNISP_NAME, &(tls->spi));
 
-    if (ret != SEC_E_OK)
+    if (ret != SEC_E_OK) {
-    {
+        tls_free(tls);
-	tls_free(tls);
+        return NULL;
-	return NULL;
     }
 
     xmpp_debug(ctx, "TLSS", "QuerySecurityPackageInfo() success");
@@ -128,18 +128,24 @@ tls_t *tls_new(xmpp_ctx_t *ctx, sock_t sock)
     memset(&scred, 0, sizeof(scred));
     scred.dwVersion = SCHANNEL_CRED_VERSION;
     /*scred.grbitEnabledProtocols = SP_PROT_TLS1_CLIENT;*/
+    /* Remote server closes connection with forced RC4.
+       The below lines are commented to leave default system configuration */
+#if 0
     /* Something down the line doesn't like AES, so force it to RC4 */
     algs[0] = CALG_RC4;
     scred.cSupportedAlgs = 1;
     scred.palgSupportedAlgs = algs;
+#else
+    (void)algs;
+#endif
 
-    ret = tls->sft->AcquireCredentialsHandleA(NULL, UNISP_NAME,
+    ret = tls->sft->AcquireCredentialsHandleA(
-	SECPKG_CRED_OUTBOUND, NULL, &scred, NULL, NULL, &(tls->hcred), NULL);
+        NULL, UNISP_NAME, SECPKG_CRED_OUTBOUND, NULL, &scred, NULL, NULL,
+        &(tls->hcred), NULL);
 
-    if (ret != SEC_E_OK)
+    if (ret != SEC_E_OK) {
-    {
+        tls_free(tls);
-	tls_free(tls);
+        return NULL;
-	return NULL;
     }
 
     xmpp_debug(ctx, "TLSS", "AcquireCredentialsHandle() success");
@@ -148,26 +154,26 @@ tls_t *tls_new(xmpp_ctx_t *ctx, sock_t sock)
 
     /* This bunch of queries should trip up wine until someone fixes
      * schannel support there */
-    ret = tls->sft->QueryCredentialsAttributes(&(tls->hcred), SECPKG_ATTR_SUPPORTED_ALGS, &spc_sa);
+    ret = tls->sft->QueryCredentialsAttributes(
-    if (ret != SEC_E_OK)
+        &(tls->hcred), SECPKG_ATTR_SUPPORTED_ALGS, &spc_sa);
-    {
+    if (ret != SEC_E_OK) {
-	tls_free(tls);
+        tls_free(tls);
-	return NULL;
+        return NULL;
-    }
+    }
-
+
-    ret = tls->sft->QueryCredentialsAttributes(&(tls->hcred), SECPKG_ATTR_CIPHER_STRENGTHS, &spc_cs);
+    ret = tls->sft->QueryCredentialsAttributes(
-    if (ret != SEC_E_OK)
+        &(tls->hcred), SECPKG_ATTR_CIPHER_STRENGTHS, &spc_cs);
-    {
+    if (ret != SEC_E_OK) {
-	tls_free(tls);
+        tls_free(tls);
-	return NULL;
+        return NULL;
-    }
+    }
-
+
-    ret = tls->sft->QueryCredentialsAttributes(&(tls->hcred), SECPKG_ATTR_SUPPORTED_PROTOCOLS, &spc_sp);
+    ret = tls->sft->QueryCredentialsAttributes(
-    if (ret != SEC_E_OK)
+        &(tls->hcred), SECPKG_ATTR_SUPPORTED_PROTOCOLS, &spc_sp);
-    {
+    if (ret != SEC_E_OK) {
-	tls_free(tls);
+        tls_free(tls);
-	return NULL;
+        return NULL;
-    }
+    }
 
     return tls;
 }
@@ -175,34 +181,36 @@ tls_t *tls_new(xmpp_ctx_t *ctx, sock_t sock)
 void tls_free(tls_t *tls)
 {
     if (tls->recvbuffer) {
-	xmpp_free(tls->ctx, tls->recvbuffer);
+        xmpp_free(tls->ctx, tls->recvbuffer);
     }
 
     if (tls->readybuffer) {
-	xmpp_free(tls->ctx, tls->readybuffer);
+        xmpp_free(tls->ctx, tls->readybuffer);
     }
 
     if (tls->sendbuffer) {
-	xmpp_free(tls->ctx, tls->sendbuffer);
+        xmpp_free(tls->ctx, tls->sendbuffer);
     }
 
     if (tls->init) {
-	tls->sft->FreeCredentialsHandle(&(tls->hcred));
+        tls->sft->FreeCredentialsHandle(&(tls->hcred));
     }
 
     tls->sft = NULL;
 
     if (tls->hsec32) {
-	FreeLibrary(tls->hsec32);
+        FreeLibrary(tls->hsec32);
-	tls->hsec32 = NULL;
+        tls->hsec32 = NULL;
     }
-    
+
     xmpp_free(tls->ctx, tls);
     return;
 }
 
 int tls_set_credentials(tls_t *tls, const char *cafilename)
 {
+    UNUSED(tls);
+    UNUSED(cafilename);
     return -1;
 }
 
@@ -213,29 +221,15 @@ 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
+    /* use the domain there as our name */
-     * name */
+    name = tls->conn->domain;
-    {
-	xmpp_connlist_t *listentry = tls->ctx->connlist;
 
-	while (listentry) {
+    ctxtreq = ISC_REQ_SEQUENCE_DETECT | ISC_REQ_REPLAY_DETECT |
-	    xmpp_conn_t *conn = listentry->conn;
+              ISC_REQ_CONFIDENTIALITY | ISC_RET_EXTENDED_ERROR |
-
+              ISC_REQ_ALLOCATE_MEMORY | ISC_REQ_STREAM |
-	    if (conn->sock == tls->sock) {
+              ISC_REQ_MANUAL_CRED_VALIDATION | ISC_REQ_INTEGRITY;
-		name = strdup(conn->domain);
-		listentry = NULL;
-	    } else {
-		listentry = listentry->next;
-	    }
-	}
-    }
-
-    ctxtreq = ISC_REQ_SEQUENCE_DETECT | ISC_REQ_REPLAY_DETECT
-	    | ISC_REQ_CONFIDENTIALITY | ISC_RET_EXTENDED_ERROR
-	    | ISC_REQ_ALLOCATE_MEMORY | ISC_REQ_STREAM
-	    | ISC_REQ_MANUAL_CRED_VALIDATION | ISC_REQ_INTEGRITY;
 
     memset(&(sbout[0]), 0, sizeof(sbout[0]));
     sbout[0].BufferType = SECBUFFER_TOKEN;
@@ -258,131 +252,134 @@ int tls_start(tls_t *tls)
     sbdin.cBuffers = 2;
     sbdin.pBuffers = sbin;
 
-    ret = tls->sft->InitializeSecurityContextA(&(tls->hcred), NULL, name, ctxtreq, 0, 0,
+    ret = tls->sft->InitializeSecurityContextA(
-					  NULL, 0, &(tls->hctxt), &sbdout,
+        &(tls->hcred), NULL, name, ctxtreq, 0, 0, NULL, 0, &(tls->hctxt),
-					  &ctxtattr, NULL);
+        &sbdout, &ctxtattr, NULL);
 
-    while (ret == SEC_I_CONTINUE_NEEDED
+    unsigned char *p = sbin[0].pvBuffer;
-	   || ret == SEC_I_INCOMPLETE_CREDENTIALS) {
+    int len = 0;
-	unsigned char *p = sbin[0].pvBuffer;
-	int len = 0, inbytes = 0;
 
-	if (sbdout.pBuffers[0].cbBuffer) {
+    while (ret == SEC_I_CONTINUE_NEEDED ||
-	    unsigned char *writebuff = sbdout.pBuffers[0].pvBuffer;
+           ret == SEC_I_INCOMPLETE_CREDENTIALS ||
-	    unsigned int writelen = sbdout.pBuffers[0].cbBuffer;
+           ret == SEC_E_INCOMPLETE_MESSAGE) {
+        int inbytes = 0;
 
-	    sent = sock_write(tls->sock, writebuff, writelen);
+        if (ret != SEC_E_INCOMPLETE_MESSAGE) {
-	    if (sent == -1) {
+            len = 0;
-		tls->lasterror = sock_error();
+            p = sbin[0].pvBuffer;
-	    }
+        }
-	    else
-	    {
-		writebuff += sent;
-		writelen -= sent;
-	    }
-	    tls->sft->FreeContextBuffer(sbdout.pBuffers[0].pvBuffer);
-	    sbdout.pBuffers[0].pvBuffer = NULL;
-	    sbdout.pBuffers[0].cbBuffer = 0;
-	}
 
-	/* poll for a bit until the remote server stops sending data, ie it
+        if (sbdout.pBuffers[0].cbBuffer) {
-	 * finishes sending the token */
+            unsigned char *writebuff = sbdout.pBuffers[0].pvBuffer;
-	inbytes = 1;
+            unsigned int writelen = sbdout.pBuffers[0].cbBuffer;
-	{
-	    fd_set fds;
-	    struct timeval tv;
 
-	    tv.tv_sec = 2;
+            sent = sock_write(tls->sock, writebuff, writelen);
-	    tv.tv_usec = 0;
+            if (sent == -1) {
+                tls->lasterror = sock_error();
+            } else {
+                writebuff += sent;
+                writelen -= sent;
+            }
+            tls->sft->FreeContextBuffer(sbdout.pBuffers[0].pvBuffer);
+            sbdout.pBuffers[0].pvBuffer = NULL;
+            sbdout.pBuffers[0].cbBuffer = 0;
+        }
 
-	    FD_ZERO(&fds);
+        /* poll for a bit until the remote server stops sending data, ie it
-	    FD_SET(tls->sock, &fds);
+         * finishes sending the token */
-    
+        inbytes = 1;
-	    select(tls->sock, &fds, NULL, NULL, &tv);
+        {
-	}
+            fd_set fds;
+            struct timeval tv;
 
-	while (inbytes > 0) {
+            tv.tv_sec = 2;
-	    fd_set fds;
+            tv.tv_usec = 0;
-	    struct timeval tv;
 
-	    tv.tv_sec = 0;
+            FD_ZERO(&fds);
-	    tv.tv_usec = 1000;
+            FD_SET(tls->sock, &fds);
 
-	    FD_ZERO(&fds);
+            select(tls->sock, &fds, NULL, NULL, &tv);
-	    FD_SET(tls->sock, &fds);
+        }
-    
-	    select(tls->sock, &fds, NULL, NULL, &tv);
 
-	    inbytes = sock_read(tls->sock, p, tls->spi->cbMaxToken - len);
+        while (inbytes > 0) {
+            fd_set fds;
+            struct timeval tv;
 
-	    if (inbytes > 0) {
+            tv.tv_sec = 0;
-		len += inbytes;
+            tv.tv_usec = 1000;
-		p += inbytes;
-	    }
-	    else
-	    {
-	        tls->lasterror = sock_error();
-	    }
 
-	}
+            FD_ZERO(&fds);
+            FD_SET(tls->sock, &fds);
 
-	sbin[0].cbBuffer = len;
+            select(tls->sock, &fds, NULL, NULL, &tv);
 
-	ret = tls->sft->InitializeSecurityContextA(&(tls->hcred), &(tls->hctxt), name,
+            inbytes = sock_read(tls->sock, p, tls->spi->cbMaxToken - len);
-					      ctxtreq, 0, 0, &sbdin, 0,
+
-					      &(tls->hctxt), &sbdout,
+            if (inbytes > 0) {
-					      &ctxtattr, NULL);
+                len += inbytes;
+                p += inbytes;
+            } else {
+                tls->lasterror = sock_error();
+            }
+        }
+
+        sbin[0].cbBuffer = len;
+
+        ret = tls->sft->InitializeSecurityContextA(
+            &(tls->hcred), &(tls->hctxt), name, ctxtreq, 0, 0, &sbdin, 0,
+            &(tls->hctxt), &sbdout, &ctxtattr, NULL);
     }
 
     if (ret == SEC_E_OK) {
-	if (sbdout.pBuffers[0].cbBuffer) {
+        if (sbdout.pBuffers[0].cbBuffer) {
-	    unsigned char *writebuff = sbdout.pBuffers[0].pvBuffer;
+            unsigned char *writebuff = sbdout.pBuffers[0].pvBuffer;
-	    unsigned int writelen = sbdout.pBuffers[0].cbBuffer;
+            unsigned int writelen = sbdout.pBuffers[0].cbBuffer;
-	    sent = sock_write(tls->sock, writebuff, writelen);
+            sent = sock_write(tls->sock, writebuff, writelen);
-	    if (sent == -1) {
+            if (sent == -1) {
-		tls->lasterror = sock_error();
+                tls->lasterror = sock_error();
-	    }
+            } else {
-	    else
+                writebuff += sent;
-	    {
+                writelen -= sent;
-		writebuff += sent;
+            }
-		writelen -= sent;
+            tls->sft->FreeContextBuffer(sbdout.pBuffers[0].pvBuffer);
-	    }
+            sbdout.pBuffers[0].pvBuffer = NULL;
-	    tls->sft->FreeContextBuffer(sbdout.pBuffers[0].pvBuffer);
+            sbdout.pBuffers[0].cbBuffer = 0;
-	    sbdout.pBuffers[0].pvBuffer = NULL;
+        }
-	    sbdout.pBuffers[0].cbBuffer = 0;
-	}
     }
 
     xmpp_free(tls->ctx, sbin[0].pvBuffer);
 
     if (ret != SEC_E_OK) {
-	tls->lasterror = ret;
+        tls->lasterror = ret;
-	return 0;
+        xmpp_error(tls->ctx, "TLSS", "Schannel error 0x%lx",
+                   (unsigned long)ret);
+        return 0;
     }
 
-    tls->sft->QueryContextAttributes(&(tls->hctxt), SECPKG_ATTR_STREAM_SIZES, 
+    tls->sft->QueryContextAttributes(&(tls->hctxt), SECPKG_ATTR_STREAM_SIZES,
-				&(tls->spcss));
+                                     &(tls->spcss));
 
-    tls->recvbuffermaxlen = tls->spcss.cbHeader + tls->spcss.cbMaximumMessage
+    tls->recvbuffermaxlen = tls->spcss.cbHeader + tls->spcss.cbMaximumMessage +
-			    + tls->spcss.cbTrailer;
+                            tls->spcss.cbTrailer;
-    tls->recvbuffer       = xmpp_alloc(tls->ctx, tls->recvbuffermaxlen);
+    tls->recvbuffer = xmpp_alloc(tls->ctx, tls->recvbuffermaxlen);
-    tls->recvbufferpos    = 0;
+    tls->recvbufferpos = 0;
 
-    tls->sendbuffermaxlen = tls->spcss.cbHeader + tls->spcss.cbMaximumMessage
+    tls->sendbuffermaxlen = tls->spcss.cbHeader + tls->spcss.cbMaximumMessage +
-			    + tls->spcss.cbTrailer;
+                            tls->spcss.cbTrailer;
-    tls->sendbuffer       = xmpp_alloc(tls->ctx, tls->sendbuffermaxlen);
+    tls->sendbuffer = xmpp_alloc(tls->ctx, tls->sendbuffermaxlen);
-    tls->sendbufferpos    = 0;
+    tls->sendbufferpos = 0;
-    tls->sendbufferlen    = 0;
+    tls->sendbufferlen = 0;
 
-    tls->readybuffer      = xmpp_alloc(tls->ctx, tls->spcss.cbMaximumMessage);
+    tls->readybuffer = xmpp_alloc(tls->ctx, tls->spcss.cbMaximumMessage);
-    tls->readybufferpos   = 0;
+    tls->readybufferpos = 0;
-    tls->readybufferlen   = 0;
+    tls->readybufferlen = 0;
 
     return 1;
 }
 
 int tls_stop(tls_t *tls)
 {
+    UNUSED(tls);
     return -1;
 }
 
@@ -393,144 +390,143 @@ int tls_error(tls_t *tls)
 
 int tls_is_recoverable(int error)
 {
-    return (error == SEC_E_OK || error == SEC_E_INCOMPLETE_MESSAGE
+    return (error == SEC_E_OK || error == SEC_E_INCOMPLETE_MESSAGE ||
-	    || error == WSAEWOULDBLOCK || error == WSAEMSGSIZE
+            error == WSAEWOULDBLOCK || error == WSAEMSGSIZE ||
-	    || error == WSAEINPROGRESS);
+            error == WSAEINPROGRESS);
 }
 
-int tls_pending(tls_t *tls) {
+int tls_pending(tls_t *tls)
-	// There are 3 cases:
+{
-	// - there is data in ready buffer, so it is by default pending
+    // There are 3 cases:
-	// - there is data in recv buffer. If it is not decrypted yet, means it 
+    // - there is data in ready buffer, so it is by default pending
-	// was incomplete. This should be processed again only if there is data
+    // - there is data in recv buffer. If it is not decrypted yet, means it
-	// on the physical connection
+    // was incomplete. This should be processed again only if there is data
-	// - there is data on the physical connection. This case is treated
+    // on the physical connection
-	// outside the tls (in event.c)
+    // - there is data on the physical connection. This case is treated
+    // outside the tls (in event.c)
 
     if (tls->readybufferpos < tls->readybufferlen) {
-		return tls->readybufferlen - tls->readybufferpos;
+        return tls->readybufferlen - tls->readybufferpos;
-	}
+    }
 
-	return 0;
+    return 0;
 }
 
-int tls_read(tls_t *tls, void * const buff, const size_t len)
+int tls_read(tls_t *tls, void *const buff, const size_t len)
 {
     int bytes;
 
     /* first, if we've got some ready data, put that in the buffer */
-    if (tls->readybufferpos < tls->readybufferlen)
+    if (tls->readybufferpos < tls->readybufferlen) {
-    {
+        if (len < tls->readybufferlen - tls->readybufferpos) {
-	if (len < tls->readybufferlen - tls->readybufferpos) {
+            bytes = len;
-	    bytes = len;
+        } else {
-	} else {
+            bytes = tls->readybufferlen - tls->readybufferpos;
-	    bytes = tls->readybufferlen - tls->readybufferpos;
+        }
-	}
 
-	memcpy(buff, tls->readybuffer + tls->readybufferpos, bytes);
+        memcpy(buff, tls->readybuffer + tls->readybufferpos, bytes);
 
-	if (len < tls->readybufferlen - tls->readybufferpos) {
+        if (len < tls->readybufferlen - tls->readybufferpos) {
-	    tls->readybufferpos += bytes;
+            tls->readybufferpos += bytes;
-	    return bytes;
+            return bytes;
-	} else {
+        } else {
-	    unsigned char *newbuff = buff;
+            unsigned char *newbuff = buff;
-	    int read;
+            int read;
-	    tls->readybufferpos += bytes;
+            tls->readybufferpos += bytes;
-	    newbuff += bytes;
+            newbuff += bytes;
-	    read = tls_read(tls, newbuff, len - bytes);
+            read = tls_read(tls, newbuff, len - bytes);
 
-	    if (read == -1) {
+            if (read == -1) {
-	        if (tls_is_recoverable(tls->lasterror))	{
+                if (tls_is_recoverable(tls->lasterror)) {
-		    return bytes;
+                    return bytes;
-		}
+                }
 
-		return -1;
+                return -1;
-	    }
+            }
 
-	    return bytes + read;
+            return bytes + read;
-	}
+        }
     }
 
     /* next, top up our recv buffer */
     bytes = sock_read(tls->sock, tls->recvbuffer + tls->recvbufferpos,
-		      tls->recvbuffermaxlen - tls->recvbufferpos);
+                      tls->recvbuffermaxlen - tls->recvbufferpos);
-			  
+
     if (bytes == 0) {
         tls->lasterror = WSAECONNRESET;
         return -1;
-    }				  
+    }
 
     if (bytes == -1) {
-	if (!tls_is_recoverable(sock_error())) {
+        if (!tls_is_recoverable(sock_error())) {
-	    tls->lasterror = sock_error();
+            tls->lasterror = sock_error();
-	    return -1;
+            return -1;
-	}
+        }
     }
 
     if (bytes > 0) {
-	tls->recvbufferpos += bytes;
+        tls->recvbufferpos += bytes;
     }
 
     /* next, try to decrypt the recv buffer */
     if (tls->recvbufferpos > 0) {
-	SecBufferDesc sbddec;
+        SecBufferDesc sbddec;
-	SecBuffer sbdec[4];
+        SecBuffer sbdec[4];
-	int ret;
+        int ret;
 
-	memset(&sbddec, 0, sizeof(sbddec));
+        memset(&sbddec, 0, sizeof(sbddec));
-	sbddec.ulVersion = SECBUFFER_VERSION;
+        sbddec.ulVersion = SECBUFFER_VERSION;
-	sbddec.cBuffers = 4;
+        sbddec.cBuffers = 4;
-	sbddec.pBuffers = sbdec;
+        sbddec.pBuffers = sbdec;
 
-	memset(&(sbdec[0]), 0, sizeof(sbdec[0]));
+        memset(&(sbdec[0]), 0, sizeof(sbdec[0]));
-	sbdec[0].BufferType = SECBUFFER_DATA;
+        sbdec[0].BufferType = SECBUFFER_DATA;
-	sbdec[0].pvBuffer = tls->recvbuffer;
+        sbdec[0].pvBuffer = tls->recvbuffer;
-	sbdec[0].cbBuffer = tls->recvbufferpos;
+        sbdec[0].cbBuffer = tls->recvbufferpos;
 
-	memset(&(sbdec[1]), 0, sizeof(sbdec[1]));
+        memset(&(sbdec[1]), 0, sizeof(sbdec[1]));
-	sbdec[1].BufferType = SECBUFFER_EMPTY;
+        sbdec[1].BufferType = SECBUFFER_EMPTY;
 
-	memset(&(sbdec[2]), 0, sizeof(sbdec[2]));
+        memset(&(sbdec[2]), 0, sizeof(sbdec[2]));
-	sbdec[2].BufferType = SECBUFFER_EMPTY;
+        sbdec[2].BufferType = SECBUFFER_EMPTY;
 
-	memset(&(sbdec[3]), 0, sizeof(sbdec[3]));
+        memset(&(sbdec[3]), 0, sizeof(sbdec[3]));
-	sbdec[3].BufferType = SECBUFFER_EMPTY;
+        sbdec[3].BufferType = SECBUFFER_EMPTY;
 
-	ret = tls->sft->DecryptMessage(&(tls->hctxt), &sbddec, 0, NULL);
+        ret = tls->sft->DecryptMessage(&(tls->hctxt), &sbddec, 0, NULL);
 
-	if (ret == SEC_E_OK) {
+        if (ret == SEC_E_OK) {
-	    memcpy(tls->readybuffer, sbdec[1].pvBuffer, sbdec[1].cbBuffer); 
+            memcpy(tls->readybuffer, sbdec[1].pvBuffer, sbdec[1].cbBuffer);
-	    tls->readybufferpos = 0;
+            tls->readybufferpos = 0;
-	    tls->readybufferlen = sbdec[1].cbBuffer;
+            tls->readybufferlen = sbdec[1].cbBuffer;
-	    /* have we got some data left over?  If so, copy it to the start
+            /* have we got some data left over?  If so, copy it to the start
-	     * of the recv buffer */
+             * of the recv buffer */
-	    if (sbdec[3].BufferType == SECBUFFER_EXTRA) {
+            if (sbdec[3].BufferType == SECBUFFER_EXTRA) {
-		memcpy(tls->recvbuffer, sbdec[3].pvBuffer, sbdec[3].cbBuffer);
+                memcpy(tls->recvbuffer, sbdec[3].pvBuffer, sbdec[3].cbBuffer);
-		tls->recvbufferpos = sbdec[3].cbBuffer;
+                tls->recvbufferpos = sbdec[3].cbBuffer;
-	    } else {
+            } else {
-		tls->recvbufferpos = 0;
+                tls->recvbufferpos = 0;
-	    }
+            }
 
-	    return tls_read(tls, buff, len);
+            return tls_read(tls, buff, len);
-	} else if (ret == SEC_E_INCOMPLETE_MESSAGE) {
+        } else if (ret == SEC_E_INCOMPLETE_MESSAGE) {
-	    tls->lasterror = SEC_E_INCOMPLETE_MESSAGE;
+            tls->lasterror = SEC_E_INCOMPLETE_MESSAGE;
-	    return -1;
+            return -1;
-	} else if (ret == SEC_I_RENEGOTIATE) {
+        } else if (ret == SEC_I_RENEGOTIATE) {
-	    ret = tls_start(tls);
+            ret = tls_start(tls);
-	    if (!ret)
+            if (!ret) {
-	    {
+                return -1;
-		return -1;
+            }
-	    }
 
-	    /* fake an incomplete message so we're called again */
+            /* fake an incomplete message so we're called again */
-	    tls->lasterror = SEC_E_INCOMPLETE_MESSAGE;
+            tls->lasterror = SEC_E_INCOMPLETE_MESSAGE;
-	    return -1;
+            return -1;
-	}
+        }
 
-	/* something bad happened, so we bail */
+        /* something bad happened, so we bail */
-	tls->lasterror = ret;
+        tls->lasterror = ret;
 
-	return -1;
+        return -1;
     }
 
     tls->lasterror = SEC_E_INCOMPLETE_MESSAGE;
@@ -540,39 +536,37 @@ int tls_read(tls_t *tls, void * const buff, const size_t len)
 
 int tls_clear_pending_write(tls_t *tls)
 {
-    if (tls->sendbufferpos < tls->sendbufferlen)
+    if (tls->sendbufferpos < tls->sendbufferlen) {
-    {
+        int bytes;
-	int bytes;
 
-	bytes = sock_write(tls->sock, tls->sendbuffer + tls->sendbufferpos,
+        bytes = sock_write(tls->sock, tls->sendbuffer + tls->sendbufferpos,
-			   tls->sendbufferlen - tls->sendbufferpos);
+                           tls->sendbufferlen - tls->sendbufferpos);
 
-	if (bytes == -1) {
+        if (bytes == -1) {
-	    tls->lasterror = sock_error();
+            tls->lasterror = sock_error();
-	    return -1;
+            return -1;
-	} else if (bytes > 0) {
+        } else if (bytes > 0) {
-	    tls->sendbufferpos += bytes;
+            tls->sendbufferpos += bytes;
-	}
+        }
 
-	if (tls->sendbufferpos < tls->sendbufferlen) {
+        if (tls->sendbufferpos < tls->sendbufferlen) {
-	    return 0;
+            return 0;
-	}
+        }
     }
 
     return 1;
 }
 
-int tls_write(tls_t *tls, const void * const buff, const size_t len)
+int tls_write(tls_t *tls, const void *const buff, const size_t len)
 {
     SecBufferDesc sbdenc;
     SecBuffer sbenc[4];
-    unsigned char *sendbuffer;
     const unsigned char *p = buff;
     int sent = 0, ret, remain = len;
 
     ret = tls_clear_pending_write(tls);
     if (ret <= 0) {
-	return ret;
+        return ret;
     }
 
     tls->sendbufferpos = 0;
@@ -600,51 +594,49 @@ int tls_write(tls_t *tls, const void * const buff, const size_t len)
 
     sbenc[1].pvBuffer = tls->sendbuffer + tls->spcss.cbHeader;
 
-    while (remain > 0)
+    while (remain > 0) {
-    {
+        if (remain > tls->spcss.cbMaximumMessage) {
-	if (remain > tls->spcss.cbMaximumMessage) {
+            sbenc[1].cbBuffer = tls->spcss.cbMaximumMessage;
-	    sbenc[1].cbBuffer = tls->spcss.cbMaximumMessage;
+        } else {
-	} else {
+            sbenc[1].cbBuffer = remain;
-	    sbenc[1].cbBuffer = remain;
+        }
-	}
 
-	sbenc[2].pvBuffer = (unsigned char *)sbenc[1].pvBuffer
+        sbenc[2].pvBuffer =
-			    + sbenc[1].cbBuffer;
+            (unsigned char *)sbenc[1].pvBuffer + sbenc[1].cbBuffer;
         sbenc[2].cbBuffer = tls->spcss.cbTrailer;
 
-	memcpy(sbenc[1].pvBuffer, p, sbenc[1].cbBuffer);
+        memcpy(sbenc[1].pvBuffer, p, sbenc[1].cbBuffer);
-	p += tls->spcss.cbMaximumMessage;
+        p += tls->spcss.cbMaximumMessage;
 
-	tls->sendbufferlen = sbenc[0].cbBuffer + sbenc[1].cbBuffer
+        tls->sendbufferlen =
-			     + sbenc[2].cbBuffer;
+            sbenc[0].cbBuffer + sbenc[1].cbBuffer + sbenc[2].cbBuffer;
 
-	ret = tls->sft->EncryptMessage(&(tls->hctxt), 0, &sbdenc, 0);
+        ret = tls->sft->EncryptMessage(&(tls->hctxt), 0, &sbdenc, 0);
 
-	if (ret != SEC_E_OK) {
+        if (ret != SEC_E_OK) {
-	    tls->lasterror = ret;
+            tls->lasterror = ret;
-	    return -1;
+            return -1;
-	}
+        }
 
-	tls->sendbufferpos = 0;
+        tls->sendbufferpos = 0;
 
-	ret = tls_clear_pending_write(tls);
+        ret = tls_clear_pending_write(tls);
 
-	if (ret == -1 && !tls_is_recoverable(tls_error(tls))) {
+        if (ret == -1 && !tls_is_recoverable(tls_error(tls))) {
-	    return -1;
+            return -1;
-	} 
+        }
-	
-	if (remain > tls->spcss.cbMaximumMessage) {
-	    sent += tls->spcss.cbMaximumMessage;
-	    remain -= tls->spcss.cbMaximumMessage;
-	} else {
-	    sent += remain;
-	    remain = 0;
-	}
 
-	if (ret == 0 || (ret == -1 && tls_is_recoverable(tls_error(tls)))) {
+        if (remain > tls->spcss.cbMaximumMessage) {
-	    return sent;
+            sent += tls->spcss.cbMaximumMessage;
-	}
+            remain -= tls->spcss.cbMaximumMessage;
+        } else {
+            sent += remain;
+            remain = 0;
+        }
 
+        if (ret == 0 || (ret == -1 && tls_is_recoverable(tls_error(tls)))) {
+            return sent;
+        }
     }
 
     return sent;

src/util.c

@@ -1,15 +1,12 @@
 /* util.c
 ** strophe XMPP client library -- various utility functions
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -24,11 +21,11 @@
 #else
 #include <sys/time.h>
 #include <time.h>
-#include <stdint.h>
 #endif
 
 #include "strophe.h"
 #include "common.h"
+#include "ostypes.h"
 #include "util.h"
 
 /** implement our own strdup that uses the ctx allocator */
@@ -41,7 +38,7 @@
  *
  *  @return a new allocates string with the same data as s or NULL on error
  */
-char *xmpp_strdup(const xmpp_ctx_t * const ctx, const char * const s)
+char *xmpp_strdup(const xmpp_ctx_t *const ctx, const char *const s)
 {
     size_t len;
     char *copy;
@@ -58,6 +55,28 @@ char *xmpp_strdup(const xmpp_ctx_t * const ctx, const char * const s)
     return copy;
 }
 
+/** strtok_r(3) implementation.
+ *  This function has appeared in POSIX.1-2001, but not in C standard.
+ *  For example, visual studio older than 2005 doesn't provide strtok_r()
+ *  nor strtok_s().
+ */
+char *xmpp_strtok_r(char *s, const char *delim, char **saveptr)
+{
+    size_t len;
+
+    s = s ? s : *saveptr;
+    len = strspn(s, delim);
+    s += len;
+    if (*s == '\0')
+        return NULL;
+
+    len = strcspn(s, delim);
+    *saveptr = s[len] == '\0' ? &s[len] : &s[len + 1];
+    s[len] = '\0';
+
+    return s;
+}
+
 /** Return an integer based time stamp.
  *  This function uses gettimeofday or timeGetTime (on Win32 platforms) to
  *  compute an integer based time stamp.  This is used internally by the
@@ -67,8 +86,24 @@ char *xmpp_strdup(const xmpp_ctx_t * const ctx, const char * const s)
  */
 uint64_t time_stamp(void)
 {
-#ifdef _WIN32
+#if defined(_WIN32) || defined(_XBOX_ONE)
-    return timeGetTime();
+
+#ifndef __GNUC__
+#define EPOCHFILETIME (116444736000000000i64)
+#else
+#define EPOCHFILETIME (116444736000000000LL)
+#endif
+
+    FILETIME ft;
+    LARGE_INTEGER li;
+    __int64 t;
+
+    GetSystemTimeAsFileTime(&ft);
+    li.LowPart = ft.dwLowDateTime;
+    li.HighPart = ft.dwHighDateTime;
+    t = li.QuadPart;              /* In 100-nanosecond intervals */
+    t -= EPOCHFILETIME;           /* Offset to the Epoch time */
+    return (uint64_t)(t / 10000); /* Convert to milliseconds */
 #else
     struct timeval tv;
 
@@ -93,15 +128,29 @@ uint64_t time_elapsed(uint64_t t1, uint64_t t2)
     return (uint64_t)(t2 - t1);
 }
 
+/** Disconnect the stream with the error.
+ *  This is a convenience function used internally by various parts of
+ *  the Strophe library for terminating the connection because of an error.
+ *
+ *  @param conn a Strophe connection object
+ *  @param error an error code
+ */
+void disconnect_with_error(xmpp_conn_t *const conn, int error)
+{
+    xmpp_error(conn->ctx, "xmpp", "Disconnecting with error %d", error);
+    conn->error = conn->error ?: error;
+    xmpp_disconnect(conn);
+}
+
 /** Disconnect the stream with a memory error.
  *  This is a convenience function used internally by various parts of
- *  the Strophe library for terminating the connection because of a 
+ *  the Strophe library for terminating the connection because of a
  *  memory error.
  *
  *  @param conn a Strophe connection object
  */
-void disconnect_mem_error(xmpp_conn_t * const conn)
+void disconnect_mem_error(xmpp_conn_t *const conn)
 {
     xmpp_error(conn->ctx, "xmpp", "Memory allocation error");
-    xmpp_disconnect(conn);
+    disconnect_with_error(conn, XMPP_EMEM);
 }

src/util.h

@@ -1,15 +1,12 @@
 /* util.h
 ** strophe XMPP client library -- various utility functions
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -19,11 +16,17 @@
 #ifndef __LIBSTROPHE_UTIL_H__
 #define __LIBSTROPHE_UTIL_H__
 
-#ifndef _WIN32
-#include <stdint.h>
-#else
 #include "ostypes.h"
-#endif
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+#endif /* ARRAY_SIZE */
+
+/* TODO evaluate x and y only once */
+#define xmpp_min(x, y) ((x) < (y) ? (x) : (y))
+
+/* string functions */
+char *xmpp_strtok_r(char *s, const char *delim, char **saveptr);
 
 /* timing functions */
 uint64_t time_stamp(void);

src/uuid.c

@@ -0,0 +1,73 @@
+/* uuid.c
+ * strophe XMPP client library -- UUID generation
+ *
+ * Copyright (C) 2015 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.
+ */
+
+/** @file
+ *  Generation of UUID version 4 according to RFC4122.
+ */
+
+#include "strophe.h"
+#include "common.h"
+#include "rand.h"
+
+/** @def XMPP_UUID_LEN
+ *  UUID length in string representation excluding '\0'.
+ */
+#define XMPP_UUID_LEN 36
+
+/** Generate UUID version 4 in pre-allocated buffer.
+ *
+ *  @param ctx a Strophe context object
+ *  @param uuid pre-allocated buffer of size (XMPP_UUID_LEN + 1)
+ */
+static void crypto_uuid_gen(xmpp_ctx_t *ctx, char *uuid)
+{
+    unsigned char buf[16];
+    int i = 0; /* uuid iterator */
+    int j = 0; /* buf iterator */
+
+    static const char hex[] = {'0', '1', '2', '3', '4', '5', '6', '7',
+                               '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+
+    xmpp_rand_bytes(ctx->rand, buf, sizeof(buf));
+    buf[8] &= 0x3f;
+    buf[8] |= 0x80;
+    buf[6] &= 0x0f;
+    buf[6] |= 0x40;
+    while (i < XMPP_UUID_LEN) {
+        if (i == 8 || i == 13 || i == 18 || i == 23)
+            uuid[i++] = '-';
+        else {
+            uuid[i++] = hex[buf[j] >> 4];
+            uuid[i++] = hex[buf[j] & 0x0f];
+            ++j;
+        }
+    }
+    uuid[XMPP_UUID_LEN] = '\0';
+}
+
+/** Generate UUID version 4.
+ *  This function allocates memory for the resulting string and must be freed
+ *  with xmpp_free().
+ *
+ *  @param ctx a Strophe context object
+ *
+ *  @return ASCIIZ string
+ */
+char *xmpp_uuid_gen(xmpp_ctx_t *ctx)
+{
+    char *uuid;
+
+    uuid = xmpp_alloc(ctx, XMPP_UUID_LEN + 1);
+    if (uuid != NULL) {
+        crypto_uuid_gen(ctx, uuid);
+    }
+    return uuid;
+}

strophe.h

@@ -6,10 +6,7 @@
 **  This software is provided AS-IS with no warranty, either express or
 **  implied.
 **
-**  This software is distributed under license and may not be copied,
+**  This software is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 /** @file
@@ -19,12 +16,12 @@
 #ifndef __LIBSTROPHE_STROPHE_H__
 #define __LIBSTROPHE_STROPHE_H__
 
+#include <stddef.h> /* size_t */
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#include <stdio.h>
-
 /* namespace defines */
 /** @def XMPP_NS_CLIENT
  *  Namespace definition for 'jabber:client'.
@@ -42,6 +39,10 @@ extern "C" {
  *  Namespace definition for 'urn:ietf:params:xml:ns:xmpp-streams'.
  */
 #define XMPP_NS_STREAMS_IETF "urn:ietf:params:xml:ns:xmpp-streams"
+/** @def XMPP_NS_STANZAS_IETF
+ *  Namespace definition for 'urn:ietf:params:xml:ns:xmpp-stanzas'.
+ */
+#define XMPP_NS_STANZAS_IETF "urn:ietf:params:xml:ns:xmpp-stanzas"
 /** @def XMPP_NS_TLS
  *  Namespace definition for 'url:ietf:params:xml:ns:xmpp-tls'.
  */
@@ -74,6 +75,10 @@ extern "C" {
  *  Namespace definition for 'jabber:iq:roster'.
  */
 #define XMPP_NS_ROSTER "jabber:iq:roster"
+/** @def XMPP_NS_REGISTER
+ *  Namespace definition for 'jabber:iq:register'.
+ */
+#define XMPP_NS_REGISTER "jabber:iq:register"
 
 /* error defines */
 /** @def XMPP_EOK
@@ -82,7 +87,7 @@ extern "C" {
 #define XMPP_EOK 0
 /** @def XMPP_EMEM
  *  Memory related failure error code.
- *  
+ *
  *  This is returned on allocation errors and signals that the host may
  *  be out of memory.
  */
@@ -98,6 +103,26 @@ extern "C" {
  *  Internal failure error code.
  */
 #define XMPP_EINT -3
+/** @def XMPP_ECERT
+ *  Certificate verification failed during TLS establishment.
+ */
+#define XMPP_ECERT -4
+/** @def XMPP_ETIMEDOUT
+ *  Operation timed out error code.
+ */
+#define XMPP_ETIMEDOUT -5
+/** @def XMPP_EIO
+ *  I/O error code.
+ */
+#define XMPP_EIO -6
+/** @def XMPP_ERESET
+ *  Error code for situation when connection closed by remote side.
+ */
+#define XMPP_ERESET -7
+/** @def XMPP_EAUTH
+ *  Authentication failed error code.
+ */
+#define XMPP_EAUTH -8
 
 /* initialization and shutdown */
 void xmpp_initialize(void);
@@ -117,14 +142,18 @@ typedef struct _xmpp_log_t xmpp_log_t;
 /* opaque run time context containing the above hooks */
 typedef struct _xmpp_ctx_t xmpp_ctx_t;
 
-xmpp_ctx_t *xmpp_ctx_new(const xmpp_mem_t * const mem, 
+xmpp_ctx_t *xmpp_ctx_new(const xmpp_mem_t *const mem,
-			     const xmpp_log_t * const log);
+                         const xmpp_log_t *const log);
-void xmpp_ctx_free(xmpp_ctx_t * const ctx);
+void xmpp_ctx_free(xmpp_ctx_t *const ctx);
+
+/* free some blocks returned by other APIs, for example the
+   buffer you get from xmpp_stanza_to_text */
+void xmpp_free(const xmpp_ctx_t *const ctx, void *p);
 
 struct _xmpp_mem_t {
-    void *(*alloc)(const size_t size, void * const userdata);
+    void *(*alloc)(const size_t size, void *const userdata);
-    void (*free)(void *p, void * const userdata);
+    void (*free)(void *p, void *const userdata);
-    void *(*realloc)(void *p, const size_t size, void * const userdata);
+    void *(*realloc)(void *p, const size_t size, void *const userdata);
     void *userdata;
 };
 
@@ -135,21 +164,16 @@ typedef enum {
     XMPP_LEVEL_ERROR
 } xmpp_log_level_t;
 
-typedef enum {
+typedef enum { XMPP_UNKNOWN, XMPP_CLIENT, XMPP_COMPONENT } xmpp_conn_type_t;
-    XMPP_UNKNOWN,
-    XMPP_CLIENT,
-    XMPP_COMPONENT
-} xmpp_conn_type_t;
 
-typedef void (*xmpp_log_handler)(void * const userdata, 
+typedef void (*xmpp_log_handler)(void *const userdata,
-				 const xmpp_log_level_t level,
+                                 const xmpp_log_level_t level,
-				 const char * const area,
+                                 const char *const area,
-				 const char * const msg);
+                                 const char *const msg);
 
 struct _xmpp_log_t {
     xmpp_log_handler handler;
     void *userdata;
-    /* mutex_t lock; */
 };
 
 /* return a default logger filtering at a given level */
@@ -161,9 +185,23 @@ xmpp_log_t *xmpp_get_default_logger(xmpp_log_level_t level);
 typedef struct _xmpp_conn_t xmpp_conn_t;
 typedef struct _xmpp_stanza_t xmpp_stanza_t;
 
+/* connection flags */
+#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 {
     XMPP_CONN_CONNECT,
+    XMPP_CONN_RAW_CONNECT,
     XMPP_CONN_DISCONNECT,
     XMPP_CONN_FAIL
 } xmpp_conn_event_t;
@@ -201,171 +239,268 @@ typedef struct {
     xmpp_stanza_t *stanza;
 } xmpp_stream_error_t;
 
-typedef void (*xmpp_conn_handler)(xmpp_conn_t * const conn, 
+typedef void (*xmpp_conn_handler)(xmpp_conn_t *const conn,
-				  const xmpp_conn_event_t event,
+                                  const xmpp_conn_event_t event,
-				  const int error,
+                                  const int error,
-				  xmpp_stream_error_t * const stream_error,
+                                  xmpp_stream_error_t *const stream_error,
-				  void * const userdata);
+                                  void *const userdata);
 
-xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t * const ctx);
+void xmpp_send_error(xmpp_conn_t *const conn,
-xmpp_conn_t * xmpp_conn_clone(xmpp_conn_t * const conn);
+                     xmpp_error_type_t const type,
-int xmpp_conn_release(xmpp_conn_t * const conn);
+                     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);
 
-const char *xmpp_conn_get_jid(const xmpp_conn_t * const conn);
+long xmpp_conn_get_flags(const xmpp_conn_t *const conn);
-const char *xmpp_conn_get_bound_jid(const xmpp_conn_t * const conn);
+int xmpp_conn_set_flags(xmpp_conn_t *const conn, long flags);
-void xmpp_conn_set_jid(xmpp_conn_t * const conn, const char * const jid);
+const char *xmpp_conn_get_jid(const xmpp_conn_t *const conn);
-const char *xmpp_conn_get_pass(const xmpp_conn_t * const conn);
+const char *xmpp_conn_get_bound_jid(const xmpp_conn_t *const conn);
-void xmpp_conn_set_pass(xmpp_conn_t * const conn, const char * const pass);
+void xmpp_conn_set_jid(xmpp_conn_t *const conn, const char *const jid);
-xmpp_ctx_t* xmpp_conn_get_context(xmpp_conn_t * const conn);
+const char *xmpp_conn_get_pass(const xmpp_conn_t *const conn);
-void xmpp_conn_disable_tls(xmpp_conn_t * const conn);
+void xmpp_conn_set_pass(xmpp_conn_t *const conn, const char *const pass);
+xmpp_ctx_t *xmpp_conn_get_context(xmpp_conn_t *const conn);
+void xmpp_conn_disable_tls(xmpp_conn_t *const conn);
+int xmpp_conn_is_secured(xmpp_conn_t *const conn);
+void xmpp_conn_set_keepalive(xmpp_conn_t *const conn,
+                             int timeout,
+                             int interval);
+int xmpp_conn_is_connecting(xmpp_conn_t *const conn);
+int xmpp_conn_is_connected(xmpp_conn_t *const conn);
+int xmpp_conn_is_disconnected(xmpp_conn_t *const conn);
 
-int xmpp_connect_client(xmpp_conn_t * const conn, 
+int xmpp_connect_client(xmpp_conn_t *const conn,
-			  const char * const altdomain,
+                        const char *const altdomain,
-			  unsigned short altport,
+                        unsigned short altport,
-			  xmpp_conn_handler callback,
+                        xmpp_conn_handler callback,
-			  void * const userdata);
+                        void *const userdata);
 
-/*
+int xmpp_connect_component(xmpp_conn_t *const conn,
-int xmpp_connect_component(conn, name)
+                           const char *const server,
-*/
+                           unsigned short port,
-void xmpp_disconnect(xmpp_conn_t * const conn);
+                           xmpp_conn_handler callback,
+                           void *const userdata);
 
-void xmpp_send(xmpp_conn_t * const conn,
+int xmpp_connect_raw(xmpp_conn_t *const conn,
-	       xmpp_stanza_t * const stanza);
+                     const char *const altdomain,
+                     unsigned short altport,
+                     xmpp_conn_handler callback,
+                     void *const userdata);
+int xmpp_conn_open_stream_default(xmpp_conn_t *const conn);
+int xmpp_conn_open_stream(xmpp_conn_t *const conn,
+                          char **attributes,
+                          size_t attributes_len);
+int xmpp_conn_tls_start(xmpp_conn_t *const conn);
 
-void xmpp_send_raw_string(xmpp_conn_t * const conn, 
+void xmpp_disconnect(xmpp_conn_t *const conn);
-			  const char * const fmt, ...);
-void xmpp_send_raw(xmpp_conn_t * const conn, 
-		   const char * const data, const size_t len);
 
+void xmpp_send(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza);
+
+void xmpp_send_raw_string(xmpp_conn_t *const conn, const char *const fmt, ...);
+void xmpp_send_raw(xmpp_conn_t *const conn,
+                   const char *const data,
+                   const size_t len);
 
 /* handlers */
 
-/* if the handle returns false it is removed */
+/* if the handler returns false it is removed */
-typedef int (*xmpp_timed_handler)(xmpp_conn_t * const conn, 
+typedef int (*xmpp_timed_handler)(xmpp_conn_t *const conn,
-				  void * const userdata);
+                                  void *const userdata);
-
-void xmpp_timed_handler_add(xmpp_conn_t * const conn,
-			    xmpp_timed_handler handler,
-			    const unsigned long period,
-			    void * const userdata);
-void xmpp_timed_handler_delete(xmpp_conn_t * const conn,
-			       xmpp_timed_handler handler);
 
+void xmpp_timed_handler_add(xmpp_conn_t *const conn,
+                            xmpp_timed_handler handler,
+                            const unsigned long period,
+                            void *const userdata);
+void xmpp_timed_handler_delete(xmpp_conn_t *const conn,
+                               xmpp_timed_handler handler);
 
 /* if the handler returns false it is removed */
-typedef int (*xmpp_handler)(xmpp_conn_t * const conn,
+typedef int (*xmpp_global_timed_handler)(xmpp_ctx_t *const ctx,
-			     xmpp_stanza_t * const stanza,
+                                         void *const userdata);
-			     void * const userdata);
 
-void xmpp_handler_add(xmpp_conn_t * const conn,
+void xmpp_global_timed_handler_add(xmpp_ctx_t *const ctx,
-		      xmpp_handler handler,
+                                   xmpp_global_timed_handler handler,
-		      const char * const ns,
+                                   const unsigned long period,
-		      const char * const name,
+                                   void *const userdata);
-		      const char * const type,
+void xmpp_global_timed_handler_delete(xmpp_ctx_t *const ctx,
-		      void * const userdata);
+                                      xmpp_global_timed_handler handler);
-void xmpp_handler_delete(xmpp_conn_t * const conn,
-			 xmpp_handler handler);
 
-void xmpp_id_handler_add(xmpp_conn_t * const conn,
+/* if the handler returns false it is removed */
-			 xmpp_handler handler,
+typedef int (*xmpp_handler)(xmpp_conn_t *const conn,
-			 const char * const id,
+                            xmpp_stanza_t *const stanza,
-			 void * const userdata);
+                            void *const userdata);
-void xmpp_id_handler_delete(xmpp_conn_t * const conn,
+
-			    xmpp_handler handler,
+void xmpp_handler_add(xmpp_conn_t *const conn,
-			    const char * const id);
+                      xmpp_handler handler,
+                      const char *const ns,
+                      const char *const name,
+                      const char *const type,
+                      void *const userdata);
+void xmpp_handler_delete(xmpp_conn_t *const conn, xmpp_handler handler);
+
+void xmpp_id_handler_add(xmpp_conn_t *const conn,
+                         xmpp_handler handler,
+                         const char *const id,
+                         void *const userdata);
+void xmpp_id_handler_delete(xmpp_conn_t *const conn,
+                            xmpp_handler handler,
+                            const char *const id);
 
 /*
 void xmpp_register_stanza_handler(conn, stanza, xmlns, type, handler)
 */
 
-/** stanzas **/
+/* stanzas */
 
-/** allocate an initialize a blank stanza */
+/* allocate and initialize a blank stanza */
 xmpp_stanza_t *xmpp_stanza_new(xmpp_ctx_t *ctx);
+xmpp_stanza_t *xmpp_stanza_new_from_string(xmpp_ctx_t *ctx, const char *str);
 
-/** clone a stanza */
+/* clone a stanza */
-xmpp_stanza_t *xmpp_stanza_clone(xmpp_stanza_t * const stanza);
+xmpp_stanza_t *xmpp_stanza_clone(xmpp_stanza_t *const stanza);
 
-/** copies a stanza and all children */
+/* copies a stanza and all children */
-xmpp_stanza_t * xmpp_stanza_copy(const xmpp_stanza_t * const stanza);
+xmpp_stanza_t *xmpp_stanza_copy(const xmpp_stanza_t *const stanza);
 
-/** free a stanza object and it's contents */
+/* free a stanza object and it's contents */
-int xmpp_stanza_release(xmpp_stanza_t * const stanza);
+int xmpp_stanza_release(xmpp_stanza_t *const stanza);
 
-/** free some blocks returned by other APIs, for example the
+xmpp_ctx_t *xmpp_stanza_get_context(const xmpp_stanza_t *const stanza);
-    buffer you get from xmpp_stanza_to_text **/
-void xmpp_free(const xmpp_ctx_t * const ctx, void *p);
 
-int xmpp_stanza_is_text(xmpp_stanza_t * const stanza);
+int xmpp_stanza_is_text(xmpp_stanza_t *const stanza);
-int xmpp_stanza_is_tag(xmpp_stanza_t * const stanza);
+int xmpp_stanza_is_tag(xmpp_stanza_t *const stanza);
 
-/** marshall a stanza into text for transmission or display **/
+/* marshall a stanza into text for transmission or display */
-int xmpp_stanza_to_text(xmpp_stanza_t *stanza, 
+int xmpp_stanza_to_text(xmpp_stanza_t *stanza,
-			char ** const buf, size_t * const buflen);
+                        char **const buf,
+                        size_t *const buflen);
 
-xmpp_stanza_t *xmpp_stanza_get_children(xmpp_stanza_t * const stanza);
+xmpp_stanza_t *xmpp_stanza_get_children(xmpp_stanza_t *const stanza);
-xmpp_stanza_t *xmpp_stanza_get_child_by_name(xmpp_stanza_t * const 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 *xmpp_stanza_get_child_by_ns(xmpp_stanza_t * const 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 *xmpp_stanza_get_next(xmpp_stanza_t * const stanza);
+xmpp_stanza_t *xmpp_stanza_get_child_by_name_and_ns(xmpp_stanza_t *const stanza,
-char *xmpp_stanza_get_attribute(xmpp_stanza_t * const stanza,
+                                                    const char *const name,
-				const char * const name);
+                                                    const char *const ns);
-char * xmpp_stanza_get_ns(xmpp_stanza_t * const stanza);
+xmpp_stanza_t *xmpp_stanza_get_next(xmpp_stanza_t *const stanza);
+int xmpp_stanza_add_child(xmpp_stanza_t *stanza, xmpp_stanza_t *child);
+int xmpp_stanza_add_child_ex(xmpp_stanza_t *stanza,
+                             xmpp_stanza_t *child,
+                             int do_clone);
+
+const char *xmpp_stanza_get_attribute(xmpp_stanza_t *const stanza,
+                                      const char *const name);
+int xmpp_stanza_get_attribute_count(xmpp_stanza_t *const stanza);
+int xmpp_stanza_get_attributes(xmpp_stanza_t *const stanza,
+                               const char **attr,
+                               int attrlen);
 /* concatenate all child text nodes.  this function
  * returns a string that must be freed by the caller */
-
+char *xmpp_stanza_get_text(xmpp_stanza_t *const stanza);
-char *xmpp_stanza_get_text(xmpp_stanza_t * const stanza);
+const char *xmpp_stanza_get_text_ptr(xmpp_stanza_t *const stanza);
-char *xmpp_stanza_get_text_ptr(xmpp_stanza_t * const stanza);
+const char *xmpp_stanza_get_name(xmpp_stanza_t *const stanza);
-char *xmpp_stanza_get_name(xmpp_stanza_t * const stanza);
-
-int xmpp_stanza_add_child(xmpp_stanza_t *stanza, xmpp_stanza_t *child);
-int xmpp_stanza_set_ns(xmpp_stanza_t * const stanza, const char * const ns);
 /* set_attribute adds/replaces attributes */
-int xmpp_stanza_set_attribute(xmpp_stanza_t * const stanza, 
+int xmpp_stanza_set_attribute(xmpp_stanza_t *const stanza,
-			      const char * const key,
+                              const char *const key,
-			      const char * const value);
+                              const char *const value);
-int xmpp_stanza_set_name(xmpp_stanza_t *stanza,
+int xmpp_stanza_set_name(xmpp_stanza_t *stanza, const char *const name);
-			 const char * const name);
+int xmpp_stanza_set_text(xmpp_stanza_t *stanza, const char *const text);
-int xmpp_stanza_set_text(xmpp_stanza_t *stanza,
-			 const char * const text);
 int xmpp_stanza_set_text_with_size(xmpp_stanza_t *stanza,
-				   const char * const text, 
+                                   const char *const text,
-				   const size_t size);
+                                   const size_t size);
+int xmpp_stanza_del_attribute(xmpp_stanza_t *const stanza,
+                              const char *const name);
 
 /* common stanza helpers */
-char *xmpp_stanza_get_type(xmpp_stanza_t * const stanza);
+const char *xmpp_stanza_get_ns(xmpp_stanza_t *const stanza);
-char *xmpp_stanza_get_id(xmpp_stanza_t * const stanza);
+const char *xmpp_stanza_get_type(xmpp_stanza_t *const stanza);
-int xmpp_stanza_set_id(xmpp_stanza_t * const stanza, 
+const char *xmpp_stanza_get_id(xmpp_stanza_t *const stanza);
-		       const char * const id);
+const char *xmpp_stanza_get_to(xmpp_stanza_t *const stanza);
-int xmpp_stanza_set_type(xmpp_stanza_t * const stanza, 
+const char *xmpp_stanza_get_from(xmpp_stanza_t *const stanza);
-			 const char * const type);
+int xmpp_stanza_set_ns(xmpp_stanza_t *const stanza, const char *const ns);
-
+int xmpp_stanza_set_id(xmpp_stanza_t *const stanza, const char *const id);
-/* unimplemented
+int xmpp_stanza_set_type(xmpp_stanza_t *const stanza, const char *const type);
-int xmpp_stanza_set_to();
+int xmpp_stanza_set_to(xmpp_stanza_t *const stanza, const char *const to);
-int xmpp_stanza_set_from();
+int xmpp_stanza_set_from(xmpp_stanza_t *const stanza, const char *const from);
-*/
 
 /* allocate and initialize a stanza in reply to another */
-/* unimplemented
+xmpp_stanza_t *xmpp_stanza_reply(xmpp_stanza_t *const stanza);
-xmpp_stanza_t *xmpp_stanza_reply(const xmpp_stanza_t *stanza);
+xmpp_stanza_t *xmpp_stanza_reply_error(xmpp_stanza_t *const stanza,
-*/
+                                       const char *const error_type,
+                                       const char *const condition,
+                                       const char *const text);
 
 /* stanza subclasses */
-/* unimplemented
+xmpp_stanza_t *xmpp_message_new(xmpp_ctx_t *ctx,
-void xmpp_message_new();
+                                const char *const type,
-void xmpp_message_get_body();
+                                const char *const to,
-void xmpp_message_set_body();
+                                const char *const id);
+char *xmpp_message_get_body(xmpp_stanza_t *msg);
+int xmpp_message_set_body(xmpp_stanza_t *msg, const char *const text);
 
-void xmpp_iq_new();
+xmpp_stanza_t *
-void xmpp_presence_new();
+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);
 
-/** event loop **/
+/* jid */
-void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long  timeout);
+
+/* these return new strings that must be xmpp_free()'d */
+char *xmpp_jid_new(xmpp_ctx_t *ctx,
+                   const char *node,
+                   const char *domain,
+                   const char *resource);
+char *xmpp_jid_bare(xmpp_ctx_t *ctx, const char *jid);
+char *xmpp_jid_node(xmpp_ctx_t *ctx, const char *jid);
+char *xmpp_jid_domain(xmpp_ctx_t *ctx, const char *jid);
+char *xmpp_jid_resource(xmpp_ctx_t *ctx, const char *jid);
+
+/* event loop */
+
+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 */
+
+char *xmpp_uuid_gen(xmpp_ctx_t *ctx);
+
+/* SHA1 */
+
+/** @def XMPP_SHA1_DIGEST_SIZE
+ *  Size of the SHA1 message digest.
+ */
+#define XMPP_SHA1_DIGEST_SIZE 20
+
+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);
+void xmpp_sha1_update(xmpp_sha1_t *sha1, const unsigned char *data, size_t len);
+void xmpp_sha1_final(xmpp_sha1_t *sha1);
+char *xmpp_sha1_to_string(xmpp_sha1_t *sha1, char *s, size_t slen);
+char *xmpp_sha1_to_string_alloc(xmpp_sha1_t *sha1);
+void xmpp_sha1_to_digest(xmpp_sha1_t *sha1, unsigned char *digest);
+
+/* Base64 */
+
+char *
+xmpp_base64_encode(xmpp_ctx_t *ctx, const unsigned char *data, size_t len);
+char *xmpp_base64_decode_str(xmpp_ctx_t *ctx, const char *base64, size_t len);
+void xmpp_base64_decode_bin(xmpp_ctx_t *ctx,
+                            const char *base64,
+                            size_t len,
+                            unsigned char **out,
+                            size_t *outlen);
 
 #ifdef __cplusplus
 }

strophepp.h

@@ -1,136 +0,0 @@
-/* strophepp.h
-** strophe XMPP client library C++ API
-**
-** Copyright (C) 2005-2009 Collecta, Inc.
-**
-**  This software is provided AS-IS with no warranty, either express or
-**  implied.
-**
-**  This software is distributed under license and may not be copied,
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
-*/
-
-/** @file
- *  Strophe public C++ API definitions.
- */
-
-#ifndef __LIBSTROPHE_STROPHEPP_H__
-#define __LIBSTROPHE_STROPHEPP_H__
-
-#include "strophe.h"
-
-namespace XMPP {
-    class Context {
-    private:
-	xmpp_mem_t m_mem;
-	xmpp_log_t m_log;
-	xmpp_ctx_t *m_ctx;
-
-    public:
-	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);
-
-	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);
-    };
-
-    class Stanza {
-    private:
-	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();
-
-    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();
-        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);
-    };
-
-    class Connection {
-    private:
-	Context *m_ctx;
-	xmpp_conn_t *conn;
-
-	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);
-
-	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);
-    };
-}
-
-#endif /* __LIBSTROPHE_STROPHEPP_H__ */

tests/check_parser.c

@@ -1,75 +1,89 @@
 /* check_parser.h
 ** strophe XMPP client library -- parser tests
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 #include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
 
-#include <check.h>
+#include "strophe.h"
-
-#include <strophe.h>
 #include "parser.h"
 
 #include "test.h"
 
-START_TEST(create_destroy)
+#define fail_unless(expr)                                               \
+    do {                                                                \
+        int result = (expr);                                            \
+        if (!result) {                                                  \
+            printf("%s:%d: Assertion failed: %s\n", __FILE__, __LINE__, \
+                   #expr);                                              \
+            exit(1);                                                    \
+        }                                                               \
+    } while (0)
+
+static void create_destroy(void)
 {
     xmpp_ctx_t *ctx;
     parser_t *parser;
 
     ctx = xmpp_ctx_new(NULL, NULL);
     parser = parser_new(ctx, NULL, NULL, NULL, NULL);
-    fail_unless(parser != NULL, "Parser creation failed.");
+    fail_unless(parser != NULL);
     parser_free(parser);
     xmpp_ctx_free(ctx);
 }
-END_TEST
 
 int cbtest_got_start = 0;
 void cbtest_handle_start(char *name, char **attrs, void *userdata)
 {
-    if (strcmp(name, "stream:stream") == 0)
+    (void)attrs;
+    (void)userdata;
+
+    if (strcmp(name, "stream") == 0)
         cbtest_got_start = 1;
 }
 
 int cbtest_got_end = 0;
 void cbtest_handle_end(char *name, void *userdata)
 {
-    if (strcmp(name, "stream:stream") == 0)
+    (void)userdata;
+
+    if (strcmp(name, "stream") == 0)
         cbtest_got_end = 1;
 }
 
 int cbtest_got_stanza = 0;
 void cbtest_handle_stanza(xmpp_stanza_t *stanza, void *userdata)
 {
+    (void)userdata;
+
     if (strcmp(xmpp_stanza_get_name(stanza), "message") == 0)
         cbtest_got_stanza = 1;
 }
 
-START_TEST(callbacks)
+static void callbacks(void)
 {
     xmpp_ctx_t *ctx;
     parser_t *parser;
     int ret;
 
     ctx = xmpp_ctx_new(NULL, NULL);
-    parser = parser_new(ctx, 
+    parser = parser_new(ctx, cbtest_handle_start, cbtest_handle_end,
-                        cbtest_handle_start, 
-                        cbtest_handle_end,
                         cbtest_handle_stanza, NULL);
 
-    ret = parser_feed(parser, "<stream:stream>", 15);
+    ret = parser_feed(parser, "<stream>", 8);
+    fail_unless(ret != 0);
     ret = parser_feed(parser, "<message/>", 10);
-    parser_feed(parser, "</stream:stream>", 16);
+    fail_unless(ret != 0);
+    ret = parser_feed(parser, "</stream>", 9);
+    fail_unless(ret != 0);
 
     fail_unless(cbtest_got_start == 1);
     fail_unless(cbtest_got_end == 1);
@@ -78,16 +92,18 @@ START_TEST(callbacks)
     parser_free(parser);
     xmpp_ctx_free(ctx);
 }
-END_TEST
 
-Suite *parser_suite(void)
+int main()
 {
-    Suite *s = suite_create("Parser");
+    printf("XML parser tests.\n");
-    TCase *tc_core = tcase_create("Core");
-    tcase_add_test(tc_core, create_destroy);
-    tcase_add_test(tc_core, callbacks);
-    suite_add_tcase(s, tc_core);
-    return s;
-}
 
-TEST_MAIN
+    printf("create-destroy: ");
+    create_destroy();
+    printf("ok\n");
+
+    printf("callbacks: ");
+    callbacks();
+    printf("ok\n");
+
+    return 0;
+}

tests/res_query_dump.c

@@ -0,0 +1,90 @@
+/* res_query_dump.c
+ * Simple program to dump res_query(3) response
+ *
+ * Copyright (C) 2014 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.
+ */
+
+/* Linux and OSX:
+ *   gcc -o res_query_dump tests/res_query_dump.c -lresolv
+ * *BSD:
+ *   gcc -o res_query_dump tests/res_query_dump.c
+ * QNX:
+ *   gcc -o res_query_dump tests/res_query_dump.c -lsocket
+ * Solaris:
+ *   gcc -o res_query_dump tests/res_query_dump.c -lresolv -lsocket -lnsl
+ */
+
+#include <netinet/in.h>
+#include <arpa/nameser.h>
+#include <resolv.h>
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#ifndef T_SRV
+#define T_SRV 33
+#endif /* T_SRV */
+#ifndef C_IN
+#define C_IN 1
+#endif /* C_IN */
+
+#define STEP 10
+
+int main(int argc, char **argv)
+{
+    unsigned char buf[65536];
+    char fulldomain[2048];
+    char *service = "xmpp-client";
+    char *proto = "tcp";
+    char *domain = NULL;
+    int len;
+    int i;
+    int j;
+
+    if (argc < 2) {
+        fprintf(stderr, "%s: argument missed\n", argc > 0 ? argv[0] : "$0");
+        fprintf(stderr, "Usage: %s <domain>\n", argc > 0 ? argv[0] : "$0");
+        return 1;
+    }
+
+    domain = argv[1];
+    snprintf(fulldomain, sizeof(fulldomain), "_%s._%s.%s", service, proto,
+             domain);
+    errno = 0;
+    len = res_query(fulldomain, C_IN, T_SRV, buf, sizeof(buf));
+
+    if (len < 0) {
+        fprintf(stderr, "res_query(): Error occurred (errno=%d)\n", errno);
+    }
+    if (len == 0) {
+        fprintf(stderr, "res_query(): Empty result\n");
+    }
+    if (len > 0) {
+        printf("/* res_query(\"%s\", C_IN, T_SRV, ...) */\n", fulldomain);
+        printf("static const unsigned char data[] = {\n");
+        for (i = 0; i < len; i += STEP) {
+            printf("   ");
+            for (j = i; j < len && j < i + STEP; ++j) {
+                printf(" 0x%02x,", buf[j]);
+            }
+            for (j = len; j < i + STEP; ++j) {
+                printf("      ");
+            }
+            printf("    // ");
+            for (j = i; j < len && j < i + STEP; ++j) {
+                printf("%c", isprint(buf[j]) ? buf[j] : '.');
+            }
+            printf("\n");
+        }
+        printf("};\n");
+    }
+
+    return len <= 0;
+}

tests/test.c

@@ -0,0 +1,54 @@
+/* test.c
+ * strophe XMPP client library -- common routines for tests
+ *
+ * Copyright (C) 2014 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 <string.h>
+
+#include "test.h"
+
+static uint8_t char_to_bin(char c)
+{
+    return c <= '9'
+               ? (uint8_t)(c - '0')
+               : c <= 'Z' ? (uint8_t)(c - 'A' + 10) : (uint8_t)(c - 'a' + 10);
+}
+
+void test_hex_to_bin(const char *hex, uint8_t *bin, size_t *bin_len)
+{
+    size_t len = strlen(hex);
+    size_t i;
+
+    assert(len % 2 == 0);
+
+    for (i = 0; i < len / 2; ++i) {
+        bin[i] = char_to_bin(hex[i * 2]) * 16 + char_to_bin(hex[i * 2 + 1]);
+    }
+    *bin_len = len / 2;
+}
+
+const char *test_bin_to_hex(const uint8_t *bin, size_t len)
+{
+    static char buf[2048];
+    size_t i;
+
+    static const char hex[] = {'0', '1', '2', '3', '4', '5', '6', '7',
+                               '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+
+    assert(ARRAY_SIZE(buf) > len * 2);
+
+    for (i = 0; i < len; ++i) {
+        buf[i * 2] = hex[(bin[i] >> 4) & 0x0f];
+        buf[i * 2 + 1] = hex[bin[i] & 0x0f];
+    }
+    buf[len * 2] = '\0';
+
+    return buf;
+}

tests/test.h

@@ -1,16 +1,66 @@
+/* test.h
+** libstrophe XMPP client library -- common routines for tests
+**
+** 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.
+*/
+
 #ifndef __LIBSTROPHE_TEST_H__
 #define __LIBSTROPHE_TEST_H__
 
-#define TEST_MAIN \
+#include <stddef.h>
-    int main(int argc, char **argv) {\
+#include <stdlib.h>
-    int num_failed;\
+#include <string.h>
-    Suite *s = parser_suite();\
+#include "ostypes.h"
-    SRunner *sr = srunner_create(s);\
+
-    srunner_run_all(sr, CK_NORMAL);\
+#define TEST_MAIN                                               \
-    num_failed = srunner_ntests_failed(sr);\
+    int main(int argc, char **argv)                             \
-    srunner_free(sr);\
+    {                                                           \
-    return (num_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;\
+        int num_failed;                                         \
-    }\
+        Suite *s = parser_suite();                              \
-      
+        SRunner *sr = srunner_create(s);                        \
+        srunner_run_all(sr, CK_NORMAL);                         \
+        num_failed = srunner_ntests_failed(sr);                 \
+        srunner_free(sr);                                       \
+        return (num_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE; \
+    }
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+#endif
+
+#define COMPARE(v1, v2)                \
+    do {                               \
+        const char *__v1 = v1;         \
+        const char *__v2 = v2;         \
+        if (strcmp(__v1, __v2) != 0) { \
+            printf("%s differs!\n"     \
+                   "expected: %s\n"    \
+                   "got:      %s\n",   \
+                   #v1, __v1, __v2);   \
+            exit(1);                   \
+        }                              \
+    } while (0)
+
+#define COMPARE_BUF(v1, len1, v2, len2)                                \
+    do {                                                               \
+        const uint8_t *__v1 = (uint8_t *)(v1);                         \
+        const uint8_t *__v2 = (uint8_t *)(v2);                         \
+        size_t __len1 = len1;                                          \
+        size_t __len2 = len2;                                          \
+        if (__len1 != __len2 || memcmp(__v1, __v2, __len1) != 0) {     \
+            printf("%s differs!\n", #v1);                              \
+            printf("expected: 0x%s\n", test_bin_to_hex(__v1, __len1)); \
+            printf("got:      0x%s\n", test_bin_to_hex(__v2, __len2)); \
+            exit(1);                                                   \
+        }                                                              \
+    } while (0)
+
+void test_hex_to_bin(const char *hex, uint8_t *bin, size_t *bin_len);
+const char *test_bin_to_hex(const uint8_t *bin, size_t len);
 
 #endif /* __LIBSTROPHE_TEST_H__ */

tests/test_base64.c

@@ -1,151 +1,163 @@
 /* test_base64.c
 ** libstrophe XMPP client library -- test routines for the base64 codec
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
+#include <assert.h>
 #include <stdio.h>
 #include <string.h>
 
 #include "strophe.h"
-#include "common.h"
-#include "sasl.h"
 
-static const unsigned char text_1[] = "How now brown cow?";
+#include "test.h"
-static const char base64_1[] = "SG93IG5vdyBicm93biBjb3c/";
-static const unsigned char text_2[] = {0x14,0xfb,0x9c,0x03,0xd9,0x7e,0x00};
-static const char base64_2[] = "FPucA9l+";
-static const unsigned char text_3[] = 
-    "From rest and sleep, which but thy pictures be, "
-    "Much pleasure; then from thee much more must flow, "
-    "And soonest our best men with thee do go, "
-    "Rest of their bones, and soul's delivery.";
-static const char base64_3[] =
-    "RnJvbSByZXN0IGFuZCBzbGVlcCwgd2hpY2ggYnV0IHRoeSBwaWN0dXJl"
-    "cyBiZSwgTXVjaCBwbGVhc3VyZTsgdGhlbiBmcm9tIHRoZWUgbXVjaCBt"
-    "b3JlIG11c3QgZmxvdywgQW5kIHNvb25lc3Qgb3VyIGJlc3QgbWVuIHdp"
-    "dGggdGhlZSBkbyBnbywgUmVzdCBvZiB0aGVpciBib25lcywgYW5kIHNv"
-    "dWwncyBkZWxpdmVyeS4=";
-static const unsigned char text_4[] = 
-    {0xd6, 0x2f, 0x27, 0x49,  0x7e, 0xdd, 0xf3, 0xd5, 
-     0x41, 0xbc, 0x1b, 0xe9,  0xdf, 0xe9, 0xb3, 0x08, 0x00};
-static const char base64_4[] = "1i8nSX7d89VBvBvp3+mzCA==";
-static const char text_5[] = 
-    "realm=\"chesspark.com\",nonce=\"b243c0d663257a9149999cef2f83a22116559e93\",qop=\"auth\",charset=utf-8,algorithm=md5-sess";
-static const char base64_5[] = 
-    "cmVhbG09ImNoZXNzcGFyay5jb20iLG5vbmNlPSJiMjQzYzBkNjYzMjU3"
-    "YTkxNDk5OTljZWYyZjgzYTIyMTE2NTU5ZTkzIixxb3A9ImF1dGgiLGNo"
-    "YXJzZXQ9dXRmLTgsYWxnb3JpdGhtPW1kNS1zZXNz";
 
-int test_encode(xmpp_ctx_t *ctx)
+static const unsigned char test_2_raw[] = {0x14, 0xfb, 0x9c, 0x03,
-{
+                                           0xd9, 0x7e, 0x00};
-    char *result;
+static const unsigned char test_4_raw[] = {0xd6, 0x2f, 0x27, 0x49, 0x7e, 0xdd,
-    result = base64_encode(ctx, text_1, strlen(text_1));
+                                           0xf3, 0xd5, 0x41, 0xbc, 0x1b, 0xe9,
-    if (result == NULL) return 2;
+                                           0xdf, 0xe9, 0xb3, 0x08, 0x00};
-    if (strlen(result) != strlen(base64_1)) return 1;
-    if (strncmp(base64_1, result, strlen(base64_1))) return 1;
-    xmpp_free(ctx,result);
 
-    result = base64_encode(ctx, text_2, strlen(text_2));
+static const struct {
-    if (result == NULL) return 2;
+    char *raw;
-    if (strlen(result) != strlen(base64_2)) return 1;
+    char *base64;
-    if (strncmp(base64_2, result, strlen(base64_2))) return 1;
+} tests[] = {
-    xmpp_free(ctx,result);
+    {
+        .raw = "How now brown cow?",
+        .base64 = "SG93IG5vdyBicm93biBjb3c/",
+    },
+    {
+        .raw = (char *)test_2_raw,
+        .base64 = "FPucA9l+",
+    },
+    {
+        .raw = "From rest and sleep, which but thy pictures be, "
+               "Much pleasure; then from thee much more must flow, "
+               "And soonest our best men with thee do go, "
+               "Rest of their bones, and soul's delivery.",
+        .base64 = "RnJvbSByZXN0IGFuZCBzbGVlcCwgd2hpY2ggYnV0IHRoeSBwaWN0dXJl"
+                  "cyBiZSwgTXVjaCBwbGVhc3VyZTsgdGhlbiBmcm9tIHRoZWUgbXVjaCBt"
+                  "b3JlIG11c3QgZmxvdywgQW5kIHNvb25lc3Qgb3VyIGJlc3QgbWVuIHdp"
+                  "dGggdGhlZSBkbyBnbywgUmVzdCBvZiB0aGVpciBib25lcywgYW5kIHNv"
+                  "dWwncyBkZWxpdmVyeS4=",
+    },
+    {
+        .raw = (char *)test_4_raw,
+        .base64 = "1i8nSX7d89VBvBvp3+mzCA==",
+    },
+    {
+        .raw = "realm=\"chesspark.com\",nonce=\"b243c0d663257a9149999cef2f83"
+               "a22116559e93\",qop=\"auth\",charset=utf-8,algorithm=md5-sess",
+        .base64 = "cmVhbG09ImNoZXNzcGFyay5jb20iLG5vbmNlPSJiMjQzYzBkNjYzMjU3"
+                  "YTkxNDk5OTljZWYyZjgzYTIyMTE2NTU5ZTkzIixxb3A9ImF1dGgiLGNo"
+                  "YXJzZXQ9dXRmLTgsYWxnb3JpdGhtPW1kNS1zZXNz",
+    },
 
-    result = base64_encode(ctx, text_3, strlen(text_3));
+    /* RFC4648 test vectors */
-    if (result == NULL) return 2;
+    {
-    if (strlen(result) != strlen(base64_3)) return 1;
+        .raw = "",
-    if (strncmp(base64_3, result, strlen(base64_3))) return 1;
+        .base64 = "",
-    xmpp_free(ctx,result);
+    },
+    {
+        .raw = "f",
+        .base64 = "Zg==",
+    },
+    {
+        .raw = "fo",
+        .base64 = "Zm8=",
+    },
+    {
+        .raw = "foo",
+        .base64 = "Zm9v",
+    },
+    {
+        .raw = "foob",
+        .base64 = "Zm9vYg==",
+    },
+    {
+        .raw = "fooba",
+        .base64 = "Zm9vYmE=",
+    },
+    {
+        .raw = "foobar",
+        .base64 = "Zm9vYmFy",
+    },
+};
 
-    result = base64_encode(ctx, text_4, strlen(text_4));
+static const unsigned char bin_data[] = {
-    if (result == NULL) return 2;
+    0xda, 0xa8, 0x81, 0x80, 0x00, 0x01, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
-    if (strlen(result) != strlen(base64_4)) return 1;
+    0x0c, 0x5f, 0x78, 0x6d, 0x70, 0x70, 0x2d, 0x63, 0x6c, 0x69, 0x65, 0x6e,
-    if (strncmp(base64_4, result, strlen(base64_4))) return 1;
+    0x74, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x05, 0x67, 0x6d, 0x61, 0x69, 0x6c,
-    xmpp_free(ctx,result);
+    0x03, 0x63, 0x6f, 0x6d, 0x00, 0x00, 0x21, 0x00, 0x01, 0xc0, 0x0c, 0x00,
+    0x21, 0x00, 0x01, 0x00, 0x00, 0x02, 0x43, 0x00, 0x1e, 0x00, 0x14, 0x00,
+    0x00, 0x14, 0x66, 0x04, 0x61, 0x6c, 0x74, 0x31, 0x04, 0x78, 0x6d, 0x70,
+    0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63,
+    0x6f, 0x6d, 0x00, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x02,
+    0x43, 0x00, 0x1e, 0x00, 0x14, 0x00, 0x00, 0x14, 0x66, 0x04, 0x61, 0x6c,
+    0x74, 0x34, 0x04, 0x78, 0x6d, 0x70, 0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f,
+    0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, 0xc0, 0x0c, 0x00,
+    0x21, 0x00, 0x01, 0x00, 0x00, 0x02, 0x43, 0x00, 0x1e, 0x00, 0x14, 0x00,
+    0x00, 0x14, 0x66, 0x04, 0x61, 0x6c, 0x74, 0x32, 0x04, 0x78, 0x6d, 0x70,
+    0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63,
+    0x6f, 0x6d, 0x00, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x02,
+    0x43, 0x00, 0x19, 0x00, 0x05, 0x00, 0x00, 0x14, 0x66, 0x04, 0x78, 0x6d,
+    0x70, 0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03,
+    0x63, 0x6f, 0x6d, 0x00, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00,
+    0x02, 0x43, 0x00, 0x1e, 0x00, 0x14, 0x00, 0x00, 0x14, 0x66, 0x04, 0x61,
+    0x6c, 0x74, 0x33, 0x04, 0x78, 0x6d, 0x70, 0x70, 0x01, 0x6c, 0x06, 0x67,
+    0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00,
+};
 
-    result = base64_encode(ctx, text_5, strlen(text_5));
+int main()
-    if (result == NULL) return 2;
-    if (strlen(result) != strlen(base64_5)) return 1;
-    if (strncmp(base64_5, result, strlen(base64_5))) return 1;
-    xmpp_free(ctx,result);
-
-    return 0;
-}
-
-
-int test_decode(xmpp_ctx_t *ctx)
-{
-    unsigned char *result;
-
-    result = base64_decode(ctx, base64_1, strlen(base64_1));
-    if (result == NULL) return 2;
-    if (strlen(result) != strlen(text_1)) return 1;
-    if (strncmp(text_1, result, strlen(text_1))) return 1;
-    xmpp_free(ctx,result);
-
-    result = base64_decode(ctx, base64_2, strlen(base64_2));
-    if (result == NULL) return 2;
-    if (strlen(result) != strlen(text_2)) return 1;
-    if (strncmp(text_2, result, strlen(text_2))) return 1;
-    xmpp_free(ctx,result);
-
-    result = base64_decode(ctx, base64_3, strlen(base64_3));
-    if (result == NULL) return 2;
-    if (strlen(result) != strlen(text_3)) return 1;
-    if (strncmp(text_3, result, strlen(text_3))) return 1;
-    xmpp_free(ctx,result);
-
-    result = base64_decode(ctx, base64_4, strlen(base64_4));
-    if (result == NULL) return 2;
-    if (strlen(result) != strlen(text_4)) return 1;
-    if (strncmp(text_4, result, strlen(text_4))) return 1;
-    xmpp_free(ctx,result);
-
-    result = base64_decode(ctx, base64_5, strlen(base64_5));
-    if (result == NULL) return 2;
-    if (strlen(result) != strlen(text_5)) return 1;
-    if (strncmp(text_5, result, strlen(text_5))) return 1;
-    xmpp_free(ctx,result);
-
-    return 0;
-}
-
-
-int main(int argc, char *argv[])
 {
     xmpp_ctx_t *ctx;
-    int ret;
+    unsigned char *udec;
+    char *dec;
+    char *enc;
+    size_t len, i;
+
+    printf("BASE64 tests.\n");
 
-    printf("allocating context... ");   
     ctx = xmpp_ctx_new(NULL, NULL);
-    if (ctx == NULL) printf("failed to create context\n");
+    if (ctx == NULL) {
-    if (ctx == NULL) return -1;
+        fprintf(stderr, "failed to create context\n");
-    printf("ok.\n");
+        return 1;
+    }
 
-    printf("testing encode... ");   
+    for (i = 0; i < ARRAY_SIZE(tests); ++i) {
-    ret = test_encode(ctx);
+        printf("Test #%d: ", (int)i + 1);
-    if (ret) printf("base64_encode failed!\n");
+        enc = xmpp_base64_encode(ctx, (unsigned char *)tests[i].raw,
-    if (ret) return ret;
+                                 strlen(tests[i].raw));
-    printf("ok.\n");
+        assert(enc != NULL);
+        COMPARE(tests[i].base64, enc);
+        xmpp_free(ctx, enc);
 
-    printf("testing decode... ");   
+        dec = xmpp_base64_decode_str(ctx, tests[i].base64,
-    ret = test_decode(ctx);
+                                     strlen(tests[i].base64));
-    if (ret) printf("base64_decode failed!\n");
+        assert(dec != NULL);
-    if (ret) return ret;
+        COMPARE_BUF(tests[i].raw, strlen(tests[i].raw), dec, strlen(dec));
-    printf("ok.\n");
+        xmpp_free(ctx, dec);
+        printf("ok\n");
+    }
+
+    printf("Test with binary data: ");
+    enc = xmpp_base64_encode(ctx, bin_data, sizeof(bin_data));
+    assert(enc != NULL);
+    xmpp_base64_decode_bin(ctx, enc, strlen(enc), &udec, &len);
+    assert(udec != NULL);
+    assert(len != 0);
+    assert(len == sizeof(bin_data));
+    COMPARE_BUF(bin_data, sizeof(bin_data), udec, len);
+    xmpp_free(ctx, udec);
+    xmpp_free(ctx, enc);
+    printf("ok\n");
 
-    printf("freeing context... ");
     xmpp_ctx_free(ctx);
-    printf("ok.\n");
 
-    return ret;
+    return 0;
 }

tests/test_ctx.c

@@ -1,15 +1,13 @@
 /* test_ctx.c
-** libstrophe XMPP client library -- test routines for the library run-time context
+** libstrophe XMPP client library -- test routines for the library run-time
+*context
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 #include <stdio.h>
@@ -24,33 +22,41 @@ static int mem_alloc_called = 0;
 static int mem_free_called = 0;
 static int mem_realloc_called = 0;
 
-void *my_alloc(const size_t size, void * const userdata)
+void *my_alloc(const size_t size, void *const userdata)
 {
+    (void)userdata;
+
     mem_alloc_called++;
     return malloc(size);
 }
 
-void my_free(void *p, void * const userdata)
+void my_free(void *p, void *const userdata)
 {
+    (void)userdata;
+
     mem_free_called++;
     return free(p);
 }
 
-void *my_realloc(void *p, const size_t size, void * const userdata)
+void *my_realloc(void *p, const size_t size, void *const userdata)
 {
+    (void)userdata;
+
     mem_realloc_called++;
     return realloc(p, size);
 }
 
-void my_logger(void * const userdata, const xmpp_log_level_t level,
+void my_logger(void *const userdata,
-	       const char * const area, const char * const msg)
+               const xmpp_log_level_t level,
+               const char *const area,
+               const char *const msg)
 {
-    if (strcmp((char *)userdata, "asdf") == 0 && level == XMPP_LEVEL_DEBUG
+    if (strcmp((char *)userdata, "asdf") == 0 && level == XMPP_LEVEL_DEBUG &&
-	&& strcmp(area, "test") == 0 && strcmp(msg, "hello") == 0)
+        strcmp(area, "test") == 0 && strcmp(msg, "hello") == 0)
-	log_called++;
+        log_called++;
 }
 
-int main(int argc, char **argv)
+int main()
 {
     xmpp_ctx_t *ctx;
     xmpp_mem_t mymem;
@@ -59,7 +65,8 @@ int main(int argc, char **argv)
     void *testptr1, *testptr2;
 
     ctx = xmpp_ctx_new(NULL, NULL);
-    if (ctx == NULL) return 1;
+    if (ctx == NULL)
+        return 1;
 
     /* destroy context */
     xmpp_ctx_free(ctx);
@@ -78,15 +85,15 @@ int main(int argc, char **argv)
 
     testptr1 = xmpp_alloc(ctx, 1024);
     if (testptr1 == NULL) {
-	xmpp_ctx_free(ctx);
+        xmpp_ctx_free(ctx);
-	return 1;
+        return 1;
     }
 
     testptr2 = xmpp_realloc(ctx, testptr1, 2048);
     if (testptr2 == NULL) {
-	xmpp_free(ctx, testptr1);
+        xmpp_free(ctx, testptr1);
-	xmpp_ctx_free(ctx);
+        xmpp_ctx_free(ctx);
-	return 1;
+        return 1;
     }
 
     xmpp_free(ctx, testptr2);
@@ -94,9 +101,11 @@ int main(int argc, char **argv)
     xmpp_ctx_free(ctx);
 
     /* check for test failure */
-    if (!(log_called && mem_alloc_called && mem_realloc_called && 
+    if (!(log_called && mem_alloc_called && mem_realloc_called &&
-	  mem_free_called))
+          mem_free_called))
-	return 1;
+        return 1;
-    
+    if (mem_alloc_called != mem_free_called)
+        return 1;
+
     return 0;
 }

tests/test_hash.c

@@ -1,15 +1,12 @@
 /* test_hash.c
 ** libstrophe XMPP client library -- self-test for the hash-table 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.
 **
-**  This software is distributed under license and may not be copied,
+** This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 #include <stdlib.h>
@@ -19,18 +16,15 @@
 #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 *keys[] = {
+const char *values[] = {"wuzzle", "mug", "canonical", "rosebud", "lottery"};
-  "foo", "bar", "baz", "quux", "xyzzy"
+const int nkeys = ARRAY_SIZE(keys);
-};
-const char *values[] = {
-  "wuzzle", "mug", "canonical", "rosebud", "lottery"
-};
 
 int main(int argc, char **argv)
 {
@@ -45,10 +39,10 @@ int main(int argc, char **argv)
 
     /* initialize random numbers */
     if (argc > 2) {
-	/* use a seed from the command line */
+        /* use a seed from the command line */
-	seed = (unsigned int)atoi(argv[1]);
+        seed = (unsigned int)atoi(argv[1]);
     } else {
-	seed = (unsigned int)clock();
+        seed = (unsigned int)clock();
     }
     /* using random seed 'seed' */
     srand(seed);
@@ -56,64 +50,81 @@ int main(int argc, char **argv)
     /* allocate a default context */
     ctx = xmpp_ctx_new(NULL, NULL);
     if (ctx == NULL) {
-	/* ctx allocation failed! */
+        /* ctx allocation failed! */
-	return -1;
+        return -1;
     }
 
     /* allocate a hash table */
-    table = hash_new(ctx, TABLESIZE, NULL);
+    table = hash_new(ctx, TABLESIZE, xmpp_free);
     if (table == NULL) {
-	/* table allocation failed! */
+        /* table allocation failed! */
-	return 1;
+        return 1;
     }
 
     /* 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;
+        if (err)
+            return err;
     }
 
     /* test key count */
     if (hash_num_keys(table) != nkeys) {
-	/* wrong number of keys in table! */
+        /* wrong number of keys in table! */
-	return 1;
+        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);
 
     /* test lookup */
     for (i = 0; i < nkeys; i++) {
-	result = hash_get(clone, keys[i]);
+        result = hash_get(clone, keys[i]);
-	if (result == NULL) {
+        if (result == NULL) {
-	    /* lookup failed! */
+            /* lookup failed! */
-	    return 1;
+            return 1;
-	}
+        }
-	if (strcmp(values[i], result)) {
+        if (strcmp(values[i], result)) {
-	    /* lookup returned incorrect value! */
+            /* lookup returned incorrect value! */
-	    return 1;
+            return 1;
-	}
+        }
     }
 
     /* test key iterator */
     iter = hash_iter_new(clone);
     if (iter == NULL) {
-	/* iterator allocation failed! */
+        /* iterator allocation failed! */
-	return 1;
+        return 1;
     }
     for (i = 0; i < nkeys; i++) {
-	key = hash_iter_next(iter);
+        key = hash_iter_next(iter);
-	printf("key: '%s'\n", key);
+        printf("key: '%s'\n", key);
     }
     key = hash_iter_next(iter);
     if (key != NULL) {
-	/* extra keys returned! */
+        /* extra keys returned! */
-	return 1;
+        return 1;
     }
     key = hash_iter_next(iter);
     if (key != NULL) {
-	/* extra keys returned! */
+        /* extra keys returned! */
-	return 1;
+        return 1;
     }
     hash_iter_release(iter);
 
@@ -122,14 +133,19 @@ int main(int argc, char **argv)
 
     /* test drops */
     hash_drop(clone, keys[2]);
-    if (hash_get(clone, keys[2]) != NULL) return 1;
+    if (hash_get(clone, keys[2]) != NULL)
+        return 1;
     hash_drop(clone, keys[1]);
     hash_drop(clone, keys[4]);
-    if (hash_get(clone, keys[4]) != NULL) return 1;
+    if (hash_get(clone, keys[4]) != NULL)
-    if (hash_get(clone, keys[1]) != NULL) return 1;
+        return 1;
+    if (hash_get(clone, keys[1]) != NULL)
+        return 1;
     /* keys 0,3 should still be available */
-    if (hash_get(clone, keys[0]) == NULL) return 1;
+    if (hash_get(clone, keys[0]) == NULL)
-    if (hash_get(clone, keys[3]) == NULL) return 1;
+        return 1;
+    if (hash_get(clone, keys[3]) == NULL)
+        return 1;
 
     /* release our clone */
     hash_release(clone);

tests/test_jid.c

@@ -1,15 +1,12 @@
-/* test_base64.c
+/* test_jid.c
 ** libstrophe XMPP client library -- test routines for the jid utils
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 #include <stdio.h>
@@ -23,59 +20,109 @@ static const char jid2[] = "anyone@example.com/hullo";
 static const char jid3[] = "manic.porter@xyz.net/frob";
 static const char jid4[] = "domain.tld";
 
+static const char *_s(const char *s)
+{
+    return s == NULL ? "<NULL>" : 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",
+    printf("jid '%s' parsed to %s, %s, %s\n", jid1, _s(node), _s(domain),
-	jid1, node, domain, resource);
+           _s(resource));
-    if (strcmp(node, "foo")) return 1;
+    if (bare == NULL || strcmp(bare, "foo@bar.com"))
-    if (strcmp(domain, "bar.com")) return 1;
+        return 1;
-    if (resource != NULL) return 1;
+    if (node == NULL || strcmp(node, "foo"))
-    if (node) xmpp_free(ctx, node);
+        return 1;
-    if (domain) xmpp_free(ctx, domain);
+    if (domain == NULL || strcmp(domain, "bar.com"))
-    if (resource) xmpp_free(ctx, resource);
+        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",
+    printf("jid '%s' parsed to %s, %s, %s\n", jid2, _s(node), _s(domain),
-	jid2, node, domain, resource);
+           _s(resource));
-    if (strcmp(node, "anyone")) return 1;
+    if (bare == NULL || strcmp(bare, "anyone@example.com"))
-    if (strcmp(domain, "example.com")) return 1;
+        return 1;
-    if (strcmp(resource, "hullo")) return 1;
+    if (node == NULL || strcmp(node, "anyone"))
-    if (node) xmpp_free(ctx, node);
+        return 1;
-    if (domain) xmpp_free(ctx, domain);
+    if (domain == NULL || strcmp(domain, "example.com"))
-    if (resource) xmpp_free(ctx, resource);
+        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",
+    printf("jid '%s' parsed to %s, %s, %s\n", jid3, _s(node), _s(domain),
-	jid3, node, domain, resource);
+           _s(resource));
-    if (strcmp(node, "manic.porter")) return 1;
+    if (bare == NULL || strcmp(bare, "manic.porter@xyz.net"))
-    if (strcmp(domain, "xyz.net")) return 1;
+        return 1;
-    if (strcmp(resource, "frob")) return 1;
+    if (node == NULL || strcmp(node, "manic.porter"))
-    if (node) xmpp_free(ctx, node);
+        return 1;
-    if (domain) xmpp_free(ctx, domain);
+    if (domain == NULL || strcmp(domain, "xyz.net"))
-    if (resource) xmpp_free(ctx, resource);
+        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",
+    printf("jid '%s' parsed to %s, %s, %s\n", jid4, _s(node), _s(domain),
-	jid4, node, domain, resource);
+           _s(resource));
-    if (node != NULL) return 1;
+    if (bare == NULL || strcmp(bare, "domain.tld"))
-    if (strcmp(domain, "domain.tld")) return 1;
+        return 1;
-    if (resource != NULL) return 1;
+    if (node != NULL)
-    if (node) xmpp_free(ctx, node);
+        return 1;
-    if (domain) xmpp_free(ctx, domain);
+    if (domain == NULL || strcmp(domain, "domain.tld"))
-    if (resource) xmpp_free(ctx, resource);
+        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);
 
     return 0;
 }
@@ -86,39 +133,47 @@ int test_jid_new(xmpp_ctx_t *ctx)
 
     jid = xmpp_jid_new(ctx, "node", "domain", "resource");
     printf("new jid: '%s'\n", jid);
-    if (strcmp(jid, "node@domain/resource")) return 1;
+    if (strcmp(jid, "node@domain/resource"))
+        return 1;
     xmpp_free(ctx, jid);
 
     jid = xmpp_jid_new(ctx, "foo", "bar.com", NULL);
     printf("new jid: '%s'\n", jid);
-    if (strcmp(jid, "foo@bar.com")) return 1;
+    if (strcmp(jid, "foo@bar.com"))
+        return 1;
     xmpp_free(ctx, jid);
 
     return 0;
 }
 
-int main(int argc, char *argv[])
+int main()
 {
     xmpp_ctx_t *ctx;
     int ret;
 
-    printf("allocating context... ");   
+    printf("allocating context... ");
     ctx = xmpp_ctx_new(NULL, NULL);
-    if (ctx == NULL) printf("failed to create context\n");
+    if (ctx == NULL)
-    if (ctx == NULL) return -1;
+        printf("failed to create context\n");
+    if (ctx == NULL)
+        return -1;
     printf("ok.\n");
 
-    printf("testing jid routines... ");   
+    printf("testing jid routines...\n");
     ret = test_jid(ctx);
-    if (ret) printf("failed!\n");
+    if (ret)
-    if (ret) return ret;
+        printf("testing jid routines... failed!\n");
-    printf("ok.\n");
+    if (ret)
+        return ret;
+    printf("testing jid routines... ok.\n");
 
-    printf("testing jid new routines... ");   
+    printf("testing jid new routines...\n");
     ret = test_jid_new(ctx);
-    if (ret) printf("failed!\n");
+    if (ret)
-    if (ret) return ret;
+        printf("testing jid new routines... failed!\n");
-    printf("ok.\n");
+    if (ret)
+        return ret;
+    printf("testing jid new routines... ok.\n");
 
     printf("freeing context... ");
     xmpp_ctx_free(ctx);

tests/test_md5.c

@@ -0,0 +1,77 @@
+/* test_md5.c
+ * strophe XMPP client library -- test vectors for MD5
+ *
+ * Copyright (C) 2015 Dmitry Podgorny <pasis.ua@gmail.com>
+ *
+ *  This software is provided AS-IS with no warranty, either express
+ *  or implied.
+ *
+ *  This program is dual licensed under the MIT and GPLv3 licenses.
+ */
+
+/* gcc -o test_md5 -I./src tests/test_md5.c tests/test.c src/md5.c */
+
+#include <stdio.h>
+#include <string.h>
+
+#include "test.h"
+#include "md5.h"
+
+/*
+ * Test vectors for MD5 (RFC1321).
+ */
+static const struct {
+    const char *data;
+    const char *md5;
+} tests[] = {
+    {
+        .data = "",
+        .md5 = "d41d8cd98f00b204e9800998ecf8427e",
+    },
+    {
+        .data = "a",
+        .md5 = "0cc175b9c0f1b6a831c399e269772661",
+    },
+    {
+        .data = "abc",
+        .md5 = "900150983cd24fb0d6963f7d28e17f72",
+    },
+    {
+        .data = "message digest",
+        .md5 = "f96b697d7cb7938d525a2f31aaf161d0",
+    },
+    {
+        .data = "abcdefghijklmnopqrstuvwxyz",
+        .md5 = "c3fcd3d76192e4007dfb496cca67e13b",
+    },
+    {
+        .data = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcde"
+                "fghijklmnopqrstuvwxyz0123456789",
+        .md5 = "d174ab98d277d9f5a5611c2c9f419d9f",
+    },
+    {
+        .data = "1234567890123456789012345678901"
+                "2345678901234567890123456789012"
+                "345678901234567890",
+        .md5 = "57edf4a22be3c955ac49da2e2107b67a",
+    },
+};
+
+int main()
+{
+    struct MD5Context ctx;
+    unsigned char digest[16];
+    size_t i;
+
+    printf("MD5 tests.\n");
+
+    for (i = 0; i < ARRAY_SIZE(tests); ++i) {
+        printf("Test #%zu: ", i + 1);
+        MD5Init(&ctx);
+        MD5Update(&ctx, (unsigned char *)tests[i].data, strlen(tests[i].data));
+        MD5Final(digest, &ctx);
+        COMPARE(tests[i].md5, test_bin_to_hex(digest, sizeof(digest)));
+        printf("ok\n");
+    }
+    return 0;
+}

tests/test_rand.c

@@ -0,0 +1,160 @@
+/* check_rand.c
+ * strophe XMPP client library -- test vectors for Hash_DRBG
+ *
+ * Copyright (C) 2014 Dmitry Podgorny <pasis.ua@gmail.com>
+ *
+ *  This software is provided AS-IS with no warranty, either express
+ *  or implied.
+ *
+ *  This program is dual licensed under the MIT and GPLv3 licenses.
+ */
+
+/* gcc -o test_rand -I./src tests/test_rand.c tests/test.c src/sha1.c */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "test.h"
+
+/* include rand.c to access private structures and functions */
+#include "rand.c"
+
+/* stubs to build test without whole libstrophe */
+void *xmpp_alloc(const xmpp_ctx_t *const ctx, const size_t size)
+{
+    (void)ctx;
+    (void)size;
+    return NULL;
+}
+
+void xmpp_free(const xmpp_ctx_t *const ctx, void *p)
+{
+    (void)ctx;
+    (void)p;
+}
+
+int xmpp_snprintf(char *str, size_t count, const char *fmt, ...)
+{
+    (void)str;
+    (void)count;
+    (void)fmt;
+    return 0;
+}
+
+uint64_t time_stamp(void)
+{
+    return 0;
+}
+
+static struct {
+    const char *entropy_input;
+    const char *nonce;
+    size_t returned_bytes;
+    /* after instantiate */
+    const char *V1;
+    const char *C1;
+    /* after first generate */
+    const char *V2;
+    const char *C2;
+    /* after second generate */
+    const char *V3;
+    const char *C3;
+    const char *output;
+} test_vectors[] = {
+    {
+        .entropy_input = "136cf1c174e5a09f66b962d994396525",
+        .nonce = "fff1c6645f19231f",
+        .returned_bytes = 80,
+        .V1 = "a884a83fa40bcf730e7395dd5800ea7101b48"
+              "77aaa29da9b7bc0bd2bd052b9b4022f83bae3"
+              "8064134a233835845fdd1442bf3a0221bdc8",
+        .C1 = "4977fb1268c1f6286b5b3969d416fb8ca7e4e"
+              "aab7fd2edefc239202baa033f8b44e9145148"
+              "ad24ce83d597176a0bacc84c99246f15e088",
+        .V2 = "f1fca3520ccdc59b79cecf472c17e5fda9997"
+              "22629fcc88b3df9dd577a55f93f47189892b1"
+              "8e1c5f39dfc077ae256588eecec7bbd0323c",
+        .C2 = "4977fb1268c1f6286b5b3969d416fb8ca7e4e"
+              "aab7fd2edefc239202baa033f8b44e9145148"
+              "ad24ce83d597176a0bacc84c99246f15e088",
+        .V3 = "3b749e64758fbbc3e52a08b1002ee18a517e5"
+              "cd1a9cfb67b0032fd83245938ca8c01add770"
+              "68515bde248c75adea10bbaaf0bc18e66a2c",
+        .C3 = "4977fb1268c1f6286b5b3969d416fb8ca7e4e"
+              "aab7fd2edefc239202baa033f8b44e9145148"
+              "ad24ce83d597176a0bacc84c99246f15e088",
+        .output = "0e28130fa5ca11edd3293ca26fdb8ae1810611f7"
+                  "8715082ed3841e7486f16677b28e33ffe0b93d98"
+                  "ba57ba358c1343ab2a26b4eb7940f5bc63938464"
+                  "1ee80a25140331076268bd1ce702ad534dda0ed8",
+    },
+
+    {
+        .entropy_input = "dfed69b08902fcfb795d5d35dbe23f6b",
+        .nonce = "37258e820432e392",
+        .returned_bytes = 80,
+        .V1 = "2708022f0f6d13cd8bc139ceb86ee237ee124"
+              "e17029ac4f053d41526285599d4eac5029972"
+              "7d83a0df0d5fa9824d5f14d7e7e9c8bdb165",
+        .C1 = "fdb1a827c30e436c997261da6dc31ae7c27ee"
+              "28e5c29b2ee0ca57b44ab78b7b0d1e8b459ba"
+              "7285f5d93abf218d16d834a803c2330321cd",
+        .V2 = "24b9aa56d27b573a25339ba92631fd1fb0913"
+              "0a55ec477de6079906ad3ce5185bcadb7b047"
+              "627060f80afb8529c18b46567e6b79dffb01",
+        .C2 = "fdb1a827c30e436c997261da6dc31ae7c27ee"
+              "28e5c29b2ee0ca57b44ab78b7b0d1e8b459ba"
+              "7285f5d93abf218d16d834a803c2330321cd",
+        .V3 = "226b527e95899aa6bea5fd8393f5180773101"
+              "333baee2acc6d1f0baf7f4709368e966c945c"
+              "d4a0d86093183375443379b09c08e4381fa8",
+        .C3 = "fdb1a827c30e436c997261da6dc31ae7c27ee"
+              "28e5c29b2ee0ca57b44ab78b7b0d1e8b459ba"
+              "7285f5d93abf218d16d834a803c2330321cd",
+        .output = "adcb8e2cbbc5957d538a20db18b5e7fe350a90a2"
+                  "01359fab9e0f154c53aa146bc6af1fcc7ff8f330"
+                  "b8d9f3d7b038488ba627e6fa21d0147377b13404"
+                  "22b22634b412dac69ac82c35b5fb411a4e42a133",
+    },
+};
+
+int main()
+{
+    size_t i;
+    uint8_t entropy_input[1024];
+    size_t entropy_input_len;
+    uint8_t nonce[1024];
+    size_t nonce_len;
+    uint8_t output[1024];
+    Hash_DRBG_CTX ctx;
+
+    printf("Hash_DRBG tests.\n");
+    for (i = 0; i < ARRAY_SIZE(test_vectors); ++i) {
+        printf("Test #%d: ", (int)i + 1);
+        test_hex_to_bin(test_vectors[i].entropy_input, entropy_input,
+                        &entropy_input_len);
+        test_hex_to_bin(test_vectors[i].nonce, nonce, &nonce_len);
+
+        Hash_DRBG_Instantiate(&ctx, entropy_input, entropy_input_len, nonce,
+                              nonce_len);
+        COMPARE(test_vectors[i].V1, test_bin_to_hex(ctx.V, sizeof(ctx.V)));
+        COMPARE(test_vectors[i].C1, test_bin_to_hex(ctx.C, sizeof(ctx.C)));
+        assert(ctx.reseed_counter == 1);
+
+        Hash_DRBG_Generate(&ctx, output, test_vectors[i].returned_bytes);
+        COMPARE(test_vectors[i].V2, test_bin_to_hex(ctx.V, sizeof(ctx.V)));
+        COMPARE(test_vectors[i].C2, test_bin_to_hex(ctx.C, sizeof(ctx.C)));
+        assert(ctx.reseed_counter == 2);
+
+        Hash_DRBG_Generate(&ctx, output, test_vectors[i].returned_bytes);
+        COMPARE(test_vectors[i].V3, test_bin_to_hex(ctx.V, sizeof(ctx.V)));
+        COMPARE(test_vectors[i].C3, test_bin_to_hex(ctx.C, sizeof(ctx.C)));
+        COMPARE(test_vectors[i].output,
+                test_bin_to_hex(output, test_vectors[i].returned_bytes));
+        assert(ctx.reseed_counter == 3);
+        printf("ok\n");
+    }
+
+    return 0;
+}

tests/test_resolver.c

@@ -0,0 +1,234 @@
+/* test_resolver.c
+ * strophe XMPP client library -- tests for resolver
+ *
+ * Copyright (C) 2015 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 <stdio.h>
+
+#include "strophe.h"
+#include "rand.h"
+#include "resolver.h"
+#include "test.h"
+
+/* res_query("_xmpp-client._tcp.jabber.kiev.ua", C_IN, T_SRV, ...) */
+static const unsigned char data1[] = {
+    0x95, 0xf3, 0x81, 0x80, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+    0x0c, 0x5f, 0x78, 0x6d, 0x70, 0x70, 0x2d, 0x63, 0x6c, 0x69, 0x65, 0x6e,
+    0x74, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x06, 0x6a, 0x61, 0x62, 0x62, 0x65,
+    0x72, 0x04, 0x6b, 0x69, 0x65, 0x76, 0x02, 0x75, 0x61, 0x00, 0x00, 0x21,
+    0x00, 0x01, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x00, 0x3b,
+    0x00, 0x16, 0x00, 0x01, 0x00, 0x00, 0x14, 0x66, 0x06, 0x6a, 0x61, 0x62,
+    0x62, 0x65, 0x72, 0x04, 0x6b, 0x69, 0x65, 0x76, 0x02, 0x75, 0x61, 0x00,
+};
+/* res_query("_xmpp-client._tcp.jabber.org", C_IN, T_SRV, ...) */
+static const unsigned char data2[] = {
+    0xf2, 0x98, 0x81, 0x80, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
+    0x0c, 0x5f, 0x78, 0x6d, 0x70, 0x70, 0x2d, 0x63, 0x6c, 0x69, 0x65, 0x6e,
+    0x74, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x06, 0x6a, 0x61, 0x62, 0x62, 0x65,
+    0x72, 0x03, 0x6f, 0x72, 0x67, 0x00, 0x00, 0x21, 0x00, 0x01, 0xc0, 0x0c,
+    0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x03, 0x83, 0x00, 0x1a, 0x00, 0x1e,
+    0x00, 0x1e, 0x14, 0x66, 0x07, 0x68, 0x65, 0x72, 0x6d, 0x65, 0x73, 0x32,
+    0x06, 0x6a, 0x61, 0x62, 0x62, 0x65, 0x72, 0x03, 0x6f, 0x72, 0x67, 0x00,
+    0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x03, 0x83, 0x00, 0x1c,
+    0x00, 0x1f, 0x00, 0x1e, 0x14, 0x66, 0x09, 0x68, 0x65, 0x72, 0x6d, 0x65,
+    0x73, 0x32, 0x76, 0x36, 0x06, 0x6a, 0x61, 0x62, 0x62, 0x65, 0x72, 0x03,
+    0x6f, 0x72, 0x67, 0x00,
+};
+/* res_query("_xmpp-client._tcp.gmail.com", C_IN, T_SRV, ...) */
+static const unsigned char data3[] = {
+    0xda, 0xa8, 0x81, 0x80, 0x00, 0x01, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+    0x0c, 0x5f, 0x78, 0x6d, 0x70, 0x70, 0x2d, 0x63, 0x6c, 0x69, 0x65, 0x6e,
+    0x74, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x05, 0x67, 0x6d, 0x61, 0x69, 0x6c,
+    0x03, 0x63, 0x6f, 0x6d, 0x00, 0x00, 0x21, 0x00, 0x01, 0xc0, 0x0c, 0x00,
+    0x21, 0x00, 0x01, 0x00, 0x00, 0x02, 0x43, 0x00, 0x1e, 0x00, 0x14, 0x00,
+    0x00, 0x14, 0x66, 0x04, 0x61, 0x6c, 0x74, 0x31, 0x04, 0x78, 0x6d, 0x70,
+    0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63,
+    0x6f, 0x6d, 0x00, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x02,
+    0x43, 0x00, 0x1e, 0x00, 0x14, 0x00, 0x00, 0x14, 0x66, 0x04, 0x61, 0x6c,
+    0x74, 0x34, 0x04, 0x78, 0x6d, 0x70, 0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f,
+    0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00, 0xc0, 0x0c, 0x00,
+    0x21, 0x00, 0x01, 0x00, 0x00, 0x02, 0x43, 0x00, 0x1e, 0x00, 0x14, 0x00,
+    0x00, 0x14, 0x66, 0x04, 0x61, 0x6c, 0x74, 0x32, 0x04, 0x78, 0x6d, 0x70,
+    0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63,
+    0x6f, 0x6d, 0x00, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x02,
+    0x43, 0x00, 0x19, 0x00, 0x05, 0x00, 0x00, 0x14, 0x66, 0x04, 0x78, 0x6d,
+    0x70, 0x70, 0x01, 0x6c, 0x06, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03,
+    0x63, 0x6f, 0x6d, 0x00, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00,
+    0x02, 0x43, 0x00, 0x1e, 0x00, 0x14, 0x00, 0x00, 0x14, 0x66, 0x04, 0x61,
+    0x6c, 0x74, 0x33, 0x04, 0x78, 0x6d, 0x70, 0x70, 0x01, 0x6c, 0x06, 0x67,
+    0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00,
+};
+/* res_query("_xmpp-client._tcp.jabber.calyxinstitute.org", C_IN, T_SRV, ...) */
+static const unsigned char data4[] = {
+    0x8d, 0x58, 0x81, 0x80, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, // .X........
+    0x00, 0x00, 0x0c, 0x5f, 0x78, 0x6d, 0x70, 0x70, 0x2d, 0x63, // ..._xmpp-c
+    0x6c, 0x69, 0x65, 0x6e, 0x74, 0x04, 0x5f, 0x74, 0x63, 0x70, // lient._tcp
+    0x06, 0x6a, 0x61, 0x62, 0x62, 0x65, 0x72, 0x0e, 0x63, 0x61, // .jabber.ca
+    0x6c, 0x79, 0x78, 0x69, 0x6e, 0x73, 0x74, 0x69, 0x74, 0x75, // lyxinstitu
+    0x74, 0x65, 0x03, 0x6f, 0x72, 0x67, 0x00, 0x00, 0x21, 0x00, // te.org..!.
+    0x01, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x03, // ....!.....
+    0x83, 0x00, 0x1e, 0x00, 0x04, 0x00, 0x00, 0x14, 0x66, 0x10, // ........f.
+    0x69, 0x6a, 0x65, 0x65, 0x79, 0x6e, 0x72, 0x63, 0x36, 0x78, // ijeeynrc6x
+    0x32, 0x75, 0x79, 0x35, 0x6f, 0x62, 0x05, 0x6f, 0x6e, 0x69, // 2uy5ob.oni
+    0x6f, 0x6e, 0x00, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, // on....!...
+    0x00, 0x03, 0x83, 0x00, 0x21, 0x00, 0x05, 0x00, 0x01, 0x14, // ....!.....
+    0x66, 0x06, 0x6a, 0x61, 0x62, 0x62, 0x65, 0x72, 0x0e, 0x63, // f.jabber.c
+    0x61, 0x6c, 0x79, 0x78, 0x69, 0x6e, 0x73, 0x74, 0x69, 0x74, // alyxinstit
+    0x75, 0x74, 0x65, 0x03, 0x6f, 0x72, 0x67, 0x00,             // ute.org.
+};
+/* res_query("_xmpp-client._tcp.jabber.org", C_IN, T_SRV, ...) with pointers */
+static const unsigned char data5[] = {
+    0x00, 0x00, 0x81, 0x80, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, // ..........
+    0x00, 0x00, 0x0c, 0x5f, 0x78, 0x6d, 0x70, 0x70, 0x2d, 0x63, // ..._xmpp-c
+    0x6c, 0x69, 0x65, 0x6e, 0x74, 0x04, 0x5f, 0x74, 0x63, 0x70, // lient._tcp
+    0x06, 0x6a, 0x61, 0x62, 0x62, 0x65, 0x72, 0x03, 0x6f, 0x72, // .jabber.or
+    0x67, 0x00, 0x00, 0x21, 0x00, 0x01, 0xc0, 0x0c, 0x00, 0x21, // g..!.....!
+    0x00, 0x01, 0x00, 0x00, 0x01, 0x9e, 0x00, 0x12, 0x00, 0x1f, // ..........
+    0x00, 0x1e, 0x14, 0x66, 0x09, 0x68, 0x65, 0x72, 0x6d, 0x65, // ...f.herme
+    0x73, 0x32, 0x76, 0x36, 0xc0, 0x1e, 0xc0, 0x0c, 0x00, 0x21, // s2v6.....!
+    0x00, 0x01, 0x00, 0x00, 0x01, 0x9e, 0x00, 0x10, 0x00, 0x1e, // ..........
+    0x00, 0x1e, 0x14, 0x66, 0x07, 0x68, 0x65, 0x72, 0x6d, 0x65, // ...f.herme
+    0x73, 0x32, 0xc0, 0x1e,                                     // s2..
+};
+/* hacked data2 with two empty-string targets. */
+static const unsigned char data6[] = {
+    0xf2, 0x98, 0x81, 0x80, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00,
+    0x00, 0x0c, 0x5f, 0x78, 0x6d, 0x70, 0x70, 0x2d, 0x63, 0x6c, 0x69,
+    0x65, 0x6e, 0x74, 0x04, 0x5f, 0x74, 0x63, 0x70, 0x06, 0x6a, 0x61,
+    0x62, 0x62, 0x65, 0x72, 0x03, 0x6f, 0x72, 0x67, 0x00, 0x00, 0x21,
+    0x00, 0x01, 0xc0, 0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x03,
+    0x83, 0x00, 0x07, 0x00, 0x1e, 0x00, 0x1e, 0x14, 0x66, 0x00, 0xc0,
+    0x0c, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x03, 0x83, 0x00, 0x08,
+    0x00, 0x1f, 0x00, 0x1e, 0x14, 0x66, 0xc0, 0x40,
+};
+
+static const struct {
+    const unsigned char *data;
+    size_t len;
+    char *target;
+    unsigned short port;
+    int target_nr;
+} tests[] = {
+    {
+        .data = data1,
+        .len = sizeof(data1),
+        .target = "jabber.kiev.ua",
+        .port = 5222,
+        .target_nr = 1,
+    },
+    {
+        .data = data2,
+        .len = sizeof(data2),
+        .target = "hermes2.jabber.org",
+        .port = 5222,
+        .target_nr = 2,
+    },
+    {
+        .data = data3,
+        .len = sizeof(data3),
+        .target = "xmpp.l.google.com",
+        .port = 5222,
+        .target_nr = 5,
+    },
+    {
+        .data = data4,
+        .len = sizeof(data4),
+        .target = "ijeeynrc6x2uy5ob.onion",
+        .port = 5222,
+        .target_nr = 2,
+    },
+    {
+        .data = data5,
+        .len = sizeof(data5),
+        .target = "hermes2.jabber.org",
+        .port = 5222,
+        .target_nr = 2,
+    },
+    {
+        .data = data6,
+        .len = sizeof(data6),
+        .target = "",
+        .port = 5222,
+        .target_nr = 2,
+    },
+};
+
+static int srv_rr_list_len(resolver_srv_rr_t *list)
+{
+    int nr;
+
+    for (nr = 0; list != NULL; ++nr, list = list->next)
+        ;
+
+    return nr;
+}
+
+int main()
+{
+    xmpp_ctx_t *ctx;
+    xmpp_rand_t *rand;
+    resolver_srv_rr_t *srv_rr_list;
+    char *domain;
+    unsigned char *buf;
+    unsigned short port;
+    size_t i;
+    int ret;
+
+    ctx = xmpp_ctx_new(NULL, NULL);
+    assert(ctx != NULL);
+
+    printf("resolver_srv_lookup_buf() tests.\n");
+    for (i = 0; i < ARRAY_SIZE(tests); ++i) {
+        printf("Test #%zu: ", i + 1);
+        ret = resolver_srv_lookup_buf(ctx, tests[i].data, tests[i].len,
+                                      &srv_rr_list);
+        assert(ret == XMPP_DOMAIN_FOUND);
+        assert(srv_rr_list != NULL);
+        if (tests[i].target_nr != srv_rr_list_len(srv_rr_list)) {
+            printf("fail! got %d targets, but should be %d\n",
+                   srv_rr_list_len(srv_rr_list), tests[i].target_nr);
+            return 1;
+        }
+        /* check only 1st result */
+        domain = srv_rr_list->target;
+        port = srv_rr_list->port;
+        COMPARE(tests[i].target, domain);
+        if (tests[i].port != port) {
+            printf("fail! got port=%u, but should be %u\n", (unsigned)port,
+                   (unsigned)tests[i].port);
+            return 1;
+        }
+        printf("ok\n");
+        resolver_srv_free(ctx, srv_rr_list);
+    }
+
+    /*
+     * The next test case must not crash and is supposed to be checked
+     * under valgrind.
+     */
+    printf("Test of a broken message: ");
+    rand = xmpp_rand_new(ctx);
+    assert(rand != NULL);
+    assert(sizeof(data2) > 64);
+    buf = xmpp_alloc(ctx, sizeof(data2));
+    assert(buf != NULL);
+    memcpy(buf, data2, 64);
+    xmpp_rand_bytes(rand, &buf[64], sizeof(data2) - 64);
+    ret = resolver_srv_lookup_buf(ctx, buf, sizeof(data2), &srv_rr_list);
+    if (ret == XMPP_DOMAIN_FOUND && srv_rr_list != NULL)
+        resolver_srv_free(ctx, srv_rr_list);
+    xmpp_free(ctx, buf);
+    xmpp_rand_free(ctx, rand);
+    printf("ok\n");
+
+    xmpp_ctx_free(ctx);
+
+    return 0;
+}

tests/test_sasl.c

@@ -1,15 +1,12 @@
 /* test_sasl.c
 ** libstrophe XMPP client library -- test routines for the SASL 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.
 **
-**  This software is distributed under license and may not be copied,
+**  This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 #include <stdio.h>
@@ -23,32 +20,32 @@ static const unsigned char jid[] = "foo@bar.com";
 static const char password[] = "secret";
 static const char response_plain[] = "AGZvb0BiYXIuY29tAHNlY3JldA==";
 
-static const char challenge_md5[] = 
+static const char challenge_md5[] =
-  "cmVhbG09InNvbWVyZWFsbSIsbm9uY2U9Ik9BNk1HOXRFUUdtMmhoIixxb3A9ImF1dGgi"
+    "cmVhbG09InNvbWVyZWFsbSIsbm9uY2U9Ik9BNk1HOXRFUUdtMmhoIixxb3A9ImF1dGgi"
-  "LGNoYXJzZXQ9dXRmLTgsYWxnb3JpdGhtPW1kNS1zZXNzCg==";
+    "LGNoYXJzZXQ9dXRmLTgsYWxnb3JpdGhtPW1kNS1zZXNzCg==";
 static const char response_md5[] =
-  "dXNlcm5hbWU9InNvbWVub2RlIixyZWFsbT0ic29tZXJlYWxtIixub25jZT0i"
+    "dXNlcm5hbWU9InNvbWVub2RlIixyZWFsbT0ic29tZXJlYWxtIixub25jZT0i"
-  "T0E2TUc5dEVRR20yaGgiLGNub25jZT0iMDBERUFEQkVFRjAwIixuYz0wMDAw"
+    "T0E2TUc5dEVRR20yaGgiLGNub25jZT0iMDBERUFEQkVFRjAwIixuYz0wMDAw"
-  "MDAwMSxxb3A9YXV0aCxkaWdlc3QtdXJpPSJ4bXBwL3NvbWVyZWFsbSIscmVz"
+    "MDAwMSxxb3A9YXV0aCxkaWdlc3QtdXJpPSJ4bXBwL3NvbWVyZWFsbSIscmVz"
-  "cG9uc2U9NGVhNmU4N2JjMDkzMzUwNzQzZGIyOGQ3MDIwOGNhZmIsY2hhcnNl"
+    "cG9uc2U9NGVhNmU4N2JjMDkzMzUwNzQzZGIyOGQ3MDIwOGNhZmIsY2hhcnNl"
-  "dD11dGYtOA==";
+    "dD11dGYtOA==";
 static const char response_md5_rfc[] =
-  "dXNlcm5hbWU9InNvbWVub2RlIixyZWFsbT0ic29tZXJlYWxtIixub25jZT0i"
+    "dXNlcm5hbWU9InNvbWVub2RlIixyZWFsbT0ic29tZXJlYWxtIixub25jZT0i"
-  "T0E2TUc5dEVRR20yaGgiLGNub25jZT0iT0E2TUhYaDZWcVRyUmsiLG5jPTAw"
+    "T0E2TUc5dEVRR20yaGgiLGNub25jZT0iT0E2TUhYaDZWcVRyUmsiLG5jPTAw"
-  "MDAwMDAxLHFvcD1hdXRoLGRpZ2VzdC11cmk9InhtcHAvZXhhbXBsZS5jb20i"
+    "MDAwMDAxLHFvcD1hdXRoLGRpZ2VzdC11cmk9InhtcHAvZXhhbXBsZS5jb20i"
-  "LHJlc3BvbnNlPWQzODhkYWQ5MGQ0YmJkNzYwYTE1MjMyMWYyMTQzYWY3LGNo"
+    "LHJlc3BvbnNlPWQzODhkYWQ5MGQ0YmJkNzYwYTE1MjMyMWYyMTQzYWY3LGNo"
-  "YXJzZXQ9dXRmLTgK";
+    "YXJzZXQ9dXRmLTgK";
 
 static const char challenge_md5_2[] =
-  "cmVhbG09ImVsd29vZC5pbm5vc29mdC5jb20iLG5vbmNlPSJPQTZNRzl0"
+    "cmVhbG09ImVsd29vZC5pbm5vc29mdC5jb20iLG5vbmNlPSJPQTZNRzl0"
-  "RVFHbTJoaCIscW9wPSJhdXRoIixhbGdvcml0aG09bWQ1LXNlc3MsY2hh"
+    "RVFHbTJoaCIscW9wPSJhdXRoIixhbGdvcml0aG09bWQ1LXNlc3MsY2hh"
-  "cnNldD11dGYtOA==";
+    "cnNldD11dGYtOA==";
 static const char response_md5_2[] =
-  "Y2hhcnNldD11dGYtOCx1c2VybmFtZT0iY2hyaXMiLHJlYWxtPSJlbHdvb2"
+    "Y2hhcnNldD11dGYtOCx1c2VybmFtZT0iY2hyaXMiLHJlYWxtPSJlbHdvb2"
-  "QuaW5ub3NvZnQuY29tIixub25jZT0iT0E2TUc5dEVRR20yaGgiLG5jPTAw"
+    "QuaW5ub3NvZnQuY29tIixub25jZT0iT0E2TUc5dEVRR20yaGgiLG5jPTAw"
-  "MDAwMDAxLGNub25jZT0iT0E2TUhYaDZWcVRyUmsiLGRpZ2VzdC11cmk9Im"
+    "MDAwMDAxLGNub25jZT0iT0E2TUhYaDZWcVRyUmsiLGRpZ2VzdC11cmk9Im"
-  "ltYXAvZWx3b29kLmlubm9zb2Z0LmNvbSIscmVzcG9uc2U9ZDM4OGRhZDkw"
+    "ltYXAvZWx3b29kLmlubm9zb2Z0LmNvbSIscmVzcG9uc2U9ZDM4OGRhZDkw"
-  "ZDRiYmQ3NjBhMTUyMzIxZjIxNDNhZjcscW9wPWF1dGg=";
+    "ZDRiYmQ3NjBhMTUyMzIxZjIxNDNhZjcscW9wPWF1dGg=";
 
 int test_plain(xmpp_ctx_t *ctx)
 {
@@ -56,12 +53,12 @@ int test_plain(xmpp_ctx_t *ctx)
 
     result = sasl_plain(ctx, jid, password);
     if (result == NULL) {
-	/* SASL PLAIN internal failure! */
+        /* SASL PLAIN internal failure! */
-	return 1;
+        return 1;
     }
     if (strncmp(response_plain, result, strlen(response_plain))) {
-	/* SASL PLAIN returned incorrect string! */
+        /* SASL PLAIN returned incorrect string! */
-	return 2;
+        return 2;
     }
     xmpp_free(ctx, result);
 
@@ -72,38 +69,44 @@ int test_digest_md5(xmpp_ctx_t *ctx)
 {
     char *result;
 
-    result = sasl_digest_md5(ctx, challenge_md5,
+    result =
-				"somenode@somerealm", "secret");
+        sasl_digest_md5(ctx, challenge_md5, "somenode@somerealm", "secret");
     printf("response:\n%s\n", result);
     if (strcmp(response_md5, result)) {
-	/* generated incorrect response to challenge */
+        /* generated incorrect response to challenge */
-	return 1;
+        return 1;
     }
 
     return 0;
 }
 
-int main(int argc, char *argv[])
+int main()
 {
     xmpp_ctx_t *ctx;
     int ret;
 
-    printf("allocating context... ");   
+    printf("allocating context... ");
     ctx = xmpp_ctx_new(NULL, NULL);
-    if (ctx == NULL) printf("failed to create context\n");
+    if (ctx == NULL)
-    if (ctx == NULL) return -1;
+        printf("failed to create context\n");
+    if (ctx == NULL)
+        return -1;
     printf("ok.\n");
 
-    printf("testing SASL PLAIN... ");   
+    printf("testing SASL PLAIN... ");
     ret = test_plain(ctx);
-    if (ret) printf("failed!\n");
+    if (ret)
-    if (ret) return ret;
+        printf("failed!\n");
+    if (ret)
+        return ret;
     printf("ok.\n");
 
     printf("testing SASL DIGEST-MD5... ");
     ret = test_digest_md5(ctx);
-    if (ret) printf("failed!\n");
+    if (ret)
-    if (ret) return ret;
+        printf("failed!\n");
+    if (ret)
+        return ret;
     printf("ok.\n");
 
     printf("freeing context... ");

tests/test_scram.c

@@ -0,0 +1,215 @@
+/* test_scram.c
+ * strophe XMPP client library -- test vectors for SCRAM-SHA1
+ *
+ * Copyright (C) 2014 Dmitry Podgorny <pasis.ua@gmail.com>
+ *
+ *  This software is provided AS-IS with no warranty, either express
+ *  or implied.
+ *
+ *  This program is dual licensed under the MIT and GPLv3 licenses.
+ */
+
+/* gcc -o test_scram -I./src tests/test_scram.c tests/test.c src/sha1.c */
+
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "test.h"
+
+/* include scram.c to access static functions */
+#include "scram.c"
+
+/*
+ * Test vectors for derivation function (RFC6070).
+ */
+static const struct {
+    char *P; /* text */
+    char *S; /* salt */
+    size_t P_len;
+    size_t S_len;
+    uint32_t c; /* i */
+    char *DK;   /* resulting digest */
+} df_vectors[] = {
+    {
+        .P = "password",
+        .S = "salt",
+        .P_len = 8,
+        .S_len = 4,
+        .c = 1,
+        .DK = "0c60c80f961f0e71f3a9b524af6012062fe037a6",
+    },
+    {
+        .P = "password",
+        .S = "salt",
+        .P_len = 8,
+        .S_len = 4,
+        .c = 2,
+        .DK = "ea6c014dc72d6f8ccd1ed92ace1d41f0d8de8957",
+    },
+    {
+        .P = "password",
+        .S = "salt",
+        .P_len = 8,
+        .S_len = 4,
+        .c = 4096,
+        .DK = "4b007901b765489abead49d926f721d065a429c1",
+    },
+};
+
+static void test_df(const struct hash_alg *alg)
+{
+    size_t i;
+    const char *s;
+    uint8_t dk[SCRAM_DIGEST_SIZE];
+
+    printf("Derivation function SCRAM_Hi tests for %s.\n", alg->scram_name);
+    for (i = 0; i < ARRAY_SIZE(df_vectors); ++i) {
+        printf("Test #%d: ", (int)i + 1);
+        SCRAM_Hi(alg, (uint8_t *)df_vectors[i].P, df_vectors[i].P_len,
+                 (uint8_t *)df_vectors[i].S, df_vectors[i].S_len,
+                 df_vectors[i].c, dk);
+        s = test_bin_to_hex(dk, alg->digest_size);
+        COMPARE(df_vectors[i].DK, s);
+        printf("ok\n");
+    }
+}
+
+/* RFC6120 */
+static const struct {
+    char *password;
+    char *initial;
+    char *challenge;
+    char *response;
+    char *salt;
+    uint32_t i;
+    char *sign;
+} scram_vectors[] = {
+    {
+        .password = "r0m30myr0m30",
+        .initial = "n,,n=juliet,r=oMsTAAwAAAAMAAAANP0TAAAAAABPU0AA",
+        .challenge = "r=oMsTAAwAAAAMAAAANP0TAAAAAABPU0AAe124695b-69a9-4de6-9c30"
+                     "-b51b3808c59e,s=NjhkYTM0MDgtNGY0Zi00NjdmLTkxMmUtNDlmNTNmN"
+                     "DNkMDMz,i=4096",
+        .response = "c=biws,r=oMsTAAwAAAAMAAAANP0TAAAAAABPU0AAe124695b-69a9-4de"
+                    "6-9c30-b51b3808c59e",
+        .salt = "36386461333430382d346634662d34363766"
+                "2d393132652d343966353366343364303333",
+        .i = 4096,
+        .sign = "500e7bb4cfd2be90130641f6157b345835ef258c",
+    },
+};
+
+static void test_scram(const struct hash_alg *alg)
+{
+    uint8_t key[SCRAM_DIGEST_SIZE];
+    uint8_t sign[SCRAM_DIGEST_SIZE];
+    uint8_t salt[256];
+    size_t salt_len;
+    char auth[512];
+    const char *s;
+    size_t i;
+    size_t j;
+
+    printf("SCRAM_ClientKey and SCRAM_ClientSignature tests for %s.\n",
+           alg->scram_name);
+    for (i = 0; i < ARRAY_SIZE(scram_vectors); ++i) {
+        printf("Test #%d: ", (int)i + 1);
+        snprintf(auth, sizeof(auth), "%s,%s,%s", scram_vectors[i].initial + 3,
+                 scram_vectors[i].challenge, scram_vectors[i].response);
+        test_hex_to_bin(scram_vectors[i].salt, salt, &salt_len);
+
+        SCRAM_ClientKey(alg, (uint8_t *)scram_vectors[i].password,
+                        strlen(scram_vectors[i].password), salt, salt_len,
+                        scram_vectors[i].i, key);
+        SCRAM_ClientSignature(alg, key, (uint8_t *)auth, strlen(auth), sign);
+        for (j = 0; j < alg->digest_size; j++) {
+            sign[j] ^= key[j];
+        }
+        s = test_bin_to_hex(sign, alg->digest_size);
+        COMPARE(scram_vectors[i].sign, s);
+        printf("ok\n");
+    }
+}
+
+/*
+ * Test vectors for HMAC (RFC2202, RFC4231).
+ */
+static const uint8_t hmac_key1[] = {0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+                                    0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
+                                    0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b};
+static const uint8_t hmac_data1[] = {0x48, 0x69, 0x20, 0x54,
+                                     0x68, 0x65, 0x72, 0x65};
+static const struct {
+    const uint8_t *key;
+    size_t key_len;
+    const uint8_t *data;
+    size_t data_len;
+    const uint8_t sha1[SHA1_DIGEST_SIZE];
+    const uint8_t sha256[SHA256_DIGEST_SIZE];
+    const uint8_t sha512[SHA512_DIGEST_SIZE];
+} hmac_vectors[] = {
+    {
+        .key = hmac_key1,
+        .key_len = sizeof(hmac_key1),
+        .data = hmac_data1,
+        .data_len = sizeof(hmac_data1),
+        .sha1 = {0xb6, 0x17, 0x31, 0x86, 0x55, 0x05, 0x72, 0x64, 0xe2, 0x8b,
+                 0xc0, 0xb6, 0xfb, 0x37, 0x8c, 0x8e, 0xf1, 0x46, 0xbe, 0x00},
+        .sha256 = {0xb0, 0x34, 0x4c, 0x61, 0xd8, 0xdb, 0x38, 0x53,
+                   0x5c, 0xa8, 0xaf, 0xce, 0xaf, 0x0b, 0xf1, 0x2b,
+                   0x88, 0x1d, 0xc2, 0x00, 0xc9, 0x83, 0x3d, 0xa7,
+                   0x26, 0xe9, 0x37, 0x6c, 0x2e, 0x32, 0xcf, 0xf7},
+        .sha512 = {0x87, 0xaa, 0x7c, 0xde, 0xa5, 0xef, 0x61, 0x9d, 0x4f, 0xf0,
+                   0xb4, 0x24, 0x1a, 0x1d, 0x6c, 0xb0, 0x23, 0x79, 0xf4, 0xe2,
+                   0xce, 0x4e, 0xc2, 0x78, 0x7a, 0xd0, 0xb3, 0x05, 0x45, 0xe1,
+                   0x7c, 0xde, 0xda, 0xa8, 0x33, 0xb7, 0xd6, 0xb8, 0xa7, 0x02,
+                   0x03, 0x8b, 0x27, 0x4e, 0xae, 0xa3, 0xf4, 0xe4, 0xbe, 0x9d,
+                   0x91, 0x4e, 0xeb, 0x61, 0xf1, 0x70, 0x2e, 0x69, 0x6c, 0x20,
+                   0x3a, 0x12, 0x68, 0x54},
+    },
+};
+
+static void test_hmac(const struct hash_alg *alg)
+{
+    size_t i;
+    uint8_t digest[SCRAM_DIGEST_SIZE];
+
+    printf("HMAC tests for %s.\n", alg->scram_name);
+    for (i = 0; i < ARRAY_SIZE(hmac_vectors); ++i) {
+        printf("Test #%d: ", (int)i + 1);
+        memset(digest, 0, sizeof(digest));
+        crypto_HMAC(alg, hmac_vectors[i].key, hmac_vectors[i].key_len,
+                    hmac_vectors[i].data, hmac_vectors[i].data_len, digest);
+        switch (alg->digest_size) {
+        case SHA1_DIGEST_SIZE:
+            COMPARE_BUF(hmac_vectors[i].sha1, alg->digest_size, digest,
+                        alg->digest_size);
+            break;
+        case SHA256_DIGEST_SIZE:
+            COMPARE_BUF(hmac_vectors[i].sha256, alg->digest_size, digest,
+                        alg->digest_size);
+            break;
+        case SHA512_DIGEST_SIZE:
+            COMPARE_BUF(hmac_vectors[i].sha512, alg->digest_size, digest,
+                        alg->digest_size);
+            break;
+        default:
+            printf("Unknown digest size: %zu\n", alg->digest_size);
+            exit(1);
+        }
+        printf("ok\n");
+    }
+}
+
+int main()
+{
+    test_df(&scram_sha1);
+    test_scram(&scram_sha1);
+    test_hmac(&scram_sha1);
+    test_hmac(&scram_sha256);
+    test_hmac(&scram_sha512);
+
+    return 0;
+}

tests/test_sha1.c

@@ -0,0 +1,93 @@
+/* Tests for Steve Reid's public domain SHA-1 implementation */
+/* This file is in the public domain */
+
+/* gcc -o test_sha1 -I./src tests/test_sha1.c src/sha1.c */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "sha1.h"
+#include "test.h"
+
+/* Test Vectors (from FIPS PUB 180-1) */
+static char *test_data[] = {
+    "abc", "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+    "A million repetitions of 'a'",
+    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"};
+static char *test_results[] = {"A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D",
+                               "84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1",
+                               "34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F",
+                               "AD5B3FDB CB526778 C2839D2F 151EA753 995E26A0"};
+
+static void digest_to_hex(const uint8_t *digest, char *output)
+{
+    int i, j;
+    char *c = output;
+
+    for (i = 0; i < SHA1_DIGEST_SIZE / 4; i++) {
+        for (j = 0; j < 4; j++) {
+            sprintf(c, "%02X", digest[i * 4 + j]);
+            c += 2;
+        }
+        sprintf(c, " ");
+        c += 1;
+    }
+    *(c - 1) = '\0';
+}
+
+int main()
+{
+    size_t k;
+    SHA1_CTX context;
+    uint8_t digest[20];
+    char output[80];
+    char *copy;
+
+    fprintf(stdout, "verifying SHA-1 implementation... ");
+
+    for (k = 0; k < ARRAY_SIZE(test_data); k++) {
+        if (k == 2) {
+            /* this case will be checked below */
+            continue;
+        }
+        copy = strdup(test_data[k]);
+        crypto_SHA1_Init(&context);
+        crypto_SHA1_Update(&context, (uint8_t *)test_data[k],
+                           strlen(test_data[k]));
+        crypto_SHA1_Final(&context, digest);
+        digest_to_hex(digest, output);
+
+        if (strcmp(output, test_results[k])) {
+            fprintf(stdout, "FAIL\n");
+            fprintf(stderr, "* hash of \"%s\" incorrect:\n", test_data[k]);
+            fprintf(stderr, "\t%s returned\n", output);
+            fprintf(stderr, "\t%s is correct\n", test_results[k]);
+            return (1);
+        }
+        if (strcmp(copy, test_data[k])) {
+            fprintf(stdout, "FAIL\n");
+            fprintf(stdout, "* original string was changed by SHA1\n");
+            return (1);
+        }
+        free(copy);
+    }
+    /* million 'a' vector we feed separately */
+    crypto_SHA1_Init(&context);
+    for (k = 0; k < 1000000; k++)
+        crypto_SHA1_Update(&context, (uint8_t *)"a", 1);
+    crypto_SHA1_Final(&context, digest);
+    digest_to_hex(digest, output);
+    if (strcmp(output, test_results[2])) {
+        fprintf(stdout, "FAIL\n");
+        fprintf(stderr, "* hash of \"%s\" incorrect:\n", test_data[2]);
+        fprintf(stderr, "\t%s returned\n", output);
+        fprintf(stderr, "\t%s is correct\n", test_results[2]);
+        return (1);
+    }
+
+    /* success */
+    fprintf(stdout, "ok\n");
+    return (0);
+}

tests/test_sha256.c

@@ -0,0 +1,44 @@
+/* Tests for SHA-256 from LibTomCrypt */
+/* This file is in the public domain */
+
+/* gcc -o test_sha256 -I./src tests/test_sha256.c tests/test.c src/sha256.c */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "sha256.h"
+#include "test.h"
+
+int main()
+{
+    static const struct {
+        const char *msg;
+        unsigned char hash[SHA256_DIGEST_SIZE];
+    } tests[] = {
+        {"abc",
+         {0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea, 0x41, 0x41, 0x40,
+          0xde, 0x5d, 0xae, 0x22, 0x23, 0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17,
+          0x7a, 0x9c, 0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad}},
+        {"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
+         {0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8, 0xe5, 0xc0, 0x26,
+          0x93, 0x0c, 0x3e, 0x60, 0x39, 0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff,
+          0x21, 0x67, 0xf6, 0xec, 0xed, 0xd4, 0x19, 0xdb, 0x06, 0xc1}},
+    };
+
+    int i;
+    unsigned char tmp[SHA256_DIGEST_SIZE];
+    sha256_context md;
+
+    for (i = 0; i < (int)(sizeof(tests) / sizeof(tests[0])); i++) {
+        sha256_init(&md);
+        sha256_process(&md, (unsigned char *)tests[i].msg,
+                       (unsigned long)strlen(tests[i].msg));
+        sha256_done(&md, tmp);
+        COMPARE_BUF(tmp, sizeof(tmp), tests[i].hash, sizeof(tests[i].hash));
+    }
+
+    /* success */
+    fprintf(stdout, "ok\n");
+    return (0);
+}

tests/test_sha512.c

@@ -0,0 +1,65 @@
+/* Tests for SHA-512 from LibTomCrypt */
+/* This file is in the public domain */
+
+/* gcc -o test_sha512 -I./src tests/test_sha512.c tests/test.c src/sha512.c */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "sha512.h"
+#include "test.h"
+
+static const uint8_t hash_1m_a[SHA512_DIGEST_SIZE] = {
+    0xe7, 0x18, 0x48, 0x3d, 0x0c, 0xe7, 0x69, 0x64, 0x4e, 0x2e, 0x42,
+    0xc7, 0xbc, 0x15, 0xb4, 0x63, 0x8e, 0x1f, 0x98, 0xb1, 0x3b, 0x20,
+    0x44, 0x28, 0x56, 0x32, 0xa8, 0x03, 0xaf, 0xa9, 0x73, 0xeb, 0xde,
+    0x0f, 0xf2, 0x44, 0x87, 0x7e, 0xa6, 0x0a, 0x4c, 0xb0, 0x43, 0x2c,
+    0xe5, 0x77, 0xc3, 0x1b, 0xeb, 0x00, 0x9c, 0x5c, 0x2c, 0x49, 0xaa,
+    0x2e, 0x4e, 0xad, 0xb2, 0x17, 0xad, 0x8c, 0xc0, 0x9b};
+
+int main()
+{
+    static const struct {
+        const char *msg;
+        uint8_t hash[SHA512_DIGEST_SIZE];
+    } tests[] = {
+        {"abc",
+         {0xdd, 0xaf, 0x35, 0xa1, 0x93, 0x61, 0x7a, 0xba, 0xcc, 0x41, 0x73,
+          0x49, 0xae, 0x20, 0x41, 0x31, 0x12, 0xe6, 0xfa, 0x4e, 0x89, 0xa9,
+          0x7e, 0xa2, 0x0a, 0x9e, 0xee, 0xe6, 0x4b, 0x55, 0xd3, 0x9a, 0x21,
+          0x92, 0x99, 0x2a, 0x27, 0x4f, 0xc1, 0xa8, 0x36, 0xba, 0x3c, 0x23,
+          0xa3, 0xfe, 0xeb, 0xbd, 0x45, 0x4d, 0x44, 0x23, 0x64, 0x3c, 0xe8,
+          0x0e, 0x2a, 0x9a, 0xc9, 0x4f, 0xa5, 0x4c, 0xa4, 0x9f}},
+        {"abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklm"
+         "nopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu",
+         {0x8e, 0x95, 0x9b, 0x75, 0xda, 0xe3, 0x13, 0xda, 0x8c, 0xf4, 0xf7,
+          0x28, 0x14, 0xfc, 0x14, 0x3f, 0x8f, 0x77, 0x79, 0xc6, 0xeb, 0x9f,
+          0x7f, 0xa1, 0x72, 0x99, 0xae, 0xad, 0xb6, 0x88, 0x90, 0x18, 0x50,
+          0x1d, 0x28, 0x9e, 0x49, 0x00, 0xf7, 0xe4, 0x33, 0x1b, 0x99, 0xde,
+          0xc4, 0xb5, 0x43, 0x3a, 0xc7, 0xd3, 0x29, 0xee, 0xb6, 0xdd, 0x26,
+          0x54, 0x5e, 0x96, 0xe5, 0x5b, 0x87, 0x4b, 0xe9, 0x09}},
+    };
+
+    size_t i;
+    uint8_t tmp[SHA512_DIGEST_SIZE];
+    sha512_context md;
+
+    for (i = 0; i < ARRAY_SIZE(tests); i++) {
+        sha512_init(&md);
+        sha512_process(&md, (uint8_t *)tests[i].msg, strlen(tests[i].msg));
+        sha512_done(&md, tmp);
+        COMPARE_BUF(tests[i].hash, sizeof(tests[i].hash), tmp, sizeof(tmp));
+    }
+
+    /* special case: one million repetitions of the character 'a' */
+    sha512_init(&md);
+    for (i = 0; i < 1000000U; ++i)
+        sha512_process(&md, (uint8_t *)"a", 1);
+    sha512_done(&md, tmp);
+    COMPARE_BUF(hash_1m_a, sizeof(hash_1m_a), tmp, sizeof(tmp));
+
+    /* success */
+    fprintf(stdout, "ok\n");
+    return 0;
+}

tests/test_snprintf.c

@@ -0,0 +1,65 @@
+/*
+ * Copyright Patrick Powell 1995
+ * This code is based on code written by Patrick Powell (papowell@astart.com)
+ * It may be used for any purpose as long as this notice remains intact
+ * on all source code distributions
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#undef HAVE_VSNPRINTF
+#undef HAVE_SNPRINTF
+#include "snprintf.c"
+
+#ifndef LONG_STRING
+#define LONG_STRING 1024
+#endif
+
+int main(void)
+{
+    char buf1[LONG_STRING];
+    char buf2[LONG_STRING];
+    char *fp_fmt[] = {"%-1.5f",  "%1.5f",  "%123.9f", "%10.5f", "% 10.5f",
+                      "%+22.9f", "%+4.9f", "%01.3f",  "%4f",    "%3.1f",
+                      "%3.2f",   "%.0f",   "%.1f",    NULL};
+    double fp_nums[] = {-1.5,  134.21, 91340.2, 341.1234, 0203.9, 0.96,
+                        0.996, 0.9996, 1.996,   4.136,    0};
+    char *int_fmt[] = {"%-1.5d", "%1.5d",   "%123.9d",  "%5.5d",
+                       "%10.5d", "% 10.5d", "%+22.33d", "%01.3d",
+                       "%4d",    "0x%x",    "0x%04x",   NULL};
+    long int_nums[] = {-1, 134, 91340, 341, 0203, 0x76543210, 0};
+    int x, y;
+    int fail = 0;
+    int num = 0;
+
+    printf("Testing xmpp_snprintf format codes against system sprintf...\n");
+
+    for (x = 0; fp_fmt[x] != NULL; x++)
+        for (y = 0; fp_nums[y] != 0; y++) {
+            xmpp_snprintf(buf1, sizeof(buf1), fp_fmt[x], fp_nums[y]);
+            sprintf(buf2, fp_fmt[x], fp_nums[y]);
+            if (strcmp(buf1, buf2)) {
+                printf("xmpp_snprintf doesn't match Format: "
+                       "%s\n\txmpp_snprintf = %s\n\tsprintf  = %s\n",
+                       fp_fmt[x], buf1, buf2);
+                fail++;
+            }
+            num++;
+        }
+
+    for (x = 0; int_fmt[x] != NULL; x++)
+        for (y = 0; int_nums[y] != 0; y++) {
+            xmpp_snprintf(buf1, sizeof(buf1), int_fmt[x], int_nums[y]);
+            sprintf(buf2, int_fmt[x], int_nums[y]);
+            if (strcmp(buf1, buf2)) {
+                printf("xmpp_snprintf doesn't match Format: "
+                       "%s\n\txmpp_snprintf = %s\n\tsprintf  = %s\n",
+                       int_fmt[x], buf1, buf2);
+                fail++;
+            }
+            num++;
+        }
+    printf("%d tests failed out of %d.\n", fail, num);
+    return fail != 0 ? 1 : 0;
+}

tests/test_sock.c

@@ -1,15 +1,12 @@
 /* test_sock.c
 ** libstrophe XMPP client library -- test routines for the socket abstraction
 **
-** 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.
 **
-**  This software is distributed under license and may not be copied,
+** This program is dual licensed under the MIT and GPLv3 licenses.
-**  modified or distributed except as expressly authorized under the
-**  terms of the license contained in the file LICENSE.txt in this
-**  distribution.
 */
 
 #include <stdio.h>
@@ -26,19 +23,24 @@ int wait_for_connect(sock_t sock)
     fd_set wfds, efds;
     int ret;
 
-    FD_ZERO(&wfds); FD_SET(sock, &wfds);
+    FD_ZERO(&wfds);
-    FD_ZERO(&efds); FD_SET(sock, &efds);
+    FD_SET(sock, &wfds);
+    FD_ZERO(&efds);
+    FD_SET(sock, &efds);
 
     ret = select(sock + 1, NULL, &wfds, &efds, NULL);
-    if (ret <= 0) return -1;
+    if (ret <= 0)
+        return -1;
 
-    if (FD_ISSET(sock, &efds)) return 0;
+    if (FD_ISSET(sock, &efds))
-    if (FD_ISSET(sock, &wfds)) return 1;
+        return 0;
+    if (FD_ISSET(sock, &wfds))
+        return 1;
 
     return -1;
 }
 
-int main(int argc, char **argv)
+int main()
 {
     sock_t sock;
     int err;
@@ -48,15 +50,15 @@ int main(int argc, char **argv)
     sock = sock_connect("www.google.com", 80);
 
     if (sock < 0) {
-	sock_shutdown();
+        sock_shutdown();
-	return 1;
+        return 1;
     }
 
     err = wait_for_connect(sock);
     if (err < 0) {
-	sock_close(sock);
+        sock_close(sock);
-	sock_shutdown();
+        sock_shutdown();
-	return 1;
+        return 1;
     }
 
     sock_close(sock);

tests/test_stanza.c

@@ -0,0 +1,131 @@
+/* test_stanza.c
+ * libstrophe XMPP client library -- test routines for stanza functions
+ *
+ * Copyright (C) 2020 Dmitry Podgorny <pasis.ua@gmail.com>
+ *
+ *  This software is provided AS-IS with no warranty, either express
+ *  or implied.
+ *
+ *  This program is dual licensed under the MIT and GPLv3 licenses.
+ */
+
+/* gcc -o test_stanza -I./src tests/test_stanza.c -lstrophe */
+
+#include <strophe.h>
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MAGICPTR ((void *)0xfeedbeef)
+static unsigned long used_blocks = 0;
+
+static void *stanza_alloc(size_t size, void *userdata)
+{
+    assert(userdata == MAGICPTR);
+
+    ++used_blocks;
+    return malloc(size);
+}
+
+static void stanza_free(void *ptr, void *userdata)
+{
+    assert(userdata == MAGICPTR);
+
+    if (ptr != NULL) {
+        assert(used_blocks > 0);
+        --used_blocks;
+    }
+    free(ptr);
+}
+
+static void *stanza_realloc(void *ptr, size_t size, void *userdata)
+{
+    assert(userdata == MAGICPTR);
+
+    if (ptr != NULL && size == 0) {
+        /* equivalent to free(ptr) */
+        assert(used_blocks > 0);
+        --used_blocks;
+    } else if (ptr == NULL) {
+        /* equivalent to malloc(size) */
+        ++used_blocks;
+    }
+    return realloc(ptr, size);
+}
+
+static const xmpp_mem_t stanza_mem = {
+    .alloc = &stanza_alloc,
+    .free = &stanza_free,
+    .realloc = &stanza_realloc,
+    .userdata = MAGICPTR,
+};
+
+static void test_stanza_add_child(xmpp_ctx_t *ctx)
+{
+    xmpp_stanza_t *stanza;
+    xmpp_stanza_t *child;
+    unsigned long baseline = used_blocks;
+
+    /* xmpp_stanza_add_child */
+
+    stanza = xmpp_stanza_new(ctx);
+    child = xmpp_stanza_new(ctx);
+    assert(stanza != NULL);
+    assert(child != NULL);
+    xmpp_stanza_add_child(stanza, child);
+    xmpp_stanza_release(stanza);
+    assert(used_blocks > baseline);
+    xmpp_stanza_release(child);
+    assert(used_blocks == baseline);
+
+    /* xmpp_stanza_add_child_ex */
+
+    stanza = xmpp_stanza_new(ctx);
+    child = xmpp_stanza_new(ctx);
+    assert(stanza != NULL);
+    assert(child != NULL);
+    xmpp_stanza_add_child_ex(stanza, child, 0);
+    xmpp_stanza_release(stanza);
+    assert(used_blocks == baseline);
+}
+
+static void test_stanza_from_string(xmpp_ctx_t *ctx)
+{
+    xmpp_stanza_t *stanza;
+    char *buf;
+    size_t buflen;
+    int ret;
+
+    static const char *str =
+        "<signcrypt xmlns=\"urn:xmpp:openpgp:0\"><to "
+        "jid=\"user@domain.com\"/><time "
+        "stamp=\"2020-06-03T21:26:24+0200\"/><rpad/><payload><body "
+        "xmlns=\"jabber:client\">Hello World!</body></payload></signcrypt>";
+
+    stanza = xmpp_stanza_new_from_string(ctx, str);
+    assert(stanza != NULL);
+    ret = xmpp_stanza_to_text(stanza, &buf, &buflen);
+    assert(ret == XMPP_EOK);
+    assert(strcmp(buf, str) == 0);
+    xmpp_free(ctx, buf);
+    xmpp_stanza_release(stanza);
+}
+
+int main()
+{
+    xmpp_ctx_t *ctx;
+
+    xmpp_initialize();
+    ctx = xmpp_ctx_new(&stanza_mem, NULL);
+    assert(ctx != NULL);
+
+    test_stanza_add_child(ctx);
+    test_stanza_from_string(ctx);
+
+    xmpp_ctx_free(ctx);
+    xmpp_shutdown();
+
+    /* All allocated blocks must be freed. */
+    assert(used_blocks == 0);
+}

tests/test_string.c

@@ -0,0 +1,126 @@
+/* test_string.c
+ * strophe XMPP client library -- tests for re-implemented string functions
+ *
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "strophe.h"
+#include "common.h"
+#include "util.h"
+
+#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--";
+    char *s1, *s2, *sub1, *sub2;
+    char *sp1, *sp2;
+
+    s1 = strdup(test);
+    s2 = strdup(test);
+    assert(strcmp(s1, s2) == 0);
+
+    sub1 = strtok_r(s1, "-", &sp1);
+    sub2 = xmpp_strtok_r(s2, "-", &sp2);
+    if (strcmp(sub1, sub2) != 0) {
+        printf("1st token is '%s', must be '%s'\n", sub2, sub1);
+        return -1;
+    }
+    sub1 = strtok_r(NULL, "-=", &sp1);
+    sub2 = xmpp_strtok_r(NULL, "-=", &sp2);
+    if (strcmp(sub1, sub2) != 0) {
+        printf("2nd token is '%s', must be '%s'\n", sub2, sub1);
+        return -1;
+    }
+    sub1 = strtok_r(NULL, "-", &sp1);
+    sub2 = xmpp_strtok_r(NULL, "-", &sp2);
+    if (sub1 != sub2) {
+        printf("3rd call returns %p instead of NULL\n", sub2);
+        return -1;
+    }
+
+    free(s1);
+    free(s2);
+
+    return 0;
+}
+
+static int test_strdup_one(xmpp_ctx_t *ctx, const char *s)
+{
+    char *s1, *s2;
+    int rc = 0;
+
+    s1 = strdup(s);
+    s2 = xmpp_strdup(ctx, s);
+
+    if (!s1 || !s2 || strcmp(s1, s2) != 0) {
+        rc = -1;
+        printf("strdup: '%s', xmpp_strdup: '%s'\n", s1 ? s1 : "<NULL>",
+               s2 ? s2 : "<NULL>");
+    }
+
+    free(s1);
+    if (s2)
+        xmpp_free(ctx, s2);
+
+    return rc;
+}
+
+static int test_strdup(void)
+{
+    xmpp_ctx_t *ctx;
+    size_t i;
+    int rc = 0;
+
+    static const char *tests[] = {"", "\0", "test", "s p a c e", "\n\r"};
+
+    ctx = xmpp_ctx_new(NULL, NULL);
+    assert(ctx != NULL);
+    for (i = 0; i < ARRAY_SIZE(tests); ++i) {
+        rc = test_strdup_one(ctx, tests[i]);
+        if (rc != 0)
+            break;
+    }
+    xmpp_ctx_free(ctx);
+
+    return rc;
+}
+
+int main()
+{
+    int rc;
+
+    printf("xmpp_strtok_r() tests... ");
+    rc = test_strtok_r();
+    if (rc != 0)
+        return 1;
+    printf("ok\n");
+
+    printf("xmpp_strdup() tests... ");
+    rc = test_strdup();
+    if (rc != 0)
+        return 1;
+    printf("ok\n");
+
+    return 0;
+}

vs2008/active.vcproj

@@ -1,195 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="9.00"
-	Name="active example"
-	ProjectGUID="{FB499990-F569-426A-9215-5B013D94B70C}"
-	RootNamespace="active"
-	Keyword="Win32Proj"
-	TargetFrameworkVersion="196613"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="1"
-			CharacterSet="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				AdditionalIncludeDirectories="../"
-				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
-				MinimalRebuild="true"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="3"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				DebugInformationFormat="4"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				AdditionalDependencies="Ws2_32.lib winmm.lib"
-				LinkIncremental="2"
-				GenerateDebugInformation="true"
-				SubSystem="1"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="1"
-			CharacterSet="1"
-			WholeProgramOptimization="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="2"
-				EnableIntrinsicFunctions="true"
-				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
-				RuntimeLibrary="2"
-				EnableFunctionLevelLinking="true"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				LinkIncremental="1"
-				GenerateDebugInformation="true"
-				SubSystem="1"
-				OptimizeReferences="2"
-				EnableCOMDATFolding="2"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
-			>
-			<File
-				RelativePath="..\examples\active.c"
-				>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
-			>
-		</Filter>
-		<Filter
-			Name="Resource Files"
-			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
-			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
-			>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>

vs2008/basic.vcproj

@@ -1,195 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="9.00"
-	Name="basic example"
-	ProjectGUID="{7BD355D0-941D-4630-B82F-1FB43A971440}"
-	RootNamespace="basic"
-	Keyword="Win32Proj"
-	TargetFrameworkVersion="196613"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="1"
-			CharacterSet="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				AdditionalIncludeDirectories="../"
-				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
-				MinimalRebuild="true"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="3"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				DebugInformationFormat="4"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				AdditionalDependencies="Ws2_32.lib winmm.lib"
-				LinkIncremental="2"
-				GenerateDebugInformation="true"
-				SubSystem="1"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="1"
-			CharacterSet="1"
-			WholeProgramOptimization="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="2"
-				EnableIntrinsicFunctions="true"
-				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
-				RuntimeLibrary="2"
-				EnableFunctionLevelLinking="true"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				LinkIncremental="1"
-				GenerateDebugInformation="true"
-				SubSystem="1"
-				OptimizeReferences="2"
-				EnableCOMDATFolding="2"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
-			>
-			<File
-				RelativePath="..\examples\basic.c"
-				>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
-			>
-		</Filter>
-		<Filter
-			Name="Resource Files"
-			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
-			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
-			>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>

vs2008/bot.vcproj

@@ -1,195 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="9.00"
-	Name="bot example"
-	ProjectGUID="{DEE25458-271F-4F9A-8979-C460C64B49C8}"
-	RootNamespace="bot"
-	Keyword="Win32Proj"
-	TargetFrameworkVersion="196613"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="1"
-			CharacterSet="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				AdditionalIncludeDirectories="../"
-				PreprocessorDefinitions="WIN32;_DEBUG;_CONSOLE"
-				MinimalRebuild="true"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="3"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				DebugInformationFormat="4"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				AdditionalDependencies="Ws2_32.lib winmm.lib"
-				LinkIncremental="2"
-				GenerateDebugInformation="true"
-				SubSystem="1"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory="$(SolutionDir)$(ConfigurationName)"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="1"
-			CharacterSet="1"
-			WholeProgramOptimization="1"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="2"
-				EnableIntrinsicFunctions="true"
-				PreprocessorDefinitions="WIN32;NDEBUG;_CONSOLE"
-				RuntimeLibrary="2"
-				EnableFunctionLevelLinking="true"
-				UsePrecompiledHeader="0"
-				WarningLevel="3"
-				DebugInformationFormat="3"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLinkerTool"
-				LinkIncremental="1"
-				GenerateDebugInformation="true"
-				SubSystem="1"
-				OptimizeReferences="2"
-				EnableCOMDATFolding="2"
-				TargetMachine="1"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCManifestTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCAppVerifierTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx"
-			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
-			>
-			<File
-				RelativePath="..\examples\bot.c"
-				>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl;inc;xsd"
-			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
-			>
-		</Filter>
-		<Filter
-			Name="Resource Files"
-			Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav"
-			UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
-			>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>

vs2008/expat.vcproj

@@ -1,288 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="9.00"
-	Name="expat"
-	ProjectGUID="{AAFBC1E9-6192-46AE-95BC-642DCB20D361}"
-	RootNamespace="expat"
-	TargetFrameworkVersion="0"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			OutputDirectory=".\Debug"
-			IntermediateDirectory="$(ConfigurationName)"
-			ConfigurationType="4"
-			InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC60.vsprops"
-			UseOfMFC="0"
-			ATLMinimizesCRunTimeLibraryUsage="false"
-			CharacterSet="2"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="0"
-				PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;COMPILED_FROM_DSP;_LIB"
-				BasicRuntimeChecks="3"
-				RuntimeLibrary="3"
-				PrecompiledHeaderFile=".\Debug/expat_static.pch"
-				BrowseInformation="1"
-				WarningLevel="3"
-				SuppressStartupBanner="true"
-				DebugInformationFormat="4"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-				PreprocessorDefinitions="_DEBUG"
-				Culture="1033"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLibrarianTool"
-				OutputFile="Debug\libexpatMTD.lib"
-				SuppressStartupBanner="true"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-				SuppressStartupBanner="true"
-				OutputFile=".\Debug/expat_static.bsc"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			OutputDirectory=".\Release_static"
-			IntermediateDirectory=".\Release_static"
-			ConfigurationType="4"
-			InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC60.vsprops"
-			UseOfMFC="0"
-			ATLMinimizesCRunTimeLibraryUsage="false"
-			CharacterSet="2"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-				Optimization="2"
-				InlineFunctionExpansion="1"
-				PreprocessorDefinitions="WIN32;_WINDOWS;NDEBUG;_LIB;COMPILED_FROM_DSP"
-				StringPooling="true"
-				RuntimeLibrary="0"
-				EnableFunctionLevelLinking="true"
-				PrecompiledHeaderFile=".\Release_static/expat_static.pch"
-				AssemblerListingLocation=".\Release_static/"
-				ObjectFile=".\Release_static/"
-				ProgramDataBaseFileName=".\Release_static/"
-				WarningLevel="3"
-				SuppressStartupBanner="true"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-				PreprocessorDefinitions="NDEBUG"
-				Culture="1033"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLibrarianTool"
-				OutputFile="Release_static\libexpatMT.lib"
-				SuppressStartupBanner="true"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-				SuppressStartupBanner="true"
-				OutputFile=".\Release_static/expat_static.bsc"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<Filter
-			Name="Source Files"
-			Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
-			>
-			<File
-				RelativePath="..\expat\lib\xmlparse.c"
-				>
-				<FileConfiguration
-					Name="Debug|Win32"
-					>
-					<Tool
-						Name="VCCLCompilerTool"
-						PreprocessorDefinitions=""
-					/>
-				</FileConfiguration>
-				<FileConfiguration
-					Name="Release|Win32"
-					>
-					<Tool
-						Name="VCCLCompilerTool"
-						PreprocessorDefinitions=""
-					/>
-				</FileConfiguration>
-			</File>
-			<File
-				RelativePath="..\expat\lib\xmlrole.c"
-				>
-				<FileConfiguration
-					Name="Debug|Win32"
-					>
-					<Tool
-						Name="VCCLCompilerTool"
-						PreprocessorDefinitions=""
-					/>
-				</FileConfiguration>
-				<FileConfiguration
-					Name="Release|Win32"
-					>
-					<Tool
-						Name="VCCLCompilerTool"
-						PreprocessorDefinitions=""
-					/>
-				</FileConfiguration>
-			</File>
-			<File
-				RelativePath="..\expat\lib\xmltok.c"
-				>
-				<FileConfiguration
-					Name="Debug|Win32"
-					>
-					<Tool
-						Name="VCCLCompilerTool"
-						PreprocessorDefinitions=""
-					/>
-				</FileConfiguration>
-				<FileConfiguration
-					Name="Release|Win32"
-					>
-					<Tool
-						Name="VCCLCompilerTool"
-						PreprocessorDefinitions=""
-					/>
-				</FileConfiguration>
-			</File>
-		</Filter>
-		<Filter
-			Name="Header Files"
-			Filter="h;hpp;hxx;hm;inl"
-			>
-			<File
-				RelativePath="..\expat\lib\ascii.h"
-				>
-			</File>
-			<File
-				RelativePath="..\expat\lib\asciitab.h"
-				>
-			</File>
-			<File
-				RelativePath="..\expat\lib\expat.h"
-				>
-			</File>
-			<File
-				RelativePath="..\expat\lib\expat_external.h"
-				>
-			</File>
-			<File
-				RelativePath="..\expat\lib\iasciitab.h"
-				>
-			</File>
-			<File
-				RelativePath="..\expat\lib\internal.h"
-				>
-			</File>
-			<File
-				RelativePath="..\expat\lib\latin1tab.h"
-				>
-			</File>
-			<File
-				RelativePath="..\expat\lib\nametab.h"
-				>
-			</File>
-			<File
-				RelativePath="..\expat\lib\utf8tab.h"
-				>
-			</File>
-			<File
-				RelativePath="..\expat\lib\xmlrole.h"
-				>
-			</File>
-			<File
-				RelativePath="..\expat\lib\xmltok.h"
-				>
-			</File>
-			<File
-				RelativePath="..\expat\lib\xmltok_impl.h"
-				>
-			</File>
-		</Filter>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>

vs2008/libstrophe.sln

@@ -1,66 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 10.00
-# Visual C++ Express 2008
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libstrophe", "libstrophe.vcproj", "{659E3B17-B1BF-4D3B-94E6-438F85EBC410}"
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "active example", "active.vcproj", "{FB499990-F569-426A-9215-5B013D94B70C}"
-	ProjectSection(ProjectDependencies) = postProject
-		{659E3B17-B1BF-4D3B-94E6-438F85EBC410} = {659E3B17-B1BF-4D3B-94E6-438F85EBC410}
-		{AAFBC1E9-6192-46AE-95BC-642DCB20D361} = {AAFBC1E9-6192-46AE-95BC-642DCB20D361}
-	EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "basic example", "basic.vcproj", "{7BD355D0-941D-4630-B82F-1FB43A971440}"
-	ProjectSection(ProjectDependencies) = postProject
-		{659E3B17-B1BF-4D3B-94E6-438F85EBC410} = {659E3B17-B1BF-4D3B-94E6-438F85EBC410}
-		{AAFBC1E9-6192-46AE-95BC-642DCB20D361} = {AAFBC1E9-6192-46AE-95BC-642DCB20D361}
-	EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "bot example", "bot.vcproj", "{DEE25458-271F-4F9A-8979-C460C64B49C8}"
-	ProjectSection(ProjectDependencies) = postProject
-		{659E3B17-B1BF-4D3B-94E6-438F85EBC410} = {659E3B17-B1BF-4D3B-94E6-438F85EBC410}
-		{AAFBC1E9-6192-46AE-95BC-642DCB20D361} = {AAFBC1E9-6192-46AE-95BC-642DCB20D361}
-	EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "roster example", "roster.vcproj", "{5F6591E0-3FAD-45AE-80CF-A47C1F8BA2CC}"
-	ProjectSection(ProjectDependencies) = postProject
-		{659E3B17-B1BF-4D3B-94E6-438F85EBC410} = {659E3B17-B1BF-4D3B-94E6-438F85EBC410}
-		{AAFBC1E9-6192-46AE-95BC-642DCB20D361} = {AAFBC1E9-6192-46AE-95BC-642DCB20D361}
-	EndProjectSection
-EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "expat", "expat.vcproj", "{AAFBC1E9-6192-46AE-95BC-642DCB20D361}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Win32 = Debug|Win32
-		Release|Win32 = Release|Win32
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{659E3B17-B1BF-4D3B-94E6-438F85EBC410}.Debug|Win32.ActiveCfg = Debug|Win32
-		{659E3B17-B1BF-4D3B-94E6-438F85EBC410}.Debug|Win32.Build.0 = Debug|Win32
-		{659E3B17-B1BF-4D3B-94E6-438F85EBC410}.Release|Win32.ActiveCfg = Release|Win32
-		{659E3B17-B1BF-4D3B-94E6-438F85EBC410}.Release|Win32.Build.0 = Release|Win32
-		{FB499990-F569-426A-9215-5B013D94B70C}.Debug|Win32.ActiveCfg = Debug|Win32
-		{FB499990-F569-426A-9215-5B013D94B70C}.Debug|Win32.Build.0 = Debug|Win32
-		{FB499990-F569-426A-9215-5B013D94B70C}.Release|Win32.ActiveCfg = Release|Win32
-		{FB499990-F569-426A-9215-5B013D94B70C}.Release|Win32.Build.0 = Release|Win32
-		{7BD355D0-941D-4630-B82F-1FB43A971440}.Debug|Win32.ActiveCfg = Debug|Win32
-		{7BD355D0-941D-4630-B82F-1FB43A971440}.Debug|Win32.Build.0 = Debug|Win32
-		{7BD355D0-941D-4630-B82F-1FB43A971440}.Release|Win32.ActiveCfg = Release|Win32
-		{7BD355D0-941D-4630-B82F-1FB43A971440}.Release|Win32.Build.0 = Release|Win32
-		{DEE25458-271F-4F9A-8979-C460C64B49C8}.Debug|Win32.ActiveCfg = Debug|Win32
-		{DEE25458-271F-4F9A-8979-C460C64B49C8}.Debug|Win32.Build.0 = Debug|Win32
-		{DEE25458-271F-4F9A-8979-C460C64B49C8}.Release|Win32.ActiveCfg = Release|Win32
-		{DEE25458-271F-4F9A-8979-C460C64B49C8}.Release|Win32.Build.0 = Release|Win32
-		{5F6591E0-3FAD-45AE-80CF-A47C1F8BA2CC}.Debug|Win32.ActiveCfg = Debug|Win32
-		{5F6591E0-3FAD-45AE-80CF-A47C1F8BA2CC}.Debug|Win32.Build.0 = Debug|Win32
-		{5F6591E0-3FAD-45AE-80CF-A47C1F8BA2CC}.Release|Win32.ActiveCfg = Release|Win32
-		{5F6591E0-3FAD-45AE-80CF-A47C1F8BA2CC}.Release|Win32.Build.0 = Release|Win32
-		{AAFBC1E9-6192-46AE-95BC-642DCB20D361}.Debug|Win32.ActiveCfg = Debug|Win32
-		{AAFBC1E9-6192-46AE-95BC-642DCB20D361}.Debug|Win32.Build.0 = Debug|Win32
-		{AAFBC1E9-6192-46AE-95BC-642DCB20D361}.Release|Win32.ActiveCfg = Release|Win32
-		{AAFBC1E9-6192-46AE-95BC-642DCB20D361}.Release|Win32.Build.0 = Release|Win32
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-EndGlobal