自学教程：C++ xmpp_disconnect函数代码示例

static int _handle_legacy(xmpp_conn_t * const conn,			  xmpp_stanza_t * const stanza,			  void * const userdata){    char *type, *name;    /* delete missing handler */    xmpp_timed_handler_delete(conn, _handle_missing_legacy);    /* server responded to legacy auth request */    type = xmpp_stanza_get_type(stanza);    name = xmpp_stanza_get_name(stanza);    if (!type || strcmp(name, "iq") != 0) {	xmpp_error(conn->ctx, "xmpp", "Server sent us an unexpected response "/		   "to legacy authentication request.");	xmpp_disconnect(conn);    } else if (strcmp(type, "error") == 0) {	/* legacy client auth failed, no more fallbacks */	xmpp_error(conn->ctx, "xmpp", "Legacy client authentication failed.");	xmpp_disconnect(conn);    } else if (strcmp(type, "result") == 0) {	/* auth succeeded */	xmpp_debug(conn->ctx, "xmpp", "Legacy auth succeeded.");	conn->authenticated = 1;	conn->conn_handler(conn, XMPP_CONN_CONNECT, 0, NULL, conn->userdata);    } else {	xmpp_error(conn->ctx, "xmpp", "Server sent us a legacy authentication "/		   "response with a bad type.");	xmpp_disconnect(conn);    }    return 0;}

static int _handle_session(xmpp_conn_t * const conn,			   xmpp_stanza_t * const stanza,			   void * const userdata){    char *type;    /* delete missing session handler */    xmpp_timed_handler_delete(conn, _handle_missing_session);    /* server has replied to the session request */    type = xmpp_stanza_get_type(stanza);    if (type && strcmp(type, "error") == 0) {	xmpp_error(conn->ctx, "xmpp", "Session establishment failed.");	xmpp_disconnect(conn);    } else if (type && strcmp(type, "result") == 0) {	xmpp_debug(conn->ctx, "xmpp", "Session establishment successful.");	conn->authenticated = 1;	/* call connection handler */	conn->conn_handler(conn, XMPP_CONN_CONNECT, 0, NULL, conn->userdata);    } else {	xmpp_error(conn->ctx, "xmpp", "Server sent malformed session reply.");	xmpp_disconnect(conn);    }    return 0;}

static int _handle_register(xmpp_conn_t * const conn,			     xmpp_stanza_t * const stanza,			     void * const userdata){    char *type;    /* delete missing handler */    xmpp_timed_handler_delete(conn, _handle_missing_register);    /* server responded to legacy auth request */    type = xmpp_stanza_get_type(stanza);    if (!type) {	xmpp_error(conn->ctx, "xmpp", "Server sent us an unexpected response "/		   "to register request.");	xmpp_disconnect(conn);    } else if (strcmp(type, "error") == 0) {	/* legacy client auth failed, no more fallbacks */	xmpp_error(conn->ctx, "xmpp", "Register clientfailed.");	xmpp_disconnect(conn);    } else if (strcmp(type, "result") == 0) {	/* auth succeeded */	xmpp_debug(conn->ctx, "xmpp", "Register succeeded.");	_auth(conn);    } else {	xmpp_error(conn->ctx, "xmpp", "Server sent us a register"	/		   "response with a bad type.");	xmpp_disconnect(conn);    }    return 0;}

static void_jabber_disconnect(void){    // if connected, send end stream and wait for response    if (jabber_conn.conn_status == JABBER_CONNECTED) {        log_info("Closing connection");        jabber_conn.conn_status = JABBER_DISCONNECTING;        xmpp_disconnect(jabber_conn.conn);        while (jabber_get_connection_status() == JABBER_DISCONNECTING) {            jabber_process_events();        }        _connection_free_saved_account();        _connection_free_saved_details();        _connection_free_session_data();        if (jabber_conn.conn != NULL) {            xmpp_conn_release(jabber_conn.conn);            jabber_conn.conn = NULL;        }        if (jabber_conn.ctx != NULL) {            xmpp_ctx_free(jabber_conn.ctx);            jabber_conn.ctx = NULL;        }    }    jabber_conn.conn_status = JABBER_STARTED;    FREE_SET_NULL(jabber_conn.presence_message);    FREE_SET_NULL(jabber_conn.domain);}

static int _handle_proceedtls_default(xmpp_conn_t * const conn,			      xmpp_stanza_t * const stanza,			      void * const userdata){    char *name;    name = xmpp_stanza_get_name(stanza);    xmpp_debug(conn->ctx, "xmpp",	"handle proceedtls called for %s", name);    if (strcmp(name, "proceed") == 0) {        xmpp_debug(conn->ctx, "xmpp", "proceeding with TLS");	conn->tls = tls_new(conn->ctx, conn->sock);	if (!tls_start(conn->tls))	{	    xmpp_debug(conn->ctx, "xmpp", "Couldn't start TLS! error %d", tls_error(conn->tls));	    tls_free(conn->tls);	    conn->tls = NULL;	    conn->tls_failed = 1;	    /* failed tls spoils the connection, so disconnect */	    xmpp_disconnect(conn);	}	else	{            conn->secured = 1;            conn_prepare_reset(conn, auth_handle_open);	    conn_open_stream(conn);	}    }    return 0;}

static int _handle_missing_session(xmpp_conn_t * const conn,				   void * const userdata){    xmpp_error(conn->ctx, "xmpp", "Server did not reply to session request.");    xmpp_disconnect(conn);    return 0;}

static int _handle_sasl_result(xmpp_conn_t * const conn,			       xmpp_stanza_t * const stanza,			       void * const userdata){    char *name;    name = xmpp_stanza_get_name(stanza);    /* the server should send a <success> or <failure> stanza */    if (strcmp(name, "failure") == 0) {	xmpp_debug(conn->ctx, "xmpp", "SASL %s auth failed",		   (char *)userdata);	/* fall back to next auth method */	_auth(conn);    } else if (strcmp(name, "success") == 0) {	/* SASL PLAIN auth successful, we need to restart the stream */	xmpp_debug(conn->ctx, "xmpp", "SASL %s auth successful",		   (char *)userdata);	/* reset parser */	conn_prepare_reset(conn, _handle_open_sasl);	/* send stream tag */	conn_open_stream(conn);    } else {	/* got unexpected reply */	xmpp_error(conn->ctx, "xmpp", "Got unexpected reply to SASL %s"/		   "authentication.", (char *)userdata);	xmpp_disconnect(conn);    }    return 0;}

voidjabber_disconnect(void){    // if connected, send end stream and wait for response    if (jabber_conn.conn_status == JABBER_CONNECTED) {        char *account_name = jabber_get_account_name();        const char *fulljid = jabber_get_fulljid();        plugins_on_disconnect(account_name, fulljid);        log_info("Closing connection");        accounts_set_last_activity(jabber_get_account_name());        jabber_conn.conn_status = JABBER_DISCONNECTING;        xmpp_disconnect(jabber_conn.conn);        while (jabber_get_connection_status() == JABBER_DISCONNECTING) {            jabber_process_events(10);        }        _connection_free_saved_account();        _connection_free_saved_details();        _connection_free_session_data();        if (jabber_conn.conn) {            xmpp_conn_release(jabber_conn.conn);            jabber_conn.conn = NULL;        }        if (jabber_conn.ctx) {            xmpp_ctx_free(jabber_conn.ctx);            jabber_conn.ctx = NULL;        }    }    jabber_conn.conn_status = JABBER_STARTED;    FREE_SET_NULL(jabber_conn.presence_message);    FREE_SET_NULL(jabber_conn.domain);}

voidjabber_autoping_fail(void){    if (jabber_conn.conn_status == JABBER_CONNECTED) {        log_info("Closing connection");        char *account_name = jabber_get_account_name();        const char *fulljid = jabber_get_fulljid();        plugins_on_disconnect(account_name, fulljid);        accounts_set_last_activity(jabber_get_account_name());        jabber_conn.conn_status = JABBER_DISCONNECTING;        xmpp_disconnect(jabber_conn.conn);        while (jabber_get_connection_status() == JABBER_DISCONNECTING) {            jabber_process_events(10);        }        if (jabber_conn.conn) {            xmpp_conn_release(jabber_conn.conn);            jabber_conn.conn = NULL;        }        if (jabber_conn.ctx) {            xmpp_ctx_free(jabber_conn.ctx);            jabber_conn.ctx = NULL;        }    }    FREE_SET_NULL(jabber_conn.presence_message);    FREE_SET_NULL(jabber_conn.domain);    jabber_conn.conn_status = JABBER_DISCONNECTED;    _jabber_lost_connection();}

voidxmpp_cleanup() {    xmpp_disconnect();    if (connection) lm_connection_unref(connection);    xmpp_roster_cleanup();    config_cleanup();} /* xmpp_cleanup */

int handle_reply(xmpp_conn_t * const conn,		 xmpp_stanza_t * const stanza,		 void * const userdata){    xmpp_stanza_t *query, *item;    char *type, *name;    type = xmpp_stanza_get_type(stanza);    if (strcmp(type, "error") == 0)	fprintf(stderr, "ERROR: query failed/n");    else {	query = xmpp_stanza_get_child_by_name(stanza, "query");	printf("Roster:/n");	for (item = xmpp_stanza_get_children(query); item; 	     item = xmpp_stanza_get_next(item))	    if ((name = xmpp_stanza_get_attribute(item, "name")))		printf("/t %s (%s) sub=%s/n", 		       name,		       xmpp_stanza_get_attribute(item, "jid"),		       xmpp_stanza_get_attribute(item, "subscription"));	    else		printf("/t %s sub=%s/n",		       xmpp_stanza_get_attribute(item, "jid"),		       xmpp_stanza_get_attribute(item, "subscription"));	printf("END OF LIST/n");    }    /* disconnect */    xmpp_disconnect(conn);    return 0;}

/* Check if the received stanza is <handshake/> and set auth to true * and fire connection handler. */int _handle_component_hs_response(xmpp_conn_t * const conn,            xmpp_stanza_t * const stanza,            void * const userdata){    char *name;    xmpp_timed_handler_delete(conn, _handle_missing_handshake);    name = xmpp_stanza_get_name(stanza);    if (strcmp(name, "handshake") != 0) {        char *msg;        size_t msg_size;        xmpp_stanza_to_text(stanza, &msg, &msg_size);        if (msg) {            xmpp_debug(conn->ctx, "auth", "Handshake failed: %s", msg);            xmpp_free(conn->ctx, msg);        }        xmpp_disconnect(conn);        return XMPP_EINT;    } else {        conn->authenticated = 1;        conn->conn_handler(conn, XMPP_CONN_CONNECT, 0, NULL, conn->userdata);    }    /* We don't need this handler anymore, return 0 so it can be deleted     * from the list of handlers.     */    return 0;}

void *console_routine(void *arg){    xmpp_conn_t *conn = (xmpp_conn_t*)arg;    process_input(conn);    xmpp_disconnect(conn);    return NULL;}

static int _handle_missing_features_sasl(xmpp_conn_t * const conn,					 void * const userdata){    xmpp_error(conn->ctx, "xmpp", "Did not receive stream features "/	       "after SASL authentication.");    xmpp_disconnect(conn);    return 0;}

/* 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){    xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;    if (status == XMPP_CONN_CONNECT) {        fprintf(stderr, "DEBUG: connected/n");        xmpp_disconnect(conn);    }    else {        fprintf(stderr, "DEBUG: disconnected/n");        xmpp_stop(ctx);    }}

void  xmpp_ua_logout(xmpp_ua_t *ua){	WaitForSingleObject(_mutex_4_conn, INFINITE);	conn_ua_map::iterator iter = _conn_map.find(ua->conn);	if (iter == _conn_map.end())	{		ReleaseMutex(_mutex_4_conn);		return;	}	xmpp_disconnect(ua->conn);	_conn_map.erase(iter);	ReleaseMutex(_mutex_4_conn);	WaitForSingleObject(ua->mutex_4_ua, INFINITE);	ua->conn = NULL;	ReleaseMutex(ua->mutex_4_ua);}

void auth_handle_component_open(xmpp_conn_t * const conn){    int rc;    /* reset all timed handlers */    handler_reset_timed(conn, 0);    handler_add(conn, _handle_error, XMPP_NS_STREAMS, "error", NULL, NULL);    handler_add(conn, _handle_component_hs_response, NULL,                "handshake", NULL, NULL);    handler_add_timed(conn, _handle_missing_handshake, HANDSHAKE_TIMEOUT, NULL);    rc = _handle_component_auth(conn);    if (rc != 0) {        xmpp_error(conn->ctx, "auth", "Component authentication failed.");        xmpp_disconnect(conn);    }}

void XMPP_Close(xmpp_ctx_t *ctx,  xmpp_conn_t *conn){    if(conn !=NULL)        xmpp_disconnect(conn);   //   xmpp_handler_delete(conn, iq_ibb_open_handler);    xmpp_conn_release(conn);    fprintf(stderr, "Conn release!");    /* final shutdown of the library */   if(ctx!=NULL)        xmpp_ctx_free(ctx);   xmpp_shutdown();}

/* 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){    xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;    int secured;    if (status == XMPP_CONN_CONNECT) {        fprintf(stderr, "DEBUG: connected/n");        secured = xmpp_conn_is_secured(conn);        fprintf(stderr, "DEBUG: connection is %s./n",                secured ? "secured" : "NOT secured");        xmpp_disconnect(conn);    }    else {        fprintf(stderr, "DEBUG: disconnected/n");        xmpp_stop(ctx);    }}

voidconnection_disconnect(void){    conn.conn_status = JABBER_DISCONNECTING;    xmpp_disconnect(conn.xmpp_conn);    while (conn.conn_status == JABBER_DISCONNECTING) {        session_process_events();    }    if (conn.xmpp_conn) {        xmpp_conn_release(conn.xmpp_conn);        conn.xmpp_conn = NULL;    }    if (conn.xmpp_ctx) {        xmpp_ctx_free(conn.xmpp_ctx);        conn.xmpp_ctx = NULL;    }}

/* Will compute SHA1 and authenticate the component to the server */int _handle_component_auth(xmpp_conn_t * const conn){    uint8_t md_value[SHA1_DIGEST_SIZE];    SHA1_CTX mdctx;    char *digest;    size_t i;    /*
C++ xmpp_display_attrs函数代码示例
C++ xmpp_debug函数代码示例