/* conn.c ** strophe XMPP client library -- connection object functions ** ** Copyright (C) 2005-2009 Collecta, Inc. ** ** 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 * Connection management. */ /** @defgroup Connections Connection management */ #include #include #include #include "strophe.h" #include "common.h" #include "util.h" #include "parser.h" #include "resolver.h" #ifndef DEFAULT_SEND_QUEUE_MAX /** @def DEFAULT_SEND_QUEUE_MAX * The default maximum send queue size. This is currently unused. */ #define DEFAULT_SEND_QUEUE_MAX 64 #endif #ifndef DISCONNECT_TIMEOUT /** @def DISCONNECT_TIMEOUT * The time to wait (in milliseconds) for graceful disconnection to * complete before the connection is reset. The default is 2 seconds. */ #define DISCONNECT_TIMEOUT 2000 /* 2 seconds */ #endif #ifndef CONNECT_TIMEOUT /** @def CONNECT_TIMEOUT * The time to wait (in milliseconds) for a connection attempt to succeed * or error. The default is 5 seconds. */ #define CONNECT_TIMEOUT 5000 /* 5 seconds */ #endif 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); static unsigned short _conn_default_port(xmpp_conn_t * const conn, xmpp_conn_type_t type); static void _conn_reset(xmpp_conn_t * const conn); static int _conn_connect(xmpp_conn_t * const conn, const char * const domain, const char * const host, unsigned short port, xmpp_conn_type_t type, xmpp_conn_handler callback, void * const userdata); /** Create a new Strophe connection object. * * @param ctx a Strophe context object * * @return a Strophe connection object or NULL on an error * * @ingroup Connections */ xmpp_conn_t *xmpp_conn_new(xmpp_ctx_t * const ctx) { xmpp_conn_t *conn = NULL; xmpp_connlist_t *tail, *item; if (ctx == NULL) return NULL; conn = xmpp_alloc(ctx, sizeof(xmpp_conn_t)); if (conn != NULL) { conn->ctx = ctx; conn->type = XMPP_UNKNOWN; conn->state = XMPP_STATE_DISCONNECTED; conn->sock = -1; conn->ka_timeout = 0; conn->ka_interval = 0; conn->tls = NULL; conn->timeout_stamp = 0; conn->error = 0; conn->stream_error = NULL; /* default send parameters */ conn->blocking_send = 0; conn->send_queue_max = DEFAULT_SEND_QUEUE_MAX; conn->send_queue_len = 0; conn->send_queue_head = NULL; conn->send_queue_tail = NULL; /* default timeouts */ conn->connect_timeout = CONNECT_TIMEOUT; conn->lang = xmpp_strdup(conn->ctx, "en"); if (!conn->lang) { xmpp_free(conn->ctx, conn); return NULL; } conn->domain = NULL; conn->jid = NULL; conn->pass = NULL; conn->stream_id = NULL; conn->bound_jid = NULL; conn->tls_support = 0; conn->tls_disabled = 0; conn->tls_mandatory = 0; conn->tls_legacy_ssl = 0; conn->tls_failed = 0; conn->sasl_support = 0; conn->secured = 0; conn->bind_required = 0; conn->session_required = 0; conn->parser = parser_new(conn->ctx, _handle_stream_start, _handle_stream_end, _handle_stream_stanza, conn); conn->reset_parser = 0; conn->authenticated = 0; conn->conn_handler = NULL; conn->userdata = NULL; conn->timed_handlers = NULL; /* we own (and will free) the hash values */ conn->id_handlers = hash_new(conn->ctx, 32, NULL); conn->handlers = NULL; /* give the caller a reference to connection */ conn->ref = 1; /* add connection to ctx->connlist */ tail = conn->ctx->connlist; while (tail && tail->next) tail = tail->next; item = xmpp_alloc(conn->ctx, sizeof(xmpp_connlist_t)); if (!item) { xmpp_error(conn->ctx, "xmpp", "failed to allocate memory"); xmpp_free(conn->ctx, conn->lang); parser_free(conn->parser); xmpp_free(conn->ctx, conn); conn = NULL; } else { item->conn = conn; item->next = NULL; if (tail) tail->next = item; else conn->ctx->connlist = item; } } return conn; } /** Clone a Strophe connection object. * * @param conn a Strophe connection object * * @return the same conn object passed in with its reference count * incremented by 1 * * @ingroup Connections */ xmpp_conn_t *xmpp_conn_clone(xmpp_conn_t * const conn) { conn->ref++; return conn; } /** Set TCP keepalive parameters * Turn on TCP keepalive and set timeout and interval. Zero timeout * disables TCP keepalives. The parameters are applied immediately for * a non disconnected object. Also, they are applied when the connection * object connects successfully. * * @param conn a Strophe connection object * @param timeout TCP keepalive timeout in seconds * @param interval TCP keepalive interval in seconds * * @ingroup Connections */ void xmpp_conn_set_keepalive(xmpp_conn_t * const conn, int timeout, int interval) { int ret = 0; conn->ka_timeout = timeout; conn->ka_interval = interval; if (conn->state != XMPP_STATE_DISCONNECTED) ret = sock_set_keepalive(conn->sock, timeout, interval); if (ret < 0) { xmpp_error(conn->ctx, "xmpp", "Setting TCP keepalive (%d,%d) error: %d", timeout, interval, sock_error()); } } /** Release a Strophe connection object. * Decrement the reference count by one for a connection, freeing the * connection object if the count reaches 0. * * @param conn a Strophe connection object * * @return TRUE if the connection object was freed and FALSE otherwise * * @ingroup Connections */ int xmpp_conn_release(xmpp_conn_t * const conn) { xmpp_ctx_t *ctx; xmpp_connlist_t *item, *prev; xmpp_handlist_t *hlitem, *thli; hash_iterator_t *iter; const char *key; int released = 0; if (conn->ref > 1) conn->ref--; else { ctx = conn->ctx; /* remove connection from context's connlist */ if (ctx->connlist->conn == conn) { item = ctx->connlist; ctx->connlist = item->next; xmpp_free(ctx, item); } else { prev = NULL; item = ctx->connlist; while (item && item->conn != conn) { prev = item; item = item->next; } if (!item) { xmpp_error(ctx, "xmpp", "Connection not in context's list\n"); } else { prev->next = item->next; xmpp_free(ctx, item); } } /* free handler stuff * note that userdata is the responsibility of the client * and the handler pointers don't need to be freed since they * are pointers to functions */ hlitem = conn->timed_handlers; while (hlitem) { thli = hlitem; hlitem = hlitem->next; xmpp_free(ctx, thli); } /* id handlers * we have to traverse the hash table freeing list elements * then release the hash table */ iter = hash_iter_new(conn->id_handlers); while ((key = hash_iter_next(iter))) { hlitem = (xmpp_handlist_t *)hash_get(conn->id_handlers, key); while (hlitem) { thli = hlitem; hlitem = hlitem->next; xmpp_free(conn->ctx, thli->id); xmpp_free(conn->ctx, thli); } } hash_iter_release(iter); hash_release(conn->id_handlers); hlitem = conn->handlers; while (hlitem) { thli = hlitem; hlitem = hlitem->next; if (thli->ns) xmpp_free(ctx, thli->ns); if (thli->name) xmpp_free(ctx, thli->name); if (thli->type) xmpp_free(ctx, thli->type); xmpp_free(ctx, thli); } parser_free(conn->parser); _conn_reset(conn); if (conn->jid) xmpp_free(ctx, conn->jid); if (conn->pass) xmpp_free(ctx, conn->pass); if (conn->lang) xmpp_free(ctx, conn->lang); xmpp_free(ctx, conn); released = 1; } return released; } /** Get the JID which is or will be bound to the connection. * * @param conn a Strophe connection object * * @return a string containing the full JID or NULL if it has not been set * * @ingroup Connections */ 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 * the JID string. If the supplied JID is missing the node, SASL * ANONYMOUS authentication will be used. * * @param conn a Strophe connection object * @param jid a full or bare JID * * @ingroup Connections */ void xmpp_conn_set_jid(xmpp_conn_t * const conn, const char * const jid) { if (conn->jid) xmpp_free(conn->ctx, conn->jid); conn->jid = xmpp_strdup(conn->ctx, jid); } /** Get the password used for authentication of a connection. * * @param conn a Strophe connection object * * @return a string containing the password or NULL if it has not been set * * @ingroup Connections */ const char *xmpp_conn_get_pass(const xmpp_conn_t * const conn) { return conn->pass; } /** Set the password used to authenticate the connection. * If any password was previously set, it will be discarded. The function * will make a copy of the password string. * * @param conn a Strophe connection object * @param pass the password * * @ingroup Connections */ void xmpp_conn_set_pass(xmpp_conn_t * const conn, const char * const pass) { if (conn->pass) xmpp_free(conn->ctx, conn->pass); conn->pass = xmpp_strdup(conn->ctx, pass); } /** Get the strophe context that the connection is associated with. * @param conn a Strophe connection object * * @return a Strophe context * * @ingroup Connections */ xmpp_ctx_t* xmpp_conn_get_context(xmpp_conn_t * const conn) { return conn->ctx; } /** Initiate a connection to the XMPP server. * This function returns immediately after starting the connection * process to the XMPP server, and notifications of connection state changes * will be sent to the callback function. The domain and port to connect to * are usually determined by an SRV lookup for the xmpp-client service at * the domain specified in the JID. If SRV lookup fails, altdomain and * altport will be used instead if specified. * * @param conn a Strophe connection object * @param altdomain a string with domain to use if SRV lookup fails. If this * is NULL, the domain from the JID will be used. * @param altport an integer port number to use if SRV lookup fails. If this * is 0, the default port will be assumed. * @param callback a xmpp_conn_handler callback function that will receive * notifications of connection status * @param userdata an opaque data pointer that will be passed to the callback * * @return 0 on success and -1 on an error * * @ingroup Connections */ int xmpp_connect_client(xmpp_conn_t * const conn, const char * const altdomain, unsigned short altport, xmpp_conn_handler callback, void * const userdata) { resolver_srv_rr_t *srv_rr_list = NULL; char *domain; const char *host; unsigned short port; int found = XMPP_DOMAIN_NOT_FOUND; int rc; domain = xmpp_jid_domain(conn->ctx, conn->jid); if (!domain) return -1; if (altdomain != NULL) { xmpp_debug(conn->ctx, "xmpp", "Connecting via altdomain."); host = altdomain; port = altport ? altport : _conn_default_port(conn, XMPP_CLIENT); found = XMPP_DOMAIN_ALTDOMAIN; /* SSL tunneled connection on 5223 port is legacy and doesn't * have an SRV record. */ } else if (!conn->tls_legacy_ssl) { host = xmpp_alloc(conn->ctx, MAX_DOMAIN_LEN); srv_rr_list = xmpp_alloc(conn->ctx, sizeof(resolver_srv_rr_t)); if (srv_rr_list != NULL) { srv_rr_list->next = NULL; found = resolver_srv_lookup(conn->ctx, "xmpp-client", "tcp", domain, &srv_rr_list); /* Try DNS-SRV list connection*/ if (found == XMPP_DOMAIN_FOUND) { resolver_srv_rr_t *srv_rr_p = srv_rr_list; sock_t sock_try; while(srv_rr_p != NULL) { xmpp_debug(conn->ctx, "xmpp", "Try sock_connect %s:%d ",srv_rr_p->target, srv_rr_p->port); sock_try = sock_connect(srv_rr_p->target, srv_rr_p->port); if (sock_try == 0){ host = srv_rr_p->target; port = srv_rr_p->port; found = XMPP_DOMAIN_FOUND; break; } srv_rr_p = srv_rr_p->next; found = XMPP_DOMAIN_NOT_FOUND; } } } } if (XMPP_DOMAIN_NOT_FOUND == found) { xmpp_debug(conn->ctx, "xmpp", "SRV lookup failed, " "connecting via domain."); host = domain; port = altport ? altport : _conn_default_port(conn, XMPP_CLIENT); } rc = _conn_connect(conn, domain, host, port, XMPP_CLIENT, callback, userdata); xmpp_free(conn->ctx, domain); while (srv_rr_list!=NULL) { resolver_srv_rr_t *rr_next = srv_rr_list->next; xmpp_free(conn->ctx, srv_rr_list); srv_rr_list = rr_next; } return rc; } /** Initiate a component connection to server. * This function returns immediately after starting the connection * process to the XMPP server, and notifications of connection state changes * will be sent to the internal callback function that will set up handler * for the component handshake as defined in XEP-0114. * The domain and port to connect to must be provided in this case as the JID * provided to the call serves as component identifier to the server and is * not subject to DNS resolution. * * @param conn a Strophe connection object * @param server a string with domain to use directly as the domain can't be * extracted from the component name/JID. If this is not set, the call * will fail. * @param port an integer port number to use to connect to server expecting * an external component. If this is 0, the port 5347 will be assumed. * @param callback a xmpp_conn_handler callback function that will receive * notifications of connection status * @param userdata an opaque data pointer that will be passed to the callback * * @return 0 on success and -1 on an error * * @ingroup Connections */ int xmpp_connect_component(xmpp_conn_t * const conn, const char * const server, unsigned short port, xmpp_conn_handler callback, void * const userdata) { /* The server domain, jid and password MUST be specified. */ if (!(server && conn->jid && conn->pass)) return -1; /* XEP-0114 does not support TLS */ xmpp_conn_disable_tls(conn); if (!conn->tls_disabled) { xmpp_error(conn->ctx, "conn", "Failed to disable TLS. " "XEP-0114 does not support TLS"); return -1; } port = port ? port : _conn_default_port(conn, XMPP_COMPONENT); /* JID serves as an identifier here and will be used as "to" attribute of the stream */ return _conn_connect(conn, conn->jid, server, port, XMPP_COMPONENT, callback, userdata); } /** Cleanly disconnect the connection. * This function is only called by the stream parser when * is received, and it not intended to be called by code outside of Strophe. * * @param conn a Strophe connection object */ void conn_disconnect_clean(xmpp_conn_t * const conn) { /* remove the timed handler */ xmpp_timed_handler_delete(conn, _disconnect_cleanup); conn_disconnect(conn); } /** Disconnect from the XMPP server. * This function immediately disconnects from the XMPP server, and should * not be used outside of the Strophe library. * * @param conn a Strophe connection object */ void conn_disconnect(xmpp_conn_t * const conn) { xmpp_debug(conn->ctx, "xmpp", "Closing socket."); conn->state = XMPP_STATE_DISCONNECTED; if (conn->tls) { tls_stop(conn->tls); tls_free(conn->tls); conn->tls = NULL; } sock_close(conn->sock); /* fire off connection handler */ 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 */ static int _disconnect_cleanup(xmpp_conn_t * const conn, void * const userdata) { xmpp_debug(conn->ctx, "xmpp", "disconnection forced by cleanup timeout"); conn_disconnect(conn); return 0; } /** Initiate termination of the connection to the XMPP server. * This function starts the disconnection sequence by sending * to the XMPP server. This function will do nothing * if the connection state is CONNECTING or CONNECTED. * * @param conn a Strophe connection object * * @ingroup Connections */ void xmpp_disconnect(xmpp_conn_t * const conn) { if (conn->state != XMPP_STATE_CONNECTING && conn->state != XMPP_STATE_CONNECTED) return; /* close the stream */ xmpp_send_raw_string(conn, ""); /* setup timed handler in case disconnect takes too long */ handler_add_timed(conn, _disconnect_cleanup, DISCONNECT_TIMEOUT, NULL); } /** Send a raw string to the XMPP server. * This function is a convenience function to send raw string data to the * XMPP server. It is used by Strophe to send short messages instead of * building up an XML stanza with DOM methods. This should be used with care * as it does not validate the data; invalid data may result in immediate * stream termination by the XMPP server. * * @param conn a Strophe connection object * @param fmt a printf-style format string followed by a variable list of * arguments to format * * @ingroup Connections */ void xmpp_send_raw_string(xmpp_conn_t * const conn, const char * const fmt, ...) { va_list ap; size_t len; char buf[1024]; /* small buffer for common case */ char *bigbuf; va_start(ap, fmt); len = xmpp_vsnprintf(buf, 1024, fmt, ap); va_end(ap); if (len >= 1024) { /* we need more space for this data, so we allocate a big * enough buffer and print to that */ len++; /* account for trailing \0 */ bigbuf = xmpp_alloc(conn->ctx, len); if (!bigbuf) { xmpp_debug(conn->ctx, "xmpp", "Could not allocate memory for send_raw_string"); return; } va_start(ap, fmt); xmpp_vsnprintf(bigbuf, len, fmt, ap); va_end(ap); xmpp_debug(conn->ctx, "conn", "SENT: %s", bigbuf); /* len - 1 so we don't send trailing \0 */ xmpp_send_raw(conn, bigbuf, len - 1); xmpp_free(conn->ctx, bigbuf); } else { xmpp_debug(conn->ctx, "conn", "SENT: %s", buf); xmpp_send_raw(conn, buf, len); } } /** Send raw bytes to the XMPP server. * This function is a convenience function to send raw bytes to the * XMPP server. It is used primarily by xmpp_send_raw_string(). This * function should be used with care as it does not validate the bytes and * invalid data may result in stream termination by the XMPP server. * * @param conn a Strophe connection object * @param data a buffer of raw bytes * @param len the length of the data in the buffer * * @ingroup Connections */ void xmpp_send_raw(xmpp_conn_t * const conn, const char * const data, const size_t len) { xmpp_send_queue_t *item; if (conn->state != XMPP_STATE_CONNECTED) return; /* create send queue item for queue */ item = xmpp_alloc(conn->ctx, sizeof(xmpp_send_queue_t)); if (!item) return; item->data = xmpp_alloc(conn->ctx, len); if (!item->data) { xmpp_free(conn->ctx, item); return; } memcpy(item->data, data, len); item->len = len; item->next = NULL; item->written = 0; /* add item to the send queue */ if (!conn->send_queue_tail) { /* first item, set head and tail */ conn->send_queue_head = item; conn->send_queue_tail = item; } else { /* add to the tail */ conn->send_queue_tail->next = item; conn->send_queue_tail = item; } conn->send_queue_len++; } /** Send an XML stanza to the XMPP server. * This is the main way to send data to the XMPP server. The function will * terminate without action if the connection state is not CONNECTED. * * @param conn a Strophe connection object * @param stanza a Strophe stanza object * * @ingroup Connections */ void xmpp_send(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza) { char *buf; size_t len; int ret; if (conn->state == XMPP_STATE_CONNECTED) { if ((ret = xmpp_stanza_to_text(stanza, &buf, &len)) == 0) { xmpp_send_raw(conn, buf, len); xmpp_debug(conn->ctx, "conn", "SENT: %s", buf); xmpp_free(conn->ctx, buf); } } } /** Send the opening <stream:stream> tag to the server. * This function is used by Strophe to begin an XMPP stream. It should * not be used outside of the library. * * @param conn a Strophe connection object */ void conn_open_stream(xmpp_conn_t * const conn) { xmpp_send_raw_string(conn, "" \ "", conn->domain, conn->lang, conn->type == XMPP_CLIENT ? XMPP_NS_CLIENT : XMPP_NS_COMPONENT, XMPP_NS_STREAMS); } int conn_tls_start(xmpp_conn_t * const conn) { int rc; if (conn->tls_disabled) { conn->tls = NULL; rc = -ENOSYS; } else { conn->tls = tls_new(conn->ctx, conn->sock); rc = conn->tls == NULL ? -ENOMEM : 0; } if (conn->tls != NULL) { if (tls_start(conn->tls)) { conn->secured = 1; conn_prepare_reset(conn, auth_handle_open); } else { rc = tls_error(conn->tls); conn->error = rc; tls_free(conn->tls); conn->tls = NULL; conn->tls_failed = 1; } } if (rc != 0) xmpp_debug(conn->ctx, "conn", "Couldn't start TLS! error %d", rc); return rc; } /** Return applied flags for the connection. * * @param conn a Strophe connection object * * @return ORed connection flags that are applied for the connection. * * @ingroup Connections */ long xmpp_conn_get_flags(const xmpp_conn_t * const conn) { long flags; flags = XMPP_CONN_FLAG_DISABLE_TLS * conn->tls_disabled | XMPP_CONN_FLAG_MANDATORY_TLS * conn->tls_mandatory | XMPP_CONN_FLAG_LEGACY_SSL * conn->tls_legacy_ssl; return flags; } /** Set flags for the connection. * This function applies set flags and resets unset ones. Default connection * configuration is all flags unset. Flags can be applied only for a connection * in disconnected state. * All unsupported flags are ignored. If a flag is unset after successful set * operation then the flag is not supported by current version. * * Supported flags are: * * - XMPP_CONN_FLAG_DISABLE_TLS * - XMPP_CONN_FLAG_MANDATORY_TLS * - XMPP_CONN_FLAG_LEGACY_SSL * * @param conn a Strophe connection object * @param flags ORed connection flags * * @return 0 on success or -1 if flags can't be applied. * * @ingroup Connections */ int xmpp_conn_set_flags(xmpp_conn_t * const conn, long flags) { if (conn->state != XMPP_STATE_DISCONNECTED) { xmpp_error(conn->ctx, "conn", "Flags can be set only " "for disconnected connection"); return -1; } if (flags & XMPP_CONN_FLAG_DISABLE_TLS && flags & (XMPP_CONN_FLAG_MANDATORY_TLS | XMPP_CONN_FLAG_LEGACY_SSL)) { xmpp_error(conn->ctx, "conn", "Flags 0x%04lx conflict", flags); return -1; } conn->tls_disabled = (flags & XMPP_CONN_FLAG_DISABLE_TLS) ? 1 : 0; conn->tls_mandatory = (flags & XMPP_CONN_FLAG_MANDATORY_TLS) ? 1 : 0; conn->tls_legacy_ssl = (flags & XMPP_CONN_FLAG_LEGACY_SSL) ? 1 : 0; return 0; } /** Disable TLS for this connection, called by users of the library. * Occasionally a server will be misconfigured to send the starttls * feature, but will not support the handshake. * * @param conn a Strophe connection object * * @note this function is deprecated * @see xmpp_conn_set_flags() * * @ingroup Connections */ void xmpp_conn_disable_tls(xmpp_conn_t * const conn) { long flags = xmpp_conn_get_flags(conn); flags |= XMPP_CONN_FLAG_DISABLE_TLS; (void)xmpp_conn_set_flags(conn, flags); } /** Return whether TLS session is established or not. * * @return TRUE if TLS session is established and FALSE otherwise * * @ingroup Connections */ int xmpp_conn_is_secured(xmpp_conn_t * const conn) { return conn->secured && !conn->tls_failed && conn->tls != NULL ? 1 : 0; } static void _log_open_tag(xmpp_conn_t *conn, char **attrs) { char buf[4096]; size_t pos; int len; int i; char *attr; if (!attrs) return; pos = 0; len = xmpp_snprintf(buf, 4096, "ctx, attrs[i]); len = xmpp_snprintf(&buf[pos], 4096 - pos, " %s='%s'", attr, attrs[i+1]); xmpp_free(conn->ctx, attr); 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 (conn->stream_id) xmpp_free(conn->ctx, conn->stream_id); conn->stream_id = NULL; if (strcmp(name, "stream") == 0) { _log_open_tag(conn, attrs); id = _get_stream_attribute(attrs, "id"); if (id) conn->stream_id = xmpp_strdup(conn->ctx, id); /* check and log errors */ if (!id) xmpp_error(conn->ctx, "conn", "No id attribute."); else if (!conn->stream_id) xmpp_error(conn->ctx, "conn", "Memory allocation failed."); } else { xmpp_error(conn->ctx, "conn", "Server did not open valid stream." " name = %s.", name); } if (conn->stream_id) { /* call stream open handler */ conn->open_handler(conn); } else { conn_disconnect(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: "); 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); } static unsigned short _conn_default_port(xmpp_conn_t * const conn, xmpp_conn_type_t type) { switch (type) { case XMPP_CLIENT: return conn->tls_legacy_ssl ? XMPP_PORT_CLIENT_LEGACY_SSL : XMPP_PORT_CLIENT; case XMPP_COMPONENT: return XMPP_PORT_COMPONENT; default: return 0; }; } static void _conn_reset(xmpp_conn_t * const conn) { xmpp_ctx_t *ctx = conn->ctx; xmpp_send_queue_t *sq, *tsq; if (conn->state != XMPP_STATE_DISCONNECTED) { xmpp_debug(ctx, "conn", "Can't reset connected object."); return; } /* free queued */ sq = conn->send_queue_head; while (sq) { tsq = sq; sq = sq->next; xmpp_free(ctx, tsq->data); xmpp_free(ctx, tsq); } if (conn->stream_error) { xmpp_stanza_release(conn->stream_error->stanza); if (conn->stream_error->text) xmpp_free(ctx, conn->stream_error->text); xmpp_free(ctx, conn->stream_error); conn->stream_error = NULL; } if (conn->domain) xmpp_free(ctx, conn->domain); if (conn->bound_jid) xmpp_free(ctx, conn->bound_jid); if (conn->stream_id) xmpp_free(ctx, conn->stream_id); conn->domain = NULL; conn->bound_jid = NULL; conn->stream_id = NULL; conn->secured = 0; conn->tls_failed = 0; conn->error = 0; } static int _conn_connect(xmpp_conn_t * const conn, const char * const domain, const char * const host, unsigned short port, xmpp_conn_type_t type, xmpp_conn_handler callback, void * const userdata) { if (conn->state != XMPP_STATE_DISCONNECTED) return -1; if (type != XMPP_CLIENT && type != XMPP_COMPONENT) return -1; _conn_reset(conn); conn->type = type; conn->domain = xmpp_strdup(conn->ctx, domain); if (!conn->domain) return -1; conn->sock = sock_connect(host, port); xmpp_debug(conn->ctx, "xmpp", "sock_connect() to %s:%u returned %d", host, port, conn->sock); if (conn->sock == -1) return -1; if (conn->ka_timeout || conn->ka_interval) sock_set_keepalive(conn->sock, conn->ka_timeout, conn->ka_interval); /* setup handler */ conn->conn_handler = callback; conn->userdata = userdata; conn_prepare_reset(conn, type == XMPP_CLIENT ? auth_handle_open : auth_handle_component_open); /* FIXME: it could happen that the connect returns immediately as * successful, though this is pretty unlikely. This would be a little * hard to fix, since we'd have to detect and fire off the callback * from within the event loop */ conn->state = XMPP_STATE_CONNECTING; conn->timeout_stamp = time_stamp(); xmpp_debug(conn->ctx, "xmpp", "Attempting to connect to %s", host); return 0; }