1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */

     2 /*

     3  * Copyright (C) 2003-2007 Imendio AB

     4  *  and/or its subsidiary/subsidiaries. All rights reserved.

     5  * Copyright (C) 2007 Collabora Ltd.

     6  *

     7  * This program is free software; you can redistribute it and/or

     8  * modify it under the terms of the GNU Lesser General Public License as

     9  * published by the Free Software Foundation; either version 2 of the

    10  * License, or (at your option) any later version.

    11  *

    12  * This program is distributed in the hope that it will be useful,

    13  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    15  * Lesser General Public License for more details.

    16  *

    17  * You should have received a copy of the GNU Lesser General Public

    18  * License along with this program; if not, write to the

    19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

    20  * Boston, MA 02111-1307, USA.

    21  */

    22 

    23 #include <config.h>

    24 

    25 #include <string.h>

    26 #include <sys/stat.h> 

    27 #include <sys/types.h>

    28 #include <fcntl.h>

    29 

    30 /* Needed on Mac OS X */

    31 #if HAVE_NETINET_IN_H

    32 #include <netinet/in.h>

    33 #endif

    34 

    35 #include <arpa/nameser.h>

    36 //#include <resolv.h>

    37 

    38 #include <glib.h>

    39 #include <gdebug.h>

    40 

    41 #include "lm-sock.h"

    42 #include "lm-debug.h"

    43 #include "lm-error.h"

    44 #include "lm-internals.h"

    45 #include "lm-message-queue.h"

    46 #include "lm-misc.h"

    47 #include "lm-ssl-internals.h"

    48 #include "lm-parser.h"

    49 #include "lm-sha.h"

    50 #include "lm-connection.h"

    51 #include "lm-utils.h"

    52 #include "lm-socket.h"

    53 #include "lm-sasl.h"

    54 

    55 #define IN_BUFFER_SIZE 1024

    56 //#define SRV_LEN 8192

    57 #define SRV_LEN 2048 // check the actual value needed here! - MeCo

    58 

    59 typedef struct {

    60 	LmHandlerPriority  priority;

    61 	LmMessageHandler  *handler;

    62 } HandlerData;

    63 

    64 struct _LmConnection {

    65 	/* Parameters */

    66 	GMainContext *context;

    67 	gchar        *server;

    68 	gchar        *jid;

    69 	gchar        *effective_jid;

    70 	guint         port;

    71 	gboolean      use_srv;

    72 

    73 	LmSocket     *socket;

    74 	LmSSL        *ssl;

    75 	LmProxy      *proxy;

    76 	LmParser     *parser;

    77 

    78 	gchar        *stream_id;

    79 

    80 	GHashTable   *id_handlers;

    81 	GSList       *handlers[LM_MESSAGE_TYPE_UNKNOWN];

    82 

    83 	/* XMPP1.0 stuff (SASL, resource binding, StartTLS) */

    84 	gboolean      use_sasl;

    85 	LmSASL       *sasl;

    86 	gchar        *resource;

    87 	LmMessageHandler *features_cb;

    88 	LmMessageHandler *starttls_cb;

    89 	gboolean      tls_started;

    90 

    91 	/* Communication */

    92 	guint         open_id;

    93 	LmCallback   *open_cb;

    94 

    95  	gboolean      async_connect_waiting;

    96 	gboolean      blocking;

    97 

    98 	gboolean      cancel_open;

    99 	LmCallback   *auth_cb;

   100 

   101 	LmCallback   *disconnect_cb;

   102 

   103 	LmMessageQueue *queue;

   104 

   105 	LmConnectionState state;

   106 

   107 	guint         keep_alive_rate;

   108 	GSource      *keep_alive_source;

   109 

   110 	gint          ref_count;

   111 };

   112 

   113 typedef enum {

   114 	AUTH_TYPE_PLAIN  = 1,

   115 	AUTH_TYPE_DIGEST = 2,

   116 	AUTH_TYPE_0K     = 4

   117 } AuthType;

   118 

   119 #define XMPP_NS_BIND "urn:ietf:params:xml:ns:xmpp-bind"

   120 #define XMPP_NS_SESSION "urn:ietf:params:xml:ns:xmpp-session"

   121 #define XMPP_NS_STARTTLS "urn:ietf:params:xml:ns:xmpp-tls"

   122 

   123 static void     connection_free (LmConnection *connection);

   124 

   125 

   126 static void     connection_handle_message    (LmConnection         *connection,

   127 					      LmMessage            *message);

   128 

   129 static void     connection_new_message_cb    (LmParser             *parser,

   130 					      LmMessage            *message,

   131 					      LmConnection         *connection);

   132 static gboolean connection_do_open           (LmConnection         *connection,

   133 					      GError              **error);

   134 void            connection_do_close          (LmConnection         *connection);

   135 

   136 

   137 static LmMessage *     connection_create_auth_req_msg (const gchar *username);

   138 static LmMessage *     connection_create_auth_msg     (LmConnection *connection,

   139 						       const gchar  *username,

   140 						       const gchar  *password,

   141 						       const gchar  *resource,

   142 						       gint          auth_type);

   143 static LmHandlerResult connection_auth_req_reply (LmMessageHandler *handler,

   144 						  LmConnection     *connection,

   145 						  LmMessage        *m,

   146 						  gpointer          user_data);

   147 static int connection_check_auth_type            (LmMessage      *auth_req_rpl);

   148 					      

   149 static LmHandlerResult

   150 connection_auth_reply                            (LmMessageHandler *handler,

   151 						  LmConnection     *connection,

   152 						  LmMessage        *m,

   153 						  gpointer          user_data);

   154 

   155 static void      connection_stream_received      (LmConnection    *connection, 

   156 						  LmMessage       *m);

   157 static void      connection_stream_error         (LmConnection    *connection, 

   158 						  LmMessage       *m);

   159 

   160 static gint      connection_handler_compare_func (HandlerData     *a,

   161 						  HandlerData     *b);

   162 static gboolean  connection_send_keep_alive      (LmConnection    *connection);

   163 static void      connection_start_keep_alive     (LmConnection    *connection);

   164 static void      connection_stop_keep_alive      (LmConnection    *connection);

   165 static gboolean  connection_send                 (LmConnection    *connection, 

   166 						  const gchar     *str, 

   167 						  gint             len, 

   168 						  GError         **error);

   169 static void      connection_message_queue_cb     (LmMessageQueue  *queue,

   170 						  LmConnection    *connection);

   171 static void      connection_signal_disconnect    (LmConnection       *connection,

   172 						  LmDisconnectReason  reason);

   173 static void      connection_incoming_data        (LmSocket        *socket, 

   174 						  const gchar     *buf,

   175 						  LmConnection    *connection);

   176 static void      connection_socket_closed_cb     (LmSocket        *socket,

   177 						  LmDisconnectReason reason,

   178 						  LmConnection       *connection);

   179 static void      connection_socket_connect_cb    (LmSocket           *socket,

   180 						  gboolean            result,

   181 						  LmConnection       *connection);

   182 

   183 static gboolean  connection_get_server_from_jid  (const gchar     *jid,

   184 						  gchar          **server);

   185 static void      connection_send_stream_header   (LmConnection    *connection);

   186 static LmHandlerResult connection_features_cb (LmMessageHandler *handler,

   187 					       LmConnection     *connection,

   188 					       LmMessage        *message,

   189 					       gpointer          user_data);

   190 

   191 static void

   192 connection_free (LmConnection *connection)

   193 {

   194 	int        i;

   195 

   196 	g_free (connection->server);

   197 	g_free (connection->jid);

   198 	g_free (connection->effective_jid);

   199 	g_free (connection->stream_id);

   200 	g_free (connection->resource);

   201 

   202 	if (connection->sasl) {

   203 		lm_sasl_free (connection->sasl);

   204 	}

   205 

   206 	if (connection->parser) {

   207 		lm_parser_free (connection->parser);

   208 	}

   209 

   210 	/* Unref handlers */

   211 	for (i = 0; i < LM_MESSAGE_TYPE_UNKNOWN; ++i) {

   212 		GSList *l;

   213 

   214 		for (l = connection->handlers[i]; l; l = l->next) {

   215 			HandlerData *hd = (HandlerData *) l->data;

   216 			

   217 			lm_message_handler_unref (hd->handler);

   218 			g_free (hd);

   219 		}

   220 

   221 		g_slist_free (connection->handlers[i]);

   222 	}

   223 

   224 	g_hash_table_destroy (connection->id_handlers);

   225 	if (connection->state >= LM_CONNECTION_STATE_OPENING) {

   226 		connection_do_close (connection);

   227 	}

   228 

   229 	if (connection->open_cb) {

   230 		_lm_utils_free_callback (connection->open_cb);

   231 	}

   232 	

   233 	if (connection->auth_cb) {

   234 		_lm_utils_free_callback (connection->auth_cb);

   235 	}

   236 

   237 	lm_connection_set_disconnect_function (connection, NULL, NULL, NULL);

   238 

   239 	if (connection->proxy) {

   240 		lm_proxy_unref (connection->proxy);

   241 	}

   242 

   243 	lm_message_queue_unref (connection->queue);

   244 

   245         if (connection->context) {

   246                 g_main_context_unref (connection->context);

   247         }

   248 

   249 	if (connection->socket) {

   250 		lm_socket_unref (connection->socket);

   251 	}

   252 

   253         g_free (connection);

   254 }

   255 

   256 static void

   257 connection_handle_message (LmConnection *connection, LmMessage *m)

   258 {

   259 	LmMessageHandler *handler;

   260 	GSList           *l;

   261 	const gchar      *id;

   262 	LmHandlerResult   result = LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS;

   263 

   264 	lm_connection_ref (connection);

   265 	lm_verbose("[connection_handle_message]: Inside\n");

   266 	lm_verbose("msg type:[%d]\n", lm_message_get_type (m));

   267 	id = lm_message_node_get_attribute (m->node, "id");

   268 	if(id)

   269 		{

   270 		lm_verbose("handlemsg node id: %s\n", id);

   271 		}

   272 	if (lm_message_get_type (m) == LM_MESSAGE_TYPE_STREAM) {

   273 		lm_verbose("[connection_handle_message]: Stream received\n");

   274 		lm_verbose("[connection_handle_message]: calling connection_stream_received \n");

   275 		connection_stream_received (connection, m);

   276 		lm_verbose("[connection_handle_message]: CALLED connection_stream_received \n");

   277 		goto out;

   278 	}

   279 

   280 	if ((lm_message_get_sub_type (m) == LM_MESSAGE_SUB_TYPE_ERROR) ||

   281 	    (lm_message_get_sub_type (m) == LM_MESSAGE_SUB_TYPE_RESULT)) {

   282 		id = lm_message_node_get_attribute (m->node, "id");

   283 

   284 		lm_verbose("[connection_handle_message]: type is error or result \n");

   285 		if (id) {

   286 			handler = g_hash_table_lookup (connection->id_handlers, id);

   287 			if (handler) {

   288 				lm_verbose("[connection_handle_message]: calling the right handler for error/result \n");

   289 				result = _lm_message_handler_handle_message (handler,

   290 									     connection,

   291 									     m);

   292 				lm_verbose("[connection_handle_message]: Called right handler for error/result \n");									     

   293 				g_hash_table_remove (connection->id_handlers,

   294 						    id);

   295 			}

   296 		}

   297 

   298 		if (result == LM_HANDLER_RESULT_REMOVE_MESSAGE) {

   299 			lm_verbose("return from connection_handle_message\n");

   300 			goto out;

   301 		}

   302 	}

   303 	lm_verbose("[connection_handle_message]:starting for loop for more handlers\n");

   304 	for (l = connection->handlers[lm_message_get_type (m)]; 

   305 	     l && result == LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS; 

   306 	     l = l->next) {

   307 		HandlerData *hd = (HandlerData *) l->data;

   308 		lm_verbose("[connection_handle_message]:inside for loop for more handlers with msg type: %d\n", lm_message_get_type (m));

   309 		lm_verbose("[connection_handle_message]:inside for loop with node name: %s\n",lm_message_get_node(m)->name);

   310 		result = _lm_message_handler_handle_message (hd->handler,

   311 							     connection,

   312 							     m);

   313 		lm_verbose("[connection_handle_message]:got result from _lm_message_handler_handle_message as :%d\n",result);

   314 	}

   315 	lm_verbose("[connection_handle_message]:Ended for loop for more handlers\n");

   316 	if (lm_message_get_type (m) == LM_MESSAGE_TYPE_STREAM_ERROR) {

   317 		lm_verbose("[connection_handle_message]:stream error\n");

   318 		connection_stream_error (connection, m);

   319 		goto out;

   320 	}

   321 	

   322 out:

   323 	lm_verbose("[connection_handle_message]:exiting connection_handle_message\n");

   324 	lm_connection_unref (connection);

   325 	lm_verbose("[connection_handle_message]:after unref of connection\n");

   326 	return;

   327 }

   328 

   329 static void

   330 connection_new_message_cb (LmParser     *parser,

   331 			   LmMessage    *m,

   332 			   LmConnection *connection)

   333 {

   334 	const gchar *from;

   335 	

   336 	lm_message_ref (m);

   337 

   338 	from = lm_message_node_get_attribute (m->node, "from");

   339 	if (!from) {

   340 		from = "unknown";

   341 	}

   342 	

   343 	lm_verbose ("New message with type=\"%s\" from: %s\n",

   344 		    _lm_message_type_to_string (lm_message_get_type (m)),

   345 		    from);

   346 

   347 	lm_message_queue_push_tail (connection->queue, m);

   348 	UNUSED_FORMAL_PARAM(parser);

   349 }

   350 

   351 static gboolean

   352 connection_send_keep_alive (LmConnection *connection)

   353 { 

   354     lm_verbose ("[connection_send_keep_alive]\n");

   355 	if (!connection_send (connection, " ", -1, NULL)) {

   356 		lm_verbose ("Error while sending keep alive package!\n");

   357 	}

   358 	return TRUE;

   359 }

   360 

   361 static void

   362 connection_start_keep_alive (LmConnection *connection)

   363 {

   364 	lm_verbose("[connection_start_keep_alive]:Inside ....");

   365 	/* try using TCP keepalives if possible */

   366 	if ((connection->keep_alive_rate > 0) &&

   367 		lm_socket_set_keepalive (connection->socket,

   368 			connection->keep_alive_rate)) {

   369 	lm_verbose("[connection_start_keep_alive]: timer already active\n");

   370 	connection->keep_alive_source =

   371          lm_misc_add_timeout (connection->context,

   372                       connection->keep_alive_rate * 1000,

   373                       (GSourceFunc) connection_send_keep_alive,

   374                       connection);

   375 		return;

   376 	}

   377 

   378 	if (connection->keep_alive_source) {

   379 		lm_verbose("[connection_start_keep_alive]:stopping keep alive timer");

   380 		connection_stop_keep_alive (connection);

   381 	}

   382 

   383 	if (connection->keep_alive_rate > 0) {

   384 		connection->keep_alive_source =

   385 			lm_misc_add_timeout (connection->context,

   386 					     connection->keep_alive_rate * 1000,

   387 					     (GSourceFunc) connection_send_keep_alive,

   388 					     connection);

   389 		lm_verbose("[connection_start_keep_alive]: added timer to gsource\n");

   390 	}

   391 lm_verbose("[connection_start_keep_alive]: ...Exiting connection_start_keep_alive....");	 

   392 }

   393 

   394 static void

   395 connection_stop_keep_alive (LmConnection *connection)

   396 {

   397 	lm_verbose("[connection_start_keep_alive]:Stopping Keep Alive\n");

   398 	if (connection->keep_alive_source) {

   399 		g_source_destroy (connection->keep_alive_source);

   400 	}

   401 

   402 	connection->keep_alive_source = NULL;

   403 }

   404 

   405 static gboolean

   406 connection_send (LmConnection  *connection, 

   407 		 const gchar   *str, 

   408 		 gint           len, 

   409 		 GError       **error)

   410 {

   411 	gint b_written;

   412 

   413 	if (connection->state < LM_CONNECTION_STATE_OPENING) {

   414 	/*	g_log (LM_LOG_DOMAIN,LM_LOG_LEVEL_NET,

   415 		       "Connection is not open.\n");

   416 

   417 		g_set_error (error,

   418 			     LM_ERROR,

   419 			     LM_ERROR_CONNECTION_NOT_OPEN,

   420 			     "Connection is not open, call lm_connection_open() first");*/

   421 		lm_verbose("[connection_send]: Connection is not open call lm_connection_open() first");	     

   422 		return FALSE;

   423 	}

   424 

   425 	if (len == -1) {

   426 		len = strlen (str);

   427 	}

   428 

   429 	//g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET, "\nSEND:\n");

   430 	//g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET, 

   431 	//       "-----------------------------------\n");

   432 	//g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET, "%s\n", str);

   433 	//g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_NET, 

   434 	//       "-----------------------------------\n");

   435 	lm_verbose (  "\n[connection_send]: SEND:\n");

   436 	lm_verbose (  "-----------------------------------\n");

   437 	lm_verbose (  "%s\n", str);

   438 	lm_verbose (  "-----------------------------------\n");

   439 

   440 	/* Check to see if there already is an output buffer, if so, add to the

   441 	   buffer and return */

   442 

   443 	if (lm_socket_output_is_buffered (connection->socket, str, len)) {

   444 		return TRUE;

   445 	}

   446 	

   447 	b_written = lm_socket_do_write (connection->socket, str, len);

   448 

   449 	lm_verbose("[connection_send]: number of bytes written using lm_socket_do_write is : %d\n",b_written);

   450 	if (b_written < 0) {

   451 		lm_verbose("[connection_send]: Since b_written<0 closing the connection\n");

   452 		connection_do_close (connection);

   453 		connection_signal_disconnect (connection, 

   454 		                     LM_DISCONNECT_REASON_ERROR);

   455 		g_set_error (error,

   456 			     LM_ERROR,

   457 			     LM_ERROR_CONNECTION_FAILED,

   458 			     "Server closed the connection");

   459 		return FALSE;

   460 	}

   461 

   462 	if (b_written < len) {

   463 		lm_socket_setup_output_buffer (connection->socket, 

   464 						str + b_written, 

   465 						len - b_written);

   466 	}

   467 

   468 	return TRUE;

   469 }

   470 

   471 static void

   472 connection_message_queue_cb (LmMessageQueue *queue, LmConnection *connection)

   473 {

   474 	LmMessage *m;

   475 

   476 	m = lm_message_queue_pop_nth (connection->queue, 0);

   477 

   478 	if (m) {

   479 	    lm_verbose("In connection_message_queue_cb\n");

   480 		connection_handle_message (connection, m);

   481 		lm_message_unref (m);

   482 		lm_verbose("After un refing the message\n");

   483 	}

   484 	UNUSED_FORMAL_PARAM(queue);

   485 }

   486 

   487 /* Returns directly */

   488 /* Setups all data needed to start the connection attempts */

   489 static gboolean

   490 connection_do_open (LmConnection *connection, GError **error) 

   491 {

   492 	gchar *domain = NULL;

   493 

   494 	if (lm_connection_is_open (connection)) {

   495 		g_set_error (error,

   496 			     LM_ERROR,

   497 			     LM_ERROR_CONNECTION_NOT_OPEN,

   498 			     "Connection is already open, call lm_connection_close() first");

   499 		return FALSE;

   500 	}

   501 

   502 	if (!connection_get_server_from_jid (connection->jid, &domain)) {

   503 		domain = g_strdup (connection->server);

   504 	}

   505 

   506 	lm_verbose ("[connection_do_open]: Connecting to: %s:%d\n", connection->server, connection->port);

   507 

   508 	connection->socket = lm_socket_create (connection->context,

   509 					       (IncomingDataFunc) connection_incoming_data,

   510 					       (SocketClosedFunc) connection_socket_closed_cb,

   511 					       (ConnectResultFunc) connection_socket_connect_cb,

   512 					       connection,

   513 					       connection,

   514 					       connection->blocking,

   515 					       connection->server,

   516 					       domain,

   517 					       connection->port,

   518 					       connection->ssl,

   519 					       connection->proxy,

   520 					       error);

   521 

   522 	g_free (domain);

   523     lm_verbose ("[connection_do_open]: after lm_socket_create call in connection_do_open");

   524     

   525 	if (!connection->socket) {

   526 		return FALSE;

   527 	}

   528 

   529 	lm_message_queue_attach (connection->queue, connection->context);

   530 	

   531 	connection->state = LM_CONNECTION_STATE_OPENING;

   532 	connection->async_connect_waiting = FALSE;

   533 

   534 	return TRUE;

   535 }

   536 					

   537 void

   538 connection_do_close (LmConnection *connection)

   539 {

   540 	connection_stop_keep_alive (connection);

   541 

   542 	if (connection->socket) {

   543 		lm_socket_close (connection->socket);

   544 	}

   545 

   546 	lm_message_queue_detach (connection->queue);

   547 	

   548 	if (!lm_connection_is_open (connection)) {

   549 		/* lm_connection_is_open is FALSE for state OPENING as well */

   550 		connection->state = LM_CONNECTION_STATE_CLOSED;

   551 		connection->async_connect_waiting = FALSE;

   552 		return;

   553 	}

   554 	

   555 	connection->state = LM_CONNECTION_STATE_CLOSED;

   556 	connection->async_connect_waiting = FALSE;

   557 	if (connection->ssl) {

   558 		_lm_ssl_close (connection->ssl);

   559 	}

   560 

   561 	if (connection->sasl) {

   562 		lm_sasl_free (connection->sasl);

   563 		connection->sasl = NULL;

   564 	}

   565 }

   566 

   567 typedef struct {

   568 	gchar        *username;

   569 	gchar        *password;

   570 	gchar        *resource;

   571 } AuthReqData;

   572 

   573 static void 

   574 auth_req_data_free (AuthReqData *data) 

   575 {

   576 	g_free (data->username);

   577 	g_free (data->password);

   578 	g_free (data->resource);

   579 	g_free (data);

   580 }

   581 

   582 static LmMessage *

   583 connection_create_auth_req_msg (const gchar *username)

   584 {

   585 	LmMessage     *m;

   586 	LmMessageNode *q_node;

   587 	

   588 	m = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_IQ,

   589 					  LM_MESSAGE_SUB_TYPE_GET);

   590 	q_node = lm_message_node_add_child (m->node, "query", NULL);

   591 	lm_message_node_set_attributes (q_node,

   592 					"xmlns", "jabber:iq:auth",

   593 					NULL);

   594 	lm_message_node_add_child (q_node, "username", username);

   595 

   596 	return m;

   597 }

   598 

   599 static LmMessage *

   600 connection_create_auth_msg (LmConnection *connection,

   601 			    const gchar  *username,

   602 			    const gchar  *password,

   603 			    const gchar  *resource,

   604 			    gint          auth_type)

   605 {

   606 	LmMessage     *auth_msg;

   607 	LmMessageNode *q_node;

   608 

   609 	auth_msg = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_IQ,

   610 						 LM_MESSAGE_SUB_TYPE_SET);

   611 	

   612 	q_node = lm_message_node_add_child (auth_msg->node, "query", NULL);

   613 	

   614 	lm_message_node_set_attributes (q_node,

   615 					"xmlns", "jabber:iq:auth", 

   616 					NULL);

   617 

   618 	lm_message_node_add_child (q_node, "username", username);

   619 	

   620 	if (auth_type & AUTH_TYPE_0K) {

   621 		lm_verbose ("Using 0k auth (not implemented yet)\n");

   622 		/* TODO: Should probably use this? */

   623 	}

   624 

   625 	if (auth_type & AUTH_TYPE_DIGEST) {

   626 		gchar       *str;

   627 		const gchar *digest;

   628 

   629 		lm_verbose ("Using digest\n");

   630 		str = g_strconcat (connection->stream_id, password, NULL);

   631 		digest = lm_sha_hash (str);

   632 		g_free (str);

   633 		lm_message_node_add_child (q_node, "digest", digest);

   634 	} 

   635 	else if (auth_type & AUTH_TYPE_PLAIN) {

   636 		lm_verbose ("Using plaintext auth\n");

   637 		lm_message_node_add_child (q_node, "password", password);

   638 	} else {

   639 		/* TODO: Report error somehow */

   640 	}

   641 	

   642 	lm_message_node_add_child (q_node, "resource", resource);

   643 

   644 	return auth_msg;

   645 }

   646 

   647 static LmHandlerResult

   648 connection_auth_req_reply (LmMessageHandler *handler,

   649 			   LmConnection     *connection,

   650 			   LmMessage        *m,

   651 			   gpointer          user_data)

   652 {

   653 	int               auth_type;

   654 	LmMessage        *auth_msg;

   655 	LmMessageHandler *auth_handler;

   656 	AuthReqData      *data = (AuthReqData *) user_data;      

   657 	gboolean          result;

   658 	

   659 	auth_type = connection_check_auth_type (m);

   660 

   661 	auth_msg = connection_create_auth_msg (connection, 

   662 					       data->username,

   663 					       data->password,

   664 					       data->resource,

   665 					       auth_type);

   666 

   667 	auth_handler = lm_message_handler_new (connection_auth_reply,

   668 					       NULL, NULL);

   669 	result = lm_connection_send_with_reply (connection, auth_msg, 

   670 						auth_handler, NULL);

   671 	lm_message_handler_unref (auth_handler);

   672 	lm_message_unref (auth_msg);

   673 	UNUSED_FORMAL_PARAM(handler);

   674 	UNUSED_FORMAL_PARAM(user_data);

   675 	return LM_HANDLER_RESULT_REMOVE_MESSAGE;

   676 }

   677 

   678 static int

   679 connection_check_auth_type (LmMessage *auth_req_rpl)

   680 {

   681 	LmMessageNode *q_node;

   682 	gint           ret_val = 0; 

   683 

   684 	q_node = lm_message_node_get_child (auth_req_rpl->node, "query");

   685 	

   686 	if (!q_node) {

   687 		return AUTH_TYPE_PLAIN;

   688 	}

   689 

   690 	if (lm_message_node_get_child (q_node, "password")) {

   691 		ret_val |= AUTH_TYPE_PLAIN;

   692 	}

   693 

   694 	if (lm_message_node_get_child (q_node, "digest")) {

   695 		ret_val |= AUTH_TYPE_DIGEST;

   696 	}

   697 

   698 	if (lm_message_node_get_child (q_node, "sequence") &&

   699 	    lm_message_node_get_child (q_node, "token")) {

   700 		ret_val |= AUTH_TYPE_0K;

   701 	}

   702 

   703 	return ret_val;

   704 }

   705 

   706 static LmHandlerResult 

   707 connection_auth_reply (LmMessageHandler *handler,

   708 		       LmConnection     *connection,

   709 		       LmMessage        *m,

   710 		       gpointer          user_data)

   711 {

   712 	const gchar *type;

   713 	gboolean     result = TRUE;

   714 	

   715 	g_return_val_if_fail (connection != NULL, 

   716 			      LM_HANDLER_RESULT_ALLOW_MORE_HANDLERS);

   717 	

   718 

   719 	type = lm_message_node_get_attribute (m->node, "type");

   720 	if (strcmp (type, "result") == 0) {

   721 		result = TRUE;

   722 		connection->state = LM_CONNECTION_STATE_AUTHENTICATED;

   723 	} 

   724 	else if (strcmp (type, "error") == 0) {

   725 		result = FALSE;

   726 		connection->state = LM_CONNECTION_STATE_OPEN;

   727 	}

   728 	

   729 	lm_verbose ("AUTH reply: %d\n", result);

   730 	

   731 	if (connection->auth_cb) {

   732 	        LmCallback *cb = connection->auth_cb;

   733 

   734 		connection->auth_cb = NULL;

   735 

   736 		if (cb->func) {

   737 	    		(* ((LmResultFunction) cb->func)) (connection, 

   738 						           result, cb->user_data);

   739 		}

   740 

   741 		_lm_utils_free_callback (cb);

   742 	}

   743 	UNUSED_FORMAL_PARAM(handler);

   744 	UNUSED_FORMAL_PARAM(user_data);

   745 	return LM_HANDLER_RESULT_REMOVE_MESSAGE;

   746 }

   747 

   748 

   749 static LmHandlerResult

   750 _lm_connection_starttls_cb (LmMessageHandler *handler,

   751 			    LmConnection *connection,

   752 			    LmMessage *message,

   753 			    gpointer user_data)

   754 {

   755 	if (lm_socket_starttls (connection->socket)) {

   756 		connection->tls_started = TRUE;

   757 		connection_send_stream_header (connection);

   758 	} else {

   759 		connection_do_close (connection);

   760 		connection_signal_disconnect (connection, 

   761 					      LM_DISCONNECT_REASON_ERROR);

   762 	}

   763 	UNUSED_FORMAL_PARAM(message);

   764 	UNUSED_FORMAL_PARAM(handler);

   765 	UNUSED_FORMAL_PARAM(user_data);

   766 	return LM_HANDLER_RESULT_REMOVE_MESSAGE;

   767 }

   768 

   769 static void

   770 connection_stream_received (LmConnection *connection, LmMessage *m)

   771 {

   772 	gboolean result;

   773 	const char *xmpp_version;

   774 	

   775 	g_return_if_fail (connection != NULL);

   776 	g_return_if_fail (m != NULL);

   777 	

   778 	connection->stream_id = g_strdup (lm_message_node_get_attribute (m->node,

   779 									 "id"));;

   780 

   781 	xmpp_version = lm_message_node_get_attribute (m->node, "version");

   782 	if (xmpp_version && strcmp (xmpp_version, "1.0") == 0) {

   783 		lm_verbose ("[connection_stream_received]: XMPP 1.0 stream received: %s\n",

   784 			    connection->stream_id);

   785 

   786 		connection->use_sasl = TRUE;

   787 		

   788 		/* stream is started multiple times, but we only want

   789 		 * one sasl mechanism */

   790 		if (!connection->sasl)

   791 			connection->sasl = lm_sasl_new(connection);

   792 

   793 		/* if we'd like to use tls and we didn't already start

   794 		 * it, prepare for it now */

   795 		if (connection->ssl &&

   796 				lm_ssl_get_use_starttls (connection->ssl) &&

   797 				!connection->starttls_cb) {

   798 						lm_verbose("[connction_stream_received]: Starttls called");

   799 			connection->starttls_cb  =

   800 				lm_message_handler_new (_lm_connection_starttls_cb,

   801 					NULL, NULL);

   802 			lm_connection_register_message_handler (connection,

   803 				connection->starttls_cb,

   804 				LM_MESSAGE_TYPE_PROCEED,

   805 				LM_HANDLER_PRIORITY_FIRST);

   806 		}

   807 	} else {

   808 		lm_verbose ("Old Jabber stream received: %s\n", 

   809 			    connection->stream_id);

   810 	}

   811 	

   812 	if (connection->state < LM_CONNECTION_STATE_OPEN) {

   813 		connection->state = LM_CONNECTION_STATE_OPEN;

   814 	}

   815 	

   816 	/* Check to see if the stream is correctly set up */

   817 	result = TRUE;

   818 

   819 //	connection_start_keep_alive (connection); //prima

   820 

   821 	if (connection->open_cb) {

   822 		LmCallback *cb = connection->open_cb;

   823 

   824 		connection->open_cb = NULL;

   825 		

   826 		if (cb->func) {

   827 		        (* ((LmResultFunction) cb->func)) (connection, result,

   828 			        			   cb->user_data);

   829 		}

   830 		_lm_utils_free_callback (cb);

   831 	}

   832 }

   833 

   834 static void

   835 connection_stream_error (LmConnection *connection, LmMessage *m)

   836 {

   837 	LmMessageNode *node, *reason_node;

   838 	LmDisconnectReason reason;

   839 

   840 	g_return_if_fail (connection != NULL);

   841 	g_return_if_fail (m != NULL);

   842 

   843 	node = m->node;

   844 

   845 	/* Resource conflict */

   846 	reason_node = lm_message_node_get_child (node, "conflict");

   847 	if (reason_node) {

   848 		lm_verbose ("Stream error: Conflict (resource connected elsewhere)\n");

   849 		reason = LM_DISCONNECT_REASON_RESOURCE_CONFLICT;

   850 		return;

   851 	}

   852 

   853 	/* XML is crack */

   854 	reason_node = lm_message_node_get_child (node, "xml-not-well-formed");

   855 	if (reason_node) {

   856 		lm_verbose ("Stream error: XML not well formed\n");

   857 		reason = LM_DISCONNECT_REASON_INVALID_XML;

   858 		return;

   859 	}

   860 

   861 	lm_verbose ("Stream error: Unrecognised error\n");

   862 	reason = LM_DISCONNECT_REASON_ERROR;

   863 	connection->stream_id = g_strdup (lm_message_node_get_attribute (m->node,

   864 									 "id"));;

   865 	connection_do_close (connection);

   866 	connection_signal_disconnect (connection, reason);

   867 }

   868 

   869 static gint

   870 connection_handler_compare_func (HandlerData *a, HandlerData *b)

   871 {

   872 	return b->priority - a->priority;

   873 }

   874 

   875 static void

   876 connection_signal_disconnect (LmConnection       *connection,

   877 			      LmDisconnectReason  reason)

   878 {

   879     lm_verbose ("[connection_signal_disconnect]\n");      

   880 	if (connection->disconnect_cb && connection->disconnect_cb->func) {

   881 	    

   882 		LmCallback *cb = connection->disconnect_cb;

   883 		lm_verbose("[connection_signal_disconnect]: ...disconnecting\n");		

   884 		lm_connection_ref (connection);

   885 		(* ((LmDisconnectFunction) cb->func)) (connection,

   886 						       reason,

   887 						       cb->user_data);

   888 		lm_connection_unref (connection);

   889 		lm_verbose("[connection_signal_disconnect]: ...after unref\n"); 

   890 	}

   891 }

   892 

   893 static void

   894 connection_incoming_data (LmSocket     *socket, 

   895 			  const gchar  *buf, 

   896 			  LmConnection *connection)

   897 {

   898 	lm_parser_parse (connection->parser, buf);

   899 	UNUSED_FORMAL_PARAM(socket);

   900 }

   901 

   902 static void

   903 connection_socket_closed_cb (LmSocket        *socket,

   904 			     LmDisconnectReason reason,

   905 			     LmConnection       *connection)

   906 {

   907     lm_verbose("[connection_socket_closed_cb]: inside..\n");

   908     connection_do_close (connection);

   909 	connection_signal_disconnect (connection, reason);

   910 	lm_verbose("[connection_socket_closed_cb]: exiting..\n");

   911 	UNUSED_FORMAL_PARAM(socket);

   912 }

   913 

   914 static void

   915 connection_socket_connect_cb (LmSocket           *socket,

   916 			      gboolean            result,

   917 			      LmConnection       *connection)

   918 {

   919 	if (!result) {

   920 		connection_do_close (connection);

   921 	    lm_verbose ("[connection_socket_connect_cb]: result false ");

   922 		if (connection->open_cb) {

   923 			LmCallback *cb = connection->open_cb;

   924 		    lm_verbose ("[connection_socket_connect_cb]: connection->open_cb is defined "); 

   925 

   926 			connection->open_cb = NULL;

   927 			

   928 			(* ((LmResultFunction) cb->func)) (connection, FALSE,

   929 							   cb->user_data);

   930 			_lm_utils_free_callback (cb);

   931 		}

   932 	

   933 		UNUSED_FORMAL_PARAM(socket);

   934 		return;

   935 	}

   936 	

   937 	/* FIXME: Set up according to XMPP 1.0 specification */

   938 	/*        StartTLS and the like */

   939 	if (!connection_send (connection, 

   940 			      "<?xml version='1.0' encoding='UTF-8'?>", -1,

   941 			      NULL)) {

   942 		lm_verbose ("Failed to send xml version and encoding\n");

   943 		connection_do_close (connection);

   944 

   945 		return;

   946 	}

   947 

   948 	connection_send_stream_header (connection);

   949 	lm_verbose("\n[connection_socket_connect_cb]: exiting ");

   950 }

   951 

   952 static gboolean

   953 connection_get_server_from_jid (const gchar     *jid,

   954 				gchar          **server)

   955 {

   956 	gchar *ch;

   957 	gchar *ch_end;

   958 

   959 	if (jid != NULL && (ch = strchr (jid, '@')) != NULL) {

   960 		ch_end = strchr(ch + 1, '/');

   961 		if (ch_end != NULL) {

   962 			*server = g_strndup (ch + 1, ch_end - ch - 1);

   963 		} else {

   964 			*server = g_strdup (ch + 1);

   965 		}

   966 

   967 		return TRUE;

   968 	} 

   969 	

   970 	return FALSE;

   971 }

   972 

   973 static void

   974 connection_send_stream_header (LmConnection *connection)

   975 {

   976 	LmMessage *m;

   977 	gchar     *server_from_jid;

   978 

   979 	lm_verbose ("Sending stream header\n");

   980 

   981 	if (!connection_get_server_from_jid (connection->jid, &server_from_jid)) {

   982 		server_from_jid = g_strdup (connection->server);

   983 	}

   984 

   985 	m = lm_message_new (server_from_jid, LM_MESSAGE_TYPE_STREAM);

   986 	lm_message_node_set_attributes (m->node,

   987 					"xmlns:stream", 

   988 					"http://etherx.jabber.org/streams",

   989 					"xmlns", "jabber:client",

   990 					"version", "1.0",

   991 					NULL);

   992 	

   993 	g_free (server_from_jid);

   994 

   995 	if (!lm_connection_send (connection, m, NULL)) {

   996 		lm_verbose ("Failed to send stream information\n");

   997 		connection_do_close (connection);

   998 	}

   999 	connection_start_keep_alive (connection); //prima	

  1000 	lm_message_unref (m);

  1001 	lm_verbose("\n[connection_send_stream_header]: Exiting send stream header method");

  1002 }

  1003 

  1004 gboolean 

  1005 _lm_connection_async_connect_waiting (LmConnection *connection)

  1006 {

  1007 	return connection->async_connect_waiting;

  1008 }

  1009 

  1010 void

  1011 _lm_connection_set_async_connect_waiting (LmConnection *connection,

  1012 					  gboolean      waiting)

  1013 {

  1014 	connection->async_connect_waiting = waiting;

  1015 }

  1016 

  1017 static void

  1018 connection_call_auth_cb (LmConnection *connection, gboolean success)

  1019 {

  1020 	if (success) {

  1021 		lm_verbose("connection_call_auth_cb: authenticated\n");

  1022 		connection->state = LM_CONNECTION_STATE_AUTHENTICATED;

  1023 	} else {

  1024 		lm_verbose("connection_call_auth_cb: conn still open\n");

  1025 		connection->state = LM_CONNECTION_STATE_OPEN;

  1026 	}

  1027 

  1028 	if (connection->auth_cb) {

  1029 	        LmCallback *cb = connection->auth_cb;

  1030 

  1031 		connection->auth_cb = NULL;

  1032 

  1033 		if (cb->func) {

  1034 		lm_verbose("connection_call_auth_cb: calling the test code's registered cb method\n");

  1035 	    		(* ((LmResultFunction) cb->func)) (connection, 

  1036 						           success,

  1037 							   cb->user_data);

  1038 		}

  1039 

  1040 		_lm_utils_free_callback (cb);

  1041 	}

  1042 }

  1043 

  1044 static LmHandlerResult

  1045 connection_bind_reply (LmMessageHandler *handler,

  1046 			LmConnection    *connection,

  1047 			LmMessage       *message,

  1048 			gpointer         user_data)

  1049 {

  1050 	LmMessage        *m;

  1051 	LmMessageNode    *session_node;

  1052 	LmMessageNode    *jid_node;

  1053 	int               result;

  1054 	LmMessageSubType  type;

  1055 	lm_verbose("[connection_bind_reply]: inside connection_bind_reply\n");

  1056 	type = lm_message_get_sub_type (message);

  1057 	if (type == LM_MESSAGE_SUB_TYPE_ERROR) {

  1058 		/*g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_SASL, 

  1059 		       "%s: error while binding to resource\n", G_STRFUNC);*/

  1060 		lm_verbose("[connection_bind_reply]: calling connection_call_auth_cb\n");

  1061 		connection_call_auth_cb (connection, FALSE);

  1062 		lm_verbose("[connection_bind_reply]: called connection_call_auth_cb\n");

  1063 		UNUSED_FORMAL_PARAM(user_data);

  1064 		UNUSED_FORMAL_PARAM(handler);

  1065 		return LM_HANDLER_RESULT_REMOVE_MESSAGE;

  1066 	}

  1067 

  1068 	/* use whatever server returns as our effective jid */

  1069 	jid_node = lm_message_node_find_child (message->node, "jid");

  1070 	if (jid_node) {

  1071 		g_free (connection->effective_jid);

  1072 		connection->effective_jid = g_strdup

  1073 			(lm_message_node_get_value (jid_node));

  1074 	}

  1075 

  1076 

  1077 	m = lm_message_new_with_sub_type (NULL,

  1078 					  LM_MESSAGE_TYPE_IQ, 

  1079 					  LM_MESSAGE_SUB_TYPE_SET);

  1080 

  1081 	lm_verbose("[connection_bind_reply]: Creation session child node\n");

  1082 	session_node = lm_message_node_add_child (m->node, "session", NULL);

  1083 	lm_message_node_set_attributes (session_node,

  1084 					"xmlns", XMPP_NS_SESSION,

  1085 					NULL);

  1086 	lm_verbose("[connection_bind_reply]: Sending session child node\n");

  1087 	result = lm_connection_send (connection, m, NULL);

  1088 	lm_message_unref (m);

  1089 	if (result < 0) {

  1090 		connection_do_close (connection);

  1091 	}

  1092 

  1093 	/* We may finally tell the client they're authorized */

  1094 	connection_call_auth_cb (connection, TRUE);

  1095 

  1096 	return LM_HANDLER_RESULT_REMOVE_MESSAGE;

  1097 }

  1098 

  1099 static LmHandlerResult

  1100 connection_features_cb (LmMessageHandler *handler,

  1101 			    LmConnection     *connection,

  1102 			    LmMessage        *message,

  1103 			    gpointer          user_data)

  1104 {

  1105 	LmMessageNode *bind_node;

  1106 	LmMessageNode    *starttls_node;

  1107 	LmMessageNode *old_auth;

  1108 	lm_verbose("[connection_features_cb] inside..\n");

  1109 	

  1110 	starttls_node = lm_message_node_find_child (message->node, "starttls");

  1111 	if (connection->ssl && lm_ssl_get_use_starttls (connection->ssl)) {

  1112 		if (starttls_node) {

  1113 			LmMessage        *msg;

  1114 

  1115 			msg = lm_message_new (NULL, LM_MESSAGE_TYPE_STARTTLS);

  1116 

  1117 			lm_message_node_set_attributes (

  1118 				msg->node,

  1119 				"xmlns", XMPP_NS_STARTTLS,

  1120 				NULL);

  1121 

  1122 			lm_connection_send (connection, msg, NULL);

  1123 			lm_message_unref (msg);

  1124 

  1125 			return LM_HANDLER_RESULT_REMOVE_MESSAGE;

  1126 		} else if (!connection->tls_started &&

  1127 				lm_ssl_get_require_starttls (connection->ssl)) {

  1128 			/* If there were no starttls features present and we require it, this is

  1129 			 * the place to scream. */

  1130 		lm_verbose("connection_features_cb: Required StartTLS feature not supported by server\n");

  1131 

  1132 			/*g_log (LM_LOG_DOMAIN, LM_LOG_LEVEL_SASL, 

  1133 			       "%s: required StartTLS feature not supported by server\n", G_STRFUNC);*/

  1134 			connection_do_close (connection);

  1135 			connection_signal_disconnect (connection,