Context Navigation

source: protocols/jabber/io.c @ fe79f7a7

Last change on this file since fe79f7a7 was fe79f7a7, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-12-16T21:02:16Z
Hide password information during SASL auth in xmlconsole.
Property mode set to `100644`
File size: 15.6 KB

Line
1	/***************************************************************************\
2	* *
3	* BitlBee - An IRC to IM gateway *
4	* Jabber module - I/O stuff (plain, SSL), queues, etc *
5	* *
6	* Copyright 2006 Wilmer van der Gaast <wilmer@gaast.net> *
7	* *
8	* This program is free software; you can redistribute it and/or modify *
9	* it under the terms of the GNU General Public License as published by *
10	* the Free Software Foundation; either version 2 of the License, or *
11	* (at your option) any later version. *
12	* *
13	* This program is distributed in the hope that it will be useful, *
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16	* GNU General Public License for more details. *
17	* *
18	* You should have received a copy of the GNU General Public License along *
19	* with this program; if not, write to the Free Software Foundation, Inc., *
20	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
21	* *
22	\***************************************************************************/
23
24	#include "jabber.h"
25	#include "ssl_client.h"
26
27	static gboolean jabber_write_callback( gpointer data, gint fd, b_input_condition cond );
28	static gboolean jabber_write_queue( struct im_connection *ic );
29
30	int jabber_write_packet( struct im_connection ic, struct xt_node node )
31	{
32	char *buf;
33	int st;
34
35	buf = xt_to_string( node );
36	st = jabber_write( ic, buf, strlen( buf ) );
37	g_free( buf );
38
39	return st;
40	}
41
42	int jabber_write( struct im_connection ic, char buf, int len )
43	{
44	struct jabber_data *jd = ic->proto_data;
45	gboolean ret;
46
47	if( jd->flags & JFLAG_XMLCONSOLE )
48	{
49	char msg, s;
50
51	msg = g_strdup_printf( "TX: %s", buf );
52	/* Don't include auth info in XML logs. */
53	if( strncmp( msg, "TX: <auth ", 10 ) == 0 && ( s = strchr( msg, '>' ) ) )
54	{
55	s++;
56	while( s && s != '<' )
57	(s++) = '';
58	}
59	imcb_buddy_msg( ic, JABBER_XMLCONSOLE_HANDLE, msg, 0, 0 );
60	g_free( msg );
61	}
62
63	if( jd->tx_len == 0 )
64	{
65	/* If the queue is empty, allocate a new buffer. */
66	jd->tx_len = len;
67	jd->txq = g_memdup( buf, len );
68
69	/* Try if we can write it immediately so we don't have to do
70	it via the event handler. If not, add the handler. (In
71	most cases it probably won't be necessary.) */
72	if( ( ret = jabber_write_queue( ic ) ) && jd->tx_len > 0 )
73	jd->w_inpa = b_input_add( jd->fd, B_EV_IO_WRITE, jabber_write_callback, ic );
74	}
75	else
76	{
77	/* Just add it to the buffer if it's already filled. The
78	event handler is already set. */
79	jd->txq = g_renew( char, jd->txq, jd->tx_len + len );
80	memcpy( jd->txq + jd->tx_len, buf, len );
81	jd->tx_len += len;
82
83	/* The return value for write() doesn't necessarily mean
84	that everything got sent, it mainly means that the
85	connection (officially) still exists and can still
86	be accessed without hitting SIGSEGV. IOW: */
87	ret = TRUE;
88	}
89
90	return ret;
91	}
92
93	/* Splitting up in two separate functions: One to use as a callback and one
94	to use in the function above to escape from having to wait for the event
95	handler to call us, if possible.
96
97	Two different functions are necessary because of the return values: The
98	callback should only return TRUE if the write was successful AND if the
99	buffer is not empty yet (ie. if the handler has to be called again when
100	the socket is ready for more data). */
101	static gboolean jabber_write_callback( gpointer data, gint fd, b_input_condition cond )
102	{
103	struct jabber_data jd = ((struct im_connection )data)->proto_data;
104
105	return jd->fd != -1 &&
106	jabber_write_queue( data ) &&
107	jd->tx_len > 0;
108	}
109
110	static gboolean jabber_write_queue( struct im_connection *ic )
111	{
112	struct jabber_data *jd = ic->proto_data;
113	int st;
114
115	if( jd->ssl )
116	st = ssl_write( jd->ssl, jd->txq, jd->tx_len );
117	else
118	st = write( jd->fd, jd->txq, jd->tx_len );
119
120	if( st == jd->tx_len )
121	{
122	/* We wrote everything, clear the buffer. */
123	g_free( jd->txq );
124	jd->txq = NULL;
125	jd->tx_len = 0;
126
127	return TRUE;
128	}
129	else if( st == 0 \|\| ( st < 0 && !ssl_sockerr_again( jd->ssl ) ) )
130	{
131	/* Set fd to -1 to make sure we won't write to it anymore. */
132	closesocket( jd->fd ); /* Shouldn't be necessary after errors? */
133	jd->fd = -1;
134
135	imcb_error( ic, "Short write() to server" );
136	imc_logout( ic, TRUE );
137	return FALSE;
138	}
139	else if( st > 0 )
140	{
141	char *s;
142
143	s = g_memdup( jd->txq + st, jd->tx_len - st );
144	jd->tx_len -= st;
145	g_free( jd->txq );
146	jd->txq = s;
147
148	return TRUE;
149	}
150	else
151	{
152	/* Just in case we had EINPROGRESS/EAGAIN: */
153
154	return TRUE;
155	}
156	}
157
158	static gboolean jabber_read_callback( gpointer data, gint fd, b_input_condition cond )
159	{
160	struct im_connection *ic = data;
161	struct jabber_data *jd = ic->proto_data;
162	char buf[512];
163	int st;
164
165	if( jd->fd == -1 )
166	return FALSE;
167
168	if( jd->ssl )
169	st = ssl_read( jd->ssl, buf, sizeof( buf ) );
170	else
171	st = read( jd->fd, buf, sizeof( buf ) );
172
173	if( st > 0 )
174	{
175	/* Parse. */
176	if( xt_feed( jd->xt, buf, st ) < 0 )
177	{
178	imcb_error( ic, "XML stream error" );
179	imc_logout( ic, TRUE );
180	return FALSE;
181	}
182
183	/* Execute all handlers. */
184	if( !xt_handle( jd->xt, NULL, 1 ) )
185	{
186	/* Don't do anything, the handlers should have
187	aborted the connection already. */
188	return FALSE;
189	}
190
191	if( jd->flags & JFLAG_STREAM_RESTART )
192	{
193	jd->flags &= ~JFLAG_STREAM_RESTART;
194	jabber_start_stream( ic );
195	}
196
197	/* Garbage collection. */
198	xt_cleanup( jd->xt, NULL, 1 );
199
200	/* This is a bit hackish, unfortunately. Although xmltree
201	has nifty event handler stuff, it only calls handlers
202	when nodes are complete. Since the server should only
203	send an opening <stream:stream> tag, we have to check
204	this by hand. :-( */
205	if( !( jd->flags & JFLAG_STREAM_STARTED ) && jd->xt && jd->xt->root )
206	{
207	if( g_strcasecmp( jd->xt->root->name, "stream:stream" ) == 0 )
208	{
209	jd->flags \|= JFLAG_STREAM_STARTED;
210
211	/* If there's no version attribute, assume
212	this is an old server that can't do SASL
213	authentication. */
214	if( !sasl_supported( ic ) )
215	{
216	/* If there's no version= tag, we suppose
217	this server does NOT implement: XMPP 1.0,
218	SASL and TLS. */
219	if( set_getbool( &ic->acc->set, "tls" ) )
220	{
221	imcb_error( ic, "TLS is turned on for this "
222	"account, but is not supported by this server" );
223	imc_logout( ic, FALSE );
224	return FALSE;
225	}
226	else
227	{
228	return jabber_init_iq_auth( ic );
229	}
230	}
231	}
232	else
233	{
234	imcb_error( ic, "XML stream error" );
235	imc_logout( ic, TRUE );
236	return FALSE;
237	}
238	}
239	}
240	else if( st == 0 \|\| ( st < 0 && !ssl_sockerr_again( jd->ssl ) ) )
241	{
242	closesocket( jd->fd );
243	jd->fd = -1;
244
245	imcb_error( ic, "Error while reading from server" );
246	imc_logout( ic, TRUE );
247	return FALSE;
248	}
249
250	if( ssl_pending( jd->ssl ) )
251	/* OpenSSL empties the TCP buffers completely but may keep some
252	data in its internap buffers. select() won't see that, but
253	ssl_pending() does. */
254	return jabber_read_callback( data, fd, cond );
255	else
256	return TRUE;
257	}
258
259	gboolean jabber_connected_plain( gpointer data, gint source, b_input_condition cond )
260	{
261	struct im_connection *ic = data;
262
263	if( g_slist_find( jabber_connections, ic ) == NULL )
264	return FALSE;
265
266	if( source == -1 )
267	{
268	imcb_error( ic, "Could not connect to server" );
269	imc_logout( ic, TRUE );
270	return FALSE;
271	}
272
273	imcb_log( ic, "Connected to server, logging in" );
274
275	return jabber_start_stream( ic );
276	}
277
278	gboolean jabber_connected_ssl( gpointer data, void *source, b_input_condition cond )
279	{
280	struct im_connection *ic = data;
281	struct jabber_data *jd;
282
283	if( g_slist_find( jabber_connections, ic ) == NULL )
284	return FALSE;
285
286	jd = ic->proto_data;
287
288	if( source == NULL )
289	{
290	/* The SSL connection will be cleaned up by the SSL lib
291	already, set it to NULL here to prevent a double cleanup: */
292	jd->ssl = NULL;
293
294	imcb_error( ic, "Could not connect to server" );
295	imc_logout( ic, TRUE );
296	return FALSE;
297	}
298
299	imcb_log( ic, "Connected to server, logging in" );
300
301	return jabber_start_stream( ic );
302	}
303
304	static xt_status jabber_end_of_stream( struct xt_node *node, gpointer data )
305	{
306	imc_logout( data, TRUE );
307	return XT_ABORT;
308	}
309
310	static xt_status jabber_pkt_features( struct xt_node *node, gpointer data )
311	{
312	struct im_connection *ic = data;
313	struct jabber_data *jd = ic->proto_data;
314	struct xt_node c, reply;
315	int trytls;
316
317	trytls = g_strcasecmp( set_getstr( &ic->acc->set, "tls" ), "try" ) == 0;
318	c = xt_find_node( node->children, "starttls" );
319	if( c && !jd->ssl )
320	{
321	/* If the server advertises the STARTTLS feature and if we're
322	not in a secure connection already: */
323
324	c = xt_find_node( c->children, "required" );
325
326	if( c && ( !trytls && !set_getbool( &ic->acc->set, "tls" ) ) )
327	{
328	imcb_error( ic, "Server requires TLS connections, but TLS is turned off for this account" );
329	imc_logout( ic, FALSE );
330
331	return XT_ABORT;
332	}
333
334	/* Only run this if the tls setting is set to true or try: */
335	if( ( trytls \|\| set_getbool( &ic->acc->set, "tls" ) ) )
336	{
337	reply = xt_new_node( "starttls", NULL, NULL );
338	xt_add_attr( reply, "xmlns", XMLNS_TLS );
339	if( !jabber_write_packet( ic, reply ) )
340	{
341	xt_free_node( reply );
342	return XT_ABORT;
343	}
344	xt_free_node( reply );
345
346	return XT_HANDLED;
347	}
348	}
349	else if( !c && !jd->ssl )
350	{
351	/* If the server does not advertise the STARTTLS feature and
352	we're not in a secure connection already: (Servers have a
353	habit of not advertising <starttls/> anymore when already
354	using SSL/TLS. */
355
356	if( !trytls && set_getbool( &ic->acc->set, "tls" ) )
357	{
358	imcb_error( ic, "TLS is turned on for this account, but is not supported by this server" );
359	imc_logout( ic, FALSE );
360
361	return XT_ABORT;
362	}
363	}
364
365	/* This one used to be in jabber_handlers[], but it has to be done
366	from here to make sure the TLS session will be initialized
367	properly before we attempt SASL authentication. */
368	if( ( c = xt_find_node( node->children, "mechanisms" ) ) )
369	{
370	if( sasl_pkt_mechanisms( c, data ) == XT_ABORT )
371	return XT_ABORT;
372	}
373	/* If the server SEEMS to support SASL authentication but doesn't
374	support it after all, we should try to do authentication the
375	other way. jabber.com doesn't seem to do SASL while it pretends
376	to be XMPP 1.0 compliant! */
377	else if( !( jd->flags & JFLAG_AUTHENTICATED ) && sasl_supported( ic ) )
378	{
379	if( !jabber_init_iq_auth( ic ) )
380	return XT_ABORT;
381	}
382
383	if( ( c = xt_find_node( node->children, "bind" ) ) )
384	jd->flags \|= JFLAG_WANT_BIND;
385
386	if( ( c = xt_find_node( node->children, "session" ) ) )
387	jd->flags \|= JFLAG_WANT_SESSION;
388
389	if( jd->flags & JFLAG_AUTHENTICATED )
390	return jabber_pkt_bind_sess( ic, NULL, NULL );
391
392	return XT_HANDLED;
393	}
394
395	static xt_status jabber_pkt_proceed_tls( struct xt_node *node, gpointer data )
396	{
397	struct im_connection *ic = data;
398	struct jabber_data *jd = ic->proto_data;
399	char *xmlns;
400
401	xmlns = xt_find_attr( node, "xmlns" );
402
403	/* Just ignore it when it doesn't seem to be TLS-related (is that at
404	all possible??). */
405	if( !xmlns \|\| strcmp( xmlns, XMLNS_TLS ) != 0 )
406	return XT_HANDLED;
407
408	/* We don't want event handlers to touch our TLS session while it's
409	still initializing! */
410	b_event_remove( jd->r_inpa );
411	if( jd->tx_len > 0 )
412	{
413	/* Actually the write queue should be empty here, but just
414	to be sure... */
415	b_event_remove( jd->w_inpa );
416	g_free( jd->txq );
417	jd->txq = NULL;
418	jd->tx_len = 0;
419	}
420	jd->w_inpa = jd->r_inpa = 0;
421
422	imcb_log( ic, "Converting stream to TLS" );
423
424	jd->flags \|= JFLAG_STARTTLS_DONE;
425	jd->ssl = ssl_starttls( jd->fd, jabber_connected_ssl, ic );
426
427	return XT_HANDLED;
428	}
429
430	static xt_status jabber_pkt_stream_error( struct xt_node *node, gpointer data )
431	{
432	struct im_connection *ic = data;
433	int allow_reconnect = TRUE;
434	struct jabber_error *err;
435
436	err = jabber_error_parse( node, XMLNS_STREAM_ERROR );
437
438	/* Tssk... */
439	if( err->code == NULL )
440	{
441	imcb_error( ic, "Unknown stream error reported by server" );
442	imc_logout( ic, allow_reconnect );
443	jabber_error_free( err );
444	return XT_ABORT;
445	}
446
447	/* We know that this is a fatal error. If it's a "conflict" error, we
448	should turn off auto-reconnect to make sure we won't get some nasty
449	infinite loop! */
450	if( strcmp( err->code, "conflict" ) == 0 )
451	{
452	imcb_error( ic, "Account and resource used from a different location" );
453	allow_reconnect = FALSE;
454	}
455	else
456	{
457	imcb_error( ic, "Stream error: %s%s%s", err->code, err->text ? ": " : "",
458	err->text ? err->text : "" );
459	}
460
461	jabber_error_free( err );
462	imc_logout( ic, allow_reconnect );
463
464	return XT_ABORT;
465	}
466
467	static xt_status jabber_xmlconsole( struct xt_node *node, gpointer data )
468	{
469	struct im_connection *ic = data;
470	struct jabber_data *jd = ic->proto_data;
471
472	if( jd->flags & JFLAG_XMLCONSOLE )
473	{
474	char msg, pkt;
475
476	pkt = xt_to_string( node );
477	msg = g_strdup_printf( "RX: %s", pkt );
478	imcb_buddy_msg( ic, JABBER_XMLCONSOLE_HANDLE, msg, 0, 0 );
479	g_free( msg );
480	g_free( pkt );
481	}
482
483	return XT_NEXT;
484	}
485
486	static const struct xt_handler_entry jabber_handlers[] = {
487	{ NULL, "stream:stream", jabber_xmlconsole },
488	{ "stream:stream", "<root>", jabber_end_of_stream },
489	{ "message", "stream:stream", jabber_pkt_message },
490	{ "presence", "stream:stream", jabber_pkt_presence },
491	{ "iq", "stream:stream", jabber_pkt_iq },
492	{ "stream:features", "stream:stream", jabber_pkt_features },
493	{ "stream:error", "stream:stream", jabber_pkt_stream_error },
494	{ "proceed", "stream:stream", jabber_pkt_proceed_tls },
495	{ "challenge", "stream:stream", sasl_pkt_challenge },
496	{ "success", "stream:stream", sasl_pkt_result },
497	{ "failure", "stream:stream", sasl_pkt_result },
498	{ NULL, NULL, NULL }
499	};
500
501	gboolean jabber_start_stream( struct im_connection *ic )
502	{
503	struct jabber_data *jd = ic->proto_data;
504	int st;
505	char *greet;
506
507	/* We'll start our stream now, so prepare everything to receive one
508	from the server too. */
509	xt_free( jd->xt ); /* In case we're RE-starting. */
510	jd->xt = xt_new( jabber_handlers, ic );
511
512	if( jd->r_inpa <= 0 )
513	jd->r_inpa = b_input_add( jd->fd, B_EV_IO_READ, jabber_read_callback, ic );
514
515	greet = g_strdup_printf( "%s<stream:stream to=\"%s\" xmlns=\"jabber:client\" "
516	"xmlns:stream=\"http://etherx.jabber.org/streams\" version=\"1.0\">",
517	( jd->flags & JFLAG_STARTTLS_DONE ) ? "" : "<?xml version='1.0' ?>",
518	jd->server );
519
520	st = jabber_write( ic, greet, strlen( greet ) );
521
522	g_free( greet );
523
524	return st;
525	}
526
527	void jabber_end_stream( struct im_connection *ic )
528	{
529	struct jabber_data *jd = ic->proto_data;
530
531	/* Let's only do this if the queue is currently empty, otherwise it'd
532	take too long anyway. */
533	if( jd->tx_len == 0 )
534	{
535	char eos[] = "</stream:stream>";
536	struct xt_node *node;
537	int st = 1;
538
539	if( ic->flags & OPT_LOGGED_IN )
540	{
541	node = jabber_make_packet( "presence", "unavailable", NULL, NULL );
542	st = jabber_write_packet( ic, node );
543	xt_free_node( node );
544	}
545
546	if( st )
547	jabber_write( ic, eos, strlen( eos ) );
548	}
549	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: