diff --git a/src/handler.c b/src/handler.c
index ae4d386..5c4c2cf 100644
--- a/src/handler.c
+++ b/src/handler.c
@@ -1,7 +1,7 @@
 /* handler.c
 ** strophe XMPP client library -- event handler management
 **
-** Copyright (C) 2005-2009 Collecta, Inc. 
+** Copyright (C) 2005-2009 Collecta, Inc.
 **
 **  This software is provided AS-IS with no warranty, either express
 **  or implied.
@@ -32,92 +32,92 @@
  *  @param stanza a Strophe stanza object
  */
 void handler_fire_stanza(xmpp_conn_t * const conn,
-			 xmpp_stanza_t * const stanza)
+                         xmpp_stanza_t * const stanza)
 {
     xmpp_handlist_t *item, *prev;
     const char *id, *ns, *name, *type;
-    
+
     /* call id handlers */
     id = xmpp_stanza_get_id(stanza);
     if (id) {
-	prev = NULL;
- 	item = (xmpp_handlist_t *)hash_get(conn->id_handlers, id);
-	while (item) {
-	    xmpp_handlist_t *next = item->next;
+        prev = NULL;
+         item = (xmpp_handlist_t *)hash_get(conn->id_handlers, id);
+        while (item) {
+            xmpp_handlist_t *next = item->next;
 
-	    if (item->user_handler && !conn->authenticated) {
-		item = next;
- 		continue;
-	    }
+            if (item->user_handler && !conn->authenticated) {
+                item = next;
+                 continue;
+            }
 
-	    if (!((xmpp_handler)(item->handler))(conn, stanza, item->userdata)) {
-		/* handler is one-shot, so delete it */
-		if (prev)
-		    prev->next = next;
-		else {
-		    hash_drop(conn->id_handlers, id);
-		    hash_add(conn->id_handlers, id, next);
-		}
+            if (!((xmpp_handler)(item->handler))(conn, stanza, item->userdata)) {
+                /* handler is one-shot, so delete it */
+                if (prev)
+                    prev->next = next;
+                else {
+                    hash_drop(conn->id_handlers, id);
+                    hash_add(conn->id_handlers, id, next);
+                }
                 xmpp_free(conn->ctx, item->id);
-		xmpp_free(conn->ctx, item);
-		item = NULL;
-	    }
-	    if (item)
-		prev = item;
-	    item = next;
-	}
+                xmpp_free(conn->ctx, item);
+                item = NULL;
+            }
+            if (item)
+                prev = item;
+            item = next;
+        }
     }
-    
+
     /* call handlers */
     ns = xmpp_stanza_get_ns(stanza);
     name = xmpp_stanza_get_name(stanza);
     type = xmpp_stanza_get_type(stanza);
-    
+
     /* enable all added handlers */
     for (item = conn->handlers; item; item = item->next)
-	item->enabled = 1;
+        item->enabled = 1;
 
     prev = NULL;
     item = conn->handlers;
     while (item) {
-	/* skip newly added handlers */
-	if (!item->enabled) {
-	    prev = item;
-	    item = item->next;
-	    continue;
-	}
+        /* skip newly added handlers */
+        if (!item->enabled) {
+            prev = item;
+            item = item->next;
+            continue;
+        }
 
-	/* don't call user handlers until authentication succeeds */
-	if (item->user_handler && !conn->authenticated) {
-	    prev = item;
-	    item = item->next;
-	    continue;
-	}
+        /* don't call user handlers until authentication succeeds */
+        if (item->user_handler && !conn->authenticated) {
+            prev = item;
+            item = item->next;
+            continue;
+        }
 
-	if ((!item->ns || (ns && strcmp(ns, item->ns) == 0) ||
-	     xmpp_stanza_get_child_by_ns(stanza, item->ns)) &&
-	    (!item->name || (name && strcmp(name, item->name) == 0)) &&
-	    (!item->type || (type && strcmp(type, item->type) == 0)))
-	    if (!((xmpp_handler)(item->handler))(conn, stanza, item->userdata)) {
-		/* handler is one-shot, so delete it */
-		if (prev)
-		    prev->next = item->next;
-		else
-		    conn->handlers = item->next;
+        if ((!item->ns || (ns && strcmp(ns, item->ns) == 0) ||
+             xmpp_stanza_get_child_by_ns(stanza, item->ns)) &&
+            (!item->name || (name && strcmp(name, item->name) == 0)) &&
+            (!item->type || (type && strcmp(type, item->type) == 0)))
+            if (!((xmpp_handler)(item->handler))(conn, stanza, item->userdata)) {
+                /* handler is one-shot, so delete it */
+                if (prev)
+                    prev->next = item->next;
+                else
+                    conn->handlers = item->next;
                 if (item->ns) xmpp_free(conn->ctx, item->ns);
                 if (item->name) xmpp_free(conn->ctx, item->name);
                 if (item->type) xmpp_free(conn->ctx, item->type);
-		xmpp_free(conn->ctx, item);
-		item = NULL;
-	    }
-	
-	if (item) {
-	    prev = item;
-	    item = item->next;
-	} else if (prev)
-	    item = prev->next;
-	else
-	    item = conn->handlers;
+                xmpp_free(conn->ctx, item);
+                item = NULL;
+            }
+
+        if (item) {
+            prev = item;
+            item = item->next;
+        } else if (prev)
+            item = prev->next;
+        else
+            item = conn->handlers;
     }
 }
 
@@ -139,49 +139,49 @@ uint64_t handler_fire_timed(xmpp_ctx_t * const ctx)
 
     connitem = ctx->connlist;
     while (connitem) {
-	if (connitem->conn->state != XMPP_STATE_CONNECTED) {
-	    connitem = connitem->next;
-	    continue;
-	}
-	
-	/* enable all handlers that were added */
-	for (handitem = connitem->conn->timed_handlers; handitem;
-	     handitem = handitem->next)
-	    handitem->enabled = 1;
+        if (connitem->conn->state != XMPP_STATE_CONNECTED) {
+            connitem = connitem->next;
+            continue;
+        }
 
-	handitem = connitem->conn->timed_handlers;
-	while (handitem) {
-	    /* skip newly added handlers */
-	    if (!handitem->enabled) {
-		handitem = handitem->next;
-		continue;
-	    }
+        /* enable all handlers that were added */
+        for (handitem = connitem->conn->timed_handlers; handitem;
+             handitem = handitem->next)
+            handitem->enabled = 1;
 
-	    /* only fire user handlers after authentication */
-	    if (handitem->user_handler && !connitem->conn->authenticated) {
-		handitem = handitem->next;
-		continue;
-	    }
+        handitem = connitem->conn->timed_handlers;
+        while (handitem) {
+            /* skip newly added handlers */
+            if (!handitem->enabled) {
+                handitem = handitem->next;
+                continue;
+            }
 
-	    fired = 0;
-	    elapsed = time_elapsed(handitem->last_stamp, time_stamp());
-	    if (elapsed >= handitem->period) {
-		/* fire! */
-		fired = 1;
-		handitem->last_stamp = time_stamp();
-		ret = ((xmpp_timed_handler)handitem->handler)(connitem->conn, handitem->userdata);
-	    } else if (min > (handitem->period - elapsed))
-		min = handitem->period - elapsed;
-		
-	    temp = handitem;
-	    handitem = handitem->next;
+            /* only fire user handlers after authentication */
+            if (handitem->user_handler && !connitem->conn->authenticated) {
+                handitem = handitem->next;
+                continue;
+            }
 
-	    /* delete handler if it returned false */
-	    if (fired && !ret)
-		xmpp_timed_handler_delete(connitem->conn, temp->handler);
-	}
+            fired = 0;
+            elapsed = time_elapsed(handitem->last_stamp, time_stamp());
+            if (elapsed >= handitem->period) {
+                /* fire! */
+                fired = 1;
+                handitem->last_stamp = time_stamp();
+                ret = ((xmpp_timed_handler)handitem->handler)(connitem->conn, handitem->userdata);
+            } else if (min > (handitem->period - elapsed))
+                min = handitem->period - elapsed;
 
-	connitem = connitem->next;
+            temp = handitem;
+            handitem = handitem->next;
+
+            /* delete handler if it returned false */
+            if (fired && !ret)
+                xmpp_timed_handler_delete(connitem->conn, temp->handler);
+        }
+
+        connitem = connitem->next;
     }
 
     return min;
@@ -199,25 +199,25 @@ void handler_reset_timed(xmpp_conn_t *conn, int user_only)
 
     handitem = conn->timed_handlers;
     while (handitem) {
-	if ((user_only && handitem->user_handler) || !user_only)
-	    handitem->last_stamp = time_stamp();
-	
-	handitem = handitem->next;
+        if ((user_only && handitem->user_handler) || !user_only)
+            handitem->last_stamp = time_stamp();
+
+        handitem = handitem->next;
     }
 }
 
 static void _timed_handler_add(xmpp_conn_t * const conn,
-			       xmpp_timed_handler handler,
-			       const unsigned long period,
-			       void * const userdata, 
-			       const int user_handler)
+                               xmpp_timed_handler handler,
+                               const unsigned long period,
+                               void * const userdata,
+                               const int user_handler)
 {
     xmpp_handlist_t *item, *tail;
 
     /* check if handler is already in the list */
     for (item = conn->timed_handlers; item; item = item->next) {
-	if (item->handler == (void *)handler)
-	    break;
+        if (item->handler == (void *)handler)
+            break;
     }
     if (item) return;
 
@@ -236,12 +236,12 @@ static void _timed_handler_add(xmpp_conn_t * const conn,
 
     /* append item to list */
     if (!conn->timed_handlers)
-	conn->timed_handlers = item;
+        conn->timed_handlers = item;
     else {
-	tail = conn->timed_handlers;
-	while (tail->next) 
-	    tail = tail->next;
-	tail->next = item;
+        tail = conn->timed_handlers;
+        while (tail->next)
+            tail = tail->next;
+        tail->next = item;
     }
 }
 
@@ -253,7 +253,7 @@ static void _timed_handler_add(xmpp_conn_t * const conn,
  *  @ingroup Handlers
  */
 void xmpp_timed_handler_delete(xmpp_conn_t * const conn,
-			       xmpp_timed_handler handler)
+                               xmpp_timed_handler handler)
 {
     xmpp_handlist_t *item, *prev;
 
@@ -262,35 +262,35 @@ void xmpp_timed_handler_delete(xmpp_conn_t * const conn,
     prev = NULL;
     item = conn->timed_handlers;
     while (item) {
-	if (item->handler == (void *)handler)
-	    break;
-	prev = item;
-	item = item->next;
+        if (item->handler == (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);
+        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,
-			 xmpp_handler handler,
-			 const char * const id,
-			 void * const userdata, int user_handler)
+                         xmpp_handler handler,
+                         const char * const id,
+                         void * const userdata, int user_handler)
 {
     xmpp_handlist_t *item, *tail;
 
     /* check if handler is already in the list */
     item = (xmpp_handlist_t *)hash_get(conn->id_handlers, id);
     while (item) {
-	if (item->handler == (void *)handler)
-	    break;
-	item = item->next;
+        if (item->handler == (void *)handler)
+            break;
+        item = item->next;
     }
     if (item) return;
 
@@ -306,18 +306,18 @@ static void _id_handler_add(xmpp_conn_t * const conn,
 
     item->id = xmpp_strdup(conn->ctx, id);
     if (!item->id) {
-	xmpp_free(conn->ctx, item);
-	return;
+        xmpp_free(conn->ctx, item);
+        return;
     }
 
     /* put on list in hash table */
     tail = (xmpp_handlist_t *)hash_get(conn->id_handlers, id);
     if (!tail)
-	hash_add(conn->id_handlers, id, item);
+        hash_add(conn->id_handlers, id, item);
     else {
-	while (tail->next) 
-	    tail = tail->next;
-	tail->next = item;
+        while (tail->next)
+            tail = tail->next;
+        tail->next = item;
     }
 }
 
@@ -330,8 +330,8 @@ static void _id_handler_add(xmpp_conn_t * const conn,
  *  @ingroup Handlers
  */
 void xmpp_id_handler_delete(xmpp_conn_t * const conn,
-			    xmpp_handler handler,
-			    const char * const id)
+                            xmpp_handler handler,
+                            const char * const id)
 {
     xmpp_handlist_t *item, *prev;
 
@@ -340,39 +340,39 @@ void xmpp_id_handler_delete(xmpp_conn_t * const conn,
     if (!item) return;
 
     while (item) {
-	if (item->handler == (void *)handler)
-	    break;
+        if (item->handler == (void *)handler)
+            break;
 
-	prev = item;
-	item = item->next;
+        prev = item;
+        item = item->next;
     }
 
     if (item) {
-	if (prev)
-	    prev->next = item->next;
-	else {
-	    hash_drop(conn->id_handlers, id);
-	    hash_add(conn->id_handlers, id, item->next);
-	}
-	xmpp_free(conn->ctx, item->id);
-	xmpp_free(conn->ctx, item);
+        if (prev)
+            prev->next = item->next;
+        else {
+            hash_drop(conn->id_handlers, id);
+            hash_add(conn->id_handlers, id, item->next);
+        }
+        xmpp_free(conn->ctx, item->id);
+        xmpp_free(conn->ctx, item);
     }
 }
 
 /* add a stanza handler */
 static void _handler_add(xmpp_conn_t * const conn,
-			 xmpp_handler handler,
-			 const char * const ns,
-			 const char * const name,
-			 const char * const type,
-			 void * const userdata, int user_handler)
+                         xmpp_handler handler,
+                         const char * const ns,
+                         const char * const name,
+                         const char * const type,
+                         void * const userdata, int user_handler)
 {
     xmpp_handlist_t *item, *tail;
 
     /* check if handler already in list */
     for (item = conn->handlers; item; item = item->next) {
-	if (item->handler == (void *)handler)
-	    break;
+        if (item->handler == (void *)handler)
+            break;
     }
     if (item) return;
 
@@ -385,42 +385,42 @@ static void _handler_add(xmpp_conn_t * const conn,
     item->userdata = userdata;
     item->enabled = 0;
     item->next = NULL;
-    
+
     if (ns) {
-	item->ns = xmpp_strdup(conn->ctx, ns);
-	if (!item->ns) {
-	    xmpp_free(conn->ctx, item);
-	    return;
-	}
+        item->ns = xmpp_strdup(conn->ctx, ns);
+        if (!item->ns) {
+            xmpp_free(conn->ctx, item);
+            return;
+        }
     } else
-	item->ns = NULL;
+        item->ns = NULL;
     if (name) {
-	item->name = xmpp_strdup(conn->ctx, name);
-	if (!item->name) {
-	    if (item->ns) xmpp_free(conn->ctx, item->ns);
-	    xmpp_free(conn->ctx, item);
-	    return;
-	}
+        item->name = xmpp_strdup(conn->ctx, name);
+        if (!item->name) {
+            if (item->ns) xmpp_free(conn->ctx, item->ns);
+            xmpp_free(conn->ctx, item);
+            return;
+        }
     } else
-	item->name = NULL;
+        item->name = NULL;
     if (type) {
-	item->type = xmpp_strdup(conn->ctx, type);
-	if (!item->type) {
-	    if (item->ns) xmpp_free(conn->ctx, item->ns);
-	    if (item->name) xmpp_free(conn->ctx, item->name);
-	    xmpp_free(conn->ctx, item);
-	}
+        item->type = xmpp_strdup(conn->ctx, type);
+        if (!item->type) {
+            if (item->ns) xmpp_free(conn->ctx, item->ns);
+            if (item->name) xmpp_free(conn->ctx, item->name);
+            xmpp_free(conn->ctx, item);
+        }
     } else
-	item->type = NULL;
+        item->type = NULL;
 
     /* append to list */
     if (!conn->handlers)
-	conn->handlers = item;
+        conn->handlers = item;
     else {
-	tail = conn->handlers;
-	while (tail->next) 
-	    tail = tail->next;
-	tail->next = item;
+        tail = conn->handlers;
+        while (tail->next)
+            tail = tail->next;
+        tail->next = item;
     }
 }
 
@@ -432,7 +432,7 @@ static void _handler_add(xmpp_conn_t * const conn,
  *  @ingroup Handlers
  */
 void xmpp_handler_delete(xmpp_conn_t * const conn,
-			 xmpp_handler handler)
+                         xmpp_handler handler)
 {
     xmpp_handlist_t *prev, *item;
 
@@ -441,23 +441,23 @@ void xmpp_handler_delete(xmpp_conn_t * const conn,
     prev = NULL;
     item = conn->handlers;
     while (item) {
-	if (item->handler == (void *)handler)
-	    break;
-	
-	prev = item;
-	item = item->next;
+        if (item->handler == (void *)handler)
+            break;
+
+        prev = item;
+        item = item->next;
     }
 
     if (item) {
-	if (prev)
-	    prev->next = item->next;
-	else
-	    conn->handlers = item->next;
+        if (prev)
+            prev->next = item->next;
+        else
+            conn->handlers = item->next;
 
-	if (item->ns) xmpp_free(conn->ctx, item->ns);
-	if (item->name) xmpp_free(conn->ctx, item->name);
-	if (item->type) xmpp_free(conn->ctx, item->type);
-	xmpp_free(conn->ctx, item);
+        if (item->ns) xmpp_free(conn->ctx, item->ns);
+        if (item->name) xmpp_free(conn->ctx, item->name);
+        if (item->type) xmpp_free(conn->ctx, item->type);
+        xmpp_free(conn->ctx, item);
     }
 }
 
@@ -466,7 +466,7 @@ void xmpp_handler_delete(xmpp_conn_t * const conn,
  *  and continue firing regularly after that.  Strophe will try its best
  *  to fire handlers as close to the period times as it can, but accuracy
  *  will vary depending on the resolution of the event loop.
- *   
+ *
  *  If the handler function returns true, it will be kept, and if it
  *  returns false, it will be deleted from the list of handlers.
  *
@@ -478,9 +478,9 @@ void xmpp_handler_delete(xmpp_conn_t * const conn,
  *  @ingroup Handlers
  */
 void xmpp_timed_handler_add(xmpp_conn_t * const conn,
-			    xmpp_timed_handler handler,
-			    const unsigned long period,
-			    void * const userdata)
+                            xmpp_timed_handler handler,
+                            const unsigned long period,
+                            void * const userdata)
 {
     _timed_handler_add(conn, handler, period, userdata, 1);
 }
@@ -495,9 +495,9 @@ void xmpp_timed_handler_add(xmpp_conn_t * const conn,
  *  @param userdata an opaque data pointer that will be passed to the handler
  */
 void handler_add_timed(xmpp_conn_t * const conn,
-		       xmpp_timed_handler handler,
-		       const unsigned long period,
-		       void * const userdata)
+                       xmpp_timed_handler handler,
+                       const unsigned long period,
+                       void * const userdata)
 {
     _timed_handler_add(conn, handler, period, userdata, 0);
 }
@@ -519,9 +519,9 @@ void handler_add_timed(xmpp_conn_t * const conn,
  *  @ingroup Handlers
  */
 void xmpp_id_handler_add(xmpp_conn_t * const conn,
-			 xmpp_handler handler,
-			 const char * const id,
-			 void * const userdata)
+                         xmpp_handler handler,
+                         const char * const id,
+                         void * const userdata)
 {
     _id_handler_add(conn, handler, id, userdata, 1);
 }
@@ -536,9 +536,9 @@ void xmpp_id_handler_add(xmpp_conn_t * const conn,
  *  @param userdata an opaque data pointer that will be passed to the handler
  */
 void handler_add_id(xmpp_conn_t * const conn,
-		    xmpp_handler handler,
-		    const char * const id,
-		    void * const userdata)
+                    xmpp_handler handler,
+                    const char * const id,
+                    void * const userdata)
 {
     _id_handler_add(conn, handler, id, userdata, 0);
 }
@@ -566,11 +566,11 @@ void handler_add_id(xmpp_conn_t * const conn,
  *  @ingroup Handlers
  */
 void xmpp_handler_add(xmpp_conn_t * const conn,
-		      xmpp_handler handler,
-		      const char * const ns,
-		      const char * const name,
-		      const char * const type,
-		      void * const userdata)
+                      xmpp_handler handler,
+                      const char * const ns,
+                      const char * const name,
+                      const char * const type,
+                      void * const userdata)
 {
     _handler_add(conn, handler, ns, name, type, userdata, 1);
 }
@@ -587,11 +587,11 @@ void xmpp_handler_add(xmpp_conn_t * const conn,
  *  @param userdata an opaque data pointer that will be passed to the handler
  */
 void handler_add(xmpp_conn_t * const conn,
-		 xmpp_handler handler,
-		 const char * const ns,
-		 const char * const name,
-		 const char * const type,
-		 void * const userdata)
+                 xmpp_handler handler,
+                 const char * const ns,
+                 const char * const name,
+                 const char * const type,
+                 void * const userdata)
 {
     _handler_add(conn, handler, ns, name, type, userdata, 0);
 }