Context Navigation

source: protocols/jabber/io.c @ fb020ac

Last change on this file since fb020ac was e046390, checked in by Wilmer van der Gaast <wilmer@…>, at 2009-10-10T23:25:54Z

Make purple use BitlBee's event handling API. Since the APIs never really
diverged too much this is fairly transparent. I did rename and redefine
GAIM_INPUT_* variables to really make it work without adding another stupid
layer in between.

One problem left, the new libpurple input API doesn't care about return
values. Fixing that in the next CL.

Property mode set to 100644

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

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

Download in other formats: