Context Navigation

source: protocols/jabber/jabber.c @ 121c978

Last change on this file since 121c978 was b7d3cc34, checked in by Wilmer van der Gaast <wilmer@…>, at 2005-11-06T18:23:18Z
Initial repository (0.99 release tree)
Property mode set to `100644`
File size: 61.1 KB

Rev	Line
[b7d3cc34]	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 their 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
	2444	my_protocol = ret;
	2445	}

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

Download in other formats: