Context Navigation

source: protocols/jabber/jabber.c @ 94281ef

Last change on this file since 94281ef was 5c09a59, checked in by Wilmer van der Gaast <wilmer@…>, at 2005-11-15T23:16:39Z

Got rid of raw ^{B's in source,

Replaced most irc_usermsg() calls in nogaim.c with serv_got_crap(),

Slightly clearer handling of buddy add requests.}

Thanks to timing for the patch.

Property mode set to 100644

File size: 61.1 KB

Line
1	/* -- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -- */
2	/*
3	* gaim
4	*
5	* Some code copyright (C) 1998-1999, Mark Spencer <markster@marko.net>
6	* libfaim code copyright 1998, 1999 Adam Fritzler <afritz@auk.cx>
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
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21	*
22	*/
23
24	#ifdef HAVE_CONFIG_H
25	#include "config.h"
26	#endif
27
28	#ifndef _WIN32
29	#include <sys/utsname.h>
30	#endif
31	#include <errno.h>
32	#include <string.h>
33	#include <stdlib.h>
34	#include <stdio.h>
35	#include <time.h>
36	#include <sys/stat.h>
37	#include "jabber.h"
38	#include "nogaim.h"
39	#include "bitlbee.h"
40	#include "proxy.h"
41	#include "ssl_client.h"
42
43	/* The priv member of gjconn's is a gaim_connection for now. */
44	#define GJ_GC(x) ((struct gaim_connection *)(x)->priv)
45
46	#define IQID_AUTH "__AUTH__"
47
48	#define IQ_NONE -1
49	#define IQ_AUTH 0
50	#define IQ_ROSTER 1
51
52	#define UC_AWAY (0x02 \| UC_UNAVAILABLE)
53	#define UC_CHAT 0x04
54	#define UC_XA (0x08 \| UC_UNAVAILABLE)
55	#define UC_DND (0x10 \| UC_UNAVAILABLE)
56
57	#define DEFAULT_SERVER "jabber.org"
58	#define DEFAULT_GROUPCHAT "conference.jabber.org"
59	#define DEFAULT_PORT 5222
60	#define DEFAULT_PORT_SSL 5223
61
62	#define JABBER_GROUP "Friends"
63
64	/* i18n disabled - Bitlbee */
65	#define N_(String) String
66
67	/*
68	* Note: "was_connected" may seem redundant, but it was needed and I
69	* didn't want to touch the Jabber state stuff not specific to Gaim.
70	*/
71	typedef struct gjconn_struct {
72	/* Core structure */
73	pool p; /* Memory allocation pool */
74	int state; /* Connection state flag */
75	int was_connected; /* We were once connected */
76	int fd; /* Connection file descriptor */
77	void ssl; / SSL connection */
78	jid user; /* User info */
79	char pass; / User passwd */
80
81	/* Stream stuff */
82	int id; /* id counter for jab_getid() function */
83	char idbuf[9]; /* temporary storage for jab_getid() */
84	char sid; / stream id from server, for digest auth */
85	XML_Parser parser; /* Parser instance */
86	xmlnode current; /* Current node in parsing instance.. */
87
88	/* Event callback ptrs */
89	void (on_state)(struct gjconn_struct gjc, int state);
90	void (on_packet)(struct gjconn_struct gjc, jpacket p);
91
92	GHashTable queries; / query tracker */
93
94	void *priv;
95	} *gjconn, gjconn_struct;
96
97	typedef void (*gjconn_state_h)(gjconn gjc, int state);
98	typedef void (*gjconn_packet_h)(gjconn gjc, jpacket p);
99
100	static gjconn gjab_new(char user, char pass, void *priv);
101	static void gjab_delete(gjconn gjc);
102	static void gjab_state_handler(gjconn gjc, gjconn_state_h h);
103	static void gjab_packet_handler(gjconn gjc, gjconn_packet_h h);
104	static void gjab_start(gjconn gjc);
105	static void gjab_stop(gjconn gjc);
106	/*
107	static int gjab_getfd(gjconn gjc);
108	static jid gjab_getjid(gjconn gjc);
109	static char *gjab_getsid(gjconn gjc);
110	*/
111	static char *gjab_getid(gjconn gjc);
112	static void gjab_send(gjconn gjc, xmlnode x);
113	static void gjab_send_raw(gjconn gjc, const char *str);
114	static void gjab_recv(gjconn gjc);
115	static void gjab_auth(gjconn gjc);
116
117	/*
118	* It is this to which we point the gaim_connection proto_data
119	*/
120	struct jabber_data {
121	gjconn gjc;
122	gboolean did_import;
123	GSList *chats;
124	GHashTable *hash;
125	time_t idle;
126	gboolean die;
127	};
128
129	/*
130	* Jabber "chat group" info. Pointers to these go in jabber_data
131	* pending and existing chats lists.
132	*/
133	struct jabber_chat {
134	jid Jid;
135	struct gaim_connection *gc;
136	struct conversation *b;
137	int id;
138	int state;
139	};
140
141	/*
142	* Jabber chat states...
143	*
144	* Note: due to a bug in one version of the Jabber server, subscriptions
145	* to chat groups aren't (always?) properly removed at the server. The
146	* result is clients receive Jabber "presence" notifications for JIDs
147	* they no longer care about. The problem with such vestigial notifies is
148	* that we really have no way of telling if it's vestigial or if it's a
149	* valid "buddy" presence notification. So we keep jabber_chat structs
150	* around after leaving a chat group and simply mark them "closed." That
151	* way we can test for such errant presence notifications. I.e.: if we
152	* get a presence notfication from a JID that matches a chat group JID,
153	* we disregard it.
154	*/
155	#define JCS_PENDING 1 /* pending */
156	#define JCS_ACTIVE 2 /* active */
157	#define JCS_CLOSED 3 /* closed */
158
159
160	static char *jabber_name()
161	{
162	return "Jabber";
163	}
164
165	#define STATE_EVT(arg) if(gjc->on_state) { (gjc->on_state)(gjc, (arg) ); }
166
167	static void jabber_remove_buddy(struct gaim_connection gc, char name, char *group);
168	static void jabber_handlevcard(gjconn gjc, xmlnode querynode, char *from);
169
170	static char create_valid_jid(const char given, char server, char resource)
171	{
172	char *valid;
173
174	if (!strchr(given, '@'))
175	valid = g_strdup_printf("%s@%s/%s", given, server, resource);
176	else if (!strchr(strchr(given, '@'), '/'))
177	valid = g_strdup_printf("%s/%s", given, resource);
178	else
179	valid = g_strdup(given);
180
181	return valid;
182	}
183
184	static gjconn gjab_new(char user, char pass, void *priv)
185	{
186	pool p;
187	gjconn gjc;
188
189	if (!user)
190	return (NULL);
191
192	p = pool_new();
193	if (!p)
194	return (NULL);
195	gjc = pmalloc_x(p, sizeof(gjconn_struct), 0);
196	if (!gjc) {
197	pool_free(p); /* no need for this anymore! */
198	return (NULL);
199	}
200	gjc->p = p;
201
202	if((gjc->user = jid_new(p, user)) == NULL) {
203	pool_free(p); /* no need for this anymore! */
204	return (NULL);
205	}
206	gjc->pass = pstrdup(p, pass);
207
208	gjc->state = JCONN_STATE_OFF;
209	gjc->was_connected = 0;
210	gjc->id = 1;
211	gjc->fd = -1;
212
213	gjc->priv = priv;
214
215	return gjc;
216	}
217
218	static void gjab_delete(gjconn gjc)
219	{
220	if (!gjc)
221	return;
222
223	gjab_stop(gjc);
224	pool_free(gjc->p);
225	}
226
227	static void gjab_state_handler(gjconn gjc, gjconn_state_h h)
228	{
229	if (!gjc)
230	return;
231
232	gjc->on_state = h;
233	}
234
235	static void gjab_packet_handler(gjconn gjc, gjconn_packet_h h)
236	{
237	if (!gjc)
238	return;
239
240	gjc->on_packet = h;
241	}
242
243	static void gjab_stop(gjconn gjc)
244	{
245	if (!gjc \|\| gjc->state == JCONN_STATE_OFF)
246	return;
247
248	gjab_send_raw(gjc, "</stream:stream>");
249	gjc->state = JCONN_STATE_OFF;
250	gjc->was_connected = 0;
251	if (gjc->ssl) {
252	ssl_disconnect(gjc->ssl);
253	gjc->ssl = NULL;
254	} else {
255	closesocket(gjc->fd);
256	}
257	gjc->fd = -1;
258	XML_ParserFree(gjc->parser);
259	gjc->parser = NULL;
260	}
261
262	/*
263	static int gjab_getfd(gjconn gjc)
264	{
265	if (gjc)
266	return gjc->fd;
267	else
268	return -1;
269	}
270
271	static jid gjab_getjid(gjconn gjc)
272	{
273	if (gjc)
274	return (gjc->user);
275	else
276	return NULL;
277	}
278
279	static char *gjab_getsid(gjconn gjc)
280	{
281	if (gjc)
282	return (gjc->sid);
283	else
284	return NULL;
285	}
286	*/
287
288	static char *gjab_getid(gjconn gjc)
289	{
290	g_snprintf(gjc->idbuf, 8, "%d", gjc->id++);
291	return &gjc->idbuf[0];
292	}
293
294	static void gjab_send(gjconn gjc, xmlnode x)
295	{
296	if (gjc && gjc->state != JCONN_STATE_OFF) {
297	char *buf = xmlnode2str(x);
298	if (!buf)
299	return;
300	else if (gjc->ssl)
301	ssl_write(gjc->ssl, buf, strlen(buf));
302	else
303	write(gjc->fd, buf, strlen(buf));
304	}
305	}
306
307	static void gjab_send_raw(gjconn gjc, const char *str)
308	{
309	if (gjc && gjc->state != JCONN_STATE_OFF) {
310	int len;
311
312	/*
313	* JFIXME: No error detection?!?!
314	*/
315	if (gjc->ssl)
316	len = ssl_write(gjc->ssl, str, strlen(str));
317	else
318	len = write(gjc->fd, str, strlen(str));
319
320	if(len < 0) {
321	/* Do NOT write to stdout/stderr directly, IRC clients
322	might get confused, and we don't want that...
323	fprintf(stderr, "DBG: Problem sending. Error: %d\n", errno);
324	fflush(stderr); */
325	}
326	}
327	}
328
329	static void gjab_reqroster(gjconn gjc)
330	{
331	xmlnode x;
332
333	x = jutil_iqnew(JPACKET__GET, NS_ROSTER);
334	xmlnode_put_attrib(x, "id", gjab_getid(gjc));
335
336	gjab_send(gjc, x);
337	xmlnode_free(x);
338	}
339
340	static void gjab_reqauth(gjconn gjc)
341	{
342	xmlnode x, y, z;
343	char *user;
344
345	if (!gjc)
346	return;
347
348	x = jutil_iqnew(JPACKET__GET, NS_AUTH);
349	xmlnode_put_attrib(x, "id", IQID_AUTH);
350	y = xmlnode_get_tag(x, "query");
351
352	user = gjc->user->user;
353
354	if (user) {
355	z = xmlnode_insert_tag(y, "username");
356	xmlnode_insert_cdata(z, user, -1);
357	}
358
359	gjab_send(gjc, x);
360	xmlnode_free(x);
361	}
362
363	static void gjab_auth(gjconn gjc)
364	{
365	xmlnode x, y, z;
366	char hash, user;
367
368	if (!gjc)
369	return;
370
371	x = jutil_iqnew(JPACKET__SET, NS_AUTH);
372	xmlnode_put_attrib(x, "id", IQID_AUTH);
373	y = xmlnode_get_tag(x, "query");
374
375	user = gjc->user->user;
376
377	if (user) {
378	z = xmlnode_insert_tag(y, "username");
379	xmlnode_insert_cdata(z, user, -1);
380	}
381
382	z = xmlnode_insert_tag(y, "resource");
383	xmlnode_insert_cdata(z, gjc->user->resource, -1);
384
385	if (gjc->sid) {
386	z = xmlnode_insert_tag(y, "digest");
387	hash = pmalloc(x->p, strlen(gjc->sid) + strlen(gjc->pass) + 1);
388	strcpy(hash, gjc->sid);
389	strcat(hash, gjc->pass);
390	hash = shahash(hash);
391	xmlnode_insert_cdata(z, hash, 40);
392	} else {
393	z = xmlnode_insert_tag(y, "password");
394	xmlnode_insert_cdata(z, gjc->pass, -1);
395	}
396
397	gjab_send(gjc, x);
398	xmlnode_free(x);
399
400	return;
401	}
402
403	static void gjab_recv(gjconn gjc)
404	{
405	static char buf[4096];
406	int len;
407
408	if (!gjc \|\| gjc->state == JCONN_STATE_OFF)
409	return;
410
411	if (gjc->ssl)
412	len = ssl_read(gjc->ssl, buf, sizeof(buf) - 1);
413	else
414	len = read(gjc->fd, buf, sizeof(buf) - 1);
415
416	if (len > 0) {
417	struct jabber_data *jd = GJ_GC(gjc)->proto_data;
418	buf[len] = '\0';
419	XML_Parse(gjc->parser, buf, len, 0);
420	if (jd->die)
421	signoff(GJ_GC(gjc));
422	} else if (len < 0 \|\| errno != EAGAIN) {
423	STATE_EVT(JCONN_STATE_OFF)
424	}
425	}
426
427	static void startElement(void userdata, const char name, const char **attribs)
428	{
429	xmlnode x;
430	gjconn gjc = (gjconn) userdata;
431
432	if (gjc->current) {
433	/* Append the node to the current one */
434	x = xmlnode_insert_tag(gjc->current, name);
435	xmlnode_put_expat_attribs(x, attribs);
436
437	gjc->current = x;
438	} else {
439	x = xmlnode_new_tag(name);
440	xmlnode_put_expat_attribs(x, attribs);
441	if (strcmp(name, "stream:stream") == 0) {
442	/* special case: name == stream:stream */
443	/* id attrib of stream is stored for digest auth */
444	gjc->sid = g_strdup(xmlnode_get_attrib(x, "id"));
445	/* STATE_EVT(JCONN_STATE_AUTH) */
446	xmlnode_free(x);
447	} else {
448	gjc->current = x;
449	}
450	}
451	}
452
453	static void endElement(void userdata, const char name)
454	{
455	gjconn gjc = (gjconn) userdata;
456	xmlnode x;
457	jpacket p;
458
459	if (gjc->current == NULL) {
460	/* we got </stream:stream> */
461	STATE_EVT(JCONN_STATE_OFF)
462	return;
463	}
464
465	x = xmlnode_get_parent(gjc->current);
466
467	if (!x) {
468	/* it is time to fire the event */
469	p = jpacket_new(gjc->current);
470
471	if (gjc->on_packet)
472	(gjc->on_packet) (gjc, p);
473	else
474	xmlnode_free(gjc->current);
475	}
476
477	gjc->current = x;
478	}
479
480	static void jabber_callback(gpointer data, gint source, GaimInputCondition condition)
481	{
482	struct gaim_connection gc = (struct gaim_connection )data;
483	struct jabber_data jd = (struct jabber_data )gc->proto_data;
484
485	gjab_recv(jd->gjc);
486	}
487
488	static void charData(void userdata, const char s, int slen)
489	{
490	gjconn gjc = (gjconn) userdata;
491
492	if (gjc->current)
493	xmlnode_insert_cdata(gjc->current, s, slen);
494	}
495
496	static void gjab_connected(gpointer data, gint source, GaimInputCondition cond)
497	{
498	xmlnode x;
499	char t, t2;
500	struct gaim_connection *gc = data;
501	struct jabber_data *jd;
502	gjconn gjc;
503
504	if (!g_slist_find(get_connections(), gc)) {
505	closesocket(source);
506	return;
507	}
508
509	jd = gc->proto_data;
510	gjc = jd->gjc;
511
512	if (gjc->fd != source)
513	gjc->fd = source;
514
515	if (source == -1) {
516	STATE_EVT(JCONN_STATE_OFF)
517	return;
518	}
519
520	gjc->state = JCONN_STATE_CONNECTED;
521	STATE_EVT(JCONN_STATE_CONNECTED)
522
523	/* start stream */
524	x = jutil_header(NS_CLIENT, gjc->user->server);
525	t = xmlnode2str(x);
526	/* this is ugly, we can create the string here instead of jutil_header */
527	/* what do you think about it? -madcat */
528	t2 = strstr(t, "/>");
529	*t2++ = '>';
530	*t2 = '\0';
531	gjab_send_raw(gjc, "<?xml version='1.0'?>");
532	gjab_send_raw(gjc, t);
533	xmlnode_free(x);
534
535	gjc->state = JCONN_STATE_ON;
536	STATE_EVT(JCONN_STATE_ON);
537
538	gc = GJ_GC(gjc);
539	gc->inpa = gaim_input_add(gjc->fd, GAIM_INPUT_READ, jabber_callback, gc);
540	}
541
542	static void gjab_connected_ssl(gpointer data, void *source, GaimInputCondition cond)
543	{
544	struct gaim_connection *gc = data;
545	struct jabber_data *jd;
546	gjconn gjc;
547
548	if (!g_slist_find(get_connections(), gc)) {
549	ssl_disconnect(source);
550	return;
551	}
552
553	jd = gc->proto_data;
554	gjc = jd->gjc;
555
556	if (source == NULL) {
557	STATE_EVT(JCONN_STATE_OFF)
558	return;
559	}
560
561	gjab_connected(data, gjc->fd, cond);
562	}
563
564	static void gjab_start(gjconn gjc)
565	{
566	struct aim_user *user;
567	int port = -1, ssl = 0;
568	char server = NULL, s;
569
570	if (!gjc \|\| gjc->state != JCONN_STATE_OFF)
571	return;
572
573	user = GJ_GC(gjc)->user;
574	if (*user->proto_opt[0]) {
575	/* If there's a dot, assume there's a hostname in the beginning */
576	if (strchr(user->proto_opt[0], '.')) {
577	server = g_strdup(user->proto_opt[0]);
578	if ((s = strchr(server, ':')))
579	*s = 0;
580	}
581
582	/* After the hostname, there can be a port number */
583	s = strchr(user->proto_opt[0], ':');
584	if (s && isdigit(s[1]))
585	sscanf(s + 1, "%d", &port);
586
587	/* And if there's the string ssl, the user wants an SSL-connection */
588	if (strstr(user->proto_opt[0], ":ssl") \|\| g_strcasecmp(user->proto_opt[0], "ssl") == 0)
589	ssl = 1;
590	}
591
592	if (port == -1 && !ssl)
593	port = DEFAULT_PORT;
594	else if (port == -1 && ssl)
595	port = DEFAULT_PORT_SSL;
596
597	if (server == NULL)
598	server = g_strdup(gjc->user->server);
599
600	gjc->parser = XML_ParserCreate(NULL);
601	XML_SetUserData(gjc->parser, (void *)gjc);
602	XML_SetElementHandler(gjc->parser, startElement, endElement);
603	XML_SetCharacterDataHandler(gjc->parser, charData);
604
605	if (ssl) {
606	if ((gjc->ssl = ssl_connect(server, port, gjab_connected_ssl, GJ_GC(gjc))))
607	gjc->fd = ssl_getfd(gjc->ssl);
608	else
609	gjc->fd = -1;
610	} else {
611	gjc->fd = proxy_connect(server, port, gjab_connected, GJ_GC(gjc));
612	}
613
614	g_free(server);
615
616	if (!user->gc \|\| (gjc->fd < 0)) {
617	STATE_EVT(JCONN_STATE_OFF)
618	return;
619	}
620	}
621
622	/*
623	* Find existing/active Jabber chat
624	*/
625	static struct jabber_chat find_existing_chat(struct gaim_connection gc, jid chat)
626	{
627	GSList jcs = ((struct jabber_data )gc->proto_data)->chats;
628	struct jabber_chat *jc = NULL;
629
630	while (jcs) {
631	jc = jcs->data;
632	if (jc->state == JCS_ACTIVE && !jid_cmpx(chat, jc->Jid, JID_USER \| JID_SERVER))
633	break;
634	jc = NULL;
635	jcs = jcs->next;
636	}
637
638	return jc;
639	}
640
641	/*
642	* Find pending chat
643	*/
644	static struct jabber_chat find_pending_chat(struct gaim_connection gc, jid chat)
645	{
646	GSList jcs = ((struct jabber_data )gc->proto_data)->chats;
647	struct jabber_chat *jc = NULL;
648
649	while (jcs) {
650	jc = jcs->data;
651	if (jc->state == JCS_PENDING && !jid_cmpx(chat, jc->Jid, JID_USER \| JID_SERVER))
652	break;
653	jc = NULL;
654	jcs = jcs->next;
655	}
656
657	return jc;
658	}
659
660	static gboolean find_chat_buddy(struct conversation b, char name)
661	{
662	GList *m = b->in_room;
663
664	while (m) {
665	if (!strcmp(m->data, name))
666	return TRUE;
667	m = m->next;
668	}
669
670	return FALSE;
671	}
672
673	/*
674	* Remove a buddy from the (gaim) buddylist (if he's on it)
675	*/
676	static void jabber_remove_gaim_buddy(struct gaim_connection gc, char buddyname)
677	{
678	struct buddy *b;
679
680	if ((b = find_buddy(gc, buddyname)) != NULL) {
681	/* struct group *group;
682
683	group = find_group_by_buddy(gc, buddyname);
684	remove_buddy(gc, group, b); */
685	jabber_remove_buddy(gc, b->name, JABBER_GROUP);
686	}
687	}
688
689	/*
690	* keep track of away msg same as yahoo plugin
691	*/
692	static void jabber_track_away(gjconn gjc, jpacket p, char name, char type)
693	{
694	struct jabber_data *jd = GJ_GC(gjc)->proto_data;
695	gpointer val = g_hash_table_lookup(jd->hash, name);
696	char *show;
697	char *vshow = NULL;
698	char *status = NULL;
699	char *msg = NULL;
700
701	if (type && (g_strcasecmp(type, "unavailable") == 0)) {
702	vshow = _("Unavailable");
703	} else {
704	if((show = xmlnode_get_tag_data(p->x, "show")) != NULL) {
705	if (!g_strcasecmp(show, "away")) {
706	vshow = _("Away");
707	} else if (!g_strcasecmp(show, "chat")) {
708	vshow = _("Online");
709	} else if (!g_strcasecmp(show, "xa")) {
710	vshow = _("Extended Away");
711	} else if (!g_strcasecmp(show, "dnd")) {
712	vshow = _("Do Not Disturb");
713	}
714	}
715	}
716
717	status = xmlnode_get_tag_data(p->x, "status");
718
719	if(vshow != NULL \|\| status != NULL ) {
720	/* kinda hokey, but it works :-) */
721	msg = g_strdup_printf("%s%s%s",
722	(vshow == NULL? "" : vshow),
723	(vshow == NULL \|\| status == NULL? "" : ": "),
724	(status == NULL? "" : status));
725	} else {
726	msg = g_strdup(_("Online"));
727	}
728
729	if (val) {
730	g_free(val);
731	g_hash_table_insert(jd->hash, name, msg);
732	} else {
733	g_hash_table_insert(jd->hash, g_strdup(name), msg);
734	}
735	}
736
737	static time_t iso8601_to_time(char *timestamp)
738	{
739	struct tm t;
740	time_t retval = 0;
741
742	if(sscanf(timestamp,"%04d%02d%02dT%02d:%02d:%02d",
743	&t.tm_year, &t.tm_mon, &t.tm_mday, &t.tm_hour, &t.tm_min, &t.tm_sec))
744	{
745	t.tm_year -= 1900;
746	t.tm_mon -= 1;
747	t.tm_isdst = 0;
748	retval = mktime(&t);
749	# ifdef HAVE_TM_GMTOFF
750	retval += t.tm_gmtoff;
751	# else
752	# ifdef HAVE_TIMEZONE
753	tzset(); /* making sure */
754	retval -= timezone;
755	# endif
756	# endif
757	}
758
759	return retval;
760	}
761
762	static void jabber_handlemessage(gjconn gjc, jpacket p)
763	{
764	xmlnode y, xmlns, subj, z;
765	time_t time_sent = time(NULL);
766
767	char from = NULL, msg = NULL, type = NULL, topic = NULL;
768	char m[BUF_LONG * 2];
769
770	type = xmlnode_get_attrib(p->x, "type");
771
772	z = xmlnode_get_firstchild(p->x);
773
774	while(z)
775	{
776	if(NSCHECK(z,NS_DELAY))
777	{
778	char *timestamp = xmlnode_get_attrib(z,"stamp");
779	time_sent = iso8601_to_time(timestamp);
780	}
781	z = xmlnode_get_nextsibling(z);
782	}
783
784	if (!type \|\| !g_strcasecmp(type, "normal") \|\| !g_strcasecmp(type, "chat")) {
785
786	/* XXX namespaces could be handled better. (mid) */
787	if ((xmlns = xmlnode_get_tag(p->x, "x")))
788	type = xmlnode_get_attrib(xmlns, "xmlns");
789
790	from = jid_full(p->from);
791	/*
792	if ((y = xmlnode_get_tag(p->x, "html"))) {
793	msg = xmlnode_get_data(y);
794	} else
795	*/
796	if ((y = xmlnode_get_tag(p->x, "body"))) {
797	msg = xmlnode_get_data(y);
798	}
799
800
801	if (!from)
802	return;
803
804	if (type && !g_strcasecmp(type, "jabber:x:conference")) {
805	char *room;
806	GList *m = NULL;
807	char **data;
808
809	room = xmlnode_get_attrib(xmlns, "jid");
810	data = g_strsplit(room, "@", 2);
811	m = g_list_append(m, g_strdup(data[0]));
812	m = g_list_append(m, g_strdup(data[1]));
813	m = g_list_append(m, g_strdup(gjc->user->user));
814	g_strfreev(data);
815
816	/* Bitlbee serv_got_chat_invite(GJ_GC(gjc), room, from, msg, m); */
817	} else if (msg) { /* whisper */
818	struct jabber_chat *jc;
819	g_snprintf(m, sizeof(m), "%s", msg);
820	if (((jc = find_existing_chat(GJ_GC(gjc), p->from)) != NULL) && jc->b)
821	serv_got_chat_in(GJ_GC(gjc), jc->b->id, p->from->resource, 1, m, time_sent);
822	else {
823	int flags = 0;
824	/* Bitlbee
825	if (xmlnode_get_tag(p->x, "gaim"))
826	flags = IM_FLAG_GAIMUSER;
827	if (find_conversation(jid_full(p->from)))
828	serv_got_im(GJ_GC(gjc), jid_full(p->from), m, flags, time_sent, -1);
829	else {
830	End - Bitlbee */
831	if(p->from->user) {
832	from = g_strdup_printf("%s@%s", p->from->user, p->from->server);
833	} else {
834	/* server message? */
835	from = g_strdup(p->from->server);
836	}
837	serv_got_im(GJ_GC(gjc), from, m, flags, time_sent, -1);
838	g_free(from);
839	/* Bitlbee } End - Bitlbee */
840	}
841	}
842
843	} else if (!g_strcasecmp(type, "error")) {
844	if ((y = xmlnode_get_tag(p->x, "error"))) {
845	type = xmlnode_get_attrib(y, "code");
846	msg = xmlnode_get_data(y);
847	}
848
849	if (msg) {
850	from = g_strdup_printf("Error %s", type ? type : "");
851	do_error_dialog(GJ_GC(gjc), msg, from);
852	g_free(from);
853	}
854	} else if (!g_strcasecmp(type, "groupchat")) {
855	struct jabber_chat *jc;
856	static int i = 0;
857
858	/*
859	if ((y = xmlnode_get_tag(p->x, "html"))) {
860	msg = xmlnode_get_data(y);
861	} else
862	*/
863	if ((y = xmlnode_get_tag(p->x, "body"))) {
864	msg = xmlnode_get_data(y);
865	}
866
867	msg = utf8_to_str(msg);
868
869	if ((subj = xmlnode_get_tag(p->x, "subject"))) {
870	topic = xmlnode_get_data(subj);
871	}
872	topic = utf8_to_str(topic);
873
874	jc = find_existing_chat(GJ_GC(gjc), p->from);
875	if (!jc) {
876	/* we're not in this chat. are we supposed to be? */
877	if ((jc = find_pending_chat(GJ_GC(gjc), p->from)) != NULL) {
878	/* yes, we're supposed to be. so now we are. */
879	jc->b = serv_got_joined_chat(GJ_GC(gjc), i++, p->from->user);
880	jc->id = jc->b->id;
881	jc->state = JCS_ACTIVE;
882	} else {
883	/* no, we're not supposed to be. */
884	g_free(msg);
885	return;
886	}
887	}
888	if (p->from->resource) {
889	if (!y) {
890	if (!find_chat_buddy(jc->b, p->from->resource)) {
891	add_chat_buddy(jc->b, p->from->resource);
892	} else if ((y = xmlnode_get_tag(p->x, "status"))) {
893	char *buf;
894
895	buf = g_strdup_printf("%s@%s/%s",
896	p->from->user, p->from->server, p->from->resource);
897	jabber_track_away(gjc, p, buf, NULL);
898	g_free(buf);
899
900	}
901	} else if (jc->b && msg) {
902	char buf[8192];
903
904	if (topic) {
905	char tbuf[8192];
906	g_snprintf(tbuf, sizeof(tbuf), "%s", topic);
907	}
908
909
910	g_snprintf(buf, sizeof(buf), "%s", msg);
911	serv_got_chat_in(GJ_GC(gjc), jc->b->id, p->from->resource, 0, buf, time_sent);
912	}
913	} else { /* message from the server */
914	if(jc->b && topic) {
915	char tbuf[8192];
916	g_snprintf(tbuf, sizeof(tbuf), "%s", topic);
917	}
918	}
919
920	g_free(msg);
921	g_free(topic);
922
923	}
924	}
925
926	static void jabber_handlepresence(gjconn gjc, jpacket p)
927	{
928	char to, from, *type;
929	struct buddy *b = NULL;
930	jid who;
931	char *buddy;
932	xmlnode y;
933	char *show;
934	int state = 0;
935	GSList *resources;
936	char *res;
937	struct conversation *cnv = NULL;
938	struct jabber_chat *jc = NULL;
939
940	to = xmlnode_get_attrib(p->x, "to");
941	from = xmlnode_get_attrib(p->x, "from");
942	type = xmlnode_get_attrib(p->x, "type");
943
944	if (type && g_strcasecmp(type, "error") == 0) {
945	return;
946	}
947	else if ((y = xmlnode_get_tag(p->x, "show"))) {
948	show = xmlnode_get_data(y);
949	if (!show) {
950	state = 0;
951	} else if (!g_strcasecmp(show, "away")) {
952	state = UC_AWAY;
953	} else if (!g_strcasecmp(show, "chat")) {
954	state = UC_CHAT;
955	} else if (!g_strcasecmp(show, "xa")) {
956	state = UC_XA;
957	} else if (!g_strcasecmp(show, "dnd")) {
958	state = UC_DND;
959	}
960	} else {
961	state = 0;
962	}
963
964	who = jid_new(gjc->p, from);
965	if (who->user == NULL) {
966	/* FIXME: transport */
967	return;
968	}
969
970	buddy = g_strdup_printf("%s@%s", who->user, who->server);
971
972	/* um. we're going to check if it's a chat. if it isn't, and there are pending
973	* chats, create the chat. if there aren't pending chats and we don't have the
974	* buddy on our list, simply bail out. */
975	if ((cnv = NULL) == NULL) {
976	static int i = 0x70;
977	if ((jc = find_pending_chat(GJ_GC(gjc), who)) != NULL) {
978	jc->b = cnv = serv_got_joined_chat(GJ_GC(gjc), i++, who->user);
979	jc->id = jc->b->id;
980	jc->state = JCS_ACTIVE;
981	} else if ((b = find_buddy(GJ_GC(gjc), buddy)) == NULL) {
982	g_free(buddy);
983	return;
984	}
985	}
986
987	if (!cnv) {
988	resources = b->proto_data;
989	res = who->resource;
990	if (res)
991	while (resources) {
992	if (!strcmp(res, resources->data))
993	break;
994	resources = resources->next;
995	}
996
997	/* keep track of away msg same as yahoo plugin */
998	jabber_track_away(gjc, p, normalize(b->name), type);
999
1000	if (type && (g_strcasecmp(type, "unavailable") == 0)) {
1001	if (resources) {
1002	g_free(resources->data);
1003	b->proto_data = g_slist_remove(b->proto_data, resources->data);
1004	}
1005	if (!b->proto_data) {
1006	serv_got_update(GJ_GC(gjc), buddy, 0, 0, 0, 0, 0, 0);
1007	}
1008	} else {
1009	if (!resources) {
1010	b->proto_data = g_slist_append(b->proto_data, g_strdup(res));
1011	}
1012
1013	serv_got_update(GJ_GC(gjc), buddy, 1, 0, b->signon, b->idle, state, 0);
1014
1015	}
1016	} else {
1017	if (who->resource) {
1018	char *buf;
1019
1020	buf = g_strdup_printf("%s@%s/%s", who->user, who->server, who->resource);
1021	jabber_track_away(gjc, p, buf, type);
1022	g_free(buf);
1023
1024	if (type && !g_strcasecmp(type, "unavailable")) {
1025	struct jabber_data *jd;
1026	if (!jc && !(jc = find_existing_chat(GJ_GC(gjc), who))) {
1027	g_free(buddy);
1028	return;
1029	}
1030	jd = jc->gc->proto_data;
1031	/* if it's not ourselves...*/
1032	if (strcmp(who->resource, jc->Jid->resource) && jc->b) {
1033	remove_chat_buddy(jc->b, who->resource, NULL);
1034	g_free(buddy);
1035	return;
1036	}
1037
1038	jc->state = JCS_CLOSED;
1039	serv_got_chat_left(GJ_GC(gjc), jc->id);
1040	/*
1041	* TBD: put back some day?
1042	jd->chats = g_slist_remove(jd->chats, jc);
1043	g_free(jc);
1044	*/
1045	} else {
1046	if ((!jc && !(jc = find_existing_chat(GJ_GC(gjc), who))) \|\| !jc->b) {
1047	g_free(buddy);
1048	return;
1049	}
1050	if (!find_chat_buddy(jc->b, who->resource)) {
1051	add_chat_buddy(jc->b, who->resource);
1052	}
1053	}
1054	}
1055	}
1056
1057	g_free(buddy);
1058
1059	return;
1060	}
1061
1062	/*
1063	* Used only by Jabber accept/deny add stuff just below
1064	*/
1065	struct jabber_add_permit {
1066	gjconn gjc;
1067	gchar *user;
1068	};
1069
1070	/*
1071	* Common part for Jabber accept/deny adds
1072	*
1073	* "type" says whether we'll permit/deny the subscribe request
1074	*/
1075	static void jabber_accept_deny_add(struct jabber_add_permit jap, const char type)
1076	{
1077	xmlnode g = xmlnode_new_tag("presence");
1078
1079	xmlnode_put_attrib(g, "to", jap->user);
1080	xmlnode_put_attrib(g, "type", type);
1081	gjab_send(jap->gjc, g);
1082
1083	xmlnode_free(g);
1084	}
1085
1086	/*
1087	* Callback from "accept" in do_ask_dialog() invoked by jabber_handles10n()
1088	*/
1089	static void jabber_accept_add(gpointer w, struct jabber_add_permit *jap)
1090	{
1091	jabber_accept_deny_add(jap, "subscribed");
1092	/*
1093	* If we don't already have the buddy on our buddylist,
1094	* ask if we want him or her added.
1095	*/
1096	if(find_buddy(GJ_GC(jap->gjc), jap->user) == NULL) {
1097	show_got_added(GJ_GC(jap->gjc), NULL, jap->user, NULL, NULL);
1098	}
1099	g_free(jap->user);
1100	g_free(jap);
1101	}
1102
1103	/*
1104	* Callback from "deny/cancel" in do_ask_dialog() invoked by jabber_handles10n()
1105	*/
1106	static void jabber_deny_add(gpointer w, struct jabber_add_permit *jap)
1107	{
1108	jabber_accept_deny_add(jap, "unsubscribed");
1109	g_free(jap->user);
1110	g_free(jap);
1111	}
1112
1113	/*
1114	* Handle subscription requests
1115	*/
1116	static void jabber_handles10n(gjconn gjc, jpacket p)
1117	{
1118	xmlnode g;
1119	char *Jid = xmlnode_get_attrib(p->x, "from");
1120	char *type = xmlnode_get_attrib(p->x, "type");
1121
1122	g = xmlnode_new_tag("presence");
1123	xmlnode_put_attrib(g, "to", Jid);
1124
1125	if (!strcmp(type, "subscribe")) {
1126	/*
1127	* A "subscribe to us" request was received - put up the approval dialog
1128	*/
1129	struct jabber_add_permit *jap = g_new0(struct jabber_add_permit, 1);
1130	gchar *msg = g_strdup_printf(_("The user %s wants to add you to his/her buddy list."),
1131	Jid);
1132
1133	jap->gjc = gjc;
1134	jap->user = g_strdup(Jid);
1135	do_ask_dialog(GJ_GC(gjc), msg, jap, jabber_accept_add, jabber_deny_add);
1136
1137	g_free(msg);
1138	xmlnode_free(g); /* Never needed it here anyway */
1139	return;
1140
1141	} else if (!strcmp(type, "unsubscribe")) {
1142	/*
1143	* An "unsubscribe to us" was received - simply "approve" it
1144	*/
1145	xmlnode_put_attrib(g, "type", "unsubscribed");
1146	} else {
1147	/*
1148	* Did we attempt to subscribe to somebody and they do not exist?
1149	*/
1150	if (!strcmp(type, "unsubscribed")) {
1151	xmlnode y;
1152	char *status;
1153	if((y = xmlnode_get_tag(p->x, "status")) && (status = xmlnode_get_data(y)) &&
1154	!strcmp(status, "Not Found")) {
1155	char *msg = g_strdup_printf("%s: \"%s\"", _("No such user"),
1156	xmlnode_get_attrib(p->x, "from"));
1157	do_error_dialog(GJ_GC(gjc), msg, _("Jabber Error"));
1158	g_free(msg);
1159	}
1160	}
1161
1162	xmlnode_free(g);
1163	return;
1164	}
1165
1166	gjab_send(gjc, g);
1167	xmlnode_free(g);
1168	}
1169
1170	/*
1171	* Pending subscription to a buddy?
1172	*/
1173	#define BUD_SUB_TO_PEND(sub, ask) ((!g_strcasecmp((sub), "none") \|\| !g_strcasecmp((sub), "from")) && \
1174	(ask) != NULL && !g_strcasecmp((ask), "subscribe"))
1175
1176	/*
1177	* Subscribed to a buddy?
1178	*/
1179	#define BUD_SUBD_TO(sub, ask) ((!g_strcasecmp((sub), "to") \|\| !g_strcasecmp((sub), "both")) && \
1180	((ask) == NULL \|\| !g_strcasecmp((ask), "subscribe")))
1181
1182	/*
1183	* Pending unsubscription to a buddy?
1184	*/
1185	#define BUD_USUB_TO_PEND(sub, ask) ((!g_strcasecmp((sub), "to") \|\| !g_strcasecmp((sub), "both")) && \
1186	(ask) != NULL && !g_strcasecmp((ask), "unsubscribe"))
1187
1188	/*
1189	* Unsubscribed to a buddy?
1190	*/
1191	#define BUD_USUBD_TO(sub, ask) ((!g_strcasecmp((sub), "none") \|\| !g_strcasecmp((sub), "from")) && \
1192	((ask) == NULL \|\| !g_strcasecmp((ask), "unsubscribe")))
1193
1194	/*
1195	* If a buddy is added or removed from the roster on another resource
1196	* jabber_handlebuddy is called
1197	*
1198	* Called with roster item node.
1199	*/
1200	static void jabber_handlebuddy(gjconn gjc, xmlnode x)
1201	{
1202	xmlnode g;
1203	char Jid, name, sub, ask;
1204	jid who;
1205	struct buddy *b = NULL;
1206	char buddyname, groupname = NULL;
1207
1208	Jid = xmlnode_get_attrib(x, "jid");
1209	name = xmlnode_get_attrib(x, "name");
1210	sub = xmlnode_get_attrib(x, "subscription");
1211	ask = xmlnode_get_attrib(x, "ask");
1212	who = jid_new(gjc->p, Jid);
1213
1214	/* JFIXME: jabber_handleroster() had a "FIXME: transport" at this
1215	* equivilent point. So...
1216	*
1217	* We haven't allocated any memory or done anything interesting to
1218	* this point, so we'll violate Good Coding Structure here by
1219	* simply bailing out.
1220	*/
1221	if (!who \|\| !who->user) {
1222	return;
1223	}
1224
1225	buddyname = g_strdup_printf("%s@%s", who->user, who->server);
1226
1227	if((g = xmlnode_get_tag(x, "group")) != NULL) {
1228	groupname = xmlnode_get_data(g);
1229	}
1230
1231	/*
1232	* Add or remove a buddy? Change buddy's alias or group?
1233	*/
1234	if (BUD_SUB_TO_PEND(sub, ask) \|\| BUD_SUBD_TO(sub, ask)) {
1235	if ((b = find_buddy(GJ_GC(gjc), buddyname)) == NULL) {
1236	add_buddy(GJ_GC(gjc), groupname ? groupname : _("Buddies"), buddyname,
1237	name ? name : buddyname);
1238	} else {
1239	/* struct group c_grp = find_group_by_buddy(GJ_GC(gjc), buddyname); /
1240
1241	/*
1242	* If the buddy's in a new group or his/her alias is changed...
1243	*/
1244	if(groupname) {
1245	int present = b->present; /* save presence state */
1246	int uc = b->uc; /* and away state (?) */
1247	int idle = b->idle;
1248	int signon = b->signon;
1249
1250	/*
1251	* seems rude, but it seems to be the only way...
1252	*/
1253	/* remove_buddy(GJ_GC(gjc), c_grp, b); */
1254	jabber_remove_buddy(GJ_GC(gjc), b->name, JABBER_GROUP);
1255
1256	add_buddy(GJ_GC(gjc), groupname, buddyname,
1257	name ? name : buddyname);
1258	if(present) {
1259	serv_got_update(GJ_GC(gjc), buddyname, 1, 0, signon, idle, uc, 0);
1260	}
1261	} else if(name != NULL && strcmp(b->show, name)) {
1262	strncpy(b->show, name, BUDDY_ALIAS_MAXLEN);
1263	b->show[BUDDY_ALIAS_MAXLEN - 1] = '\0'; /* cheap safety feature */
1264	serv_buddy_rename(GJ_GC(gjc), buddyname, b->show);
1265	}
1266	}
1267	} else if (BUD_USUB_TO_PEND(sub, ask) \|\| BUD_USUBD_TO(sub, ask) \|\| !g_strcasecmp(sub, "remove")) {
1268	jabber_remove_gaim_buddy(GJ_GC(gjc), buddyname);
1269	}
1270	g_free(buddyname);
1271
1272	}
1273
1274	static void jabber_handleroster(gjconn gjc, xmlnode querynode)
1275	{
1276	xmlnode x;
1277
1278	x = xmlnode_get_firstchild(querynode);
1279	while (x) {
1280	jabber_handlebuddy(gjc, x);
1281	x = xmlnode_get_nextsibling(x);
1282	}
1283
1284	x = jutil_presnew(0, NULL, "Online");
1285	gjab_send(gjc, x);
1286	xmlnode_free(x);
1287	}
1288
1289	static void jabber_handleauthresp(gjconn gjc, jpacket p)
1290	{
1291	if (jpacket_subtype(p) == JPACKET__RESULT) {
1292	if (xmlnode_has_children(p->x)) {
1293	xmlnode query = xmlnode_get_tag(p->x, "query");
1294	set_login_progress(GJ_GC(gjc), 4, _("Authenticating"));
1295	if (!xmlnode_get_tag(query, "digest")) {
1296	g_free(gjc->sid);
1297	gjc->sid = NULL;
1298	}
1299	gjab_auth(gjc);
1300	} else {
1301	account_online(GJ_GC(gjc));
1302
1303	if (bud_list_cache_exists(GJ_GC(gjc)))
1304	do_import(GJ_GC(gjc), NULL);
1305
1306	((struct jabber_data *)GJ_GC(gjc)->proto_data)->did_import = TRUE;
1307
1308	gjab_reqroster(gjc);
1309	}
1310	} else {
1311	xmlnode xerr;
1312	char *errmsg = NULL;
1313	int errcode = 0;
1314	struct jabber_data *jd = GJ_GC(gjc)->proto_data;
1315
1316	xerr = xmlnode_get_tag(p->x, "error");
1317	if (xerr) {
1318	char msg[BUF_LONG];
1319	errmsg = xmlnode_get_data(xerr);
1320	if (xmlnode_get_attrib(xerr, "code")) {
1321	errcode = atoi(xmlnode_get_attrib(xerr, "code"));
1322	g_snprintf(msg, sizeof(msg), "Error %d: %s", errcode, errmsg ? errmsg : "Unknown error");
1323	} else
1324	g_snprintf(msg, sizeof(msg), "%s", errmsg);
1325	hide_login_progress(GJ_GC(gjc), msg);
1326	} else {
1327	hide_login_progress(GJ_GC(gjc), _("Unknown login error"));
1328	}
1329
1330	jd->die = TRUE;
1331	}
1332	}
1333
1334	static void jabber_handleversion(gjconn gjc, xmlnode iqnode) {
1335	xmlnode querynode, x;
1336	char id, from;
1337	char os[1024];
1338	#ifndef _WIN32
1339	struct utsname osinfo;
1340
1341	uname(&osinfo);
1342	g_snprintf(os, sizeof os, "%s %s %s", osinfo.sysname, osinfo.release, osinfo.machine);
1343	#else
1344	g_snprintf(os, sizeof os, "Windows %d %d", _winmajor, _winminor);
1345	#endif
1346
1347
1348	id = xmlnode_get_attrib(iqnode, "id");
1349	from = xmlnode_get_attrib(iqnode, "from");
1350
1351	x = jutil_iqnew(JPACKET__RESULT, NS_VERSION);
1352
1353	xmlnode_put_attrib(x, "to", from);
1354	xmlnode_put_attrib(x, "id", id);
1355	querynode = xmlnode_get_tag(x, "query");
1356	xmlnode_insert_cdata(xmlnode_insert_tag(querynode, "name"), PACKAGE, -1);
1357	xmlnode_insert_cdata(xmlnode_insert_tag(querynode, "version"), BITLBEE_VERSION, -1);
1358	xmlnode_insert_cdata(xmlnode_insert_tag(querynode, "os"), os, -1);
1359
1360	gjab_send(gjc, x);
1361
1362	xmlnode_free(x);
1363	}
1364
1365	static void jabber_handletime(gjconn gjc, xmlnode iqnode) {
1366	xmlnode querynode, x;
1367	char id, from;
1368	time_t now_t;
1369	struct tm *now;
1370	char buf[1024];
1371
1372	time(&now_t);
1373	now = localtime(&now_t);
1374
1375	id = xmlnode_get_attrib(iqnode, "id");
1376	from = xmlnode_get_attrib(iqnode, "from");
1377
1378	x = jutil_iqnew(JPACKET__RESULT, NS_TIME);
1379
1380	xmlnode_put_attrib(x, "to", from);
1381	xmlnode_put_attrib(x, "id", id);
1382	querynode = xmlnode_get_tag(x, "query");
1383
1384	strftime(buf, 1024, "%Y%m%dT%T", now);
1385	xmlnode_insert_cdata(xmlnode_insert_tag(querynode, "utc"), buf, -1);
1386	strftime(buf, 1024, "%Z", now);
1387	xmlnode_insert_cdata(xmlnode_insert_tag(querynode, "tz"), buf, -1);
1388	strftime(buf, 1024, "%d %b %Y %T", now);
1389	xmlnode_insert_cdata(xmlnode_insert_tag(querynode, "display"), buf, -1);
1390
1391	gjab_send(gjc, x);
1392
1393	xmlnode_free(x);
1394	}
1395
1396	static void jabber_handlelast(gjconn gjc, xmlnode iqnode) {
1397	xmlnode x, querytag;
1398	char id, from;
1399	struct jabber_data *jd = GJ_GC(gjc)->proto_data;
1400	char idle_time[32];
1401
1402	id = xmlnode_get_attrib(iqnode, "id");
1403	from = xmlnode_get_attrib(iqnode, "from");
1404
1405	x = jutil_iqnew(JPACKET__RESULT, "jabber:iq:last");
1406
1407	xmlnode_put_attrib(x, "to", from);
1408	xmlnode_put_attrib(x, "id", id);
1409	querytag = xmlnode_get_tag(x, "query");
1410	g_snprintf(idle_time, sizeof idle_time, "%ld", jd->idle ? time(NULL) - jd->idle : 0);
1411	xmlnode_put_attrib(querytag, "seconds", idle_time);
1412
1413	gjab_send(gjc, x);
1414	xmlnode_free(x);
1415	}
1416
1417	/*
1418	* delete == TRUE: delete found entry
1419	*
1420	* returns pointer to (local) copy of value if found, NULL otherwise
1421	*
1422	* Note: non-reentrant! Local static storage re-used on subsequent calls.
1423	* If you're going to need to keep the returned value, make a copy!
1424	*/
1425	static gchar jabber_track_queries(GHashTable queries, gchar *key, gboolean delete)
1426	{
1427	gpointer my_key, my_val;
1428	static gchar *ret_val = NULL;
1429
1430	if(ret_val != NULL) {
1431	g_free(ret_val);
1432	ret_val = NULL;
1433	}
1434
1435	/* self-protection */
1436	if(queries != NULL && key != NULL) {
1437	if(g_hash_table_lookup_extended(queries, key, &my_key, &my_val)) {
1438	ret_val = g_strdup((gchar *) my_val);
1439	if(delete) {
1440	g_hash_table_remove(queries, key);
1441	g_free(my_key);
1442	g_free(my_val);
1443	}
1444	}
1445	}
1446
1447	return(ret_val);
1448	}
1449
1450	static void jabber_handlepacket(gjconn gjc, jpacket p)
1451	{
1452	char *id;
1453	switch (p->type) {
1454	case JPACKET_MESSAGE:
1455	jabber_handlemessage(gjc, p);
1456	break;
1457	case JPACKET_PRESENCE:
1458	jabber_handlepresence(gjc, p);
1459	break;
1460	case JPACKET_IQ:
1461	id = xmlnode_get_attrib(p->x, "id");
1462	if (id != NULL && !strcmp(id, IQID_AUTH)) {
1463	jabber_handleauthresp(gjc, p);
1464	break;
1465	}
1466
1467	if (jpacket_subtype(p) == JPACKET__SET) {
1468	xmlnode querynode;
1469	querynode = xmlnode_get_tag(p->x, "query");
1470	if (NSCHECK(querynode, "jabber:iq:roster")) {
1471	jabber_handlebuddy(gjc, xmlnode_get_firstchild(querynode));
1472	}
1473	} else if (jpacket_subtype(p) == JPACKET__GET) {
1474	xmlnode querynode;
1475	querynode = xmlnode_get_tag(p->x, "query");
1476	if (NSCHECK(querynode, NS_VERSION)) {
1477	jabber_handleversion(gjc, p->x);
1478	} else if (NSCHECK(querynode, NS_TIME)) {
1479	jabber_handletime(gjc, p->x);
1480	} else if (NSCHECK(querynode, "jabber:iq:last")) {
1481	jabber_handlelast(gjc, p->x);
1482	}
1483	} else if (jpacket_subtype(p) == JPACKET__RESULT) {
1484	xmlnode querynode, vcard;
1485	/* char xmlns; /
1486	char *from;
1487
1488	/*
1489	* TBD: ISTM maybe this part could use a serious re-work?
1490	*/
1491	from = xmlnode_get_attrib(p->x, "from");
1492	querynode = xmlnode_get_tag(p->x, "query");
1493	vcard = xmlnode_get_tag(p->x, "vCard");
1494	if (!vcard)
1495	vcard = xmlnode_get_tag(p->x, "VCARD");
1496
1497	if (NSCHECK(querynode, NS_ROSTER)) {
1498	jabber_handleroster(gjc, querynode);
1499	} else if (NSCHECK(querynode, NS_VCARD)) {
1500	jabber_track_queries(gjc->queries, id, TRUE); /* delete query track */
1501	jabber_handlevcard(gjc, querynode, from);
1502	} else if (vcard) {
1503	jabber_track_queries(gjc->queries, id, TRUE); /* delete query track */
1504	jabber_handlevcard(gjc, vcard, from);
1505	} else {
1506	char *val;
1507
1508	/* handle "null" query results */
1509	if((val = jabber_track_queries(gjc->queries, id, TRUE)) != NULL) {
1510	if (!g_strncasecmp(val, "vcard", 5)) {
1511	jabber_handlevcard(gjc, NULL, from);
1512	}
1513
1514	/* No-op */
1515	}
1516	}
1517
1518	} else if (jpacket_subtype(p) == JPACKET__ERROR) {
1519	xmlnode xerr;
1520	char from, errmsg = NULL;
1521	int errcode = 0;
1522
1523	from = xmlnode_get_attrib(p->x, "from");
1524	xerr = xmlnode_get_tag(p->x, "error");
1525	if (xerr) {
1526	errmsg = xmlnode_get_data(xerr);
1527	if (xmlnode_get_attrib(xerr, "code"))
1528	errcode = atoi(xmlnode_get_attrib(xerr, "code"));
1529	}
1530
1531	from = g_strdup_printf("Error %d (%s)", errcode, from);
1532	do_error_dialog(GJ_GC(gjc), errmsg, from);
1533	g_free(from);
1534
1535	}
1536
1537	break;
1538	case JPACKET_S10N:
1539	jabber_handles10n(gjc, p);
1540	break;
1541	}
1542
1543	xmlnode_free(p->x);
1544
1545	return;
1546	}
1547
1548	static void jabber_handlestate(gjconn gjc, int state)
1549	{
1550	switch (state) {
1551	case JCONN_STATE_OFF:
1552	if(gjc->was_connected) {
1553	hide_login_progress_error(GJ_GC(gjc), _("Connection lost"));
1554	} else {
1555	hide_login_progress(GJ_GC(gjc), _("Unable to connect"));
1556	}
1557	signoff(GJ_GC(gjc));
1558	break;
1559	case JCONN_STATE_CONNECTED:
1560	gjc->was_connected = 1;
1561	set_login_progress(GJ_GC(gjc), 2, _("Connected"));
1562	break;
1563	case JCONN_STATE_ON:
1564	set_login_progress(GJ_GC(gjc), 3, _("Requesting Authentication Method"));
1565	gjab_reqauth(gjc);
1566	break;
1567	}
1568	return;
1569	}
1570
1571	static void jabber_login(struct aim_user *user)
1572	{
1573	struct gaim_connection *gc = new_gaim_conn(user);
1574	struct jabber_data *jd = gc->proto_data = g_new0(struct jabber_data, 1);
1575	char *loginname = create_valid_jid(user->username, DEFAULT_SERVER, "BitlBee");
1576
1577	jd->hash = g_hash_table_new(g_str_hash, g_str_equal);
1578	jd->chats = NULL; /* we have no chats yet */
1579
1580	set_login_progress(gc, 1, _("Connecting"));
1581
1582	if (!(jd->gjc = gjab_new(loginname, user->password, gc))) {
1583	g_free(loginname);
1584	hide_login_progress(gc, _("Unable to connect"));
1585	signoff(gc);
1586	return;
1587	}
1588
1589	g_free(loginname);
1590	gjab_state_handler(jd->gjc, jabber_handlestate);
1591	gjab_packet_handler(jd->gjc, jabber_handlepacket);
1592	jd->gjc->queries = g_hash_table_new(g_str_hash, g_str_equal);
1593	gjab_start(jd->gjc);
1594	}
1595
1596	static gboolean jabber_destroy_hash(gpointer key, gpointer val, gpointer data) {
1597	g_free(key);
1598	g_free(val);
1599	return TRUE;
1600	}
1601
1602	static gboolean jabber_free(gpointer data)
1603	{
1604	struct jabber_data *jd = data;
1605
1606	if(jd->gjc != NULL) {
1607	gjab_delete(jd->gjc);
1608	g_free(jd->gjc->sid);
1609	jd->gjc = NULL;
1610	}
1611	g_free(jd);
1612
1613	return FALSE;
1614	}
1615
1616	static void jabber_close(struct gaim_connection *gc)
1617	{
1618	struct jabber_data *jd = gc->proto_data;
1619
1620	if(jd) {
1621	GSList *jcs = jd->chats;
1622
1623	/* Free-up the jabber_chat struct allocs and the list */
1624	while (jcs) {
1625	g_free(jcs->data);
1626	jcs = jcs->next;
1627	}
1628	g_slist_free(jd->chats);
1629
1630	/* Free-up the away status memories and the list */
1631	if(jd->hash != NULL) {
1632	g_hash_table_foreach_remove(jd->hash, jabber_destroy_hash, NULL);
1633	g_hash_table_destroy(jd->hash);
1634	jd->hash = NULL;
1635	}
1636
1637	/* Free-up the pending queries memories and the list */
1638	if(jd->gjc != NULL && jd->gjc->queries != NULL) {
1639	g_hash_table_foreach_remove(jd->gjc->queries, jabber_destroy_hash, NULL);
1640	g_hash_table_destroy(jd->gjc->queries);
1641	jd->gjc->queries = NULL;
1642	}
1643	}
1644	if (gc->inpa)
1645	gaim_input_remove(gc->inpa);
1646
1647	if(jd) {
1648	g_timeout_add(50, jabber_free, jd);
1649	if(jd->gjc != NULL)
1650	xmlnode_free(jd->gjc->current);
1651	}
1652	gc->proto_data = NULL;
1653	}
1654
1655	static int jabber_send_im(struct gaim_connection gc, char who, char *message, int len, int flags)
1656	{
1657	xmlnode x, y;
1658	char *realwho;
1659	gjconn gjc = ((struct jabber_data *)gc->proto_data)->gjc;
1660
1661	if (!who \|\| !message)
1662	return 0;
1663
1664	x = xmlnode_new_tag("message");
1665	/* Bare username and "username" not the server itself? */
1666	if (!strchr(who, '@') && strcmp(who, gjc->user->server) != 0)
1667	realwho = g_strdup_printf("%s@%s", who, gjc->user->server);
1668	else
1669	realwho = g_strdup(who);
1670	xmlnode_put_attrib(x, "to", realwho);
1671	g_free(realwho);
1672
1673	xmlnode_insert_tag(x, "bitlbee");
1674	xmlnode_put_attrib(x, "type", "chat");
1675
1676	if (message && strlen(message)) {
1677	y = xmlnode_insert_tag(x, "body");
1678	xmlnode_insert_cdata(y, message, -1);
1679	}
1680
1681	gjab_send(((struct jabber_data *)gc->proto_data)->gjc, x);
1682	xmlnode_free(x);
1683	return 1;
1684	}
1685
1686	/*
1687	* Add/update buddy's roster entry on server
1688	*/
1689	static void jabber_roster_update(struct gaim_connection gc, char name)
1690	{
1691	xmlnode x, y;
1692	char *realwho;
1693	gjconn gjc;
1694	struct buddy *buddy = NULL;
1695	/* struct group buddy_group = NULL; /
1696
1697	if(gc && gc->proto_data && ((struct jabber_data *)gc->proto_data)->gjc && name) {
1698	gjc = ((struct jabber_data *)gc->proto_data)->gjc;
1699
1700	if (!strchr(name, '@'))
1701	realwho = g_strdup_printf("%s@%s", name, gjc->user->server);
1702	else {
1703	jid who = jid_new(gjc->p, name);
1704	if (who->user == NULL) {
1705	/* FIXME: transport */
1706	return;
1707	}
1708	realwho = g_strdup_printf("%s@%s", who->user, who->server);
1709	}
1710
1711
1712	x = jutil_iqnew(JPACKET__SET, NS_ROSTER);
1713	y = xmlnode_insert_tag(xmlnode_get_tag(x, "query"), "item");
1714	xmlnode_put_attrib(y, "jid", realwho);
1715
1716
1717	/* If we can find the buddy, there's an alias for him, it's not 0-length
1718	* and it doesn't match his JID, add the "name" attribute.
1719	*/
1720	if((buddy = find_buddy(gc, realwho)) != NULL &&
1721	buddy->show != NULL && buddy->show[0] != '\0' && strcmp(realwho, buddy->show)) {
1722
1723	xmlnode_put_attrib(y, "name", buddy->show);
1724	}
1725
1726	/*
1727	* Find out what group the buddy's in and send that along
1728	* with the roster item.
1729	*/
1730	/* Bitlbee disabled
1731	if((buddy_group = NULL) != NULL) {
1732	xmlnode z;
1733	z = xmlnode_insert_tag(y, "group");
1734	xmlnode_insert_cdata(z, buddy_group->name, -1);
1735	}
1736	End - Bitlbee */
1737
1738	gjab_send(((struct jabber_data *)gc->proto_data)->gjc, x);
1739
1740	xmlnode_free(x);
1741	g_free(realwho);
1742	}
1743	}
1744
1745	/*
1746	* Change buddy's group on server roster
1747	*/
1748	static void jabber_group_change(struct gaim_connection gc, char name, char old_group, char new_group)
1749	{
1750	if(strcmp(old_group, new_group)) {
1751	jabber_roster_update(gc, name);
1752	}
1753	}
1754
1755	static void jabber_add_buddy(struct gaim_connection gc, char name)
1756	{
1757	xmlnode x;
1758	char *realwho;
1759	gjconn gjc = ((struct jabber_data *)gc->proto_data)->gjc;
1760
1761	if (!((struct jabber_data *)gc->proto_data)->did_import)
1762	return;
1763
1764	if (!name)
1765	return;
1766
1767	if (!strcmp(gc->username, name))
1768	return;
1769
1770	if (!strchr(name, '@'))
1771	realwho = g_strdup_printf("%s@%s", name, gjc->user->server);
1772	else {
1773	jid who;
1774
1775	if((who = jid_new(gjc->p, name)) == NULL) {
1776	char *msg = g_strdup_printf("%s: \"%s\"", _("Invalid Jabber I.D."), name);
1777	do_error_dialog(GJ_GC(gjc), msg, _("Jabber Error"));
1778	g_free(msg);
1779	jabber_remove_gaim_buddy(gc, name);
1780	return;
1781	}
1782	if (who->user == NULL) {
1783	/* FIXME: transport */
1784	return;
1785	}
1786	realwho = g_strdup_printf("%s@%s", who->user, who->server);
1787	}
1788
1789	x = xmlnode_new_tag("presence");
1790	xmlnode_put_attrib(x, "to", realwho);
1791	xmlnode_put_attrib(x, "type", "subscribe");
1792	gjab_send(((struct jabber_data *)gc->proto_data)->gjc, x);
1793	xmlnode_free(x);
1794
1795	jabber_roster_update(gc, realwho);
1796
1797	g_free(realwho);
1798	}
1799
1800	static void jabber_remove_buddy(struct gaim_connection gc, char name, char *group)
1801	{
1802	xmlnode x;
1803	char *realwho;
1804	gjconn gjc = ((struct jabber_data *)gc->proto_data)->gjc;
1805
1806	if (!name)
1807	return;
1808
1809	if (!strchr(name, '@'))
1810	realwho = g_strdup_printf("%s@%s", name, gjc->user->server);
1811	else
1812	realwho = g_strdup(name);
1813
1814	x = xmlnode_new_tag("presence");
1815	xmlnode_put_attrib(x, "to", realwho);
1816	xmlnode_put_attrib(x, "type", "unsubscribe");
1817	gjab_send(((struct jabber_data *)gc->proto_data)->gjc, x);
1818	g_free(realwho);
1819	xmlnode_free(x);
1820	}
1821
1822	static void jabber_get_info(struct gaim_connection gc, char who) {
1823	xmlnode x;
1824	char *id;
1825	char *realwho;
1826	struct jabber_data *jd = gc->proto_data;
1827	gjconn gjc = jd->gjc;
1828
1829	x = jutil_iqnew(JPACKET__GET, NS_VCARD);
1830	/* Bare username? */
1831	if (!strchr(who, '@')) {
1832	realwho = g_strdup_printf("%s@%s", who, gjc->user->server);
1833	} else {
1834	realwho = g_strdup(who);
1835	}
1836	xmlnode_put_attrib(x, "to", realwho);
1837	g_free(realwho);
1838
1839	id = gjab_getid(gjc);
1840	xmlnode_put_attrib(x, "id", id);
1841
1842	g_hash_table_insert(jd->gjc->queries, g_strdup(id), g_strdup("vCard"));
1843
1844	gjab_send(gjc, x);
1845
1846	xmlnode_free(x);
1847
1848	}
1849
1850	static void jabber_get_away_msg(struct gaim_connection gc, char who) {
1851	struct jabber_data *jd = gc->proto_data;
1852	gjconn gjc = jd->gjc;
1853	char *status;
1854
1855	/* space for all elements: Jabber I.D. + "status" + NULL (list terminator) */
1856	gchar str_arr = (gchar ) g_new(gpointer, 3);
1857	gchar **ap = str_arr;
1858	gchar realwho, final;
1859
1860	/* Bare username? */
1861	if (!strchr(who, '@')) {
1862	realwho = g_strdup_printf("%s@%s", who, gjc->user->server);
1863	} else {
1864	realwho = g_strdup(who);
1865	}
1866	*ap++ = g_strdup_printf("<B>Jabber ID:</B> %s<BR>\n", realwho);
1867
1868	if((status = g_hash_table_lookup(jd->hash, realwho)) == NULL) {
1869	status = _("Unknown");
1870	}
1871	*ap++ = g_strdup_printf("<B>Status:</B> %s<BR>\n", status);
1872
1873	*ap = NULL;
1874
1875	final= g_strjoinv(NULL, str_arr);
1876	g_strfreev(str_arr);
1877
1878	g_free(realwho);
1879	g_free(final);
1880
1881	}
1882
1883	static GList jabber_away_states(struct gaim_connection gc) {
1884	GList *m = NULL;
1885
1886	m = g_list_append(m, "Online");
1887	m = g_list_append(m, "Chatty");
1888	m = g_list_append(m, "Away");
1889	m = g_list_append(m, "Extended Away");
1890	m = g_list_append(m, "Do Not Disturb");
1891
1892	return m;
1893	}
1894
1895	static void jabber_set_away(struct gaim_connection gc, char state, char *message)
1896	{
1897	xmlnode x, y;
1898	struct jabber_data *jd = gc->proto_data;
1899	gjconn gjc = jd->gjc;
1900
1901	gc->away = NULL; /* never send an auto-response */
1902
1903	x = xmlnode_new_tag("presence");
1904
1905	if (!strcmp(state, GAIM_AWAY_CUSTOM)) {
1906	/* oh goody. Gaim is telling us what to do. */
1907	if (message) {
1908	/* Gaim wants us to be away */
1909	y = xmlnode_insert_tag(x, "show");
1910	xmlnode_insert_cdata(y, "away", -1);
1911	y = xmlnode_insert_tag(x, "status");
1912	{
1913	char *utf8 = str_to_utf8(message);
1914	xmlnode_insert_cdata(y, utf8, -1);
1915	g_free(utf8);
1916	}
1917	gc->away = "";
1918	} else {
1919	/* Gaim wants us to not be away */
1920	/* but for Jabber, we can just send presence with no other information. */
1921	}
1922	} else {
1923	/* state is one of our own strings. it won't be NULL. */
1924	if (!g_strcasecmp(state, "Online")) {
1925	/* once again, we don't have to put anything here */
1926	} else if (!g_strcasecmp(state, "Chatty")) {
1927	y = xmlnode_insert_tag(x, "show");
1928	xmlnode_insert_cdata(y, "chat", -1);
1929	} else if (!g_strcasecmp(state, "Away")) {
1930	y = xmlnode_insert_tag(x, "show");
1931	xmlnode_insert_cdata(y, "away", -1);
1932	gc->away = "";
1933	} else if (!g_strcasecmp(state, "Extended Away")) {
1934	y = xmlnode_insert_tag(x, "show");
1935	xmlnode_insert_cdata(y, "xa", -1);
1936	gc->away = "";
1937	} else if (!g_strcasecmp(state, "Do Not Disturb")) {
1938	y = xmlnode_insert_tag(x, "show");
1939	xmlnode_insert_cdata(y, "dnd", -1);
1940	gc->away = "";
1941	}
1942	}
1943
1944	gjab_send(gjc, x);
1945	xmlnode_free(x);
1946	}
1947
1948	static void jabber_set_idle(struct gaim_connection *gc, int idle) {
1949	struct jabber_data jd = (struct jabber_data )gc->proto_data;
1950	jd->idle = idle ? time(NULL) - idle : idle;
1951	}
1952
1953	static void jabber_keepalive(struct gaim_connection *gc) {
1954	struct jabber_data jd = (struct jabber_data )gc->proto_data;
1955	gjab_send_raw(jd->gjc, " \t ");
1956	}
1957
1958	static void jabber_buddy_free(struct buddy *b)
1959	{
1960	while (b->proto_data) {
1961	g_free(((GSList *)b->proto_data)->data);
1962	b->proto_data = g_slist_remove(b->proto_data, ((GSList *)b->proto_data)->data);
1963	}
1964	}
1965
1966	/---------------------------------------/
1967	/* Jabber "set info" (vCard) support */
1968	/---------------------------------------/
1969
1970	/*
1971	* V-Card format:
1972	*
1973	* <vCard prodid='' version='' xmlns=''>
1974	* <FN></FN>
1975	* <N>
1976	* <FAMILY/>
1977	* <GIVEN/>
1978	* </N>
1979	* <NICKNAME/>
1980	* <URL/>
1981	* <ADR>
1982	* <STREET/>
1983	* <EXTADD/>
1984	* <LOCALITY/>
1985	* <REGION/>
1986	* <PCODE/>
1987	* <COUNTRY/>
1988	* </ADR>
1989	* <TEL/>
1990	* <EMAIL/>
1991	* <ORG>
1992	* <ORGNAME/>
1993	* <ORGUNIT/>
1994	* </ORG>
1995	* <TITLE/>
1996	* <ROLE/>
1997	* <DESC/>
1998	* <BDAY/>
1999	* </vCard>
2000	*
2001	* See also:
2002	*
2003	* http://docs.jabber.org/proto/html/vcard-temp.html
2004	* http://www.vcard-xml.org/dtd/vCard-XML-v2-20010520.dtd
2005	*/
2006
2007	/*
2008	* Cross-reference user-friendly V-Card entry labels to vCard XML tags
2009	* and attributes.
2010	*
2011	* Order is (or should be) unimportant. For example: we have no way of
2012	* knowing in what order real data will arrive.
2013	*
2014	* Format: Label, Pre-set text, "visible" flag, "editable" flag, XML tag
2015	* name, XML tag's parent tag "path" (relative to vCard node).
2016	*
2017	* List is terminated by a NULL label pointer.
2018	*
2019	* Entries with no label text, but with XML tag and parent tag
2020	* entries, are used by V-Card XML construction routines to
2021	* "automagically" construct the appropriate XML node tree.
2022	*
2023	* Thoughts on future direction/expansion
2024	*
2025	* This is a "simple" vCard.
2026	*
2027	* It is possible for nodes other than the "vCard" node to have
2028	* attributes. Should that prove necessary/desirable, add an
2029	* "attributes" pointer to the vcard_template struct, create the
2030	* necessary tag_attr structs, and add 'em to the vcard_dflt_data
2031	* array.
2032	*
2033	* The above changes will (obviously) require changes to the vCard
2034	* construction routines.
2035	*/
2036
2037	static struct vcard_template {
2038	char label; / label text pointer */
2039	char text; / entry text pointer */
2040	int visible; /* should entry field be "visible?" */
2041	int editable; /* should entry field be editable? */
2042	char tag; / tag text */
2043	char ptag; / parent tag "path" text */
2044	char url; / vCard display format if URL */
2045	} vcard_template_data[] = {
2046	{N_("Full Name"), NULL, TRUE, TRUE, "FN", NULL, NULL},
2047	{N_("Family Name"), NULL, TRUE, TRUE, "FAMILY", "N", NULL},
2048	{N_("Given Name"), NULL, TRUE, TRUE, "GIVEN", "N", NULL},
2049	{N_("Nickname"), NULL, TRUE, TRUE, "NICKNAME", NULL, NULL},
2050	{N_("URL"), NULL, TRUE, TRUE, "URL", NULL, "<A HREF=\"%s\">%s</A>"},
2051	{N_("Street Address"), NULL, TRUE, TRUE, "STREET", "ADR", NULL},
2052	{N_("Extended Address"), NULL, TRUE, TRUE, "EXTADD", "ADR", NULL},
2053	{N_("Locality"), NULL, TRUE, TRUE, "LOCALITY", "ADR", NULL},
2054	{N_("Region"), NULL, TRUE, TRUE, "REGION", "ADR", NULL},
2055	{N_("Postal Code"), NULL, TRUE, TRUE, "PCODE", "ADR", NULL},
2056	{N_("Country"), NULL, TRUE, TRUE, "COUNTRY", "ADR", NULL},
2057	{N_("Telephone"), NULL, TRUE, TRUE, "TELEPHONE", NULL, NULL},
2058	{N_("Email"), NULL, TRUE, TRUE, "EMAIL", NULL, "<A HREF=\"mailto:%s\">%s</A>"},
2059	{N_("Organization Name"), NULL, TRUE, TRUE, "ORGNAME", "ORG", NULL},
2060	{N_("Organization Unit"), NULL, TRUE, TRUE, "ORGUNIT", "ORG", NULL},
2061	{N_("Title"), NULL, TRUE, TRUE, "TITLE", NULL, NULL},
2062	{N_("Role"), NULL, TRUE, TRUE, "ROLE", NULL, NULL},
2063	{N_("Birthday"), NULL, TRUE, TRUE, "BDAY", NULL, NULL},
2064	{N_("Description"), NULL, TRUE, TRUE, "DESC", NULL, NULL},
2065	{"", NULL, TRUE, TRUE, "N", NULL, NULL},
2066	{"", NULL, TRUE, TRUE, "ADR", NULL, NULL},
2067	{"", NULL, TRUE, TRUE, "ORG", NULL, NULL},
2068	{NULL, NULL, 0, 0, NULL, NULL, NULL}
2069	};
2070
2071	/*
2072	* Used by routines to parse an XML-encoded string into an xmlnode tree
2073	*/
2074	typedef struct {
2075	XML_Parser parser;
2076	xmlnode current;
2077	} *xmlstr2xmlnode_parser, xmlstr2xmlnode_parser_struct;
2078
2079
2080	/*
2081	* Used by XML_Parse on parsing CDATA
2082	*/
2083	static void xmlstr2xmlnode_charData(void userdata, const char s, int slen)
2084	{
2085	xmlstr2xmlnode_parser xmlp = (xmlstr2xmlnode_parser) userdata;
2086
2087	if (xmlp->current)
2088	xmlnode_insert_cdata(xmlp->current, s, slen);
2089	}
2090
2091	/*
2092	* Used by XML_Parse to start or append to an xmlnode
2093	*/
2094	static void xmlstr2xmlnode_startElement(void userdata, const char name, const char **attribs)
2095	{
2096	xmlnode x;
2097	xmlstr2xmlnode_parser xmlp = (xmlstr2xmlnode_parser) userdata;
2098
2099	if (xmlp->current) {
2100	/* Append the node to the current one */
2101	x = xmlnode_insert_tag(xmlp->current, name);
2102	xmlnode_put_expat_attribs(x, attribs);
2103
2104	xmlp->current = x;
2105	} else {
2106	x = xmlnode_new_tag(name);
2107	xmlnode_put_expat_attribs(x, attribs);
2108	xmlp->current = x;
2109	}
2110	}
2111
2112	/*
2113	* Used by XML_Parse to end an xmlnode
2114	*/
2115	static void xmlstr2xmlnode_endElement(void userdata, const char name)
2116	{
2117	xmlstr2xmlnode_parser xmlp = (xmlstr2xmlnode_parser) userdata;
2118	xmlnode x;
2119
2120	if (xmlp->current != NULL && (x = xmlnode_get_parent(xmlp->current)) != NULL) {
2121	xmlp->current = x;
2122	}
2123	}
2124
2125	/*
2126	* Parse an XML-encoded string into an xmlnode tree
2127	*
2128	* Caller is responsible for freeing the returned xmlnode
2129	*/
2130	static xmlnode xmlstr2xmlnode(char *xmlstring)
2131	{
2132	xmlstr2xmlnode_parser my_parser = g_new(xmlstr2xmlnode_parser_struct, 1);
2133	xmlnode x = NULL;
2134
2135	my_parser->parser = XML_ParserCreate(NULL);
2136	my_parser->current = NULL;
2137
2138	XML_SetUserData(my_parser->parser, (void *)my_parser);
2139	XML_SetElementHandler(my_parser->parser, xmlstr2xmlnode_startElement, xmlstr2xmlnode_endElement);
2140	XML_SetCharacterDataHandler(my_parser->parser, xmlstr2xmlnode_charData);
2141	XML_Parse(my_parser->parser, xmlstring, strlen(xmlstring), 0);
2142
2143	x = my_parser->current;
2144
2145	XML_ParserFree(my_parser->parser);
2146	g_free(my_parser);
2147
2148	return(x);
2149	}
2150
2151	/*
2152	* Insert a tag node into an xmlnode tree, recursively inserting parent tag
2153	* nodes as necessary
2154	*
2155	* Returns pointer to inserted node
2156	*
2157	* Note to hackers: this code is designed to be re-entrant (it's recursive--it
2158	* calls itself), so don't put any "static"s in here!
2159	*/
2160	static xmlnode insert_tag_to_parent_tag(xmlnode start, const char parent_tag, const char new_tag)
2161	{
2162	xmlnode x = NULL;
2163
2164	/*
2165	* If the parent tag wasn't specified, see if we can get it
2166	* from the vCard template struct.
2167	*/
2168	if(parent_tag == NULL) {
2169	struct vcard_template *vc_tp = vcard_template_data;
2170
2171	while(vc_tp->label != NULL) {
2172	if(strcmp(vc_tp->tag, new_tag) == 0) {
2173	parent_tag = vc_tp->ptag;
2174	break;
2175	}
2176	++vc_tp;
2177	}
2178	}
2179
2180	/*
2181	* If we have a parent tag...
2182	*/
2183	if(parent_tag != NULL ) {
2184	/*
2185	* Try to get the parent node for a tag
2186	*/
2187	if((x = xmlnode_get_tag(start, parent_tag)) == NULL) {
2188	/*
2189	* Descend?
2190	*/
2191	char *grand_parent = strcpy(g_malloc(strlen(parent_tag) + 1), parent_tag);
2192	char *parent;
2193
2194	if((parent = strrchr(grand_parent, '/')) != NULL) {
2195	*(parent++) = '\0';
2196	x = insert_tag_to_parent_tag(start, grand_parent, parent);
2197	} else {
2198	x = xmlnode_insert_tag(start, grand_parent);
2199	}
2200	g_free(grand_parent);
2201	} else {
2202	/*
2203	* We found something to be the parent node.
2204	* Note: may be the "root" node!
2205	*/
2206	xmlnode y;
2207	if((y = xmlnode_get_tag(x, new_tag)) != NULL) {
2208	return(y);
2209	}
2210	}
2211	}
2212
2213	/*
2214	* insert the new tag into its parent node
2215	*/
2216	return(xmlnode_insert_tag((x == NULL? start : x), new_tag));
2217	}
2218
2219	/*
2220	* Send vCard info to Jabber server
2221	*/
2222	static void jabber_set_info(struct gaim_connection gc, char info)
2223	{
2224	xmlnode x, vc_node;
2225	char *id;
2226	struct jabber_data *jd = gc->proto_data;
2227	gjconn gjc = jd->gjc;
2228
2229	x = xmlnode_new_tag("iq");
2230	xmlnode_put_attrib(x,"type","set");
2231
2232	id = gjab_getid(gjc);
2233
2234	xmlnode_put_attrib(x, "id", id);
2235
2236	/*
2237	* Send only if there's actually any information to send
2238	*/
2239	if((vc_node = xmlstr2xmlnode(info)) != NULL && xmlnode_get_name(vc_node) != NULL &&
2240	g_strncasecmp(xmlnode_get_name(vc_node), "vcard", 5) == 0) {
2241	xmlnode_insert_tag_node(x, vc_node);
2242	gjab_send(gjc, x);
2243	}
2244
2245	xmlnode_free(x);
2246	}
2247
2248	/*
2249	* displays a Jabber vCard
2250	*/
2251	static void jabber_handlevcard(gjconn gjc, xmlnode querynode, char *from)
2252	{
2253	struct jabber_data *jd = GJ_GC(gjc)->proto_data;
2254	jid who = jid_new(gjc->p, from);
2255	char status = NULL, text = NULL;
2256	GString *str = g_string_sized_new(100);
2257	xmlnode child;
2258
2259	gchar *buddy = NULL;
2260
2261	if(querynode == NULL) {
2262	serv_got_crap(GJ_GC(gjc), "%s - Received empty info reply from %s", _("User Info"), from);
2263	return;
2264	}
2265
2266	if(who->resource != NULL && (who->resource)[0] != '\0') {
2267	buddy = g_strdup_printf("%s@%s/%s", who->user, who->server, who->resource);
2268	} else {
2269	buddy = g_strdup_printf("%s@%s", who->user, who->server);
2270	}
2271
2272	if((status = g_hash_table_lookup(jd->hash, buddy)) == NULL) {
2273	status = _("Unknown");
2274	}
2275
2276	g_string_sprintfa(str, "%s: %s - %s: %s", _("Jabber ID"), buddy, _("Status"),
2277	status);
2278
2279	for(child = querynode->firstchild; child; child = child->next)
2280	{
2281	xmlnode child2;
2282
2283	if(child->type != NTYPE_TAG)
2284	continue;
2285
2286	text = xmlnode_get_data(child);
2287	if(text && !strcmp(child->name, "FN")) {
2288	info_string_append(str, "\n", _("Full Name"), text);
2289	} else if (!strcmp(child->name, "N")) {
2290	for (child2 = child->firstchild; child2; child2 = child2->next) {
2291	char *text2 = NULL;
2292
2293	if (child2->type != NTYPE_TAG)
2294	continue;
2295
2296	text2 = xmlnode_get_data(child2);
2297	if (text2 && !strcmp(child2->name, "FAMILY")) {
2298	info_string_append(str, "\n", _("Family Name"), text2);
2299	} else if (text2 && !strcmp(child2->name, "GIVEN")) {
2300	info_string_append(str, "\n", _("Given Name"), text2);
2301	} else if (text2 && !strcmp(child2->name, "MIDDLE")) {
2302	info_string_append(str, "\n", _("Middle Name"), text2);
2303	}
2304	}
2305	} else if (text && !strcmp(child->name, "NICKNAME")) {
2306	info_string_append(str, "\n", _("Nickname"), text);
2307	} else if (text && !strcmp(child->name, "BDAY")) {
2308	info_string_append(str, "\n", _("Birthday"), text);
2309	} else if (!strcmp(child->name, "ADR")) {
2310	/* show wich address it is */
2311	/* Just for the beauty of bitlbee
2312	if (child->firstchild)
2313	g_string_sprintfa(str, "%s:\n", _("Address"));
2314	*/
2315	for(child2 = child->firstchild; child2; child2 = child2->next) {
2316	char *text2 = NULL;
2317
2318	if(child2->type != NTYPE_TAG)
2319	continue;
2320
2321	text2 = xmlnode_get_data(child2);
2322	if(text2 && !strcmp(child2->name, "POBOX")) {
2323	info_string_append(str, "\n",
2324	_("P.O. Box"), text2);
2325	} else if(text2 && !strcmp(child2->name, "EXTADR")) {
2326	info_string_append(str, "\n",
2327	_("Extended Address"), text2);
2328	} else if(text2 && !strcmp(child2->name, "STREET")) {
2329	info_string_append(str, "\n",
2330	_("Street Address"), text2);
2331	} else if(text2 && !strcmp(child2->name, "LOCALITY")) {
2332	info_string_append(str, "\n",
2333	_("Locality"), text2);
2334	} else if(text2 && !strcmp(child2->name, "REGION")) {
2335	info_string_append(str, "\n",
2336	_("Region"), text2);
2337	} else if(text2 && !strcmp(child2->name, "PCODE")) {
2338	info_string_append(str, "\n",
2339	_("Postal Code"), text2);
2340	} else if(text2 && (!strcmp(child2->name, "CTRY")
2341	\|\| !strcmp(child2->name, "COUNTRY"))) {
2342	info_string_append(str, "\n", _("Country"), text2);
2343	}
2344	}
2345	} else if(!strcmp(child->name, "TEL")) {
2346	char *number = NULL;
2347	if ((child2 = xmlnode_get_tag(child, "NUMBER"))) {
2348	/* show what kind of number it is */
2349	number = xmlnode_get_data(child2);
2350	if(number) {
2351	info_string_append(str, "\n", _("Telephone"), number);
2352	}
2353	} else if((number = xmlnode_get_data(child))) {
2354	/* lots of clients (including gaim) do this,
2355	* but it's out of spec */
2356	info_string_append(str, "\n", _("Telephone"), number);
2357	}
2358	} else if(!strcmp(child->name, "EMAIL")) {
2359	char *userid = NULL;
2360	if((child2 = xmlnode_get_tag(child, "USERID"))) {
2361	/* show what kind of email it is */
2362	userid = xmlnode_get_data(child2);
2363	if(userid) {
2364	info_string_append(str, "\n", _("Email"), userid);
2365	}
2366	} else if((userid = xmlnode_get_data(child))) {
2367	/* lots of clients (including gaim) do this,
2368	* but it's out of spec */
2369	info_string_append(str, "\n", _("Email"), userid);
2370	}
2371	} else if(!strcmp(child->name, "ORG")) {
2372	for(child2 = child->firstchild; child2; child2 = child2->next) {
2373	char *text2 = NULL;
2374
2375	if(child2->type != NTYPE_TAG)
2376	continue;
2377
2378	text2 = xmlnode_get_data(child2);
2379	if(text2 && !strcmp(child2->name, "ORGNAME")) {
2380	info_string_append(str, "\n", _("Organization Name"), text2);
2381	} else if(text2 && !strcmp(child2->name, "ORGUNIT")) {
2382	info_string_append(str, "\n", _("Organization Unit"), text2);
2383	}
2384	}
2385	} else if(text && !strcmp(child->name, "TITLE")) {
2386	info_string_append(str, "\n", _("Title"), text);
2387	} else if(text && !strcmp(child->name, "ROLE")) {
2388	info_string_append(str, "\n", _("Role"), text);
2389	} else if(text && !strcmp(child->name, "DESC")) {
2390	g_string_sprintfa(str, "\n%s:\n%s\n%s", _("Description"),
2391	text, _("End of Description"));
2392	}
2393	}
2394
2395	serv_got_crap(GJ_GC(gjc), "%s\n%s", _("User Info"), str->str);
2396
2397	g_free(buddy);
2398	g_string_free(str, TRUE);
2399	}
2400
2401
2402	static GList *jabber_actions()
2403	{
2404	GList *m = NULL;
2405
2406	m = g_list_append(m, _("Set User Info"));
2407	/*
2408	m = g_list_append(m, _("Set Dir Info"));
2409	m = g_list_append(m, _("Change Password"));
2410	*/
2411
2412	return m;
2413	}
2414
2415	static struct prpl *my_protocol = NULL;
2416
2417	void jabber_init(struct prpl *ret)
2418	{
2419	/* the NULL's aren't required but they're nice to have */
2420	ret->protocol = PROTO_JABBER;
2421	ret->name = jabber_name;
2422	ret->away_states = jabber_away_states;
2423	ret->actions = jabber_actions;
2424	ret->login = jabber_login;
2425	ret->close = jabber_close;
2426	ret->send_im = jabber_send_im;
2427	ret->set_info = jabber_set_info;
2428	ret->get_info = jabber_get_info;
2429	ret->set_away = jabber_set_away;
2430	ret->get_away = jabber_get_away_msg;
2431	ret->set_idle = jabber_set_idle;
2432	ret->add_buddy = jabber_add_buddy;
2433	ret->remove_buddy = jabber_remove_buddy;
2434	ret->add_permit = NULL;
2435	ret->add_deny = NULL;
2436	ret->rem_permit = NULL;
2437	ret->rem_deny = NULL;
2438	ret->set_permit_deny = NULL;
2439	ret->keepalive = jabber_keepalive;
2440	ret->buddy_free = jabber_buddy_free;
2441	ret->alias_buddy = jabber_roster_update;
2442	ret->group_buddy = jabber_group_change;
2443	ret->cmp_buddynames = g_strcasecmp;
2444
2445	my_protocol = ret;
2446	}

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

Download in other formats: