Context Navigation

source: protocols/msn/sb.c @ 0d4a068

Last change on this file since 0d4a068 was f924563, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-05-03T00:52:08Z
Mainline merge.
Property mode set to `100644`
File size: 18.5 KB

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

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

Download in other formats: