Context Navigation

source: protocols/msn/sb.c @ ce617f0

Last change on this file since ce617f0 was 9c84617, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-12-13T00:42:58Z
Silently adding /CTCP NUDGE support for MSN contacts.
Property mode set to `100644`
File size: 18.8 KB

Line
1	/********************************************************************\
2	* BitlBee -- An IRC to other IM-networks gateway *
3	* *
4	* Copyright 2002-2010 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", 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, 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\r\n", ++sb->trId, ic->acc->user, sb->key );
337	else
338	g_snprintf( buf, sizeof( buf ), "ANS %d %s %s %d\r\n", ++sb->trId, ic->acc->user, 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	if( num == 1 )
458	{
459	g_snprintf( buf, sizeof( buf ), "MSN groupchat session %d", sb->session );
460	sb->chat = imcb_chat_new( ic, buf );
461
462	g_free( sb->who );
463	sb->who = NULL;
464	}
465
466	imcb_chat_add_buddy( sb->chat, cmd[4] );
467
468	if( num == tot )
469	{
470	imcb_chat_add_buddy( sb->chat, ic->acc->user );
471	}
472	}
473	}
474	else if( strcmp( cmd[0], "ANS" ) == 0 )
475	{
476	if( num_parts < 3 )
477	{
478	msn_sb_destroy( sb );
479	return( 0 );
480	}
481
482	if( strcmp( cmd[2], "OK" ) != 0 )
483	{
484	debug( "Switchboard server sent a negative ANS reply" );
485	msn_sb_destroy( sb );
486	return( 0 );
487	}
488
489	sb->ready = 1;
490
491	msn_sb_start_keepalives( sb, FALSE );
492	}
493	else if( strcmp( cmd[0], "CAL" ) == 0 )
494	{
495	if( num_parts < 4 \|\| !isdigit( cmd[3][0] ) )
496	{
497	msn_sb_destroy( sb );
498	return( 0 );
499	}
500
501	sb->session = atoi( cmd[3] );
502	}
503	else if( strcmp( cmd[0], "JOI" ) == 0 )
504	{
505	if( num_parts < 3 )
506	{
507	msn_sb_destroy( sb );
508	return( 0 );
509	}
510
511	if( sb->who && g_strcasecmp( cmd[1], sb->who ) == 0 )
512	{
513	/* The user we wanted to talk to is finally there, let's send the queued messages then. */
514	struct msn_message *m;
515	GSList *l;
516	int st = 1;
517
518	debug( "%s arrived in the switchboard session, now sending queued message(s)", cmd[1] );
519
520	/* Without this, sendmessage() will put everything back on the queue... */
521	sb->ready = 1;
522
523	while( ( l = sb->msgq ) )
524	{
525	m = l->data;
526	if( st )
527	{
528	/* This hack is meant to convert a regular new chat into a groupchat */
529	if( strcmp( m->text, GROUPCHAT_SWITCHBOARD_MESSAGE ) == 0 )
530	msn_sb_to_chat( sb );
531	else
532	st = msn_sb_sendmessage( sb, m->text );
533	}
534	g_free( m->text );
535	g_free( m->who );
536	g_free( m );
537
538	sb->msgq = g_slist_remove( sb->msgq, m );
539	}
540
541	msn_sb_start_keepalives( sb, FALSE );
542
543	return( st );
544	}
545	else if( sb->who )
546	{
547	debug( "Converting chat with %s to a groupchat because %s joined the session.", sb->who, cmd[1] );
548
549	/* This SB is a one-to-one chat right now, but someone else is joining. */
550	msn_sb_to_chat( sb );
551
552	imcb_chat_add_buddy( sb->chat, cmd[1] );
553	}
554	else if( sb->chat )
555	{
556	imcb_chat_add_buddy( sb->chat, cmd[1] );
557	sb->ready = 1;
558	}
559	else
560	{
561	/* PANIC! */
562	}
563	}
564	else if( strcmp( cmd[0], "MSG" ) == 0 )
565	{
566	if( num_parts < 4 )
567	{
568	msn_sb_destroy( sb );
569	return( 0 );
570	}
571
572	sb->handler->msglen = atoi( cmd[3] );
573
574	if( sb->handler->msglen <= 0 )
575	{
576	debug( "Received a corrupted message on the switchboard, the switchboard will be closed" );
577	msn_sb_destroy( sb );
578	return( 0 );
579	}
580	}
581	else if( strcmp( cmd[0], "NAK" ) == 0 )
582	{
583	if( sb->who )
584	{
585	imcb_log( ic, "The MSN servers could not deliver one of your messages to %s.", sb->who );
586	}
587	else
588	{
589	imcb_log( ic, "The MSN servers could not deliver one of your groupchat messages to all participants." );
590	}
591	}
592	else if( strcmp( cmd[0], "BYE" ) == 0 )
593	{
594	if( num_parts < 2 )
595	{
596	msn_sb_destroy( sb );
597	return( 0 );
598	}
599
600	/* if( cmd[2] && cmd[2] == '1' ) -=> Chat is being cleaned up because of idleness /
601
602	if( sb->who )
603	{
604	msn_sb_stop_keepalives( sb );
605
606	/* This is a single-person chat, and the other person is leaving. */
607	g_free( sb->who );
608	sb->who = NULL;
609	sb->ready = 0;
610
611	debug( "Person %s left the one-to-one switchboard connection. Keeping it around as a spare...", cmd[1] );
612
613	/* We could clean up the switchboard now, but keeping it around
614	as a spare for a next conversation sounds more sane to me.
615	The server will clean it up when it's idle for too long. */
616	}
617	else if( sb->chat )
618	{
619	imcb_chat_remove_buddy( sb->chat, cmd[1], "" );
620	}
621	else
622	{
623	/* PANIC! */
624	}
625	}
626	else if( isdigit( cmd[0][0] ) )
627	{
628	int num = atoi( cmd[0] );
629	const struct msn_status_code *err = msn_status_by_number( num );
630
631	/* If the person is offline, send an offline message instead,
632	and don't report an error. */
633	if( num == 217 )
634	msn_soap_oim_send_queue( ic, &sb->msgq );
635	else
636	imcb_error( ic, "Error reported by switchboard server: %s", err->text );
637
638	if( err->flags & STATUS_SB_FATAL )
639	{
640	msn_sb_destroy( sb );
641	return 0;
642	}
643	else if( err->flags & STATUS_FATAL )
644	{
645	imc_logout( ic, TRUE );
646	return 0;
647	}
648	else if( err->flags & STATUS_SB_IM_SPARE )
649	{
650	if( sb->who )
651	{
652	/* Apparently some invitation failed. We might want to use this
653	board later, so keep it as a spare. */
654	g_free( sb->who );
655	sb->who = NULL;
656
657	/* Also clear the msgq, otherwise someone else might get them. */
658	msn_msgq_purge( ic, &sb->msgq );
659	}
660
661	/* Do NOT return 0 here, we want to keep this sb. */
662	}
663	}
664	else
665	{
666	/* debug( "Received unknown command from switchboard server: %s", cmd[0] ); */
667	}
668
669	return( 1 );
670	}
671
672	static int msn_sb_message( struct msn_handler_data handler, char msg, int msglen, char **cmd, int num_parts )
673	{
674	struct msn_switchboard *sb = handler->data;
675	struct im_connection *ic = sb->ic;
676	char *body;
677	int blen = 0;
678
679	if( !num_parts )
680	return( 1 );
681
682	if( ( body = strstr( msg, "\r\n\r\n" ) ) )
683	{
684	body += 4;
685	blen = msglen - ( body - msg );
686	}
687
688	if( strcmp( cmd[0], "MSG" ) == 0 )
689	{
690	char *ct = msn_findheader( msg, "Content-Type:", msglen );
691
692	if( !ct )
693	return( 1 );
694
695	if( g_strncasecmp( ct, "text/plain", 10 ) == 0 )
696	{
697	g_free( ct );
698
699	if( !body )
700	return( 1 );
701
702	if( sb->who )
703	{
704	imcb_buddy_msg( ic, cmd[1], body, 0, 0 );
705	}
706	else if( sb->chat )
707	{
708	imcb_chat_msg( sb->chat, cmd[1], body, 0, 0 );
709	}
710	else
711	{
712	/* PANIC! */
713	}
714	}
715	#if 0
716	// Disable MSN ft support for now.
717	else if( g_strncasecmp( ct, "text/x-msmsgsinvite", 19 ) == 0 )
718	{
719	char *command = msn_findheader( body, "Invitation-Command:", blen );
720	char *cookie = msn_findheader( body, "Invitation-Cookie:", blen );
721	unsigned int icookie;
722
723	g_free( ct );
724
725	/* Every invite should have both a Command and Cookie header */
726	if( !command \|\| !cookie ) {
727	g_free( command );
728	g_free( cookie );
729	imcb_log( ic, "Warning: No command or cookie from %s", sb->who );
730	return 1;
731	}
732
733	icookie = strtoul( cookie, NULL, 10 );
734	g_free( cookie );
735
736	if( g_strncasecmp( command, "INVITE", 6 ) == 0 ) {
737	msn_invitation_invite( sb, cmd[1], icookie, body, blen );
738	} else if( g_strncasecmp( command, "ACCEPT", 6 ) == 0 ) {
739	msn_invitation_accept( sb, cmd[1], icookie, body, blen );
740	} else if( g_strncasecmp( command, "CANCEL", 6 ) == 0 ) {
741	msn_invitation_cancel( sb, cmd[1], icookie, body, blen );
742	} else {
743	imcb_log( ic, "Warning: Received invalid invitation with "
744	"command %s from %s", command, sb->who );
745	}
746
747	g_free( command );
748	}
749	#endif
750	else if( g_strncasecmp( ct, "application/x-msnmsgrp2p", 24 ) == 0 )
751	{
752	/* Not currently implemented. Don't warn about it since
753	this seems to be used for avatars now. */
754	g_free( ct );
755	}
756	else if( g_strncasecmp( ct, "text/x-msmsgscontrol", 20 ) == 0 )
757	{
758	char *who = msn_findheader( msg, "TypingUser:", msglen );
759
760	if( who )
761	{
762	imcb_buddy_typing( ic, who, OPT_TYPING );
763	g_free( who );
764	}
765
766	g_free( ct );
767	}
768	else
769	{
770	g_free( ct );
771	}
772	}
773
774	return( 1 );
775	}
776
777	static gboolean msn_sb_keepalive( gpointer data, gint source, b_input_condition cond )
778	{
779	struct msn_switchboard *sb = data;
780	return sb->ready && msn_sb_sendmessage( sb, SB_KEEPALIVE_MESSAGE );
781	}
782
783	void msn_sb_start_keepalives( struct msn_switchboard *sb, gboolean initial )
784	{
785	bee_user_t *bu;
786
787	if( sb && sb->who && sb->keepalive == 0 &&
788	( bu = bee_user_by_handle( sb->ic->bee, sb->ic, sb->who ) ) &&
789	!( bu->flags & BEE_USER_ONLINE ) &&
790	set_getbool( &sb->ic->acc->set, "switchboard_keepalives" ) )
791	{
792	if( initial )
793	msn_sb_keepalive( sb, 0, 0 );
794
795	sb->keepalive = b_timeout_add( 20000, msn_sb_keepalive, sb );
796	}
797	}
798
799	void msn_sb_stop_keepalives( struct msn_switchboard *sb )
800	{
801	if( sb && sb->keepalive > 0 )
802	{
803	b_event_remove( sb->keepalive );
804	sb->keepalive = 0;
805	}
806	}

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

Download in other formats: