WIP Initial server support

.gitignore

@@ -35,6 +35,7 @@ examples/basic
 examples/bot
 examples/component
 examples/roster
+examples/server
 examples/uuid
 examples/vcard
 test_stamp

ChangeLog

@@ -8,9 +8,6 @@
 	  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_ctx_set_timeout()
 		- xmpp_sha1_digest()

Makefile.am

@@ -11,7 +11,7 @@ SSL_LIBS = @openssl_LIBS@
 
 RESOLV_LIBS = @RESOLV_LIBS@
 
-STROPHE_FLAGS = -I$(top_srcdir) -Wall -Wextra -Wno-unused-parameter
+STROPHE_FLAGS = -I$(top_srcdir) -Wall -Wextra -Werror -Wno-unused-parameter
 STROPHE_LIBS = libstrophe.la
 
 ## Main build targets
@@ -36,6 +36,7 @@ libstrophe_la_SOURCES = \
 	src/resolver.c \
 	src/sasl.c \
 	src/scram.c \
+	src/server.c \
 	src/sha1.c \
 	src/snprintf.c \
 	src/sock.c \
@@ -99,6 +100,7 @@ noinst_PROGRAMS = \
 	examples/bot \
 	examples/component \
 	examples/roster \
+	examples/server \
 	examples/uuid \
 	examples/vcard
 
@@ -117,6 +119,9 @@ examples_component_LDADD = $(STROPHE_LIBS)
 examples_roster_SOURCES = examples/roster.c
 examples_roster_CFLAGS = $(STROPHE_FLAGS)
 examples_roster_LDADD = $(STROPHE_LIBS)
+examples_server_SOURCES = examples/server.c
+examples_server_CFLAGS = $(STROPHE_FLAGS)
+examples_server_LDADD = $(STROPHE_LIBS)
 examples_uuid_SOURCES = examples/uuid.c
 examples_uuid_CFLAGS = $(STROPHE_FLAGS)
 examples_uuid_LDADD = $(STROPHE_LIBS)

configure.ac

@@ -1,4 +1,4 @@
-AC_INIT([libstrophe], [0.9.2], [jack@metajack.im])
+AC_INIT([libstrophe], [0.9.1], [jack@metajack.im])
 AC_CONFIG_MACRO_DIR([m4])
 AM_INIT_AUTOMAKE([foreign])
 LT_INIT([dlopen])

examples/server.c

@@ -0,0 +1,83 @@
+
+#include <stdio.h>
+#include <string.h>
+#include <strophe.h>
+
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
+#endif
+
+int message_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza,
+                    void * const userdata)
+{
+    xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
+    xmpp_stanza_t *success;
+
+    if (strcmp(xmpp_stanza_get_name(stanza), "auth") == 0) {
+        success = xmpp_stanza_new(ctx);
+        xmpp_stanza_set_name(success, "success");
+        xmpp_stanza_set_ns(success, XMPP_NS_SASL);
+        xmpp_send(conn, success);
+        xmpp_stanza_release(success);
+    } else
+        xmpp_disconnect(conn);
+
+    return 1;
+}
+
+void server_handler(xmpp_server_t * const srv, xmpp_conn_t * const conn,
+                    const xmpp_server_event_t event, const int error,
+                    void * const userdata)
+{
+    xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
+
+    static char *attrs[] = {
+        "xmlns", XMPP_NS_CLIENT, "xmlns:stream", XMPP_NS_STREAMS,
+        "id", "0123456789", "from", "127.0.0.1", "version", "1.0",
+        "xml:lang", "en",
+    };
+
+    switch (event) {
+    case XMPP_SERVER_ACCEPT:
+        printf("Event XMPP_SERVER_ACCEPT\n");
+        break;
+    case XMPP_SERVER_OPEN_STREAM:
+        printf("Event XMPP_SERVER_OPEN_STREAM\n");
+        xmpp_handler_add(conn, message_handler, NULL, NULL, NULL, ctx);
+        xmpp_conn_open_stream(conn, attrs, ARRAY_SIZE(attrs));
+        xmpp_send_raw_string(conn,
+                "<stream:features>"
+                "<mechanisms xmlns=\"%s\"><mechanism>PLAIN</mechanism>"
+                "</mechanisms></stream:features>", XMPP_NS_SASL);
+        break;
+    case XMPP_SERVER_DISCONNECT:
+        printf("Event XMPP_SERVER_DISCONNECT\n");
+        xmpp_stop(ctx);
+        break;
+    default:
+        printf("Unknown event\n");
+        break;
+    }
+}
+
+int main()
+{
+    xmpp_ctx_t *ctx;
+    xmpp_log_t *log;
+    xmpp_server_t *srv;
+
+    xmpp_initialize();
+    log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG);
+    ctx = xmpp_ctx_new(NULL, log);
+    srv = xmpp_server_new(ctx);
+    xmpp_server_listen(srv, 0, server_handler, ctx);
+
+    xmpp_run(ctx);
+
+    xmpp_server_stop(srv);
+    xmpp_server_free(srv);
+    xmpp_ctx_free(ctx);
+    xmpp_shutdown();
+
+    return 0;
+}

jni/Android.mk

@@ -44,6 +44,7 @@ LOCAL_SRC_FILES := \
 	../src/resolver.c \
 	../src/sasl.c \
 	../src/scram.c \
+	../src/server.c \
 	../src/sha1.c \
 	../src/snprintf.c \
 	../src/sock.c \

src/common.h

@@ -43,6 +43,11 @@ typedef struct _xmpp_connlist_t {
     struct _xmpp_connlist_t *next;
 } xmpp_connlist_t;
 
+typedef struct _xmpp_serverlist_t {
+    xmpp_server_t *server;
+    struct _xmpp_serverlist_t *next;
+} xmpp_serverlist_t;
+
 struct _xmpp_ctx_t {
     const xmpp_mem_t *mem;
     const xmpp_log_t *log;
@@ -50,6 +55,7 @@ struct _xmpp_ctx_t {
     xmpp_rand_t *rand;
     xmpp_loop_status_t loop_status;
     xmpp_connlist_t *connlist;
+    xmpp_serverlist_t *serverlist;
 
     unsigned long timeout;
 };
@@ -225,6 +231,24 @@ 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_STATE_STOPPED,
+    XMPP_STATE_LISTENING
+} xmpp_server_state_t;
+
+struct _xmpp_server_t {
+    xmpp_ctx_t *ctx;
+    xmpp_server_state_t state;
+
+    sock_t sock;
+    unsigned short port;
+    xmpp_server_handler callback;
+    void *userdata;
+    /* incomming connections list */
+};
+
+void server_accept(xmpp_server_t * const srv);
+void server_handle_open(xmpp_conn_t * const conn);
 
 typedef enum {
     XMPP_STANZA_UNKNOWN,

src/conn.c

@@ -73,15 +73,6 @@ static int _conn_connect(xmpp_conn_t * const conn,
                          xmpp_conn_handler callback,
                          void * const userdata);
 
-void xmpp_send_error(xmpp_conn_t * const conn, xmpp_error_type_t const type, char * const text)
-{
-    xmpp_stanza_t *error = xmpp_error_new(conn->ctx, type, text);
-
-    xmpp_send(conn, error);
-
-    xmpp_stanza_release(error);
-}
-
 /** Create a new Strophe connection object.
  *
  *  @param ctx a Strophe context object
@@ -634,13 +625,14 @@ int xmpp_conn_open_stream(xmpp_conn_t * const conn, char **attributes,
 {
     char *tag;
 
-    if (!conn->is_raw)
+    if (!conn->is_raw && conn->type != XMPP_INCOMING)
         return XMPP_EINVOP;
 
     tag = _conn_build_stream_tag(conn, attributes, attributes_len);
     if (!tag)
         return XMPP_EMEM;
 
+    if (conn->type != XMPP_INCOMING)
         conn_prepare_reset(conn, auth_handle_open_raw);
     xmpp_send_raw_string(conn, "<?xml version=\"1.0\"?>%s", tag);
     xmpp_free(conn->ctx, tag);

src/crypto.c

@@ -61,7 +61,7 @@ static char *digest_to_string_alloc(xmpp_ctx_t *ctx, const uint8_t *digest)
     return s;
 }
 
-/** Compute SHA1 message digest.
+/** Compute SHA1 message digest
  *  Returns an allocated string which represents SHA1 message digest in
  *  hexadecimal notation. The string must be freed with xmpp_free().
  *
@@ -81,7 +81,7 @@ char *xmpp_sha1(xmpp_ctx_t *ctx, const unsigned char *data, size_t len)
     return digest_to_string_alloc(ctx, digest);
 }
 
-/** Compute SHA1 message digest.
+/** Compute SHA1 message digest
  *  Stores digest in user's buffer which must be at least XMPP_SHA1_DIGEST_SIZE
  *  bytes long.
  *
@@ -97,7 +97,7 @@ void xmpp_sha1_digest(const unsigned char *data, size_t len,
     crypto_SHA1((const uint8_t *)data, len, digest);
 }
 
-/** Create new SHA1 object.
+/** Create new SHA1 object
  *  SHA1 object is used to compute SHA1 digest of a buffer that is split
  *  in multiple chunks or provided in stream mode. A single buffer can be
  *  processed by short functions xmpp_sha1() and xmpp_sha1_digest().
@@ -111,7 +111,7 @@ void xmpp_sha1_digest(const unsigned char *data, size_t len,
  *      xmpp_sha1_free(sha1);
  *  @endcode
  *
- *  @param ctx a Strophe context object
+ *  @param ctx a Strophe context onject
  *
  *  @return new SHA1 object
  *
@@ -130,7 +130,7 @@ xmpp_sha1_t *xmpp_sha1_new(xmpp_ctx_t *ctx)
     return sha1;
 }
 
-/** Destroy SHA1 object.
+/** Destroy SHA1 object
  *
  *  @param sha1 a SHA1 object
  *
@@ -141,7 +141,7 @@ void xmpp_sha1_free(xmpp_sha1_t *sha1)
     xmpp_free(sha1->xmpp_ctx, sha1);
 }
 
-/** Update SHA1 context with the next portion of data.
+/** Update SHA1 context with the next portion of data
  *  Can be called repeatedly.
  *
  *  @param sha1 a SHA1 object
@@ -155,7 +155,7 @@ void xmpp_sha1_update(xmpp_sha1_t *sha1, const unsigned char *data, size_t len)
     crypto_SHA1_Update(&sha1->ctx, data, len);
 }
 
-/** Finish SHA1 computation.
+/** Finish SHA1 computation
  *  Don't call xmpp_sha1_update() after this function. Retrieve resulting
  *  message digest with xmpp_sha1_to_string() or xmpp_sha1_to_digest().
  *
@@ -168,7 +168,7 @@ void xmpp_sha1_final(xmpp_sha1_t *sha1)
     crypto_SHA1_Final(&sha1->ctx, sha1->digest);
 }
 
-/** Return message digest rendered as a string.
+/** Return message digest rendered as a string
  *  Stores the string to a user's buffer and returns the buffer. Call this
  *  function after xmpp_sha1_final().
  *
@@ -185,7 +185,7 @@ char *xmpp_sha1_to_string(xmpp_sha1_t *sha1, char *s, size_t slen)
     return digest_to_string(sha1->digest, s, slen);
 }
 
-/** Return message digest rendered as a string.
+/** Return message digest rendered as a string
  *  Returns an allocated string. Free the string using the Strophe context
  *  which is passed to xmpp_sha1_new(). Call this function after
  *  xmpp_sha1_final().
@@ -201,7 +201,7 @@ char *xmpp_sha1_to_string_alloc(xmpp_sha1_t *sha1)
     return digest_to_string_alloc(sha1->xmpp_ctx, sha1->digest);
 }
 
-/** Stores message digest to a user's buffer.
+/** Stores message digest to a user's buffer
  *
  *  @param sha1 a SHA1 object
  *  @param digest output buffer of XMPP_SHA1_DIGEST_SIZE bytes
@@ -419,7 +419,7 @@ _base64_error:
     *outlen = 0;
 }
 
-/** Base64 encoding routine.
+/** Base64 encoding routine
  *  Returns an allocated string which must be freed with xmpp_free().
  *
  *  @param ctx a Strophe context
@@ -435,7 +435,7 @@ char *xmpp_base64_encode(xmpp_ctx_t *ctx, const unsigned char *data, size_t len)
     return base64_encode(ctx, data, len);
 }
 
-/** Base64 decoding routine.
+/** Base64 decoding routine
  *  Returns an allocated string which must be freed with xmpp_free(). User
  *  calls this function when the result must be a string. When decoded buffer
  *  contains '\0' NULL is returned.
@@ -471,7 +471,7 @@ char *xmpp_base64_decode_str(xmpp_ctx_t *ctx, const char *base64, size_t len)
     return (char *)buf;
 }
 
-/** Base64 decoding routine.
+/** Base64 decoding routine
  *  Returns an allocated buffer which must be freed with xmpp_free().
  *
  *  @param ctx a Strophe context

src/ctx.c

@@ -415,6 +415,7 @@ xmpp_ctx_t *xmpp_ctx_new(const xmpp_mem_t * const mem,
             ctx->log = log;
 
         ctx->connlist = NULL;
+        ctx->serverlist = NULL;
         ctx->loop_status = XMPP_LOOP_NOTSTARTED;
         ctx->rand = xmpp_rand_new(ctx);
         ctx->timeout = EVENT_LOOP_DEFAULT_TIMEOUT;

src/event.c

@@ -67,7 +67,9 @@
 void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
 {
     xmpp_connlist_t *connitem;
+    xmpp_serverlist_t *serveritem;
     xmpp_conn_t *conn;
+    xmpp_server_t *srv;
     fd_set rfds, wfds;
     sock_t max = 0;
     int ret;
@@ -206,6 +208,23 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
         connitem = connitem->next;
     }
 
+    serveritem = ctx->serverlist;
+    while (serveritem) {
+        srv = serveritem->server;
+
+        switch (srv->state) {
+        case XMPP_STATE_LISTENING:
+            FD_SET(srv->sock, &rfds);
+            if (srv->sock > max) max = srv->sock;
+            break;
+        case XMPP_STATE_STOPPED:
+            /* do nothing */
+        default:
+            break;
+        }
+        serveritem = serveritem->next;
+    }
+
     /* check for events */
     if (max > 0)
         ret = select(max + 1, &rfds,  &wfds, NULL, &tv);
@@ -262,8 +281,10 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
                 if (ret > 0) {
                     ret = parser_feed(conn->parser, buf, ret);
                     if (!ret) {
-                        xmpp_debug(ctx, "xmpp", "parse error [%s]", buf);
+                        /* parse error, we need to shut down */
-                        xmpp_send_error(conn, XMPP_SE_INVALID_XML, "parse error");
+                        /* FIXME */
+                        xmpp_debug(ctx, "xmpp", "parse error, disconnecting");
+                        conn_disconnect(conn);
                     }
                 } else {
                     if (conn->tls) {
@@ -291,6 +312,24 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
         connitem = connitem->next;
     }
 
+    serveritem = ctx->serverlist;
+    while (serveritem) {
+        srv = serveritem->server;
+
+        switch (srv->state) {
+        case XMPP_STATE_LISTENING:
+            if (FD_ISSET(srv->sock, &rfds)) {
+                server_accept(srv);
+            }
+            break;
+        case XMPP_STATE_STOPPED:
+            /* do nothing */
+        default:
+            break;
+        }
+        serveritem = serveritem->next;
+    }
+
     /* fire any ready handlers */
     handler_fire_timed(ctx);
 }

src/hash.c

@@ -241,7 +241,7 @@ void hash_iter_release(hash_iterator_t *iter)
 
     iter->ref--;
 
-    if (iter->ref == 0) { // ref is unsigned!!!
+    if (iter->ref <= 0) {
 	hash_release(iter->table);
 	xmpp_free(ctx, iter);
     }

src/parser_libxml2.c

@@ -249,8 +249,6 @@ void parser_free(parser_t *parser)
 {
     if (parser->xmlctx)
         xmlFreeParserCtxt(parser->xmlctx);
-    if (parser->stanza)
-        xmpp_stanza_release(parser->stanza);
     xmpp_free(parser->ctx, parser);
 }
 
@@ -259,16 +257,18 @@ int parser_reset(parser_t *parser)
 {
     if (parser->xmlctx)
         xmlFreeParserCtxt(parser->xmlctx);
+
     if (parser->stanza) 
 	xmpp_stanza_release(parser->stanza);
 
-    parser->stanza = NULL;
-    parser->depth = 0;
-
     parser->xmlctx = xmlCreatePushParserCtxt(&parser->handlers, 
                                              parser, NULL, 0, NULL);
+    if (!parser->xmlctx) return 0;
 
-    return parser->xmlctx ? 1 : 0;
+    parser->depth = 0;
+    parser->stanza = NULL;
+
+    return 1;
 }
 
 /* feed a chunk of data to the parser */

src/resolver.c

@@ -517,7 +517,7 @@ static int resolver_win32_srv_query(const char *fulldomain,
                                     unsigned char *buf, size_t len)
 {
     int set = 0;
-    int insize = 0;
+    int insize;
 
     /* if dnsapi didn't work/isn't there, try querying the dns server manually */
     if (!set)
@@ -550,7 +550,7 @@ static int resolver_win32_srv_query(const char *fulldomain,
 				char buffer[65535];
 
 				len = 65535;
-				fi = (FIXED_INFO *)buffer;
+				fi = buffer;
 
 				if ((error = pGetNetworkParams(fi, &len)) == ERROR_SUCCESS)
 				{

src/sasl.c

@@ -264,7 +264,6 @@ char *sasl_digest_md5(xmpp_ctx_t *ctx, const char *challenge,
     xmpp_rand_nonce(ctx->rand, cnonce, sizeof(cnonce));
     hash_add(table, "cnonce", xmpp_strdup(ctx, cnonce));
     hash_add(table, "nc", xmpp_strdup(ctx, "00000001"));
-    if (hash_get(table, "qop") == NULL)
     hash_add(table, "qop", xmpp_strdup(ctx, "auth"));
     value = xmpp_alloc(ctx, 5 + strlen(domain) + 1);
     memcpy(value, "xmpp/", 5);

src/server.c

@@ -0,0 +1,162 @@
+/* server.c
+ * strophe XMPP client library -- server object 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.
+ */
+
+/** @file
+ *  Server management.
+ */
+
+/** @defgroup Server Server management
+ */
+
+#include <string.h>
+
+#include "common.h"
+#include "strophe.h"
+
+static xmpp_server_t *conn2srv(xmpp_conn_t *conn);
+static void _server_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_server_t *xmpp_server_new(xmpp_ctx_t * const ctx)
+{
+    xmpp_server_t *srv;
+    xmpp_serverlist_t *item;
+
+    srv = xmpp_alloc(ctx, sizeof(*srv));
+    item = xmpp_alloc(ctx, sizeof(*item));
+    if (srv == NULL || item == NULL) {
+        xmpp_error(ctx, "xmpp", "Failed to allocate memory.");
+        xmpp_free(ctx, srv);
+        xmpp_free(ctx, item);
+        srv = NULL;
+        item = NULL;
+    }
+
+    if (srv != NULL) {
+        memset(srv, 0, sizeof(*srv));
+        srv->state = XMPP_STATE_STOPPED;
+        srv->ctx = ctx;
+        srv->sock = -1;
+
+        item->server = srv;
+        item->next = ctx->serverlist;
+        ctx->serverlist = item;
+    }
+    return srv;
+}
+
+void xmpp_server_free(xmpp_server_t * const srv)
+{
+    xmpp_ctx_t *ctx = srv->ctx;
+    xmpp_serverlist_t *item, *prev = NULL;
+
+    item = ctx->serverlist;
+    while (item != NULL) {
+        if (item->server == srv) {
+            if (prev == NULL) ctx->serverlist = item->next;
+            if (prev != NULL) prev->next = item->next;
+            xmpp_free(ctx, item);
+        }
+        prev = item;
+        item = item->next;
+    }
+
+    xmpp_free(ctx, srv);
+}
+
+int xmpp_server_listen(xmpp_server_t * const srv, unsigned short port,
+                       xmpp_server_handler callback, void * const userdata)
+{
+    int rc = 0;
+
+    if (port == 0) port = XMPP_PORT_CLIENT;
+    srv->callback = callback;
+    srv->userdata = userdata;
+    srv->port = port;
+    srv->sock = sock_listen(port);
+    if (srv->sock >= 0) {
+        srv->state = XMPP_STATE_LISTENING;
+        xmpp_debug(srv->ctx, "xmpp", "Listening on port %u.", port);
+    } else
+        rc = XMPP_EINT;
+
+    return rc;
+}
+
+void xmpp_server_stop(xmpp_server_t * const srv)
+{
+    srv->state = XMPP_STATE_STOPPED;
+    sock_stop_listen(srv->sock);
+    xmpp_debug(srv->ctx, "xmpp", "Server stopped on %u.", srv->port);
+}
+
+void server_accept(xmpp_server_t * const srv)
+{
+    xmpp_conn_t *conn;
+    sock_t fd;
+
+    fd = sock_accept(srv->sock);
+    if (fd >= 0) {
+        xmpp_debug(srv->ctx, "xmpp", "New incoming connection on port %u.",
+                   srv->port);
+
+        conn = xmpp_conn_new(srv->ctx);
+        conn->type = XMPP_INCOMING;
+        conn->state = XMPP_STATE_CONNECTED;
+        conn->sock = fd;
+        conn->conn_handler = _server_conn_handler;
+        conn->userdata = (void *)srv;
+        conn->authenticated = 1; /* don't ignore handlers */
+        conn_prepare_reset(conn, server_handle_open);
+
+        srv->callback(srv, conn, XMPP_SERVER_ACCEPT, 0, srv->userdata);
+    }
+}
+
+void server_handle_open(xmpp_conn_t * const conn)
+{
+    xmpp_server_t *srv = conn2srv(conn);
+
+    /* XXX need to reset parser and re-open stream after authentication */
+
+    srv->callback(srv, conn, XMPP_SERVER_OPEN_STREAM, 0, srv->userdata);
+}
+
+static xmpp_server_t *conn2srv(xmpp_conn_t *conn)
+{
+    xmpp_server_t *srv;
+
+    /* XXX dirty hack */
+    if (conn->ctx->serverlist != NULL)
+        srv = conn->ctx->serverlist->server;
+    else
+        srv = NULL;
+
+    return srv;
+}
+
+static void _server_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_server_t *srv = (xmpp_server_t *)userdata;
+
+    if (status == XMPP_CONN_DISCONNECT) {
+        /* remove conn from the list */
+        /* XXX when client sends </stream> first, server should close stream too */
+        srv->callback(srv, conn, XMPP_SERVER_DISCONNECT, error, srv->userdata);
+    }
+}

src/sock.c

@@ -109,6 +109,43 @@ sock_t sock_connect(const char * const host, const unsigned short port)
     return sock;
 }
 
+sock_t sock_listen(const unsigned short port)
+{
+    struct sockaddr_in addr;
+    sock_t sock;
+    int rc;
+
+    sock = socket(AF_INET, SOCK_STREAM, 0);
+    if (sock < 0) return -1;
+
+    memset(&addr, 0, sizeof(addr));
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(port);
+    addr.sin_addr.s_addr = INADDR_ANY;
+    rc = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
+    if (rc == 0) {
+        rc = listen(sock, 100);
+        sock_set_nonblocking(sock);
+    }
+    if (rc != 0) close(sock);
+
+    return rc == 0 ? sock : -1;
+}
+
+int sock_stop_listen(const sock_t sock)
+{
+    return sock_close(sock);
+}
+
+sock_t sock_accept(const sock_t sock)
+{
+    sock_t fd;
+
+    fd = accept(sock, NULL, NULL);
+
+    return fd;
+}
+
 int sock_set_keepalive(const sock_t sock, int timeout, int interval)
 {
     int ret;

src/sock.h

@@ -32,6 +32,9 @@ int sock_error(void);
 
 sock_t sock_connect(const char * const host, const unsigned short port);
 int sock_close(const sock_t sock);
+sock_t sock_listen(const unsigned short port);
+int sock_stop_listen(const sock_t sock);
+sock_t sock_accept(const sock_t sock);
 
 int sock_set_blocking(const sock_t sock);
 int sock_set_nonblocking(const sock_t sock);

src/stanza.c

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

src/tls_openssl.c

@@ -209,14 +209,6 @@ int tls_stop(tls_t *tls)
         }
         _tls_sock_wait(tls, error);
     }
-    if (error == SSL_ERROR_SYSCALL && errno == 0) {
-        /*
-         * Handle special case when peer closes connection instead of
-         * proper shutdown.
-         */
-        error = 0;
-        ret = 1;
-    }
     _tls_set_error(tls, error);
 
     return ret <= 0 ? 0 : 1;
@@ -268,8 +260,6 @@ static void _tls_sock_wait(tls_t *tls, int error)
     int nfds;
     int ret;
 
-    if (error == SSL_ERROR_NONE) return;
-
     FD_ZERO(&rfds);
     FD_ZERO(&wfds);
     if (error == SSL_ERROR_WANT_READ)
@@ -288,7 +278,6 @@ static void _tls_sock_wait(tls_t *tls, int error)
 static void _tls_set_error(tls_t *tls, int error)
 {
     if (error != 0 && !tls_is_recoverable(error)) {
-        xmpp_debug(tls->ctx, "tls", "error=%d errno=%d", error, errno);
         _tls_log_error(tls->ctx);
     }
     tls->lasterror = error;

strophe.h

@@ -139,7 +139,8 @@ typedef enum {
 typedef enum {
     XMPP_UNKNOWN,
     XMPP_CLIENT,
-    XMPP_COMPONENT
+    XMPP_COMPONENT,
+    XMPP_INCOMING
 } xmpp_conn_type_t;
 
 typedef void (*xmpp_log_handler)(void * const userdata, 
@@ -217,7 +218,6 @@ typedef void (*xmpp_conn_handler)(xmpp_conn_t * const conn,
 				  xmpp_stream_error_t * const stream_error,
 				  void * const userdata);
 
-void xmpp_send_error(xmpp_conn_t * const conn, xmpp_error_type_t const type, char * const text);
 xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t * const ctx);
 xmpp_conn_t *xmpp_conn_clone(xmpp_conn_t * const conn);
 int xmpp_conn_release(xmpp_conn_t * const conn);
@@ -264,6 +264,30 @@ void xmpp_send_raw_string(xmpp_conn_t * const conn,
 void xmpp_send_raw(xmpp_conn_t * const conn, 
 		   const char * const data, const size_t len);
 
+/* server */
+
+/* opaque server object */
+typedef struct _xmpp_server_t xmpp_server_t;
+
+/* server callback */
+typedef enum {
+    XMPP_SERVER_ACCEPT,
+    XMPP_SERVER_OPEN_STREAM,
+    XMPP_SERVER_DISCONNECT,
+    XMPP_SERVER_FAIL
+} xmpp_server_event_t;
+
+typedef void (*xmpp_server_handler)(xmpp_server_t * const srv,
+                                    xmpp_conn_t * const conn,
+                                    const xmpp_server_event_t event,
+                                    const int error,
+                                    void * const userdata);
+
+xmpp_server_t *xmpp_server_new(xmpp_ctx_t * const ctx);
+void xmpp_server_free(xmpp_server_t * const srv);
+int xmpp_server_listen(xmpp_server_t * const srv, unsigned short port,
+                       xmpp_server_handler callback, void * const userdata);
+void xmpp_server_stop(xmpp_server_t * const srv);
 
 /* handlers */
 
@@ -382,8 +406,6 @@ int xmpp_message_set_body(xmpp_stanza_t *msg, const char * const text);
 xmpp_stanza_t *xmpp_iq_new(xmpp_ctx_t *ctx, const char * const type,
                            const char * const id);
 xmpp_stanza_t *xmpp_presence_new(xmpp_ctx_t *ctx);
-xmpp_stanza_t *xmpp_error_new(xmpp_ctx_t *ctx, xmpp_error_type_t const type,
-                              const char * const text);
 
 /* jid */
 

tests/test_string.c

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