Context Navigation

source: protocols/msn/sb.c @ 713d611

Last change on this file since 713d611 was bb839e8, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-04-10T01:05:39Z
Be more clever with keepalives; detect when a switchboard is opened with someone who's offline already. Still a hack but it eases the pain a little bit.
Property mode set to `100644`
File size: 18.4 KB

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

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

Download in other formats: