WIP examples: PLAIN auth mechanism over raw connection

.gitignore

@@ -34,8 +34,8 @@ examples/active
 examples/basic
 examples/bot
 examples/component
+examples/ext_auth
 examples/roster
-examples/server
 examples/uuid
 examples/vcard
 test_stamp

Makefile.am

@@ -36,7 +36,6 @@ 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,8 +98,8 @@ noinst_PROGRAMS = \
 	examples/basic \
 	examples/bot \
 	examples/component \
+	examples/ext_auth \
 	examples/roster \
-	examples/server \
 	examples/uuid \
 	examples/vcard
 
@@ -116,12 +115,12 @@ examples_bot_LDADD = $(STROPHE_LIBS)
 examples_component_SOURCES = examples/component.c
 examples_component_CFLAGS = $(STROPHE_FLAGS)
 examples_component_LDADD = $(STROPHE_LIBS)
+examples_ext_auth_SOURCES = examples/ext_auth.c
+examples_ext_auth_CFLAGS = $(STROPHE_FLAGS)
+examples_ext_auth_LDADD = $(STROPHE_LIBS)
 examples_roster_SOURCES = examples/roster.c
 examples_roster_CFLAGS = $(STROPHE_FLAGS)
 examples_roster_LDADD = $(STROPHE_LIBS)
-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)

examples/ext_auth.c

@@ -0,0 +1,290 @@
+/* ext_auth.c
+ * strophe XMPP client library -- PLAIN mechanism example with a raw connection
+ *
+ * Copyright (C) 2016 Dmitry Podgorny <pasis.ua@gmail.com>
+ *
+ *  This software is provided AS-IS with no warranty, either express
+ *  or implied.
+ *
+ *  This program is dual licensed under the MIT and GPLv3 licenses.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <strophe.h>
+
+typedef struct {
+    xmpp_ctx_t *ctx;
+    const char *jid;
+    const char *pass;
+    char *domain;
+    int authenticated;
+} xmpp_auth_t;
+
+#define FEATURES_TIMEOUT 5000 /* 5 seconds */
+
+static int _handle_error(xmpp_conn_t * const conn,
+                         xmpp_stanza_t * const stanza,
+                         void * const userdata)
+{
+    fprintf(stderr, "DEBUG: received stream error\n");
+    xmpp_disconnect(conn);
+
+    return 0;
+}
+
+static int _handle_proceedtls_default(xmpp_conn_t * const conn,
+                                      xmpp_stanza_t * const stanza,
+                                      void * const userdata)
+{
+    xmpp_auth_t *auth = (xmpp_auth_t *)userdata;
+    const char *name = xmpp_stanza_get_name(stanza);
+
+    (void)auth;
+    if (strcmp(name, "proceed") == 0) {
+        if (xmpp_conn_tls_start(conn) == 0) {
+            xmpp_handler_delete(conn, _handle_error);
+            xmpp_conn_open_stream_default(conn);
+        } else {
+            /* failed tls spoils the connection, so disconnect */
+            xmpp_disconnect(conn);
+        }
+    } else
+        xmpp_disconnect(conn);
+
+    return 0;
+}
+
+static int _plain_mechanim_exists(xmpp_ctx_t *ctx, xmpp_stanza_t *features)
+{
+    xmpp_stanza_t *mechanisms;
+    xmpp_stanza_t *child;
+    char *text;
+    int found = 0;
+
+    mechanisms = xmpp_stanza_get_child_by_name(features, "mechanisms");
+    child = mechanisms ? xmpp_stanza_get_children(mechanisms) : NULL;
+    while (!found && mechanisms && child) {
+        /* TODO xmpp_stanza_get_name(child) is "mechanism" */
+        text = xmpp_stanza_get_text(child);
+        found = text && strcmp(text, "PLAIN") == 0;
+        xmpp_free(ctx, text);
+        child = xmpp_stanza_get_next(child);
+    }
+    return found;
+}
+
+static char *_plain_mechanism_authdata(xmpp_auth_t *auth)
+{
+    char *node, *b64;
+    unsigned char *msg;
+    size_t node_len, pass_len;
+
+    node = xmpp_jid_node(auth->ctx, auth->jid);
+    node_len = strlen(node);
+    pass_len = strlen(auth->pass);
+    msg = malloc(node_len + pass_len + 2);
+    msg[0] = '\0';
+    memcpy(msg + 1, node, node_len);
+    msg[node_len + 1] = '\0';
+    memcpy(msg + node_len + 2, auth->pass, pass_len);
+    b64 = xmpp_base64_encode(auth->ctx, msg, node_len + pass_len + 2);
+
+    free(msg);
+    xmpp_free(auth->ctx, node);
+
+    return b64;
+}
+
+static int _plain_mechanism_handle_result(xmpp_conn_t * const conn,
+                                          xmpp_stanza_t * const stanza,
+                                          void * const userdata)
+{
+    xmpp_auth_t *auth = (xmpp_auth_t *)userdata;
+    const char *name;
+
+    name = xmpp_stanza_get_name(stanza);
+
+    if (strcmp(name, "success") == 0) {
+        /* SASL PLAIN auth successful, we need to restart the stream */
+        fprintf(stderr, "DEBUG: SASL PLAIN auth successful\n");
+        auth->authenticated = 1;
+        xmpp_handler_delete(conn, _handle_error);
+        xmpp_conn_open_stream_default(conn);
+    } else {
+        fprintf(stderr, "DEBUG: SASL authentication failed: %s\n", name);
+        xmpp_disconnect(conn);
+    }
+    return 0;
+}
+
+static int _handle_missing_features(xmpp_conn_t * const conn,
+                                    void * const userdata)
+{
+    fprintf(stderr, "DEBUG: timeout\n");
+    xmpp_disconnect(conn);
+
+    return 0;
+}
+
+static int _handle_features(xmpp_conn_t * const conn,
+                            xmpp_stanza_t * const stanza,
+                            void * const userdata)
+{
+    xmpp_auth_t *auth = (xmpp_auth_t *)userdata;
+    xmpp_ctx_t *ctx = auth->ctx;
+    xmpp_stanza_t *plain, *child;
+    char *str;
+
+    xmpp_timed_handler_delete(conn, _handle_missing_features);
+
+    if (auth->authenticated) {
+        /* after successful SASL authentication */
+        /* TODO bind, session and we'are done */
+        xmpp_disconnect(conn); /* XXX */
+        return 0;
+    }
+
+    /* secure connection if possible */
+    child = xmpp_stanza_get_child_by_name(stanza, "starttls");
+    if (child && (strcmp(xmpp_stanza_get_ns(child), XMPP_NS_TLS) == 0)) {
+        child = xmpp_stanza_new(ctx);
+        xmpp_stanza_set_name(child, "starttls");
+        xmpp_stanza_set_ns(child, XMPP_NS_TLS);
+        xmpp_handler_add(conn, _handle_proceedtls_default,
+                         XMPP_NS_TLS, NULL, NULL, userdata);
+        xmpp_send(conn, child);
+        xmpp_stanza_release(child);
+        return 0;
+    }
+
+    /* check if PLAIN mechanism is supported */
+    if (!_plain_mechanim_exists(ctx, stanza)) {
+        fprintf(stderr, "DEBUG: PLAIN mechanism is NOT supported\n");
+        xmpp_disconnect(conn);
+        return 0;
+    }
+
+    /* perform authentication */
+    plain = xmpp_stanza_new(ctx);
+    xmpp_stanza_set_name(plain, "auth");
+    xmpp_stanza_set_ns(plain, XMPP_NS_SASL);
+    xmpp_stanza_set_attribute(plain, "mechanism", "PLAIN");
+    str = _plain_mechanism_authdata(auth);
+    child = xmpp_stanza_new(ctx);
+    xmpp_stanza_set_text(child, str);
+    xmpp_free(ctx, str);
+    xmpp_stanza_add_child(plain, child);
+    xmpp_stanza_release(child);
+
+    xmpp_handler_add(conn, _plain_mechanism_handle_result,
+                     XMPP_NS_SASL, NULL, NULL, userdata);
+    xmpp_send(conn, plain);
+    xmpp_stanza_release(plain);
+
+    return 0;
+}
+
+static void conn_handler(xmpp_conn_t * const conn,
+                         const xmpp_conn_event_t status,
+                         const int error,
+                         xmpp_stream_error_t * const stream_error,
+                         void * const userdata)
+{
+    xmpp_auth_t *auth = (xmpp_auth_t *)userdata;
+    xmpp_ctx_t *ctx = auth->ctx;
+    int secured;
+
+    if (status == XMPP_CONN_RAW_CONNECT) {
+        fprintf(stderr, "DEBUG: raw connection established\n");
+        xmpp_conn_open_stream_default(conn);
+    } else if (status == XMPP_CONN_CONNECT) {
+        fprintf(stderr, "DEBUG: stream opened\n");
+        secured = xmpp_conn_is_secured(conn);
+        fprintf(stderr, "DEBUG: connection is %s.\n",
+                secured ? "secured" : "NOT secured");
+
+        /* setup handler for stream:error */
+        xmpp_handler_add(conn, _handle_error, XMPP_NS_STREAMS,
+                         "error", NULL, NULL);
+
+        /* setup handlers for incoming <stream:features> */
+        xmpp_handler_add(conn, _handle_features, XMPP_NS_STREAMS,
+                         "features", NULL, auth);
+        xmpp_timed_handler_add(conn, _handle_missing_features,
+                               FEATURES_TIMEOUT, NULL);
+    } else {
+        fprintf(stderr, "DEBUG: disconnected\n");
+        xmpp_stop(ctx);
+    }
+}
+
+static xmpp_auth_t *xmpp_auth_new(void)
+{
+    xmpp_auth_t *auth;
+
+    auth = malloc(sizeof(*auth));
+    if (auth != NULL) {
+        memset(auth, 0, sizeof(*auth));
+    }
+    return auth;
+}
+
+static void xmpp_auth_release(xmpp_auth_t *auth)
+{
+    free(auth);
+}
+
+int main(int argc, char **argv)
+{
+    xmpp_ctx_t *ctx;
+    xmpp_conn_t *conn;
+    xmpp_log_t *log;
+    xmpp_auth_t *auth;
+    const char *jid;
+    const char *pass;
+    const char *host = NULL;
+
+    if (argc < 3 || argc > 4) {
+        fprintf(stderr, "Usage: %s <jid> <pass> [<host>]\n", argv[0]);
+        return 1;
+    }
+
+    jid = argv[1];
+    pass = argv[2];
+    if (argc > 3)
+        host = argv[3];
+
+    /*
+     * Note, this example doesn't handle errors. Applications should check
+     * return values of non-void functions.
+     */
+
+    xmpp_initialize();
+    log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG);
+    ctx = xmpp_ctx_new(NULL, log);
+    conn = xmpp_conn_new(ctx);
+
+    xmpp_conn_set_jid(conn, jid);
+
+    /* private data */
+    auth = xmpp_auth_new();
+    auth->ctx = ctx;
+    auth->jid = jid;
+    auth->pass = pass;
+    auth->domain = xmpp_jid_domain(ctx, jid);
+
+    xmpp_connect_raw(conn, host, 0, conn_handler, auth);
+    xmpp_run(ctx);
+
+    /* release private data */
+    xmpp_auth_release(auth);
+
+    xmpp_conn_release(conn);
+    xmpp_ctx_free(ctx);
+    xmpp_shutdown();
+
+    return 0;
+}

examples/server.c

@@ -1,83 +0,0 @@
-
-#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,7 +44,6 @@ 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,11 +43,6 @@ 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;
@@ -55,7 +50,6 @@ 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;
 };
@@ -231,24 +225,6 @@ 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

@@ -625,15 +625,14 @@ int xmpp_conn_open_stream(xmpp_conn_t * const conn, char **attributes,
 {
     char *tag;
 
-    if (!conn->is_raw && conn->type != XMPP_INCOMING)
+    if (!conn->is_raw)
         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);
-        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/ctx.c

@@ -415,7 +415,6 @@ 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,9 +67,7 @@
 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;
@@ -208,23 +206,6 @@ 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);
@@ -312,24 +293,6 @@ 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/server.c

@@ -1,162 +0,0 @@
-/* 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,43 +109,6 @@ 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,9 +32,6 @@ 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);

strophe.h

@@ -139,8 +139,7 @@ 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, 
@@ -212,7 +211,7 @@ 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 int error,
 				  xmpp_stream_error_t * const stream_error,
@@ -264,30 +263,6 @@ 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 */