Context Navigation

source: protocols/nogaim.c @ 59a7dc5

Last change on this file since 59a7dc5 was 35712b7, checked in by jgeboski <jgeboski@…>, at 2016-05-26T02:48:08Z

Only load plugins with the right file extension

Plugins which use autotools will install a .la file along with the .so
file. Both of these files are loadable as plugins, so the plugin ends
up being loaded twice. To prevent this, only load the .so module.

Property mode set to 100644

File size: 19.5 KB

Line
1	/********************************************************************\
2	* BitlBee -- An IRC to other IM-networks gateway *
3	* *
4	* Copyright 2002-2012 Wilmer van der Gaast and others *
5	\********************************************************************/
6
7	/*
8	* nogaim
9	*
10	* Gaim without gaim - for BitlBee
11	*
12	* This file contains functions called by the Gaim IM-modules. It's written
13	* from scratch for BitlBee and doesn't contain any code from Gaim anymore
14	* (except for the function names).
15	*/
16
17	/*
18	This program is free software; you can redistribute it and/or modify
19	it under the terms of the GNU General Public License as published by
20	the Free Software Foundation; either version 2 of the License, or
21	(at your option) any later version.
22
23	This program is distributed in the hope that it will be useful,
24	but WITHOUT ANY WARRANTY; without even the implied warranty of
25	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26	GNU General Public License for more details.
27
28	You should have received a copy of the GNU General Public License with
29	the Debian GNU/Linux distribution in /usr/share/common-licenses/GPL;
30	if not, write to the Free Software Foundation, Inc., 51 Franklin St.,
31	Fifth Floor, Boston, MA 02110-1301 USA
32	*/
33
34	#define BITLBEE_CORE
35	#include <ctype.h>
36
37	#include "nogaim.h"
38
39	GSList *connections;
40
41	#ifdef WITH_PLUGINS
42	GList *plugins = NULL;
43
44	static gint pluginscmp(gconstpointer a, gconstpointer b, gpointer data)
45	{
46	const struct plugin_info *ia = a;
47	const struct plugin_info *ib = b;
48
49	return g_strcasecmp(ia->name, ib->name);
50	}
51
52	gboolean load_plugin(char *path)
53	{
54	GList *l;
55	struct plugin_info *i;
56	struct plugin_info *info;
57	struct plugin_info * (*info_function) (void) = NULL;
58	void (*init_function) (void);
59
60	GModule *mod = g_module_open(path, G_MODULE_BIND_LAZY);
61	gboolean loaded = FALSE;
62
63	if (!mod) {
64	log_message(LOGLVL_ERROR, "Error loading plugin `%s': %s\n", path, g_module_error());
65	return FALSE;
66	}
67
68	if (g_module_symbol(mod, "init_plugin_info", (gpointer *) &info_function)) {
69	info = info_function();
70
71	if (info->abiver != BITLBEE_ABI_VERSION_CODE) {
72	log_message(LOGLVL_ERROR,
73	"`%s' uses ABI %u but %u is required\n",
74	path, info->abiver,
75	BITLBEE_ABI_VERSION_CODE);
76	g_module_close(mod);
77	return FALSE;
78	}
79
80	if (!info->name \|\| !info->version) {
81	log_message(LOGLVL_ERROR,
82	"Name or version missing from the "
83	"plugin info in `%s'\n", path);
84	g_module_close(mod);
85	return FALSE;
86	}
87
88	for (l = plugins; l; l = l->next) {
89	i = l->data;
90
91	if (g_strcasecmp(i->name, info->name) == 0) {
92	loaded = TRUE;
93	break;
94	}
95	}
96
97	if (loaded) {
98	log_message(LOGLVL_WARNING,
99	"%s plugin already loaded\n",
100	info->name);
101	g_module_close(mod);
102	return FALSE;
103	}
104	} else {
105	log_message(LOGLVL_WARNING, "Can't find function `init_plugin_info' in `%s'\n", path);
106	}
107
108	if (!g_module_symbol(mod, "init_plugin", (gpointer *) &init_function)) {
109	log_message(LOGLVL_WARNING, "Can't find function `init_plugin' in `%s'\n", path);
110	g_module_close(mod);
111	return FALSE;
112	}
113
114	if (info_function) {
115	plugins = g_list_insert_sorted_with_data(plugins, info,
116	pluginscmp, NULL);
117	}
118
119	init_function();
120	return TRUE;
121	}
122
123	void load_plugins(void)
124	{
125	GDir *dir;
126	GError *error = NULL;
127
128	dir = g_dir_open(global.conf->plugindir, 0, &error);
129
130	if (dir) {
131	const gchar *entry;
132	char *path;
133
134	while ((entry = g_dir_read_name(dir))) {
135	if (!g_str_has_suffix(entry, "." G_MODULE_SUFFIX)) {
136	continue;
137	}
138
139	path = g_build_filename(global.conf->plugindir, entry, NULL);
140	if (!path) {
141	log_message(LOGLVL_WARNING, "Can't build path for %s\n", entry);
142	continue;
143	}
144
145	load_plugin(path);
146
147	g_free(path);
148	}
149
150	g_dir_close(dir);
151	}
152	}
153
154	GList *get_plugins()
155	{
156	return plugins;
157	}
158	#endif
159
160	GList *protocols = NULL;
161	GList *disabled_protocols = NULL;
162
163	void register_protocol(struct prpl *p)
164	{
165	int i;
166	gboolean refused = global.conf->protocols != NULL;
167
168	for (i = 0; global.conf->protocols && global.conf->protocols[i]; i++) {
169	if (g_strcasecmp(p->name, global.conf->protocols[i]) == 0) {
170	refused = FALSE;
171	}
172	}
173
174	if (refused) {
175	disabled_protocols = g_list_append(disabled_protocols, p);
176	} else {
177	protocols = g_list_append(protocols, p);
178	}
179	}
180
181	static int proto_name_cmp(const void proto_, const void name)
182	{
183	const struct prpl *proto = proto_;
184	return g_strcasecmp(proto->name, name);
185	}
186
187	struct prpl find_protocol(const char name)
188	{
189	GList *gl = g_list_find_custom(protocols, name, proto_name_cmp);
190	return gl ? gl->data: NULL;
191	}
192
193	gboolean is_protocol_disabled(const char *name)
194	{
195	return g_list_find_custom(disabled_protocols, name, proto_name_cmp) != NULL;
196	}
197
198	void nogaim_init()
199	{
200	extern void msn_initmodule();
201	extern void oscar_initmodule();
202	extern void byahoo_initmodule();
203	extern void jabber_initmodule();
204	extern void twitter_initmodule();
205	extern void purple_initmodule();
206
207	#ifdef WITH_MSN
208	msn_initmodule();
209	#endif
210
211	#ifdef WITH_OSCAR
212	oscar_initmodule();
213	#endif
214
215	#ifdef WITH_YAHOO
216	byahoo_initmodule();
217	#endif
218
219	#ifdef WITH_JABBER
220	jabber_initmodule();
221	#endif
222
223	#ifdef WITH_TWITTER
224	twitter_initmodule();
225	#endif
226
227	#ifdef WITH_PURPLE
228	purple_initmodule();
229	#endif
230
231	#ifdef WITH_PLUGINS
232	load_plugins();
233	#endif
234	}
235
236	GList *get_protocols()
237	{
238	return protocols;
239	}
240
241	GList *get_protocols_disabled()
242	{
243	return disabled_protocols;
244	}
245
246	GSList *get_connections()
247	{
248	return connections;
249	}
250
251	struct im_connection imcb_new(account_t acc)
252	{
253	struct im_connection *ic;
254
255	ic = g_new0(struct im_connection, 1);
256
257	ic->bee = acc->bee;
258	ic->acc = acc;
259	acc->ic = ic;
260
261	connections = g_slist_append(connections, ic);
262
263	return(ic);
264	}
265
266	void imc_free(struct im_connection *ic)
267	{
268	account_t *a;
269
270	/* Destroy the pointer to this connection from the account list */
271	for (a = ic->bee->accounts; a; a = a->next) {
272	if (a->ic == ic) {
273	a->ic = NULL;
274	break;
275	}
276	}
277
278	connections = g_slist_remove(connections, ic);
279	g_free(ic);
280	}
281
282	static void serv_got_crap(struct im_connection ic, char format, ...)
283	{
284	va_list params;
285	char *text;
286	account_t *a;
287
288	if (!ic->bee->ui->log) {
289	return;
290	}
291
292	va_start(params, format);
293	text = g_strdup_vprintf(format, params);
294	va_end(params);
295
296	if ((g_strcasecmp(set_getstr(&ic->bee->set, "strip_html"), "always") == 0) \|\|
297	((ic->flags & OPT_DOES_HTML) && set_getbool(&ic->bee->set, "strip_html"))) {
298	strip_html(text);
299	}
300
301	/* Try to find a different connection on the same protocol. */
302	for (a = ic->bee->accounts; a; a = a->next) {
303	if (a->prpl == ic->acc->prpl && a->ic != ic) {
304	break;
305	}
306	}
307
308	/* If we found one, include the screenname in the message. */
309	if (a) {
310	ic->bee->ui->log(ic->bee, ic->acc->tag, text);
311	} else {
312	ic->bee->ui->log(ic->bee, ic->acc->prpl->name, text);
313	}
314
315	g_free(text);
316	}
317
318	void imcb_log(struct im_connection ic, char format, ...)
319	{
320	va_list params;
321	char *text;
322
323	va_start(params, format);
324	text = g_strdup_vprintf(format, params);
325	va_end(params);
326
327	if (ic->flags & OPT_LOGGED_IN) {
328	serv_got_crap(ic, "%s", text);
329	} else {
330	serv_got_crap(ic, "Logging in: %s", text);
331	}
332
333	g_free(text);
334	}
335
336	void imcb_error(struct im_connection ic, char format, ...)
337	{
338	va_list params;
339	char *text;
340
341	va_start(params, format);
342	text = g_strdup_vprintf(format, params);
343	va_end(params);
344
345	if (ic->flags & OPT_LOGGED_IN) {
346	serv_got_crap(ic, "Error: %s", text);
347	} else {
348	serv_got_crap(ic, "Login error: %s", text);
349	}
350
351	g_free(text);
352	}
353
354	static gboolean send_keepalive(gpointer d, gint fd, b_input_condition cond)
355	{
356	struct im_connection *ic = d;
357
358	if ((ic->flags & OPT_PONGS) && !(ic->flags & OPT_PONGED)) {
359	/* This protocol is expected to ack keepalives and hasn't
360	since the last time we were here. */
361	imcb_error(ic, "Connection timeout");
362	imc_logout(ic, TRUE);
363	return FALSE;
364	}
365	ic->flags &= ~OPT_PONGED;
366
367	if (ic->acc->prpl->keepalive) {
368	ic->acc->prpl->keepalive(ic);
369	}
370
371	return TRUE;
372	}
373
374	void start_keepalives(struct im_connection *ic, int interval)
375	{
376	b_event_remove(ic->keepalive);
377	ic->keepalive = b_timeout_add(interval, send_keepalive, ic);
378
379	/* Connecting successfully counts as a first successful pong. */
380	if (ic->flags & OPT_PONGS) {
381	ic->flags \|= OPT_PONGED;
382	}
383	}
384
385	void imcb_connected(struct im_connection *ic)
386	{
387	/* MSN servers sometimes redirect you to a different server and do
388	the whole login sequence again, so these "late" calls to this
389	function should be handled correctly. (IOW, ignored) */
390	if (ic->flags & OPT_LOGGED_IN) {
391	return;
392	}
393
394	if (ic->acc->flags & ACC_FLAG_LOCAL) {
395	GHashTableIter nicks;
396	gpointer k, v;
397	g_hash_table_iter_init(&nicks, ic->acc->nicks);
398	while (g_hash_table_iter_next(&nicks, &k, &v)) {
399	ic->acc->prpl->add_buddy(ic, (char *) k, NULL);
400	}
401	}
402
403	imcb_log(ic, "Logged in");
404
405	ic->flags \|= OPT_LOGGED_IN;
406	start_keepalives(ic, 60000);
407
408	/* Necessary to send initial presence status, even if we're not away. */
409	imc_away_send_update(ic);
410
411	/* Apparently we're connected successfully, so reset the
412	exponential backoff timer. */
413	ic->acc->auto_reconnect_delay = 0;
414
415	if (ic->bee->ui->imc_connected) {
416	ic->bee->ui->imc_connected(ic);
417	}
418	}
419
420	gboolean auto_reconnect(gpointer data, gint fd, b_input_condition cond)
421	{
422	account_t *a = data;
423
424	a->reconnect = 0;
425	account_on(a->bee, a);
426
427	return(FALSE); /* Only have to run the timeout once */
428	}
429
430	void cancel_auto_reconnect(account_t *a)
431	{
432	b_event_remove(a->reconnect);
433	a->reconnect = 0;
434	}
435
436	void imc_logout(struct im_connection *ic, int allow_reconnect)
437	{
438	bee_t *bee = ic->bee;
439	account_t *a;
440	GSList *l;
441	int delay;
442
443	/* Nested calls might happen sometimes, this is probably the best
444	place to catch them. */
445	if (ic->flags & OPT_LOGGING_OUT) {
446	return;
447	} else {
448	ic->flags \|= OPT_LOGGING_OUT;
449	}
450
451	if (ic->bee->ui->imc_disconnected) {
452	ic->bee->ui->imc_disconnected(ic);
453	}
454
455	imcb_log(ic, "Signing off..");
456
457	/* TBH I don't remember anymore why I didn't just use ic->acc... */
458	for (a = bee->accounts; a; a = a->next) {
459	if (a->ic == ic) {
460	break;
461	}
462	}
463
464	if (a && !allow_reconnect && !(ic->flags & OPT_LOGGED_IN) &&
465	set_getbool(&a->set, "oauth")) {
466	/* If this account supports OAuth, we're not logged in yet and
467	not allowed to retry, assume there were auth issues. Give a
468	helpful message on what might be necessary to fix this. */
469	imcb_log(ic, "If you're having problems logging in, try re-requesting "
470	"an OAuth token: account %s set password \"\"", a->tag);
471	}
472
473	for (l = bee->users; l; ) {
474	bee_user_t *bu = l->data;
475	GSList *next = l->next;
476
477	if (bu->ic == ic) {
478	bee_user_free(bee, bu);
479	}
480
481	l = next;
482	}
483
484	b_event_remove(ic->keepalive);
485	ic->keepalive = 0;
486	ic->acc->prpl->logout(ic);
487	b_event_remove(ic->inpa);
488
489	g_free(ic->away);
490	ic->away = NULL;
491
492	query_del_by_conn((irc_t *) ic->bee->ui_data, ic);
493
494	if (!a) {
495	/* Uhm... This is very sick. */
496	} else if (allow_reconnect && set_getbool(&bee->set, "auto_reconnect") &&
497	set_getbool(&a->set, "auto_reconnect") &&
498	(delay = account_reconnect_delay(a)) > 0) {
499	imcb_log(ic, "Reconnecting in %d seconds..", delay);
500	a->reconnect = b_timeout_add(delay * 1000, auto_reconnect, a);
501	}
502
503	imc_free(ic);
504	}
505
506	void imcb_ask(struct im_connection ic, char msg, void *data,
507	query_callback doit, query_callback dont)
508	{
509	query_add((irc_t *) ic->bee->ui_data, ic, msg, doit, dont, g_free, data);
510	}
511
512	void imcb_ask_with_free(struct im_connection ic, char msg, void *data,
513	query_callback doit, query_callback dont, query_callback myfree)
514	{
515	query_add((irc_t *) ic->bee->ui_data, ic, msg, doit, dont, myfree, data);
516	}
517
518	void imcb_add_buddy(struct im_connection ic, const char handle, const char *group)
519	{
520	bee_user_t *bu;
521	bee_t *bee = ic->bee;
522	bee_group_t *oldg;
523
524	if (!(bu = bee_user_by_handle(bee, ic, handle))) {
525	bu = bee_user_new(bee, ic, handle, 0);
526	}
527
528	oldg = bu->group;
529	bu->group = bee_group_by_name(bee, group, TRUE);
530
531	if (bee->ui->user_group && bu->group != oldg) {
532	bee->ui->user_group(bee, bu);
533	}
534	}
535
536	void imcb_rename_buddy(struct im_connection ic, const char handle, const char *fullname)
537	{
538	bee_t *bee = ic->bee;
539	bee_user_t *bu = bee_user_by_handle(bee, ic, handle);
540
541	if (!bu \|\| !fullname) {
542	return;
543	}
544
545	if (!bu->fullname \|\| strcmp(bu->fullname, fullname) != 0) {
546	g_free(bu->fullname);
547	bu->fullname = g_strdup(fullname);
548
549	if (bee->ui->user_fullname) {
550	bee->ui->user_fullname(bee, bu);
551	}
552	}
553	}
554
555	void imcb_remove_buddy(struct im_connection ic, const char handle, char *group)
556	{
557	bee_user_free(ic->bee, bee_user_by_handle(ic->bee, ic, handle));
558	}
559
560	/* Implements either imcb_buddy_nick_hint() or imcb_buddy_nick_change() depending on the value of 'change' */
561	static void buddy_nick_hint_or_change(struct im_connection ic, const char handle, const char *nick, gboolean change)
562	{
563	bee_t *bee = ic->bee;
564	bee_user_t *bu = bee_user_by_handle(bee, ic, handle);
565
566	if (!bu \|\| !nick) {
567	return;
568	}
569
570	g_free(bu->nick);
571	bu->nick = g_strdup(nick);
572
573	if (change && bee->ui->user_nick_change) {
574	bee->ui->user_nick_change(bee, bu, nick);
575	} else if (!change && bee->ui->user_nick_hint) {
576	bee->ui->user_nick_hint(bee, bu, nick);
577	}
578	}
579
580	/* Soft variant, for newly created users. Does nothing if it's already online */
581	void imcb_buddy_nick_hint(struct im_connection ic, const char handle, const char *nick)
582	{
583	buddy_nick_hint_or_change(ic, handle, nick, FALSE);
584	}
585
586	/* Hard variant, always changes the nick */
587	void imcb_buddy_nick_change(struct im_connection ic, const char handle, const char *nick)
588	{
589	buddy_nick_hint_or_change(ic, handle, nick, TRUE);
590	}
591
592	struct imcb_ask_cb_data {
593	struct im_connection *ic;
594	char *handle;
595	};
596
597	static void imcb_ask_cb_free(void *data)
598	{
599	struct imcb_ask_cb_data *cbd = data;
600
601	g_free(cbd->handle);
602	g_free(cbd);
603	}
604
605	static void imcb_ask_auth_cb_no(void *data)
606	{
607	struct imcb_ask_cb_data *cbd = data;
608
609	cbd->ic->acc->prpl->auth_deny(cbd->ic, cbd->handle);
610
611	imcb_ask_cb_free(cbd);
612	}
613
614	static void imcb_ask_auth_cb_yes(void *data)
615	{
616	struct imcb_ask_cb_data *cbd = data;
617
618	cbd->ic->acc->prpl->auth_allow(cbd->ic, cbd->handle);
619
620	imcb_ask_cb_free(cbd);
621	}
622
623	void imcb_ask_auth(struct im_connection ic, const char handle, const char *realname)
624	{
625	struct imcb_ask_cb_data *data = g_new0(struct imcb_ask_cb_data, 1);
626	char s, realname_ = NULL;
627
628	if (realname != NULL) {
629	realname_ = g_strdup_printf(" (%s)", realname);
630	}
631
632	s = g_strdup_printf("The user %s%s wants to add you to his/her buddy list.",
633	handle, realname_ ? realname_ : "");
634
635	g_free(realname_);
636
637	data->ic = ic;
638	data->handle = g_strdup(handle);
639	query_add((irc_t *) ic->bee->ui_data, ic, s,
640	imcb_ask_auth_cb_yes, imcb_ask_auth_cb_no, imcb_ask_cb_free, data);
641
642	g_free(s);
643	}
644
645	static void imcb_ask_add_cb_yes(void *data)
646	{
647	struct imcb_ask_cb_data *cbd = data;
648
649	cbd->ic->acc->prpl->add_buddy(cbd->ic, cbd->handle, NULL);
650
651	imcb_ask_cb_free(data);
652	}
653
654	void imcb_ask_add(struct im_connection ic, const char handle, const char *realname)
655	{
656	struct imcb_ask_cb_data *data;
657	char *s;
658
659	/* TODO: Make a setting for this! */
660	if (bee_user_by_handle(ic->bee, ic, handle) != NULL) {
661	return;
662	}
663
664	data = g_new0(struct imcb_ask_cb_data, 1);
665
666	s = g_strdup_printf("The user %s is not in your buddy list yet. Do you want to add him/her now?", handle);
667
668	data->ic = ic;
669	data->handle = g_strdup(handle);
670	query_add((irc_t *) ic->bee->ui_data, ic, s,
671	imcb_ask_add_cb_yes, imcb_ask_cb_free, imcb_ask_cb_free, data);
672
673	g_free(s);
674	}
675
676	struct bee_user imcb_buddy_by_handle(struct im_connection ic, const char *handle)
677	{
678	return bee_user_by_handle(ic->bee, ic, handle);
679	}
680
681	/* The plan is to not allow straight calls to prpl functions anymore, but do
682	them all from some wrappers. We'll start to define some down here: */
683
684	int imc_chat_msg(struct groupchat c, char msg, int flags)
685	{
686	char *buf = NULL;
687
688	if ((c->ic->flags & OPT_DOES_HTML) && (g_strncasecmp(msg, "<html>", 6) != 0)) {
689	buf = escape_html(msg);
690	msg = buf;
691	}
692
693	c->ic->acc->prpl->chat_msg(c, msg, flags);
694	g_free(buf);
695
696	return 1;
697	}
698
699	static char imc_away_state_find(GList gcm, char away, char *message);
700
701	int imc_away_send_update(struct im_connection *ic)
702	{
703	char away, msg = NULL;
704
705	if (ic->acc->prpl->away_states == NULL \|\|
706	ic->acc->prpl->set_away == NULL) {
707	return 0;
708	}
709
710	away = set_getstr(&ic->acc->set, "away") ?
711	: set_getstr(&ic->bee->set, "away");
712	if (away && *away) {
713	GList *m = ic->acc->prpl->away_states(ic);
714	msg = ic->acc->flags & ACC_FLAG_AWAY_MESSAGE ? away : NULL;
715	away = imc_away_state_find(m, away, &msg) ? :
716	(imc_away_state_find(m, "away", &msg) ? : m->data);
717	} else if (ic->acc->flags & ACC_FLAG_STATUS_MESSAGE) {
718	away = NULL;
719	msg = set_getstr(&ic->acc->set, "status") ?
720	: set_getstr(&ic->bee->set, "status");
721	}
722
723	ic->acc->prpl->set_away(ic, away, msg);
724
725	return 1;
726	}
727
728	static char *imc_away_alias_list[8][5] =
729	{
730	{ "Away from computer", "Away", "Extended away", NULL },
731	{ "NA", "N/A", "Not available", NULL },
732	{ "Busy", "Do not disturb", "DND", "Occupied", NULL },
733	{ "Be right back", "BRB", NULL },
734	{ "On the phone", "Phone", "On phone", NULL },
735	{ "Out to lunch", "Lunch", "Food", NULL },
736	{ "Invisible", "Hidden" },
737	{ NULL }
738	};
739
740	static char imc_away_state_find(GList gcm, char away, char *message)
741	{
742	GList *m;
743	int i, j;
744
745	for (m = gcm; m; m = m->next) {
746	if (g_strncasecmp(m->data, away, strlen(m->data)) == 0) {
747	/* At least the Yahoo! module works better if message
748	contains no data unless it adds something to what
749	we have in state already. */
750	if (strlen(m->data) == strlen(away)) {
751	*message = NULL;
752	}
753
754	return m->data;
755	}
756	}
757
758	for (i = 0; *imc_away_alias_list[i]; i++) {
759	int keep_message;
760
761	for (j = 0; imc_away_alias_list[i][j]; j++) {
762	if (g_strncasecmp(away, imc_away_alias_list[i][j], strlen(imc_away_alias_list[i][j])) == 0) {
763	keep_message = strlen(away) != strlen(imc_away_alias_list[i][j]);
764	break;
765	}
766	}
767
768	if (!imc_away_alias_list[i][j]) { /* If we reach the end, this row */
769	continue; /* is not what we want. Next! */
770
771	}
772	/* Now find an entry in this row which exists in gcm */
773	for (j = 0; imc_away_alias_list[i][j]; j++) {
774	for (m = gcm; m; m = m->next) {
775	if (g_strcasecmp(imc_away_alias_list[i][j], m->data) == 0) {
776	if (!keep_message) {
777	*message = NULL;
778	}
779
780	return imc_away_alias_list[i][j];
781	}
782	}
783	}
784
785	/* No need to look further, apparently this state doesn't
786	have any good alias for this protocol. */
787	break;
788	}
789
790	return NULL;
791	}
792
793	void imc_add_allow(struct im_connection ic, char handle)
794	{
795	if (g_slist_find_custom(ic->permit, handle, (GCompareFunc) ic->acc->prpl->handle_cmp) == NULL) {
796	ic->permit = g_slist_prepend(ic->permit, g_strdup(handle));
797	}
798
799	ic->acc->prpl->add_permit(ic, handle);
800	}
801
802	void imc_rem_allow(struct im_connection ic, char handle)
803	{
804	GSList *l;
805
806	if ((l = g_slist_find_custom(ic->permit, handle, (GCompareFunc) ic->acc->prpl->handle_cmp))) {
807	g_free(l->data);
808	ic->permit = g_slist_delete_link(ic->permit, l);
809	}
810
811	ic->acc->prpl->rem_permit(ic, handle);
812	}
813
814	void imc_add_block(struct im_connection ic, char handle)
815	{
816	if (g_slist_find_custom(ic->deny, handle, (GCompareFunc) ic->acc->prpl->handle_cmp) == NULL) {
817	ic->deny = g_slist_prepend(ic->deny, g_strdup(handle));
818	}
819
820	ic->acc->prpl->add_deny(ic, handle);
821	}
822
823	void imc_rem_block(struct im_connection ic, char handle)
824	{
825	GSList *l;
826
827	if ((l = g_slist_find_custom(ic->deny, handle, (GCompareFunc) ic->acc->prpl->handle_cmp))) {
828	g_free(l->data);
829	ic->deny = g_slist_delete_link(ic->deny, l);
830	}
831
832	ic->acc->prpl->rem_deny(ic, handle);
833	}
834
835	/* Deprecated: using this function resulted in merging several handles accidentally
836	* Also the irc layer handles this decently nowadays */
837	void imcb_clean_handle(struct im_connection ic, char handle)
838	{
839	}

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

Download in other formats: