Context Navigation

source: protocols/jabber/io.c @ d6ddff0

Last change on this file since d6ddff0 was ad46e4d, checked in by Wilmer van der Gaast <wilmer@…>, at 2011-12-22T11:23:18Z
Use initgroups() as well when dropping privileges. Closes bug #852.
Property mode set to `100644`
File size: 15.8 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 && !( ic->flags & OPT_LOGGING_OUT ) )
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	if( jd->flags & JFLAG_MOCK )
176	return TRUE;
177
178	/* Parse. */
179	if( xt_feed( jd->xt, buf, st ) < 0 )
180	{
181	imcb_error( ic, "XML stream error" );
182	imc_logout( ic, TRUE );
183	return FALSE;
184	}
185
186	/* Execute all handlers. */
187	if( !xt_handle( jd->xt, NULL, 1 ) )
188	{
189	/* Don't do anything, the handlers should have
190	aborted the connection already. */
191	return FALSE;
192	}
193
194	if( jd->flags & JFLAG_STREAM_RESTART )
195	{
196	jd->flags &= ~JFLAG_STREAM_RESTART;
197	jabber_start_stream( ic );
198	}
199
200	/* Garbage collection. */
201	xt_cleanup( jd->xt, NULL, 1 );
202
203	/* This is a bit hackish, unfortunately. Although xmltree
204	has nifty event handler stuff, it only calls handlers
205	when nodes are complete. Since the server should only
206	send an opening <stream:stream> tag, we have to check
207	this by hand. :-( */
208	if( !( jd->flags & JFLAG_STREAM_STARTED ) && jd->xt && jd->xt->root )
209	{
210	if( g_strcasecmp( jd->xt->root->name, "stream:stream" ) == 0 )
211	{
212	jd->flags \|= JFLAG_STREAM_STARTED;
213
214	/* If there's no version attribute, assume
215	this is an old server that can't do SASL
216	authentication. */
217	if( !set_getbool( &ic->acc->set, "sasl") \|\| !sasl_supported( ic ) )
218	{
219	/* If there's no version= tag, we suppose
220	this server does NOT implement: XMPP 1.0,
221	SASL and TLS. */
222	if( set_getbool( &ic->acc->set, "tls" ) )
223	{
224	imcb_error( ic, "TLS is turned on for this "
225	"account, but is not supported by this server" );
226	imc_logout( ic, FALSE );
227	return FALSE;
228	}
229	else
230	{
231	return jabber_init_iq_auth( ic );
232	}
233	}
234	}
235	else
236	{
237	imcb_error( ic, "XML stream error" );
238	imc_logout( ic, TRUE );
239	return FALSE;
240	}
241	}
242	}
243	else if( st == 0 \|\| ( st < 0 && !ssl_sockerr_again( jd->ssl ) ) )
244	{
245	closesocket( jd->fd );
246	jd->fd = -1;
247
248	imcb_error( ic, "Error while reading from server" );
249	imc_logout( ic, TRUE );
250	return FALSE;
251	}
252
253	if( ssl_pending( jd->ssl ) )
254	/* OpenSSL empties the TCP buffers completely but may keep some
255	data in its internap buffers. select() won't see that, but
256	ssl_pending() does. */
257	return jabber_read_callback( data, fd, cond );
258	else
259	return TRUE;
260	}
261
262	gboolean jabber_connected_plain( gpointer data, gint source, b_input_condition cond )
263	{
264	struct im_connection *ic = data;
265
266	if( g_slist_find( jabber_connections, ic ) == NULL )
267	return FALSE;
268
269	if( source == -1 )
270	{
271	imcb_error( ic, "Could not connect to server" );
272	imc_logout( ic, TRUE );
273	return FALSE;
274	}
275
276	imcb_log( ic, "Connected to server, logging in" );
277
278	return jabber_start_stream( ic );
279	}
280
281	gboolean jabber_connected_ssl( gpointer data, void *source, b_input_condition cond )
282	{
283	struct im_connection *ic = data;
284	struct jabber_data *jd;
285
286	if( g_slist_find( jabber_connections, ic ) == NULL )
287	return FALSE;
288
289	jd = ic->proto_data;
290
291	if( source == NULL )
292	{
293	/* The SSL connection will be cleaned up by the SSL lib
294	already, set it to NULL here to prevent a double cleanup: */
295	jd->ssl = NULL;
296
297	imcb_error( ic, "Could not connect to server" );
298	imc_logout( ic, TRUE );
299	return FALSE;
300	}
301
302	imcb_log( ic, "Connected to server, logging in" );
303
304	return jabber_start_stream( ic );
305	}
306
307	static xt_status jabber_end_of_stream( struct xt_node *node, gpointer data )
308	{
309	imc_logout( data, TRUE );
310	return XT_ABORT;
311	}
312
313	static xt_status jabber_pkt_features( struct xt_node *node, gpointer data )
314	{
315	struct im_connection *ic = data;
316	struct jabber_data *jd = ic->proto_data;
317	struct xt_node c, reply;
318	int trytls;
319
320	trytls = g_strcasecmp( set_getstr( &ic->acc->set, "tls" ), "try" ) == 0;
321	c = xt_find_node( node->children, "starttls" );
322	if( c && !jd->ssl )
323	{
324	/* If the server advertises the STARTTLS feature and if we're
325	not in a secure connection already: */
326
327	c = xt_find_node( c->children, "required" );
328
329	if( c && ( !trytls && !set_getbool( &ic->acc->set, "tls" ) ) )
330	{
331	imcb_error( ic, "Server requires TLS connections, but TLS is turned off for this account" );
332	imc_logout( ic, FALSE );
333
334	return XT_ABORT;
335	}
336
337	/* Only run this if the tls setting is set to true or try: */
338	if( ( trytls \|\| set_getbool( &ic->acc->set, "tls" ) ) )
339	{
340	reply = xt_new_node( "starttls", NULL, NULL );
341	xt_add_attr( reply, "xmlns", XMLNS_TLS );
342	if( !jabber_write_packet( ic, reply ) )
343	{
344	xt_free_node( reply );
345	return XT_ABORT;
346	}
347	xt_free_node( reply );
348
349	return XT_HANDLED;
350	}
351	}
352	else if( !c && !jd->ssl )
353	{
354	/* If the server does not advertise the STARTTLS feature and
355	we're not in a secure connection already: (Servers have a
356	habit of not advertising <starttls/> anymore when already
357	using SSL/TLS. */
358
359	if( !trytls && set_getbool( &ic->acc->set, "tls" ) )
360	{
361	imcb_error( ic, "TLS is turned on for this account, but is not supported by this server" );
362	imc_logout( ic, FALSE );
363
364	return XT_ABORT;
365	}
366	}
367
368	/* This one used to be in jabber_handlers[], but it has to be done
369	from here to make sure the TLS session will be initialized
370	properly before we attempt SASL authentication. */
371	if( ( c = xt_find_node( node->children, "mechanisms" ) ) )
372	{
373	if( sasl_pkt_mechanisms( c, data ) == XT_ABORT )
374	return XT_ABORT;
375	}
376	/* If the server SEEMS to support SASL authentication but doesn't
377	support it after all, we should try to do authentication the
378	other way. jabber.com doesn't seem to do SASL while it pretends
379	to be XMPP 1.0 compliant! */
380	else if( !( jd->flags & JFLAG_AUTHENTICATED ) && set_getbool( &ic->acc->set, "sasl") && sasl_supported( ic ) )
381	{
382	if( !jabber_init_iq_auth( ic ) )
383	return XT_ABORT;
384	}
385
386	if( ( c = xt_find_node( node->children, "bind" ) ) )
387	jd->flags \|= JFLAG_WANT_BIND;
388
389	if( ( c = xt_find_node( node->children, "session" ) ) )
390	jd->flags \|= JFLAG_WANT_SESSION;
391
392	if( jd->flags & JFLAG_AUTHENTICATED )
393	return jabber_pkt_bind_sess( ic, NULL, NULL );
394
395	return XT_HANDLED;
396	}
397
398	static xt_status jabber_pkt_proceed_tls( struct xt_node *node, gpointer data )
399	{
400	struct im_connection *ic = data;
401	struct jabber_data *jd = ic->proto_data;
402	char *xmlns;
403
404	xmlns = xt_find_attr( node, "xmlns" );
405
406	/* Just ignore it when it doesn't seem to be TLS-related (is that at
407	all possible??). */
408	if( !xmlns \|\| strcmp( xmlns, XMLNS_TLS ) != 0 )
409	return XT_HANDLED;
410
411	/* We don't want event handlers to touch our TLS session while it's
412	still initializing! */
413	b_event_remove( jd->r_inpa );
414	if( jd->tx_len > 0 )
415	{
416	/* Actually the write queue should be empty here, but just
417	to be sure... */
418	b_event_remove( jd->w_inpa );
419	g_free( jd->txq );
420	jd->txq = NULL;
421	jd->tx_len = 0;
422	}
423	jd->w_inpa = jd->r_inpa = 0;
424
425	imcb_log( ic, "Converting stream to TLS" );
426
427	jd->flags \|= JFLAG_STARTTLS_DONE;
428	jd->ssl = ssl_starttls( jd->fd, jabber_connected_ssl, ic );
429
430	return XT_HANDLED;
431	}
432
433	static xt_status jabber_pkt_stream_error( struct xt_node *node, gpointer data )
434	{
435	struct im_connection *ic = data;
436	int allow_reconnect = TRUE;
437	struct jabber_error *err;
438
439	err = jabber_error_parse( node, XMLNS_STREAM_ERROR );
440
441	/* Tssk... */
442	if( err->code == NULL )
443	{
444	imcb_error( ic, "Unknown stream error reported by server" );
445	imc_logout( ic, allow_reconnect );
446	jabber_error_free( err );
447	return XT_ABORT;
448	}
449
450	/* We know that this is a fatal error. If it's a "conflict" error, we
451	should turn off auto-reconnect to make sure we won't get some nasty
452	infinite loop! */
453	if( strcmp( err->code, "conflict" ) == 0 )
454	{
455	imcb_error( ic, "Account and resource used from a different location" );
456	allow_reconnect = FALSE;
457	}
458	else
459	{
460	imcb_error( ic, "Stream error: %s%s%s", err->code, err->text ? ": " : "",
461	err->text ? err->text : "" );
462	}
463
464	jabber_error_free( err );
465	imc_logout( ic, allow_reconnect );
466
467	return XT_ABORT;
468	}
469
470	static xt_status jabber_xmlconsole( struct xt_node *node, gpointer data )
471	{
472	struct im_connection *ic = data;
473	struct jabber_data *jd = ic->proto_data;
474
475	if( jd->flags & JFLAG_XMLCONSOLE )
476	{
477	char msg, pkt;
478
479	pkt = xt_to_string( node );
480	msg = g_strdup_printf( "RX: %s", pkt );
481	imcb_buddy_msg( ic, JABBER_XMLCONSOLE_HANDLE, msg, 0, 0 );
482	g_free( msg );
483	g_free( pkt );
484	}
485
486	return XT_NEXT;
487	}
488
489	static const struct xt_handler_entry jabber_handlers[] = {
490	{ NULL, "stream:stream", jabber_xmlconsole },
491	{ "stream:stream", "<root>", jabber_end_of_stream },
492	{ "message", "stream:stream", jabber_pkt_message },
493	{ "presence", "stream:stream", jabber_pkt_presence },
494	{ "iq", "stream:stream", jabber_pkt_iq },
495	{ "stream:features", "stream:stream", jabber_pkt_features },
496	{ "stream:error", "stream:stream", jabber_pkt_stream_error },
497	{ "proceed", "stream:stream", jabber_pkt_proceed_tls },
498	{ "challenge", "stream:stream", sasl_pkt_challenge },
499	{ "success", "stream:stream", sasl_pkt_result },
500	{ "failure", "stream:stream", sasl_pkt_result },
501	{ NULL, NULL, NULL }
502	};
503
504	gboolean jabber_start_stream( struct im_connection *ic )
505	{
506	struct jabber_data *jd = ic->proto_data;
507	int st;
508	char *greet;
509
510	/* We'll start our stream now, so prepare everything to receive one
511	from the server too. */
512	xt_free( jd->xt ); /* In case we're RE-starting. */
513	jd->xt = xt_new( jabber_handlers, ic );
514
515	if( jd->r_inpa <= 0 )
516	jd->r_inpa = b_input_add( jd->fd, B_EV_IO_READ, jabber_read_callback, ic );
517
518	greet = g_strdup_printf( "%s<stream:stream to=\"%s\" xmlns=\"jabber:client\" "
519	"xmlns:stream=\"http://etherx.jabber.org/streams\" version=\"1.0\">",
520	( jd->flags & JFLAG_STARTTLS_DONE ) ? "" : "<?xml version='1.0' ?>",
521	jd->server );
522
523	st = jabber_write( ic, greet, strlen( greet ) );
524
525	g_free( greet );
526
527	return st;
528	}
529
530	void jabber_end_stream( struct im_connection *ic )
531	{
532	struct jabber_data *jd = ic->proto_data;
533
534	/* Let's only do this if the queue is currently empty, otherwise it'd
535	take too long anyway. */
536	if( jd->tx_len == 0 )
537	{
538	char eos[] = "</stream:stream>";
539	struct xt_node *node;
540	int st = 1;
541
542	if( ic->flags & OPT_LOGGED_IN )
543	{
544	node = jabber_make_packet( "presence", "unavailable", NULL, NULL );
545	st = jabber_write_packet( ic, node );
546	xt_free_node( node );
547	}
548
549	if( st )
550	jabber_write( ic, eos, strlen( eos ) );
551	}
552	}

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

Download in other formats: