Context Navigation

source: protocols/purple/purple.c @ e5d8d21

Last change on this file since e5d8d21 was e5d8d21, checked in by Wilmer van der Gaast <wilmer@…>, at 2009-11-25T00:45:27Z
Added in-memory help info, which I wanted to implement for ages already. Sadly the way I'm using it now doesn't work yet since nogaim_init() is called before help_init(). I'll fix that later. (Have to do that anyway to at least make ForkDaemon mode work..)
Property mode set to `100644`
File size: 16.2 KB

Rev	Line
[796da03]	1	/***************************************************************************\
	2	* *
	3	* BitlBee - An IRC to IM gateway *
	4	* libpurple module - Main file *
	5	* *
	6	* Copyright 2009 Wilmer van der Gaast <wilmer@gaast.net> *
	7	* *
	8	* This program is free software; you can redistribute it and/or modify *
	9	* it under the terms of the GNU General Public License as published by *
	10	* the Free Software Foundation; either version 2 of the License, or *
	11	* (at your option) any later version. *
	12	* *
	13	* This program is distributed in the hope that it will be useful, *
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	16	* GNU General Public License for more details. *
	17	* *
	18	* You should have received a copy of the GNU General Public License along *
	19	* with this program; if not, write to the Free Software Foundation, Inc., *
	20	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
	21	* *
	22	\***************************************************************************/
	23
[b3117f2]	24	#include "bitlbee.h"
[e5d8d21]	25	#include "help.h"
[b3117f2]	26
[0ac1a375]	27	#include <stdarg.h>
	28
[796da03]	29	#include <glib.h>
	30	#include <purple.h>
	31
	32	GSList *purple_connections;
	33
[0ac1a375]	34	/* This makes me VERY sad... :-( But some libpurple callbacks come in without
	35	any context so this is the only way to get that. Don't want to support
	36	libpurple in daemon mode anyway. */
	37	static irc_t *local_irc;
	38
[7da726b]	39	static struct im_connection purple_ic_by_pa( PurpleAccount pa )
[860ba6a]	40	{
	41	GSList *i;
	42
	43	for( i = purple_connections; i; i = i->next )
	44	if( ((struct im_connection *)i->data)->proto_data == pa )
	45	return i->data;
	46
	47	return NULL;
	48	}
	49
[7da726b]	50	static struct im_connection purple_ic_by_gc( PurpleConnection gc )
	51	{
	52	return purple_ic_by_pa( purple_connection_get_account( gc ) );
	53	}
	54
[796da03]	55	static void purple_init( account_t *acc )
	56	{
[45a19e5]	57	PurplePlugin prpl = purple_plugins_find_with_id( (char) acc->prpl->data );
[0f7ee7e5]	58	PurplePluginProtocolInfo *pi = prpl->info->extra_info;
	59	GList *i;
[0cbef26]	60
[0f7ee7e5]	61	for( i = pi->protocol_options; i; i = i->next )
	62	{
	63	PurpleAccountOption *o = i->data;
	64	const char *name;
	65	char *def = NULL;
	66	set_eval eval = NULL;
	67	set_t *s;
	68
	69	name = purple_account_option_get_setting( o );
	70
	71	switch( purple_account_option_get_type( o ) )
	72	{
	73	case PURPLE_PREF_STRING:
	74	def = g_strdup( purple_account_option_get_default_string( o ) );
	75	break;
	76
	77	case PURPLE_PREF_INT:
	78	def = g_strdup_printf( "%d", purple_account_option_get_default_int( o ) );
	79	eval = set_eval_int;
	80	break;
	81
	82	case PURPLE_PREF_BOOLEAN:
	83	if( purple_account_option_get_default_bool( o ) )
	84	def = g_strdup( "true" );
	85	else
	86	def = g_strdup( "false" );
	87	eval = set_eval_bool;
	88	break;
	89
	90	default:
	91	fprintf( stderr, "Setting with unknown type: %s (%d)\n", name, purple_account_option_get_type( o ) );
[b3117f2]	92	name = NULL;
[0f7ee7e5]	93	}
	94
[b3117f2]	95	if( name != NULL )
[0f7ee7e5]	96	{
	97	s = set_add( &acc->set, name, def, eval, acc );
	98	s->flags \|= ACC_SET_OFFLINE_ONLY;
	99	g_free( def );
	100	}
	101	}
[796da03]	102	}
	103
[b74b287]	104	static void purple_sync_settings( account_t acc, PurpleAccount pa )
	105	{
	106	PurplePlugin *prpl = purple_plugins_find_with_id( pa->protocol_id );
	107	PurplePluginProtocolInfo *pi = prpl->info->extra_info;
	108	GList *i;
	109
	110	for( i = pi->protocol_options; i; i = i->next )
	111	{
	112	PurpleAccountOption *o = i->data;
	113	const char *name;
	114	set_t *s;
	115
	116	name = purple_account_option_get_setting( o );
	117	s = set_find( &acc->set, name );
	118	if( s->value == NULL )
	119	continue;
	120
	121	switch( purple_account_option_get_type( o ) )
	122	{
	123	case PURPLE_PREF_STRING:
	124	purple_account_set_string( pa, name, set_getstr( &acc->set, name ) );
	125	break;
	126
	127	case PURPLE_PREF_INT:
	128	purple_account_set_int( pa, name, set_getint( &acc->set, name ) );
	129	break;
	130
	131	case PURPLE_PREF_BOOLEAN:
	132	purple_account_set_bool( pa, name, set_getbool( &acc->set, name ) );
	133	break;
	134
	135	default:
	136	break;
	137	}
	138	}
	139	}
	140
[796da03]	141	static void purple_login( account_t *acc )
	142	{
	143	struct im_connection *ic = imcb_new( acc );
[860ba6a]	144	PurpleAccount *pa;
[796da03]	145
[0ac1a375]	146	if( local_irc != NULL && local_irc != acc->irc )
[6967d01]	147	{
[0ac1a375]	148	irc_usermsg( acc->irc, "Daemon mode detected. Do not try to use libpurple in daemon mode! "
	149	"Please use inetd or ForkDaemon mode instead." );
[6967d01]	150	return;
	151	}
[0ac1a375]	152	local_irc = acc->irc;
[6967d01]	153
[796da03]	154	/* For now this is needed in the _connected() handlers if using
	155	GLib event handling, to make sure we're not handling events
	156	on dead connections. */
	157	purple_connections = g_slist_prepend( purple_connections, ic );
	158
[cd741d8]	159	ic->proto_data = pa = purple_account_new( acc->user, (char*) acc->prpl->data );
[860ba6a]	160	purple_account_set_password( pa, acc->pass );
[b74b287]	161	purple_sync_settings( acc, pa );
[860ba6a]	162
	163	purple_account_set_enabled( pa, "BitlBee", TRUE );
[796da03]	164	}
	165
	166	static void purple_logout( struct im_connection *ic )
	167	{
[db4cd40]	168	PurpleAccount *pa = ic->proto_data;
	169
	170	purple_account_set_enabled( pa, "BitlBee", FALSE );
[796da03]	171	purple_connections = g_slist_remove( purple_connections, ic );
[b74b287]	172	purple_accounts_remove( pa );
[796da03]	173	}
	174
	175	static int purple_buddy_msg( struct im_connection ic, char who, char *message, int flags )
	176	{
[389f7be]	177	PurpleConversation *conv;
	178
	179	if( ( conv = purple_find_conversation_with_account( PURPLE_CONV_TYPE_IM,
	180	who, ic->proto_data ) ) == NULL )
	181	{
	182	conv = purple_conversation_new( PURPLE_CONV_TYPE_IM,
	183	ic->proto_data, who );
	184	}
	185
	186	purple_conv_im_send( purple_conversation_get_im_data( conv ), message );
[0cbef26]	187
	188	return 1;
[796da03]	189	}
	190
	191	static GList purple_away_states( struct im_connection ic )
	192	{
[ec5e57d]	193	PurpleAccount *pa = ic->proto_data;
	194	GList st, ret = NULL;
	195
	196	for( st = purple_account_get_status_types( pa ); st; st = st->next )
	197	ret = g_list_append( ret, (void*) purple_status_type_get_name( st->data ) );
	198
	199	return ret;
[796da03]	200	}
	201
	202	static void purple_set_away( struct im_connection ic, char state_txt, char *message )
	203	{
[ec5e57d]	204	PurpleAccount *pa = ic->proto_data;
	205	GList status_types = purple_account_get_status_types( pa ), st;
	206	PurpleStatusType *pst = NULL;
	207
	208	for( st = status_types; st; st = st->next )
	209	{
	210	pst = st->data;
	211
	212	if( g_strcasecmp( state_txt, purple_status_type_get_name( pst ) ) == 0 )
	213	break;
	214	}
	215
	216	purple_account_set_status( pa, st ? purple_status_type_get_id( pst ) : "away",
	217	TRUE, "message", message, NULL );
[796da03]	218	}
	219
	220	static void purple_add_buddy( struct im_connection ic, char who, char *group )
	221	{
[b3117f2]	222	PurpleBuddy *pb;
	223
	224	pb = purple_buddy_new( (PurpleAccount*) ic->proto_data, who, NULL );
	225	purple_blist_add_buddy( pb, NULL, NULL, NULL );
	226	purple_account_add_buddy( (PurpleAccount*) ic->proto_data, pb );
[796da03]	227	}
	228
	229	static void purple_remove_buddy( struct im_connection ic, char who, char *group )
	230	{
[b3117f2]	231	PurpleBuddy *pb;
	232
	233	pb = purple_find_buddy( (PurpleAccount*) ic->proto_data, who );
	234	if( pb != NULL )
	235	{
	236	purple_account_remove_buddy( (PurpleAccount*) ic->proto_data, pb, NULL );
	237	purple_blist_remove_buddy( pb );
	238	}
[796da03]	239	}
	240
	241	static void purple_keepalive( struct im_connection *ic )
	242	{
	243	}
	244
	245	static int purple_send_typing( struct im_connection ic, char who, int typing )
	246	{
[0cbef26]	247	return 1;
[796da03]	248	}
	249
[860ba6a]	250	static void purple_ui_init();
	251
	252	static PurpleCoreUiOps bee_core_uiops =
	253	{
	254	NULL,
	255	NULL,
	256	purple_ui_init,
	257	NULL,
	258	};
	259
	260	static void prplcb_conn_progress( PurpleConnection gc, const char text, size_t step, size_t step_count )
	261	{
[0cbef26]	262	struct im_connection *ic = purple_ic_by_gc( gc );
	263
	264	imcb_log( ic, "%s", text );
[860ba6a]	265	}
	266
	267	static void prplcb_conn_connected( PurpleConnection *gc )
	268	{
[d250b2a]	269	struct im_connection *ic = purple_ic_by_gc( gc );
	270
	271	imcb_connected( ic );
	272
	273	if( gc->flags & PURPLE_CONNECTION_HTML )
	274	ic->flags \|= OPT_DOES_HTML;
[860ba6a]	275	}
	276
	277	static void prplcb_conn_disconnected( PurpleConnection *gc )
	278	{
[0cbef26]	279	struct im_connection *ic = purple_ic_by_gc( gc );
	280
	281	if( ic != NULL )
[b74b287]	282	{
[0cbef26]	283	imc_logout( ic, TRUE );
[b74b287]	284	}
[860ba6a]	285	}
	286
	287	static void prplcb_conn_notice( PurpleConnection gc, const char text )
	288	{
[0cbef26]	289	struct im_connection *ic = purple_ic_by_gc( gc );
	290
	291	if( ic != NULL )
	292	imcb_log( ic, "%s", text );
[860ba6a]	293	}
	294
	295	static void prplcb_conn_report_disconnect_reason( PurpleConnection gc, PurpleConnectionError reason, const char text )
	296	{
[0cbef26]	297	struct im_connection *ic = purple_ic_by_gc( gc );
	298
[860ba6a]	299	/* PURPLE_CONNECTION_ERROR_NAME_IN_USE means concurrent login,
	300	should probably handle that. */
[0cbef26]	301	if( ic != NULL )
	302	imcb_error( ic, "%s", text );
[860ba6a]	303	}
	304
	305	static PurpleConnectionUiOps bee_conn_uiops =
	306	{
	307	prplcb_conn_progress,
	308	prplcb_conn_connected,
	309	prplcb_conn_disconnected,
	310	prplcb_conn_notice,
	311	NULL,
	312	NULL,
	313	NULL,
	314	prplcb_conn_report_disconnect_reason,
	315	};
	316
[7da726b]	317	static void prplcb_blist_new( PurpleBlistNode *node )
	318	{
	319	PurpleBuddy bud = (PurpleBuddy) node;
	320
[db4cd40]	321	if( node->type == PURPLE_BLIST_BUDDY_NODE )
[7da726b]	322	{
[db4cd40]	323	struct im_connection *ic = purple_ic_by_pa( bud->account );
	324
	325	if( ic == NULL )
	326	return;
	327
[7da726b]	328	imcb_add_buddy( ic, bud->name, NULL );
	329	if( bud->server_alias )
[4524f66]	330	{
	331	imcb_rename_buddy( ic, bud->name, bud->server_alias );
[7da726b]	332	imcb_buddy_nick_hint( ic, bud->name, bud->server_alias );
[4524f66]	333	}
[7da726b]	334	}
	335	}
	336
	337	static void prplcb_blist_update( PurpleBuddyList list, PurpleBlistNode node )
	338	{
	339	PurpleBuddy bud = (PurpleBuddy) node;
	340
[db4cd40]	341	if( node->type == PURPLE_BLIST_BUDDY_NODE )
[7da726b]	342	{
[db4cd40]	343	struct im_connection *ic = purple_ic_by_pa( bud->account );
[4f103ea]	344	PurpleStatus *as;
	345	int flags = 0;
	346
[db4cd40]	347	if( ic == NULL )
	348	return;
	349
[4524f66]	350	if( bud->server_alias )
	351	imcb_rename_buddy( ic, bud->name, bud->server_alias );
	352
[4f103ea]	353	flags \|= purple_presence_is_online( bud->presence ) ? OPT_LOGGED_IN : 0;
	354	flags \|= purple_presence_is_available( bud->presence ) ? 0 : OPT_AWAY;
	355
	356	as = purple_presence_get_active_status( bud->presence );
	357
	358	imcb_buddy_status( ic, bud->name, flags, purple_status_get_name( as ),
	359	purple_status_get_attr_string( as, "message" ) );
[7da726b]	360	}
	361	}
	362
	363	static void prplcb_blist_remove( PurpleBuddyList list, PurpleBlistNode node )
	364	{
	365	PurpleBuddy bud = (PurpleBuddy) node;
	366
[b3117f2]	367	/*
[db4cd40]	368	if( node->type == PURPLE_BLIST_BUDDY_NODE )
[0cbef26]	369	{
[db4cd40]	370	struct im_connection *ic = purple_ic_by_pa( bud->account );
	371
	372	if( ic == NULL )
	373	return;
	374
[0cbef26]	375	imcb_remove_buddy( ic, bud->name, NULL );
	376	}
[b3117f2]	377	*/
[7da726b]	378	}
	379
	380	static PurpleBlistUiOps bee_blist_uiops =
	381	{
	382	NULL,
	383	prplcb_blist_new,
	384	NULL,
	385	prplcb_blist_update,
	386	prplcb_blist_remove,
	387	};
	388
[d250b2a]	389	static void prplcb_conv_im( PurpleConversation conv, const char who, const char *message, PurpleMessageFlags flags, time_t mtime )
	390	{
	391	struct im_connection *ic = purple_ic_by_pa( conv->account );
	392
[389f7be]	393	/* ..._SEND means it's an outgoing message, no need to echo those. */
	394	if( !( flags & PURPLE_MESSAGE_SEND ) )
	395	imcb_buddy_msg( ic, (char) who, (char) message, 0, mtime );
[d250b2a]	396	}
	397
[860ba6a]	398	static PurpleConversationUiOps bee_conv_uiops =
	399	{
	400	NULL, /* create_conversation */
	401	NULL, /* destroy_conversation */
	402	NULL, /* write_chat */
[d250b2a]	403	prplcb_conv_im, /* write_im */
[e046390]	404	NULL, /* write_conv */
[860ba6a]	405	NULL, /* chat_add_users */
	406	NULL, /* chat_rename_user */
	407	NULL, /* chat_remove_users */
	408	NULL, /* chat_update_user */
	409	NULL, /* present */
	410	NULL, /* has_focus */
	411	NULL, /* custom_smiley_add */
	412	NULL, /* custom_smiley_write */
	413	NULL, /* custom_smiley_close */
	414	NULL, /* send_confirm */
	415	};
	416
[0ac1a375]	417	struct prplcb_request_action_data
	418	{
	419	void user_data, bee_data;
	420	PurpleRequestActionCb yes, no;
	421	int yes_i, no_i;
	422	};
	423
	424	static void prplcb_request_action_yes( void *data )
	425	{
	426	struct prplcb_request_action_data *pqad = data;
	427
	428	pqad->yes( pqad->user_data, pqad->yes_i );
	429	g_free( pqad );
	430	}
	431
	432	static void prplcb_request_action_no( void *data )
	433	{
	434	struct prplcb_request_action_data *pqad = data;
	435
	436	pqad->no( pqad->user_data, pqad->no_i );
	437	g_free( pqad );
	438	}
	439
	440	static void prplcb_request_action( const char title, const char primary, const char secondary,
	441	int default_action, PurpleAccount account, const char who,
	442	PurpleConversation conv, void user_data, size_t action_count,
	443	va_list actions )
	444	{
	445	struct prplcb_request_action_data *pqad;
	446	int i;
	447	char *q;
	448
	449	pqad = g_new0( struct prplcb_request_action_data, 1 );
	450
	451	for( i = 0; i < action_count; i ++ )
	452	{
	453	char *caption;
	454	void *fn;
	455
	456	caption = va_arg( actions, char* );
	457	fn = va_arg( actions, void* );
	458
	459	if( strcmp( caption, "Accept" ) == 0 )
	460	{
	461	pqad->yes = fn;
	462	pqad->yes_i = i;
	463	}
	464	else if( strcmp( caption, "Reject" ) == 0 )
	465	{
	466	pqad->no = fn;
	467	pqad->no_i = i;
	468	}
	469	}
	470
	471	pqad->user_data = user_data;
	472
	473	q = g_strdup_printf( "Request: %s\n\n%s\n\n%s", title, primary, secondary );
	474	pqad->bee_data = query_add( local_irc, purple_ic_by_pa( account ), q,
	475	prplcb_request_action_yes, prplcb_request_action_no, pqad );
	476
	477	g_free( q );
[e5d8d21]	478
	479	return pqad;
[0ac1a375]	480	}
	481
	482	static PurpleRequestUiOps bee_request_uiops =
	483	{
	484	NULL,
	485	NULL,
	486	prplcb_request_action,
	487	NULL,
	488	NULL,
	489	NULL,
	490	NULL,
	491	};
	492
[0cbef26]	493	static void prplcb_debug_print( PurpleDebugLevel level, const char category, const char arg_s )
	494	{
[6967d01]	495	fprintf( stderr, "DEBUG %s: %s", category, arg_s );
[0cbef26]	496	}
	497
	498	static PurpleDebugUiOps bee_debug_uiops =
	499	{
	500	prplcb_debug_print,
	501	};
	502
[4164e62]	503	static guint prplcb_ev_timeout_add( guint interval, GSourceFunc func, gpointer udata )
	504	{
	505	return b_timeout_add( interval, (b_event_handler) func, udata );
	506	}
	507
	508	static guint prplcb_ev_input_add( int fd, PurpleInputCondition cond, PurpleInputFunction func, gpointer udata )
	509	{
	510	return b_input_add( fd, cond \| B_EV_FLAG_FORCE_REPEAT, (b_event_handler) func, udata );
	511	}
	512
	513	static gboolean prplcb_ev_remove( guint id )
	514	{
	515	b_event_remove( (gint) id );
	516	return TRUE;
	517	}
	518
	519	static PurpleEventLoopUiOps glib_eventloops =
	520	{
	521	prplcb_ev_timeout_add,
	522	prplcb_ev_remove,
	523	prplcb_ev_input_add,
	524	prplcb_ev_remove,
	525	};
	526
[860ba6a]	527	static void purple_ui_init()
	528	{
[7da726b]	529	purple_blist_set_ui_ops( &bee_blist_uiops );
[860ba6a]	530	purple_connections_set_ui_ops( &bee_conn_uiops );
	531	purple_conversations_set_ui_ops( &bee_conv_uiops );
[0ac1a375]	532	purple_request_set_ui_ops( &bee_request_uiops );
[0cbef26]	533	//purple_debug_set_ui_ops( &bee_debug_uiops );
[860ba6a]	534	}
	535
[796da03]	536	void purple_initmodule()
	537	{
[cd741d8]	538	struct prpl funcs;
[796da03]	539	GList *prots;
[e5d8d21]	540	GString *help;
[796da03]	541
[e046390]	542	if( B_EV_IO_READ != PURPLE_INPUT_READ \|\|
	543	B_EV_IO_WRITE != PURPLE_INPUT_WRITE )
	544	{
	545	/* FIXME FIXME FIXME FIXME FIXME :-) */
	546	exit( 1 );
	547	}
	548
[796da03]	549	purple_util_set_user_dir("/tmp");
	550	purple_debug_set_enabled(FALSE);
	551	purple_core_set_ui_ops(&bee_core_uiops);
	552	purple_eventloop_set_ui_ops(&glib_eventloops);
	553	if( !purple_core_init( "BitlBee") )
	554	{
	555	/* Initializing the core failed. Terminate. */
	556	fprintf( stderr, "libpurple initialization failed.\n" );
	557	abort();
	558	}
	559
	560	/* This seems like stateful shit we don't want... */
	561	purple_set_blist(purple_blist_new());
	562	purple_blist_load();
	563
	564	/* Meh? */
	565	purple_prefs_load();
	566
[cd741d8]	567	memset( &funcs, 0, sizeof( funcs ) );
	568	funcs.login = purple_login;
	569	funcs.init = purple_init;
	570	funcs.logout = purple_logout;
	571	funcs.buddy_msg = purple_buddy_msg;
	572	funcs.away_states = purple_away_states;
	573	funcs.set_away = purple_set_away;
	574	funcs.add_buddy = purple_add_buddy;
	575	funcs.remove_buddy = purple_remove_buddy;
	576	funcs.keepalive = purple_keepalive;
	577	funcs.send_typing = purple_send_typing;
	578	funcs.handle_cmp = g_strcasecmp;
	579
[e5d8d21]	580	help = g_string_new("BitlBee libpurple module supports the following IM protocols:\n");
	581
[796da03]	582	for( prots = purple_plugins_get_protocols(); prots; prots = prots->next )
	583	{
	584	PurplePlugin *prot = prots->data;
[cd741d8]	585	struct prpl *ret;
[796da03]	586
[cd741d8]	587	ret = g_memdup( &funcs, sizeof( funcs ) );
	588	ret->name = ret->data = prot->info->id;
	589	if( strncmp( ret->name, "prpl-", 5 ) == 0 )
	590	ret->name += 5;
[796da03]	591	register_protocol( ret );
[cd741d8]	592
[e5d8d21]	593	g_string_append_printf( help, "\n* %s (%s)", ret->name, prot->info->name );
	594
[cd741d8]	595	if( g_strcasecmp( prot->info->id, "prpl-aim" ) == 0 )
	596	{
	597	ret = g_memdup( &funcs, sizeof( funcs ) );
	598	ret->name = "oscar";
	599	ret->data = prot->info->id;
	600	register_protocol( ret );
	601	}
[796da03]	602	}
[e5d8d21]	603
	604	help_add_mem( &global.help, "purple", help->str );
	605	g_string_free( help, TRUE );
[796da03]	606	}

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

Download in other formats: