--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/loudmouth/src/lm-connection.c Tue Feb 02 01:10:06 2010 +0200
@@ -0,0 +1,2248 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/*
+ * Copyright (C) 2003-2007 Imendio AB
+ * and/or its subsidiary/subsidiaries. All rights reserved.
+ * Copyright (C) 2007 Collabora Ltd.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+
+/* Needed on Mac OS X */
+#if HAVE_NETINET_IN_H
+#include <netinet/in.h>
+#endif
+
+#include <arpa/nameser.h>
+//#include <resolv.h>
+
+#include <glib.h>
+#include <gdebug.h>
+
+#include "lm-sock.h"
+#include "lm-debug.h"
+#include "lm-error.h"
+#include "lm-internals.h"
+#include "lm-message-queue.h"
+#include "lm-misc.h"
+#include "lm-ssl-internals.h"
+#include "lm-parser.h"
+#include "lm-sha.h"
+#include "lm-connection.h"
+#include "lm-utils.h"
+#include "lm-socket.h"
+#include "lm-sasl.h"
+
+#define IN_BUFFER_SIZE 1024
+//#define SRV_LEN 8192
+#define SRV_LEN 2048 // check the actual value needed here! - MeCo
+
+typedef struct {
+ LmHandlerPriority priority;
+ LmMessageHandler *handler;
+} HandlerData;
+
+struct _LmConnection {
+ /* Parameters */
+ GMainContext *context;
+ gchar *server;
+ gchar *jid;
+ gchar *effective_jid;
+ guint port;
+ gboolean use_srv;
+
+ LmSocket *socket;
+ LmSSL *ssl;
+ LmProxy *proxy;
+ LmParser *parser;
+
+ gchar *stream_id;
+
+ GHashTable *id_handlers;
+ GSList *handlers[LM_MESSAGE_TYPE_UNKNOWN];
+
+ /* XMPP1.0 stuff (SASL, resource binding, StartTLS) */
+ gboolean use_sasl;
+ LmSASL *sasl;
+ gchar *resource;
+ LmMessageHandler *features_cb;
+ LmMessageHandler *starttls_cb;
+ gboolean tls_started;
+
+ /* Communication */
+ guint open_id;
+ LmCallback *open_cb;
+
+ gboolean async_connect_waiting;
+ gboolean blocking;
+
+ gboolean cancel_open;
+ LmCallback *auth_cb;
+
+ LmCallback *disconnect_cb;
+
+ LmMessageQueue *queue;
+
+ LmConnectionState state;
+
+ guint keep_alive_rate;
+ GSource *keep_alive_source;
+
+ gint ref_count;
+};
+
+typedef enum {
+ AUTH_TYPE_PLAIN = 1,
+ AUTH_TYPE_DIGEST = 2,
+ AUTH_TYPE_0K = 4
+} AuthType;
+
+#define XMPP_NS_BIND "urn:ietf:params:xml:ns:xmpp-bind"
+#define XMPP_NS_SESSION "urn:ietf:params:xml:ns:xmpp-session"
+#define XMPP_NS_STARTTLS "urn:ietf:params:xml:ns:xmpp-tls"
+
+static void connection_free (LmConnection *connection);
+
+
+static void connection_handle_message (LmConnection *connection,
+ LmMessage *message);
+
+static void connection_new_message_cb (LmParser *parser,
+ LmMessage *message,
+ LmConnection *connection);
+static gboolean connection_do_open (LmConnection *connection,
+ GError **error);
+void connection_do_close (LmConnection *connection);
+
+
+static LmMessage * connection_create_auth_req_msg (const gchar *username);
+static LmMessage * connection_create_auth_msg (LmConnection *connection,
+ const gchar *username,
+ const gchar *password,
+ const gchar *resource,
+ gint auth_type);
+static LmHandlerResult connection_auth_req_reply (LmMessageHandler *handler,
+ LmConnection *connection,
+ LmMessage *m,
+ gpointer user_data);
+static int connection_check_auth_type (LmMessage *auth_req_rpl);
+
+static LmHandlerResult
+connection_auth_reply (LmMessageHandler *handler,
+ LmConnection *connection,
+ LmMessage *m,
+ gpointer user_data);
+
+static void connection_stream_received (LmConnection *connection,
+ LmMessage *m);
+static void connection_stream_error (LmConnection *connection,
+ LmMessage *m);
+
+static gint connection_handler_compare_func (HandlerData *a,
+ HandlerData *b);
+static gboolean connection_send_keep_alive (LmConnection *connection);
+static void connection_start_keep_alive (LmConnection *connection);
+static void connection_stop_keep_alive (LmConnection *connection);
+static gboolean connection_send (LmConnection *connection,
+ const gchar *str,
+ gint len,
+ GError **error);
+static void connection_message_queue_cb (LmMessageQueue *queue,
+ LmConnection *connection);
+static void connection_signal_disconnect (LmConnection *connection,
+ LmDisconnectReason reason);
+static void connection_incoming_data (LmSocket *socket,
+ const gchar *buf,
+ LmConnection *connection);
+static void connection_socket_closed_cb (LmSocket *socket,
+ LmDisconnectReason reason,
+ LmConnection *connection);
+static void connection_socket_connect_cb (LmSocket *socket,
+ gboolean result,
+ LmConnection *connection);
+
+static gboolean connection_get_server_from_jid (const gchar *jid,
+ gchar **server);
+static void connection_send_stream_header (LmConnection *connection);
+static LmHandlerResult connection_features_cb (LmMessageHandler *handler,
+ LmConnection *connection,
+ LmMessage *message,
+ gpointer user_data);
+
+static void
+connection_free (LmConnection *connection)
+{
+ int i;
+
+ g_free (connection->server);
+ g_free (connection->jid);
+ g_free (connection->effective_jid);
+ g_free (connection->stream_id);
+ g_free (connection->resource);
+
+ if (connection->sasl) {
+ lm_sasl_free (connection->sasl);
+ }
+
+ if (connection->parser) {
+ lm_parser_free (connection->parser);
+ }
+
+ /* Unref handlers */
+ for (i = 0; i < LM_MESSAGE_TYPE_UNKNOWN; ++i) {
+ GSList *l;
+
+ for (l = connection->handlers[i]; l; l = l->next) {
+ HandlerData *hd = (HandlerData *) l->data;
+
+ lm_message_handler_unref (hd->handler);
+ g_free (hd);
+ }
+
+ g_slist_free (connection->handlers[i]);
+ }
+
+ g_hash_table_destroy (connection->id_handlers);
+ if (connection->state >= LM_CONNECTION_STATE_OPENING) {
+ connection_do_close (connection);
+ }
+
+ if (connection->open_cb) {
+ _lm_utils_free_callback (connection->open_cb);
+ }
+
+ if (connection->auth_cb) {
+ _lm_utils_free_callback (connection->auth_cb);
+ }
+
+ lm_connection_set_disconnect_function (connection, NULL, NULL, NULL);
+
+ if (connection->proxy) {
+ lm_proxy_unref (connection->proxy);
+ }
+
+ lm_message_queue_unref (connection->queue);
+
+ if (connection->context) {
+ g_main_context_unref (connection->context);
+ }
+
+ if (connection->socket) {
+ lm_socket_unref (connection->socket);
+ }
+
+ g_free (connection);
+}
+
+static void
+connection_handle_message (LmConnection *connection, LmMessage *m)
+{
+ LmMessageHandler *handler;
+ GSList *l;
+ const gchar *id;
+ LmHandlerResult result = LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
+
+ lm_connection_ref (connection);
+ lm_verbose("[connection_handle_message]: Inside\n");
+ lm_verbose("msg type:[%d]\n", lm_message_get_type (m));
+ id = lm_message_node_get_attribute (m->node, "id");
+ if(id)
+ {
+ lm_verbose("handlemsg node id: %s\n", id);
+ }
+ if (lm_message_get_type (m) == LM_MESSAGE_TYPE_STREAM) {
+ lm_verbose("[connection_handle_message]: Stream received\n");
+ lm_verbose("[connection_handle_message]: calling connection_stream_received \n");
+ connection_stream_received (connection, m);
+ lm_verbose("[connection_handle_message]: CALLED connection_stream_received \n");
+ goto out;
+ }
+
+ if ((lm_message_get_sub_type (m) == LM_MESSAGE_SUB_TYPE_ERROR) ||
+ (lm_message_get_sub_type (m) == LM_MESSAGE_SUB_TYPE_RESULT)) {
+ id = lm_message_node_get_attribute (m->node, "id");
+
+ lm_verbose("[connection_handle_message]: type is error or result \n");
+ if (id) {
+ handler = g_hash_table_lookup (connection->id_handlers, id);
+ if (handler) {
+ lm_verbose("[connection_handle_message]: calling the right handler for error/result \n");
+ result = _lm_message_handler_handle_message (handler,
+ connection,
+ m);
+ lm_verbose("[connection_handle_message]: Called right handler for error/result \n");
+ g_hash_table_remove (connection->id_handlers,
+ id);
+ }
+ }
+
+ if (result == LM_HANDLER_RESULT_REMOVE_MESSAGE) {
+ lm_verbose("return from connection_handle_message\n");
+ goto out;
+ }
+ }
+ lm_verbose("[connection_handle_message]:starting for loop for more handlers\n");
+ for (l = connection->handlers[lm_message_get_type (m)];
+ l && result == LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
+ l = l->next) {
+ HandlerData *hd = (HandlerData *) l->data;
+ lm_verbose("[connection_handle_message]:inside for loop for more handlers with msg type: %d\n", lm_message_get_type (m));
+ lm_verbose("[connection_handle_message]:inside for loop with node name: %s\n",lm_message_get_node(m)->name);
+ result = _lm_message_handler_handle_message (hd->handler,
+ connection,
+ m);
+ lm_verbose("[connection_handle_message]:got result from _lm_message_handler_handle_message as :%d\n",result);
+ }
+ lm_verbose("[connection_handle_message]:Ended for loop for more handlers\n");
+ if (lm_message_get_type (m) == LM_MESSAGE_TYPE_STREAM_ERROR) {
+ lm_verbose("[connection_handle_message]:stream error\n");
+ connection_stream_error (connection, m);
+ goto out;
+ }
+
+out:
+ lm_verbose("[connection_handle_message]:exiting connection_handle_message\n");
+ lm_connection_unref (connection);
+ lm_verbose("[connection_handle_message]:after unref of connection\n");
+ return;
+}
+
+static void
+connection_new_message_cb (LmParser *parser,
+ LmMessage *m,
+ LmConnection *connection)
+{
+ const gchar *from;
+
+ lm_message_ref (m);
+
+ from = lm_message_node_get_attribute (m->node, "from");
+ if (!from) {
+ from = "unknown";
+ }
+
+ lm_verbose ("New message with type=\"%s\" from: %s\n",
+ _lm_message_type_to_string (lm_message_get_type (m)),
+ from);
+
+ lm_message_queue_push_tail (connection->queue, m);
+ UNUSED_FORMAL_PARAM(parser);
+}
+
+static gboolean
+connection_send_keep_alive (LmConnection *connection)
+{
+ lm_verbose ("[connection_send_keep_alive]\n");
+ if (!connection_send (connection, " ", -1, NULL)) {
+ lm_verbose ("Error while sending keep alive package!\n");
+ }
+ return TRUE;
+}
+
+static void
+connection_start_keep_alive (LmConnection *connection)
+{
+ lm_verbose("[connection_start_keep_alive]:Inside ....");
+ /* try using TCP keepalives if possible */
+ if ((connection->keep_alive_rate > 0) &&
+ lm_socket_set_keepalive (connection->socket,
+ connection->keep_alive_rate)) {
+ lm_verbose("[connection_start_keep_alive]: timer already active\n");
+ connection->keep_alive_source =
+ lm_misc_add_timeout (connection->context,
+ connection->keep_alive_rate * 1000,
+ (GSourceFunc) connection_send_keep_alive,
+ connection);
+ return;
+ }
+
+ if (connection->keep_alive_source) {
+ lm_verbose("[connection_start_keep_alive]:stopping keep alive timer");
+ connection_stop_keep_alive (connection);
+ }
+
+ if (connection->keep_alive_rate > 0) {
+ connection->keep_alive_source =
+ lm_misc_add_timeout (connection->context,
+ connection->keep_alive_rate * 1000,
+ (GSourceFunc) connection_send_keep_alive,
+ connection);
+ lm_verbose("[connection_start_keep_alive]: added timer to gsource\n");
+ }
+lm_verbose("[connection_start_keep_alive]: ...Exiting connection_start_keep_alive....");
+}
+
+static void
+connection_stop_keep_alive (LmConnection *connection)
+{
+ lm_verbose("[connection_start_keep_alive]:Stopping Keep Alive\n");
+ if (connection->keep_alive_source) {
+ g_source_destroy (connection->keep_alive_source);
+ }
+
+ connection->keep_alive_source = NULL;
+}
+
+static gboolean
+connection_send (LmConnection *connection,
+ const gchar *str,
+ gint len,
+ GError **error)
+{
+ gint b_written;
+
+ if (connection->state < LM_CONNECTION_STATE_OPENING) {
+ /* g_log (LM_LOG_DOMAIN,LM_LOG_LEVEL_NET,
+ "Connection is not open.\n");
+
+ g_set_error (error,
+ LM_ERROR,
+ LM_ERROR_CONNECTION_NOT_OPEN,
+ "Connection is not open, call lm_connection_open() first");*/
+ lm_verbose("[connection_send]: Connection is not open call lm_connection_open() first");
+ return FALSE;
+ }
+
+ if (len == -1) {
+ len = strlen (str);
+ }
+
+ //g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET, "\nSEND:\n");
+ //g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET,
+ // "-----------------------------------\n");
+ //g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET, "%s\n", str);
+ //g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET,
+ // "-----------------------------------\n");
+ lm_verbose ( "\n[connection_send]: SEND:\n");
+ lm_verbose ( "-----------------------------------\n");
+ lm_verbose ( "%s\n", str);
+ lm_verbose ( "-----------------------------------\n");
+
+ /* Check to see if there already is an output buffer, if so, add to the
+ buffer and return */
+
+ if (lm_socket_output_is_buffered (connection->socket, str, len)) {
+ return TRUE;
+ }
+
+ b_written = lm_socket_do_write (connection->socket, str, len);
+
+ lm_verbose("[connection_send]: number of bytes written using lm_socket_do_write is : %d\n",b_written);
+ if (b_written < 0) {
+ lm_verbose("[connection_send]: Since b_written<0 closing the connection\n");
+ connection_do_close (connection);
+ connection_signal_disconnect (connection,
+ LM_DISCONNECT_REASON_ERROR);
+ g_set_error (error,
+ LM_ERROR,
+ LM_ERROR_CONNECTION_FAILED,
+ "Server closed the connection");
+ return FALSE;
+ }
+
+ if (b_written < len) {
+ lm_socket_setup_output_buffer (connection->socket,
+ str + b_written,
+ len - b_written);
+ }
+
+ return TRUE;
+}
+
+static void
+connection_message_queue_cb (LmMessageQueue *queue, LmConnection *connection)
+{
+ LmMessage *m;
+
+ m = lm_message_queue_pop_nth (connection->queue, 0);
+
+ if (m) {
+ lm_verbose("In connection_message_queue_cb\n");
+ connection_handle_message (connection, m);
+ lm_message_unref (m);
+ lm_verbose("After un refing the message\n");
+ }
+ UNUSED_FORMAL_PARAM(queue);
+}
+
+/* Returns directly */
+/* Setups all data needed to start the connection attempts */
+static gboolean
+connection_do_open (LmConnection *connection, GError **error)
+{
+ gchar *domain = NULL;
+
+ if (lm_connection_is_open (connection)) {
+ g_set_error (error,
+ LM_ERROR,
+ LM_ERROR_CONNECTION_NOT_OPEN,
+ "Connection is already open, call lm_connection_close() first");
+ return FALSE;
+ }
+
+ if (!connection_get_server_from_jid (connection->jid, &domain)) {
+ domain = g_strdup (connection->server);
+ }
+
+ lm_verbose ("[connection_do_open]: Connecting to: %s:%d\n", connection->server, connection->port);
+
+ connection->socket = lm_socket_create (connection->context,
+ (IncomingDataFunc) connection_incoming_data,
+ (SocketClosedFunc) connection_socket_closed_cb,
+ (ConnectResultFunc) connection_socket_connect_cb,
+ connection,
+ connection,
+ connection->blocking,
+ connection->server,
+ domain,
+ connection->port,
+ connection->ssl,
+ connection->proxy,
+ error);
+
+ g_free (domain);
+ lm_verbose ("[connection_do_open]: after lm_socket_create call in connection_do_open");
+
+ if (!connection->socket) {
+ return FALSE;
+ }
+
+ lm_message_queue_attach (connection->queue, connection->context);
+
+ connection->state = LM_CONNECTION_STATE_OPENING;
+ connection->async_connect_waiting = FALSE;
+
+ return TRUE;
+}
+
+void
+connection_do_close (LmConnection *connection)
+{
+ connection_stop_keep_alive (connection);
+
+ if (connection->socket) {
+ lm_socket_close (connection->socket);
+ }
+
+ lm_message_queue_detach (connection->queue);
+
+ if (!lm_connection_is_open (connection)) {
+ /* lm_connection_is_open is FALSE for state OPENING as well */
+ connection->state = LM_CONNECTION_STATE_CLOSED;
+ connection->async_connect_waiting = FALSE;
+ return;
+ }
+
+ connection->state = LM_CONNECTION_STATE_CLOSED;
+ connection->async_connect_waiting = FALSE;
+ if (connection->ssl) {
+ _lm_ssl_close (connection->ssl);
+ }
+
+ if (connection->sasl) {
+ lm_sasl_free (connection->sasl);
+ connection->sasl = NULL;
+ }
+}
+
+typedef struct {
+ gchar *username;
+ gchar *password;
+ gchar *resource;
+} AuthReqData;
+
+static void
+auth_req_data_free (AuthReqData *data)
+{
+ g_free (data->username);
+ g_free (data->password);
+ g_free (data->resource);
+ g_free (data);
+}
+
+static LmMessage *
+connection_create_auth_req_msg (const gchar *username)
+{
+ LmMessage *m;
+ LmMessageNode *q_node;
+
+ m = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_IQ,
+ LM_MESSAGE_SUB_TYPE_GET);
+ q_node = lm_message_node_add_child (m->node, "query", NULL);
+ lm_message_node_set_attributes (q_node,
+ "xmlns", "jabber:iq:auth",
+ NULL);
+ lm_message_node_add_child (q_node, "username", username);
+
+ return m;
+}
+
+static LmMessage *
+connection_create_auth_msg (LmConnection *connection,
+ const gchar *username,
+ const gchar *password,
+ const gchar *resource,
+ gint auth_type)
+{
+ LmMessage *auth_msg;
+ LmMessageNode *q_node;
+
+ auth_msg = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_IQ,
+ LM_MESSAGE_SUB_TYPE_SET);
+
+ q_node = lm_message_node_add_child (auth_msg->node, "query", NULL);
+
+ lm_message_node_set_attributes (q_node,
+ "xmlns", "jabber:iq:auth",
+ NULL);
+
+ lm_message_node_add_child (q_node, "username", username);
+
+ if (auth_type & AUTH_TYPE_0K) {
+ lm_verbose ("Using 0k auth (not implemented yet)\n");
+ /* TODO: Should probably use this? */
+ }
+
+ if (auth_type & AUTH_TYPE_DIGEST) {
+ gchar *str;
+ const gchar *digest;
+
+ lm_verbose ("Using digest\n");
+ str = g_strconcat (connection->stream_id, password, NULL);
+ digest = lm_sha_hash (str);
+ g_free (str);
+ lm_message_node_add_child (q_node, "digest", digest);
+ }
+ else if (auth_type & AUTH_TYPE_PLAIN) {
+ lm_verbose ("Using plaintext auth\n");
+ lm_message_node_add_child (q_node, "password", password);
+ } else {
+ /* TODO: Report error somehow */
+ }
+
+ lm_message_node_add_child (q_node, "resource", resource);
+
+ return auth_msg;
+}
+
+static LmHandlerResult
+connection_auth_req_reply (LmMessageHandler *handler,
+ LmConnection *connection,
+ LmMessage *m,
+ gpointer user_data)
+{
+ int auth_type;
+ LmMessage *auth_msg;
+ LmMessageHandler *auth_handler;
+ AuthReqData *data = (AuthReqData *) user_data;
+ gboolean result;
+
+ auth_type = connection_check_auth_type (m);
+
+ auth_msg = connection_create_auth_msg (connection,
+ data->username,
+ data->password,
+ data->resource,
+ auth_type);
+
+ auth_handler = lm_message_handler_new (connection_auth_reply,
+ NULL, NULL);
+ result = lm_connection_send_with_reply (connection, auth_msg,
+ auth_handler, NULL);
+ lm_message_handler_unref (auth_handler);
+ lm_message_unref (auth_msg);
+ UNUSED_FORMAL_PARAM(handler);
+ UNUSED_FORMAL_PARAM(user_data);
+ return LM_HANDLER_RESULT_REMOVE_MESSAGE;
+}
+
+static int
+connection_check_auth_type (LmMessage *auth_req_rpl)
+{
+ LmMessageNode *q_node;
+ gint ret_val = 0;
+
+ q_node = lm_message_node_get_child (auth_req_rpl->node, "query");
+
+ if (!q_node) {
+ return AUTH_TYPE_PLAIN;
+ }
+
+ if (lm_message_node_get_child (q_node, "password")) {
+ ret_val |= AUTH_TYPE_PLAIN;
+ }
+
+ if (lm_message_node_get_child (q_node, "digest")) {
+ ret_val |= AUTH_TYPE_DIGEST;
+ }
+
+ if (lm_message_node_get_child (q_node, "sequence") &&
+ lm_message_node_get_child (q_node, "token")) {
+ ret_val |= AUTH_TYPE_0K;
+ }
+
+ return ret_val;
+}
+
+static LmHandlerResult
+connection_auth_reply (LmMessageHandler *handler,
+ LmConnection *connection,
+ LmMessage *m,
+ gpointer user_data)
+{
+ const gchar *type;
+ gboolean result = TRUE;
+
+ g_return_val_if_fail (connection != NULL,
+ LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS);
+
+
+ type = lm_message_node_get_attribute (m->node, "type");
+ if (strcmp (type, "result") == 0) {
+ result = TRUE;
+ connection->state = LM_CONNECTION_STATE_AUTHENTICATED;
+ }
+ else if (strcmp (type, "error") == 0) {
+ result = FALSE;
+ connection->state = LM_CONNECTION_STATE_OPEN;
+ }
+
+ lm_verbose ("AUTH reply: %d\n", result);
+
+ if (connection->auth_cb) {
+ LmCallback *cb = connection->auth_cb;
+
+ connection->auth_cb = NULL;
+
+ if (cb->func) {
+ (* ((LmResultFunction) cb->func)) (connection,
+ result, cb->user_data);
+ }
+
+ _lm_utils_free_callback (cb);
+ }
+ UNUSED_FORMAL_PARAM(handler);
+ UNUSED_FORMAL_PARAM(user_data);
+ return LM_HANDLER_RESULT_REMOVE_MESSAGE;
+}
+
+
+static LmHandlerResult
+_lm_connection_starttls_cb (LmMessageHandler *handler,
+ LmConnection *connection,
+ LmMessage *message,
+ gpointer user_data)
+{
+ if (lm_socket_starttls (connection->socket)) {
+ connection->tls_started = TRUE;
+ connection_send_stream_header (connection);
+ } else {
+ connection_do_close (connection);
+ connection_signal_disconnect (connection,
+ LM_DISCONNECT_REASON_ERROR);
+ }
+ UNUSED_FORMAL_PARAM(message);
+ UNUSED_FORMAL_PARAM(handler);
+ UNUSED_FORMAL_PARAM(user_data);
+ return LM_HANDLER_RESULT_REMOVE_MESSAGE;
+}
+
+static void
+connection_stream_received (LmConnection *connection, LmMessage *m)
+{
+ gboolean result;
+ const char *xmpp_version;
+
+ g_return_if_fail (connection != NULL);
+ g_return_if_fail (m != NULL);
+
+ connection->stream_id = g_strdup (lm_message_node_get_attribute (m->node,
+ "id"));;
+
+ xmpp_version = lm_message_node_get_attribute (m->node, "version");
+ if (xmpp_version && strcmp (xmpp_version, "1.0") == 0) {
+ lm_verbose ("[connection_stream_received]: XMPP 1.0 stream received: %s\n",
+ connection->stream_id);
+
+ connection->use_sasl = TRUE;
+
+ /* stream is started multiple times, but we only want
+ * one sasl mechanism */
+ if (!connection->sasl)
+ connection->sasl = lm_sasl_new(connection);
+
+ /* if we'd like to use tls and we didn't already start
+ * it, prepare for it now */
+ if (connection->ssl &&
+ lm_ssl_get_use_starttls (connection->ssl) &&
+ !connection->starttls_cb) {
+ lm_verbose("[connction_stream_received]: Starttls called");
+ connection->starttls_cb =
+ lm_message_handler_new (_lm_connection_starttls_cb,
+ NULL, NULL);
+ lm_connection_register_message_handler (connection,
+ connection->starttls_cb,
+ LM_MESSAGE_TYPE_PROCEED,
+ LM_HANDLER_PRIORITY_FIRST);
+ }
+ } else {
+ lm_verbose ("Old Jabber stream received: %s\n",
+ connection->stream_id);
+ }
+
+ if (connection->state < LM_CONNECTION_STATE_OPEN) {
+ connection->state = LM_CONNECTION_STATE_OPEN;
+ }
+
+ /* Check to see if the stream is correctly set up */
+ result = TRUE;
+
+// connection_start_keep_alive (connection); //prima
+
+ if (connection->open_cb) {
+ LmCallback *cb = connection->open_cb;
+
+ connection->open_cb = NULL;
+
+ if (cb->func) {
+ (* ((LmResultFunction) cb->func)) (connection, result,
+ cb->user_data);
+ }
+ _lm_utils_free_callback (cb);
+ }
+}
+
+static void
+connection_stream_error (LmConnection *connection, LmMessage *m)
+{
+ LmMessageNode *node, *reason_node;
+ LmDisconnectReason reason;
+
+ g_return_if_fail (connection != NULL);
+ g_return_if_fail (m != NULL);
+
+ node = m->node;
+
+ /* Resource conflict */
+ reason_node = lm_message_node_get_child (node, "conflict");
+ if (reason_node) {
+ lm_verbose ("Stream error: Conflict (resource connected elsewhere)\n");
+ reason = LM_DISCONNECT_REASON_RESOURCE_CONFLICT;
+ return;
+ }
+
+ /* XML is crack */
+ reason_node = lm_message_node_get_child (node, "xml-not-well-formed");
+ if (reason_node) {
+ lm_verbose ("Stream error: XML not well formed\n");
+ reason = LM_DISCONNECT_REASON_INVALID_XML;
+ return;
+ }
+
+ lm_verbose ("Stream error: Unrecognised error\n");
+ reason = LM_DISCONNECT_REASON_ERROR;
+ connection->stream_id = g_strdup (lm_message_node_get_attribute (m->node,
+ "id"));;
+ connection_do_close (connection);
+ connection_signal_disconnect (connection, reason);
+}
+
+static gint
+connection_handler_compare_func (HandlerData *a, HandlerData *b)
+{
+ return b->priority - a->priority;
+}
+
+static void
+connection_signal_disconnect (LmConnection *connection,
+ LmDisconnectReason reason)
+{
+ lm_verbose ("[connection_signal_disconnect]\n");
+ if (connection->disconnect_cb && connection->disconnect_cb->func) {
+
+ LmCallback *cb = connection->disconnect_cb;
+ lm_verbose("[connection_signal_disconnect]: ...disconnecting\n");
+ lm_connection_ref (connection);
+ (* ((LmDisconnectFunction) cb->func)) (connection,
+ reason,
+ cb->user_data);
+ lm_connection_unref (connection);
+ lm_verbose("[connection_signal_disconnect]: ...after unref\n");
+ }
+}
+
+static void
+connection_incoming_data (LmSocket *socket,
+ const gchar *buf,
+ LmConnection *connection)
+{
+ lm_parser_parse (connection->parser, buf);
+ UNUSED_FORMAL_PARAM(socket);
+}
+
+static void
+connection_socket_closed_cb (LmSocket *socket,
+ LmDisconnectReason reason,
+ LmConnection *connection)
+{
+ lm_verbose("[connection_socket_closed_cb]: inside..\n");
+ connection_do_close (connection);
+ connection_signal_disconnect (connection, reason);
+ lm_verbose("[connection_socket_closed_cb]: exiting..\n");
+ UNUSED_FORMAL_PARAM(socket);
+}
+
+static void
+connection_socket_connect_cb (LmSocket *socket,
+ gboolean result,
+ LmConnection *connection)
+{
+ if (!result) {
+ connection_do_close (connection);
+ lm_verbose ("[connection_socket_connect_cb]: result false ");
+ if (connection->open_cb) {
+ LmCallback *cb = connection->open_cb;
+ lm_verbose ("[connection_socket_connect_cb]: connection->open_cb is defined ");
+
+ connection->open_cb = NULL;
+
+ (* ((LmResultFunction) cb->func)) (connection, FALSE,
+ cb->user_data);
+ _lm_utils_free_callback (cb);
+ }
+
+ UNUSED_FORMAL_PARAM(socket);
+ return;
+ }
+
+ /* FIXME: Set up according to XMPP 1.0 specification */
+ /* StartTLS and the like */
+ if (!connection_send (connection,
+ "<?xml version='1.0' encoding='UTF-8'?>", -1,
+ NULL)) {
+ lm_verbose ("Failed to send xml version and encoding\n");
+ connection_do_close (connection);
+
+ return;
+ }
+
+ connection_send_stream_header (connection);
+ lm_verbose("\n[connection_socket_connect_cb]: exiting ");
+}
+
+static gboolean
+connection_get_server_from_jid (const gchar *jid,
+ gchar **server)
+{
+ gchar *ch;
+ gchar *ch_end;
+
+ if (jid != NULL && (ch = strchr (jid, '@')) != NULL) {
+ ch_end = strchr(ch + 1, '/');
+ if (ch_end != NULL) {
+ *server = g_strndup (ch + 1, ch_end - ch - 1);
+ } else {
+ *server = g_strdup (ch + 1);
+ }
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static void
+connection_send_stream_header (LmConnection *connection)
+{
+ LmMessage *m;
+ gchar *server_from_jid;
+
+ lm_verbose ("Sending stream header\n");
+
+ if (!connection_get_server_from_jid (connection->jid, &server_from_jid)) {
+ server_from_jid = g_strdup (connection->server);
+ }
+
+ m = lm_message_new (server_from_jid, LM_MESSAGE_TYPE_STREAM);
+ lm_message_node_set_attributes (m->node,
+ "xmlns:stream",
+ "http://etherx.jabber.org/streams",
+ "xmlns", "jabber:client",
+ "version", "1.0",
+ NULL);
+
+ g_free (server_from_jid);
+
+ if (!lm_connection_send (connection, m, NULL)) {
+ lm_verbose ("Failed to send stream information\n");
+ connection_do_close (connection);
+ }
+ connection_start_keep_alive (connection); //prima
+ lm_message_unref (m);
+ lm_verbose("\n[connection_send_stream_header]: Exiting send stream header method");
+}
+
+gboolean
+_lm_connection_async_connect_waiting (LmConnection *connection)
+{
+ return connection->async_connect_waiting;
+}
+
+void
+_lm_connection_set_async_connect_waiting (LmConnection *connection,
+ gboolean waiting)
+{
+ connection->async_connect_waiting = waiting;
+}
+
+static void
+connection_call_auth_cb (LmConnection *connection, gboolean success)
+{
+ if (success) {
+ lm_verbose("connection_call_auth_cb: authenticated\n");
+ connection->state = LM_CONNECTION_STATE_AUTHENTICATED;
+ } else {
+ lm_verbose("connection_call_auth_cb: conn still open\n");
+ connection->state = LM_CONNECTION_STATE_OPEN;
+ }
+
+ if (connection->auth_cb) {
+ LmCallback *cb = connection->auth_cb;
+
+ connection->auth_cb = NULL;
+
+ if (cb->func) {
+ lm_verbose("connection_call_auth_cb: calling the test code's registered cb method\n");
+ (* ((LmResultFunction) cb->func)) (connection,
+ success,
+ cb->user_data);
+ }
+
+ _lm_utils_free_callback (cb);
+ }
+}
+
+static LmHandlerResult
+connection_bind_reply (LmMessageHandler *handler,
+ LmConnection *connection,
+ LmMessage *message,
+ gpointer user_data)
+{
+ LmMessage *m;
+ LmMessageNode *session_node;
+ LmMessageNode *jid_node;
+ int result;
+ LmMessageSubType type;
+ lm_verbose("[connection_bind_reply]: inside connection_bind_reply\n");
+ type = lm_message_get_sub_type (message);
+ if (type == LM_MESSAGE_SUB_TYPE_ERROR) {
+ /*g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_SASL,
+ "%s: error while binding to resource\n", G_STRFUNC);*/
+ lm_verbose("[connection_bind_reply]: calling connection_call_auth_cb\n");
+ connection_call_auth_cb (connection, FALSE);
+ lm_verbose("[connection_bind_reply]: called connection_call_auth_cb\n");
+ UNUSED_FORMAL_PARAM(user_data);
+ UNUSED_FORMAL_PARAM(handler);
+ return LM_HANDLER_RESULT_REMOVE_MESSAGE;
+ }
+
+ /* use whatever server returns as our effective jid */
+ jid_node = lm_message_node_find_child (message->node, "jid");
+ if (jid_node) {
+ g_free (connection->effective_jid);
+ connection->effective_jid = g_strdup
+ (lm_message_node_get_value (jid_node));
+ }
+
+
+ m = lm_message_new_with_sub_type (NULL,
+ LM_MESSAGE_TYPE_IQ,
+ LM_MESSAGE_SUB_TYPE_SET);
+
+ lm_verbose("[connection_bind_reply]: Creation session child node\n");
+ session_node = lm_message_node_add_child (m->node, "session", NULL);
+ lm_message_node_set_attributes (session_node,
+ "xmlns", XMPP_NS_SESSION,
+ NULL);
+ lm_verbose("[connection_bind_reply]: Sending session child node\n");
+ result = lm_connection_send (connection, m, NULL);
+ lm_message_unref (m);
+ if (result < 0) {
+ connection_do_close (connection);
+ }
+
+ /* We may finally tell the client they're authorized */
+ connection_call_auth_cb (connection, TRUE);
+
+ return LM_HANDLER_RESULT_REMOVE_MESSAGE;
+}
+
+static LmHandlerResult
+connection_features_cb (LmMessageHandler *handler,
+ LmConnection *connection,
+ LmMessage *message,
+ gpointer user_data)
+{
+ LmMessageNode *bind_node;
+ LmMessageNode *starttls_node;
+ LmMessageNode *old_auth;
+ lm_verbose("[connection_features_cb] inside..\n");
+
+ starttls_node = lm_message_node_find_child (message->node, "starttls");
+ if (connection->ssl && lm_ssl_get_use_starttls (connection->ssl)) {
+ if (starttls_node) {
+ LmMessage *msg;
+
+ msg = lm_message_new (NULL, LM_MESSAGE_TYPE_STARTTLS);
+
+ lm_message_node_set_attributes (
+ msg->node,
+ "xmlns", XMPP_NS_STARTTLS,
+ NULL);
+
+ lm_connection_send (connection, msg, NULL);
+ lm_message_unref (msg);
+
+ return LM_HANDLER_RESULT_REMOVE_MESSAGE;
+ } else if (!connection->tls_started &&
+ lm_ssl_get_require_starttls (connection->ssl)) {
+ /* If there were no starttls features present and we require it, this is
+ * the place to scream. */
+ lm_verbose("connection_features_cb: Required StartTLS feature not supported by server\n");
+
+ /*g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_SASL,
+ "%s: required StartTLS feature not supported by server\n", G_STRFUNC);*/
+ connection_do_close (connection);
+ connection_signal_disconnect (connection,
+ LM_DISCONNECT_REASON_ERROR);
+ UNUSED_FORMAL_PARAM(user_data);
+ UNUSED_FORMAL_PARAM(handler);
+ return LM_HANDLER_RESULT_REMOVE_MESSAGE;
+ }
+ }
+
+ bind_node = lm_message_node_find_child (message->node, "bind");
+ if (bind_node) {
+ LmMessageHandler *bind_handler;
+ LmMessage *bind_msg;
+ const gchar *ns;
+ int result;
+
+ lm_verbose("connection_features_cb: found bind node\n");
+ ns = lm_message_node_get_attribute (bind_node, "xmlns");
+ if (!ns || strcmp (ns, XMPP_NS_BIND) != 0) {
+ return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
+ }
+
+ bind_msg = lm_message_new_with_sub_type (NULL,
+ LM_MESSAGE_TYPE_IQ,
+ LM_MESSAGE_SUB_TYPE_SET);
+
+ bind_node = lm_message_node_add_child (bind_msg->node,
+ "bind", NULL);
+ lm_message_node_set_attributes (bind_node,
+ "xmlns", XMPP_NS_BIND,
+ NULL);
+
+ lm_message_node_add_child (bind_node, "resource",
+ connection->resource);
+
+ lm_verbose("[connection_features_cb]:setting callback method for bind response\n");
+ bind_handler = lm_message_handler_new (connection_bind_reply,
+ NULL, NULL);
+ lm_verbose("[connection_features_cb]: calling lm_connection_send_with_reply for bind response\n");
+ result = lm_connection_send_with_reply (connection, bind_msg,
+ bind_handler, NULL);
+ lm_verbose("[connection_features_cb]:called lm_connection_send_with_reply for bind response with result: %d\n", result);
+ lm_message_handler_unref (bind_handler);
+ lm_message_unref (bind_msg);
+
+ if (result < 0) {
+ /*g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_SASL,
+ "%s: can't send resource binding request\n", G_STRFUNC);*/
+ connection_do_close (connection);
+ }
+ }
+
+ old_auth = lm_message_node_find_child (message->node, "auth");
+ if (connection->use_sasl && old_auth) {
+ g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_SASL,
+ "Server uses XEP-0078 (jabber iq auth) instead of SASL\n");
+ /* So the server is XMPP1.0, but doesn't support SASL and uses
+ * obsolete XEP-0078 instead. Let's cope. */
+
+ connection->use_sasl = FALSE;
+
+ if (connection->sasl) {
+ const gchar *user, *pass;
+
+ lm_sasl_get_auth_params (connection->sasl, &user, &pass);
+ if (user && pass) {
+ GError *error = NULL;
+ lm_verbose("[connection_features_cb]:calling _lm_connection_old_auth\n");
+ _lm_connection_old_auth (connection, user, pass,
+ connection->resource, &error);
+
+ if (error) {
+ g_error_free (error);
+ }
+ }
+
+ lm_sasl_free (connection->sasl);
+ connection->sasl = NULL;
+ }
+ }
+
+ return LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;
+}
+
+/**
+ * lm_connection_new:
+ * @server: The hostname to the server for the connection.
+ *
+ * Creates a new closed connection. To open the connection call
+ * lm_connection_open(). @server can be #NULL but must be set before calling lm_connection_open().
+ *
+ * Return value: A newly created LmConnection, should be unreffed with lm_connection_unref().
+ **/
+EXPORT_C LmConnection *
+lm_connection_new (const gchar *server)
+{
+ LmConnection *connection = NULL;
+ gint i;
+
+ lm_debug_init ();
+ _lm_sock_library_init ();
+
+ connection = g_new0 (LmConnection, 1);
+
+ if (server) {
+ connection->server = _lm_utils_hostname_to_punycode (server);
+ connection->use_srv = FALSE;
+ } else {
+ connection->server = NULL;
+ connection->use_srv = TRUE;
+ }
+
+ connection->context = NULL;
+ connection->port = LM_CONNECTION_DEFAULT_PORT;
+ connection->jid = NULL;
+ connection->effective_jid = NULL;
+ connection->ssl = NULL;
+ connection->proxy = NULL;
+ connection->disconnect_cb = NULL;
+ connection->queue = lm_message_queue_new ((LmMessageQueueCallback) connection_message_queue_cb,
+ connection);
+ connection->cancel_open = FALSE;
+ connection->state = LM_CONNECTION_STATE_CLOSED;
+ connection->keep_alive_source = NULL;
+ connection->keep_alive_rate = 0;
+ connection->socket = NULL;
+ connection->use_sasl = FALSE;
+ connection->tls_started = FALSE;
+
+ connection->id_handlers = g_hash_table_new_full (g_str_hash,
+ g_str_equal,
+ g_free,
+ (GDestroyNotify) lm_message_handler_unref);
+ connection->ref_count = 1;
+
+ for (i = 0; i < LM_MESSAGE_TYPE_UNKNOWN; ++i) {
+ connection->handlers[i] = NULL;
+ }
+
+ connection->parser = lm_parser_new
+ ((LmParserMessageFunction) connection_new_message_cb,
+ connection, NULL);
+
+ return connection;
+}
+
+/**
+ * lm_connection_new_with_context:
+ * @server: The hostname to the server for the connection.
+ * @context: The context this connection should be running in.
+ *
+ * Creates a new closed connection running in a certain context. To open the
+ * connection call #lm_connection_open. @server can be #NULL but must be set
+ * before calling #lm_connection_open.
+ *
+ * Return value: A newly created LmConnection, should be unreffed with lm_connection_unref().
+ **/
+EXPORT_C LmConnection *
+lm_connection_new_with_context (const gchar *server, GMainContext *context)
+{
+ LmConnection *connection;
+
+ connection = lm_connection_new (server);
+ connection->context = context;
+
+ if (context) {
+ g_main_context_ref (connection->context);
+ }
+
+ return connection;
+}
+
+/**
+ * lm_connection_open:
+ * @connection: #LmConnection to open
+ * @function: Callback function that will be called when the connection is open.
+ * @user_data: User data that will be passed to @function.
+ * @notify: Function for freeing that user_data, can be NULL.
+ * @error: location to store error, or %NULL
+ *
+ * An async call to open @connection. When the connection is open @function will be called.
+ *
+ * Return value: #TRUE if everything went fine, otherwise #FALSE.
+ **/
+EXPORT_C gboolean
+lm_connection_open (LmConnection *connection,
+ LmResultFunction function,
+ gpointer user_data,
+ GDestroyNotify notify,
+ GError **error)
+{
+ lm_verbose("[lm_connection_open]: open...");
+ g_return_val_if_fail (connection != NULL, FALSE);
+
+ connection->open_cb = _lm_utils_new_callback ((gpointer)function,
+ user_data, notify);
+ connection->blocking = FALSE;
+ lm_verbose("[lm_connection_open]: calling connection_do_open...");
+ return connection_do_open (connection, error);
+}
+
+/**
+ * lm_connection_open_and_block:
+ * @connection: an #LmConnection to open
+ * @error: location to store error, or %NULL
+ *
+ * Opens @connection and waits until the stream is setup.
+ *
+ * Return value: #TRUE if no errors where encountered during opening and stream setup successfully, #FALSE otherwise.
+ **/
+EXPORT_C gboolean
+lm_connection_open_and_block (LmConnection *connection, GError **error)
+{
+ gboolean result;
+ LmConnectionState state;
+
+ g_return_val_if_fail (connection != NULL, FALSE);
+
+ connection->open_cb = NULL;
+ connection->blocking = TRUE;
+
+ result = connection_do_open (connection, error);
+
+ if (result == FALSE) {
+ return FALSE;
+ }
+
+ while ((state = lm_connection_get_state (connection)) == LM_CONNECTION_STATE_OPENING) {
+ if (g_main_context_pending (connection->context)) {
+ g_main_context_iteration (connection->context, TRUE);
+ } else {
+ /* Sleep for 1 millisecond */
+ g_usleep (1000);
+ }
+ }
+
+ if (lm_connection_is_open (connection)) {
+ connection_start_keep_alive (connection);
+ return TRUE;
+ }
+
+ /* Need to set the error here: LM-15 */
+ g_set_error (error,
+ LM_ERROR,
+ LM_ERROR_CONNECTION_FAILED,
+ "Opening the connection failed");
+
+ return FALSE;
+}
+
+/**
+ * lm_connection_cancel_open:
+ * @connection: an #LmConnection to cancel opening on
+ *
+ * Cancels the open operation of a connection. The connection should be in the state #LM_CONNECTION_STATE_OPENING.
+ **/
+EXPORT_C void
+lm_connection_cancel_open (LmConnection *connection)
+{
+ g_return_if_fail (connection != NULL);
+
+ lm_verbose("[lm_connection_cancel_open]: inside..");
+ if (connection->open_cb) {
+ _lm_utils_free_callback (connection->open_cb);
+ connection->open_cb = NULL;
+ }
+
+ connection->cancel_open = TRUE;
+
+#ifdef HAVE_ASYNCNS
+ lm_verbose("[lm_connection_cancel_open] called in HAVE_ASYNCNS");
+ _asyncns_cancel(connection->socket);
+#endif
+}
+
+/**
+ * lm_connection_close:
+ * @connection: #LmConnection to close
+ * @error: location to store error, or %NULL
+ *
+ * A synchronous call to close the connection. When returning the connection is considered to be closed and can be opened again with lm_connection_open().
+ *
+ * Return value: Returns #TRUE if no errors where detected, otherwise #FALSE.
+ **/
+EXPORT_C gboolean
+lm_connection_close (LmConnection *connection,
+ GError **error)
+{
+ gboolean no_errors = TRUE;
+
+ g_return_val_if_fail (connection != NULL, FALSE);
+
+#ifdef HAVE_ASYNCNS
+ _asyncns_cancel (connection->socket);
+#endif
+
+ if (connection->state == LM_CONNECTION_STATE_CLOSED) {
+ g_set_error (error,
+ LM_ERROR,
+ LM_ERROR_CONNECTION_NOT_OPEN,
+ "Connection is not open, call lm_connection_open() first");
+ return FALSE;
+ }
+
+ lm_verbose ("Disconnecting from: %s:%d\n",
+ connection->server, connection->port);
+
+ if (lm_connection_is_open (connection)) {
+ if (!connection_send (connection, "</stream:stream>", -1, error)) {
+ no_errors = FALSE;
+ }
+
+ lm_socket_flush (connection->socket);
+ }
+
+ connection_do_close (connection);
+ connection_signal_disconnect (connection, LM_DISCONNECT_REASON_OK);
+
+ return no_errors;
+}
+
+static void
+connection_sasl_auth_finished (LmSASL *sasl,
+ LmConnection *connection,
+ gboolean success,
+ const gchar *reason)
+{
+ if (!success) {
+ lm_verbose ("SASL authentication failed, closing connection\n");
+ connection_call_auth_cb (connection, FALSE);
+ return;
+ }
+
+ connection_send_stream_header (connection);
+ UNUSED_FORMAL_PARAM(sasl);
+ UNUSED_FORMAL_PARAM(reason);
+ lm_verbose("\n exiting SASL auth finished method");
+}
+
+/**
+ * lm_connection_authenticate:
+ * @connection: #LmConnection to authenticate.
+ * @username: Username used to authenticate.
+ * @password: Password corresponding to @username.
+ * @resource: Resource used for this connection.
+ * @function: Callback called when authentication is finished.
+ * @user_data: Userdata passed to @function when called.
+ * @notify: Destroy function to free the memory used by @user_data, can be NULL.
+ * @error: location to store error, or %NULL
+ *
+ * Tries to authenticate a user against the server. The #LmResult in the result callback @function will say whether it succeeded or not.
+ *
+ * Return value: #TRUE if no errors where detected while sending the authentication message, #FALSE otherwise.
+ **/
+EXPORT_C gboolean
+lm_connection_authenticate (LmConnection *connection,
+ const gchar *username,
+ const gchar *password,
+ const gchar *resource,
+ LmResultFunction function,
+ gpointer user_data,
+ GDestroyNotify notify,
+ GError **error)
+{
+ g_return_val_if_fail (connection != NULL, FALSE);
+ g_return_val_if_fail (username != NULL, FALSE);
+ g_return_val_if_fail (password != NULL, FALSE);
+ g_return_val_if_fail (resource != NULL, FALSE);
+
+ if (!lm_connection_is_open (connection)) {
+ g_set_error (error,
+ LM_ERROR,
+ LM_ERROR_CONNECTION_NOT_OPEN,
+ "Connection is not open, call lm_connection_open() first");
+ return FALSE;
+ }
+ lm_verbose("\n[lm_connection_authenticate] inside...\n");
+ connection->state = LM_CONNECTION_STATE_AUTHENTICATING;
+
+ connection->auth_cb = _lm_utils_new_callback ((gpointer)function,
+ user_data,
+ notify);
+
+ connection->resource = g_strdup (resource);
+ connection->effective_jid = g_strdup_printf ("%s/%s",
+ connection->jid, connection->resource);
+
+ if (connection->use_sasl) {
+ lm_verbose("[lm_connection_authenticate]: conn->use_sasl is true. calling lm_sasl_authenticate\n");
+ lm_sasl_authenticate (connection->sasl,
+ username, password,
+ connection->server,
+ connection_sasl_auth_finished);
+
+ connection->features_cb =
+ lm_message_handler_new (connection_features_cb,
+ NULL, NULL);
+ lm_connection_register_message_handler (connection,
+ connection->features_cb,
+ LM_MESSAGE_TYPE_STREAM_FEATURES,
+ LM_HANDLER_PRIORITY_FIRST);
+
+ lm_verbose("[lm_connection_authenticate]: connection->use_sasl is true. So NOT calling create_auth_req_msg\n");
+ return TRUE;
+ }
+
+ return _lm_connection_old_auth (connection, username, password,
+ resource, error);
+}
+
+gboolean
+_lm_connection_old_auth (LmConnection *connection, const gchar *username,
+ const gchar *password, const gchar *resource, GError **error)
+{
+ LmMessage *m;
+ AuthReqData *data;
+ LmMessageHandler *handler;
+ gboolean result;
+
+
+ m = connection_create_auth_req_msg (username);
+
+ data = g_new0 (AuthReqData, 1);
+ data->username = g_strdup (username);
+ data->password = g_strdup (password);
+ data->resource = g_strdup (resource);
+
+ handler = lm_message_handler_new (connection_auth_req_reply,
+ data,
+ (GDestroyNotify) auth_req_data_free);
+ result = lm_connection_send_with_reply (connection, m, handler, error);
+
+ lm_message_handler_unref (handler);
+ lm_message_unref (m);
+
+ return result;
+}
+
+/**
+ * lm_connection_authenticate_and_block:
+ * @connection: an #LmConnection
+ * @username: Username used to authenticate.
+ * @password: Password corresponding to @username.
+ * @resource: Resource used for this connection.
+ * @error: location to store error, or %NULL
+ *
+ * Tries to authenticate a user against the server. This function blocks until a reply to the authentication attempt is returned and returns whether it was successful or not.
+ *
+ * Return value: #TRUE if no errors where detected and authentication was successful. #FALSE otherwise.
+ **/
+EXPORT_C gboolean
+lm_connection_authenticate_and_block (LmConnection *connection,
+ const gchar *username,
+ const gchar *password,
+ const gchar *resource,
+ GError **error)
+{
+ gboolean result;
+
+ result = lm_connection_authenticate (connection, username, password,
+ resource, NULL, NULL, NULL, error);
+
+ if (!result)
+ return result;
+
+ while (lm_connection_get_state (connection) == LM_CONNECTION_STATE_AUTHENTICATING) {
+ if (g_main_context_pending (connection->context)) {
+ g_main_context_iteration (connection->context, TRUE);
+ } else {
+ /* Sleep for 1 millisecond */
+ g_usleep (1000);
+ }
+ }
+
+ switch (lm_connection_get_state (connection)) {
+ case LM_CONNECTION_STATE_AUTHENTICATED:
+ return TRUE;
+ //removing compilation error : not reachable statement
+ //break;
+ case LM_CONNECTION_STATE_OPEN:
+ g_set_error (error,
+ LM_ERROR,
+ LM_ERROR_AUTH_FAILED,
+ "Authentication failed");
+ return FALSE;
+ //removing compilation error : not reachable statement
+ //break;
+ default:
+ g_assert_not_reached ();
+ break;
+ }
+
+ return FALSE;
+}
+
+/**
+ * lm_connection_get_keep_alive_rate:
+ * @connection: an #LmConnection
+ *
+ * Get the keep alive rate, in seconds. Zero is returned if no keep alive rate has been set.
+ *
+ * Since 1.3.5
+ **/
+guint
+lm_connection_get_keep_alive_rate (LmConnection *connection)
+{
+ g_return_val_if_fail (connection != NULL, 0);
+
+ return connection->keep_alive_rate;
+}
+
+/**
+ * lm_connection_set_keep_alive_rate:
+ * @connection: an #LmConnection
+ * @rate: Number of seconds between keep alive packages are sent.
+ *
+ * Set the keep alive rate, in seconds. Set to 0 to prevent keep alive messages to be sent.
+ * A keep alive message is a single space character.
+ **/
+EXPORT_C void
+lm_connection_set_keep_alive_rate (LmConnection *connection, guint rate)
+{
+ g_return_if_fail (connection != NULL);
+ lm_verbose("Setting Keep Alive Rate");
+ connection_stop_keep_alive (connection);
+
+ if (rate == 0) {
+ connection->keep_alive_source = NULL;
+ return;
+ }
+
+ connection->keep_alive_rate = rate;
+
+ if (lm_connection_is_open (connection)) {
+ connection_start_keep_alive (connection);
+ }
+}
+
+/**
+ * lm_connection_is_open:
+ * @connection: #LmConnection to check if it is open.
+ *
+ * Check if the @connection is currently open.
+ *
+ * Return value: #TRUE if connection is open and #FALSE if it is closed.
+ **/
+EXPORT_C gboolean
+lm_connection_is_open (LmConnection *connection)
+{
+ g_return_val_if_fail (connection != NULL, FALSE);
+
+ return connection->state >= LM_CONNECTION_STATE_OPEN;
+}
+
+/**
+ * lm_connection_is_authenticated:
+ * @connection: #LmConnection to check if it is authenticated
+ *
+ * Check if @connection is authenticated.
+ *
+ * Return value: #TRUE if connection is authenticated, #FALSE otherwise.
+ **/
+EXPORT_C gboolean
+lm_connection_is_authenticated (LmConnection *connection)
+{
+ g_return_val_if_fail (connection != NULL, FALSE);
+
+ return connection->state >= LM_CONNECTION_STATE_AUTHENTICATED;
+}
+
+/**
+ * lm_connection_get_server:
+ * @connection: an #LmConnection
+ *
+ * Fetches the server address that @connection is using.
+ *
+ * Return value: the server address
+ **/
+EXPORT_C const gchar *
+lm_connection_get_server (LmConnection *connection)
+{
+ g_return_val_if_fail (connection != NULL, NULL);
+
+ return connection->server;
+}
+
+/**
+ * lm_connection_set_server:
+ * @connection: an #LmConnection
+ * @server: Address of the server
+ *
+ * Sets the server address for @connection to @server. Notice that @connection
+ * can't be open while doing this.
+ **/
+EXPORT_C void
+lm_connection_set_server (LmConnection *connection, const gchar *server)
+{
+ g_return_if_fail (connection != NULL);
+ g_return_if_fail (server != NULL);
+
+ if (lm_connection_is_open (connection)) {
+ g_warning ("Can't change server address while connected");
+ return;
+ }
+
+ g_free (connection->server);
+ connection->server = _lm_utils_hostname_to_punycode (server);
+ connection->use_srv = FALSE;
+}
+
+/**
+ * lm_connection_get_jid:
+ * @connection: an #LmConnection
+ *
+ * Fetches the jid set for @connection is using.
+ *
+ * Return value: the jid
+ **/
+EXPORT_C const gchar *
+lm_connection_get_jid (LmConnection *connection)
+{
+ g_return_val_if_fail (connection != NULL, NULL);
+
+ return connection->jid;
+}
+
+/**
+ * lm_connection_get_full_jid:
+ * @connection: an #LmConnection
+ *
+ * Returns the full jid that server set for us after
+ * resource binding, complete with the resource.
+ *
+ * Return value: the jid
+ **/
+gchar *
+lm_connection_get_full_jid (LmConnection *connection)
+{
+ g_return_val_if_fail (connection != NULL, NULL);
+
+ return connection->effective_jid;
+}
+
+/**
+ * lm_connection_set_jid:
+ * @connection: an #LmConnection
+ * @jid: JID to be used for @connection
+ *
+ * Sets the JID to be used for @connection.
+ **/
+EXPORT_C void
+lm_connection_set_jid (LmConnection *connection, const gchar *jid)
+{
+ g_return_if_fail (connection != NULL);
+
+ if (lm_connection_is_open (connection)) {
+ g_warning ("Can't change JID while connected");
+ return;
+ }
+
+ g_free (connection->jid);
+ connection->jid = g_strdup (jid);
+}
+
+/**
+ * lm_connection_get_port:
+ * @connection: an #LmConnection
+ *
+ * Fetches the port that @connection is using.
+ *
+ * Return value:
+ **/
+EXPORT_C guint
+lm_connection_get_port (LmConnection *connection)
+{
+ g_return_val_if_fail (connection != NULL, 0);
+
+ return connection->port;
+}
+
+/**
+ * lm_connection_set_port:
+ * @connection: an #LmConnection
+ * @port: server port
+ *
+ * Sets the server port that @connection will be using.
+ **/
+EXPORT_C void
+lm_connection_set_port (LmConnection *connection, guint port)
+{
+ g_return_if_fail (connection != NULL);
+
+ if (lm_connection_is_open (connection)) {
+ g_warning ("Can't change server port while connected");
+ return;
+ }
+
+ connection->port = port;
+}
+
+/**
+ * lm_connection_get_ssl:
+ * @connection: an #LmConnection
+ *
+ * Returns the SSL struct if the connection is using one.
+ *
+ * Return value: The ssl struct or %NULL if no proxy is used.
+ **/
+EXPORT_C LmSSL *
+lm_connection_get_ssl (LmConnection *connection)
+{
+ g_return_val_if_fail (connection != NULL, NULL);
+
+ return connection->ssl;
+}
+
+/**
+ * lm_connection_set_ssl:
+ * @connection: An #LmConnection
+ * @ssl: An #LmSSL
+ *
+ * Sets SSL struct or unset if @ssl is %NULL. If set @connection will use SSL to for the connection.
+ */
+EXPORT_C void
+lm_connection_set_ssl (LmConnection *connection, LmSSL *ssl)
+{
+ lm_verbose("[lm_connection_set_ssl]: inside...");
+ g_return_if_fail (connection != NULL);
+ g_return_if_fail (lm_ssl_is_supported () == TRUE);
+
+ if (connection->ssl) {
+ lm_ssl_unref (connection->ssl);
+ }
+
+ if (ssl) {
+ lm_verbose("[lm_connection_set_ssl]: setting of ssl success");
+ connection->ssl = lm_ssl_ref (ssl);
+ } else {
+ lm_verbose("[lm_connection_set_ssl]: setting of ssl failed");
+ connection->ssl = NULL;
+ }
+}
+
+/**
+ * lm_connection_get_proxy:
+ * @connection: an #LmConnection
+ *
+ * Returns the proxy if the connection is using one.
+ *
+ * Return value: The proxy or %NULL if no proxy is used.
+ **/
+EXPORT_C LmProxy *
+lm_connection_get_proxy (LmConnection *connection)
+{
+ g_return_val_if_fail (connection != NULL, NULL);
+
+ return connection->proxy;
+}
+
+/**
+ * lm_connection_set_proxy:
+ * @connection: an #LmConnection
+ * @proxy: an #LmProxy
+ *
+ * Sets the proxy to use for this connection. To unset pass #NULL.
+ *
+ **/
+EXPORT_C void
+lm_connection_set_proxy (LmConnection *connection, LmProxy *proxy)
+{
+ g_return_if_fail (connection != NULL);
+
+ if (lm_connection_is_open (connection)) {
+ g_warning ("Can't change server proxy while connected");
+ return;
+ }
+
+ if (connection->proxy) {
+ lm_proxy_unref (connection->proxy);
+ connection->proxy = NULL;
+ }
+
+ if (proxy && lm_proxy_get_type (proxy) != LM_PROXY_TYPE_NONE) {
+ connection->proxy = lm_proxy_ref (proxy);
+ }
+}
+
+/**
+ * lm_connection_send:
+ * @connection: #LmConnection to send message over.
+ * @message: #LmMessage to send.
+ * @error: location to store error, or %NULL
+ *
+ * Asynchronous call to send a message.
+ *
+ * Return value: Returns #TRUE if no errors where detected while sending, #FALSE otherwise.
+ **/
+EXPORT_C gboolean
+lm_connection_send (LmConnection *connection,
+ LmMessage *message,
+ GError **error)
+{
+ gchar *xml_str;
+ gchar *ch;
+ gboolean result;
+
+ g_return_val_if_fail (connection != NULL, FALSE);
+ g_return_val_if_fail (message != NULL, FALSE);
+
+ xml_str = lm_message_node_to_string (message->node);
+ ch = strstr (xml_str, "</stream:stream>");
+ if (ch) {
+ *ch = '\0';
+ }
+
+ result = connection_send (connection, xml_str, -1, error);
+ g_free (xml_str);
+
+ return result;
+}
+
+/**
+ * lm_connection_send_with_reply:
+ * @connection: #LmConnection used to send message.
+ * @message: #LmMessage to send.
+ * @handler: #LmMessageHandler that will be used when a reply to @message arrives
+ * @error: location to store error, or %NULL
+ *
+ * Send a #LmMessage which will result in a reply.
+ *
+ * Return value: Returns #TRUE if no errors where detected while sending, #FALSE otherwise.
+ **/
+EXPORT_C gboolean
+lm_connection_send_with_reply (LmConnection *connection,
+ LmMessage *message,
+ LmMessageHandler *handler,
+ GError **error)
+{
+ gchar *id;
+
+ g_return_val_if_fail (connection != NULL, FALSE);
+ g_return_val_if_fail (message != NULL, FALSE);
+ g_return_val_if_fail (handler != NULL, FALSE);
+
+ if (lm_message_node_get_attribute (message->node, "id")) {
+ id = g_strdup (lm_message_node_get_attribute (message->node,
+ "id"));
+ } else {
+ id = _lm_utils_generate_id ();
+ lm_message_node_set_attributes (message->node, "id", id, NULL);
+ }
+
+ g_hash_table_insert (connection->id_handlers,
+ id, lm_message_handler_ref (handler));
+ lm_verbose("[lm_connection_send_with_reply]: inside..calling lm_connection_send\n");
+ return lm_connection_send (connection, message, error);
+}
+
+/**
+ * lm_connection_send_with_reply_and_block:
+ * @connection: an #LmConnection
+ * @message: an #LmMessage
+ * @error: Set if error was detected during sending.
+ *
+ * Send @message and wait for return.
+ *
+ * Return value: The reply
+ **/
+EXPORT_C LmMessage *
+lm_connection_send_with_reply_and_block (LmConnection *connection,
+ LmMessage *message,
+ GError **error)
+{
+ gchar *id;
+ LmMessage *reply = NULL;
+
+ g_return_val_if_fail (connection != NULL, NULL);
+ g_return_val_if_fail (message != NULL, NULL);
+
+ if (connection->state < LM_CONNECTION_STATE_OPENING) {
+ g_set_error (error,
+ LM_ERROR,
+ LM_ERROR_CONNECTION_NOT_OPEN,
+ "Connection is not open, call lm_connection_open() first");
+ return FALSE;
+ }
+
+
+ if (lm_message_node_get_attribute (message->node, "id")) {
+ id = g_strdup (lm_message_node_get_attribute (message->node,
+ "id"));
+ } else {
+ id = _lm_utils_generate_id ();
+ lm_message_node_set_attributes (message->node, "id", id, NULL);
+ }
+
+ lm_message_queue_detach (connection->queue);
+
+ lm_connection_send (connection, message, error);
+
+ while (!reply) {
+ const gchar *m_id;
+ guint n;
+
+ g_main_context_iteration (connection->context, TRUE);
+
+ if (lm_message_queue_is_empty (connection->queue)) {
+ continue;
+ }
+
+ for (n = 0; n < lm_message_queue_get_length (connection->queue); n++) {
+ LmMessage *m;
+
+ m = (LmMessage *) lm_message_queue_peek_nth (connection->queue, n);
+
+ m_id = lm_message_node_get_attribute (m->node, "id");
+
+ if (m_id && strcmp (m_id, id) == 0) {
+ reply = m;
+ lm_message_queue_pop_nth (connection->queue, n);
+ break;
+ }
+ }
+ }
+
+ g_free (id);
+ lm_message_queue_attach (connection->queue, connection->context);
+
+ return reply;
+}
+
+/**
+ * lm_connection_register_message_handler:
+ * @connection: Connection to register a handler for.
+ * @handler: Message handler to register.
+ * @type: Message type that @handler will handle.
+ * @priority: The priority in which to call @handler.
+ *
+ * Registers a #LmMessageHandler to handle incoming messages of a certain type.
+ * To unregister the handler call lm_connection_unregister_message_handler().
+ **/
+EXPORT_C void
+lm_connection_register_message_handler (LmConnection *connection,
+ LmMessageHandler *handler,
+ LmMessageType type,
+ LmHandlerPriority priority)
+{
+ HandlerData *hd;
+
+ g_return_if_fail (connection != NULL);
+ g_return_if_fail (handler != NULL);
+ g_return_if_fail (type != LM_MESSAGE_TYPE_UNKNOWN);
+
+ hd = g_new0 (HandlerData, 1);
+ hd->priority = priority;
+ hd->handler = lm_message_handler_ref (handler);
+
+ connection->handlers[type] = g_slist_insert_sorted (connection->handlers[type],
+ hd,
+ (GCompareFunc) connection_handler_compare_func);
+}
+
+/**
+ * lm_connection_unregister_message_handler:
+ * @connection: Connection to unregister a handler for.
+ * @handler: The handler to unregister.
+ * @type: What type of messages to unregister this handler for.
+ *
+ * Unregisters a handler for @connection. @handler will no longer be called
+ * when incoming messages of @type arrive.
+ **/
+EXPORT_C void
+lm_connection_unregister_message_handler (LmConnection *connection,
+ LmMessageHandler *handler,
+ LmMessageType type)
+{
+ GSList *l;
+
+ g_return_if_fail (connection != NULL);
+ g_return_if_fail (handler != NULL);
+ g_return_if_fail (type != LM_MESSAGE_TYPE_UNKNOWN);
+
+ for (l = connection->handlers[type]; l; l = l->next) {
+ HandlerData *hd = (HandlerData *) l->data;
+
+ if (handler == hd->handler) {
+ connection->handlers[type] = g_slist_remove_link (connection->handlers[type], l);
+ g_slist_free (l);
+ lm_message_handler_unref (hd->handler);
+ g_free (hd);
+ break;
+ }
+ }
+}
+
+/**
+ * lm_connection_set_disconnect_function:
+ * @connection: Connection to register disconnect callback for.
+ * @function: Function to be called when @connection is closed.
+ * @user_data: User data passed to @function.
+ * @notify: Function that will be called with @user_data when @user_data needs to be freed. Pass #NULL if it shouldn't be freed.
+ *
+ * Set the callback that will be called when a connection is closed.
+ **/
+EXPORT_C void
+lm_connection_set_disconnect_function (LmConnection *connection,
+ LmDisconnectFunction function,
+ gpointer user_data,
+ GDestroyNotify notify)
+{
+ g_return_if_fail (connection != NULL);
+
+ if (connection->disconnect_cb) {
+ _lm_utils_free_callback (connection->disconnect_cb);
+ }
+
+ if (function) {
+ connection->disconnect_cb = _lm_utils_new_callback ((gpointer)function,
+ user_data,
+ notify);
+ } else {
+ connection->disconnect_cb = NULL;
+ }
+}
+
+/**
+ * lm_connection_send_raw:
+ * @connection: Connection used to send
+ * @str: The string to send, the entire string will be sent.
+ * @error: Set if error was detected during sending.
+ *
+ * Asynchronous call to send a raw string. Useful for debugging and testing.
+ *
+ * Return value: Returns #TRUE if no errors was detected during sending,
+ * #FALSE otherwise.
+ **/
+EXPORT_C gboolean
+lm_connection_send_raw (LmConnection *connection,
+ const gchar *str,
+ GError **error)
+{
+ g_return_val_if_fail (connection != NULL, FALSE);
+ g_return_val_if_fail (str != NULL, FALSE);
+
+ return connection_send (connection, str, -1, error);
+}
+/**
+ * lm_connection_get_state:
+ * @connection: Connection to get state on
+ *
+ * Returns the state of the connection.
+ *
+ * Return value: The state of the connection.
+ **/
+EXPORT_C LmConnectionState
+lm_connection_get_state (LmConnection *connection)
+{
+ g_return_val_if_fail (connection != NULL,
+ LM_CONNECTION_STATE_CLOSED);
+
+ return connection->state;
+}
+
+/**
+ * lm_connection_get_client_host:
+ * @connection: An #LmConnection
+ *
+ * Returns the local host name of the connection.
+ *
+ * Return value: A newly allocated string representing the local host name.
+ **/
+gchar *
+lm_connection_get_local_host (LmConnection *connection)
+{
+ return lm_socket_get_local_host (connection->socket);
+}
+
+/**
+ * lm_connection_ref:
+ * @connection: Connection to add a reference to.
+ *
+ * Add a reference on @connection. To remove a reference call
+ * lm_connection_unref().
+ *
+ * Return value: Returns the same connection.
+ **/
+EXPORT_C LmConnection*
+lm_connection_ref (LmConnection *connection)
+{
+ g_return_val_if_fail (connection != NULL, NULL);
+
+ connection->ref_count++;
+
+ return connection;
+}
+
+/**
+ * lm_connection_unref:
+ * @connection: Connection to remove reference from.
+ *
+ * Removes a reference on @connection. If there are no references to
+ * @connection it will be freed and shouldn't be used again.
+ **/
+EXPORT_C void
+lm_connection_unref (LmConnection *connection)
+{
+ //g_return_if_fail (connection != NULL);
+ if(!connection)
+ return;
+ connection->ref_count--;
+
+ if (connection->ref_count == 0) {
+ connection_free (connection);
+ }
+}