Context Navigation

source: protocols/oscar/oscar.c @ d860a8d

Last change on this file since d860a8d was 81e04e1, checked in by Wilmer van der Gaast <wilmer@…>, at 2010-04-01T02:32:25Z
nogaim.c is close to doing something useful again without speaking any IRC itself.
Property mode set to `100644`
File size: 75.8 KB

Line
1	/*
2	* gaim
3	*
4	* Some code copyright (C) 2002-2006, Jelmer Vernooij <jelmer@samba.org>
5	* and the BitlBee team.
6	* Some code copyright (C) 1998-1999, Mark Spencer <markster@marko.net>
7	* libfaim code copyright 1998, 1999 Adam Fritzler <afritz@auk.cx>
8	*
9	* This program is free software; you can redistribute it and/or modify
10	* it under the terms of the GNU General Public License as published by
11	* the Free Software Foundation; either version 2 of the License, or
12	* (at your option) any later version.
13	*
14	* This program is distributed in the hope that it will be useful,
15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	* GNU General Public License for more details.
18	*
19	* You should have received a copy of the GNU General Public License
20	* along with this program; if not, write to the Free Software
21	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22	*
23	*/
24
25	#include <errno.h>
26	#include <ctype.h>
27	#include <string.h>
28	#include <stdlib.h>
29	#include <stdio.h>
30	#include <time.h>
31	#include <sys/stat.h>
32	#include <glib.h>
33	#include "nogaim.h"
34	#include "bitlbee.h"
35	#include "proxy.h"
36	#include "sock.h"
37
38	#include "aim.h"
39	#include "icq.h"
40	#include "bos.h"
41	#include "ssi.h"
42	#include "im.h"
43	#include "info.h"
44	#include "buddylist.h"
45	#include "chat.h"
46	#include "chatnav.h"
47
48	/* constants to identify proto_opts */
49	#define USEROPT_AUTH 0
50	#define USEROPT_AUTHPORT 1
51
52	#define UC_AOL 0x02
53	#define UC_ADMIN 0x04
54	#define UC_UNCONFIRMED 0x08
55	#define UC_NORMAL 0x10
56	#define UC_AB 0x20
57	#define UC_WIRELESS 0x40
58
59	#define AIMHASHDATA "http://gaim.sourceforge.net/aim_data.php3"
60
61	#define OSCAR_GROUP "Friends"
62
63	#define BUF_LEN 2048
64	#define BUF_LONG ( BUF_LEN * 2 )
65
66	/* Don't know if support for UTF8 is really working. For now it's UTF16 here.
67	static int gaim_caps = AIM_CAPS_UTF8; */
68
69	static int gaim_caps = AIM_CAPS_INTEROP \| AIM_CAPS_ICHAT \| AIM_CAPS_ICQSERVERRELAY \| AIM_CAPS_CHAT;
70	static guint8 gaim_features[] = {0x01, 0x01, 0x01, 0x02};
71
72	struct oscar_data {
73	aim_session_t *sess;
74	aim_conn_t *conn;
75
76	guint cnpa;
77	guint paspa;
78
79	GSList *create_rooms;
80
81	gboolean conf;
82	gboolean reqemail;
83	gboolean setemail;
84	char *email;
85	gboolean setnick;
86	char *newsn;
87	gboolean chpass;
88	char *oldp;
89	char *newp;
90
91	GSList *oscar_chats;
92
93	gboolean killme, no_reconnect;
94	gboolean icq;
95	GSList *evilhack;
96
97	GHashTable *ips;
98
99	struct {
100	guint maxbuddies; /* max users you can watch */
101	guint maxwatchers; /* max users who can watch you */
102	guint maxpermits; /* max users on permit list */
103	guint maxdenies; /* max users on deny list */
104	guint maxsiglen; /* max size (bytes) of profile */
105	guint maxawaymsglen; /* max size (bytes) of posted away message */
106	} rights;
107	};
108
109	struct create_room {
110	char *name;
111	int exchange;
112	};
113
114	struct chat_connection {
115	char *name;
116	char show; / AOL did something funny to us */
117	guint16 exchange;
118	guint16 instance;
119	int fd; /* this is redundant since we have the conn below */
120	aim_conn_t *conn;
121	int inpa;
122	int id;
123	struct im_connection ic; / i hate this. */
124	struct groupchat cnv; / bah. */
125	int maxlen;
126	int maxvis;
127	};
128
129	struct ask_direct {
130	struct im_connection *ic;
131	char *sn;
132	char ip[64];
133	guint8 cookie[8];
134	};
135
136	struct icq_auth {
137	struct im_connection *ic;
138	guint32 uin;
139	};
140
141	static char extract_name(const char name) {
142	char *tmp;
143	int i, j;
144	char *x = strchr(name, '-');
145	if (!x) return g_strdup(name);
146	x = strchr(++x, '-');
147	if (!x) return g_strdup(name);
148	tmp = g_strdup(++x);
149
150	for (i = 0, j = 0; x[i]; i++) {
151	char hex[3];
152	if (x[i] != '%') {
153	tmp[j++] = x[i];
154	continue;
155	}
156	strncpy(hex, x + ++i, 2); hex[2] = 0;
157	i++;
158	tmp[j++] = (char)strtol(hex, NULL, 16);
159	}
160
161	tmp[j] = 0;
162	return tmp;
163	}
164
165	static struct chat_connection find_oscar_chat_by_conn(struct im_connection ic,
166	aim_conn_t *conn) {
167	GSList g = ((struct oscar_data )ic->proto_data)->oscar_chats;
168	struct chat_connection *c = NULL;
169
170	while (g) {
171	c = (struct chat_connection *)g->data;
172	if (c->conn == conn)
173	break;
174	g = g->next;
175	c = NULL;
176	}
177
178	return c;
179	}
180
181	static int gaim_parse_auth_resp (aim_session_t , aim_frame_t , ...);
182	static int gaim_parse_login (aim_session_t , aim_frame_t , ...);
183	static int gaim_parse_logout (aim_session_t , aim_frame_t , ...);
184	static int gaim_handle_redirect (aim_session_t , aim_frame_t , ...);
185	static int gaim_parse_oncoming (aim_session_t , aim_frame_t , ...);
186	static int gaim_parse_offgoing (aim_session_t , aim_frame_t , ...);
187	static int gaim_parse_incoming_im(aim_session_t , aim_frame_t , ...);
188	static int gaim_parse_misses (aim_session_t , aim_frame_t , ...);
189	static int gaim_parse_motd (aim_session_t , aim_frame_t , ...);
190	static int gaim_chatnav_info (aim_session_t , aim_frame_t , ...);
191	static int gaim_chat_join (aim_session_t , aim_frame_t , ...);
192	static int gaim_chat_leave (aim_session_t , aim_frame_t , ...);
193	static int gaim_chat_info_update (aim_session_t , aim_frame_t , ...);
194	static int gaim_chat_incoming_msg(aim_session_t , aim_frame_t , ...);
195	static int gaim_parse_ratechange (aim_session_t , aim_frame_t , ...);
196	static int gaim_bosrights (aim_session_t , aim_frame_t , ...);
197	static int conninitdone_bos (aim_session_t , aim_frame_t , ...);
198	static int conninitdone_admin (aim_session_t , aim_frame_t , ...);
199	static int conninitdone_chat (aim_session_t , aim_frame_t , ...);
200	static int conninitdone_chatnav (aim_session_t , aim_frame_t , ...);
201	static int gaim_parse_msgerr (aim_session_t , aim_frame_t , ...);
202	static int gaim_parse_locaterights(aim_session_t , aim_frame_t , ...);
203	static int gaim_parse_buddyrights(aim_session_t , aim_frame_t , ...);
204	static int gaim_parse_locerr (aim_session_t , aim_frame_t , ...);
205	static int gaim_icbm_param_info (aim_session_t , aim_frame_t , ...);
206	static int gaim_parse_genericerr (aim_session_t , aim_frame_t , ...);
207	static int gaim_memrequest (aim_session_t , aim_frame_t , ...);
208	static int gaim_selfinfo (aim_session_t , aim_frame_t , ...);
209	static int gaim_offlinemsg (aim_session_t , aim_frame_t , ...);
210	static int gaim_offlinemsgdone (aim_session_t , aim_frame_t , ...);
211	static int gaim_ssi_parserights (aim_session_t , aim_frame_t , ...);
212	static int gaim_ssi_parselist (aim_session_t , aim_frame_t , ...);
213	static int gaim_ssi_parseack (aim_session_t , aim_frame_t , ...);
214	static int gaim_parsemtn (aim_session_t , aim_frame_t , ...);
215	static int gaim_icqinfo (aim_session_t , aim_frame_t , ...);
216	static int gaim_parseaiminfo (aim_session_t , aim_frame_t , ...);
217
218	static char *msgerrreason[] = {
219	"Invalid error",
220	"Invalid SNAC",
221	"Rate to host",
222	"Rate to client",
223	"Not logged in",
224	"Service unavailable",
225	"Service not defined",
226	"Obsolete SNAC",
227	"Not supported by host",
228	"Not supported by client",
229	"Refused by client",
230	"Reply too big",
231	"Responses lost",
232	"Request denied",
233	"Busted SNAC payload",
234	"Insufficient rights",
235	"In local permit/deny",
236	"Too evil (sender)",
237	"Too evil (receiver)",
238	"User temporarily unavailable",
239	"No match",
240	"List overflow",
241	"Request ambiguous",
242	"Queue full",
243	"Not while on AOL"
244	};
245	static int msgerrreasonlen = 25;
246
247	/* Hurray, this function is NOT thread-safe \o/ */
248	static char normalize(const char s)
249	{
250	static char buf[BUF_LEN];
251	char t, u;
252	int x = 0;
253
254	g_return_val_if_fail((s != NULL), NULL);
255
256	u = t = g_strdup(s);
257
258	strcpy(t, s);
259	g_strdown(t);
260
261	while (*t && (x < BUF_LEN - 1)) {
262	if (t != ' ' && t != '!') {
263	buf[x] = *t;
264	x++;
265	}
266	t++;
267	}
268	buf[x] = '\0';
269	g_free(u);
270	return buf;
271	}
272
273	static gboolean oscar_callback(gpointer data, gint source,
274	b_input_condition condition) {
275	aim_conn_t conn = (aim_conn_t )data;
276	aim_session_t *sess = aim_conn_getsess(conn);
277	struct im_connection *ic = sess ? sess->aux_data : NULL;
278	struct oscar_data *odata;
279
280	if (!ic) {
281	/* ic is null. we return, else we seg SIGSEG on next line. */
282	return FALSE;
283	}
284
285	if (!g_slist_find(get_connections(), ic)) {
286	/* oh boy. this is probably bad. i guess the only thing we
287	* can really do is return? */
288	return FALSE;
289	}
290
291	odata = (struct oscar_data *)ic->proto_data;
292
293	if (condition & GAIM_INPUT_READ) {
294	if (aim_get_command(odata->sess, conn) >= 0) {
295	aim_rxdispatch(odata->sess);
296	if (odata->killme)
297	imc_logout(ic, !odata->no_reconnect);
298	} else {
299	if ((conn->type == AIM_CONN_TYPE_BOS) \|\|
300	!(aim_getconn_type(odata->sess, AIM_CONN_TYPE_BOS))) {
301	imcb_error(ic, _("Disconnected."));
302	imc_logout(ic, TRUE);
303	} else if (conn->type == AIM_CONN_TYPE_CHAT) {
304	struct chat_connection *c = find_oscar_chat_by_conn(ic, conn);
305	c->conn = NULL;
306	if (c->inpa > 0)
307	b_event_remove(c->inpa);
308	c->inpa = 0;
309	c->fd = -1;
310	aim_conn_kill(odata->sess, &conn);
311	imcb_error(sess->aux_data, _("You have been disconnected from chat room %s."), c->name);
312	} else if (conn->type == AIM_CONN_TYPE_CHATNAV) {
313	if (odata->cnpa > 0)
314	b_event_remove(odata->cnpa);
315	odata->cnpa = 0;
316	while (odata->create_rooms) {
317	struct create_room *cr = odata->create_rooms->data;
318	g_free(cr->name);
319	odata->create_rooms =
320	g_slist_remove(odata->create_rooms, cr);
321	g_free(cr);
322	imcb_error(sess->aux_data, _("Chat is currently unavailable"));
323	}
324	aim_conn_kill(odata->sess, &conn);
325	} else if (conn->type == AIM_CONN_TYPE_AUTH) {
326	if (odata->paspa > 0)
327	b_event_remove(odata->paspa);
328	odata->paspa = 0;
329	aim_conn_kill(odata->sess, &conn);
330	} else {
331	aim_conn_kill(odata->sess, &conn);
332	}
333	}
334	} else {
335	/* WTF??? */
336	return FALSE;
337	}
338
339	return TRUE;
340	}
341
342	static gboolean oscar_login_connect(gpointer data, gint source, b_input_condition cond)
343	{
344	struct im_connection *ic = data;
345	struct oscar_data *odata;
346	aim_session_t *sess;
347	aim_conn_t *conn;
348
349	if (!g_slist_find(get_connections(), ic)) {
350	closesocket(source);
351	return FALSE;
352	}
353
354	odata = ic->proto_data;
355	sess = odata->sess;
356	conn = aim_getconn_type_all(sess, AIM_CONN_TYPE_AUTH);
357
358	if (source < 0) {
359	imcb_error(ic, _("Couldn't connect to host"));
360	imc_logout(ic, TRUE);
361	return FALSE;
362	}
363
364	aim_conn_completeconnect(sess, conn);
365	ic->inpa = b_input_add(conn->fd, GAIM_INPUT_READ,
366	oscar_callback, conn);
367
368	return FALSE;
369	}
370
371	static void oscar_init(account_t *acc)
372	{
373	set_t *s;
374
375	if (isdigit(acc->user[0])) {
376	set_add(&acc->set, "ignore_auth_requests", "false", set_eval_bool, acc);
377	}
378
379	s = set_add(&acc->set, "server", AIM_DEFAULT_LOGIN_SERVER, set_eval_account, acc);
380	s->flags \|= ACC_SET_NOSAVE \| ACC_SET_OFFLINE_ONLY;
381
382	if(isdigit(acc->user[0])) {
383	s = set_add(&acc->set, "web_aware", "false", set_eval_bool, acc);
384	s->flags \|= ACC_SET_OFFLINE_ONLY;
385	}
386
387	acc->flags \|= ACC_FLAG_AWAY_MESSAGE;
388	}
389
390	static void oscar_login(account_t *acc) {
391	aim_session_t *sess;
392	aim_conn_t *conn;
393	struct im_connection *ic = imcb_new(acc);
394	struct oscar_data *odata = ic->proto_data = g_new0(struct oscar_data, 1);
395
396	if (isdigit(acc->user[0]))
397	odata->icq = TRUE;
398	else
399	ic->flags \|= OPT_DOES_HTML;
400
401	sess = g_new0(aim_session_t, 1);
402
403	aim_session_init(sess, AIM_SESS_FLAGS_NONBLOCKCONNECT, 0);
404
405	/* we need an immediate queue because we don't use a while-loop to
406	* see if things need to be sent. */
407	aim_tx_setenqueue(sess, AIM_TX_IMMEDIATE, NULL);
408	odata->sess = sess;
409	sess->aux_data = ic;
410
411	conn = aim_newconn(sess, AIM_CONN_TYPE_AUTH, NULL);
412	if (conn == NULL) {
413	imcb_error(ic, _("Unable to login to AIM"));
414	imc_logout(ic, TRUE);
415	return;
416	}
417
418	imcb_log(ic, _("Signon: %s"), ic->acc->user);
419
420	aim_conn_addhandler(sess, conn, 0x0017, 0x0007, gaim_parse_login, 0);
421	aim_conn_addhandler(sess, conn, 0x0017, 0x0003, gaim_parse_auth_resp, 0);
422
423	conn->status \|= AIM_CONN_STATUS_INPROGRESS;
424	conn->fd = proxy_connect(set_getstr(&acc->set, "server"),
425	AIM_LOGIN_PORT, oscar_login_connect, ic);
426	if (conn->fd < 0) {
427	imcb_error(ic, _("Couldn't connect to host"));
428	imc_logout(ic, TRUE);
429	return;
430	}
431	aim_request_login(sess, conn, ic->acc->user);
432	}
433
434	static void oscar_logout(struct im_connection *ic) {
435	struct oscar_data odata = (struct oscar_data )ic->proto_data;
436
437	while (odata->oscar_chats) {
438	struct chat_connection *n = odata->oscar_chats->data;
439	if (n->inpa > 0)
440	b_event_remove(n->inpa);
441	g_free(n->name);
442	g_free(n->show);
443	odata->oscar_chats = g_slist_remove(odata->oscar_chats, n);
444	g_free(n);
445	}
446	while (odata->create_rooms) {
447	struct create_room *cr = odata->create_rooms->data;
448	g_free(cr->name);
449	odata->create_rooms = g_slist_remove(odata->create_rooms, cr);
450	g_free(cr);
451	}
452	if (odata->ips)
453	g_hash_table_destroy(odata->ips);
454	if (odata->email)
455	g_free(odata->email);
456	if (odata->newp)
457	g_free(odata->newp);
458	if (odata->oldp)
459	g_free(odata->oldp);
460	if (ic->inpa > 0)
461	b_event_remove(ic->inpa);
462	if (odata->cnpa > 0)
463	b_event_remove(odata->cnpa);
464	if (odata->paspa > 0)
465	b_event_remove(odata->paspa);
466	aim_session_kill(odata->sess);
467	g_free(odata->sess);
468	odata->sess = NULL;
469	g_free(ic->proto_data);
470	ic->proto_data = NULL;
471	}
472
473	static gboolean oscar_bos_connect(gpointer data, gint source, b_input_condition cond) {
474	struct im_connection *ic = data;
475	struct oscar_data *odata;
476	aim_session_t *sess;
477	aim_conn_t *bosconn;
478
479	if (!g_slist_find(get_connections(), ic)) {
480	closesocket(source);
481	return FALSE;
482	}
483
484	odata = ic->proto_data;
485	sess = odata->sess;
486	bosconn = odata->conn;
487
488	if (source < 0) {
489	imcb_error(ic, _("Could Not Connect"));
490	imc_logout(ic, TRUE);
491	return FALSE;
492	}
493
494	aim_conn_completeconnect(sess, bosconn);
495	ic->inpa = b_input_add(bosconn->fd, GAIM_INPUT_READ,
496	oscar_callback, bosconn);
497	imcb_log(ic, _("Connection established, cookie sent"));
498
499	return FALSE;
500	}
501
502	static int gaim_parse_auth_resp(aim_session_t sess, aim_frame_t fr, ...) {
503	va_list ap;
504	struct aim_authresp_info *info;
505	int i; char *host; int port;
506	aim_conn_t *bosconn;
507
508	struct im_connection *ic = sess->aux_data;
509	struct oscar_data *od = ic->proto_data;
510	port = AIM_LOGIN_PORT;
511
512	va_start(ap, fr);
513	info = va_arg(ap, struct aim_authresp_info *);
514	va_end(ap);
515
516	if (info->errorcode \|\| !info->bosip \|\| !info->cookie) {
517	switch (info->errorcode) {
518	case 0x05:
519	/* Incorrect nick/password */
520	imcb_error(ic, _("Incorrect nickname or password."));
521	// plugin_event(event_error, (void *)980, 0, 0, 0);
522	break;
523	case 0x11:
524	/* Suspended account */
525	imcb_error(ic, _("Your account is currently suspended."));
526	break;
527	case 0x18:
528	/* connecting too frequently */
529	od->no_reconnect = TRUE;
530	imcb_error(ic, _("You have been connecting and disconnecting too frequently. Wait ten minutes and try again. If you continue to try, you will need to wait even longer."));
531	break;
532	case 0x1c:
533	/* client too old */
534	imcb_error(ic, _("The client version you are using is too old. Please upgrade at " WEBSITE));
535	break;
536	default:
537	imcb_error(ic, _("Authentication Failed"));
538	break;
539	}
540	od->killme = TRUE;
541	return 1;
542	}
543
544
545	aim_conn_kill(sess, &fr->conn);
546
547	bosconn = aim_newconn(sess, AIM_CONN_TYPE_BOS, NULL);
548	if (bosconn == NULL) {
549	imcb_error(ic, _("Internal Error"));
550	od->killme = TRUE;
551	return 0;
552	}
553
554	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNINITDONE, conninitdone_bos, 0);
555	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_BOS, AIM_CB_BOS_RIGHTS, gaim_bosrights, 0);
556	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_ACK, AIM_CB_ACK_ACK, NULL, 0);
557	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_GEN, AIM_CB_GEN_REDIRECT, gaim_handle_redirect, 0);
558	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_LOC, AIM_CB_LOC_RIGHTSINFO, gaim_parse_locaterights, 0);
559	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_BUD, AIM_CB_BUD_RIGHTSINFO, gaim_parse_buddyrights, 0);
560	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_BUD, AIM_CB_BUD_ONCOMING, gaim_parse_oncoming, 0);
561	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_BUD, AIM_CB_BUD_OFFGOING, gaim_parse_offgoing, 0);
562	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_MSG, AIM_CB_MSG_INCOMING, gaim_parse_incoming_im, 0);
563	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_LOC, AIM_CB_LOC_ERROR, gaim_parse_locerr, 0);
564	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_MSG, AIM_CB_MSG_MISSEDCALL, gaim_parse_misses, 0);
565	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_GEN, AIM_CB_GEN_RATECHANGE, gaim_parse_ratechange, 0);
566	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_MSG, AIM_CB_MSG_ERROR, gaim_parse_msgerr, 0);
567	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_GEN, AIM_CB_GEN_MOTD, gaim_parse_motd, 0);
568	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_MSG, AIM_CB_MSG_PARAMINFO, gaim_icbm_param_info, 0);
569	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_GEN, AIM_CB_GEN_ERROR, gaim_parse_genericerr, 0);
570	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_BUD, AIM_CB_BUD_ERROR, gaim_parse_genericerr, 0);
571	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_BOS, AIM_CB_BOS_ERROR, gaim_parse_genericerr, 0);
572	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_GEN, 0x1f, gaim_memrequest, 0);
573	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_GEN, AIM_CB_GEN_SELFINFO, gaim_selfinfo, 0);
574	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_ICQ, AIM_CB_ICQ_OFFLINEMSG, gaim_offlinemsg, 0);
575	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_ICQ, AIM_CB_ICQ_OFFLINEMSGCOMPLETE, gaim_offlinemsgdone, 0);
576	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_ICQ, AIM_CB_ICQ_INFO, gaim_icqinfo, 0);
577	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_SSI, AIM_CB_SSI_RIGHTSINFO, gaim_ssi_parserights, 0);
578	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_SSI, AIM_CB_SSI_LIST, gaim_ssi_parselist, 0);
579	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_SSI, AIM_CB_SSI_SRVACK, gaim_ssi_parseack, 0);
580	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_LOC, AIM_CB_LOC_USERINFO, gaim_parseaiminfo, 0);
581	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_MSG, AIM_CB_MSG_MTN, gaim_parsemtn, 0);
582	aim_conn_addhandler(sess, bosconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNERR, gaim_parse_logout, 0);
583
584	((struct oscar_data *)ic->proto_data)->conn = bosconn;
585	for (i = 0; i < (int)strlen(info->bosip); i++) {
586	if (info->bosip[i] == ':') {
587	port = atoi(&(info->bosip[i+1]));
588	break;
589	}
590	}
591	host = g_strndup(info->bosip, i);
592	bosconn->status \|= AIM_CONN_STATUS_INPROGRESS;
593	bosconn->fd = proxy_connect(host, port, oscar_bos_connect, ic);
594	g_free(host);
595	if (bosconn->fd < 0) {
596	imcb_error(ic, _("Could Not Connect"));
597	od->killme = TRUE;
598	return 0;
599	}
600	aim_sendcookie(sess, bosconn, info->cookie);
601	b_event_remove(ic->inpa);
602
603	return 1;
604	}
605
606	struct pieceofcrap {
607	struct im_connection *ic;
608	unsigned long offset;
609	unsigned long len;
610	char *modname;
611	int fd;
612	aim_conn_t *conn;
613	unsigned int inpa;
614	};
615
616	static gboolean damn_you(gpointer data, gint source, b_input_condition c)
617	{
618	struct pieceofcrap *pos = data;
619	struct oscar_data *od = pos->ic->proto_data;
620	char in = '\0';
621	int x = 0;
622	unsigned char m[17];
623
624	while (read(pos->fd, &in, 1) == 1) {
625	if (in == '\n')
626	x++;
627	else if (in != '\r')
628	x = 0;
629	if (x == 2)
630	break;
631	in = '\0';
632	}
633	if (in != '\n') {
634	imcb_error(pos->ic, "Gaim was unable to get a valid hash for logging into AIM."
635	" You may be disconnected shortly.");
636	b_event_remove(pos->inpa);
637	closesocket(pos->fd);
638	g_free(pos);
639	return FALSE;
640	}
641	/* [WvG] Wheeeee! Who needs error checking anyway? ;-) */
642	read(pos->fd, m, 16);
643	m[16] = '\0';
644	b_event_remove(pos->inpa);
645	closesocket(pos->fd);
646	aim_sendmemblock(od->sess, pos->conn, 0, 16, m, AIM_SENDMEMBLOCK_FLAG_ISHASH);
647	g_free(pos);
648
649	return FALSE;
650	}
651
652	static gboolean straight_to_hell(gpointer data, gint source, b_input_condition cond) {
653	struct pieceofcrap *pos = data;
654	char buf[BUF_LONG];
655
656	if (source < 0) {
657	imcb_error(pos->ic, "Gaim was unable to get a valid hash for logging into AIM."
658	" You may be disconnected shortly.");
659	if (pos->modname)
660	g_free(pos->modname);
661	g_free(pos);
662	return FALSE;
663	}
664
665	g_snprintf(buf, sizeof(buf), "GET " AIMHASHDATA
666	"?offset=%ld&len=%ld&modname=%s HTTP/1.0\n\n",
667	pos->offset, pos->len, pos->modname ? pos->modname : "");
668	write(pos->fd, buf, strlen(buf));
669	if (pos->modname)
670	g_free(pos->modname);
671	pos->inpa = b_input_add(pos->fd, GAIM_INPUT_READ, damn_you, pos);
672	return FALSE;
673	}
674
675	/* size of icbmui.ocm, the largest module in AIM 3.5 */
676	#define AIM_MAX_FILE_SIZE 98304
677
678	int gaim_memrequest(aim_session_t sess, aim_frame_t fr, ...) {
679	va_list ap;
680	struct pieceofcrap *pos;
681	guint32 offset, len;
682	char *modname;
683	int fd;
684
685	va_start(ap, fr);
686	offset = (guint32)va_arg(ap, unsigned long);
687	len = (guint32)va_arg(ap, unsigned long);
688	modname = va_arg(ap, char *);
689	va_end(ap);
690
691	if (len == 0) {
692	aim_sendmemblock(sess, fr->conn, offset, len, NULL,
693	AIM_SENDMEMBLOCK_FLAG_ISREQUEST);
694	return 1;
695	}
696	/* uncomment this when you're convinced it's right. remember, it's been wrong before.
697	if (offset > AIM_MAX_FILE_SIZE \|\| len > AIM_MAX_FILE_SIZE) {
698	char *buf;
699	int i = 8;
700	if (modname)
701	i += strlen(modname);
702	buf = g_malloc(i);
703	i = 0;
704	if (modname) {
705	memcpy(buf, modname, strlen(modname));
706	i += strlen(modname);
707	}
708	buf[i++] = offset & 0xff;
709	buf[i++] = (offset >> 8) & 0xff;
710	buf[i++] = (offset >> 16) & 0xff;
711	buf[i++] = (offset >> 24) & 0xff;
712	buf[i++] = len & 0xff;
713	buf[i++] = (len >> 8) & 0xff;
714	buf[i++] = (len >> 16) & 0xff;
715	buf[i++] = (len >> 24) & 0xff;
716	aim_sendmemblock(sess, command->conn, offset, i, buf, AIM_SENDMEMBLOCK_FLAG_ISREQUEST);
717	g_free(buf);
718	return 1;
719	}
720	*/
721
722	pos = g_new0(struct pieceofcrap, 1);
723	pos->ic = sess->aux_data;
724	pos->conn = fr->conn;
725
726	pos->offset = offset;
727	pos->len = len;
728	pos->modname = modname ? g_strdup(modname) : NULL;
729
730	fd = proxy_connect("gaim.sourceforge.net", 80, straight_to_hell, pos);
731	if (fd < 0) {
732	if (pos->modname)
733	g_free(pos->modname);
734	g_free(pos);
735	imcb_error(sess->aux_data, "Gaim was unable to get a valid hash for logging into AIM."
736	" You may be disconnected shortly.");
737	}
738	pos->fd = fd;
739
740	return 1;
741	}
742
743	static int gaim_parse_login(aim_session_t sess, aim_frame_t fr, ...) {
744	#if 0
745	struct client_info_s info = {"gaim", 4, 1, 2010, "us", "en", 0x0004, 0x0000, 0x04b};
746	#else
747	struct client_info_s info = AIM_CLIENTINFO_KNOWNGOOD;
748	#endif
749	char *key;
750	va_list ap;
751	struct im_connection *ic = sess->aux_data;
752
753	va_start(ap, fr);
754	key = va_arg(ap, char *);
755	va_end(ap);
756
757	aim_send_login(sess, fr->conn, ic->acc->user, ic->acc->pass, &info, key);
758
759	return 1;
760	}
761
762	static int gaim_parse_logout(aim_session_t sess, aim_frame_t fr, ...) {
763	struct im_connection *ic = sess->aux_data;
764	struct oscar_data *odata = ic->proto_data;
765	int code;
766	va_list ap;
767
768	va_start(ap, fr);
769	code = va_arg(ap, int);
770	va_end(ap);
771
772	imcb_error( ic, "Connection aborted by server: %s", code == 1 ?
773	"someone else logged in with your account" :
774	"unknown reason" );
775
776	/* Tell BitlBee to disable auto_reconnect if code == 1, since that
777	means a concurrent login somewhere else. */
778	odata->no_reconnect = code == 1;
779
780	/* DO NOT log out here! Just tell the callback to do it. */
781	odata->killme = TRUE;
782
783	return 1;
784	}
785
786	static int conninitdone_chat(aim_session_t sess, aim_frame_t fr, ...) {
787	struct im_connection *ic = sess->aux_data;
788	struct chat_connection *chatcon;
789	static int id = 1;
790
791	aim_conn_addhandler(sess, fr->conn, 0x000e, 0x0001, gaim_parse_genericerr, 0);
792	aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_USERJOIN, gaim_chat_join, 0);
793	aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_USERLEAVE, gaim_chat_leave, 0);
794	aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_ROOMINFOUPDATE, gaim_chat_info_update, 0);
795	aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CHT, AIM_CB_CHT_INCOMINGMSG, gaim_chat_incoming_msg, 0);
796
797	aim_clientready(sess, fr->conn);
798
799	chatcon = find_oscar_chat_by_conn(ic, fr->conn);
800	chatcon->id = id;
801	chatcon->cnv = imcb_chat_new(ic, chatcon->show);
802	chatcon->cnv->data = chatcon;
803
804	return 1;
805	}
806
807	static int conninitdone_chatnav(aim_session_t sess, aim_frame_t fr, ...) {
808
809	aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CTN, AIM_CB_CTN_ERROR, gaim_parse_genericerr, 0);
810	aim_conn_addhandler(sess, fr->conn, AIM_CB_FAM_CTN, AIM_CB_CTN_INFO, gaim_chatnav_info, 0);
811
812	aim_clientready(sess, fr->conn);
813
814	aim_chatnav_reqrights(sess, fr->conn);
815
816	return 1;
817	}
818
819	static gboolean oscar_chatnav_connect(gpointer data, gint source, b_input_condition cond) {
820	struct im_connection *ic = data;
821	struct oscar_data *odata;
822	aim_session_t *sess;
823	aim_conn_t *tstconn;
824
825	if (!g_slist_find(get_connections(), ic)) {
826	closesocket(source);
827	return FALSE;
828	}
829
830	odata = ic->proto_data;
831	sess = odata->sess;
832	tstconn = aim_getconn_type_all(sess, AIM_CONN_TYPE_CHATNAV);
833
834	if (source < 0) {
835	aim_conn_kill(sess, &tstconn);
836	return FALSE;
837	}
838
839	aim_conn_completeconnect(sess, tstconn);
840	odata->cnpa = b_input_add(tstconn->fd, GAIM_INPUT_READ,
841	oscar_callback, tstconn);
842
843	return FALSE;
844	}
845
846	static gboolean oscar_auth_connect(gpointer data, gint source, b_input_condition cond)
847	{
848	struct im_connection *ic = data;
849	struct oscar_data *odata;
850	aim_session_t *sess;
851	aim_conn_t *tstconn;
852
853	if (!g_slist_find(get_connections(), ic)) {
854	closesocket(source);
855	return FALSE;
856	}
857
858	odata = ic->proto_data;
859	sess = odata->sess;
860	tstconn = aim_getconn_type_all(sess, AIM_CONN_TYPE_AUTH);
861
862	if (source < 0) {
863	aim_conn_kill(sess, &tstconn);
864	return FALSE;
865	}
866
867	aim_conn_completeconnect(sess, tstconn);
868	odata->paspa = b_input_add(tstconn->fd, GAIM_INPUT_READ,
869	oscar_callback, tstconn);
870
871	return FALSE;
872	}
873
874	static gboolean oscar_chat_connect(gpointer data, gint source, b_input_condition cond)
875	{
876	struct chat_connection *ccon = data;
877	struct im_connection *ic = ccon->ic;
878	struct oscar_data *odata;
879	aim_session_t *sess;
880	aim_conn_t *tstconn;
881
882	if (!g_slist_find(get_connections(), ic)) {
883	closesocket(source);
884	g_free(ccon->show);
885	g_free(ccon->name);
886	g_free(ccon);
887	return FALSE;
888	}
889
890	odata = ic->proto_data;
891	sess = odata->sess;
892	tstconn = ccon->conn;
893
894	if (source < 0) {
895	aim_conn_kill(sess, &tstconn);
896	g_free(ccon->show);
897	g_free(ccon->name);
898	g_free(ccon);
899	return FALSE;
900	}
901
902	aim_conn_completeconnect(sess, ccon->conn);
903	ccon->inpa = b_input_add(tstconn->fd,
904	GAIM_INPUT_READ,
905	oscar_callback, tstconn);
906	odata->oscar_chats = g_slist_append(odata->oscar_chats, ccon);
907
908	return FALSE;
909	}
910
911	/* Hrmph. I don't know how to make this look better. --mid */
912	static int gaim_handle_redirect(aim_session_t sess, aim_frame_t fr, ...) {
913	va_list ap;
914	struct aim_redirect_data *redir;
915	struct im_connection *ic = sess->aux_data;
916	aim_conn_t *tstconn;
917	int i;
918	char *host;
919	int port;
920
921	va_start(ap, fr);
922	redir = va_arg(ap, struct aim_redirect_data *);
923	va_end(ap);
924
925	port = AIM_LOGIN_PORT;
926	for (i = 0; i < (int)strlen(redir->ip); i++) {
927	if (redir->ip[i] == ':') {
928	port = atoi(&(redir->ip[i+1]));
929	break;
930	}
931	}
932	host = g_strndup(redir->ip, i);
933
934	switch(redir->group) {
935	case 0x7: /* Authorizer */
936	tstconn = aim_newconn(sess, AIM_CONN_TYPE_AUTH, NULL);
937	if (tstconn == NULL) {
938	g_free(host);
939	return 1;
940	}
941	aim_conn_addhandler(sess, tstconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNINITDONE, conninitdone_admin, 0);
942	// aim_conn_addhandler(sess, tstconn, 0x0007, 0x0003, gaim_info_change, 0);
943	// aim_conn_addhandler(sess, tstconn, 0x0007, 0x0005, gaim_info_change, 0);
944	// aim_conn_addhandler(sess, tstconn, 0x0007, 0x0007, gaim_account_confirm, 0);
945
946	tstconn->status \|= AIM_CONN_STATUS_INPROGRESS;
947	tstconn->fd = proxy_connect(host, port, oscar_auth_connect, ic);
948	if (tstconn->fd < 0) {
949	aim_conn_kill(sess, &tstconn);
950	g_free(host);
951	return 1;
952	}
953	aim_sendcookie(sess, tstconn, redir->cookie);
954	break;
955	case 0xd: /* ChatNav */
956	tstconn = aim_newconn(sess, AIM_CONN_TYPE_CHATNAV, NULL);
957	if (tstconn == NULL) {
958	g_free(host);
959	return 1;
960	}
961	aim_conn_addhandler(sess, tstconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNINITDONE, conninitdone_chatnav, 0);
962
963	tstconn->status \|= AIM_CONN_STATUS_INPROGRESS;
964	tstconn->fd = proxy_connect(host, port, oscar_chatnav_connect, ic);
965	if (tstconn->fd < 0) {
966	aim_conn_kill(sess, &tstconn);
967	g_free(host);
968	return 1;
969	}
970	aim_sendcookie(sess, tstconn, redir->cookie);
971	break;
972	case 0xe: /* Chat */
973	{
974	struct chat_connection *ccon;
975
976	tstconn = aim_newconn(sess, AIM_CONN_TYPE_CHAT, NULL);
977	if (tstconn == NULL) {
978	g_free(host);
979	return 1;
980	}
981
982	aim_conn_addhandler(sess, tstconn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNINITDONE, conninitdone_chat, 0);
983
984	ccon = g_new0(struct chat_connection, 1);
985	ccon->conn = tstconn;
986	ccon->ic = ic;
987	ccon->fd = -1;
988	ccon->name = g_strdup(redir->chat.room);
989	ccon->exchange = redir->chat.exchange;
990	ccon->instance = redir->chat.instance;
991	ccon->show = extract_name(redir->chat.room);
992
993	ccon->conn->status \|= AIM_CONN_STATUS_INPROGRESS;
994	ccon->conn->fd = proxy_connect(host, port, oscar_chat_connect, ccon);
995	if (ccon->conn->fd < 0) {
996	aim_conn_kill(sess, &tstconn);
997	g_free(host);
998	g_free(ccon->show);
999	g_free(ccon->name);
1000	g_free(ccon);
1001	return 1;
1002	}
1003	aim_sendcookie(sess, tstconn, redir->cookie);
1004	}
1005	break;
1006	default: /* huh? */
1007	break;
1008	}
1009
1010	g_free(host);
1011	return 1;
1012	}
1013
1014	static int gaim_parse_oncoming(aim_session_t sess, aim_frame_t fr, ...) {
1015	struct im_connection *ic = sess->aux_data;
1016	struct oscar_data *od = ic->proto_data;
1017	aim_userinfo_t *info;
1018	time_t time_idle = 0, signon = 0;
1019	int flags = OPT_LOGGED_IN;
1020	char tmp, state_string = NULL;
1021
1022	va_list ap;
1023	va_start(ap, fr);
1024	info = va_arg(ap, aim_userinfo_t *);
1025	va_end(ap);
1026
1027	if ((!od->icq) && (info->present & AIM_USERINFO_PRESENT_FLAGS)) {
1028	if (info->flags & AIM_FLAG_AWAY)
1029	flags \|= OPT_AWAY;
1030	}
1031
1032	if (info->present & AIM_USERINFO_PRESENT_ICQEXTSTATUS) {
1033	if (!(info->icqinfo.status & AIM_ICQ_STATE_CHAT) &&
1034	(info->icqinfo.status != AIM_ICQ_STATE_NORMAL)) {
1035	flags \|= OPT_AWAY;
1036	}
1037
1038	if( info->icqinfo.status & AIM_ICQ_STATE_DND )
1039	state_string = "Do Not Disturb";
1040	else if( info->icqinfo.status & AIM_ICQ_STATE_OUT )
1041	state_string = "Not Available";
1042	else if( info->icqinfo.status & AIM_ICQ_STATE_BUSY )
1043	state_string = "Occupied";
1044	else if( info->icqinfo.status & AIM_ICQ_STATE_INVISIBLE )
1045	state_string = "Invisible";
1046	}
1047
1048	if (info->present & AIM_USERINFO_PRESENT_IDLE) {
1049	time(&time_idle);
1050	time_idle -= info->idletime*60;
1051	}
1052
1053	if (info->present & AIM_USERINFO_PRESENT_SESSIONLEN)
1054	signon = time(NULL) - info->sessionlen;
1055
1056	if (info->present & AIM_USERINFO_PRESENT_ICQIPADDR) {
1057	uint32_t *uin = g_new0(uint32_t, 1);
1058
1059	if (od->ips == NULL)
1060	od->ips = g_hash_table_new_full(g_int_hash, g_int_equal, g_free, NULL);
1061
1062	if (sscanf(info->sn, "%d", uin) == 1)
1063	g_hash_table_insert(od->ips, uin, (gpointer) (long) info->icqinfo.ipaddr);
1064	}
1065
1066	if (!aim_sncmp(ic->acc->user, info->sn))
1067	g_snprintf(ic->displayname, sizeof(ic->displayname), "%s", info->sn);
1068
1069	tmp = normalize(info->sn);
1070	imcb_buddy_status(ic, tmp, flags, state_string, NULL);
1071	/* imcb_buddy_times(ic, tmp, signon, time_idle); */
1072
1073
1074	return 1;
1075	}
1076
1077	static int gaim_parse_offgoing(aim_session_t sess, aim_frame_t fr, ...) {
1078	aim_userinfo_t *info;
1079	va_list ap;
1080	struct im_connection *ic = sess->aux_data;
1081
1082	va_start(ap, fr);
1083	info = va_arg(ap, aim_userinfo_t *);
1084	va_end(ap);
1085
1086	imcb_buddy_status(ic, normalize(info->sn), 0, NULL, NULL );
1087
1088	return 1;
1089	}
1090
1091	static int incomingim_chan1(aim_session_t sess, aim_conn_t conn, aim_userinfo_t userinfo, struct aim_incomingim_ch1_args args) {
1092	char *tmp = g_malloc(BUF_LONG + 1);
1093	struct im_connection *ic = sess->aux_data;
1094	int flags = 0;
1095
1096	if (args->icbmflags & AIM_IMFLAGS_AWAY)
1097	flags \|= OPT_AWAY;
1098
1099	if ((args->icbmflags & AIM_IMFLAGS_UNICODE) \|\| (args->icbmflags & AIM_IMFLAGS_ISO_8859_1)) {
1100	char *src;
1101
1102	if (args->icbmflags & AIM_IMFLAGS_UNICODE)
1103	src = "UNICODEBIG";
1104	else
1105	src = "ISO8859-1";
1106
1107	/* Try to use iconv first to convert the message to UTF8 - which is what BitlBee expects */
1108	if (do_iconv(src, "UTF-8", args->msg, tmp, args->msglen, BUF_LONG) >= 0) {
1109	// Successfully converted!
1110	} else if (args->icbmflags & AIM_IMFLAGS_UNICODE) {
1111	int i;
1112
1113	for (i = 0, tmp[0] = '\0'; i < args->msglen; i += 2) {
1114	unsigned short uni;
1115
1116	uni = ((args->msg[i] & 0xff) << 8) \| (args->msg[i+1] & 0xff);
1117
1118	if ((uni < 128) \|\| ((uni >= 160) && (uni <= 255))) { /* ISO 8859-1 */
1119	g_snprintf(tmp+strlen(tmp), BUF_LONG-strlen(tmp), "%c", uni);
1120	} else { /* something else, do UNICODE entity */
1121	g_snprintf(tmp+strlen(tmp), BUF_LONG-strlen(tmp), "&#%04x;", uni);
1122	}
1123	}
1124	} else {
1125	g_snprintf(tmp, BUF_LONG, "%s", args->msg);
1126	}
1127	} else if (args->mpmsg.numparts == 0) {
1128	g_snprintf(tmp, BUF_LONG, "%s", args->msg);
1129	} else {
1130	aim_mpmsg_section_t *part;
1131
1132	*tmp = 0;
1133	for (part = args->mpmsg.parts; part; part = part->next) {
1134	if (part->data) {
1135	g_strlcat(tmp, (char*) part->data, BUF_LONG);
1136	g_strlcat(tmp, "\n", BUF_LONG);
1137	}
1138	}
1139	}
1140
1141	strip_linefeed(tmp);
1142	imcb_buddy_msg(ic, normalize(userinfo->sn), tmp, flags, 0);
1143	g_free(tmp);
1144
1145	return 1;
1146	}
1147
1148	void oscar_accept_chat(void *data);
1149	void oscar_reject_chat(void *data);
1150
1151	static int incomingim_chan2(aim_session_t sess, aim_conn_t conn, aim_userinfo_t userinfo, struct aim_incomingim_ch2_args args) {
1152	struct im_connection *ic = sess->aux_data;
1153
1154	if (args->status != AIM_RENDEZVOUS_PROPOSE)
1155	return 1;
1156
1157	if (args->reqclass & AIM_CAPS_CHAT) {
1158	char *name = extract_name(args->info.chat.roominfo.name);
1159	int *exch = g_new0(int, 1);
1160	GList *m = NULL;
1161	char txt[1024];
1162	struct aim_chat_invitation * inv = g_new0(struct aim_chat_invitation, 1);
1163
1164	m = g_list_append(m, g_strdup(name ? name : args->info.chat.roominfo.name));
1165	*exch = args->info.chat.roominfo.exchange;
1166	m = g_list_append(m, exch);
1167
1168	g_snprintf( txt, 1024, "Got an invitation to chatroom %s from %s: %s", name, userinfo->sn, args->msg );
1169
1170	inv->ic = ic;
1171	inv->exchange = *exch;
1172	inv->name = g_strdup(name);
1173
1174	imcb_ask( ic, txt, inv, oscar_accept_chat, oscar_reject_chat);
1175
1176	if (name)
1177	g_free(name);
1178	}
1179
1180	return 1;
1181	}
1182
1183	static void gaim_icq_authgrant(void *data_) {
1184	struct icq_auth *data = data_;
1185	char *uin, message;
1186	struct oscar_data od = (struct oscar_data )data->ic->proto_data;
1187
1188	uin = g_strdup_printf("%u", data->uin);
1189	message = 0;
1190	aim_ssi_auth_reply(od->sess, od->conn, uin, 1, "");
1191	// aim_send_im_ch4(od->sess, uin, AIM_ICQMSG_AUTHGRANTED, &message);
1192	imcb_ask_add(data->ic, uin, NULL);
1193
1194	g_free(uin);
1195	g_free(data);
1196	}
1197
1198	static void gaim_icq_authdeny(void *data_) {
1199	struct icq_auth *data = data_;
1200	char uin, message;
1201	struct oscar_data od = (struct oscar_data )data->ic->proto_data;
1202
1203	uin = g_strdup_printf("%u", data->uin);
1204	message = g_strdup_printf("No reason given.");
1205	aim_ssi_auth_reply(od->sess, od->conn, uin, 0, "");
1206	// aim_send_im_ch4(od->sess, uin, AIM_ICQMSG_AUTHDENIED, message);
1207	g_free(message);
1208
1209	g_free(uin);
1210	g_free(data);
1211	}
1212
1213	/*
1214	* For when other people ask you for authorization
1215	*/
1216	static void gaim_icq_authask(struct im_connection ic, guint32 uin, char msg) {
1217	struct icq_auth *data;
1218	char *reason = NULL;
1219	char *dialog_msg;
1220
1221	if (set_getbool(&ic->acc->set, "ignore_auth_requests"))
1222	return;
1223
1224	data = g_new(struct icq_auth, 1);
1225
1226	if (strlen(msg) > 6)
1227	reason = msg + 6;
1228
1229	dialog_msg = g_strdup_printf("The user %u wants to add you to their buddy list for the following reason: %s", uin, reason ? reason : "No reason given.");
1230	data->ic = ic;
1231	data->uin = uin;
1232	imcb_ask(ic, dialog_msg, data, gaim_icq_authgrant, gaim_icq_authdeny);
1233	g_free(dialog_msg);
1234	}
1235
1236	static int incomingim_chan4(aim_session_t sess, aim_conn_t conn, aim_userinfo_t userinfo, struct aim_incomingim_ch4_args args) {
1237	struct im_connection *ic = sess->aux_data;
1238
1239	switch (args->type) {
1240	case 0x0001: { /* An almost-normal instant message. Mac ICQ sends this. It's peculiar. */
1241	char uin, message;
1242	uin = g_strdup_printf("%u", args->uin);
1243	message = g_strdup(args->msg);
1244	strip_linefeed(message);
1245	imcb_buddy_msg(ic, normalize(uin), message, 0, 0);
1246	g_free(uin);
1247	g_free(message);
1248	} break;
1249
1250	case 0x0004: { /* Someone sent you a URL */
1251	char uin, message;
1252	char **m;
1253
1254	uin = g_strdup_printf("%u", args->uin);
1255	m = g_strsplit(args->msg, "\376", 2);
1256
1257	if ((strlen(m[0]) != 0)) {
1258	message = g_strjoinv(" -- ", m);
1259	} else {
1260	message = m[1];
1261	}
1262
1263	strip_linefeed(message);
1264	imcb_buddy_msg(ic, normalize(uin), message, 0, 0);
1265	g_free(uin);
1266	g_free(m);
1267	g_free(message);
1268	} break;
1269
1270	case 0x0006: { /* Someone requested authorization */
1271	gaim_icq_authask(ic, args->uin, args->msg);
1272	} break;
1273
1274	case 0x0007: { /* Someone has denied you authorization */
1275	imcb_log(sess->aux_data, "The user %u has denied your request to add them to your contact list for the following reason:\n%s", args->uin, args->msg ? args->msg : _("No reason given.") );
1276	} break;
1277
1278	case 0x0008: { /* Someone has granted you authorization */
1279	imcb_log(sess->aux_data, "The user %u has granted your request to add them to your contact list for the following reason:\n%s", args->uin, args->msg ? args->msg : _("No reason given.") );
1280	} break;
1281
1282	case 0x0012: {
1283	/* Ack for authorizing/denying someone. Or possibly an ack for sending any system notice */
1284	} break;
1285
1286	default: {;
1287	} break;
1288	}
1289
1290	return 1;
1291	}
1292
1293	static int gaim_parse_incoming_im(aim_session_t sess, aim_frame_t fr, ...) {
1294	int channel, ret = 0;
1295	aim_userinfo_t *userinfo;
1296	va_list ap;
1297
1298	va_start(ap, fr);
1299	channel = va_arg(ap, int);
1300	userinfo = va_arg(ap, aim_userinfo_t *);
1301
1302	switch (channel) {
1303	case 1: { /* standard message */
1304	struct aim_incomingim_ch1_args *args;
1305	args = va_arg(ap, struct aim_incomingim_ch1_args *);
1306	ret = incomingim_chan1(sess, fr->conn, userinfo, args);
1307	} break;
1308
1309	case 2: { /* rendevous */
1310	struct aim_incomingim_ch2_args *args;
1311	args = va_arg(ap, struct aim_incomingim_ch2_args *);
1312	ret = incomingim_chan2(sess, fr->conn, userinfo, args);
1313	} break;
1314
1315	case 4: { /* ICQ */
1316	struct aim_incomingim_ch4_args *args;
1317	args = va_arg(ap, struct aim_incomingim_ch4_args *);
1318	ret = incomingim_chan4(sess, fr->conn, userinfo, args);
1319	} break;
1320
1321	default: {;
1322	} break;
1323	}
1324
1325	va_end(ap);
1326
1327	return ret;
1328	}
1329
1330	static int gaim_parse_misses(aim_session_t sess, aim_frame_t fr, ...) {
1331	va_list ap;
1332	guint16 chan, nummissed, reason;
1333	aim_userinfo_t *userinfo;
1334
1335	va_start(ap, fr);
1336	chan = (guint16)va_arg(ap, unsigned int);
1337	userinfo = va_arg(ap, aim_userinfo_t *);
1338	nummissed = (guint16)va_arg(ap, unsigned int);
1339	reason = (guint16)va_arg(ap, unsigned int);
1340	va_end(ap);
1341
1342	switch(reason) {
1343	case 0:
1344	/* Invalid (0) */
1345	imcb_error(sess->aux_data,
1346	nummissed == 1 ?
1347	_("You missed %d message from %s because it was invalid.") :
1348	_("You missed %d messages from %s because they were invalid."),
1349	nummissed,
1350	userinfo->sn);
1351	break;
1352	case 1:
1353	/* Message too large */
1354	imcb_error(sess->aux_data,
1355	nummissed == 1 ?
1356	_("You missed %d message from %s because it was too large.") :
1357	_("You missed %d messages from %s because they were too large."),
1358	nummissed,
1359	userinfo->sn);
1360	break;
1361	case 2:
1362	/* Rate exceeded */
1363	imcb_error(sess->aux_data,
1364	nummissed == 1 ?
1365	_("You missed %d message from %s because the rate limit has been exceeded.") :
1366	_("You missed %d messages from %s because the rate limit has been exceeded."),
1367	nummissed,
1368	userinfo->sn);
1369	break;
1370	case 3:
1371	/* Evil Sender */
1372	imcb_error(sess->aux_data,
1373	nummissed == 1 ?
1374	_("You missed %d message from %s because it was too evil.") :
1375	_("You missed %d messages from %s because they are too evil."),
1376	nummissed,
1377	userinfo->sn);
1378	break;
1379	case 4:
1380	/* Evil Receiver */
1381	imcb_error(sess->aux_data,
1382	nummissed == 1 ?
1383	_("You missed %d message from %s because you are too evil.") :
1384	_("You missed %d messages from %s because you are too evil."),
1385	nummissed,
1386	userinfo->sn);
1387	break;
1388	default:
1389	imcb_error(sess->aux_data,
1390	nummissed == 1 ?
1391	_("You missed %d message from %s for unknown reasons.") :
1392	_("You missed %d messages from %s for unknown reasons."),
1393	nummissed,
1394	userinfo->sn);
1395	break;
1396	}
1397
1398	return 1;
1399	}
1400
1401	static int gaim_parse_genericerr(aim_session_t sess, aim_frame_t fr, ...) {
1402	va_list ap;
1403	guint16 reason;
1404
1405	va_start(ap, fr);
1406	reason = (guint16)va_arg(ap, unsigned int);
1407	va_end(ap);
1408
1409	imcb_error(sess->aux_data, _("SNAC threw error: %s"),
1410	reason < msgerrreasonlen ? msgerrreason[reason] : "Unknown error");
1411
1412	return 1;
1413	}
1414
1415	static int gaim_parse_msgerr(aim_session_t sess, aim_frame_t fr, ...) {
1416	va_list ap;
1417	char *destn;
1418	guint16 reason;
1419
1420	va_start(ap, fr);
1421	reason = (guint16)va_arg(ap, unsigned int);
1422	destn = va_arg(ap, char *);
1423	va_end(ap);
1424
1425	imcb_error(sess->aux_data, _("Your message to %s did not get sent: %s"), destn,
1426	(reason < msgerrreasonlen) ? msgerrreason[reason] : _("Reason unknown"));
1427
1428	return 1;
1429	}
1430
1431	static int gaim_parse_locerr(aim_session_t sess, aim_frame_t fr, ...) {
1432	va_list ap;
1433	char *destn;
1434	guint16 reason;
1435
1436	va_start(ap, fr);
1437	reason = (guint16)va_arg(ap, unsigned int);
1438	destn = va_arg(ap, char *);
1439	va_end(ap);
1440
1441	imcb_error(sess->aux_data, _("User information for %s unavailable: %s"), destn,
1442	(reason < msgerrreasonlen) ? msgerrreason[reason] : _("Reason unknown"));
1443
1444	return 1;
1445	}
1446
1447	static int gaim_parse_motd(aim_session_t sess, aim_frame_t fr, ...) {
1448	char *msg;
1449	guint16 id;
1450	va_list ap;
1451
1452	va_start(ap, fr);
1453	id = (guint16)va_arg(ap, unsigned int);
1454	msg = va_arg(ap, char *);
1455	va_end(ap);
1456
1457	if (id < 4)
1458	imcb_error(sess->aux_data, _("Your connection may be lost."));
1459
1460	return 1;
1461	}
1462
1463	static int gaim_chatnav_info(aim_session_t sess, aim_frame_t fr, ...) {
1464	va_list ap;
1465	guint16 type;
1466	struct im_connection *ic = sess->aux_data;
1467	struct oscar_data odata = (struct oscar_data )ic->proto_data;
1468
1469	va_start(ap, fr);
1470	type = (guint16)va_arg(ap, unsigned int);
1471
1472	switch(type) {
1473	case 0x0002: {
1474	guint8 maxrooms;
1475	struct aim_chat_exchangeinfo *exchanges;
1476	int exchangecount; // i;
1477
1478	maxrooms = (guint8)va_arg(ap, unsigned int);
1479	exchangecount = va_arg(ap, int);
1480	exchanges = va_arg(ap, struct aim_chat_exchangeinfo *);
1481	va_end(ap);
1482
1483	while (odata->create_rooms) {
1484	struct create_room *cr = odata->create_rooms->data;
1485	aim_chatnav_createroom(sess, fr->conn, cr->name, cr->exchange);
1486	g_free(cr->name);
1487	odata->create_rooms = g_slist_remove(odata->create_rooms, cr);
1488	g_free(cr);
1489	}
1490	}
1491	break;
1492	case 0x0008: {
1493	char fqcn, name, *ck;
1494	guint16 instance, flags, maxmsglen, maxoccupancy, unknown, exchange;
1495	guint8 createperms;
1496	guint32 createtime;
1497
1498	fqcn = va_arg(ap, char *);
1499	instance = (guint16)va_arg(ap, unsigned int);
1500	exchange = (guint16)va_arg(ap, unsigned int);
1501	flags = (guint16)va_arg(ap, unsigned int);
1502	createtime = va_arg(ap, guint32);
1503	maxmsglen = (guint16)va_arg(ap, unsigned int);
1504	maxoccupancy = (guint16)va_arg(ap, unsigned int);
1505	createperms = (guint8)va_arg(ap, int);
1506	unknown = (guint16)va_arg(ap, unsigned int);
1507	name = va_arg(ap, char *);
1508	ck = va_arg(ap, char *);
1509	va_end(ap);
1510
1511	aim_chat_join(odata->sess, odata->conn, exchange, ck, instance);
1512	}
1513	break;
1514	default:
1515	va_end(ap);
1516	break;
1517	}
1518	return 1;
1519	}
1520
1521	static int gaim_chat_join(aim_session_t sess, aim_frame_t fr, ...) {
1522	va_list ap;
1523	int count, i;
1524	aim_userinfo_t *info;
1525	struct im_connection *g = sess->aux_data;
1526
1527	struct chat_connection *c = NULL;
1528
1529	va_start(ap, fr);
1530	count = va_arg(ap, int);
1531	info = va_arg(ap, aim_userinfo_t *);
1532	va_end(ap);
1533
1534	c = find_oscar_chat_by_conn(g, fr->conn);
1535	if (!c)
1536	return 1;
1537
1538	for (i = 0; i < count; i++)
1539	imcb_chat_add_buddy(c->cnv, normalize(info[i].sn));
1540
1541	return 1;
1542	}
1543
1544	static int gaim_chat_leave(aim_session_t sess, aim_frame_t fr, ...) {
1545	va_list ap;
1546	int count, i;
1547	aim_userinfo_t *info;
1548	struct im_connection *g = sess->aux_data;
1549
1550	struct chat_connection *c = NULL;
1551
1552	va_start(ap, fr);
1553	count = va_arg(ap, int);
1554	info = va_arg(ap, aim_userinfo_t *);
1555	va_end(ap);
1556
1557	c = find_oscar_chat_by_conn(g, fr->conn);
1558	if (!c)
1559	return 1;
1560
1561	for (i = 0; i < count; i++)
1562	imcb_chat_remove_buddy(c->cnv, normalize(info[i].sn), NULL);
1563
1564	return 1;
1565	}
1566
1567	static int gaim_chat_info_update(aim_session_t sess, aim_frame_t fr, ...) {
1568	va_list ap;
1569	aim_userinfo_t *userinfo;
1570	struct aim_chat_roominfo *roominfo;
1571	char *roomname;
1572	int usercount;
1573	char *roomdesc;
1574	guint16 unknown_c9, unknown_d2, unknown_d5, maxmsglen, maxvisiblemsglen;
1575	guint32 creationtime;
1576	struct im_connection *ic = sess->aux_data;
1577	struct chat_connection *ccon = find_oscar_chat_by_conn(ic, fr->conn);
1578
1579	va_start(ap, fr);
1580	roominfo = va_arg(ap, struct aim_chat_roominfo *);
1581	roomname = va_arg(ap, char *);
1582	usercount= va_arg(ap, int);
1583	userinfo = va_arg(ap, aim_userinfo_t *);
1584	roomdesc = va_arg(ap, char *);
1585	unknown_c9 = (guint16)va_arg(ap, int);
1586	creationtime = (guint32)va_arg(ap, unsigned long);
1587	maxmsglen = (guint16)va_arg(ap, int);
1588	unknown_d2 = (guint16)va_arg(ap, int);
1589	unknown_d5 = (guint16)va_arg(ap, int);
1590	maxvisiblemsglen = (guint16)va_arg(ap, int);
1591	va_end(ap);
1592
1593	ccon->maxlen = maxmsglen;
1594	ccon->maxvis = maxvisiblemsglen;
1595
1596	return 1;
1597	}
1598
1599	static int gaim_chat_incoming_msg(aim_session_t sess, aim_frame_t fr, ...) {
1600	va_list ap;
1601	aim_userinfo_t *info;
1602	char *msg;
1603	struct im_connection *ic = sess->aux_data;
1604	struct chat_connection *ccon = find_oscar_chat_by_conn(ic, fr->conn);
1605	char *tmp;
1606
1607	va_start(ap, fr);
1608	info = va_arg(ap, aim_userinfo_t *);
1609	msg = va_arg(ap, char *);
1610
1611	tmp = g_malloc(BUF_LONG);
1612	g_snprintf(tmp, BUF_LONG, "%s", msg);
1613	imcb_chat_msg(ccon->cnv, normalize(info->sn), tmp, 0, 0);
1614	g_free(tmp);
1615
1616	return 1;
1617	}
1618
1619	static int gaim_parse_ratechange(aim_session_t sess, aim_frame_t fr, ...) {
1620	#if 0
1621	static const char *codes[5] = {
1622	"invalid",
1623	"change",
1624	"warning",
1625	"limit",
1626	"limit cleared",
1627	};
1628	#endif
1629	va_list ap;
1630	guint16 code, rateclass;
1631	guint32 windowsize, clear, alert, limit, disconnect, currentavg, maxavg;
1632
1633	va_start(ap, fr);
1634	code = (guint16)va_arg(ap, unsigned int);
1635	rateclass= (guint16)va_arg(ap, unsigned int);
1636	windowsize = (guint32)va_arg(ap, unsigned long);
1637	clear = (guint32)va_arg(ap, unsigned long);
1638	alert = (guint32)va_arg(ap, unsigned long);
1639	limit = (guint32)va_arg(ap, unsigned long);
1640	disconnect = (guint32)va_arg(ap, unsigned long);
1641	currentavg = (guint32)va_arg(ap, unsigned long);
1642	maxavg = (guint32)va_arg(ap, unsigned long);
1643	va_end(ap);
1644
1645	/* XXX fix these values */
1646	if (code == AIM_RATE_CODE_CHANGE) {
1647	if (currentavg >= clear)
1648	aim_conn_setlatency(fr->conn, 0);
1649	} else if (code == AIM_RATE_CODE_WARNING) {
1650	aim_conn_setlatency(fr->conn, windowsize/4);
1651	} else if (code == AIM_RATE_CODE_LIMIT) {
1652	imcb_error(sess->aux_data, _("The last message was not sent because you are over the rate limit. "
1653	"Please wait 10 seconds and try again."));
1654	aim_conn_setlatency(fr->conn, windowsize/2);
1655	} else if (code == AIM_RATE_CODE_CLEARLIMIT) {
1656	aim_conn_setlatency(fr->conn, 0);
1657	}
1658
1659	return 1;
1660	}
1661
1662	static int gaim_selfinfo(aim_session_t sess, aim_frame_t fr, ...) {
1663	va_list ap;
1664	aim_userinfo_t *info;
1665	struct im_connection *ic = sess->aux_data;
1666
1667	va_start(ap, fr);
1668	info = va_arg(ap, aim_userinfo_t *);
1669	va_end(ap);
1670
1671	ic->evil = info->warnlevel/10;
1672	/* ic->correction_time = (info->onlinesince - ic->login_time); */
1673
1674	return 1;
1675	}
1676
1677	static int conninitdone_bos(aim_session_t sess, aim_frame_t fr, ...) {
1678
1679	aim_reqpersonalinfo(sess, fr->conn);
1680	aim_bos_reqlocaterights(sess, fr->conn);
1681	aim_bos_reqbuddyrights(sess, fr->conn);
1682
1683	aim_reqicbmparams(sess);
1684
1685	aim_bos_reqrights(sess, fr->conn);
1686	aim_bos_setgroupperm(sess, fr->conn, AIM_FLAG_ALLUSERS);
1687	aim_bos_setprivacyflags(sess, fr->conn, AIM_PRIVFLAGS_ALLOWIDLE \|
1688	AIM_PRIVFLAGS_ALLOWMEMBERSINCE);
1689
1690	return 1;
1691	}
1692
1693	static int conninitdone_admin(aim_session_t sess, aim_frame_t fr, ...) {
1694	struct im_connection *ic = sess->aux_data;
1695	struct oscar_data *od = ic->proto_data;
1696
1697	aim_clientready(sess, fr->conn);
1698
1699	if (od->chpass) {
1700	aim_admin_changepasswd(sess, fr->conn, od->newp, od->oldp);
1701	g_free(od->oldp);
1702	od->oldp = NULL;
1703	g_free(od->newp);
1704	od->newp = NULL;
1705	od->chpass = FALSE;
1706	}
1707	if (od->setnick) {
1708	aim_admin_setnick(sess, fr->conn, od->newsn);
1709	g_free(od->newsn);
1710	od->newsn = NULL;
1711	od->setnick = FALSE;
1712	}
1713	if (od->conf) {
1714	aim_admin_reqconfirm(sess, fr->conn);
1715	od->conf = FALSE;
1716	}
1717	if (od->reqemail) {
1718	aim_admin_getinfo(sess, fr->conn, 0x0011);
1719	od->reqemail = FALSE;
1720	}
1721	if (od->setemail) {
1722	aim_admin_setemail(sess, fr->conn, od->email);
1723	g_free(od->email);
1724	od->setemail = FALSE;
1725	}
1726
1727	return 1;
1728	}
1729
1730	static int gaim_icbm_param_info(aim_session_t sess, aim_frame_t fr, ...) {
1731	struct aim_icbmparameters *params;
1732	va_list ap;
1733
1734	va_start(ap, fr);
1735	params = va_arg(ap, struct aim_icbmparameters *);
1736	va_end(ap);
1737
1738	/* Maybe senderwarn and recverwarn should be user preferences... */
1739	params->flags = 0x0000000b;
1740	params->maxmsglen = 8000;
1741	params->minmsginterval = 0;
1742
1743	aim_seticbmparam(sess, params);
1744
1745	return 1;
1746	}
1747
1748	static int gaim_parse_locaterights(aim_session_t sess, aim_frame_t fr, ...)
1749	{
1750	va_list ap;
1751	guint16 maxsiglen;
1752	struct im_connection *ic = sess->aux_data;
1753	struct oscar_data odata = (struct oscar_data )ic->proto_data;
1754
1755	va_start(ap, fr);
1756	maxsiglen = va_arg(ap, int);
1757	va_end(ap);
1758
1759	odata->rights.maxsiglen = odata->rights.maxawaymsglen = (guint)maxsiglen;
1760
1761	/* FIXME: It seems we're not really using this, and it broke now that
1762	struct aim_user is dead.
1763	aim_bos_setprofile(sess, fr->conn, ic->user->user_info, NULL, gaim_caps);
1764	*/
1765
1766	return 1;
1767	}
1768
1769	static int gaim_parse_buddyrights(aim_session_t sess, aim_frame_t fr, ...) {
1770	va_list ap;
1771	guint16 maxbuddies, maxwatchers;
1772	struct im_connection *ic = sess->aux_data;
1773	struct oscar_data odata = (struct oscar_data )ic->proto_data;
1774
1775	va_start(ap, fr);
1776	maxbuddies = (guint16)va_arg(ap, unsigned int);
1777	maxwatchers = (guint16)va_arg(ap, unsigned int);
1778	va_end(ap);
1779
1780	odata->rights.maxbuddies = (guint)maxbuddies;
1781	odata->rights.maxwatchers = (guint)maxwatchers;
1782
1783	return 1;
1784	}
1785
1786	static int gaim_bosrights(aim_session_t sess, aim_frame_t fr, ...) {
1787	guint16 maxpermits, maxdenies;
1788	va_list ap;
1789	struct im_connection *ic = sess->aux_data;
1790	struct oscar_data odata = (struct oscar_data )ic->proto_data;
1791
1792	va_start(ap, fr);
1793	maxpermits = (guint16)va_arg(ap, unsigned int);
1794	maxdenies = (guint16)va_arg(ap, unsigned int);
1795	va_end(ap);
1796
1797	odata->rights.maxpermits = (guint)maxpermits;
1798	odata->rights.maxdenies = (guint)maxdenies;
1799
1800	aim_clientready(sess, fr->conn);
1801
1802	aim_reqservice(sess, fr->conn, AIM_CONN_TYPE_CHATNAV);
1803
1804	aim_ssi_reqrights(sess, fr->conn);
1805	aim_ssi_reqalldata(sess, fr->conn);
1806
1807	return 1;
1808	}
1809
1810	static int gaim_offlinemsg(aim_session_t sess, aim_frame_t fr, ...) {
1811	va_list ap;
1812	struct aim_icq_offlinemsg *msg;
1813	struct im_connection *ic = sess->aux_data;
1814
1815	va_start(ap, fr);
1816	msg = va_arg(ap, struct aim_icq_offlinemsg *);
1817	va_end(ap);
1818
1819	switch (msg->type) {
1820	case 0x0001: { /* Basic offline message */
1821	char sender[32];
1822	char *dialog_msg = g_strdup(msg->msg);
1823	time_t t = get_time(msg->year, msg->month, msg->day, msg->hour, msg->minute, 0);
1824	g_snprintf(sender, sizeof(sender), "%u", msg->sender);
1825	strip_linefeed(dialog_msg);
1826	imcb_buddy_msg(ic, normalize(sender), dialog_msg, 0, t);
1827	g_free(dialog_msg);
1828	} break;
1829
1830	case 0x0004: { /* Someone sent you a URL */
1831	char sender[32];
1832	char *dialog_msg;
1833	char **m;
1834
1835	time_t t = get_time(msg->year, msg->month, msg->day, msg->hour, msg->minute, 0);
1836	g_snprintf(sender, sizeof(sender), "%u", msg->sender);
1837
1838	m = g_strsplit(msg->msg, "\376", 2);
1839
1840	if ((strlen(m[0]) != 0)) {
1841	dialog_msg = g_strjoinv(" -- ", m);
1842	} else {
1843	dialog_msg = m[1];
1844	}
1845
1846	strip_linefeed(dialog_msg);
1847	imcb_buddy_msg(ic, normalize(sender), dialog_msg, 0, t);
1848	g_free(dialog_msg);
1849	g_free(m);
1850	} break;
1851
1852	case 0x0006: { /* Authorization request */
1853	gaim_icq_authask(ic, msg->sender, msg->msg);
1854	} break;
1855
1856	case 0x0007: { /* Someone has denied you authorization */
1857	imcb_log(sess->aux_data, "The user %u has denied your request to add them to your contact list for the following reason:\n%s", msg->sender, msg->msg ? msg->msg : _("No reason given.") );
1858	} break;
1859
1860	case 0x0008: { /* Someone has granted you authorization */
1861	imcb_log(sess->aux_data, "The user %u has granted your request to add them to your contact list for the following reason:\n%s", msg->sender, msg->msg ? msg->msg : _("No reason given.") );
1862	} break;
1863
1864	case 0x0012: {
1865	/* Ack for authorizing/denying someone. Or possibly an ack for sending any system notice */
1866	} break;
1867
1868	default: {;
1869	}
1870	}
1871
1872	return 1;
1873	}
1874
1875	static int gaim_offlinemsgdone(aim_session_t sess, aim_frame_t fr, ...)
1876	{
1877	aim_icq_ackofflinemsgs(sess);
1878	return 1;
1879	}
1880
1881	static void oscar_keepalive(struct im_connection *ic) {
1882	struct oscar_data odata = (struct oscar_data )ic->proto_data;
1883	aim_flap_nop(odata->sess, odata->conn);
1884	}
1885
1886	static int oscar_buddy_msg(struct im_connection ic, char name, char *message, int imflags) {
1887	struct oscar_data odata = (struct oscar_data )ic->proto_data;
1888	int ret = 0, len = strlen(message);
1889	if (imflags & OPT_AWAY) {
1890	ret = aim_send_im(odata->sess, name, AIM_IMFLAGS_AWAY, message);
1891	} else {
1892	struct aim_sendimext_args args;
1893	char *s;
1894
1895	args.flags = AIM_IMFLAGS_ACK;
1896	if (odata->icq)
1897	args.flags \|= AIM_IMFLAGS_OFFLINE;
1898	for (s = message; *s; s++)
1899	if (*s & 128)
1900	break;
1901
1902	/* Message contains high ASCII chars, time for some translation! */
1903	if (*s) {
1904	s = g_malloc(BUF_LONG);
1905	/* Try if we can put it in an ISO8859-1 string first.
1906	If we can't, fall back to UTF16. */
1907	if ((ret = do_iconv("UTF-8", "ISO8859-1", message, s, len, BUF_LONG)) >= 0) {
1908	args.flags \|= AIM_IMFLAGS_ISO_8859_1;
1909	len = ret;
1910	} else if ((ret = do_iconv("UTF-8", "UNICODEBIG", message, s, len, BUF_LONG)) >= 0) {
1911	args.flags \|= AIM_IMFLAGS_UNICODE;
1912	len = ret;
1913	} else {
1914	/* OOF, translation failed... Oh well.. */
1915	g_free( s );
1916	s = message;
1917	}
1918	} else {
1919	s = message;
1920	}
1921
1922	args.features = gaim_features;
1923	args.featureslen = sizeof(gaim_features);
1924
1925	args.destsn = name;
1926	args.msg = s;
1927	args.msglen = len;
1928
1929	ret = aim_send_im_ext(odata->sess, &args);
1930
1931	if (s != message) {
1932	g_free(s);
1933	}
1934	}
1935	if (ret >= 0)
1936	return 1;
1937	return ret;
1938	}
1939
1940	static void oscar_get_info(struct im_connection g, char name) {
1941	struct oscar_data odata = (struct oscar_data )g->proto_data;
1942	if (odata->icq)
1943	aim_icq_getallinfo(odata->sess, name);
1944	else {
1945	aim_getinfo(odata->sess, odata->conn, name, AIM_GETINFO_AWAYMESSAGE);
1946	aim_getinfo(odata->sess, odata->conn, name, AIM_GETINFO_GENERALINFO);
1947	}
1948	}
1949
1950	static void oscar_get_away(struct im_connection g, char who) {
1951	struct oscar_data odata = (struct oscar_data )g->proto_data;
1952	if (odata->icq) {
1953	/** FIXME(wilmer): Hmm, lost the ability to get away msgs here, do we care to get that back?
1954	struct buddy *budlight = imcb_find_buddy(g, who);
1955	if (budlight)
1956	if ((budlight->uc & 0xff80) >> 7)
1957	if (budlight->caps & AIM_CAPS_ICQSERVERRELAY)
1958	aim_send_im_ch2_geticqmessage(odata->sess, who, (budlight->uc & 0xff80) >> 7);
1959	*/
1960	} else
1961	aim_getinfo(odata->sess, odata->conn, who, AIM_GETINFO_AWAYMESSAGE);
1962	}
1963
1964	static void oscar_set_away_aim(struct im_connection ic, struct oscar_data od, const char state, const char message)
1965	{
1966	if (state == NULL)
1967	state = "";
1968
1969	if (!g_strcasecmp(state, _("Visible"))) {
1970	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_NORMAL);
1971	return;
1972	} else if (!g_strcasecmp(state, _("Invisible"))) {
1973	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_INVISIBLE);
1974	return;
1975	} else if (message == NULL) {
1976	message = state;
1977	}
1978
1979	if (od->rights.maxawaymsglen == 0)
1980	imcb_error(ic, "oscar_set_away_aim called before locate rights received");
1981
1982	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_NORMAL);
1983
1984	g_free(ic->away);
1985	ic->away = NULL;
1986
1987	if (!message) {
1988	aim_bos_setprofile(od->sess, od->conn, NULL, "", gaim_caps);
1989	return;
1990	}
1991
1992	if (strlen(message) > od->rights.maxawaymsglen) {
1993	imcb_error(ic, "Maximum away message length of %d bytes exceeded, truncating", od->rights.maxawaymsglen);
1994	}
1995
1996	ic->away = g_strndup(message, od->rights.maxawaymsglen);
1997	aim_bos_setprofile(od->sess, od->conn, NULL, ic->away, gaim_caps);
1998
1999	return;
2000	}
2001
2002	static void oscar_set_away_icq(struct im_connection ic, struct oscar_data od, const char state, const char message)
2003	{
2004	const char *msg = NULL;
2005	gboolean no_message = FALSE;
2006
2007	/* clean old states */
2008	g_free(ic->away);
2009	ic->away = NULL;
2010	od->sess->aim_icq_state = 0;
2011
2012	/* if no message, then use an empty message */
2013	if (message) {
2014	msg = message;
2015	} else {
2016	msg = "";
2017	no_message = TRUE;
2018	}
2019
2020	if (state == NULL) {
2021	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_NORMAL);
2022	} else if (!g_strcasecmp(state, "Away")) {
2023	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_AWAY);
2024	ic->away = g_strdup(msg);
2025	od->sess->aim_icq_state = AIM_MTYPE_AUTOAWAY;
2026	} else if (!g_strcasecmp(state, "Do Not Disturb")) {
2027	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_AWAY \| AIM_ICQ_STATE_DND \| AIM_ICQ_STATE_BUSY);
2028	ic->away = g_strdup(msg);
2029	od->sess->aim_icq_state = AIM_MTYPE_AUTODND;
2030	} else if (!g_strcasecmp(state, "Not Available")) {
2031	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_OUT \| AIM_ICQ_STATE_AWAY);
2032	ic->away = g_strdup(msg);
2033	od->sess->aim_icq_state = AIM_MTYPE_AUTONA;
2034	} else if (!g_strcasecmp(state, "Occupied")) {
2035	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_AWAY \| AIM_ICQ_STATE_BUSY);
2036	ic->away = g_strdup(msg);
2037	od->sess->aim_icq_state = AIM_MTYPE_AUTOBUSY;
2038	} else if (!g_strcasecmp(state, "Free For Chat")) {
2039	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_CHAT);
2040	ic->away = g_strdup(msg);
2041	od->sess->aim_icq_state = AIM_MTYPE_AUTOFFC;
2042	} else if (!g_strcasecmp(state, "Invisible")) {
2043	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_INVISIBLE);
2044	ic->away = g_strdup(msg);
2045	} else {
2046	if (no_message) {
2047	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_NORMAL);
2048	} else {
2049	aim_setextstatus(od->sess, od->conn, AIM_ICQ_STATE_AWAY);
2050	ic->away = g_strdup(msg);
2051	od->sess->aim_icq_state = AIM_MTYPE_AUTOAWAY;
2052	}
2053	}
2054
2055	return;
2056	}
2057
2058	static void oscar_set_away(struct im_connection ic, char state, char *message)
2059	{
2060	struct oscar_data od = (struct oscar_data )ic->proto_data;
2061
2062	oscar_set_away_aim(ic, od, state, message);
2063	if (od->icq)
2064	oscar_set_away_icq(ic, od, state, message);
2065
2066	return;
2067	}
2068
2069	static void oscar_add_buddy(struct im_connection g, char name, char *group) {
2070	struct oscar_data odata = (struct oscar_data )g->proto_data;
2071	aim_ssi_addbuddies(odata->sess, odata->conn, OSCAR_GROUP, &name, 1, 0);
2072	}
2073
2074	static void oscar_remove_buddy(struct im_connection g, char name, char *group) {
2075	struct oscar_data odata = (struct oscar_data )g->proto_data;
2076	struct aim_ssi_item *ssigroup;
2077	while ((ssigroup = aim_ssi_itemlist_findparent(odata->sess->ssi.items, name)) && !aim_ssi_delbuddies(odata->sess, odata->conn, ssigroup->name, &name, 1));
2078	}
2079
2080	static int gaim_ssi_parserights(aim_session_t sess, aim_frame_t fr, ...) {
2081	return 1;
2082	}
2083
2084	static int gaim_ssi_parselist(aim_session_t sess, aim_frame_t fr, ...) {
2085	struct im_connection *ic = sess->aux_data;
2086	struct aim_ssi_item *curitem;
2087	int tmp;
2088	char *nrm;
2089
2090	/* Add from server list to local list */
2091	tmp = 0;
2092	for (curitem=sess->ssi.items; curitem; curitem=curitem->next) {
2093	nrm = curitem->name ? normalize(curitem->name) : NULL;
2094
2095	switch (curitem->type) {
2096	case 0x0000: /* Buddy */
2097	if ((curitem->name) && (!imcb_buddy_by_handle(ic, nrm))) {
2098	char *realname = NULL;
2099
2100	if (curitem->data && aim_gettlv(curitem->data, 0x0131, 1))
2101	realname = aim_gettlv_str(curitem->data, 0x0131, 1);
2102
2103	imcb_add_buddy(ic, nrm, NULL);
2104
2105	if (realname) {
2106	imcb_buddy_nick_hint(ic, nrm, realname);
2107	imcb_rename_buddy(ic, nrm, realname);
2108	g_free(realname);
2109	}
2110	}
2111	break;
2112
2113	case 0x0002: /* Permit buddy */
2114	if (curitem->name) {
2115	GSList *list;
2116	for (list=ic->permit; (list && aim_sncmp(curitem->name, list->data)); list=list->next);
2117	if (!list) {
2118	char *name;
2119	name = g_strdup(nrm);
2120	ic->permit = g_slist_append(ic->permit, name);
2121	tmp++;
2122	}
2123	}
2124	break;
2125
2126	case 0x0003: /* Deny buddy */
2127	if (curitem->name) {
2128	GSList *list;
2129	for (list=ic->deny; (list && aim_sncmp(curitem->name, list->data)); list=list->next);
2130	if (!list) {
2131	char *name;
2132	name = g_strdup(nrm);
2133	ic->deny = g_slist_append(ic->deny, name);
2134	tmp++;
2135	}
2136	}
2137	break;
2138
2139	case 0x0004: /* Permit/deny setting */
2140	if (curitem->data) {
2141	guint8 permdeny;
2142	if ((permdeny = aim_ssi_getpermdeny(sess->ssi.items)) && (permdeny != ic->permdeny)) {
2143	ic->permdeny = permdeny;
2144	tmp++;
2145	}
2146	}
2147	break;
2148
2149	case 0x0005: /* Presence setting */
2150	/* We don't want to change Gaim's setting because it applies to all accounts */
2151	break;
2152	} /* End of switch on curitem->type */
2153	} /* End of for loop */
2154
2155	aim_ssi_enable(sess, fr->conn);
2156
2157	/* Request offline messages, now that the buddy list is complete. */
2158	aim_icq_reqofflinemsgs(sess);
2159
2160	/* Now that we have a buddy list, we can tell BitlBee that we're online. */
2161	imcb_connected(ic);
2162
2163	return 1;
2164	}
2165
2166	static int gaim_ssi_parseack( aim_session_t sess, aim_frame_t fr, ... )
2167	{
2168	aim_snac_t *origsnac;
2169	va_list ap;
2170
2171	va_start( ap, fr );
2172	origsnac = va_arg( ap, aim_snac_t * );
2173	va_end( ap );
2174
2175	if( origsnac && origsnac->family == AIM_CB_FAM_SSI && origsnac->type == AIM_CB_SSI_ADD && origsnac->data )
2176	{
2177	int i, st, count = aim_bstream_empty( &fr->data );
2178	char *list;
2179
2180	if( count & 1 )
2181	{
2182	/* Hmm, the length should be even... */
2183	imcb_error( sess->aux_data, "Received SSI ACK package with non-even length");
2184	return( 0 );
2185	}
2186	count >>= 1;
2187
2188	list = (char *) origsnac->data;
2189	for( i = 0; i < count; i ++ )
2190	{
2191	st = aimbs_get16( &fr->data );
2192	if( st == 0x00 )
2193	{
2194	imcb_add_buddy( sess->aux_data, normalize(list), NULL );
2195	}
2196	else if( st == 0x0E )
2197	{
2198	imcb_log( sess->aux_data, "Buddy %s can't be added without authorization, requesting authorization", list );
2199
2200	aim_ssi_auth_request( sess, fr->conn, list, "" );
2201	aim_ssi_addbuddies( sess, fr->conn, OSCAR_GROUP, &list, 1, 1 );
2202	}
2203	else
2204	{
2205	imcb_error( sess->aux_data, "Error while adding buddy: 0x%04x", st );
2206	}
2207	list += strlen( list ) + 1;
2208	}
2209	}
2210
2211	return( 1 );
2212	}
2213
2214	static void oscar_set_permit_deny(struct im_connection *ic) {
2215	struct oscar_data od = (struct oscar_data )ic->proto_data;
2216	if (od->icq) {
2217	GSList *list;
2218	char buf[MAXMSGLEN];
2219	int at;
2220
2221	switch(ic->permdeny) {
2222	case 1:
2223	aim_bos_changevisibility(od->sess, od->conn, AIM_VISIBILITYCHANGE_DENYADD, ic->acc->user);
2224	break;
2225	case 2:
2226	aim_bos_changevisibility(od->sess, od->conn, AIM_VISIBILITYCHANGE_PERMITADD, ic->acc->user);
2227	break;
2228	case 3:
2229	list = ic->permit;
2230	at = 0;
2231	while (list) {
2232	at += g_snprintf(buf + at, sizeof(buf) - at, "%s&", (char *)list->data);
2233	list = list->next;
2234	}
2235	aim_bos_changevisibility(od->sess, od->conn, AIM_VISIBILITYCHANGE_PERMITADD, buf);
2236	break;
2237	case 4:
2238	list = ic->deny;
2239	at = 0;
2240	while (list) {
2241	at += g_snprintf(buf + at, sizeof(buf) - at, "%s&", (char *)list->data);
2242	list = list->next;
2243	}
2244	aim_bos_changevisibility(od->sess, od->conn, AIM_VISIBILITYCHANGE_DENYADD, buf);
2245	break;
2246	default:
2247	break;
2248	}
2249	} else {
2250	if (od->sess->ssi.received_data)
2251	aim_ssi_setpermdeny(od->sess, od->conn, ic->permdeny, 0xffffffff);
2252	}
2253	}
2254
2255	static void oscar_add_permit(struct im_connection ic, char who) {
2256	struct oscar_data od = (struct oscar_data )ic->proto_data;
2257	if (od->icq) {
2258	aim_ssi_auth_reply(od->sess, od->conn, who, 1, "");
2259	} else {
2260	if (od->sess->ssi.received_data)
2261	aim_ssi_addpord(od->sess, od->conn, &who, 1, AIM_SSI_TYPE_PERMIT);
2262	}
2263	}
2264
2265	static void oscar_add_deny(struct im_connection ic, char who) {
2266	struct oscar_data od = (struct oscar_data )ic->proto_data;
2267	if (od->icq) {
2268	aim_ssi_auth_reply(od->sess, od->conn, who, 0, "");
2269	} else {
2270	if (od->sess->ssi.received_data)
2271	aim_ssi_addpord(od->sess, od->conn, &who, 1, AIM_SSI_TYPE_DENY);
2272	}
2273	}
2274
2275	static void oscar_rem_permit(struct im_connection ic, char who) {
2276	struct oscar_data od = (struct oscar_data )ic->proto_data;
2277	if (!od->icq) {
2278	if (od->sess->ssi.received_data)
2279	aim_ssi_delpord(od->sess, od->conn, &who, 1, AIM_SSI_TYPE_PERMIT);
2280	}
2281	}
2282
2283	static void oscar_rem_deny(struct im_connection ic, char who) {
2284	struct oscar_data od = (struct oscar_data )ic->proto_data;
2285	if (!od->icq) {
2286	if (od->sess->ssi.received_data)
2287	aim_ssi_delpord(od->sess, od->conn, &who, 1, AIM_SSI_TYPE_DENY);
2288	}
2289	}
2290
2291	static GList oscar_away_states(struct im_connection ic)
2292	{
2293	struct oscar_data *od = ic->proto_data;
2294
2295	if (od->icq) {
2296	static GList *m = NULL;
2297	m = g_list_append(m, "Away");
2298	m = g_list_append(m, "Do Not Disturb");
2299	m = g_list_append(m, "Not Available");
2300	m = g_list_append(m, "Occupied");
2301	m = g_list_append(m, "Free For Chat");
2302	m = g_list_append(m, "Invisible");
2303	return m;
2304	} else {
2305	static GList *m = NULL;
2306	m = g_list_append(m, "Away");
2307	return m;
2308	}
2309	}
2310
2311	static int gaim_icqinfo(aim_session_t sess, aim_frame_t fr, ...)
2312	{
2313	struct im_connection *ic = sess->aux_data;
2314	struct oscar_data *od = ic->proto_data;
2315	gchar who[16];
2316	GString *str;
2317	va_list ap;
2318	struct aim_icq_info *info;
2319	uint32_t ip;
2320
2321	va_start(ap, fr);
2322	info = va_arg(ap, struct aim_icq_info *);
2323	va_end(ap);
2324
2325	if (!info->uin)
2326	return 0;
2327
2328	str = g_string_sized_new(512);
2329	g_snprintf(who, sizeof(who), "%u", info->uin);
2330
2331	g_string_printf(str, "%s: %s - %s: %s", _("UIN"), who, _("Nick"),
2332	info->nick ? info->nick : "-");
2333	g_string_append_printf(str, "\n%s: %s", _("First Name"), info->first);
2334	g_string_append_printf(str, "\n%s: %s", _("Last Name"), info->last);
2335	g_string_append_printf(str, "\n%s: %s", _("Email Address"), info->email);
2336	if (info->numaddresses && info->email2) {
2337	int i;
2338	for (i = 0; i < info->numaddresses; i++) {
2339	g_string_append_printf(str, "\n%s: %s", _("Email Address"), info->email2[i]);
2340	}
2341	}
2342	if ((ip = (long) g_hash_table_lookup(od->ips, &info->uin)) != 0) {
2343	g_string_append_printf(str, "\n%s: %d.%d.%d.%d", _("Last used IP address"),
2344	(ip >> 24), (ip >> 16) & 0xff, (ip >> 8) & 0xff, ip & 0xff);
2345	}
2346	g_string_append_printf(str, "\n%s: %s", _("Mobile Phone"), info->mobile);
2347	if (info->gender != 0)
2348	g_string_append_printf(str, "\n%s: %s", _("Gender"), info->gender==1 ? _("Female") : _("Male"));
2349	if (info->birthyear \|\| info->birthmonth \|\| info->birthday) {
2350	char date[30];
2351	struct tm tm;
2352	memset(&tm, 0, sizeof(struct tm));
2353	tm.tm_mday = (int)info->birthday;
2354	tm.tm_mon = (int)info->birthmonth-1;
2355	tm.tm_year = (int)info->birthyear%100;
2356	strftime(date, sizeof(date), "%Y-%m-%d", &tm);
2357	g_string_append_printf(str, "\n%s: %s", _("Birthday"), date);
2358	}
2359	if (info->age) {
2360	char age[5];
2361	g_snprintf(age, sizeof(age), "%hhd", info->age);
2362	g_string_append_printf(str, "\n%s: %s", _("Age"), age);
2363	}
2364	g_string_append_printf(str, "\n%s: %s", _("Personal Web Page"), info->personalwebpage);
2365	if (info->info && info->info[0]) {
2366	g_string_sprintfa(str, "\n%s:\n%s\n%s", _("Additional Information"),
2367	info->info, _("End of Additional Information"));
2368	}
2369	g_string_append_c(str, '\n');
2370	if ((info->homeaddr && (info->homeaddr[0])) \|\| (info->homecity && info->homecity[0]) \|\| (info->homestate && info->homestate[0]) \|\| (info->homezip && info->homezip[0])) {
2371	g_string_append_printf(str, "%s:", _("Home Address"));
2372	g_string_append_printf(str, "\n%s: %s", _("Address"), info->homeaddr);
2373	g_string_append_printf(str, "\n%s: %s", _("City"), info->homecity);
2374	g_string_append_printf(str, "\n%s: %s", _("State"), info->homestate);
2375	g_string_append_printf(str, "\n%s: %s", _("Zip Code"), info->homezip);
2376	g_string_append_c(str, '\n');
2377	}
2378	if ((info->workaddr && info->workaddr[0]) \|\| (info->workcity && info->workcity[0]) \|\| (info->workstate && info->workstate[0]) \|\| (info->workzip && info->workzip[0])) {
2379	g_string_append_printf(str, "%s:", _("Work Address"));
2380	g_string_append_printf(str, "\n%s: %s", _("Address"), info->workaddr);
2381	g_string_append_printf(str, "\n%s: %s", _("City"), info->workcity);
2382	g_string_append_printf(str, "\n%s: %s", _("State"), info->workstate);
2383	g_string_append_printf(str, "\n%s: %s", _("Zip Code"), info->workzip);
2384	g_string_append_c(str, '\n');
2385	}
2386	if ((info->workcompany && info->workcompany[0]) \|\| (info->workdivision && info->workdivision[0]) \|\| (info->workposition && info->workposition[0]) \|\| (info->workwebpage && info->workwebpage[0])) {
2387	g_string_append_printf(str, "%s:", _("Work Information"));
2388	g_string_append_printf(str, "\n%s: %s", _("Company"), info->workcompany);
2389	g_string_append_printf(str, "\n%s: %s", _("Division"), info->workdivision);
2390	g_string_append_printf(str, "\n%s: %s", _("Position"), info->workposition);
2391	if (info->workwebpage && info->workwebpage[0]) {
2392	g_string_append_printf(str, "\n%s: %s", _("Web Page"), info->workwebpage);
2393	}
2394	g_string_append_c(str, '\n');
2395	}
2396
2397	imcb_log(ic, "%s\n%s", _("User Info"), str->str);
2398	g_string_free(str, TRUE);
2399
2400	return 1;
2401
2402	}
2403
2404	static char oscar_encoding_extract(const char encoding)
2405	{
2406	char *ret = NULL;
2407	char begin, end;
2408
2409	g_return_val_if_fail(encoding != NULL, NULL);
2410
2411	/* Make sure encoding begins with charset= */
2412	if (strncmp(encoding, "text/plain; charset=", 20) &&
2413	strncmp(encoding, "text/aolrtf; charset=", 21) &&
2414	strncmp(encoding, "text/x-aolrtf; charset=", 23))
2415	{
2416	return NULL;
2417	}
2418
2419	begin = strchr(encoding, '"');
2420	end = strrchr(encoding, '"');
2421
2422	if ((begin == NULL) \|\| (end == NULL) \|\| (begin >= end))
2423	return NULL;
2424
2425	ret = g_strndup(begin+1, (end-1) - begin);
2426
2427	return ret;
2428	}
2429
2430	static char oscar_encoding_to_utf8(char encoding, char *text, int textlen)
2431	{
2432	char *utf8 = g_new0(char, 8192);
2433
2434	if ((encoding == NULL) \|\| encoding[0] == '\0') {
2435	/* gaim_debug_info("oscar", "Empty encoding, assuming UTF-8\n");*/
2436	} else if (!g_strcasecmp(encoding, "iso-8859-1")) {
2437	do_iconv("iso-8859-1", "UTF-8", text, utf8, textlen, 8192);
2438	} else if (!g_strcasecmp(encoding, "ISO-8859-1-Windows-3.1-Latin-1")) {
2439	do_iconv("Windows-1252", "UTF-8", text, utf8, textlen, 8192);
2440	} else if (!g_strcasecmp(encoding, "unicode-2-0")) {
2441	do_iconv("UCS-2BE", "UTF-8", text, utf8, textlen, 8192);
2442	} else if (g_strcasecmp(encoding, "us-ascii") && strcmp(encoding, "utf-8")) {
2443	/* gaim_debug_warning("oscar", "Unrecognized character encoding \"%s\", "
2444	"attempting to convert to UTF-8 anyway\n", encoding);*/
2445	do_iconv(encoding, "UTF-8", text, utf8, textlen, 8192);
2446	}
2447
2448	/*
2449	* If utf8 is still NULL then either the encoding is us-ascii/utf-8 or
2450	* we have been unable to convert the text to utf-8 from the encoding
2451	* that was specified. So we assume it's UTF-8 and hope for the best.
2452	*/
2453	if (*utf8 == 0) {
2454	strncpy(utf8, text, textlen);
2455	}
2456
2457	return utf8;
2458	}
2459
2460	static int gaim_parseaiminfo(aim_session_t sess, aim_frame_t fr, ...)
2461	{
2462	struct im_connection *ic = sess->aux_data;
2463	va_list ap;
2464	aim_userinfo_t *userinfo;
2465	guint16 infotype;
2466	char text_encoding = NULL, text = NULL, *extracted_encoding = NULL;
2467	guint16 text_length;
2468	char *utf8 = NULL;
2469
2470	va_start(ap, fr);
2471	userinfo = va_arg(ap, aim_userinfo_t *);
2472	infotype = va_arg(ap, int);
2473	text_encoding = va_arg(ap, char*);
2474	text = va_arg(ap, char*);
2475	text_length = va_arg(ap, int);
2476	va_end(ap);
2477
2478	if(text_encoding)
2479	extracted_encoding = oscar_encoding_extract(text_encoding);
2480	if(infotype == AIM_GETINFO_GENERALINFO) {
2481	/Display idle time/
2482	char buff[256];
2483	struct tm idletime;
2484	if(userinfo->idletime) {
2485	memset(&idletime, 0, sizeof(struct tm));
2486	idletime.tm_mday = (userinfo->idletime / 60) / 24;
2487	idletime.tm_hour = (userinfo->idletime / 60) % 24;
2488	idletime.tm_min = userinfo->idletime % 60;
2489	idletime.tm_sec = 0;
2490	strftime(buff, 256, _("%d days %H hours %M minutes"), &idletime);
2491	imcb_log(ic, "%s: %s", _("Idle Time"), buff);
2492	}
2493
2494	if(text) {
2495	utf8 = oscar_encoding_to_utf8(extracted_encoding, text, text_length);
2496	imcb_log(ic, "%s\n%s", _("User Info"), utf8);
2497	} else {
2498	imcb_log(ic, _("No user info available."));
2499	}
2500	} else if(infotype == AIM_GETINFO_AWAYMESSAGE && userinfo->flags & AIM_FLAG_AWAY) {
2501	utf8 = oscar_encoding_to_utf8(extracted_encoding, text, text_length);
2502	imcb_log(ic, "%s\n%s", _("Away Message"), utf8);
2503	}
2504
2505	g_free(utf8);
2506
2507	return 1;
2508	}
2509
2510	int gaim_parsemtn(aim_session_t sess, aim_frame_t fr, ...)
2511	{
2512	struct im_connection * ic = sess->aux_data;
2513	va_list ap;
2514	guint16 type1, type2;
2515	char * sn;
2516
2517	va_start(ap, fr);
2518	type1 = va_arg(ap, int);
2519	sn = va_arg(ap, char*);
2520	type2 = va_arg(ap, int);
2521	va_end(ap);
2522
2523	if(type2 == 0x0002) {
2524	/* User is typing */
2525	imcb_buddy_typing(ic, normalize(sn), OPT_TYPING);
2526	}
2527	else if (type2 == 0x0001) {
2528	/* User has typed something, but is not actively typing (stale) */
2529	imcb_buddy_typing(ic, normalize(sn), OPT_THINKING);
2530	}
2531	else {
2532	/* User has stopped typing */
2533	imcb_buddy_typing(ic, normalize(sn), 0);
2534	}
2535
2536	return 1;
2537	}
2538
2539	int oscar_send_typing(struct im_connection ic, char who, int typing)
2540	{
2541	struct oscar_data *od = ic->proto_data;
2542	return( aim_im_sendmtn(od->sess, 1, who, (typing & OPT_TYPING) ? 0x0002 : 0x0000) );
2543	}
2544
2545	void oscar_chat_msg(struct groupchat c, char message, int msgflags)
2546	{
2547	struct im_connection *ic = c->ic;
2548	struct oscar_data * od = (struct oscar_data*)ic->proto_data;
2549	struct chat_connection * ccon;
2550	int ret;
2551	guint8 len = strlen(message);
2552	guint16 flags;
2553	char *s;
2554
2555	ccon = c->data;
2556
2557	for (s = message; *s; s++)
2558	if (*s & 128)
2559	break;
2560
2561	flags = AIM_CHATFLAGS_NOREFLECT;
2562
2563	/* Message contains high ASCII chars, time for some translation! */
2564	if (*s) {
2565	s = g_malloc(BUF_LONG);
2566	/* Try if we can put it in an ISO8859-1 string first.
2567	If we can't, fall back to UTF16. */
2568	if ((ret = do_iconv("UTF-8", "ISO8859-1", message, s, len, BUF_LONG)) >= 0) {
2569	flags \|= AIM_CHATFLAGS_ISO_8859_1;
2570	len = ret;
2571	} else if ((ret = do_iconv("UTF-8", "UNICODEBIG", message, s, len, BUF_LONG)) >= 0) {
2572	flags \|= AIM_CHATFLAGS_UNICODE;
2573	len = ret;
2574	} else {
2575	/* OOF, translation failed... Oh well.. */
2576	g_free( s );
2577	s = message;
2578	}
2579	} else {
2580	s = message;
2581	}
2582
2583	ret = aim_chat_send_im(od->sess, ccon->conn, flags, s, len);
2584
2585	if (s != message) {
2586	g_free(s);
2587	}
2588
2589	/* return (ret >= 0); */
2590	}
2591
2592	void oscar_chat_invite(struct groupchat c, char who, char *message)
2593	{
2594	struct im_connection *ic = c->ic;
2595	struct oscar_data * od = (struct oscar_data *)ic->proto_data;
2596	struct chat_connection *ccon = c->data;
2597
2598	aim_chat_invite(od->sess, od->conn, who, message ? message : "",
2599	ccon->exchange, ccon->name, 0x0);
2600	}
2601
2602	void oscar_chat_kill(struct im_connection ic, struct chat_connection cc)
2603	{
2604	struct oscar_data od = (struct oscar_data )ic->proto_data;
2605
2606	/* Notify the conversation window that we've left the chat */
2607	imcb_chat_free(cc->cnv);
2608
2609	/* Destroy the chat_connection */
2610	od->oscar_chats = g_slist_remove(od->oscar_chats, cc);
2611	if (cc->inpa > 0)
2612	b_event_remove(cc->inpa);
2613	aim_conn_kill(od->sess, &cc->conn);
2614	g_free(cc->name);
2615	g_free(cc->show);
2616	g_free(cc);
2617	}
2618
2619	void oscar_chat_leave(struct groupchat *c)
2620	{
2621	oscar_chat_kill(c->ic, c->data);
2622	}
2623
2624	struct groupchat oscar_chat_join(struct im_connection ic, const char * room, const char * nick, const char * password )
2625	{
2626	struct oscar_data * od = (struct oscar_data *)ic->proto_data;
2627	aim_conn_t * cur;
2628
2629	if((cur = aim_getconn_type(od->sess, AIM_CONN_TYPE_CHATNAV))) {
2630	int st;
2631
2632	st = aim_chatnav_createroom(od->sess, cur, room, 4);
2633
2634	return NULL;
2635	} else {
2636	struct create_room * cr = g_new0(struct create_room, 1);
2637
2638	cr->exchange = 4;
2639	cr->name = g_strdup(room);
2640	od->create_rooms = g_slist_append(od->create_rooms, cr);
2641	aim_reqservice(od->sess, od->conn, AIM_CONN_TYPE_CHATNAV);
2642
2643	return NULL;
2644	}
2645	}
2646
2647	struct groupchat oscar_chat_with(struct im_connection ic, char *who)
2648	{
2649	struct oscar_data * od = (struct oscar_data *)ic->proto_data;
2650	struct groupchat *ret;
2651	static int chat_id = 0;
2652	char * chatname;
2653
2654	chatname = g_strdup_printf("%s%d", ic->acc->user, chat_id++);
2655
2656	ret = oscar_chat_join(ic, chatname, NULL, NULL);
2657
2658	aim_chat_invite(od->sess, od->conn, who, "", 4, chatname, 0x0);
2659
2660	g_free(chatname);
2661
2662	return NULL;
2663	}
2664
2665	void oscar_accept_chat(void *data)
2666	{
2667	struct aim_chat_invitation * inv = data;
2668
2669	oscar_chat_join(inv->ic, inv->name, NULL, NULL);
2670	g_free(inv->name);
2671	g_free(inv);
2672	}
2673
2674	void oscar_reject_chat(void *data)
2675	{
2676	struct aim_chat_invitation * inv = data;
2677
2678	g_free(inv->name);
2679	g_free(inv);
2680	}
2681
2682	void oscar_initmodule()
2683	{
2684	struct prpl *ret = g_new0(struct prpl, 1);
2685	ret->name = "oscar";
2686	ret->away_states = oscar_away_states;
2687	ret->init = oscar_init;
2688	ret->login = oscar_login;
2689	ret->keepalive = oscar_keepalive;
2690	ret->logout = oscar_logout;
2691	ret->buddy_msg = oscar_buddy_msg;
2692	ret->get_info = oscar_get_info;
2693	ret->set_away = oscar_set_away;
2694	ret->get_away = oscar_get_away;
2695	ret->add_buddy = oscar_add_buddy;
2696	ret->remove_buddy = oscar_remove_buddy;
2697	ret->chat_msg = oscar_chat_msg;
2698	ret->chat_invite = oscar_chat_invite;
2699	ret->chat_leave = oscar_chat_leave;
2700	ret->chat_with = oscar_chat_with;
2701	ret->chat_join = oscar_chat_join;
2702	ret->add_permit = oscar_add_permit;
2703	ret->add_deny = oscar_add_deny;
2704	ret->rem_permit = oscar_rem_permit;
2705	ret->rem_deny = oscar_rem_deny;
2706	ret->set_permit_deny = oscar_set_permit_deny;
2707	ret->send_typing = oscar_send_typing;
2708
2709	ret->handle_cmp = aim_sncmp;
2710
2711	register_protocol(ret);
2712	}

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

Download in other formats: