stropheruby 0.1.5 → 0.2

data/History.txt

@@ -1,3 +1,6 @@
+== 0.2 2010-02-26
+  * update the libstrophe src to 20090526
+
 == 0.1.4 2010-02-26
 
   * accessor of the connect_timeout in Connection class 

data/README.txt

@@ -4,6 +4,7 @@ Stropheruby is a ruby bindings for Strophe, a C library for writing XMPP clients
 
 This is a fork of flamontagne's stropheruby (http://github.com/flamontagne/stropheruby/tree/master) with the following improvements:
 
+* accessor of the connect_timeout in the Connection class
 * A patched version of libstrophe (trunk) is included. So there is no extra library to install. 
 * (libstrophe) Fixed a timeout issue on Mac OSX: http://groups.google.com/group/strophe-dev/browse_thread/thread/ef4cb19785020fb6
 * (libstrophe) Fixed basic auth: http://groups.google.com/group/strophe-dev/browse_thread/thread/b770f72c83d1a0b9
@@ -17,11 +18,15 @@ This is a fork of flamontagne's stropheruby (http://github.com/flamontagne/strop
 
 == INSTALLATION
 
-sudo gem sources -a http://gems.github.com
-sudo gem install yong-stropheruby
+sudo gem sources -a http://gemcutter.org
+sudo gem install stropheruby
 
 For Rails app, add this line in your config/environment.rb:
-config.gem "yong-stropheruby", :source => "http://gems.github.com", :lib => "strophe_ruby"
+config.gem "stropheruby", :source => "http://gemcutter.org", :lib => "strophe_ruby"
+
+== NOTES
+
+Stropheruby v2.0 has upgraded the libstrophe to the upstream which is 20090526
 
 == EXAMPLE
 

data/ext/auth.c

@@ -1,7 +1,7 @@
 /* auth.c
 ** strophe XMPP client library -- auth functions and handlers
 **
-** Copyright (C) 2005-2008 OGG, LLC. All rights reserved.
+** Copyright (C) 2005-2009 Collecta, Inc. 
 **
 **  This software is provided AS-IS with no warranty, either express or
 **  implied.
@@ -208,9 +208,11 @@ static int _handle_features(xmpp_conn_t * const conn,
     xmpp_timed_handler_delete(conn, _handle_missing_features);
 
     /* check for TLS */
-    child = xmpp_stanza_get_child_by_name(stanza, "starttls");
-    if (child && (strcmp(xmpp_stanza_get_ns(child), XMPP_NS_TLS) == 0))
-	conn->tls_support = 1;
+    if (!conn->secured) {
+        child = xmpp_stanza_get_child_by_name(stanza, "starttls");
+        if (child && (strcmp(xmpp_stanza_get_ns(child), XMPP_NS_TLS) == 0))
+            conn->tls_support = 1;
+    }
 
     /* check for SASL */
     child = xmpp_stanza_get_child_by_name(stanza, "mechanisms");
@@ -234,13 +236,13 @@ static int _handle_features(xmpp_conn_t * const conn,
     if (conn->pass == NULL || conn->pass[0] == '\0') {
         xmpp_debug(conn->ctx, "auth", "do not attempt auth as there is no password given");
         //If no password, do not login, this will give 'register' a chance to run 
-      	conn->authenticated = 1;
-	      /* call connection handler */
-	      conn->conn_handler(conn, XMPP_CONN_CONNECT, 0, NULL, conn->userdata);
+       conn->authenticated = 1;
+             /* call connection handler */
+             conn->conn_handler(conn, XMPP_CONN_CONNECT, 0, NULL, conn->userdata);
     } else {
         _auth(conn);
     }
-
+ 
     return 0;
 }
 
@@ -265,7 +267,7 @@ static int _handle_proceedtls_default(xmpp_conn_t * const conn,
 {
     char *name;
     name = xmpp_stanza_get_name(stanza);
-    xmpp_debug(conn->ctx, "xmpp",
+    xmpp_debug(conn->ctx, "xmpp", 
 	"handle proceedtls called for %s", name);
 
     if (strcmp(name, "proceed") == 0) {
@@ -285,7 +287,8 @@ static int _handle_proceedtls_default(xmpp_conn_t * const conn,
 	}
 	else
 	{
-	    parser_prepare_reset(conn, _handle_open_tls);
+            conn->secured = 1;
+            conn_prepare_reset(conn, auth_handle_open);
 
 	    conn_open_stream(conn);
 	}
@@ -315,7 +318,7 @@ static int _handle_sasl_result(xmpp_conn_t * const conn,
 		   (char *)userdata);
 
 	/* reset parser */
-	parser_prepare_reset(conn, _handle_open_sasl);
+	conn_prepare_reset(conn, _handle_open_sasl);
 
 	/* send stream tag */
 	conn_open_stream(conn);
@@ -700,16 +703,6 @@ void auth_handle_open(xmpp_conn_t * const conn)
 		      FEATURES_TIMEOUT, NULL);
 }
 
-/* called when stream:stream tag received after TLS connection */
-static void _handle_open_tls(xmpp_conn_t * const conn)
-{
-    xmpp_debug(conn->ctx, "xmpp", "TLS successful, proceeding with SASL");
-
-    /* go straight to SASL auth */
-    _auth(conn);
-}
-
-
 /* called when stream:stream tag received after SASL auth */
 static void _handle_open_sasl(xmpp_conn_t * const conn)
 {
@@ -848,9 +841,17 @@ static int _handle_bind(xmpp_conn_t * const conn,
 	xmpp_error(conn->ctx, "xmpp", "Binding failed.");
 	xmpp_disconnect(conn);
     } else if (type && strcmp(type, "result") == 0) {
-	/* TODO: extract resource if present */
+        xmpp_stanza_t *binding = xmpp_stanza_get_child_by_name(stanza, "bind");
 	xmpp_debug(conn->ctx, "xmpp", "Bind successful.");
 
+        if (binding) {
+            xmpp_stanza_t *jid_stanza = xmpp_stanza_get_child_by_name(binding,
+                                                                      "jid");
+            if (jid_stanza) {
+                conn->bound_jid = xmpp_stanza_get_text(jid_stanza);
+            }
+        }
+
 	/* establish a session if required */
 	if (conn->session_required) {
 	    /* setup response handlers */

data/ext/common.h

@@ -1,7 +1,7 @@
 /* common.h
 ** strophe XMPP client library -- internal common structures
 **
-** Copyright (C) 2005-2008 OGG, LLC. All rights reserved.
+** Copyright (C) 2005-2009 Collecta, Inc. 
 **
 **  This software is provided AS-IS with no warranty, either express or
 **  implied.
@@ -31,8 +31,7 @@
 #include "tls.h"
 #include "hash.h"
 #include "util.h"
-
-#include "expat.h"
+#include "parser.h"
 
 /** run-time context **/
 
@@ -163,10 +162,11 @@ struct _xmpp_conn_t {
     sock_t sock;
     tls_t *tls;
 
-    int tls_support; 
+    int tls_support;
     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 secured; /* set when stream is secured with TLS */
 
     /* if server returns <bind/> or <session/> we must do them */
     int bind_required;
@@ -178,6 +178,7 @@ struct _xmpp_conn_t {
     char *connectport;
     char *jid;
     char *pass;
+    char *bound_jid;
     char *stream_id;
 
     /* send queue and parameters */
@@ -189,9 +190,7 @@ struct _xmpp_conn_t {
 
     /* xml parser */
     int reset_parser;
-    XML_Parser parser;
-    int depth;
-    xmpp_stanza_t *stanza;
+    parser_t *parser;
 
     /* timeouts */
     unsigned int connect_timeout;
@@ -217,6 +216,8 @@ struct _xmpp_conn_t {
 void conn_disconnect(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_prepare_reset(xmpp_conn_t * const conn, xmpp_open_handler handler);
+void conn_parser_reset(xmpp_conn_t * const conn);
 
 
 typedef enum {
@@ -241,19 +242,6 @@ struct _xmpp_stanza_t {
     hash_t *attributes;
 };
 
-int xmpp_stanza_set_attributes(xmpp_stanza_t * const  stanza,
-			       const char * const * const attr);
-
-/* parser functions */
-void parser_handle_start(void *userdata,
-			 const XML_Char *name,
-			 const XML_Char **attr);
-void parser_handle_character(void *userdata, const XML_Char *s, int len);
-void parser_handle_end(void *userdata, const XML_Char *name);
-void parser_prepare_reset(xmpp_conn_t * const conn, 
-			  xmpp_open_handler handler);
-int parser_reset(xmpp_conn_t * const conn);
-
 /* handler management */
 void handler_fire_stanza(xmpp_conn_t * const conn,
 			 xmpp_stanza_t * const stanza);

data/ext/conn.c

@@ -1,7 +1,7 @@
 /* conn.c
 ** strophe XMPP client library -- connection object functions
 **
-** Copyright (C) 2005-2008 OGG, LLC. All rights reserved.
+** Copyright (C) 2005-2009 Collecta, Inc. 
 **
 **  This software is provided AS-IS with no warranty, either express
 **  or implied.
@@ -23,9 +23,11 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include "strophe.h"
+#include <strophe.h>
+
 #include "common.h"
 #include "util.h"
+#include "parser.h"
 
 #ifndef DEFAULT_SEND_QUEUE_MAX
 /** @def DEFAULT_SEND_QUEUE_MAX
@@ -51,6 +53,13 @@
 static int _disconnect_cleanup(xmpp_conn_t * const conn, 
 			       void * const userdata);
 
+static void _handle_stream_start(char *name, char **attrs, 
+                                 void * const userdata);
+static void _handle_stream_end(char *name,
+                               void * const userdata);
+static void _handle_stream_stanza(xmpp_stanza_t *stanza,
+                                  void * const userdata);
+
 /** Create a new Strophe connection object.
  *
  *  @param ctx a Strophe context object
@@ -96,17 +105,23 @@ xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t * const ctx)
 	conn->jid = NULL;
 	conn->pass = NULL;
 	conn->stream_id = NULL;
+        conn->bound_jid = NULL;
 
 	conn->tls_support = 0;
 	conn->tls_failed = 0;
 	conn->sasl_support = 0;
+        conn->secured = 0;
 
 	conn->bind_required = 0;
 	conn->session_required = 0;
 
-	conn->parser = NULL;
-	conn->stanza = NULL;
-	parser_prepare_reset(conn, auth_handle_open);
+	conn->parser = parser_new(conn->ctx, 
+                                  _handle_stream_start,
+                                  _handle_stream_end,
+                                  _handle_stream_stanza,
+                                  conn);
+        conn->reset_parser = 0;
+        conn_prepare_reset(conn, auth_handle_open);
 
 	conn->authenticated = 0;
 	conn->conn_handler = NULL;
@@ -127,7 +142,7 @@ xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t * const ctx)
 	if (!item) {
 	    xmpp_error(conn->ctx, "xmpp", "failed to allocate memory");
 	    xmpp_free(conn->ctx, conn->lang);
-	    XML_ParserFree(conn->parser);
+            parser_free(conn->parser);
 	    xmpp_free(conn->ctx, conn);
 	    conn = NULL;
 	} else {
@@ -151,7 +166,7 @@ xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t * const ctx)
  *
  *  @ingroup Connections
  */
-xmpp_conn_t * xmpp_conn_clone(xmpp_conn_t * const conn)
+xmpp_conn_t *xmpp_conn_clone(xmpp_conn_t * const conn)
 {
     conn->ref++;
     return conn;
@@ -249,12 +264,14 @@ int xmpp_conn_release(xmpp_conn_t * const conn)
 	    xmpp_free(ctx, conn->stream_error);
 	}
 
-	XML_ParserFree(conn->parser);
+        parser_free(conn->parser);
 	
 	if (conn->domain) xmpp_free(ctx, conn->domain);
 	if (conn->jid) xmpp_free(ctx, conn->jid);
+    if (conn->bound_jid) xmpp_free(ctx, conn->bound_jid);
 	if (conn->pass) xmpp_free(ctx, conn->pass);
 	if (conn->stream_id) xmpp_free(ctx, conn->stream_id);
+	if (conn->lang) xmpp_free(ctx, conn->lang);
 	xmpp_free(ctx, conn);
 	released = 1;
     }
@@ -275,6 +292,24 @@ const char *xmpp_conn_get_jid(const xmpp_conn_t * const conn)
     return conn->jid;
 }
 
+/**
+ * Get the JID discovered during binding time.
+ *
+ * This JID will contain the resource used by the current connection.
+ * This is useful in the case where a resource was not specified for
+ * binding.
+ *
+ * @param conn a Strophe connection object.
+ *
+ * @return a string containing the full JID or NULL if it's not been discovered
+ *
+ * @ingroup Connections
+ */
+const char *xmpp_conn_get_bound_jid(const xmpp_conn_t * const conn)
+{
+    return conn->bound_jid;
+}
+
 /** Set the JID of the user that will be bound to the connection.
  *  If any JID was previously set, it will be discarded.  This should not be 
  *  be used after a connection is created.  The function will make a copy of
@@ -379,25 +414,32 @@ int xmpp_connect_client(xmpp_conn_t * const conn,
 {
     char connectdomain[2048];
     int connectport;
-    char *domain;
+    const char * domain;
 
     conn->type = XMPP_CLIENT;
 
     conn->domain = xmpp_jid_domain(conn->ctx, conn->jid);
     if (!conn->domain) return -1;
 
-    if (!sock_srv_lookup("xmpp-client", "tcp", conn->domain, connectdomain, 2048, &connectport))
-    {
+    if (altdomain) {
+        xmpp_debug(conn->ctx, "xmpp", "Connecting via altdomain.");
+        strcpy(connectdomain, altdomain);
+        connectport = altport ? altport : 5222;
+    } else if (!sock_srv_lookup("xmpp-client", "tcp", conn->domain,
+                                connectdomain, 2048, &connectport)) {
 	    xmpp_debug(conn->ctx, "xmpp", "SRV lookup failed.");
 	    if (!altdomain)
 		    domain = conn->domain;
 	    else
 		    domain = altdomain;
-	    xmpp_debug(conn->ctx, "xmpp", "Using alternate domain %s, port %d", altdomain, altport);
+	    xmpp_debug(conn->ctx, "xmpp", "Using alternate domain %s, port %d",
+                   altdomain, altport);
 	    strcpy(connectdomain, domain);
 	    connectport = altport ? altport : 5222;
     }
     conn->sock = sock_connect(connectdomain, connectport);
+    xmpp_debug(conn->ctx, "xmpp", "sock_connect to %s:%d returned %d",
+               connectdomain, connectport, conn->sock);
     if (conn->sock == -1) return -1;
 
     /* setup handler */
@@ -426,7 +468,7 @@ void conn_disconnect_clean(xmpp_conn_t * const conn)
 {
     /* remove the timed handler */
     xmpp_timed_handler_delete(conn, _disconnect_cleanup);
-    conn->error = -4;
+
     conn_disconnect(conn);
 }
 
@@ -445,13 +487,26 @@ void conn_disconnect(xmpp_conn_t * const conn)
 	tls_free(conn->tls);
 	conn->tls = NULL;
     }
-
     sock_close(conn->sock);
+
     /* fire off connection handler */
-    if (NULL != conn->conn_handler) {
-        conn->conn_handler(conn, XMPP_CONN_DISCONNECT, conn->error,
+    conn->conn_handler(conn, XMPP_CONN_DISCONNECT, conn->error,
 		       conn->stream_error, conn->userdata);
-    }
+}
+
+/* prepares a parser reset.  this is called from handlers. we can't
+ * reset the parser immediately as it is not re-entrant. */
+void conn_prepare_reset(xmpp_conn_t * const conn, xmpp_open_handler handler)
+{
+    conn->reset_parser = 1;
+    conn->open_handler = handler;
+}
+
+/* reset the parser */
+void conn_parser_reset(xmpp_conn_t * const conn)
+{
+    conn->reset_parser = 0;
+    parser_reset(conn->parser);
 }
 
 /* timed handler for cleanup if normal disconnect procedure takes too long */
@@ -460,7 +515,7 @@ static int _disconnect_cleanup(xmpp_conn_t * const conn,
 {
     xmpp_debug(conn->ctx, "xmpp",
 	       "disconnection forced by cleanup timeout");
-    conn->error = -5;
+
     conn_disconnect(conn);
 
     return 0;
@@ -627,3 +682,97 @@ void conn_open_stream(xmpp_conn_t * const conn)
 			 conn->type == XMPP_CLIENT ? XMPP_NS_CLIENT : XMPP_NS_COMPONENT,
 			 XMPP_NS_STREAMS);
 }
+
+static void _log_open_tag(xmpp_conn_t *conn, char **attrs)
+{
+    char buf[4096];
+    size_t len, pos;
+    int i;
+    
+    if (!attrs) return;
+
+    pos = 0;
+    len = xmpp_snprintf(buf, 4096, "<stream:stream");
+    if (len < 0) return;
+    
+    pos += len;
+    
+    for (i = 0; attrs[i]; i += 2) {
+        len = xmpp_snprintf(&buf[pos], 4096 - pos, " %s='%s'",
+                            attrs[i], attrs[i+1]);
+        if (len < 0) return;
+        pos += len;
+    }
+
+    len = xmpp_snprintf(&buf[pos], 4096 - pos, ">");
+    if (len < 0) return;
+
+    xmpp_debug(conn->ctx, "xmpp", "RECV: %s", buf);
+}
+
+static char *_get_stream_attribute(char **attrs, char *name)
+{
+    int i;
+
+    if (!attrs) return NULL;
+
+    for (i = 0; attrs[i]; i += 2)
+        if (strcmp(name, attrs[i]) == 0)
+            return attrs[i+1];
+
+    return NULL;
+}
+
+static void _handle_stream_start(char *name, char **attrs, 
+                                 void * const userdata)
+{
+    xmpp_conn_t *conn = (xmpp_conn_t *)userdata;
+    char *id;
+
+    if (strcmp(name, "stream:stream") != 0) {
+        printf("name = %s\n", name);
+        xmpp_error(conn->ctx, "conn", "Server did not open valid stream.");
+        conn_disconnect(conn);
+    } else {
+        _log_open_tag(conn, attrs);
+        
+        if (conn->stream_id) xmpp_free(conn->ctx, conn->stream_id);
+
+        id = _get_stream_attribute(attrs, "id");
+        if (id)
+            conn->stream_id = xmpp_strdup(conn->ctx, id);
+
+        if (!conn->stream_id) {
+            xmpp_error(conn->ctx, "conn", "Memory allocation failed.");
+            conn_disconnect(conn);
+        }
+    }
+    
+    /* call stream open handler */
+    conn->open_handler(conn);
+}
+
+static void _handle_stream_end(char *name,
+                               void * const userdata)
+{
+    xmpp_conn_t *conn = (xmpp_conn_t *)userdata;
+
+    /* stream is over */
+    xmpp_debug(conn->ctx, "xmpp", "RECV: </stream:stream>");
+    conn_disconnect_clean(conn);
+}
+
+static void _handle_stream_stanza(xmpp_stanza_t *stanza,
+                                  void * const userdata)
+{
+    xmpp_conn_t *conn = (xmpp_conn_t *)userdata;
+    char *buf;
+    size_t len;
+
+    if (xmpp_stanza_to_text(stanza, &buf, &len) == 0) {
+        xmpp_debug(conn->ctx, "xmpp", "RECV: %s", buf);
+        xmpp_free(conn->ctx, buf);
+    }
+
+    handler_fire_stanza(conn, stanza);
+}

data/ext/ctx.c

@@ -1,7 +1,7 @@
 /* ctx.c
 ** strophe XMPP client library -- run-time context implementation
 **
-** Copyright (C) 2005-2008 OGG, LLC. All rights reserved.
+** Copyright (C) 2005-2009 Collecta, Inc. 
 **
 **  This software is provided AS-IS with no warranty, either express 
 **  or implied.
@@ -58,7 +58,7 @@
  *
  *  @ingroup Init
  */
-void xmpp_initialize(void)
+ void xmpp_initialize(void)
 {
     sock_initialize();
     tls_initialize();
@@ -248,12 +248,12 @@ void xmpp_log(const xmpp_ctx_t * const ctx,
 	      va_list ap)
 {
     int oldret, ret;
-    char smbuf[4096] = {0};
+    char smbuf[1024];
     char *buf;
 
     buf = smbuf;
-    ret = xmpp_vsnprintf(buf, 4096 - 1, fmt, ap);
-    if (ret > 4096 - 1) {
+    ret = xmpp_vsnprintf(buf, 1023, fmt, ap);
+    if (ret > 1023) {
 	buf = (char *)xmpp_alloc(ctx, ret + 1);
 	if (!buf) {
 	    buf = NULL;