Context Navigation

source: protocols/msn/sb.c @ c564e25

Last change on this file since c564e25 was fe79de66, checked in by Wilmer van der Gaast <wilmer@…>, at 2012-09-16T20:42:11Z
One more semicolon check (BYE command).
Property mode set to `100644`
File size: 19.6 KB

Line
1	/********************************************************************\
2	* BitlBee -- An IRC to other IM-networks gateway *
3	* *
4	* Copyright 2002-2012 Wilmer van der Gaast and others *
5	\********************************************************************/
6
7	/* MSN module - Switchboard server callbacks and utilities */
8
9	/*
10	This program is free software; you can redistribute it and/or modify
11	it under the terms of the GNU General Public License as published by
12	the Free Software Foundation; either version 2 of the License, or
13	(at your option) any later version.
14
15	This program is distributed in the hope that it will be useful,
16	but WITHOUT ANY WARRANTY; without even the implied warranty of
17	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18	GNU General Public License for more details.
19
20	You should have received a copy of the GNU General Public License with
21	the Debian GNU/Linux distribution in /usr/share/common-licenses/GPL;
22	if not, write to the Free Software Foundation, Inc., 59 Temple Place,
23	Suite 330, Boston, MA 02111-1307 USA
24	*/
25
26	#include <ctype.h>
27	#include "nogaim.h"
28	#include "msn.h"
29	#include "md5.h"
30	#include "soap.h"
31	#include "invitation.h"
32
33	static gboolean msn_sb_callback( gpointer data, gint source, b_input_condition cond );
34	static int msn_sb_command( struct msn_handler_data handler, char *cmd, int num_parts );
35	static int msn_sb_message( struct msn_handler_data handler, char msg, int msglen, char **cmd, int num_parts );
36
37	int msn_sb_write( struct msn_switchboard sb, const char fmt, ... )
38	{
39	va_list params;
40	char *out;
41	size_t len;
42	int st;
43
44	va_start( params, fmt );
45	out = g_strdup_vprintf( fmt, params );
46	va_end( params );
47
48	if( getenv( "BITLBEE_DEBUG" ) )
49	fprintf( stderr, "->SB%d:%s\n", sb->fd, out );
50
51	len = strlen( out );
52	st = write( sb->fd, out, len );
53	g_free( out );
54	if( st != len )
55	{
56	msn_sb_destroy( sb );
57	return 0;
58	}
59
60	return 1;
61	}
62
63	int msn_sb_write_msg( struct im_connection ic, struct msn_message m )
64	{
65	struct msn_data *md = ic->proto_data;
66	struct msn_switchboard *sb;
67
68	/* FIXME: CHECK the reliability of using spare sb's! */
69	if( ( sb = msn_sb_spare( ic ) ) )
70	{
71	debug( "Trying to use a spare switchboard to message %s", m->who );
72
73	sb->who = g_strdup( m->who );
74	if( msn_sb_write( sb, "CAL %d %s\r\n", ++sb->trId, m->who ) )
75	{
76	/* He/She should join the switchboard soon, let's queue the message. */
77	sb->msgq = g_slist_append( sb->msgq, m );
78	return( 1 );
79	}
80	}
81
82	debug( "Creating a new switchboard to message %s", m->who );
83
84	/* If we reach this line, there was no spare switchboard, so let's make one. */
85	if( !msn_ns_write( ic, -1, "XFR %d SB\r\n", ++md->trId ) )
86	{
87	g_free( m->who );
88	g_free( m->text );
89	g_free( m );
90
91	return( 0 );
92	}
93
94	/* And queue the message to md. We'll pick it up when the switchboard comes up. */
95	md->msgq = g_slist_append( md->msgq, m );
96
97	/* FIXME: If the switchboard creation fails, the message will not be sent. */
98
99	return( 1 );
100	}
101
102	struct msn_switchboard msn_sb_create( struct im_connection ic, char host, int port, char key, int session )
103	{
104	struct msn_data *md = ic->proto_data;
105	struct msn_switchboard *sb = g_new0( struct msn_switchboard, 1 );
106
107	sb->fd = proxy_connect( host, port, msn_sb_connected, sb );
108	if( sb->fd < 0 )
109	{
110	g_free( sb );
111	return( NULL );
112	}
113
114	sb->ic = ic;
115	sb->key = g_strdup( key );
116	sb->session = session;
117
118	msn_switchboards = g_slist_append( msn_switchboards, sb );
119	md->switchboards = g_slist_append( md->switchboards, sb );
120
121	return( sb );
122	}
123
124	struct msn_switchboard msn_sb_by_handle( struct im_connection ic, const char *handle )
125	{
126	struct msn_data *md = ic->proto_data;
127	struct msn_switchboard *sb;
128	GSList *l;
129
130	for( l = md->switchboards; l; l = l->next )
131	{
132	sb = l->data;
133	if( sb->who && strcmp( sb->who, handle ) == 0 )
134	return( sb );
135	}
136
137	return( NULL );
138	}
139
140	struct msn_switchboard msn_sb_by_chat( struct groupchat c )
141	{
142	struct msn_data *md = c->ic->proto_data;
143	struct msn_switchboard *sb;
144	GSList *l;
145
146	for( l = md->switchboards; l; l = l->next )
147	{
148	sb = l->data;
149	if( sb->chat == c )
150	return( sb );
151	}
152
153	return( NULL );
154	}
155
156	struct msn_switchboard msn_sb_spare( struct im_connection ic )
157	{
158	struct msn_data *md = ic->proto_data;
159	struct msn_switchboard *sb;
160	GSList *l;
161
162	for( l = md->switchboards; l; l = l->next )
163	{
164	sb = l->data;
165	if( !sb->who && !sb->chat )
166	return( sb );
167	}
168
169	return( NULL );
170	}
171
172	int msn_sb_sendmessage( struct msn_switchboard sb, char text )
173	{
174	if( sb->ready )
175	{
176	char *buf;
177	int i, j;
178
179	/* Build the message. Convert LF to CR-LF for normal messages. */
180	if( strcmp( text, TYPING_NOTIFICATION_MESSAGE ) == 0 )
181	{
182	i = strlen( MSN_TYPING_HEADERS ) + strlen( sb->ic->acc->user );
183	buf = g_new0( char, i );
184	i = g_snprintf( buf, i, MSN_TYPING_HEADERS, sb->ic->acc->user );
185	}
186	else if( strcmp( text, NUDGE_MESSAGE ) == 0 )
187	{
188	buf = g_strdup( MSN_NUDGE_HEADERS );
189	i = strlen( buf );
190	}
191	else if( strcmp( text, SB_KEEPALIVE_MESSAGE ) == 0 )
192	{
193	buf = g_strdup( MSN_SB_KEEPALIVE_HEADERS );
194	i = strlen( buf );
195	}
196	else if( strncmp( text, MSN_INVITE_HEADERS, sizeof( MSN_INVITE_HEADERS ) - 1 ) == 0 )
197	{
198	buf = g_strdup( text );
199	i = strlen( buf );
200	}
201	else
202	{
203	buf = g_new0( char, sizeof( MSN_MESSAGE_HEADERS ) + strlen( text ) * 2 + 1 );
204	i = strlen( MSN_MESSAGE_HEADERS );
205
206	strcpy( buf, MSN_MESSAGE_HEADERS );
207	for( j = 0; text[j]; j ++ )
208	{
209	if( text[j] == '\n' )
210	buf[i++] = '\r';
211
212	buf[i++] = text[j];
213	}
214	}
215
216	/* Build the final packet (MSG command + the message). */
217	if( msn_sb_write( sb, "MSG %d N %d\r\n%s", ++sb->trId, i, buf ) )
218	{
219	g_free( buf );
220	return 1;
221	}
222	else
223	{
224	g_free( buf );
225	return 0;
226	}
227	}
228	else if( sb->who )
229	{
230	struct msn_message *m = g_new0( struct msn_message, 1 );
231
232	m->who = g_strdup( "" );
233	m->text = g_strdup( text );
234	sb->msgq = g_slist_append( sb->msgq, m );
235
236	return( 1 );
237	}
238	else
239	{
240	return( 0 );
241	}
242	}
243
244	struct groupchat msn_sb_to_chat( struct msn_switchboard sb )
245	{
246	struct im_connection *ic = sb->ic;
247	struct groupchat *c = NULL;
248	char buf[1024];
249
250	/* Create the groupchat structure. */
251	g_snprintf( buf, sizeof( buf ), "MSN groupchat session %d", sb->session );
252	if( sb->who )
253	c = bee_chat_by_title( ic->bee, ic, sb->who );
254	if( c && !msn_sb_by_chat( c ) )
255	sb->chat = c;
256	else
257	sb->chat = imcb_chat_new( ic, buf );
258
259	/* Populate the channel. */
260	if( sb->who ) imcb_chat_add_buddy( sb->chat, sb->who );
261	imcb_chat_add_buddy( sb->chat, ic->acc->user );
262
263	/* And make sure the switchboard doesn't look like a regular chat anymore. */
264	if( sb->who )
265	{
266	g_free( sb->who );
267	sb->who = NULL;
268	}
269
270	return sb->chat;
271	}
272
273	void msn_sb_destroy( struct msn_switchboard *sb )
274	{
275	struct im_connection *ic = sb->ic;
276	struct msn_data *md = ic->proto_data;
277
278	debug( "Destroying switchboard: %s", sb->who ? sb->who : sb->key ? sb->key : "" );
279
280	msn_msgq_purge( ic, &sb->msgq );
281	msn_sb_stop_keepalives( sb );
282
283	if( sb->key ) g_free( sb->key );
284	if( sb->who ) g_free( sb->who );
285
286	if( sb->chat )
287	{
288	imcb_chat_free( sb->chat );
289	}
290
291	if( sb->handler )
292	{
293	if( sb->handler->rxq ) g_free( sb->handler->rxq );
294	if( sb->handler->cmd_text ) g_free( sb->handler->cmd_text );
295	g_free( sb->handler );
296	}
297
298	if( sb->inp ) b_event_remove( sb->inp );
299	closesocket( sb->fd );
300
301	msn_switchboards = g_slist_remove( msn_switchboards, sb );
302	md->switchboards = g_slist_remove( md->switchboards, sb );
303	g_free( sb );
304	}
305
306	gboolean msn_sb_connected( gpointer data, gint source, b_input_condition cond )
307	{
308	struct msn_switchboard *sb = data;
309	struct im_connection *ic;
310	struct msn_data *md;
311	char buf[1024];
312
313	/* Are we still alive? */
314	if( !g_slist_find( msn_switchboards, sb ) )
315	return FALSE;
316
317	ic = sb->ic;
318	md = ic->proto_data;
319
320	if( source != sb->fd )
321	{
322	debug( "Error %d while connecting to switchboard server", 1 );
323	msn_sb_destroy( sb );
324	return FALSE;
325	}
326
327	/* Prepare the callback */
328	sb->handler = g_new0( struct msn_handler_data, 1 );
329	sb->handler->fd = sb->fd;
330	sb->handler->rxq = g_new0( char, 1 );
331	sb->handler->data = sb;
332	sb->handler->exec_command = msn_sb_command;
333	sb->handler->exec_message = msn_sb_message;
334
335	if( sb->session == MSN_SB_NEW )
336	g_snprintf( buf, sizeof( buf ), "USR %d %s;{%s} %s\r\n", ++sb->trId, ic->acc->user, md->uuid, sb->key );
337	else
338	g_snprintf( buf, sizeof( buf ), "ANS %d %s;{%s} %s %d\r\n", ++sb->trId, ic->acc->user, md->uuid, sb->key, sb->session );
339
340	if( msn_sb_write( sb, "%s", buf ) )
341	sb->inp = b_input_add( sb->fd, B_EV_IO_READ, msn_sb_callback, sb );
342	else
343	debug( "Error %d while connecting to switchboard server", 2 );
344
345	return FALSE;
346	}
347
348	static gboolean msn_sb_callback( gpointer data, gint source, b_input_condition cond )
349	{
350	struct msn_switchboard *sb = data;
351	struct im_connection *ic = sb->ic;
352	struct msn_data *md = ic->proto_data;
353
354	if( msn_handler( sb->handler ) != -1 )
355	return TRUE;
356
357	if( sb->msgq != NULL )
358	{
359	time_t now = time( NULL );
360
361	if( now - md->first_sb_failure > 600 )
362	{
363	/* It's not really the first one, but the start of this "series".
364	With this, the warning below will be shown only if this happens
365	at least three times in ten minutes. This algorithm isn't
366	perfect, but for this purpose it will do. */
367	md->first_sb_failure = now;
368	md->sb_failures = 0;
369	}
370
371	debug( "Error: Switchboard died" );
372	if( ++ md->sb_failures >= 3 )
373	imcb_log( ic, "Warning: Many switchboard failures on MSN connection. "
374	"There might be problems delivering your messages." );
375
376	if( md->msgq == NULL )
377	{
378	md->msgq = sb->msgq;
379	}
380	else
381	{
382	GSList *l;
383
384	for( l = md->msgq; l->next; l = l->next );
385	l->next = sb->msgq;
386	}
387	sb->msgq = NULL;
388
389	debug( "Moved queued messages back to the main queue, "
390	"creating a new switchboard to retry." );
391	if( !msn_ns_write( ic, -1, "XFR %d SB\r\n", ++md->trId ) )
392	return FALSE;
393	}
394
395	msn_sb_destroy( sb );
396	return FALSE;
397	}
398
399	static int msn_sb_command( struct msn_handler_data handler, char *cmd, int num_parts )
400	{
401	struct msn_switchboard *sb = handler->data;
402	struct im_connection *ic = sb->ic;
403
404	if( !num_parts )
405	{
406	/* Hrrm... Empty command...? Ignore? */
407	return( 1 );
408	}
409
410	if( strcmp( cmd[0], "XFR" ) == 0 )
411	{
412	imcb_error( ic, "Received an XFR from a switchboard server, unable to comply! This is likely to be a bug, please report it!" );
413	imc_logout( ic, TRUE );
414	return( 0 );
415	}
416	else if( strcmp( cmd[0], "USR" ) == 0 )
417	{
418	if( num_parts < 5 )
419	{
420	msn_sb_destroy( sb );
421	return( 0 );
422	}
423
424	if( strcmp( cmd[2], "OK" ) != 0 )
425	{
426	msn_sb_destroy( sb );
427	return( 0 );
428	}
429
430	if( sb->who )
431	return msn_sb_write( sb, "CAL %d %s\r\n", ++sb->trId, sb->who );
432	else
433	debug( "Just created a switchboard, but I don't know what to do with it." );
434	}
435	else if( strcmp( cmd[0], "IRO" ) == 0 )
436	{
437	int num, tot;
438
439	if( num_parts < 6 )
440	{
441	msn_sb_destroy( sb );
442	return( 0 );
443	}
444
445	num = atoi( cmd[2] );
446	tot = atoi( cmd[3] );
447
448	if( tot <= 0 )
449	{
450	msn_sb_destroy( sb );
451	return( 0 );
452	}
453	else if( tot > 1 )
454	{
455	char buf[1024];
456
457	/* For as much as I understand this MPOP stuff now, a
458	switchboard has two (or more) roster entries per
459	participant. One "bare JID" and one JID;UUID. Ignore
460	the latter. */
461	if( !strchr( cmd[4], ';' ) )
462	{
463	/* HACK: Since even 1:1 chats now have >2 participants
464	(ourselves included) it gets hard to tell them apart
465	from rooms. Let's hope this is enough: */
466	if( sb->chat == NULL && num != tot )
467	{
468	g_snprintf( buf, sizeof( buf ), "MSN groupchat session %d", sb->session );
469	sb->chat = imcb_chat_new( ic, buf );
470
471	g_free( sb->who );
472	sb->who = NULL;
473	}
474
475	if( sb->chat )
476	imcb_chat_add_buddy( sb->chat, cmd[4] );
477	}
478
479	/* We have the full roster, start showing the channel to
480	the user. */
481	if( num == tot && sb->chat )
482	{
483	imcb_chat_add_buddy( sb->chat, ic->acc->user );
484	}
485	}
486	}
487	else if( strcmp( cmd[0], "ANS" ) == 0 )
488	{
489	if( num_parts < 3 )
490	{
491	msn_sb_destroy( sb );
492	return( 0 );
493	}
494
495	if( strcmp( cmd[2], "OK" ) != 0 )
496	{
497	debug( "Switchboard server sent a negative ANS reply" );
498	msn_sb_destroy( sb );
499	return( 0 );
500	}
501
502	sb->ready = 1;
503
504	msn_sb_start_keepalives( sb, FALSE );
505	}
506	else if( strcmp( cmd[0], "CAL" ) == 0 )
507	{
508	if( num_parts < 4 \|\| !isdigit( cmd[3][0] ) )
509	{
510	msn_sb_destroy( sb );
511	return( 0 );
512	}
513
514	sb->session = atoi( cmd[3] );
515	}
516	else if( strcmp( cmd[0], "JOI" ) == 0 )
517	{
518	if( num_parts < 3 )
519	{
520	msn_sb_destroy( sb );
521	return( 0 );
522	}
523
524	/* See IRO above. Handle "bare JIDs" only. */
525	if( strchr( cmd[1], ';' ) )
526	return 1;
527
528	if( sb->who && g_strcasecmp( cmd[1], sb->who ) == 0 )
529	{
530	/* The user we wanted to talk to is finally there, let's send the queued messages then. */
531	struct msn_message *m;
532	GSList *l;
533	int st = 1;
534
535	debug( "%s arrived in the switchboard session, now sending queued message(s)", cmd[1] );
536
537	/* Without this, sendmessage() will put everything back on the queue... */
538	sb->ready = 1;
539
540	while( ( l = sb->msgq ) )
541	{
542	m = l->data;
543	if( st )
544	{
545	/* This hack is meant to convert a regular new chat into a groupchat */
546	if( strcmp( m->text, GROUPCHAT_SWITCHBOARD_MESSAGE ) == 0 )
547	msn_sb_to_chat( sb );
548	else
549	st = msn_sb_sendmessage( sb, m->text );
550	}
551	g_free( m->text );
552	g_free( m->who );
553	g_free( m );
554
555	sb->msgq = g_slist_remove( sb->msgq, m );
556	}
557
558	msn_sb_start_keepalives( sb, FALSE );
559
560	return( st );
561	}
562	else if( strcmp( cmd[1], ic->acc->user ) == 0 )
563	{
564	/* Well, gee thanks. Thanks for letting me know I've arrived.. */
565	}
566	else if( sb->who )
567	{
568	debug( "Converting chat with %s to a groupchat because %s joined the session.", sb->who, cmd[1] );
569
570	/* This SB is a one-to-one chat right now, but someone else is joining. */
571	msn_sb_to_chat( sb );
572
573	imcb_chat_add_buddy( sb->chat, cmd[1] );
574	}
575	else if( sb->chat )
576	{
577	imcb_chat_add_buddy( sb->chat, cmd[1] );
578	sb->ready = 1;
579	}
580	else
581	{
582	/* PANIC! */
583	}
584	}
585	else if( strcmp( cmd[0], "MSG" ) == 0 )
586	{
587	if( num_parts < 4 )
588	{
589	msn_sb_destroy( sb );
590	return( 0 );
591	}
592
593	sb->handler->msglen = atoi( cmd[3] );
594
595	if( sb->handler->msglen <= 0 )
596	{
597	debug( "Received a corrupted message on the switchboard, the switchboard will be closed" );
598	msn_sb_destroy( sb );
599	return( 0 );
600	}
601	}
602	else if( strcmp( cmd[0], "NAK" ) == 0 )
603	{
604	if( sb->who )
605	{
606	imcb_log( ic, "The MSN servers could not deliver one of your messages to %s.", sb->who );
607	}
608	else
609	{
610	imcb_log( ic, "The MSN servers could not deliver one of your groupchat messages to all participants." );
611	}
612	}
613	else if( strcmp( cmd[0], "BYE" ) == 0 )
614	{
615	if( num_parts < 2 )
616	{
617	msn_sb_destroy( sb );
618	return( 0 );
619	}
620
621	/* if( cmd[2] && cmd[2] == '1' ) -=> Chat is being cleaned up because of idleness /
622
623	if( sb->who )
624	{
625	msn_sb_stop_keepalives( sb );
626
627	/* This is a single-person chat, and the other person is leaving. */
628	g_free( sb->who );
629	sb->who = NULL;
630	sb->ready = 0;
631
632	debug( "Person %s left the one-to-one switchboard connection. Keeping it around as a spare...", cmd[1] );
633
634	/* We could clean up the switchboard now, but keeping it around
635	as a spare for a next conversation sounds more sane to me.
636	The server will clean it up when it's idle for too long. */
637	}
638	else if( sb->chat && !strchr( cmd[1], ';' ) )
639	{
640	imcb_chat_remove_buddy( sb->chat, cmd[1], "" );
641	}
642	else
643	{
644	/* PANIC! */
645	}
646	}
647	else if( isdigit( cmd[0][0] ) )
648	{
649	int num = atoi( cmd[0] );
650	const struct msn_status_code *err = msn_status_by_number( num );
651
652	/* If the person is offline, send an offline message instead,
653	and don't report an error. */
654	if( num == 217 )
655	msn_ns_oim_send_queue( ic, &sb->msgq );
656	else
657	imcb_error( ic, "Error reported by switchboard server: %s", err->text );
658
659	if( err->flags & STATUS_SB_FATAL )
660	{
661	msn_sb_destroy( sb );
662	return 0;
663	}
664	else if( err->flags & STATUS_FATAL )
665	{
666	imc_logout( ic, TRUE );
667	return 0;
668	}
669	else if( err->flags & STATUS_SB_IM_SPARE )
670	{
671	if( sb->who )
672	{
673	/* Apparently some invitation failed. We might want to use this
674	board later, so keep it as a spare. */
675	g_free( sb->who );
676	sb->who = NULL;
677
678	/* Also clear the msgq, otherwise someone else might get them. */
679	msn_msgq_purge( ic, &sb->msgq );
680	}
681
682	/* Do NOT return 0 here, we want to keep this sb. */
683	}
684	}
685	else
686	{
687	/* debug( "Received unknown command from switchboard server: %s", cmd[0] ); */
688	}
689
690	return( 1 );
691	}
692
693	static int msn_sb_message( struct msn_handler_data handler, char msg, int msglen, char **cmd, int num_parts )
694	{
695	struct msn_switchboard *sb = handler->data;
696	struct im_connection *ic = sb->ic;
697	char *body;
698
699	if( !num_parts )
700	return( 1 );
701
702	if( ( body = strstr( msg, "\r\n\r\n" ) ) )
703	body += 4;
704
705	if( strcmp( cmd[0], "MSG" ) == 0 )
706	{
707	char *ct = get_rfc822_header( msg, "Content-Type:", msglen );
708
709	if( !ct )
710	return( 1 );
711
712	if( g_strncasecmp( ct, "text/plain", 10 ) == 0 )
713	{
714	g_free( ct );
715
716	if( !body )
717	return( 1 );
718
719	if( sb->who )
720	{
721	imcb_buddy_msg( ic, cmd[1], body, 0, 0 );
722	}
723	else if( sb->chat )
724	{
725	imcb_chat_msg( sb->chat, cmd[1], body, 0, 0 );
726	}
727	else
728	{
729	/* PANIC! */
730	}
731	}
732	#if 0
733	// Disable MSN ft support for now.
734	else if( g_strncasecmp( ct, "text/x-msmsgsinvite", 19 ) == 0 )
735	{
736	char *command = get_rfc822_header( body, "Invitation-Command:", blen );
737	char *cookie = get_rfc822_header( body, "Invitation-Cookie:", blen );
738	unsigned int icookie;
739
740	g_free( ct );
741
742	/* Every invite should have both a Command and Cookie header */
743	if( !command \|\| !cookie ) {
744	g_free( command );
745	g_free( cookie );
746	imcb_log( ic, "Warning: No command or cookie from %s", sb->who );
747	return 1;
748	}
749
750	icookie = strtoul( cookie, NULL, 10 );
751	g_free( cookie );
752
753	if( g_strncasecmp( command, "INVITE", 6 ) == 0 ) {
754	msn_invitation_invite( sb, cmd[1], icookie, body, blen );
755	} else if( g_strncasecmp( command, "ACCEPT", 6 ) == 0 ) {
756	msn_invitation_accept( sb, cmd[1], icookie, body, blen );
757	} else if( g_strncasecmp( command, "CANCEL", 6 ) == 0 ) {
758	msn_invitation_cancel( sb, cmd[1], icookie, body, blen );
759	} else {
760	imcb_log( ic, "Warning: Received invalid invitation with "
761	"command %s from %s", command, sb->who );
762	}
763
764	g_free( command );
765	}
766	#endif
767	else if( g_strncasecmp( ct, "application/x-msnmsgrp2p", 24 ) == 0 )
768	{
769	/* Not currently implemented. Don't warn about it since
770	this seems to be used for avatars now. */
771	g_free( ct );
772	}
773	else if( g_strncasecmp( ct, "text/x-msmsgscontrol", 20 ) == 0 )
774	{
775	char *who = get_rfc822_header( msg, "TypingUser:", msglen );
776
777	if( who )
778	{
779	imcb_buddy_typing( ic, who, OPT_TYPING );
780	g_free( who );
781	}
782
783	g_free( ct );
784	}
785	else
786	{
787	g_free( ct );
788	}
789	}
790
791	return( 1 );
792	}
793
794	static gboolean msn_sb_keepalive( gpointer data, gint source, b_input_condition cond )
795	{
796	struct msn_switchboard *sb = data;
797	return sb->ready && msn_sb_sendmessage( sb, SB_KEEPALIVE_MESSAGE );
798	}
799
800	void msn_sb_start_keepalives( struct msn_switchboard *sb, gboolean initial )
801	{
802	bee_user_t *bu;
803
804	if( sb && sb->who && sb->keepalive == 0 &&
805	( bu = bee_user_by_handle( sb->ic->bee, sb->ic, sb->who ) ) &&
806	!( bu->flags & BEE_USER_ONLINE ) &&
807	set_getbool( &sb->ic->acc->set, "switchboard_keepalives" ) )
808	{
809	if( initial )
810	msn_sb_keepalive( sb, 0, 0 );
811
812	sb->keepalive = b_timeout_add( 20000, msn_sb_keepalive, sb );
813	}
814	}
815
816	void msn_sb_stop_keepalives( struct msn_switchboard *sb )
817	{
818	if( sb && sb->keepalive > 0 )
819	{
820	b_event_remove( sb->keepalive );
821	sb->keepalive = 0;
822	}
823	}

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

Download in other formats: