Context Navigation

source: protocols/nogaim.c @ 537d9b9

Last change on this file since 537d9b9 was 537d9b9, checked in by dequis <dx@…>, at 2016-11-20T08:40:36Z
Merge master up to commit '9f03c47' into parson
Property mode set to `100644`
File size: 21.0 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	extern void rpc_initmodule();
207
208	#ifdef WITH_MSN
209	msn_initmodule();
210	#endif
211
212	#ifdef WITH_OSCAR
213	oscar_initmodule();
214	#endif
215
216	#ifdef WITH_YAHOO
217	byahoo_initmodule();
218	#endif
219
220	#ifdef WITH_JABBER
221	jabber_initmodule();
222	#endif
223
224	#ifdef WITH_TWITTER
225	twitter_initmodule();
226	#endif
227
228	#ifdef WITH_PURPLE
229	purple_initmodule();
230	#endif
231
232	#ifdef WITH_RPC
233	rpc_initmodule();
234	#endif
235
236	#ifdef WITH_PLUGINS
237	load_plugins();
238	#endif
239	}
240
241	GList *get_protocols()
242	{
243	return protocols;
244	}
245
246	GList *get_protocols_disabled()
247	{
248	return disabled_protocols;
249	}
250
251	GSList *get_connections()
252	{
253	return connections;
254	}
255
256	struct im_connection imcb_new(account_t acc)
257	{
258	struct im_connection *ic;
259
260	ic = g_new0(struct im_connection, 1);
261
262	ic->bee = acc->bee;
263	ic->acc = acc;
264	acc->ic = ic;
265
266	connections = g_slist_append(connections, ic);
267
268	return(ic);
269	}
270
271	void imc_free(struct im_connection *ic)
272	{
273	account_t *a;
274
275	/* Destroy the pointer to this connection from the account list */
276	for (a = ic->bee->accounts; a; a = a->next) {
277	if (a->ic == ic) {
278	a->ic = NULL;
279	break;
280	}
281	}
282
283	connections = g_slist_remove(connections, ic);
284	g_free(ic);
285	}
286
287	static void serv_got_crap(struct im_connection ic, char format, ...)
288	{
289	va_list params;
290	char *text;
291	account_t *a;
292
293	if (!ic->bee->ui->log) {
294	return;
295	}
296
297	va_start(params, format);
298	text = g_strdup_vprintf(format, params);
299	va_end(params);
300
301	if ((g_strcasecmp(set_getstr(&ic->bee->set, "strip_html"), "always") == 0) \|\|
302	((ic->flags & OPT_DOES_HTML) && set_getbool(&ic->bee->set, "strip_html"))) {
303	strip_html(text);
304	}
305
306	/* Try to find a different connection on the same protocol. */
307	for (a = ic->bee->accounts; a; a = a->next) {
308	if (a->prpl == ic->acc->prpl && a->ic != ic) {
309	break;
310	}
311	}
312
313	/* If we found one, include the screenname in the message. */
314	if (a) {
315	ic->bee->ui->log(ic->bee, ic->acc->tag, text);
316	} else {
317	ic->bee->ui->log(ic->bee, ic->acc->prpl->name, text);
318	}
319
320	g_free(text);
321	}
322
323	void imcb_log(struct im_connection ic, char format, ...)
324	{
325	va_list params;
326	char *text;
327
328	va_start(params, format);
329	text = g_strdup_vprintf(format, params);
330	va_end(params);
331
332	if (ic->flags & OPT_LOGGED_IN) {
333	serv_got_crap(ic, "%s", text);
334	} else {
335	serv_got_crap(ic, "Logging in: %s", text);
336	}
337
338	g_free(text);
339	}
340
341	void imcb_error(struct im_connection ic, char format, ...)
342	{
343	va_list params;
344	char *text;
345
346	va_start(params, format);
347	text = g_strdup_vprintf(format, params);
348	va_end(params);
349
350	if (ic->flags & OPT_LOGGED_IN) {
351	serv_got_crap(ic, "Error: %s", text);
352	} else {
353	serv_got_crap(ic, "Login error: %s", text);
354	}
355
356	g_free(text);
357	}
358
359	static gboolean send_keepalive(gpointer d, gint fd, b_input_condition cond)
360	{
361	struct im_connection *ic = d;
362
363	if ((ic->flags & OPT_PONGS) && !(ic->flags & OPT_PONGED)) {
364	/* This protocol is expected to ack keepalives and hasn't
365	since the last time we were here. */
366	imcb_error(ic, "Connection timeout");
367	imc_logout(ic, TRUE);
368	return FALSE;
369	}
370	ic->flags &= ~OPT_PONGED;
371
372	if (ic->acc->prpl->keepalive) {
373	ic->acc->prpl->keepalive(ic);
374	}
375
376	return TRUE;
377	}
378
379	void start_keepalives(struct im_connection *ic, int interval)
380	{
381	b_event_remove(ic->keepalive);
382	ic->keepalive = b_timeout_add(interval, send_keepalive, ic);
383
384	/* Connecting successfully counts as a first successful pong. */
385	if (ic->flags & OPT_PONGS) {
386	ic->flags \|= OPT_PONGED;
387	}
388	}
389
390	void imcb_connected(struct im_connection *ic)
391	{
392	/* MSN servers sometimes redirect you to a different server and do
393	the whole login sequence again, so these "late" calls to this
394	function should be handled correctly. (IOW, ignored) */
395	if (ic->flags & OPT_LOGGED_IN) {
396	return;
397	}
398
399	if ((ic->acc->flags & ACC_FLAG_LOCAL_CONTACTS) &&
400	!(ic->flags & OPT_LOCAL_CONTACTS_SENT) &&
401	ic->acc->prpl->add_buddy) {
402	GHashTableIter nicks;
403	gpointer handle;
404	g_hash_table_iter_init(&nicks, ic->acc->nicks);
405	while (g_hash_table_iter_next(&nicks, &handle, NULL)) {
406	ic->acc->prpl->add_buddy(ic, (char *) handle, NULL);
407	}
408	}
409
410	imcb_log(ic, "Logged in");
411
412	ic->flags \|= OPT_LOGGED_IN;
413	start_keepalives(ic, 60000);
414
415	/* Necessary to send initial presence status, even if we're not away. */
416	imc_away_send_update(ic);
417
418	/* Apparently we're connected successfully, so reset the
419	exponential backoff timer. */
420	ic->acc->auto_reconnect_delay = 0;
421
422	if (ic->bee->ui->imc_connected) {
423	ic->bee->ui->imc_connected(ic);
424	}
425	}
426
427	gboolean auto_reconnect(gpointer data, gint fd, b_input_condition cond)
428	{
429	account_t *a = data;
430
431	a->reconnect = 0;
432	account_on(a->bee, a);
433
434	return(FALSE); /* Only have to run the timeout once */
435	}
436
437	void cancel_auto_reconnect(account_t *a)
438	{
439	b_event_remove(a->reconnect);
440	a->reconnect = 0;
441	}
442
443	void imc_logout(struct im_connection *ic, int allow_reconnect)
444	{
445	bee_t *bee = ic->bee;
446	account_t *a;
447	GSList *l;
448	int delay;
449
450	/* Nested calls might happen sometimes, this is probably the best
451	place to catch them. */
452	if (ic->flags & OPT_LOGGING_OUT) {
453	return;
454	} else {
455	ic->flags \|= OPT_LOGGING_OUT;
456	}
457
458	if (ic->bee->ui->imc_disconnected) {
459	ic->bee->ui->imc_disconnected(ic);
460	}
461
462	imcb_log(ic, "Signing off..");
463
464	/* TBH I don't remember anymore why I didn't just use ic->acc... */
465	for (a = bee->accounts; a; a = a->next) {
466	if (a->ic == ic) {
467	break;
468	}
469	}
470
471	if (a && !allow_reconnect && !(ic->flags & OPT_LOGGED_IN) &&
472	set_getbool(&a->set, "oauth")) {
473	/* If this account supports OAuth, we're not logged in yet and
474	not allowed to retry, assume there were auth issues. Give a
475	helpful message on what might be necessary to fix this. */
476	imcb_log(ic, "If you're having problems logging in, try re-requesting "
477	"an OAuth token: account %s set password \"\"", a->tag);
478	}
479
480	for (l = bee->users; l; ) {
481	bee_user_t *bu = l->data;
482	GSList *next = l->next;
483
484	if (bu->ic == ic) {
485	bee_user_free(bee, bu);
486	}
487
488	l = next;
489	}
490
491	b_event_remove(ic->keepalive);
492	ic->keepalive = 0;
493	ic->acc->prpl->logout(ic);
494	b_event_remove(ic->inpa);
495
496	g_free(ic->away);
497	ic->away = NULL;
498
499	query_del_by_conn((irc_t *) ic->bee->ui_data, ic);
500
501	/* Throw away groupchats owned by this account. Historically this was only
502	ever done by IM modules which is a bug. But it gives them opportunity
503	to clean up protocol-specific bits as well so keep it that way, just
504	do another cleanup here as a fallback. Don't want to leave any dangling
505	pointers! */
506	while (ic->groupchats) {
507	imcb_chat_free(ic->groupchats->data);
508	}
509
510	if (!a) {
511	/* Uhm... This is very sick. */
512	} else if (allow_reconnect && set_getbool(&bee->set, "auto_reconnect") &&
513	set_getbool(&a->set, "auto_reconnect") &&
514	(delay = account_reconnect_delay(a)) > 0) {
515	imcb_log(ic, "Reconnecting in %d seconds..", delay);
516	a->reconnect = b_timeout_add(delay * 1000, auto_reconnect, a);
517	}
518
519	imc_free(ic);
520	}
521
522	void imcb_ask(struct im_connection ic, char msg, void *data,
523	query_callback doit, query_callback dont)
524	{
525	query_add((irc_t *) ic->bee->ui_data, ic, msg, doit, dont, g_free, data);
526	}
527
528	void imcb_ask_with_free(struct im_connection ic, char msg, void *data,
529	query_callback doit, query_callback dont, query_callback myfree)
530	{
531	query_add((irc_t *) ic->bee->ui_data, ic, msg, doit, dont, myfree, data);
532	}
533
534	void imcb_add_buddy(struct im_connection ic, const char handle, const char *group)
535	{
536	bee_user_t *bu;
537	bee_t *bee = ic->bee;
538	bee_group_t *oldg;
539
540	if (!(bu = bee_user_by_handle(bee, ic, handle))) {
541	bu = bee_user_new(bee, ic, handle, 0);
542	}
543
544	oldg = bu->group;
545	bu->group = bee_group_by_name(bee, group, TRUE);
546
547	if (bee->ui->user_group && bu->group != oldg) {
548	bee->ui->user_group(bee, bu);
549	}
550	}
551
552	void imcb_rename_buddy(struct im_connection ic, const char handle, const char *fullname)
553	{
554	bee_t *bee = ic->bee;
555	bee_user_t *bu = bee_user_by_handle(bee, ic, handle);
556
557	if (!bu \|\| !fullname) {
558	return;
559	}
560
561	if (!bu->fullname \|\| strcmp(bu->fullname, fullname) != 0) {
562	g_free(bu->fullname);
563	bu->fullname = g_strdup(fullname);
564
565	if (bee->ui->user_fullname) {
566	bee->ui->user_fullname(bee, bu);
567	}
568	}
569	}
570
571	void imcb_remove_buddy(struct im_connection ic, const char handle, char *group)
572	{
573	bee_user_free(ic->bee, bee_user_by_handle(ic->bee, ic, handle));
574	}
575
576	/* Implements either imcb_buddy_nick_hint() or imcb_buddy_nick_change() depending on the value of 'change' */
577	static void buddy_nick_hint_or_change(struct im_connection ic, const char handle, const char *nick, gboolean change)
578	{
579	bee_t *bee = ic->bee;
580	bee_user_t *bu = bee_user_by_handle(bee, ic, handle);
581
582	if (!bu \|\| !nick) {
583	return;
584	}
585
586	g_free(bu->nick);
587	bu->nick = g_strdup(nick);
588
589	if (change && bee->ui->user_nick_change) {
590	bee->ui->user_nick_change(bee, bu, nick);
591	} else if (!change && bee->ui->user_nick_hint) {
592	bee->ui->user_nick_hint(bee, bu, nick);
593	}
594	}
595
596	/* Soft variant, for newly created users. Does nothing if it's already online */
597	void imcb_buddy_nick_hint(struct im_connection ic, const char handle, const char *nick)
598	{
599	buddy_nick_hint_or_change(ic, handle, nick, FALSE);
600	}
601
602	/* Hard variant, always changes the nick */
603	void imcb_buddy_nick_change(struct im_connection ic, const char handle, const char *nick)
604	{
605	buddy_nick_hint_or_change(ic, handle, nick, TRUE);
606	}
607
608	/* Returns the local contacts for an IM account (based on assigned nicks).
609	Linked list should be freed, the strings themselves not! So look at it
610	like a GSList<const char*> I guess? Empty list means NULL retval (as
611	always with GSList). */
612	GSList imcb_get_local_contacts(struct im_connection ic)
613	{
614	GHashTableIter nicks;
615	GSList *ret = NULL;
616
617	if (!(ic->acc->flags & ACC_FLAG_LOCAL_CONTACTS)) {
618	/* Only allow protocols that indicate local contact list
619	support to use this function. */
620	return ret;
621	}
622
623	g_hash_table_iter_init(&nicks, ic->acc->nicks);
624	gpointer handle;
625	while (g_hash_table_iter_next(&nicks, &handle, NULL)) {
626	ret = g_slist_prepend(ret, (char *) handle);
627	}
628
629	/* If the protocol asked for the list, assume we won't have to send it
630	anymore in imcb_connected(). */
631	ic->flags \|= OPT_LOCAL_CONTACTS_SENT;
632
633	return ret;
634	}
635
636
637	struct imcb_ask_cb_data {
638	struct im_connection *ic;
639	char *handle;
640	};
641
642	static void imcb_ask_cb_free(void *data)
643	{
644	struct imcb_ask_cb_data *cbd = data;
645
646	g_free(cbd->handle);
647	g_free(cbd);
648	}
649
650	static void imcb_ask_auth_cb_no(void *data)
651	{
652	struct imcb_ask_cb_data *cbd = data;
653
654	cbd->ic->acc->prpl->auth_deny(cbd->ic, cbd->handle);
655
656	imcb_ask_cb_free(cbd);
657	}
658
659	static void imcb_ask_auth_cb_yes(void *data)
660	{
661	struct imcb_ask_cb_data *cbd = data;
662
663	cbd->ic->acc->prpl->auth_allow(cbd->ic, cbd->handle);
664
665	imcb_ask_cb_free(cbd);
666	}
667
668	void imcb_ask_auth(struct im_connection ic, const char handle, const char *realname)
669	{
670	struct imcb_ask_cb_data *data = g_new0(struct imcb_ask_cb_data, 1);
671	char s, realname_ = NULL;
672
673	if (realname != NULL) {
674	realname_ = g_strdup_printf(" (%s)", realname);
675	}
676
677	s = g_strdup_printf("The user %s%s wants to add you to his/her buddy list.",
678	handle, realname_ ? realname_ : "");
679
680	g_free(realname_);
681
682	data->ic = ic;
683	data->handle = g_strdup(handle);
684	query_add((irc_t *) ic->bee->ui_data, ic, s,
685	imcb_ask_auth_cb_yes, imcb_ask_auth_cb_no, imcb_ask_cb_free, data);
686
687	g_free(s);
688	}
689
690	static void imcb_ask_add_cb_yes(void *data)
691	{
692	struct imcb_ask_cb_data *cbd = data;
693
694	if (cbd->ic->acc->prpl->add_buddy) {
695	cbd->ic->acc->prpl->add_buddy(cbd->ic, cbd->handle, NULL);
696	}
697
698	imcb_ask_cb_free(data);
699	}
700
701	void imcb_ask_add(struct im_connection ic, const char handle, const char *realname)
702	{
703	struct imcb_ask_cb_data *data;
704	char *s;
705
706	/* TODO: Make a setting for this! */
707	if (bee_user_by_handle(ic->bee, ic, handle) != NULL) {
708	return;
709	}
710
711	data = g_new0(struct imcb_ask_cb_data, 1);
712
713	s = g_strdup_printf("The user %s is not in your buddy list yet. Do you want to add him/her now?", handle);
714
715	data->ic = ic;
716	data->handle = g_strdup(handle);
717	query_add((irc_t *) ic->bee->ui_data, ic, s,
718	imcb_ask_add_cb_yes, imcb_ask_cb_free, imcb_ask_cb_free, data);
719
720	g_free(s);
721	}
722
723	struct bee_user imcb_buddy_by_handle(struct im_connection ic, const char *handle)
724	{
725	return bee_user_by_handle(ic->bee, ic, handle);
726	}
727
728	/* The plan is to not allow straight calls to prpl functions anymore, but do
729	them all from some wrappers. We'll start to define some down here: */
730
731	int imc_chat_msg(struct groupchat c, char msg, int flags)
732	{
733	char *buf = NULL;
734
735	if ((c->ic->flags & OPT_DOES_HTML) && (g_strncasecmp(msg, "<html>", 6) != 0)) {
736	buf = escape_html(msg);
737	msg = buf;
738	}
739
740	c->ic->acc->prpl->chat_msg(c, msg, flags);
741	g_free(buf);
742
743	return 1;
744	}
745
746	static char imc_away_state_find(GList gcm, char away, char *message);
747
748	int imc_away_send_update(struct im_connection *ic)
749	{
750	char away, msg = NULL;
751
752	if (ic->acc->prpl->away_states == NULL \|\|
753	ic->acc->prpl->set_away == NULL) {
754	return 0;
755	}
756
757	away = set_getstr(&ic->acc->set, "away") ?
758	: set_getstr(&ic->bee->set, "away");
759	if (away && *away) {
760	GList *m = ic->acc->prpl->away_states(ic);
761	if (m == NULL) {
762	return 0;
763	}
764	msg = ic->acc->flags & ACC_FLAG_AWAY_MESSAGE ? away : NULL;
765	away = imc_away_state_find(m, away, &msg) ? :
766	(imc_away_state_find(m, "away", &msg) ? : m->data);
767	} else if (ic->acc->flags & ACC_FLAG_STATUS_MESSAGE) {
768	away = NULL;
769	msg = set_getstr(&ic->acc->set, "status") ?
770	: set_getstr(&ic->bee->set, "status");
771	}
772
773	ic->acc->prpl->set_away(ic, away, msg);
774
775	return 1;
776	}
777
778	static char *imc_away_alias_list[8][5] =
779	{
780	{ "Away from computer", "Away", "Extended away", NULL },
781	{ "NA", "N/A", "Not available", NULL },
782	{ "Busy", "Do not disturb", "DND", "Occupied", NULL },
783	{ "Be right back", "BRB", NULL },
784	{ "On the phone", "Phone", "On phone", NULL },
785	{ "Out to lunch", "Lunch", "Food", NULL },
786	{ "Invisible", "Hidden" },
787	{ NULL }
788	};
789
790	static char imc_away_state_find(GList gcm, char away, char *message)
791	{
792	GList *m;
793	int i, j;
794
795	for (m = gcm; m; m = m->next) {
796	if (g_strncasecmp(m->data, away, strlen(m->data)) == 0) {
797	/* At least the Yahoo! module works better if message
798	contains no data unless it adds something to what
799	we have in state already. */
800	if (strlen(m->data) == strlen(away)) {
801	*message = NULL;
802	}
803
804	return m->data;
805	}
806	}
807
808	for (i = 0; *imc_away_alias_list[i]; i++) {
809	int keep_message;
810
811	for (j = 0; imc_away_alias_list[i][j]; j++) {
812	if (g_strncasecmp(away, imc_away_alias_list[i][j], strlen(imc_away_alias_list[i][j])) == 0) {
813	keep_message = strlen(away) != strlen(imc_away_alias_list[i][j]);
814	break;
815	}
816	}
817
818	if (!imc_away_alias_list[i][j]) { /* If we reach the end, this row */
819	continue; /* is not what we want. Next! */
820
821	}
822	/* Now find an entry in this row which exists in gcm */
823	for (j = 0; imc_away_alias_list[i][j]; j++) {
824	for (m = gcm; m; m = m->next) {
825	if (g_strcasecmp(imc_away_alias_list[i][j], m->data) == 0) {
826	if (!keep_message) {
827	*message = NULL;
828	}
829
830	return imc_away_alias_list[i][j];
831	}
832	}
833	}
834
835	/* No need to look further, apparently this state doesn't
836	have any good alias for this protocol. */
837	break;
838	}
839
840	return NULL;
841	}
842
843	void imc_add_allow(struct im_connection ic, char handle)
844	{
845	if (g_slist_find_custom(ic->permit, handle, (GCompareFunc) ic->acc->prpl->handle_cmp) == NULL) {
846	ic->permit = g_slist_prepend(ic->permit, g_strdup(handle));
847	}
848
849	ic->acc->prpl->add_permit(ic, handle);
850	}
851
852	void imc_rem_allow(struct im_connection ic, char handle)
853	{
854	GSList *l;
855
856	if ((l = g_slist_find_custom(ic->permit, handle, (GCompareFunc) ic->acc->prpl->handle_cmp))) {
857	g_free(l->data);
858	ic->permit = g_slist_delete_link(ic->permit, l);
859	}
860
861	ic->acc->prpl->rem_permit(ic, handle);
862	}
863
864	void imc_add_block(struct im_connection ic, char handle)
865	{
866	if (g_slist_find_custom(ic->deny, handle, (GCompareFunc) ic->acc->prpl->handle_cmp) == NULL) {
867	ic->deny = g_slist_prepend(ic->deny, g_strdup(handle));
868	}
869
870	ic->acc->prpl->add_deny(ic, handle);
871	}
872
873	void imc_rem_block(struct im_connection ic, char handle)
874	{
875	GSList *l;
876
877	if ((l = g_slist_find_custom(ic->deny, handle, (GCompareFunc) ic->acc->prpl->handle_cmp))) {
878	g_free(l->data);
879	ic->deny = g_slist_delete_link(ic->deny, l);
880	}
881
882	ic->acc->prpl->rem_deny(ic, handle);
883	}
884
885	/* Deprecated: using this function resulted in merging several handles accidentally
886	* Also the irc layer handles this decently nowadays */
887	void imcb_clean_handle(struct im_connection ic, char handle)
888	{
889	}

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

Download in other formats: