Context Navigation

source: protocols/oscar/oscar.c @ d3307e2

Last change on this file since d3307e2 was 66c57924, checked in by Jelmer Vernooij <jelmer@…>, at 2005-11-20T16:09:23Z
Remove OFT and rendez-vous support (not used anyway and implemented in a way too complicated way)
Property mode set to `100644`
File size: 71.7 KB

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

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

Download in other formats: