XMPP

void send_iq(xmpp_conn_t *const conn)
{

    xmpp_stanza_t *iq, *pubsub, *publish, *item, *status, *object;

    iq = xmpp_stanza_new(ctx);

    xmpp_stanza_set_name(iq, "iq");

    xmpp_stanza_set_attribute(iq, "from", "google.com");

    xmpp_stanza_set_type(iq, "set");

    xmpp_stanza_set_id(iq, "1");

    pubsub = xmpp_stanza_new(ctx);

    xmpp_stanza_set_name(pubsub, "pubsub");

    xmpp_stanza_set_ns(pubsub, "http://jabber.org/protocol/pubsub");

    xmpp_stanza_add_child(iq, pubsub);

    item= xmpp_stanza_new(ctx);

    xmpp_stanza_set_name(item, "item");

    xmpp_stanza_add_child( publish, item );

    status = xmpp_stanza_new(ctx);

    xmpp_stanza_set_name(status, "status");

    xmpp_stanza_set_ns(status, "http://xmppgoogle.org/google/commands/objects/status");

    xmpp_stanza_set_attribute(status, "object_type", "dev");
    xmpp_stanza_set_attribute(status, "event", "added");
    xmpp_stanza_set_attribute(status, "from", "google.com");
    xmpp_stanza_add_child(item, status);

    object= xmpp_stanza_new(ctx);

    xmpp_stanza_set_name(object, "object");

    xmpp_stanza_set_attribute(object, "object_type", "dev");

    xmpp_stanza_set_attribute(object, "object_id", "devid");
    xmpp_stanza_set_attribute(object, "owner_id", "owner_id");

    xmpp_stanza_add_child(status, object);

    xmpp_stanza_release(object);

    xmpp_stanza_release(status);
    xmpp_stanza_release(item);

    xmpp_stanza_release(publish);
    xmpp_stanza_release(pubsub);

    xmpp_stanza_send(conn, iq);

    xmpp_stanza_release(iq);

}

int (*connect_xmpp)(char* strServXmpp, char* strUserName, char* strPassWord);

int (*set_status)(const char* status);

int (*send_chat_message)(char* friend_id, char* body);

int (*get_friends_list)();

int (*send_on_delete_friends)(const char* gDelFriend_id);

int (*send_heartbeat)();

int (*add_friends)(const char* new_friends);

int (*declare_online)();

int (*stop_xmpp)();

/*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) {

	if (status == XMPP_CONN_CONNECT) {

		LOGD("DEBUG:connected\n");

		xmpp_handler_add(conn, on_receive_message_handler, NULL, "message", NULL, NULL);

		xmpp_handler_add(conn, on_receive_iq_handler, NULL, "iq", NULL, NULL);

		xmpp_handler_add(conn, on_receive_presence_handler, NULL, "presence", NULL, NULL);

		xmpp_declare_online(conn);

		xmpp_get_vCard();

		get_friends_list();

	}
	else {
		LOGD("DEBUG:disconnect\n");

        if (error != 0)
	        LOGD("error:%d\n", error);
	    if (stream_error != NULL)
	        LOGD("stream_error:%s\n", stream_error->text);
    
		xmpp_handler_delete(conn, on_receive_message_handler);
		xmpp_handler_delete(conn, on_receive_iq_handler);
		xmpp_handler_delete(conn, on_receive_presence_handler);

		xmpp_ctx_t *ctx = xmpp_conn_get_context(conn);
		xmpp_stop(ctx);

		if (error == ENETUNREACH){
			start_xmpp = 0;
			LOGD("网络断开!\n");

			if (sendBroadcast != NULL)
				sendBroadcast(ON_NETWORK_DISCONNECT_ID, "");
		}

		if (error == ENXIO){
			start_xmpp = 0;
			LOGD("用户或密码不正确!\n");

			if (sendBroadcast != NULL)
				sendBroadcast(ON_AUTH_ERROR_ID, "");
		}

		//110
		if (error == ESHUTDOWN){
			start_xmpp = 0;
			LOGD("Can't send after socket shutdown!\n");

			if (sendBroadcast != NULL)
				sendBroadcast(ON_NETWORK_DISCONNECT_ID, "");
		}

		if (error == ETIMEDOUT){
			start_xmpp = 0;
			LOGD("Can't send after socket shutdown!\n");

			if (sendBroadcast != NULL)
				sendBroadcast(ON_NETWORK_DISCONNECT_ID, "");
		}
	}
}

void* server_thread(void* param){

	while (start_xmpp) {
		xmpp_ctx_t *ctx;
		xmpp_conn_t *conn;
		xmpp_log_t *log;

		/*initalize library*/
		xmpp_initialize();

		/*create a context*/
		log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG);
		ctx = xmpp_ctx_new(NULL, log);

		/* create a connection*/
		conn = xmpp_conn_new(ctx);

		LOGD("gUserName:%s", user_jid);
		LOGD("user_password:%s", user_password);
		/* setup authentication information*/
		xmpp_conn_set_jid(conn, user_jid);
		xmpp_conn_set_pass(conn, user_password);

		LOGD("xmpp_connect_client\n");
		/* initialize connection*/
		char *strServerIP;
		if (strlen(server_IP) == 0){
			LOGD("strServXmpp:NULL\n");
			strServerIP = NULL;
		}
		else
			strServerIP = server_IP;
		xmpp_connect_client(conn, strServerIP, server_altport, conn_handler, NULL);

		/* enter the event loop - our connect handler will trigger an exit*/
		xmpp_run(ctx);

		/*release our connection and contex*/
		xmpp_conn_release(conn);
		xmpp_ctx_free(ctx);

		//xmpp_log_free(log);

		/*final shutdown of the libraty*/
		xmpp_shutdown();

		//Connection reset by peer
		if (get_conn_error(conn) == ECONNRESET){
			LOGD("Connection reset by peer\n");
			sleep(8);
		}
		else
			sleep(1);
	}

	return (void*)0;
}

diff --git a/src/auth.c b/src/auth.c
index 2371925..85d0030 100644
--- a/src/auth.c
+++ b/src/auth.c
@@ -658,7 +658,13 @@ static void _auth(xmpp_conn_t * const conn)
 	    xmpp_stanza_release(iq);
 	    xmpp_error(conn->ctx, "auth", 
 		       "Cannot authenticate without resource");
-	    xmpp_disconnect(conn);
+        /* Add register module by xuqiqiang 2014/12/5 */
+        if(!conn->isRegister){
+            conn->error = ENXIO;
+            conn_disconnect(conn);
+        }
+        else
+            xmpp_register_user(conn);
 	    return;
 	}
 	xmpp_stanza_add_child(child, authdata);
@@ -887,8 +893,14 @@ static int _handle_bind(xmpp_conn_t * const conn,
 	    conn->authenticated = 1;
 	   
 	    /* call connection handler */
-	    conn->conn_handler(conn, XMPP_CONN_CONNECT, 0, NULL, 
-			       conn->userdata);
+        /* Add register module by xuqiqiang 2014/12/5 */
+        if(!conn->isRegister)
+            conn->conn_handler(conn, XMPP_CONN_CONNECT, 0, NULL,
+                conn->userdata);
+        else{
+            conn->register_result = XMPP_REGISTER_ALREADY_EXIST;
+            xmpp_disconnect(conn);
+        }
 	}
     } else {
 	xmpp_error(conn->ctx, "xmpp", "Server sent malformed bind reply.");
@@ -926,7 +938,13 @@ static int _handle_session(xmpp_conn_t * const conn,
 	conn->authenticated = 1;
 	
 	/* call connection handler */
-	conn->conn_handler(conn, XMPP_CONN_CONNECT, 0, NULL, conn->userdata);
+        /* Add register module by xuqiqiang 2014/12/5 */
+        if(!conn->isRegister)
+            conn->conn_handler(conn, XMPP_CONN_CONNECT, 0, NULL, conn->userdata);
+        else{
+            conn->register_result = XMPP_REGISTER_ALREADY_EXIST;
+            xmpp_disconnect(conn);
+        }
     } else {
 	xmpp_error(conn->ctx, "xmpp", "Server sent malformed session reply.");
 	xmpp_disconnect(conn);
@@ -968,7 +986,13 @@ static int _handle_legacy(xmpp_conn_t * const conn,
 	xmpp_debug(conn->ctx, "xmpp", "Legacy auth succeeded.");
 
 	conn->authenticated = 1;
-	conn->conn_handler(conn, XMPP_CONN_CONNECT, 0, NULL, conn->userdata);
+        /* Add register module by xuqiqiang 2014/12/5 */
+        if(!conn->isRegister)
+            conn->conn_handler(conn, XMPP_CONN_CONNECT, 0, NULL, conn->userdata);
+        else{
+            conn->register_result = XMPP_REGISTER_ALREADY_EXIST;
+            xmpp_disconnect(conn);
+        }
     } else {
 	xmpp_error(conn->ctx, "xmpp", "Server sent us a legacy authentication "\
 		   "response with a bad type.");
diff --git a/src/common.h b/src/common.h
index 9434e6f..254b7e0 100644
--- a/src/common.h
+++ b/src/common.h
@@ -203,7 +203,11 @@ struct _xmpp_conn_t {
 
     /* user handlers only get called after authentication */
     int authenticated;
-    
+
+    int isRegister;
+
+    int register_result;
+
     /* connection events handler */
     xmpp_conn_handler conn_handler;
     void *userdata;
diff --git a/src/conn.c b/src/conn.c
index 26df418..8de45b4 100644
--- a/src/conn.c
+++ b/src/conn.c
@@ -28,6 +28,7 @@
 #include "common.h"
 #include "util.h"
 #include "parser.h"
+#include <pthread.h>
 
 #ifndef DEFAULT_SEND_QUEUE_MAX
 /** @def DEFAULT_SEND_QUEUE_MAX
@@ -136,6 +137,9 @@ xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t * const ctx)
 	/* give the caller a reference to connection */
 	conn->ref = 1;
 
+    conn->isRegister = 0;
+    conn->register_result = XMPP_REGISTER_NETWORK_CUT_DOWN;
+
 	/* add connection to ctx->connlist */
 	tail = conn->ctx->connlist;
 	while (tail && tail->next) tail = tail->next;
@@ -159,6 +163,148 @@ xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t * const ctx)
     return conn;
 }
 
+/* Add register module by xuqiqiang 2014/12/5 */
+void xmpp_set_register(xmpp_conn_t * const conn){
+    conn->isRegister = 1;
+}
+
+int on_register_user_handler(xmpp_conn_t * const conn,
+    xmpp_stanza_t * const stanza,
+    void * const userdata){
+
+    char *type = xmpp_stanza_get_attribute(stanza, "type");
+
+    if (type != NULL && strcmp(type, "result") == 0){
+        fprintf(stderr, "register successful!\n");
+        conn->register_result = XMPP_REGISTER_SUCCESSFUL;
+    }
+    else{
+        fprintf(stderr, "register not successful!\n");
+        conn->register_result = XMPP_REGISTER_NOT_SUCCESSFUL;
+    }
+
+    xmpp_disconnect(conn);
+
+    return 1;
+}
+
+void xmpp_register_user(xmpp_conn_t * const conn){
+
+    handler_add(conn, on_register_user_handler,
+            NULL, "iq", NULL, NULL);
+
+    char name[100];
+
+    int i;
+
+    for (i = 0; conn->jid[i] != '\0'; i++){
+        if (conn->jid[i] == '@')
+            break;
+    }
+
+    strncpy(name, conn->jid, i);
+    name[i] = '\0';
+
+    xmpp_send_raw_string(conn, "<iq id=\"RbEdY-1\" type=\"set\"><query xmlns=\"jabber:iq:register\"><username>%s</username><email></email><password>%s</password></query></iq>",name,xmpp_conn_get_pass(conn));
+}
+
+/*define a handler for connection events*/
+void thread_xmpp_register_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_conn_get_context(conn);
+
+    if (status != XMPP_CONN_CONNECT) {
+
+        fprintf(stderr, "DEBUG:disconnect\n");
+
+        xmpp_stop(ctx);
+    }
+}
+
+void* thread_xmpp_register(void* param) {
+    xmpp_register_t *reg = (xmpp_register_t *)param;
+
+    xmpp_ctx_t *ctx;
+    xmpp_conn_t *conn;
+    xmpp_log_t *log;
+
+    /*initalize library*/
+    xmpp_initialize();
+
+    /*create a context*/
+    log = xmpp_get_default_logger(XMPP_LEVEL_DEBUG);
+    ctx = xmpp_ctx_new(NULL, log);
+
+    /* create a connection*/
+    conn = xmpp_conn_new(ctx);
+
+    /* setup authentication information*/
+    xmpp_conn_set_jid(conn, reg->jid);
+    xmpp_conn_set_pass(conn, reg->pass);
+
+    /* initialize connection*/
+    char *strServerIP;
+    if (reg->serverIP == NULL || strlen(reg->serverIP) == 0){
+        strServerIP = NULL;
+    }
+    else
+        strServerIP = reg->serverIP;
+
+    xmpp_set_register(conn);
+
+    xmpp_connect_client(conn, strServerIP, reg->serverAltport, thread_xmpp_register_handler, NULL);
+
+    /* enter the event loop - our connect handler will trigger an exit*/
+    xmpp_run(ctx);
+
+    if(reg->on_get_register_result != NULL)
+    reg->on_get_register_result(conn->register_result);
+
+    /*release our connection and contex*/
+    xmpp_conn_release(conn);
+    xmpp_ctx_free(ctx);
+
+    /*final shutdown of the libraty*/
+    xmpp_shutdown();
+
+    free(reg->jid);
+    free(reg->pass);
+    free(reg->serverIP);
+    free(reg);
+
+    return (void*)0;
+}
+
+void xmpp_register(const char *jid, const char *pass, const char *serverIP, int serverAltport, void * on_register){
+
+    xmpp_register_t *reg = (xmpp_register_t *)malloc(sizeof(xmpp_register_t));
+
+    reg->jid = (char *) malloc(sizeof(char) * (strlen(jid) + 1));
+    strcpy(reg->jid, jid);
+    reg->pass = (char *) malloc(sizeof(char) * (strlen(pass) + 1));
+    strcpy(reg->pass, pass);
+    reg->serverIP = (char *) malloc(sizeof(char) * (strlen(serverIP) + 1));
+    strcpy(reg->serverIP, serverIP);
+
+    reg->serverAltport = serverAltport;
+    reg->on_get_register_result = on_register;
+
+    pthread_t thread_xmpp_register_id;
+
+    pthread_attr_t thread_xmpp_register_attr; //线程属性
+    pthread_attr_init(&thread_xmpp_register_attr);  //初始化线程属性
+    pthread_attr_setdetachstate(&thread_xmpp_register_attr, PTHREAD_CREATE_DETACHED);      //设置线程属性
+
+    if (pthread_create(&thread_xmpp_register_id, &thread_xmpp_register_attr, (void *) thread_xmpp_register, reg) != 0){
+        fprintf(stderr, "Create thread_xmpp_register error!\n");
+    }
+}
+
+int get_conn_error(xmpp_conn_t * const conn){
+    return conn->error;
+}
+
 /** Clone a Strophe connection object.
  *  
  *  @param conn a Strophe connection object
@@ -474,8 +620,9 @@ void conn_disconnect(xmpp_conn_t * const conn)
     sock_close(conn->sock);
 
     /* fire off connection handler */
-    conn->conn_handler(conn, XMPP_CONN_DISCONNECT, conn->error,
-		       conn->stream_error, conn->userdata);
+    if(conn->conn_handler != NULL)
+        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
diff --git a/src/event.c b/src/event.c
index 1eaa643..a96d70b 100644
--- a/src/event.c
+++ b/src/event.c
@@ -254,6 +254,7 @@ void xmpp_run_once(xmpp_ctx_t *ctx, const unsigned long timeout)
 		if (sock_connect_error(conn->sock) != 0) {
 		    /* connection failed */
 		    xmpp_debug(ctx, "xmpp", "connection failed");
+            conn->error = ENETUNREACH;
 		    conn_disconnect(conn);
 		    break;
 		}
diff --git a/strophe.h b/strophe.h
index e3a2f4d..57286f7 100644
--- a/strophe.h
+++ b/strophe.h
@@ -367,6 +367,30 @@ 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);
 
+/* Add register module by xuqiqiang 2014/12/5 */
+typedef struct {
+    char *jid;
+    char *pass;
+    char *serverIP;
+    int serverAltport;
+    void (*on_get_register_result)(int result);
+} xmpp_register_t;
+
+void xmpp_register(const char *jid, const char *pass, const char *serverIP, int serverAltport, void * on_register);
+
+void xmpp_set_register(xmpp_conn_t * const conn);
+
+void xmpp_register_user(xmpp_conn_t * const conn);
+
+typedef enum {
+    XMPP_REGISTER_SUCCESSFUL,
+    XMPP_REGISTER_NOT_SUCCESSFUL,
+    XMPP_REGISTER_ALREADY_EXIST,
+    XMPP_REGISTER_NETWORK_CUT_DOWN
+} xmpp_register_result;
+
+int get_conn_error(xmpp_conn_t * const conn);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/src/auth.c b/src/auth.c
index 2371925..8bf26c6 100644
--- a/src/auth.c
+++ b/src/auth.c
@@ -550,6 +550,7 @@ static void _auth(xmpp_conn_t * const conn)
 	    return;
 	}
 	str = sasl_plain(conn->ctx, authid, conn->pass);
+    free(authid); // Fix memory leak by xuqiqiang 2014/12/9
 	if (!str) {
 	    disconnect_mem_error(conn);
 	    return;