Context Navigation

source: protocols/msn/sb.c @ 4c17d19

Last change on this file since 4c17d19 was e5abfd4, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-05-09T11:26:57Z
Safety check for yesterday's fixes: Double-check that a groupchat struct isn't claimed already.
Property mode set to `100644`
File size: 18.6 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;
[e5abfd4]	235	struct groupchat *c = NULL;
[b7d3cc34]	236	char buf[1024];
	237
	238	/* Create the groupchat structure. */
	239	g_snprintf( buf, sizeof( buf ), "MSN groupchat session %d", sb->session );
[36577aa]	240	if( sb->who )
[e5abfd4]	241	c = bee_chat_by_title( ic->bee, ic, sb->who );
	242	if( c && !msn_sb_by_chat( c ) )
	243	sb->chat = c;
	244	else
[36577aa]	245	sb->chat = imcb_chat_new( ic, buf );
[b7d3cc34]	246
	247	/* Populate the channel. */
[61ae52c]	248	if( sb->who ) imcb_chat_add_buddy( sb->chat, sb->who );
	249	imcb_chat_add_buddy( sb->chat, ic->acc->user );
[b7d3cc34]	250
	251	/* And make sure the switchboard doesn't look like a regular chat anymore. */
	252	if( sb->who )
	253	{
	254	g_free( sb->who );
	255	sb->who = NULL;
	256	}
[fa29d093]	257
	258	return sb->chat;
[b7d3cc34]	259	}
	260
	261	void msn_sb_destroy( struct msn_switchboard *sb )
	262	{
[0da65d5]	263	struct im_connection *ic = sb->ic;
	264	struct msn_data *md = ic->proto_data;
[b7d3cc34]	265
	266	debug( "Destroying switchboard: %s", sb->who ? sb->who : sb->key ? sb->key : "" );
	267
[46dca11]	268	msn_msgq_purge( ic, &sb->msgq );
[bb839e8]	269	msn_sb_stop_keepalives( sb );
[b7d3cc34]	270
[8ba511d]	271	if( sb->key ) g_free( sb->key );
	272	if( sb->who ) g_free( sb->who );
	273
[b7d3cc34]	274	if( sb->chat )
	275	{
[e35d1a1]	276	imcb_chat_free( sb->chat );
[b7d3cc34]	277	}
	278
	279	if( sb->handler )
	280	{
	281	if( sb->handler->rxq ) g_free( sb->handler->rxq );
	282	if( sb->handler->cmd_text ) g_free( sb->handler->cmd_text );
	283	g_free( sb->handler );
	284	}
	285
[ba9edaa]	286	if( sb->inp ) b_event_remove( sb->inp );
[b7d3cc34]	287	closesocket( sb->fd );
	288
	289	msn_switchboards = g_slist_remove( msn_switchboards, sb );
	290	md->switchboards = g_slist_remove( md->switchboards, sb );
	291	g_free( sb );
	292	}
	293
[ba9edaa]	294	gboolean msn_sb_connected( gpointer data, gint source, b_input_condition cond )
[b7d3cc34]	295	{
	296	struct msn_switchboard *sb = data;
[0da65d5]	297	struct im_connection *ic;
[b7d3cc34]	298	struct msn_data *md;
	299	char buf[1024];
	300
	301	/* Are we still alive? */
	302	if( !g_slist_find( msn_switchboards, sb ) )
[ba9edaa]	303	return FALSE;
[b7d3cc34]	304
[0da65d5]	305	ic = sb->ic;
	306	md = ic->proto_data;
[b7d3cc34]	307
	308	if( source != sb->fd )
	309	{
[46dca11]	310	debug( "Error %d while connecting to switchboard server", 1 );
[b7d3cc34]	311	msn_sb_destroy( sb );
[ba9edaa]	312	return FALSE;
[b7d3cc34]	313	}
	314
	315	/* Prepare the callback */
	316	sb->handler = g_new0( struct msn_handler_data, 1 );
	317	sb->handler->fd = sb->fd;
	318	sb->handler->rxq = g_new0( char, 1 );
	319	sb->handler->data = sb;
	320	sb->handler->exec_command = msn_sb_command;
	321	sb->handler->exec_message = msn_sb_message;
	322
	323	if( sb->session == MSN_SB_NEW )
[c2fb3809]	324	g_snprintf( buf, sizeof( buf ), "USR %d %s %s\r\n", ++sb->trId, ic->acc->user, sb->key );
[b7d3cc34]	325	else
[c2fb3809]	326	g_snprintf( buf, sizeof( buf ), "ANS %d %s %s %d\r\n", ++sb->trId, ic->acc->user, sb->key, sb->session );
[b7d3cc34]	327
	328	if( msn_sb_write( sb, buf, strlen( buf ) ) )
[ba9edaa]	329	sb->inp = b_input_add( sb->fd, GAIM_INPUT_READ, msn_sb_callback, sb );
[b7d3cc34]	330	else
[46dca11]	331	debug( "Error %d while connecting to switchboard server", 2 );
[ba9edaa]	332
	333	return FALSE;
[b7d3cc34]	334	}
	335
[ba9edaa]	336	static gboolean msn_sb_callback( gpointer data, gint source, b_input_condition cond )
[b7d3cc34]	337	{
	338	struct msn_switchboard *sb = data;
[59f527b6]	339	struct im_connection *ic = sb->ic;
	340	struct msn_data *md = ic->proto_data;
[b7d3cc34]	341
	342	if( msn_handler( sb->handler ) == -1 )
	343	{
[59f527b6]	344	time_t now = time( NULL );
	345
	346	if( now - md->first_sb_failure > 600 )
	347	{
	348	/* It's not really the first one, but the start of this "series".
	349	With this, the warning below will be shown only if this happens
	350	at least three times in ten minutes. This algorithm isn't
	351	perfect, but for this purpose it will do. */
	352	md->first_sb_failure = now;
	353	md->sb_failures = 0;
	354	}
	355
[46dca11]	356	debug( "Error: Switchboard died" );
[59f527b6]	357	if( ++ md->sb_failures >= 3 )
	358	imcb_log( ic, "Warning: Many switchboard failures on MSN connection. "
	359	"There might be problems delivering your messages." );
	360
	361	if( sb->msgq != NULL )
	362	{
	363	char buf[1024];
	364
	365	if( md->msgq == NULL )
	366	{
	367	md->msgq = sb->msgq;
	368	}
	369	else
	370	{
	371	GSList *l;
	372
	373	for( l = md->msgq; l->next; l = l->next );
	374	l->next = sb->msgq;
	375	}
	376	sb->msgq = NULL;
	377
	378	debug( "Moved queued messages back to the main queue, creating a new switchboard to retry." );
	379	g_snprintf( buf, sizeof( buf ), "XFR %d SB\r\n", ++md->trId );
	380	if( !msn_write( ic, buf, strlen( buf ) ) )
	381	return FALSE;
	382	}
	383
[b7d3cc34]	384	msn_sb_destroy( sb );
[ba9edaa]	385
	386	return FALSE;
[b7d3cc34]	387	}
[ba9edaa]	388	else
[59f527b6]	389	{
[ba9edaa]	390	return TRUE;
[59f527b6]	391	}
[b7d3cc34]	392	}
	393
	394	static int msn_sb_command( gpointer data, char **cmd, int num_parts )
	395	{
	396	struct msn_switchboard *sb = data;
[0da65d5]	397	struct im_connection *ic = sb->ic;
[b7d3cc34]	398	char buf[1024];
	399
	400	if( !num_parts )
	401	{
	402	/* Hrrm... Empty command...? Ignore? */
	403	return( 1 );
	404	}
	405
	406	if( strcmp( cmd[0], "XFR" ) == 0 )
	407	{
[84b045d]	408	imcb_error( ic, "Received an XFR from a switchboard server, unable to comply! This is likely to be a bug, please report it!" );
[c2fb3809]	409	imc_logout( ic, TRUE );
[b7d3cc34]	410	return( 0 );
	411	}
	412	else if( strcmp( cmd[0], "USR" ) == 0 )
	413	{
	414	if( num_parts != 5 )
	415	{
	416	msn_sb_destroy( sb );
	417	return( 0 );
	418	}
	419
	420	if( strcmp( cmd[2], "OK" ) != 0 )
	421	{
	422	msn_sb_destroy( sb );
	423	return( 0 );
	424	}
	425
	426	if( sb->who )
	427	{
	428	g_snprintf( buf, sizeof( buf ), "CAL %d %s\r\n", ++sb->trId, sb->who );
	429	return( msn_sb_write( sb, buf, strlen( buf ) ) );
	430	}
	431	else
	432	{
	433	debug( "Just created a switchboard, but I don't know what to do with it." );
	434	}
	435	}
	436	else if( strcmp( cmd[0], "IRO" ) == 0 )
	437	{
	438	int num, tot;
	439
	440	if( num_parts != 6 )
	441	{
	442	msn_sb_destroy( sb );
	443	return( 0 );
	444	}
	445
	446	num = atoi( cmd[2] );
	447	tot = atoi( cmd[3] );
	448
	449	if( tot <= 0 )
	450	{
	451	msn_sb_destroy( sb );
	452	return( 0 );
	453	}
	454	else if( tot > 1 )
	455	{
	456	char buf[1024];
	457
	458	if( num == 1 )
	459	{
	460	g_snprintf( buf, sizeof( buf ), "MSN groupchat session %d", sb->session );
[61ae52c]	461	sb->chat = imcb_chat_new( ic, buf );
[b7d3cc34]	462
	463	g_free( sb->who );
	464	sb->who = NULL;
	465	}
	466
[61ae52c]	467	imcb_chat_add_buddy( sb->chat, cmd[4] );
[b7d3cc34]	468
	469	if( num == tot )
	470	{
[61ae52c]	471	imcb_chat_add_buddy( sb->chat, ic->acc->user );
[b7d3cc34]	472	}
	473	}
	474	}
	475	else if( strcmp( cmd[0], "ANS" ) == 0 )
	476	{
	477	if( num_parts != 3 )
	478	{
	479	msn_sb_destroy( sb );
	480	return( 0 );
	481	}
	482
	483	if( strcmp( cmd[2], "OK" ) != 0 )
	484	{
	485	debug( "Switchboard server sent a negative ANS reply" );
	486	msn_sb_destroy( sb );
	487	return( 0 );
	488	}
	489
	490	sb->ready = 1;
[bb839e8]	491
	492	msn_sb_start_keepalives( sb, FALSE );
[b7d3cc34]	493	}
	494	else if( strcmp( cmd[0], "CAL" ) == 0 )
	495	{
	496	if( num_parts != 4 \|\| !isdigit( cmd[3][0] ) )
	497	{
	498	msn_sb_destroy( sb );
	499	return( 0 );
	500	}
	501
	502	sb->session = atoi( cmd[3] );
	503	}
	504	else if( strcmp( cmd[0], "JOI" ) == 0 )
	505	{
	506	if( num_parts != 3 )
	507	{
	508	msn_sb_destroy( sb );
	509	return( 0 );
	510	}
	511
	512	if( sb->who && g_strcasecmp( cmd[1], sb->who ) == 0 )
	513	{
	514	/* The user we wanted to talk to is finally there, let's send the queued messages then. */
	515	struct msn_message *m;
	516	GSList *l;
	517	int st = 1;
	518
	519	debug( "%s arrived in the switchboard session, now sending queued message(s)", cmd[1] );
	520
	521	/* Without this, sendmessage() will put everything back on the queue... */
	522	sb->ready = 1;
	523
	524	while( ( l = sb->msgq ) )
	525	{
	526	m = l->data;
	527	if( st )
	528	{
	529	/* This hack is meant to convert a regular new chat into a groupchat */
	530	if( strcmp( m->text, GROUPCHAT_SWITCHBOARD_MESSAGE ) == 0 )
	531	msn_sb_to_chat( sb );
	532	else
	533	st = msn_sb_sendmessage( sb, m->text );
	534	}
	535	g_free( m->text );
	536	g_free( m->who );
	537	g_free( m );
	538
	539	sb->msgq = g_slist_remove( sb->msgq, m );
	540	}
	541
[bb839e8]	542	msn_sb_start_keepalives( sb, FALSE );
	543
[b7d3cc34]	544	return( st );
	545	}
	546	else if( sb->who )
	547	{
	548	debug( "Converting chat with %s to a groupchat because %s joined the session.", sb->who, cmd[1] );
	549
	550	/* This SB is a one-to-one chat right now, but someone else is joining. */
	551	msn_sb_to_chat( sb );
	552
[61ae52c]	553	imcb_chat_add_buddy( sb->chat, cmd[1] );
[b7d3cc34]	554	}
	555	else if( sb->chat )
	556	{
[61ae52c]	557	imcb_chat_add_buddy( sb->chat, cmd[1] );
[b7d3cc34]	558	sb->ready = 1;
	559	}
	560	else
	561	{
	562	/* PANIC! */
	563	}
	564	}
	565	else if( strcmp( cmd[0], "MSG" ) == 0 )
	566	{
	567	if( num_parts != 4 )
	568	{
	569	msn_sb_destroy( sb );
	570	return( 0 );
	571	}
	572
	573	sb->handler->msglen = atoi( cmd[3] );
	574
	575	if( sb->handler->msglen <= 0 )
	576	{
	577	debug( "Received a corrupted message on the switchboard, the switchboard will be closed" );
	578	msn_sb_destroy( sb );
	579	return( 0 );
	580	}
	581	}
[3585c5a]	582	else if( strcmp( cmd[0], "NAK" ) == 0 )
	583	{
	584	if( sb->who )
	585	{
	586	imcb_log( ic, "The MSN servers could not deliver one of your messages to %s.", sb->who );
	587	}
	588	else
	589	{
	590	imcb_log( ic, "The MSN servers could not deliver one of your groupchat messages to all participants." );
	591	}
	592	}
[b7d3cc34]	593	else if( strcmp( cmd[0], "BYE" ) == 0 )
	594	{
	595	if( num_parts < 2 )
	596	{
	597	msn_sb_destroy( sb );
	598	return( 0 );
	599	}
	600
	601	/* if( cmd[2] && cmd[2] == '1' ) -=> Chat is being cleaned up because of idleness /
	602
	603	if( sb->who )
	604	{
[bb839e8]	605	msn_sb_stop_keepalives( sb );
	606
[b7d3cc34]	607	/* This is a single-person chat, and the other person is leaving. */
	608	g_free( sb->who );
	609	sb->who = NULL;
	610	sb->ready = 0;
	611
	612	debug( "Person %s left the one-to-one switchboard connection. Keeping it around as a spare...", cmd[1] );
	613
	614	/* We could clean up the switchboard now, but keeping it around
	615	as a spare for a next conversation sounds more sane to me.
	616	The server will clean it up when it's idle for too long. */
	617	}
	618	else if( sb->chat )
	619	{
[61ae52c]	620	imcb_chat_remove_buddy( sb->chat, cmd[1], "" );
[b7d3cc34]	621	}
	622	else
	623	{
	624	/* PANIC! */
	625	}
	626	}
	627	else if( isdigit( cmd[0][0] ) )
	628	{
	629	int num = atoi( cmd[0] );
[08995b0]	630	const struct msn_status_code *err = msn_status_by_number( num );
[b7d3cc34]	631
[84b045d]	632	imcb_error( ic, "Error reported by switchboard server: %s", err->text );
[b7d3cc34]	633
	634	if( err->flags & STATUS_SB_FATAL )
	635	{
	636	msn_sb_destroy( sb );
[6048744]	637	return 0;
[b7d3cc34]	638	}
[6048744]	639	else if( err->flags & STATUS_FATAL )
[b7d3cc34]	640	{
[c2fb3809]	641	imc_logout( ic, TRUE );
[6048744]	642	return 0;
[b7d3cc34]	643	}
[6048744]	644	else if( err->flags & STATUS_SB_IM_SPARE )
[3b9390b]	645	{
	646	if( sb->who )
	647	{
	648	/* Apparently some invitation failed. We might want to use this
	649	board later, so keep it as a spare. */
	650	g_free( sb->who );
	651	sb->who = NULL;
	652
	653	/* Also clear the msgq, otherwise someone else might get them. */
[46dca11]	654	msn_msgq_purge( ic, &sb->msgq );
[3b9390b]	655	}
[6048744]	656
	657	/* Do NOT return 0 here, we want to keep this sb. */
[3b9390b]	658	}
[b7d3cc34]	659	}
	660	else
	661	{
[8ff0a61]	662	/* debug( "Received unknown command from switchboard server: %s", cmd[0] ); */
[b7d3cc34]	663	}
	664
	665	return( 1 );
	666	}
	667
	668	static int msn_sb_message( gpointer data, char msg, int msglen, char *cmd, int num_parts )
	669	{
	670	struct msn_switchboard *sb = data;
[0da65d5]	671	struct im_connection *ic = sb->ic;
[b7d3cc34]	672	char *body;
	673	int blen = 0;
	674
	675	if( !num_parts )
	676	return( 1 );
	677
	678	if( ( body = strstr( msg, "\r\n\r\n" ) ) )
	679	{
	680	body += 4;
	681	blen = msglen - ( body - msg );
	682	}
	683
	684	if( strcmp( cmd[0], "MSG" ) == 0 )
	685	{
	686	char *ct = msn_findheader( msg, "Content-Type:", msglen );
	687
	688	if( !ct )
	689	return( 1 );
	690
	691	if( g_strncasecmp( ct, "text/plain", 10 ) == 0 )
	692	{
	693	g_free( ct );
	694
	695	if( !body )
	696	return( 1 );
	697
	698	if( sb->who )
	699	{
[9624fdf]	700	imcb_buddy_msg( ic, cmd[1], body, 0, 0 );
[b7d3cc34]	701	}
	702	else if( sb->chat )
	703	{
[61ae52c]	704	imcb_chat_msg( sb->chat, cmd[1], body, 0, 0 );
[b7d3cc34]	705	}
	706	else
	707	{
	708	/* PANIC! */
	709	}
	710	}
[17a6ee9]	711	#if 0
	712	// Disable MSN ft support for now.
[b7d3cc34]	713	else if( g_strncasecmp( ct, "text/x-msmsgsinvite", 19 ) == 0 )
	714	{
[a2b99ec]	715	char *command = msn_findheader( body, "Invitation-Command:", blen );
	716	char *cookie = msn_findheader( body, "Invitation-Cookie:", blen );
	717	unsigned int icookie;
[b7d3cc34]	718
	719	g_free( ct );
	720
[a2b99ec]	721	/* Every invite should have both a Command and Cookie header */
	722	if( !command \|\| !cookie ) {
	723	g_free( command );
	724	g_free( cookie );
	725	imcb_log( ic, "Warning: No command or cookie from %s", sb->who );
	726	return 1;
[b7d3cc34]	727	}
	728
[a2b99ec]	729	icookie = strtoul( cookie, NULL, 10 );
	730	g_free( cookie );
[b7d3cc34]	731
[a2b99ec]	732	if( g_strncasecmp( command, "INVITE", 6 ) == 0 ) {
	733	msn_invitation_invite( sb, cmd[1], icookie, body, blen );
	734	} else if( g_strncasecmp( command, "ACCEPT", 6 ) == 0 ) {
	735	msn_invitation_accept( sb, cmd[1], icookie, body, blen );
	736	} else if( g_strncasecmp( command, "CANCEL", 6 ) == 0 ) {
	737	msn_invitation_cancel( sb, cmd[1], icookie, body, blen );
	738	} else {
	739	imcb_log( ic, "Warning: Received invalid invitation with "
	740	"command %s from %s", command, sb->who );
[b7d3cc34]	741	}
[a2b99ec]	742
	743	g_free( command );
	744	}
[17a6ee9]	745	#endif
[a2b99ec]	746	else if( g_strncasecmp( ct, "application/x-msnmsgrp2p", 24 ) == 0 )
	747	{
	748	imcb_error( sb->ic, "Cannot receive file from %s: BitlBee does not "
	749	"support msnmsgrp2p yet.", sb->who );
	750	g_free( ct );
[b7d3cc34]	751	}
	752	else if( g_strncasecmp( ct, "text/x-msmsgscontrol", 20 ) == 0 )
	753	{
	754	char *who = msn_findheader( msg, "TypingUser:", msglen );
	755
	756	if( who )
	757	{
[9624fdf]	758	imcb_buddy_typing( ic, who, OPT_TYPING );
[b7d3cc34]	759	g_free( who );
	760	}
	761
	762	g_free( ct );
	763	}
	764	else
	765	{
	766	g_free( ct );
	767	}
	768	}
	769
	770	return( 1 );
	771	}
[9bf2481]	772
[bb839e8]	773	static gboolean msn_sb_keepalive( gpointer data, gint source, b_input_condition cond )
[9bf2481]	774	{
	775	struct msn_switchboard *sb = data;
	776	return sb->ready && msn_sb_sendmessage( sb, SB_KEEPALIVE_MESSAGE );
	777	}
[bb839e8]	778
	779	void msn_sb_start_keepalives( struct msn_switchboard *sb, gboolean initial )
	780	{
[f924563]	781	bee_user_t *bu;
[bb839e8]	782
	783	if( sb && sb->who && sb->keepalive == 0 &&
[f924563]	784	( bu = bee_user_by_handle( sb->ic->bee, sb->ic, sb->who ) ) &&
	785	!( bu->flags & BEE_USER_ONLINE ) &&
[bb839e8]	786	set_getbool( &sb->ic->acc->set, "switchboard_keepalives" ) )
	787	{
	788	if( initial )
	789	msn_sb_keepalive( sb, 0, 0 );
	790
	791	sb->keepalive = b_timeout_add( 20000, msn_sb_keepalive, sb );
	792	}
	793	}
	794
	795	void msn_sb_stop_keepalives( struct msn_switchboard *sb )
	796	{
	797	if( sb && sb->keepalive > 0 )
	798	{
	799	b_event_remove( sb->keepalive );
	800	sb->keepalive = 0;
	801	}
	802	}

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

Download in other formats: