src/misc.c


/*
 * aim_misc.c
 *
 * TODO: Seperate a lot of this into an aim_bos.c.
 *
 * Other things...
 *
 *   - Idle setting
 *
 *
 */

#define FAIM_INTERNAL
#include <aim.h>

/*
 * aim_bos_setidle()
 *
 *  Should set your current idle time in seconds.  Idealy, OSCAR should
 *  do this for us.  But, it doesn't.  The client must call this to set idle
 *  time.
 *
 */
faim_export int aim_bos_setidle(aim_session_t *sess, aim_conn_t *conn, fu32_t idletime)
{
	return aim_genericreq_l(sess, conn, 0x0001, 0x0011, &idletime);
}


/*
 * aim_bos_changevisibility(conn, changtype, namelist)
 *
 * Changes your visibility depending on changetype:
 *
 *  AIM_VISIBILITYCHANGE_PERMITADD: Lets provided list of names see you
 *  AIM_VISIBILITYCHANGE_PERMIDREMOVE: Removes listed names from permit list
 *  AIM_VISIBILITYCHANGE_DENYADD: Hides you from provided list of names
 *  AIM_VISIBILITYCHANGE_DENYREMOVE: Lets list see you again
 *
 * list should be a list of
 * screen names in the form "Screen Name One&ScreenNameTwo&" etc.
 *
 * Equivelents to options in WinAIM:
 *   - Allow all users to contact me: Send an AIM_VISIBILITYCHANGE_DENYADD
 *      with only your name on it.
 *   - Allow only users on my Buddy List: Send an
 *      AIM_VISIBILITYCHANGE_PERMITADD with the list the same as your
 *      buddy list
 *   - Allow only the uesrs below: Send an AIM_VISIBILITYCHANGE_PERMITADD
 *      with everyone listed that you want to see you.
 *   - Block all users: Send an AIM_VISIBILITYCHANGE_PERMITADD with only
 *      yourself in the list
 *   - Block the users below: Send an AIM_VISIBILITYCHANGE_DENYADD with
 *      the list of users to be blocked
 *
 * XXX ye gods.
 */
faim_export int aim_bos_changevisibility(aim_session_t *sess, aim_conn_t *conn, int changetype, const char *denylist)
{
	aim_frame_t *fr;
	int packlen = 0;
	fu16_t subtype;
	char *localcpy = NULL, *tmpptr = NULL;
	int i;
	int listcount;
	aim_snacid_t snacid;

	if (!denylist)
		return -EINVAL;

	if (changetype == AIM_VISIBILITYCHANGE_PERMITADD)
		subtype = 0x05;
	else if (changetype == AIM_VISIBILITYCHANGE_PERMITREMOVE)
		subtype = 0x06;
	else if (changetype == AIM_VISIBILITYCHANGE_DENYADD)
		subtype = 0x07;
	else if (changetype == AIM_VISIBILITYCHANGE_DENYREMOVE)
		subtype = 0x08;
	else
		return -EINVAL;

	localcpy = strdup(denylist);

	listcount = aimutil_itemcnt(localcpy, '&');
	packlen = aimutil_tokslen(localcpy, 99, '&') + listcount + 9;

	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, packlen))) {
		free(localcpy);
		return -ENOMEM;
	}

	snacid = aim_cachesnac(sess, 0x0009, subtype, 0x0000, NULL, 0);
	aim_putsnac(&fr->data, 0x0009, subtype, 0x00, snacid);

	for (i = 0; (i < (listcount - 1)) && (i < 99); i++) {
		tmpptr = aimutil_itemidx(localcpy, i, '&');

		aimbs_put8(&fr->data, strlen(tmpptr));
		aimbs_putraw(&fr->data, tmpptr, strlen(tmpptr));

		free(tmpptr);
	}
	free(localcpy);

	aim_tx_enqueue(sess, fr);

	return 0;
}


/*
 * aim_bos_setbuddylist(buddylist)
 *
 * This just builds the "set buddy list" command then queues it.
 *
 * buddy_list = "Screen Name One&ScreenNameTwo&";
 *
 * TODO: Clean this up.
 *
 * XXX: I can't stress the TODO enough.
 *
 */
faim_export int aim_bos_setbuddylist(aim_session_t *sess, aim_conn_t *conn, const char *buddy_list)
{
	aim_frame_t *fr;
	aim_snacid_t snacid;
	int i, len = 0;
	char *localcpy = NULL;
	char *tmpptr = NULL;

	if (!buddy_list || !(localcpy = strdup(buddy_list)))
		return -EINVAL;

	i = 0;
	tmpptr = strtok(localcpy, "&");
	while ((tmpptr != NULL) && (i < 150)) {
		faimdprintf(sess, 2, "---adding %d: %s (%d)\n", i, tmpptr, strlen(tmpptr));
		len += 1+strlen(tmpptr);
		i++;
		tmpptr = strtok(NULL, "&");
	}

	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+len)))
		return -ENOMEM;

	snacid = aim_cachesnac(sess, 0x0003, 0x0004, 0x0000, NULL, 0);

	aim_putsnac(&fr->data, 0x0003, 0x0004, 0x0000, snacid);

	strncpy(localcpy, buddy_list, strlen(buddy_list)+1);
	i = 0;
	tmpptr = strtok(localcpy, "&");
	while ((tmpptr != NULL) & (i < 150)) {
		faimdprintf(sess, 2, "---adding %d: %s (%d)\n", i, tmpptr, strlen(tmpptr));

		aimbs_put8(&fr->data, strlen(tmpptr));
		aimbs_putraw(&fr->data, tmpptr, strlen(tmpptr));
		i++;
		tmpptr = strtok(NULL, "&");
	}

	aim_tx_enqueue(sess, fr);

	free(localcpy);

	return 0;
}

/*
 * aim_bos_setprofile(profile)
 *
 * Gives BOS your profile.
 *
 *
 */
faim_export int aim_bos_setprofile(aim_session_t *sess, aim_conn_t *conn, const char *profile, const char *awaymsg, fu16_t caps)
{
	static const char defencoding[] = {"text/aolrtf; charset=\"us-ascii\""};
	aim_frame_t *fr;
	aim_tlvlist_t *tl = NULL;
	aim_snacid_t snacid;

	/* Build to packet first to get real length */
	if (profile) {
		aim_addtlvtochain_raw(&tl, 0x0001, strlen(defencoding), defencoding);
		aim_addtlvtochain_raw(&tl, 0x0002, strlen(profile), profile);
	}

	if (awaymsg) {
		aim_addtlvtochain_raw(&tl, 0x0003, strlen(defencoding), defencoding);
		aim_addtlvtochain_raw(&tl, 0x0004, strlen(awaymsg), awaymsg);
	}

	aim_addtlvtochain_caps(&tl, 0x0005, caps);

	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10 + aim_sizetlvchain(&tl))))
		return -ENOMEM;

	snacid = aim_cachesnac(sess, 0x0002, 0x0004, 0x0000, NULL, 0);

	aim_putsnac(&fr->data, 0x0002, 0x004, 0x0000, snacid);
	aim_writetlvchain(&fr->data, &tl);
	aim_freetlvchain(&tl);

	aim_tx_enqueue(sess, fr);

	return 0;
}

/*
 * aim_bos_clientready()
 *
 * Send Client Ready.
 *
 */
faim_export int aim_bos_clientready(aim_session_t *sess, aim_conn_t *conn)
{
	struct aim_tool_version tools[] = {
		{0x0001, 0x0003,    AIM_TOOL_WIN32, 0x0686},
		{0x0002, 0x0001,    AIM_TOOL_WIN32, 0x0001},
		{0x0003, 0x0001,    AIM_TOOL_WIN32, 0x0001},
		{0x0004, 0x0001,    AIM_TOOL_WIN32, 0x0001},
		{0x0006, 0x0001,    AIM_TOOL_WIN32, 0x0001},
		{0x0008, 0x0001,    AIM_TOOL_WIN32, 0x0001},
		{0x0009, 0x0001,    AIM_TOOL_WIN32, 0x0001},
		{0x000a, 0x0001,    AIM_TOOL_WIN32, 0x0001},
		{0x000b, 0x0001,    AIM_TOOL_WIN32, 0x0001}
	};
	int j;
	aim_frame_t *fr;
	aim_snacid_t snacid;
	int toolcount = sizeof(tools)/sizeof(struct aim_tool_version);

	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 1152)))
		return -ENOMEM;

	snacid = aim_cachesnac(sess, 0x0001, 0x0002, 0x0000, NULL, 0);
	aim_putsnac(&fr->data, 0x0001, 0x0002, 0x0000, snacid);

	for (j = 0; j < toolcount; j++) {
		aimbs_put16(&fr->data, tools[j].group);
		aimbs_put16(&fr->data, tools[j].version);
		aimbs_put16(&fr->data, tools[j].tool);
		aimbs_put16(&fr->data, tools[j].toolversion);
	}

	aim_tx_enqueue(sess, fr);

	return 0;
}

/*
 *  Request Rate Information.
 *
 */
faim_export int aim_bos_reqrate(aim_session_t *sess, aim_conn_t *conn)
{
	return aim_genericreq_n(sess, conn, 0x0001, 0x0006);
}

/*
 *  Rate Information Response Acknowledge.
 *
 */
faim_export int aim_bos_ackrateresp(aim_session_t *sess, aim_conn_t *conn)
{
	aim_frame_t *fr;
	aim_snacid_t snacid;

	if(!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+10)))
		return -ENOMEM;

	snacid = aim_cachesnac(sess, 0x0001, 0x0008, 0x0000, NULL, 0);

	aim_putsnac(&fr->data, 0x0001, 0x0008, 0x0000, snacid);
	aimbs_put16(&fr->data, 0x0001);
	aimbs_put16(&fr->data, 0x0002);
	aimbs_put16(&fr->data, 0x0003);
	aimbs_put16(&fr->data, 0x0004);
	aimbs_put16(&fr->data, 0x0005);

	aim_tx_enqueue(sess, fr);

	return 0;
}

/*
 * aim_bos_setprivacyflags()
 *
 * Sets privacy flags. Normally 0x03.
 *
 *  Bit 1:  Allows other AIM users to see how long you've been idle.
 *  Bit 2:  Allows other AIM users to see how long you've been a member.
 *
 */
faim_export int aim_bos_setprivacyflags(aim_session_t *sess, aim_conn_t *conn, fu32_t flags)
{
	return aim_genericreq_l(sess, conn, 0x0001, 0x0014, &flags);
}

/*
 * aim_bos_reqpersonalinfo()
 *
 */
faim_export int aim_bos_reqpersonalinfo(aim_session_t *sess, aim_conn_t *conn)
{
	return aim_genericreq_n(sess, conn, 0x0001, 0x000e);
}

faim_export int aim_setversions(aim_session_t *sess, aim_conn_t *conn)
{
	aim_frame_t *fr;
	aim_snacid_t snacid;
	static const struct version {
		fu16_t group;
		fu16_t version;
	} versions[] = {
		{0x0001, 0x0003},
		{0x0002, 0x0001},
		{0x0003, 0x0001},
		{0x0004, 0x0001},
		{0x0006, 0x0001},
		{0x0008, 0x0001},
		{0x0009, 0x0001},
		{0x000a, 0x0001},
		{0x000b, 0x0002},
		{0x000c, 0x0001},
		{0x0013, 0x0001},
		{0x0015, 0x0001},
	};
	int numversions = sizeof(versions) / sizeof(struct version);
	int i;

	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10 + (4*numversions))))
		return -ENOMEM;

	snacid = aim_cachesnac(sess, 0x0001, 0x0017, 0x0000, NULL, 0);

	aim_putsnac(&fr->data, 0x0001, 0x0017, 0x0000, snacid);
	for (i = 0; i < numversions; i++) {
		aimbs_put16(&fr->data, versions[i].group);
		aimbs_put16(&fr->data, versions[i].version);
	}

	aim_tx_enqueue(sess, fr);

	return 0;
}


/*
 * aim_bos_reqservice(serviceid)
 *
 * Service request.
 *
 */
faim_export int aim_bos_reqservice(aim_session_t *sess, aim_conn_t *conn, fu16_t serviceid)
{
	return aim_genericreq_s(sess, conn, 0x0001, 0x0004, &serviceid);
}

/*
 * aim_bos_nop()
 *
 * No-op.  WinAIM sends these every 4min or so to keep
 * the connection alive.  Its not real necessary.
 *
 */
faim_export int aim_bos_nop(aim_session_t *sess, aim_conn_t *conn)
{
	return aim_genericreq_n(sess, conn, 0x0001, 0x0016);
}

/*
 * aim_flap_nop()
 *
 * No-op.  WinAIM 4.x sends these _every minute_ to keep
 * the connection alive.
 */
faim_export int aim_flap_nop(aim_session_t *sess, aim_conn_t *conn)
{
	aim_frame_t *fr;

	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x05, 0)))
		return -ENOMEM;

	aim_tx_enqueue(sess, fr);

	return 0;
}

/*
 * aim_bos_reqrights()
 *
 * Request BOS rights.
 *
 */
faim_export int aim_bos_reqrights(aim_session_t *sess, aim_conn_t *conn)
{
	return aim_genericreq_n(sess, conn, 0x0009, 0x0002);
}

/*
 * aim_bos_reqbuddyrights()
 *
 * Request Buddy List rights.
 *
 */
faim_export int aim_bos_reqbuddyrights(aim_session_t *sess, aim_conn_t *conn)
{
	return aim_genericreq_n(sess, conn, 0x0003, 0x0002);
}

/*
 * Send a warning to destsn.
 *
 * Flags:
 *  AIM_WARN_ANON  Send as an anonymous (doesn't count as much)
 *
 * returns -1 on error (couldn't alloc packet), 0 on success.
 *
 */
faim_export int aim_send_warning(aim_session_t *sess, aim_conn_t *conn, const char *destsn, fu32_t flags)
{
	aim_frame_t *fr;
	aim_snacid_t snacid;
	fu16_t outflags = 0x0000;

	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, strlen(destsn)+13)))
		return -ENOMEM;

	snacid = aim_cachesnac(sess, 0x0004, 0x0008, 0x0000, destsn, strlen(destsn)+1);

	aim_putsnac(&fr->data, 0x0004, 0x0008, 0x0000, snacid);

	if (flags & AIM_WARN_ANON)
		outflags |= 0x0001;

	aimbs_put16(&fr->data, outflags);
	aimbs_put8(&fr->data, strlen(destsn));
	aimbs_putraw(&fr->data, destsn, strlen(destsn));

	aim_tx_enqueue(sess, fr);

	return 0;
}

/*
 * aim_debugconn_sendconnect()
 *
 * For aimdebugd.  If you don't know what it is, you don't want to.
 */
faim_export int aim_debugconn_sendconnect(aim_session_t *sess, aim_conn_t *conn)
{
	return aim_genericreq_n(sess, conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_DEBUGCONN_CONNECT);
}

/*
 * Generic routine for sending commands.
 *
 *
 * I know I can do this in a smarter way...but I'm not thinking straight
 * right now...
 *
 * I had one big function that handled all three cases, but then it broke
 * and I split it up into three.  But then I fixed it.  I just never went
 * back to the single.  I don't see any advantage to doing it either way.
 *
 */
faim_internal int aim_genericreq_n(aim_session_t *sess, aim_conn_t *conn, fu16_t family, fu16_t subtype)
{
	aim_frame_t *fr;
	aim_snacid_t snacid = 0x00000000;

	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10)))
		return -ENOMEM;

	aim_putsnac(&fr->data, family, subtype, 0x0000, snacid);

	aim_tx_enqueue(sess, fr);

	return 0;
}

faim_internal int aim_genericreq_n_snacid(aim_session_t *sess, aim_conn_t *conn, fu16_t family, fu16_t subtype)
{
	aim_frame_t *fr;
	aim_snacid_t snacid;

	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10)))
		return -ENOMEM;

	snacid = aim_cachesnac(sess, family, subtype, 0x0000, NULL, 0);
	aim_putsnac(&fr->data, family, subtype, 0x0000, snacid);

	aim_tx_enqueue(sess, fr);

	return 0;
}

/*
 *
 *
 */
faim_internal int aim_genericreq_l(aim_session_t *sess, aim_conn_t *conn, fu16_t family, fu16_t subtype, fu32_t *longdata)
{
	aim_frame_t *fr;
	aim_snacid_t snacid;

	if (!longdata)
		return aim_genericreq_n(sess, conn, family, subtype);

	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+4)))
		return -ENOMEM;

	snacid = aim_cachesnac(sess, family, subtype, 0x0000, NULL, 0);

	aim_putsnac(&fr->data, family, subtype, 0x0000, snacid);
	aimbs_put32(&fr->data, *longdata);

	aim_tx_enqueue(sess, fr);

	return 0;
}

faim_internal int aim_genericreq_s(aim_session_t *sess, aim_conn_t *conn, fu16_t family, fu16_t subtype, fu16_t *shortdata)
{
	aim_frame_t *fr;
	aim_snacid_t snacid;

	if (!shortdata)
		return aim_genericreq_n(sess, conn, family, subtype);

	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+2)))
		return -ENOMEM;

	snacid = aim_cachesnac(sess, family, subtype, 0x0000, NULL, 0);

	aim_putsnac(&fr->data, family, subtype, 0x0000, snacid);
	aimbs_put16(&fr->data, *shortdata);

	aim_tx_enqueue(sess, fr);

	return 0;
}

/*
 * aim_bos_reqlocaterights()
 *
 * Request Location services rights.
 *
 */
faim_export int aim_bos_reqlocaterights(aim_session_t *sess, aim_conn_t *conn)
{
	return aim_genericreq_n(sess, conn, 0x0002, 0x0002);
}

/*
 * Set directory profile data (not the same as aim_bos_setprofile!)
 *
 * privacy: 1 to allow searching, 0 to disallow.
 */
faim_export int aim_setdirectoryinfo(aim_session_t *sess, aim_conn_t *conn, const char *first, const char *middle, const char *last, const char *maiden, const char *nickname, const char *street, const char *city, const char *state, const char *zip, int country, fu16_t privacy)
{
	aim_frame_t *fr;
	aim_snacid_t snacid;
	aim_tlvlist_t *tl = NULL;


	aim_addtlvtochain16(&tl, 0x000a, privacy);

	if (first)
		aim_addtlvtochain_raw(&tl, 0x0001, strlen(first), first);
	if (last)
		aim_addtlvtochain_raw(&tl, 0x0002, strlen(last), last);
	if (middle)
		aim_addtlvtochain_raw(&tl, 0x0003, strlen(middle), middle);
	if (maiden)
		aim_addtlvtochain_raw(&tl, 0x0004, strlen(maiden), maiden);

	if (state)
		aim_addtlvtochain_raw(&tl, 0x0007, strlen(state), state);
	if (city)
		aim_addtlvtochain_raw(&tl, 0x0008, strlen(city), city);

	if (nickname)
		aim_addtlvtochain_raw(&tl, 0x000c, strlen(nickname), nickname);
	if (zip)
		aim_addtlvtochain_raw(&tl, 0x000d, strlen(zip), zip);

	if (street)
		aim_addtlvtochain_raw(&tl, 0x0021, strlen(street), street);

	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+aim_sizetlvchain(&tl))))
		return -ENOMEM;

	snacid = aim_cachesnac(sess, 0x0002, 0x0009, 0x0000, NULL, 0);

	aim_putsnac(&fr->data, 0x0002, 0x0009, 0x0000, snacid);
	aim_writetlvchain(&fr->data, &tl);
	aim_freetlvchain(&tl);

	aim_tx_enqueue(sess, fr);

	return 0;
}

/* XXX pass these in better */
faim_export int aim_setuserinterests(aim_session_t *sess, aim_conn_t *conn, const char *interest1, const char *interest2, const char *interest3, const char *interest4, const char *interest5, fu16_t privacy)
{
	aim_frame_t *fr;
	aim_snacid_t snacid;
	aim_tlvlist_t *tl = NULL;

	/* ?? privacy ?? */
	aim_addtlvtochain16(&tl, 0x000a, privacy);

	if (interest1)
		aim_addtlvtochain_raw(&tl, 0x0000b, strlen(interest1), interest1);
	if (interest2)
		aim_addtlvtochain_raw(&tl, 0x0000b, strlen(interest2), interest2);
	if (interest3)
		aim_addtlvtochain_raw(&tl, 0x0000b, strlen(interest3), interest3);
	if (interest4)
		aim_addtlvtochain_raw(&tl, 0x0000b, strlen(interest4), interest4);
	if (interest5)
		aim_addtlvtochain_raw(&tl, 0x0000b, strlen(interest5), interest5);

	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+aim_sizetlvchain(&tl))))
		return -ENOMEM;

	snacid = aim_cachesnac(sess, 0x0002, 0x000f, 0x0000, NULL, 0);

	aim_putsnac(&fr->data, 0x0002, 0x000f, 0x0000, 0);
	aim_writetlvchain(&fr->data, &tl);
	aim_freetlvchain(&tl);

	aim_tx_enqueue(sess, fr);

	return 0;
}

faim_export int aim_icq_setstatus(aim_session_t *sess, aim_conn_t *conn, fu32_t status)
{
	aim_frame_t *fr;
	aim_snacid_t snacid;
	aim_tlvlist_t *tl = NULL;
	fu32_t data;

	data = 0x00030000 | status; /* yay for error checking ;^) */

	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10 + 4)))
		return -ENOMEM;

	snacid = aim_cachesnac(sess, 0x0001, 0x001e, 0x0000, NULL, 0);
	aim_putsnac(&fr->data, 0x0001, 0x001e, 0x0000, snacid);

	aim_addtlvtochain32(&tl, 0x0006, data);
	aim_writetlvchain(&fr->data, &tl);
	aim_freetlvchain(&tl);

	aim_tx_enqueue(sess, fr);

	return 0;
}

/*
 * Should be generic enough to handle the errors for all families...
 *
 */
static int generror(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
{
	int ret = 0;
	int error = 0;
	aim_rxcallback_t userfunc;
	aim_snac_t *snac2;

	snac2 = aim_remsnac(sess, snac->id);

	if (aim_bstream_empty(bs))
		error = aimbs_get16(bs);

	if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
		ret = userfunc(sess, rx, error, snac2 ? snac2->data : NULL);

	if (snac2)
		free(snac2->data);
	free(snac2);

	return ret;
}

static int snachandler(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
{

	if (snac->subtype == 0x0001)
		return generror(sess, mod, rx, snac, bs);
	else if ((snac->family == 0xffff) && (snac->subtype == 0xffff)) {
		aim_rxcallback_t userfunc;

		if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
			return userfunc(sess, rx);
	}

	return 0;
}

faim_internal int misc_modfirst(aim_session_t *sess, aim_module_t *mod)
{

	mod->family = 0xffff;
	mod->version = 0x0000;
	mod->flags = AIM_MODFLAG_MULTIFAMILY;
	strncpy(mod->name, "misc", sizeof(mod->name));
	mod->snachandler = snachandler;

	return 0;
}
Commit	Line	Data
	1
	2	/*
	3	* aim_misc.c
	4	*
	5	* TODO: Seperate a lot of this into an aim_bos.c.
	6	*
	7	* Other things...
	8	*
	9	* - Idle setting
	10	*
	11	*
	12	*/
	13
	14	#define FAIM_INTERNAL
	15	#include <aim.h>
	16
	17	/*
	18	* aim_bos_setidle()
	19	*
	20	* Should set your current idle time in seconds. Idealy, OSCAR should
	21	* do this for us. But, it doesn't. The client must call this to set idle
	22	* time.
	23	*
	24	*/
	25	faim_export int aim_bos_setidle(aim_session_t sess, aim_conn_t conn, fu32_t idletime)
	26	{
	27	return aim_genericreq_l(sess, conn, 0x0001, 0x0011, &idletime);
	28	}
	29
	30
	31	/*
	32	* aim_bos_changevisibility(conn, changtype, namelist)
	33	*
	34	* Changes your visibility depending on changetype:
	35	*
	36	* AIM_VISIBILITYCHANGE_PERMITADD: Lets provided list of names see you
	37	* AIM_VISIBILITYCHANGE_PERMIDREMOVE: Removes listed names from permit list
	38	* AIM_VISIBILITYCHANGE_DENYADD: Hides you from provided list of names
	39	* AIM_VISIBILITYCHANGE_DENYREMOVE: Lets list see you again
	40	*
	41	* list should be a list of
	42	* screen names in the form "Screen Name One&ScreenNameTwo&" etc.
	43	*
	44	* Equivelents to options in WinAIM:
	45	* - Allow all users to contact me: Send an AIM_VISIBILITYCHANGE_DENYADD
	46	* with only your name on it.
	47	* - Allow only users on my Buddy List: Send an
	48	* AIM_VISIBILITYCHANGE_PERMITADD with the list the same as your
	49	* buddy list
	50	* - Allow only the uesrs below: Send an AIM_VISIBILITYCHANGE_PERMITADD
	51	* with everyone listed that you want to see you.
	52	* - Block all users: Send an AIM_VISIBILITYCHANGE_PERMITADD with only
	53	* yourself in the list
	54	* - Block the users below: Send an AIM_VISIBILITYCHANGE_DENYADD with
	55	* the list of users to be blocked
	56	*
	57	* XXX ye gods.
	58	*/
	59	faim_export int aim_bos_changevisibility(aim_session_t sess, aim_conn_t conn, int changetype, const char *denylist)
	60	{
	61	aim_frame_t *fr;
	62	int packlen = 0;
	63	fu16_t subtype;
	64	char localcpy = NULL, tmpptr = NULL;
	65	int i;
	66	int listcount;
	67	aim_snacid_t snacid;
	68
	69	if (!denylist)
	70	return -EINVAL;
	71
	72	if (changetype == AIM_VISIBILITYCHANGE_PERMITADD)
	73	subtype = 0x05;
	74	else if (changetype == AIM_VISIBILITYCHANGE_PERMITREMOVE)
	75	subtype = 0x06;
	76	else if (changetype == AIM_VISIBILITYCHANGE_DENYADD)
	77	subtype = 0x07;
	78	else if (changetype == AIM_VISIBILITYCHANGE_DENYREMOVE)
	79	subtype = 0x08;
	80	else
	81	return -EINVAL;
	82
	83	localcpy = strdup(denylist);
	84
	85	listcount = aimutil_itemcnt(localcpy, '&');
	86	packlen = aimutil_tokslen(localcpy, 99, '&') + listcount + 9;
	87
	88	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, packlen))) {
	89	free(localcpy);
	90	return -ENOMEM;
	91	}
	92
	93	snacid = aim_cachesnac(sess, 0x0009, subtype, 0x0000, NULL, 0);
	94	aim_putsnac(&fr->data, 0x0009, subtype, 0x00, snacid);
	95
	96	for (i = 0; (i < (listcount - 1)) && (i < 99); i++) {
	97	tmpptr = aimutil_itemidx(localcpy, i, '&');
	98
	99	aimbs_put8(&fr->data, strlen(tmpptr));
	100	aimbs_putraw(&fr->data, tmpptr, strlen(tmpptr));
	101
	102	free(tmpptr);
	103	}
	104	free(localcpy);
	105
	106	aim_tx_enqueue(sess, fr);
	107
	108	return 0;
	109	}
	110
	111
	112
	113	/*
	114	* aim_bos_setbuddylist(buddylist)
	115	*
	116	* This just builds the "set buddy list" command then queues it.
	117	*
	118	* buddy_list = "Screen Name One&ScreenNameTwo&";
	119	*
	120	* TODO: Clean this up.
	121	*
	122	* XXX: I can't stress the TODO enough.
	123	*
	124	*/
	125	faim_export int aim_bos_setbuddylist(aim_session_t sess, aim_conn_t conn, const char *buddy_list)
	126	{
	127	aim_frame_t *fr;
	128	aim_snacid_t snacid;
	129	int i, len = 0;
	130	char *localcpy = NULL;
	131	char *tmpptr = NULL;
	132
	133	if (!buddy_list \|\| !(localcpy = strdup(buddy_list)))
	134	return -EINVAL;
	135
	136	i = 0;
	137	tmpptr = strtok(localcpy, "&");
	138	while ((tmpptr != NULL) && (i < 150)) {
	139	faimdprintf(sess, 2, "---adding %d: %s (%d)\n", i, tmpptr, strlen(tmpptr));
	140	len += 1+strlen(tmpptr);
	141	i++;
	142	tmpptr = strtok(NULL, "&");
	143	}
	144
	145	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+len)))
	146	return -ENOMEM;
	147
	148	snacid = aim_cachesnac(sess, 0x0003, 0x0004, 0x0000, NULL, 0);
	149
	150	aim_putsnac(&fr->data, 0x0003, 0x0004, 0x0000, snacid);
	151
	152	strncpy(localcpy, buddy_list, strlen(buddy_list)+1);
	153	i = 0;
	154	tmpptr = strtok(localcpy, "&");
	155	while ((tmpptr != NULL) & (i < 150)) {
	156	faimdprintf(sess, 2, "---adding %d: %s (%d)\n", i, tmpptr, strlen(tmpptr));
	157
	158	aimbs_put8(&fr->data, strlen(tmpptr));
	159	aimbs_putraw(&fr->data, tmpptr, strlen(tmpptr));
	160	i++;
	161	tmpptr = strtok(NULL, "&");
	162	}
	163
	164	aim_tx_enqueue(sess, fr);
	165
	166	free(localcpy);
	167
	168	return 0;
	169	}
	170
	171	/*
	172	* aim_bos_setprofile(profile)
	173	*
	174	* Gives BOS your profile.
	175	*
	176	*
	177	*/
	178	faim_export int aim_bos_setprofile(aim_session_t sess, aim_conn_t conn, const char profile, const char awaymsg, fu16_t caps)
	179	{
	180	static const char defencoding[] = {"text/aolrtf; charset=\"us-ascii\""};
	181	aim_frame_t *fr;
	182	aim_tlvlist_t *tl = NULL;
	183	aim_snacid_t snacid;
	184
	185	/* Build to packet first to get real length */
	186	if (profile) {
	187	aim_addtlvtochain_raw(&tl, 0x0001, strlen(defencoding), defencoding);
	188	aim_addtlvtochain_raw(&tl, 0x0002, strlen(profile), profile);
	189	}
	190
	191	if (awaymsg) {
	192	aim_addtlvtochain_raw(&tl, 0x0003, strlen(defencoding), defencoding);
	193	aim_addtlvtochain_raw(&tl, 0x0004, strlen(awaymsg), awaymsg);
	194	}
	195
	196	aim_addtlvtochain_caps(&tl, 0x0005, caps);
	197
	198	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10 + aim_sizetlvchain(&tl))))
	199	return -ENOMEM;
	200
	201	snacid = aim_cachesnac(sess, 0x0002, 0x0004, 0x0000, NULL, 0);
	202
	203	aim_putsnac(&fr->data, 0x0002, 0x004, 0x0000, snacid);
	204	aim_writetlvchain(&fr->data, &tl);
	205	aim_freetlvchain(&tl);
	206
	207	aim_tx_enqueue(sess, fr);
	208
	209	return 0;
	210	}
	211
	212	/*
	213	* aim_bos_clientready()
	214	*
	215	* Send Client Ready.
	216	*
	217	*/
	218	faim_export int aim_bos_clientready(aim_session_t sess, aim_conn_t conn)
	219	{
	220	struct aim_tool_version tools[] = {
	221	{0x0001, 0x0003, AIM_TOOL_WIN32, 0x0686},
	222	{0x0002, 0x0001, AIM_TOOL_WIN32, 0x0001},
	223	{0x0003, 0x0001, AIM_TOOL_WIN32, 0x0001},
	224	{0x0004, 0x0001, AIM_TOOL_WIN32, 0x0001},
	225	{0x0006, 0x0001, AIM_TOOL_WIN32, 0x0001},
	226	{0x0008, 0x0001, AIM_TOOL_WIN32, 0x0001},
	227	{0x0009, 0x0001, AIM_TOOL_WIN32, 0x0001},
	228	{0x000a, 0x0001, AIM_TOOL_WIN32, 0x0001},
	229	{0x000b, 0x0001, AIM_TOOL_WIN32, 0x0001}
	230	};
	231	int j;
	232	aim_frame_t *fr;
	233	aim_snacid_t snacid;
	234	int toolcount = sizeof(tools)/sizeof(struct aim_tool_version);
	235
	236	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 1152)))
	237	return -ENOMEM;
	238
	239	snacid = aim_cachesnac(sess, 0x0001, 0x0002, 0x0000, NULL, 0);
	240	aim_putsnac(&fr->data, 0x0001, 0x0002, 0x0000, snacid);
	241
	242	for (j = 0; j < toolcount; j++) {
	243	aimbs_put16(&fr->data, tools[j].group);
	244	aimbs_put16(&fr->data, tools[j].version);
	245	aimbs_put16(&fr->data, tools[j].tool);
	246	aimbs_put16(&fr->data, tools[j].toolversion);
	247	}
	248
	249	aim_tx_enqueue(sess, fr);
	250
	251	return 0;
	252	}
	253
	254	/*
	255	* Request Rate Information.
	256	*
	257	*/
	258	faim_export int aim_bos_reqrate(aim_session_t sess, aim_conn_t conn)
	259	{
	260	return aim_genericreq_n(sess, conn, 0x0001, 0x0006);
	261	}
	262
	263	/*
	264	* Rate Information Response Acknowledge.
	265	*
	266	*/
	267	faim_export int aim_bos_ackrateresp(aim_session_t sess, aim_conn_t conn)
	268	{
	269	aim_frame_t *fr;
	270	aim_snacid_t snacid;
	271
	272	if(!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+10)))
	273	return -ENOMEM;
	274
	275	snacid = aim_cachesnac(sess, 0x0001, 0x0008, 0x0000, NULL, 0);
	276
	277	aim_putsnac(&fr->data, 0x0001, 0x0008, 0x0000, snacid);
	278	aimbs_put16(&fr->data, 0x0001);
	279	aimbs_put16(&fr->data, 0x0002);
	280	aimbs_put16(&fr->data, 0x0003);
	281	aimbs_put16(&fr->data, 0x0004);
	282	aimbs_put16(&fr->data, 0x0005);
	283
	284	aim_tx_enqueue(sess, fr);
	285
	286	return 0;
	287	}
	288
	289	/*
	290	* aim_bos_setprivacyflags()
	291	*
	292	* Sets privacy flags. Normally 0x03.
	293	*
	294	* Bit 1: Allows other AIM users to see how long you've been idle.
	295	* Bit 2: Allows other AIM users to see how long you've been a member.
	296	*
	297	*/
	298	faim_export int aim_bos_setprivacyflags(aim_session_t sess, aim_conn_t conn, fu32_t flags)
	299	{
	300	return aim_genericreq_l(sess, conn, 0x0001, 0x0014, &flags);
	301	}
	302
	303	/*
	304	* aim_bos_reqpersonalinfo()
	305	*
	306	*/
	307	faim_export int aim_bos_reqpersonalinfo(aim_session_t sess, aim_conn_t conn)
	308	{
	309	return aim_genericreq_n(sess, conn, 0x0001, 0x000e);
	310	}
	311
	312	faim_export int aim_setversions(aim_session_t sess, aim_conn_t conn)
	313	{
	314	aim_frame_t *fr;
	315	aim_snacid_t snacid;
	316	static const struct version {
	317	fu16_t group;
	318	fu16_t version;
	319	} versions[] = {
	320	{0x0001, 0x0003},
	321	{0x0002, 0x0001},
	322	{0x0003, 0x0001},
	323	{0x0004, 0x0001},
	324	{0x0006, 0x0001},
	325	{0x0008, 0x0001},
	326	{0x0009, 0x0001},
	327	{0x000a, 0x0001},
	328	{0x000b, 0x0002},
	329	{0x000c, 0x0001},
	330	{0x0013, 0x0001},
	331	{0x0015, 0x0001},
	332	};
	333	int numversions = sizeof(versions) / sizeof(struct version);
	334	int i;
	335
	336	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10 + (4*numversions))))
	337	return -ENOMEM;
	338
	339	snacid = aim_cachesnac(sess, 0x0001, 0x0017, 0x0000, NULL, 0);
	340
	341	aim_putsnac(&fr->data, 0x0001, 0x0017, 0x0000, snacid);
	342	for (i = 0; i < numversions; i++) {
	343	aimbs_put16(&fr->data, versions[i].group);
	344	aimbs_put16(&fr->data, versions[i].version);
	345	}
	346
	347	aim_tx_enqueue(sess, fr);
	348
	349	return 0;
	350	}
	351
	352
	353	/*
	354	* aim_bos_reqservice(serviceid)
	355	*
	356	* Service request.
	357	*
	358	*/
	359	faim_export int aim_bos_reqservice(aim_session_t sess, aim_conn_t conn, fu16_t serviceid)
	360	{
	361	return aim_genericreq_s(sess, conn, 0x0001, 0x0004, &serviceid);
	362	}
	363
	364	/*
	365	* aim_bos_nop()
	366	*
	367	* No-op. WinAIM sends these every 4min or so to keep
	368	* the connection alive. Its not real necessary.
	369	*
	370	*/
	371	faim_export int aim_bos_nop(aim_session_t sess, aim_conn_t conn)
	372	{
	373	return aim_genericreq_n(sess, conn, 0x0001, 0x0016);
	374	}
	375
	376	/*
	377	* aim_flap_nop()
	378	*
	379	* No-op. WinAIM 4.x sends these _every minute_ to keep
	380	* the connection alive.
	381	*/
	382	faim_export int aim_flap_nop(aim_session_t sess, aim_conn_t conn)
	383	{
	384	aim_frame_t *fr;
	385
	386	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x05, 0)))
	387	return -ENOMEM;
	388
	389	aim_tx_enqueue(sess, fr);
	390
	391	return 0;
	392	}
	393
	394	/*
	395	* aim_bos_reqrights()
	396	*
	397	* Request BOS rights.
	398	*
	399	*/
	400	faim_export int aim_bos_reqrights(aim_session_t sess, aim_conn_t conn)
	401	{
	402	return aim_genericreq_n(sess, conn, 0x0009, 0x0002);
	403	}
	404
	405	/*
	406	* aim_bos_reqbuddyrights()
	407	*
	408	* Request Buddy List rights.
	409	*
	410	*/
	411	faim_export int aim_bos_reqbuddyrights(aim_session_t sess, aim_conn_t conn)
	412	{
	413	return aim_genericreq_n(sess, conn, 0x0003, 0x0002);
	414	}
	415
	416	/*
	417	* Send a warning to destsn.
	418	*
	419	* Flags:
	420	* AIM_WARN_ANON Send as an anonymous (doesn't count as much)
	421	*
	422	* returns -1 on error (couldn't alloc packet), 0 on success.
	423	*
	424	*/
	425	faim_export int aim_send_warning(aim_session_t sess, aim_conn_t conn, const char *destsn, fu32_t flags)
	426	{
	427	aim_frame_t *fr;
	428	aim_snacid_t snacid;
	429	fu16_t outflags = 0x0000;
	430
	431	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, strlen(destsn)+13)))
	432	return -ENOMEM;
	433
	434	snacid = aim_cachesnac(sess, 0x0004, 0x0008, 0x0000, destsn, strlen(destsn)+1);
	435
	436	aim_putsnac(&fr->data, 0x0004, 0x0008, 0x0000, snacid);
	437
	438	if (flags & AIM_WARN_ANON)
	439	outflags \|= 0x0001;
	440
	441	aimbs_put16(&fr->data, outflags);
	442	aimbs_put8(&fr->data, strlen(destsn));
	443	aimbs_putraw(&fr->data, destsn, strlen(destsn));
	444
	445	aim_tx_enqueue(sess, fr);
	446
	447	return 0;
	448	}
	449
	450	/*
	451	* aim_debugconn_sendconnect()
	452	*
	453	* For aimdebugd. If you don't know what it is, you don't want to.
	454	*/
	455	faim_export int aim_debugconn_sendconnect(aim_session_t sess, aim_conn_t conn)
	456	{
	457	return aim_genericreq_n(sess, conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_DEBUGCONN_CONNECT);
	458	}
	459
	460	/*
	461	* Generic routine for sending commands.
	462	*
	463	*
	464	* I know I can do this in a smarter way...but I'm not thinking straight
	465	* right now...
	466	*
	467	* I had one big function that handled all three cases, but then it broke
	468	* and I split it up into three. But then I fixed it. I just never went
	469	* back to the single. I don't see any advantage to doing it either way.
	470	*
	471	*/
	472	faim_internal int aim_genericreq_n(aim_session_t sess, aim_conn_t conn, fu16_t family, fu16_t subtype)
	473	{
	474	aim_frame_t *fr;
	475	aim_snacid_t snacid = 0x00000000;
	476
	477	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10)))
	478	return -ENOMEM;
	479
	480	aim_putsnac(&fr->data, family, subtype, 0x0000, snacid);
	481
	482	aim_tx_enqueue(sess, fr);
	483
	484	return 0;
	485	}
	486
	487	faim_internal int aim_genericreq_n_snacid(aim_session_t sess, aim_conn_t conn, fu16_t family, fu16_t subtype)
	488	{
	489	aim_frame_t *fr;
	490	aim_snacid_t snacid;
	491
	492	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10)))
	493	return -ENOMEM;
	494
	495	snacid = aim_cachesnac(sess, family, subtype, 0x0000, NULL, 0);
	496	aim_putsnac(&fr->data, family, subtype, 0x0000, snacid);
	497
	498	aim_tx_enqueue(sess, fr);
	499
	500	return 0;
	501	}
	502
	503	/*
	504	*
	505	*
	506	*/
	507	faim_internal int aim_genericreq_l(aim_session_t sess, aim_conn_t conn, fu16_t family, fu16_t subtype, fu32_t *longdata)
	508	{
	509	aim_frame_t *fr;
	510	aim_snacid_t snacid;
	511
	512	if (!longdata)
	513	return aim_genericreq_n(sess, conn, family, subtype);
	514
	515	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+4)))
	516	return -ENOMEM;
	517
	518	snacid = aim_cachesnac(sess, family, subtype, 0x0000, NULL, 0);
	519
	520	aim_putsnac(&fr->data, family, subtype, 0x0000, snacid);
	521	aimbs_put32(&fr->data, *longdata);
	522
	523	aim_tx_enqueue(sess, fr);
	524
	525	return 0;
	526	}
	527
	528	faim_internal int aim_genericreq_s(aim_session_t sess, aim_conn_t conn, fu16_t family, fu16_t subtype, fu16_t *shortdata)
	529	{
	530	aim_frame_t *fr;
	531	aim_snacid_t snacid;
	532
	533	if (!shortdata)
	534	return aim_genericreq_n(sess, conn, family, subtype);
	535
	536	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+2)))
	537	return -ENOMEM;
	538
	539	snacid = aim_cachesnac(sess, family, subtype, 0x0000, NULL, 0);
	540
	541	aim_putsnac(&fr->data, family, subtype, 0x0000, snacid);
	542	aimbs_put16(&fr->data, *shortdata);
	543
	544	aim_tx_enqueue(sess, fr);
	545
	546	return 0;
	547	}
	548
	549	/*
	550	* aim_bos_reqlocaterights()
	551	*
	552	* Request Location services rights.
	553	*
	554	*/
	555	faim_export int aim_bos_reqlocaterights(aim_session_t sess, aim_conn_t conn)
	556	{
	557	return aim_genericreq_n(sess, conn, 0x0002, 0x0002);
	558	}
	559
	560	/*
	561	* Set directory profile data (not the same as aim_bos_setprofile!)
	562	*
	563	* privacy: 1 to allow searching, 0 to disallow.
	564	*/
	565	faim_export int aim_setdirectoryinfo(aim_session_t sess, aim_conn_t conn, const char first, const char middle, const char last, const char maiden, const char nickname, const char street, const char city, const char state, const char *zip, int country, fu16_t privacy)
	566	{
	567	aim_frame_t *fr;
	568	aim_snacid_t snacid;
	569	aim_tlvlist_t *tl = NULL;
	570
	571
	572	aim_addtlvtochain16(&tl, 0x000a, privacy);
	573
	574	if (first)
	575	aim_addtlvtochain_raw(&tl, 0x0001, strlen(first), first);
	576	if (last)
	577	aim_addtlvtochain_raw(&tl, 0x0002, strlen(last), last);
	578	if (middle)
	579	aim_addtlvtochain_raw(&tl, 0x0003, strlen(middle), middle);
	580	if (maiden)
	581	aim_addtlvtochain_raw(&tl, 0x0004, strlen(maiden), maiden);
	582
	583	if (state)
	584	aim_addtlvtochain_raw(&tl, 0x0007, strlen(state), state);
	585	if (city)
	586	aim_addtlvtochain_raw(&tl, 0x0008, strlen(city), city);
	587
	588	if (nickname)
	589	aim_addtlvtochain_raw(&tl, 0x000c, strlen(nickname), nickname);
	590	if (zip)
	591	aim_addtlvtochain_raw(&tl, 0x000d, strlen(zip), zip);
	592
	593	if (street)
	594	aim_addtlvtochain_raw(&tl, 0x0021, strlen(street), street);
	595
	596	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+aim_sizetlvchain(&tl))))
	597	return -ENOMEM;
	598
	599	snacid = aim_cachesnac(sess, 0x0002, 0x0009, 0x0000, NULL, 0);
	600
	601	aim_putsnac(&fr->data, 0x0002, 0x0009, 0x0000, snacid);
	602	aim_writetlvchain(&fr->data, &tl);
	603	aim_freetlvchain(&tl);
	604
	605	aim_tx_enqueue(sess, fr);
	606
	607	return 0;
	608	}
	609
	610	/* XXX pass these in better */
	611	faim_export int aim_setuserinterests(aim_session_t sess, aim_conn_t conn, const char interest1, const char interest2, const char interest3, const char interest4, const char *interest5, fu16_t privacy)
	612	{
	613	aim_frame_t *fr;
	614	aim_snacid_t snacid;
	615	aim_tlvlist_t *tl = NULL;
	616
	617	/* ?? privacy ?? */
	618	aim_addtlvtochain16(&tl, 0x000a, privacy);
	619
	620	if (interest1)
	621	aim_addtlvtochain_raw(&tl, 0x0000b, strlen(interest1), interest1);
	622	if (interest2)
	623	aim_addtlvtochain_raw(&tl, 0x0000b, strlen(interest2), interest2);
	624	if (interest3)
	625	aim_addtlvtochain_raw(&tl, 0x0000b, strlen(interest3), interest3);
	626	if (interest4)
	627	aim_addtlvtochain_raw(&tl, 0x0000b, strlen(interest4), interest4);
	628	if (interest5)
	629	aim_addtlvtochain_raw(&tl, 0x0000b, strlen(interest5), interest5);
	630
	631	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10+aim_sizetlvchain(&tl))))
	632	return -ENOMEM;
	633
	634	snacid = aim_cachesnac(sess, 0x0002, 0x000f, 0x0000, NULL, 0);
	635
	636	aim_putsnac(&fr->data, 0x0002, 0x000f, 0x0000, 0);
	637	aim_writetlvchain(&fr->data, &tl);
	638	aim_freetlvchain(&tl);
	639
	640	aim_tx_enqueue(sess, fr);
	641
	642	return 0;
	643	}
	644
	645	faim_export int aim_icq_setstatus(aim_session_t sess, aim_conn_t conn, fu32_t status)
	646	{
	647	aim_frame_t *fr;
	648	aim_snacid_t snacid;
	649	aim_tlvlist_t *tl = NULL;
	650	fu32_t data;
	651
	652	data = 0x00030000 \| status; /* yay for error checking ;^) */
	653
	654	if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_FLAP, 0x02, 10 + 4)))
	655	return -ENOMEM;
	656
	657	snacid = aim_cachesnac(sess, 0x0001, 0x001e, 0x0000, NULL, 0);
	658	aim_putsnac(&fr->data, 0x0001, 0x001e, 0x0000, snacid);
	659
	660	aim_addtlvtochain32(&tl, 0x0006, data);
	661	aim_writetlvchain(&fr->data, &tl);
	662	aim_freetlvchain(&tl);
	663
	664	aim_tx_enqueue(sess, fr);
	665
	666	return 0;
	667	}
	668
	669	/*
	670	* Should be generic enough to handle the errors for all families...
	671	*
	672	*/
	673	static int generror(aim_session_t sess, aim_module_t mod, aim_frame_t rx, aim_modsnac_t snac, aim_bstream_t *bs)
	674	{
	675	int ret = 0;
	676	int error = 0;
	677	aim_rxcallback_t userfunc;
	678	aim_snac_t *snac2;
	679
	680	snac2 = aim_remsnac(sess, snac->id);
	681
	682	if (aim_bstream_empty(bs))
	683	error = aimbs_get16(bs);
	684
	685	if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
	686	ret = userfunc(sess, rx, error, snac2 ? snac2->data : NULL);
	687
	688	if (snac2)
	689	free(snac2->data);
	690	free(snac2);
	691
	692	return ret;
	693	}
	694
	695	static int snachandler(aim_session_t sess, aim_module_t mod, aim_frame_t rx, aim_modsnac_t snac, aim_bstream_t *bs)
	696	{
	697
	698	if (snac->subtype == 0x0001)
	699	return generror(sess, mod, rx, snac, bs);
	700	else if ((snac->family == 0xffff) && (snac->subtype == 0xffff)) {
	701	aim_rxcallback_t userfunc;
	702
	703	if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
	704	return userfunc(sess, rx);
	705	}
	706
	707	return 0;
	708	}
	709
	710	faim_internal int misc_modfirst(aim_session_t sess, aim_module_t mod)
	711	{
	712
	713	mod->family = 0xffff;
	714	mod->version = 0x0000;
	715	mod->flags = AIM_MODFLAG_MULTIFAMILY;
	716	strncpy(mod->name, "misc", sizeof(mod->name));
	717	mod->snachandler = snachandler;
	718
	719	return 0;
	720	}