Context Navigation

source: protocols/nogaim.c @ 5447c59

Last change on this file since 5447c59 was 7a9d968, checked in by Wilmer van der Gaast <wilmer@…>, at 2018-03-10T11:30:39Z
Merge branch 'master' into HEAD
Property mode set to `100644`
File size: 22.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	/* semi-private */
53	gboolean plugin_info_validate(struct plugin_info info, const char path)
54	{
55	GList *l;
56	gboolean loaded = FALSE;
57
58	if (!path) {
59	path = "(null)";
60	}
61
62	if (info->abiver != BITLBEE_ABI_VERSION_CODE) {
63	log_message(LOGLVL_ERROR,
64	"`%s' uses ABI %u but %u is required\n",
65	path, info->abiver,
66	BITLBEE_ABI_VERSION_CODE);
67	return FALSE;
68	}
69
70	if (!info->name \|\| !info->version) {
71	log_message(LOGLVL_ERROR,
72	"Name or version missing from the "
73	"plugin info in `%s'\n", path);
74	return FALSE;
75	}
76
77	for (l = plugins; l; l = l->next) {
78	struct plugin_info *i = l->data;
79
80	if (g_strcasecmp(i->name, info->name) == 0) {
81	loaded = TRUE;
82	break;
83	}
84	}
85
86	if (loaded) {
87	log_message(LOGLVL_WARNING,
88	"%s plugin already loaded\n",
89	info->name);
90	return FALSE;
91	}
92
93	return TRUE;
94	}
95
96	/* semi-private */
97	gboolean plugin_info_add(struct plugin_info *info)
98	{
99	plugins = g_list_insert_sorted_with_data(plugins, info, pluginscmp, NULL);
100	return TRUE;
101	}
102
103	gboolean load_plugin(char *path)
104	{
105	struct plugin_info *info = NULL;
106	struct plugin_info * (*info_function) (void) = NULL;
107	void (*init_function) (void);
108
109	GModule *mod = g_module_open(path, G_MODULE_BIND_LAZY);
110
111	if (!mod) {
112	log_message(LOGLVL_ERROR, "Error loading plugin `%s': %s\n", path, g_module_error());
113	return FALSE;
114	}
115
116	if (g_module_symbol(mod, "init_plugin_info", (gpointer *) &info_function)) {
117	info = info_function();
118
119	if (!plugin_info_validate(info, path)) {
120	g_module_close(mod);
121	return FALSE;
122	}
123	} else {
124	log_message(LOGLVL_WARNING, "Can't find function `init_plugin_info' in `%s'\n", path);
125	}
126
127	if (!g_module_symbol(mod, "init_plugin", (gpointer *) &init_function)) {
128	log_message(LOGLVL_WARNING, "Can't find function `init_plugin' in `%s'\n", path);
129	g_module_close(mod);
130	return FALSE;
131	}
132
133	if (info_function) {
134	plugin_info_add(info);
135	}
136
137	init_function();
138	return TRUE;
139	}
140
141	void load_plugins(void)
142	{
143	GDir *dir;
144	GError *error = NULL;
145
146	dir = g_dir_open(global.conf->plugindir, 0, &error);
147
148	if (dir) {
149	const gchar *entry;
150	char *path;
151
152	while ((entry = g_dir_read_name(dir))) {
153	if (!g_str_has_suffix(entry, "." G_MODULE_SUFFIX)) {
154	continue;
155	}
156
157	path = g_build_filename(global.conf->plugindir, entry, NULL);
158	if (!path) {
159	log_message(LOGLVL_WARNING, "Can't build path for %s\n", entry);
160	continue;
161	}
162
163	load_plugin(path);
164
165	g_free(path);
166	}
167
168	g_dir_close(dir);
169	}
170	}
171
172	GList *get_plugins()
173	{
174	return plugins;
175	}
176	#endif
177
178	GList *protocols = NULL;
179	GList *disabled_protocols = NULL;
180
181	void register_protocol(struct prpl *p)
182	{
183	int i;
184	gboolean refused = global.conf->protocols != NULL;
185
186	for (i = 0; global.conf->protocols && global.conf->protocols[i]; i++) {
187	if (g_strcasecmp(p->name, global.conf->protocols[i]) == 0) {
188	refused = FALSE;
189	}
190	}
191
192	if (refused) {
193	disabled_protocols = g_list_append(disabled_protocols, p);
194	} else {
195	protocols = g_list_append(protocols, p);
196	}
197	}
198
199	static int proto_name_cmp(const void proto_, const void name)
200	{
201	const struct prpl *proto = proto_;
202	return g_strcasecmp(proto->name, name);
203	}
204
205	struct prpl find_protocol(const char name)
206	{
207	GList *gl = g_list_find_custom(protocols, name, proto_name_cmp);
208	return gl ? gl->data: NULL;
209	}
210
211	gboolean is_protocol_disabled(const char *name)
212	{
213	return g_list_find_custom(disabled_protocols, name, proto_name_cmp) != NULL;
214	}
215
216	/* Returns heap allocated string with text attempting to explain why a protocol is missing
217	* Free the return value with g_free() */
218	char explain_unknown_protocol(const char name)
219	{
220	char *extramsg = NULL;
221
222	if (is_protocol_disabled(name)) {
223	return g_strdup("Protocol disabled in the global config (bitlbee.conf)");
224	}
225
226	if (strcmp(name, "yahoo") == 0) {
227	return g_strdup("The old yahoo protocol is gone, try the funyahoo++ libpurple plugin instead.");
228	}
229
230	#ifdef WITH_PURPLE
231	if ((strcmp(name, "msn") == 0) \|\|
232	(strcmp(name, "loubserp-mxit") == 0) \|\|
233	(strcmp(name, "myspace") == 0)) {
234	return g_strdup("This protocol has been removed from your libpurple version.");
235	}
236
237	if (strcmp(name, "hipchat") == 0) {
238	return g_strdup("This account type isn't supported by libpurple's jabber.");
239	}
240
241	#else
242	if (strcmp(name, "aim") == 0 \|\| strcmp(name, "icq") == 0) {
243	return g_strdup("This account uses libpurple specific aliases for oscar. "
244	"Re-add the account with `account add oscar ...'");
245	}
246
247	extramsg = "If this is a libpurple plugin, you might need to install bitlbee-libpurple instead.";
248	#endif
249	return g_strconcat("The protocol plugin is not installed or could not be loaded. "
250	"Use the `plugins' command to list available protocols. ",
251	extramsg, NULL);
252	}
253
254	void nogaim_init()
255	{
256	extern void msn_initmodule();
257	extern void oscar_initmodule();
258	extern void jabber_initmodule();
259	extern void twitter_initmodule();
260	extern void purple_initmodule();
261	extern void rpc_initmodule();
262
263	#ifdef WITH_MSN
264	msn_initmodule();
265	#endif
266
267	#ifdef WITH_OSCAR
268	oscar_initmodule();
269	#endif
270
271	#ifdef WITH_JABBER
272	jabber_initmodule();
273	#endif
274
275	#ifdef WITH_TWITTER
276	twitter_initmodule();
277	#endif
278
279	#ifdef WITH_PURPLE
280	purple_initmodule();
281	#endif
282
283	#ifdef WITH_RPC
284	rpc_initmodule();
285	#endif
286
287	#ifdef WITH_PLUGINS
288	load_plugins();
289	#endif
290	}
291
292	GList *get_protocols()
293	{
294	return protocols;
295	}
296
297	GList *get_protocols_disabled()
298	{
299	return disabled_protocols;
300	}
301
302	GSList *get_connections()
303	{
304	return connections;
305	}
306
307	struct im_connection imcb_new(account_t acc)
308	{
309	struct im_connection *ic;
310
311	ic = g_new0(struct im_connection, 1);
312
313	ic->bee = acc->bee;
314	ic->acc = acc;
315	acc->ic = ic;
316
317	connections = g_slist_append(connections, ic);
318
319	return(ic);
320	}
321
322	void imc_free(struct im_connection *ic)
323	{
324	account_t *a;
325
326	/* Destroy the pointer to this connection from the account list */
327	for (a = ic->bee->accounts; a; a = a->next) {
328	if (a->ic == ic) {
329	a->ic = NULL;
330	break;
331	}
332	}
333
334	connections = g_slist_remove(connections, ic);
335	g_free(ic);
336	}
337
338	static void serv_got_crap(struct im_connection ic, char format, ...)
339	{
340	va_list params;
341	char *text;
342	account_t *a;
343
344	if (!ic->bee->ui->log) {
345	return;
346	}
347
348	va_start(params, format);
349	text = g_strdup_vprintf(format, params);
350	va_end(params);
351
352	if ((g_strcasecmp(set_getstr(&ic->bee->set, "strip_html"), "always") == 0) \|\|
353	((ic->flags & OPT_DOES_HTML) && set_getbool(&ic->bee->set, "strip_html"))) {
354	strip_html(text);
355	}
356
357	/* Try to find a different connection on the same protocol. */
358	for (a = ic->bee->accounts; a; a = a->next) {
359	if (a->prpl == ic->acc->prpl && a->ic != ic) {
360	break;
361	}
362	}
363
364	/* If we found one, include the screenname in the message. */
365	if (a) {
366	ic->bee->ui->log(ic->bee, ic->acc->tag, text);
367	} else {
368	ic->bee->ui->log(ic->bee, ic->acc->prpl->name, text);
369	}
370
371	g_free(text);
372	}
373
374	void imcb_log(struct im_connection ic, char format, ...)
375	{
376	va_list params;
377	char *text;
378
379	va_start(params, format);
380	text = g_strdup_vprintf(format, params);
381	va_end(params);
382
383	if (ic->flags & OPT_LOGGED_IN) {
384	serv_got_crap(ic, "%s", text);
385	} else {
386	serv_got_crap(ic, "Logging in: %s", text);
387	}
388
389	g_free(text);
390	}
391
392	void imcb_error(struct im_connection ic, char format, ...)
393	{
394	va_list params;
395	char *text;
396
397	va_start(params, format);
398	text = g_strdup_vprintf(format, params);
399	va_end(params);
400
401	if (ic->flags & OPT_LOGGED_IN) {
402	serv_got_crap(ic, "Error: %s", text);
403	} else {
404	serv_got_crap(ic, "Login error: %s", text);
405	}
406
407	g_free(text);
408	}
409
410	static gboolean send_keepalive(gpointer d, gint fd, b_input_condition cond)
411	{
412	struct im_connection *ic = d;
413
414	if ((ic->flags & OPT_PONGS) && !(ic->flags & OPT_PONGED)) {
415	/* This protocol is expected to ack keepalives and hasn't
416	since the last time we were here. */
417	imcb_error(ic, "Connection timeout");
418	imc_logout(ic, TRUE);
419	return FALSE;
420	}
421	ic->flags &= ~OPT_PONGED;
422
423	if (ic->acc->prpl->keepalive) {
424	ic->acc->prpl->keepalive(ic);
425	}
426
427	return TRUE;
428	}
429
430	void start_keepalives(struct im_connection *ic, int interval)
431	{
432	b_event_remove(ic->keepalive);
433	ic->keepalive = b_timeout_add(interval, send_keepalive, ic);
434
435	/* Connecting successfully counts as a first successful pong. */
436	if (ic->flags & OPT_PONGS) {
437	ic->flags \|= OPT_PONGED;
438	}
439	}
440
441	void imcb_connected(struct im_connection *ic)
442	{
443	/* MSN servers sometimes redirect you to a different server and do
444	the whole login sequence again, so these "late" calls to this
445	function should be handled correctly. (IOW, ignored) */
446	if (ic->flags & OPT_LOGGED_IN) {
447	return;
448	}
449
450	if ((ic->acc->flags & ACC_FLAG_LOCAL_CONTACTS) &&
451	!(ic->flags & OPT_LOCAL_CONTACTS_SENT) &&
452	ic->acc->prpl->add_buddy) {
453	GHashTableIter nicks;
454	gpointer handle;
455	g_hash_table_iter_init(&nicks, ic->acc->nicks);
456	while (g_hash_table_iter_next(&nicks, &handle, NULL)) {
457	ic->acc->prpl->add_buddy(ic, (char *) handle, NULL);
458	}
459	}
460
461	imcb_log(ic, "Logged in");
462
463	ic->flags \|= OPT_LOGGED_IN;
464	start_keepalives(ic, 60000);
465
466	/* Necessary to send initial presence status, even if we're not away. */
467	imc_away_send_update(ic);
468
469	/* Apparently we're connected successfully, so reset the
470	exponential backoff timer. */
471	ic->acc->auto_reconnect_delay = 0;
472
473	if (ic->bee->ui->imc_connected) {
474	ic->bee->ui->imc_connected(ic);
475	}
476	}
477
478	gboolean auto_reconnect(gpointer data, gint fd, b_input_condition cond)
479	{
480	account_t *a = data;
481
482	a->reconnect = 0;
483	account_on(a->bee, a);
484
485	return(FALSE); /* Only have to run the timeout once */
486	}
487
488	void cancel_auto_reconnect(account_t *a)
489	{
490	b_event_remove(a->reconnect);
491	a->reconnect = 0;
492	}
493
494	void imc_logout(struct im_connection *ic, int allow_reconnect)
495	{
496	bee_t *bee = ic->bee;
497	account_t *a;
498	GSList *l;
499	int delay;
500
501	/* Nested calls might happen sometimes, this is probably the best
502	place to catch them. */
503	if (ic->flags & OPT_LOGGING_OUT) {
504	return;
505	} else {
506	ic->flags \|= OPT_LOGGING_OUT;
507	}
508
509	if (ic->bee->ui->imc_disconnected) {
510	ic->bee->ui->imc_disconnected(ic);
511	}
512
513	imcb_log(ic, "Signing off..");
514
515	/* TBH I don't remember anymore why I didn't just use ic->acc... */
516	for (a = bee->accounts; a; a = a->next) {
517	if (a->ic == ic) {
518	break;
519	}
520	}
521
522	if (a && !allow_reconnect && !(ic->flags & OPT_LOGGED_IN) &&
523	set_getbool(&a->set, "oauth")) {
524	/* If this account supports OAuth, we're not logged in yet and
525	not allowed to retry, assume there were auth issues. Give a
526	helpful message on what might be necessary to fix this. */
527	imcb_log(ic, "If you're having problems logging in, try re-requesting "
528	"an OAuth token: account %s set password \"\"", a->tag);
529	}
530
531	for (l = bee->users; l; ) {
532	bee_user_t *bu = l->data;
533	GSList *next = l->next;
534
535	if (bu->ic == ic) {
536	bee_user_free(bee, bu);
537	}
538
539	l = next;
540	}
541
542	b_event_remove(ic->keepalive);
543	ic->keepalive = 0;
544	ic->acc->prpl->logout(ic);
545	b_event_remove(ic->inpa);
546
547	g_free(ic->away);
548	ic->away = NULL;
549
550	query_del_by_conn((irc_t *) ic->bee->ui_data, ic);
551
552	/* Throw away groupchats owned by this account. Historically this was only
553	ever done by IM modules which is a bug. But it gives them opportunity
554	to clean up protocol-specific bits as well so keep it that way, just
555	do another cleanup here as a fallback. Don't want to leave any dangling
556	pointers! */
557	while (ic->groupchats) {
558	imcb_chat_free(ic->groupchats->data);
559	}
560
561	if (!a) {
562	/* Uhm... This is very sick. */
563	} else if (allow_reconnect && set_getbool(&bee->set, "auto_reconnect") &&
564	set_getbool(&a->set, "auto_reconnect") &&
565	(delay = account_reconnect_delay(a)) > 0) {
566	imcb_log(ic, "Reconnecting in %d seconds..", delay);
567	a->reconnect = b_timeout_add(delay * 1000, auto_reconnect, a);
568	}
569
570	imc_free(ic);
571	}
572
573	void imcb_ask(struct im_connection ic, char msg, void *data,
574	query_callback doit, query_callback dont)
575	{
576	query_add((irc_t *) ic->bee->ui_data, ic, msg, doit, dont, g_free, data);
577	}
578
579	void imcb_ask_with_free(struct im_connection ic, char msg, void *data,
580	query_callback doit, query_callback dont, query_callback myfree)
581	{
582	query_add((irc_t *) ic->bee->ui_data, ic, msg, doit, dont, myfree, data);
583	}
584
585	void imcb_add_buddy(struct im_connection ic, const char handle, const char *group)
586	{
587	bee_user_t *bu;
588	bee_t *bee = ic->bee;
589	bee_group_t *oldg;
590
591	if (!(bu = bee_user_by_handle(bee, ic, handle))) {
592	bu = bee_user_new(bee, ic, handle, 0);
593	}
594
595	oldg = bu->group;
596	bu->group = bee_group_by_name(bee, group, TRUE);
597
598	if (bee->ui->user_group && bu->group != oldg) {
599	bee->ui->user_group(bee, bu);
600	}
601	}
602
603	void imcb_rename_buddy(struct im_connection ic, const char handle, const char *fullname)
604	{
605	bee_t *bee = ic->bee;
606	bee_user_t *bu = bee_user_by_handle(bee, ic, handle);
607
608	if (!bu \|\| !fullname) {
609	return;
610	}
611
612	if (!bu->fullname \|\| strcmp(bu->fullname, fullname) != 0) {
613	g_free(bu->fullname);
614	bu->fullname = g_strdup(fullname);
615
616	if (bee->ui->user_fullname) {
617	bee->ui->user_fullname(bee, bu);
618	}
619	}
620	}
621
622	void imcb_remove_buddy(struct im_connection ic, const char handle, char *group)
623	{
624	bee_user_free(ic->bee, bee_user_by_handle(ic->bee, ic, handle));
625	}
626
627	/* Implements either imcb_buddy_nick_hint() or imcb_buddy_nick_change() depending on the value of 'change' */
628	static void buddy_nick_hint_or_change(struct im_connection ic, const char handle, const char *nick, gboolean change)
629	{
630	bee_t *bee = ic->bee;
631	bee_user_t *bu = bee_user_by_handle(bee, ic, handle);
632
633	if (!bu \|\| !nick) {
634	return;
635	}
636
637	g_free(bu->nick);
638	bu->nick = g_strdup(nick);
639
640	if (change && bee->ui->user_nick_change) {
641	bee->ui->user_nick_change(bee, bu, nick);
642	} else if (!change && bee->ui->user_nick_hint) {
643	bee->ui->user_nick_hint(bee, bu, nick);
644	}
645	}
646
647	/* Soft variant, for newly created users. Does nothing if it's already online */
648	void imcb_buddy_nick_hint(struct im_connection ic, const char handle, const char *nick)
649	{
650	buddy_nick_hint_or_change(ic, handle, nick, FALSE);
651	}
652
653	/* Hard variant, always changes the nick */
654	void imcb_buddy_nick_change(struct im_connection ic, const char handle, const char *nick)
655	{
656	buddy_nick_hint_or_change(ic, handle, nick, TRUE);
657	}
658
659	/* Returns the local contacts for an IM account (based on assigned nicks).
660	Linked list should be freed, the strings themselves not! So look at it
661	like a GSList<const char*> I guess? Empty list means NULL retval (as
662	always with GSList). */
663	GSList imcb_get_local_contacts(struct im_connection ic)
664	{
665	GHashTableIter nicks;
666	GSList *ret = NULL;
667
668	if (!(ic->acc->flags & ACC_FLAG_LOCAL_CONTACTS)) {
669	/* Only allow protocols that indicate local contact list
670	support to use this function. */
671	return ret;
672	}
673
674	g_hash_table_iter_init(&nicks, ic->acc->nicks);
675	gpointer handle;
676	while (g_hash_table_iter_next(&nicks, &handle, NULL)) {
677	ret = g_slist_prepend(ret, (char *) handle);
678	}
679
680	/* If the protocol asked for the list, assume we won't have to send it
681	anymore in imcb_connected(). */
682	ic->flags \|= OPT_LOCAL_CONTACTS_SENT;
683
684	return ret;
685	}
686
687
688	struct imcb_ask_cb_data {
689	struct im_connection *ic;
690	char *handle;
691	};
692
693	static void imcb_ask_cb_free(void *data)
694	{
695	struct imcb_ask_cb_data *cbd = data;
696
697	g_free(cbd->handle);
698	g_free(cbd);
699	}
700
701	static void imcb_ask_auth_cb_no(void *data)
702	{
703	struct imcb_ask_cb_data *cbd = data;
704
705	cbd->ic->acc->prpl->auth_deny(cbd->ic, cbd->handle);
706
707	imcb_ask_cb_free(cbd);
708	}
709
710	static void imcb_ask_auth_cb_yes(void *data)
711	{
712	struct imcb_ask_cb_data *cbd = data;
713
714	cbd->ic->acc->prpl->auth_allow(cbd->ic, cbd->handle);
715
716	imcb_ask_cb_free(cbd);
717	}
718
719	void imcb_ask_auth(struct im_connection ic, const char handle, const char *realname)
720	{
721	struct imcb_ask_cb_data *data = g_new0(struct imcb_ask_cb_data, 1);
722	char s, realname_ = NULL;
723
724	if (realname != NULL) {
725	realname_ = g_strdup_printf(" (%s)", realname);
726	}
727
728	s = g_strdup_printf("The user %s%s wants to add you to his/her buddy list.",
729	handle, realname_ ? realname_ : "");
730
731	g_free(realname_);
732
733	data->ic = ic;
734	data->handle = g_strdup(handle);
735	query_add((irc_t *) ic->bee->ui_data, ic, s,
736	imcb_ask_auth_cb_yes, imcb_ask_auth_cb_no, imcb_ask_cb_free, data);
737
738	g_free(s);
739	}
740
741	static void imcb_ask_add_cb_yes(void *data)
742	{
743	struct imcb_ask_cb_data *cbd = data;
744
745	if (cbd->ic->acc->prpl->add_buddy) {
746	cbd->ic->acc->prpl->add_buddy(cbd->ic, cbd->handle, NULL);
747	}
748
749	imcb_ask_cb_free(data);
750	}
751
752	void imcb_ask_add(struct im_connection ic, const char handle, const char *realname)
753	{
754	struct imcb_ask_cb_data *data;
755	char *s;
756
757	/* TODO: Make a setting for this! */
758	if (bee_user_by_handle(ic->bee, ic, handle) != NULL) {
759	return;
760	}
761
762	data = g_new0(struct imcb_ask_cb_data, 1);
763
764	s = g_strdup_printf("The user %s is not in your buddy list yet. Do you want to add him/her now?", handle);
765
766	data->ic = ic;
767	data->handle = g_strdup(handle);
768	query_add((irc_t *) ic->bee->ui_data, ic, s,
769	imcb_ask_add_cb_yes, imcb_ask_cb_free, imcb_ask_cb_free, data);
770
771	g_free(s);
772	}
773
774	struct bee_user imcb_buddy_by_handle(struct im_connection ic, const char *handle)
775	{
776	return bee_user_by_handle(ic->bee, ic, handle);
777	}
778
779	/* The plan is to not allow straight calls to prpl functions anymore, but do
780	them all from some wrappers. We'll start to define some down here: */
781
782	int imc_chat_msg(struct groupchat c, char msg, int flags)
783	{
784	char *buf = NULL;
785
786	if ((c->ic->flags & OPT_DOES_HTML) && (g_strncasecmp(msg, "<html>", 6) != 0)) {
787	buf = escape_html(msg);
788	msg = buf;
789	}
790
791	c->ic->acc->prpl->chat_msg(c, msg, flags);
792	g_free(buf);
793
794	return 1;
795	}
796
797	static char imc_away_state_find(GList gcm, char away, char *message);
798
799	int imc_away_send_update(struct im_connection *ic)
800	{
801	char away, msg = NULL;
802
803	if (ic->acc->prpl->away_states == NULL \|\|
804	ic->acc->prpl->set_away == NULL) {
805	return 0;
806	}
807
808	away = set_getstr(&ic->acc->set, "away") ?
809	: set_getstr(&ic->bee->set, "away");
810	if (away && *away) {
811	GList *m = ic->acc->prpl->away_states(ic);
812	if (m == NULL) {
813	return 0;
814	}
815	msg = ic->acc->flags & ACC_FLAG_AWAY_MESSAGE ? away : NULL;
816	away = imc_away_state_find(m, away, &msg) ? :
817	(imc_away_state_find(m, "away", NULL) ? : m->data);
818	} else if (ic->acc->flags & ACC_FLAG_STATUS_MESSAGE) {
819	away = NULL;
820	msg = set_getstr(&ic->acc->set, "status") ?
821	: set_getstr(&ic->bee->set, "status");
822	}
823
824	ic->acc->prpl->set_away(ic, away, msg);
825
826	return 1;
827	}
828
829	static char *imc_away_alias_list[8][5] =
830	{
831	{ "Away from computer", "Away", "Extended away", NULL },
832	{ "NA", "N/A", "Not available", NULL },
833	{ "Busy", "Do not disturb", "DND", "Occupied", NULL },
834	{ "Be right back", "BRB", NULL },
835	{ "On the phone", "Phone", "On phone", NULL },
836	{ "Out to lunch", "Lunch", "Food", NULL },
837	{ "Invisible", "Hidden" },
838	{ NULL }
839	};
840
841	static char imc_away_state_find(GList gcm, char away, char *message)
842	{
843	GList *m;
844	int i, j;
845
846	for (m = gcm; m; m = m->next) {
847	if (g_strncasecmp(m->data, away, strlen(m->data)) == 0) {
848	/* At least the Yahoo! module works better if message
849	contains no data unless it adds something to what
850	we have in state already. */
851	if (message && strlen(m->data) == strlen(away)) {
852	*message = NULL;
853	}
854
855	return m->data;
856	}
857	}
858
859	for (i = 0; *imc_away_alias_list[i]; i++) {
860	int keep_message;
861
862	for (j = 0; imc_away_alias_list[i][j]; j++) {
863	if (g_strncasecmp(away, imc_away_alias_list[i][j], strlen(imc_away_alias_list[i][j])) == 0) {
864	keep_message = strlen(away) != strlen(imc_away_alias_list[i][j]);
865	break;
866	}
867	}
868
869	if (!imc_away_alias_list[i][j]) { /* If we reach the end, this row */
870	continue; /* is not what we want. Next! */
871
872	}
873	/* Now find an entry in this row which exists in gcm */
874	for (j = 0; imc_away_alias_list[i][j]; j++) {
875	for (m = gcm; m; m = m->next) {
876	if (g_strcasecmp(imc_away_alias_list[i][j], m->data) == 0) {
877	if (!keep_message && message) {
878	*message = NULL;
879	}
880
881	return imc_away_alias_list[i][j];
882	}
883	}
884	}
885
886	/* No need to look further, apparently this state doesn't
887	have any good alias for this protocol. */
888	break;
889	}
890
891	return NULL;
892	}
893
894	void imc_add_allow(struct im_connection ic, char handle)
895	{
896	if (g_slist_find_custom(ic->permit, handle, (GCompareFunc) ic->acc->prpl->handle_cmp) == NULL) {
897	ic->permit = g_slist_prepend(ic->permit, g_strdup(handle));
898	}
899
900	ic->acc->prpl->add_permit(ic, handle);
901	}
902
903	void imc_rem_allow(struct im_connection ic, char handle)
904	{
905	GSList *l;
906
907	if ((l = g_slist_find_custom(ic->permit, handle, (GCompareFunc) ic->acc->prpl->handle_cmp))) {
908	g_free(l->data);
909	ic->permit = g_slist_delete_link(ic->permit, l);
910	}
911
912	ic->acc->prpl->rem_permit(ic, handle);
913	}
914
915	void imc_add_block(struct im_connection ic, char handle)
916	{
917	if (g_slist_find_custom(ic->deny, handle, (GCompareFunc) ic->acc->prpl->handle_cmp) == NULL) {
918	ic->deny = g_slist_prepend(ic->deny, g_strdup(handle));
919	}
920
921	ic->acc->prpl->add_deny(ic, handle);
922	}
923
924	void imc_rem_block(struct im_connection ic, char handle)
925	{
926	GSList *l;
927
928	if ((l = g_slist_find_custom(ic->deny, handle, (GCompareFunc) ic->acc->prpl->handle_cmp))) {
929	g_free(l->data);
930	ic->deny = g_slist_delete_link(ic->deny, l);
931	}
932
933	ic->acc->prpl->rem_deny(ic, handle);
934	}
935
936	/* Deprecated: using this function resulted in merging several handles accidentally
937	* Also the irc layer handles this decently nowadays */
938	void imcb_clean_handle(struct im_connection ic, char handle)
939	{
940	}

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

Download in other formats: