rename accountopt.[ch] to purpleaccountoption.[ch]

[pidgin-git.git] / libpurple / protocols / oscar / family_oservice.c

/*
 * Purple's oscar protocol plugin
 * This file is the legal property of its developers.
 * Please see the AUTHORS file distributed alongside this file.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
*/

/*
 * Family 0x0001 - This is a very special group.  All connections support
 * this group, as it does some particularly good things (like rate limiting).
 */

#include "oscar.h"

/*
 * Each time we make a FLAP connection to an oscar server the server gives
 * us a list of rate classes.  Each rate class has different properties for
 * how frequently we can send SNACs in that rate class before we become
 * throttled or disconnected.
 *
 * The server also gives us a list of every available SNAC and tells us which
 * rate class it's in.  There are a lot of different SNACs, so this list can be
 * fairly large.  One important characteristic of these rate classes is that
 * currently (and since at least 2004) most SNACs are in the same rate class.
 *
 * One optimization we can do to save memory is to only keep track of SNACs
 * that are in classes other than this default rate class.  So if we try to
 * look up a SNAC and it's not in our hash table then we can assume that it's
 * in the default rate class.
 */
#define OSCAR_DEFAULT_RATECLASS 1

/* Subtype 0x0002 - Client Online */
void
aim_srv_clientready(OscarData *od, FlapConnection *conn)
{
        ByteStream bs;
        aim_snacid_t snacid;
        GSList *cur;

        byte_stream_new(&bs, 1142);

        /*
         * Send only the tool versions that the server cares about (that it
         * marked as supporting in the server ready SNAC).
         */
        for (cur = conn->groups; cur != NULL; cur = cur->next)
        {
                aim_module_t *mod;

                if ((mod = aim__findmodulebygroup(od, GPOINTER_TO_UINT(cur->data))))
                {
                        byte_stream_put16(&bs, mod->family);
                        byte_stream_put16(&bs, mod->version);
                        byte_stream_put16(&bs, mod->toolid);
                        byte_stream_put16(&bs, mod->toolversion);
                }
        }

        snacid = aim_cachesnac(od, SNAC_FAMILY_OSERVICE, 0x0002, 0x0000, NULL, 0);
        flap_connection_send_snac(od, conn, SNAC_FAMILY_OSERVICE, 0x0002, snacid, &bs);

        byte_stream_destroy(&bs);
}

/*
 * Subtype 0x0003 - Host Online
 *
 * See comments in conn.c about how the group associations are supposed
 * to work, and how they really work.
 *
 * This info probably doesn't even need to make it to the client.
 *
 * We don't actually call the client here.  This starts off the connection
 * initialization routine required by all AIM connections.  The next time
 * the client is called is the CONNINITDONE callback, which should be
 * shortly after the rate information is acknowledged.
 *
 */
static int
hostonline(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
{
        int group;

        while (byte_stream_bytes_left(bs))
        {
                group = byte_stream_get16(bs);
                conn->groups = g_slist_prepend(conn->groups, GUINT_TO_POINTER(group));
        }

        /*
         * Next step is in the Host Versions handler.
         *
         * Note that we must send this before we request rates, since
         * the format of the rate information depends on the versions we
         * give it.
         *
         */
        aim_srv_setversions(od, conn);

        return 1;
}

/* Subtype 0x0004 - Service request */
void
aim_srv_requestnew(OscarData *od, guint16 serviceid)
{
        FlapConnection *conn;
        ByteStream bs;
        aim_snacid_t snacid;
        GSList *tlvlist = NULL;

        conn = flap_connection_findbygroup(od, SNAC_FAMILY_BOS);
        if(!conn)
                return;

        byte_stream_new(&bs, 6);

        byte_stream_put16(&bs, serviceid);

        if (od->use_ssl)
                /* Request SSL Connection */
                aim_tlvlist_add_noval(&tlvlist, 0x008c);

        aim_tlvlist_write(&bs, &tlvlist);
        aim_tlvlist_free(tlvlist);

        snacid = aim_cachesnac(od, SNAC_FAMILY_OSERVICE, 0x0004, 0x0000, NULL, 0);
        flap_connection_send_snac(od, conn, SNAC_FAMILY_OSERVICE, 0x0004, snacid, &bs);

        byte_stream_destroy(&bs);
}

/*
 * Join a room of name roomname.  This is the first step to joining an
 * already created room.  It's basically a Service Request for
 * family 0x000e, with a little added on to specify the exchange and room
 * name.
 */
int
aim_chat_join(OscarData *od, guint16 exchange, const char *roomname, guint16 instance)
{
        FlapConnection *conn;
        ByteStream bs;
        aim_snacid_t snacid;
        GSList *tlvlist = NULL;
        struct chatsnacinfo csi;

        conn = flap_connection_findbygroup(od, SNAC_FAMILY_BOS);
        if (!conn || !roomname || roomname[0] == '\0')
                return -EINVAL;

        byte_stream_new(&bs, 506);

        memset(&csi, 0, sizeof(csi));
        csi.exchange = exchange;
        g_strlcpy(csi.name, roomname, sizeof(csi.name));
        csi.instance = instance;

        /*
         * Requesting service chat (0x000e)
         */
        byte_stream_put16(&bs, 0x000e);

        aim_tlvlist_add_chatroom(&tlvlist, 0x0001, exchange, roomname, instance);

        if (od->use_ssl)
                /* Request SSL Connection */
                aim_tlvlist_add_noval(&tlvlist, 0x008c);

        aim_tlvlist_write(&bs, &tlvlist);
        aim_tlvlist_free(tlvlist);

        snacid = aim_cachesnac(od, SNAC_FAMILY_OSERVICE, 0x0004, 0x0000, &csi, sizeof(csi));
        flap_connection_send_snac(od, conn, SNAC_FAMILY_OSERVICE, 0x0004, snacid, &bs);

        byte_stream_destroy(&bs);

        return 0;
}

/* Subtype 0x0005 - Redirect */
static int
redirect(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
{
        struct aim_redirect_data redir;
        aim_rxcallback_t userfunc;
        GSList *tlvlist;
        aim_snac_t *origsnac = NULL;
        int ret = 0;

        memset(&redir, 0, sizeof(redir));

        tlvlist = aim_tlvlist_read(bs);

        if (!aim_tlv_gettlv(tlvlist, 0x000d, 1) ||
                        !aim_tlv_gettlv(tlvlist, 0x0005, 1) ||
                        !aim_tlv_gettlv(tlvlist, 0x0006, 1)) {
                aim_tlvlist_free(tlvlist);
                return 0;
        }

        redir.group = aim_tlv_get16(tlvlist, 0x000d, 1);
        redir.ip = aim_tlv_getstr(tlvlist, 0x0005, 1);
        redir.cookielen = aim_tlv_gettlv(tlvlist, 0x0006, 1)->length;
        redir.cookie = (guchar *)aim_tlv_getstr(tlvlist, 0x0006, 1);
        redir.ssl_cert_cn = aim_tlv_getstr(tlvlist, 0x008d, 1);
        redir.use_ssl = aim_tlv_get8(tlvlist, 0x008e, 1);

        /* Fetch original SNAC so we can get csi if needed */
        origsnac = aim_remsnac(od, snac->id);

        if ((redir.group == SNAC_FAMILY_CHAT) && origsnac) {
                struct chatsnacinfo *csi = (struct chatsnacinfo *)origsnac->data;

                redir.chat.exchange = csi->exchange;
                redir.chat.room = csi->name;
                redir.chat.instance = csi->instance;
        }

        if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
                ret = userfunc(od, conn, frame, &redir);

        g_free((void *)redir.ip);
        g_free((void *)redir.cookie);
        g_free((void *)redir.ssl_cert_cn);

        if (origsnac)
                g_free(origsnac->data);
        g_free(origsnac);

        aim_tlvlist_free(tlvlist);

        return ret;
}

/* Subtype 0x0006 - Request Rate Information. */
void
aim_srv_reqrates(OscarData *od, FlapConnection *conn)
{
        aim_genericreq_n_snacid(od, conn, SNAC_FAMILY_OSERVICE, 0x0006);
}

/*
 * OSCAR defines several 'rate classes'.  Each class has separate
 * rate limiting properties (limit level, alert level, disconnect
 * level, etc), and a set of SNAC family/type pairs associated with
 * it.  The rate classes, their limiting properties, and the definitions
 * of which SNACs belong to which class are defined in the
 * Rate Response packet at login to each host.
 *
 * Logically, all rate offenses within one class count against further
 * offenses for other SNACs in the same class (ie, sending messages
 * too fast will limit the number of user info requests you can send,
 * since those two SNACs are in the same rate class).
 *
 * Since the rate classes are defined dynamically at login, the values
 * below may change. But they seem to be fairly constant.
 *
 * Currently, BOS defines five rate classes, with the commonly used
 * members as follows...
 *
 *  Rate class 0x0001:
 *      - Everything thats not in any of the other classes
 *
 *  Rate class 0x0002:
 *      - Buddy list add/remove
 *      - Permit list add/remove
 *      - Deny list add/remove
 *
 *  Rate class 0x0003:
 *      - User information requests
 *      - Outgoing ICBMs
 *
 *  Rate class 0x0004:
 *      - A few unknowns: 2/9, 2/b, and f/2
 *
 *  Rate class 0x0005:
 *      - Chat room create
 *      - Outgoing chat ICBMs
 *
 * The only other thing of note is that class 5 (chat) has slightly looser
 * limiting properties than class 3 (normal messages).  But thats just a
 * small bit of trivia for you.
 *
 * The last thing that needs to be learned about the rate limiting
 * system is how the actual numbers relate to the passing of time.  This
 * seems to be a big mystery.
 *
 * See joscar's javadoc for the RateClassInfo class for a great
 * explanation.  You might be able to find it at
 * http://dscoder.com/RateClassInfo.html
 */

static struct rateclass *
rateclass_find(GSList *rateclasses, guint16 id)
{
        GSList *tmp;

        for (tmp = rateclasses; tmp != NULL; tmp = tmp->next)
        {
                struct rateclass *rateclass;
                rateclass = tmp->data;
                if (rateclass->classid == id)
                        return rateclass;
        }

        return NULL;
}

/* Subtype 0x0007 - Rate Parameters */
static int
rateresp(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
{
        guint16 numclasses, i;
        aim_rxcallback_t userfunc;

        /*
         * First are the parameters for each rate class.
         */
        numclasses = byte_stream_get16(bs);
        for (i = 0; i < numclasses; i++)
        {
                struct rateclass *rateclass;
                guint32 delta;
                struct timeval now;

                gettimeofday(&now, NULL);
                rateclass = g_new(struct rateclass, 1);

                rateclass->classid = byte_stream_get16(bs);
                rateclass->windowsize = byte_stream_get32(bs);
                rateclass->clear = byte_stream_get32(bs);
                rateclass->alert = byte_stream_get32(bs);
                rateclass->limit = byte_stream_get32(bs);
                rateclass->disconnect = byte_stream_get32(bs);
                rateclass->current = byte_stream_get32(bs);
                rateclass->max = byte_stream_get32(bs);
                if (mod->version >= 3) {
                        delta = byte_stream_get32(bs);
                        rateclass->dropping_snacs = byte_stream_get8(bs);
                } else {
                        delta = 0;
                        rateclass->dropping_snacs = 0;
                }

                rateclass->last.tv_sec = now.tv_sec - delta / 1000;
                rateclass->last.tv_usec = now.tv_usec - (delta % 1000) * 1000;

                conn->rateclasses = g_slist_prepend(conn->rateclasses, rateclass);

                if (rateclass->classid == OSCAR_DEFAULT_RATECLASS)
                        conn->default_rateclass = rateclass;
        }
        conn->rateclasses = g_slist_reverse(conn->rateclasses);

        /*
         * Then the members of each class.
         */
        for (i = 0; i < numclasses; i++)
        {
                guint16 classid, count;
                struct rateclass *rateclass;
                int j;

                classid = byte_stream_get16(bs);
                count = byte_stream_get16(bs);

                if (classid == OSCAR_DEFAULT_RATECLASS) {
                        /*
                         * Don't bother adding these SNACs to the hash table.  See the
                         * comment for OSCAR_DEFAULT_RATECLASS at the top of this file.
                         */
                        byte_stream_advance(bs, 4 * count);
                        continue;
                }

                rateclass = rateclass_find(conn->rateclasses, classid);

                for (j = 0; j < count; j++)
                {
                        guint16 group, subtype;

                        group = byte_stream_get16(bs);
                        subtype = byte_stream_get16(bs);

                        if (rateclass != NULL)
                                g_hash_table_insert(conn->rateclass_members,
                                                GUINT_TO_POINTER((group << 16) + subtype),
                                                rateclass);
                }
        }

        /*
         * We don't pass the rate information up to the client, as it really
         * doesn't care.  The information is stored in the connection, however
         * so that we can do rate limiting management when sending SNACs.
         */

        /*
         * Subscribe to rate change information for all rate classes.
         */
        aim_srv_rates_addparam(od, conn);

        /*
         * Finally, tell the client it's ready to go...
         */
        if ((userfunc = aim_callhandler(od, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_CONNINITDONE)))
                userfunc(od, conn, frame);

        return 1;
}

/* Subtype 0x0008 - Add Rate Parameter */
void
aim_srv_rates_addparam(OscarData *od, FlapConnection *conn)
{
        ByteStream bs;
        aim_snacid_t snacid;
        GSList *tmp;

        byte_stream_new(&bs, 502);

        for (tmp = conn->rateclasses; tmp != NULL; tmp = tmp->next)
        {
                struct rateclass *rateclass;
                rateclass = tmp->data;
                byte_stream_put16(&bs, rateclass->classid);
        }

        snacid = aim_cachesnac(od, SNAC_FAMILY_OSERVICE, 0x0008, 0x0000, NULL, 0);
        flap_connection_send_snac(od, conn, SNAC_FAMILY_OSERVICE, 0x0008, snacid, &bs);

        byte_stream_destroy(&bs);
}

/* Subtype 0x000a - Rate Change */
static int
ratechange(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
{
        guint16 code, classid;
        struct rateclass *rateclass;
        guint32 delta;
        struct timeval now;
        static const char *codes[5] = {
                "invalid",
                "change",
                "warning",
                "limit",
                "limit cleared",
        };

        gettimeofday(&now, NULL);
        code = byte_stream_get16(bs);
        classid = byte_stream_get16(bs);

        rateclass = rateclass_find(conn->rateclasses, classid);
        if (rateclass == NULL)
                /* This should never really happen */
                return 0;

        rateclass->windowsize = byte_stream_get32(bs);
        rateclass->clear = byte_stream_get32(bs);
        rateclass->alert = byte_stream_get32(bs);
        rateclass->limit = byte_stream_get32(bs);
        rateclass->disconnect = byte_stream_get32(bs);
        rateclass->current = byte_stream_get32(bs);
        rateclass->max = byte_stream_get32(bs);
        if (mod->version >= 3) {
                delta = byte_stream_get32(bs);
                rateclass->dropping_snacs = byte_stream_get8(bs);
        } else {
                delta = 0;
                rateclass->dropping_snacs = 0;
        }

        rateclass->last.tv_sec = now.tv_sec - delta / 1000;
        rateclass->last.tv_usec = now.tv_usec - (delta % 1000) * 1000;

        purple_debug_misc("oscar", "rate %s (param ID 0x%04hx): curavg = %u, "
                        "maxavg = %u, alert at %u, clear warning at %u, limit at %u, "
                        "disconnect at %u, delta is %u, dropping is %u (window size = %u)\n",
                        (code < 5) ? codes[code] : codes[0], rateclass->classid,
                        rateclass->current, rateclass->max, rateclass->alert,
                        rateclass->clear, rateclass->limit, rateclass->disconnect,
                        delta, rateclass->dropping_snacs, rateclass->windowsize);

        if (code == AIM_RATE_CODE_LIMIT) {
                purple_debug_warning("oscar",  "The last action you attempted "
                                "could not be performed because you are over the rate "
                                "limit. Please wait 10 seconds and try again.\n");
        }

        return 1;
}

/*
 * How Migrations work.
 *
 * The server sends a Server Pause message, which the client should respond to
 * with a Server Pause Ack, which contains the families it needs on this
 * connection. The server will send a Migration Notice with an IP address, and
 * then disconnect. Next the client should open the connection and send the
 * cookie.  Repeat the normal login process and pretend this never happened.
 *
 * The Server Pause contains no data.
 *
 */

/* Subtype 0x000b - Service Pause */
static int
serverpause(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
{
        int ret = 0;
        aim_rxcallback_t userfunc;

        if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
                ret = userfunc(od, conn, frame);

        return ret;
}

/* Subtype 0x000d - Service Resume */
static int
serverresume(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
{
        int ret = 0;
        aim_rxcallback_t userfunc;

        if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
                ret = userfunc(od, conn, frame);

        return ret;
}

/* Subtype 0x000e - Request self-info */
void
aim_srv_reqpersonalinfo(OscarData *od, FlapConnection *conn)
{
        aim_genericreq_n_snacid(od, conn, SNAC_FAMILY_OSERVICE, 0x000e);
}

/* Subtype 0x000f - Self User Info */
static int
selfinfo(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
{
        int ret = 0;
        aim_rxcallback_t userfunc;
        aim_userinfo_t userinfo;

        aim_info_extract(od, bs, &userinfo);

        if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
                ret = userfunc(od, conn, frame, &userinfo);

        aim_info_free(&userinfo);

        return ret;
}

/* Subtype 0x0010 - Evil Notification */
static int
evilnotify(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
{
        int ret = 0;
        aim_rxcallback_t userfunc;
        guint16 newevil;
        aim_userinfo_t userinfo;

        memset(&userinfo, 0, sizeof(aim_userinfo_t));

        newevil = byte_stream_get16(bs);

        if (byte_stream_bytes_left(bs))
                aim_info_extract(od, bs, &userinfo);

        if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
                ret = userfunc(od, conn, frame, newevil, &userinfo);

        aim_info_free(&userinfo);

        return ret;
}

/*
 * Subtype 0x0011 - Idle Notification
 *
 * Should set your current idle time in seconds.  Note that this should
 * never be called consecutively with a non-zero idle time.  That makes
 * OSCAR do funny things.  Instead, just set it once you go idle, and then
 * call it again with zero when you're back.
 *
 */
void
aim_srv_setidle(OscarData *od, guint32 idletime)
{
        FlapConnection *conn;

        conn = flap_connection_findbygroup(od, SNAC_FAMILY_BOS);
        if(!conn)
                return;

        aim_genericreq_l(od, conn, SNAC_FAMILY_OSERVICE, 0x0011, &idletime);
}

/*
 * Subtype 0x0012 - Service Migrate
 *
 * This is the final SNAC sent on the original connection during a migration.
 * It contains the IP and cookie used to connect to the new server, and
 * optionally a list of the SNAC groups being migrated.
 *
 */
static int
migrate(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
{
        aim_rxcallback_t userfunc;
        int ret = 0;
        guint16 groupcount, i;
        GSList *tlvlist;
        char *ip = NULL;
        aim_tlv_t *cktlv;

        /*
         * Apparently there's some fun stuff that can happen right here. The
         * migration can actually be quite selective about what groups it
         * moves to the new server.  When not all the groups for a connection
         * are migrated, or they are all migrated but some groups are moved
         * to a different server than others, it is called a bifurcated
         * migration.
         *
         * Let's play dumb and not support that.
         *
         */
        groupcount = byte_stream_get16(bs);
        for (i = 0; i < groupcount; i++) {
                guint16 group;

                group = byte_stream_get16(bs);

                purple_debug_misc("oscar", "bifurcated migration unsupported -- group 0x%04x\n", group);
        }

        tlvlist = aim_tlvlist_read(bs);

        if (aim_tlv_gettlv(tlvlist, 0x0005, 1))
                ip = aim_tlv_getstr(tlvlist, 0x0005, 1);

        cktlv = aim_tlv_gettlv(tlvlist, 0x0006, 1);

        if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
                ret = userfunc(od, conn, frame, ip, cktlv ? cktlv->value : NULL);

        aim_tlvlist_free(tlvlist);
        g_free(ip);

        return ret;
}

/* Subtype 0x0013 - Message of the Day */
static int
motd(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
{
        aim_rxcallback_t userfunc;
        char *msg = NULL;
        int ret = 0;
        GSList *tlvlist;
        guint16 id;

        /*
         * Code.
         *
         * Valid values:
         *   1 Mandatory upgrade
         *   2 Advisory upgrade
         *   3 System bulletin
         *   4 Nothing's wrong ("top o the world" -- normal)
         *   5 Lets-break-something.
         *
         */
        id = byte_stream_get16(bs);

        /*
         * TLVs follow
         */
        tlvlist = aim_tlvlist_read(bs);

        msg = aim_tlv_getstr(tlvlist, 0x000b, 1);

        if ((userfunc = aim_callhandler(od, snac->family, snac->subtype)))
                ret = userfunc(od, conn, frame, id, msg);

        g_free(msg);

        aim_tlvlist_free(tlvlist);

        return ret;
}

/*
 * Subtype 0x0017 - Set client versions
 *
 * If you've seen the clientonline/clientready SNAC you're probably
 * wondering what the point of this one is.  And that point seems to be
 * that the versions in the client online SNAC are sent too late for the
 * server to be able to use them to change the protocol for the earlier
 * login packets (client versions are sent right after Host Online is
 * received, but client online versions aren't sent until quite a bit later).
 * We can see them already making use of this by changing the format of
 * the rate information based on what version of group 1 we advertise here.
 *
 */
void
aim_srv_setversions(OscarData *od, FlapConnection *conn)
{
        ByteStream bs;
        aim_snacid_t snacid;
        GSList *cur;

        byte_stream_new(&bs, 1142);

        /*
         * Send only the versions that the server cares about (that it
         * marked as supporting in the server ready SNAC).
         */
        for (cur = conn->groups; cur != NULL; cur = cur->next)
        {
                aim_module_t *mod;

                if ((mod = aim__findmodulebygroup(od, GPOINTER_TO_UINT(cur->data))))
                {
                        byte_stream_put16(&bs, mod->family);
                        byte_stream_put16(&bs, mod->version);
                }
        }

        snacid = aim_cachesnac(od, SNAC_FAMILY_OSERVICE, 0x0017, 0x0000, NULL, 0);
        flap_connection_send_snac(od, conn, SNAC_FAMILY_OSERVICE, 0x0017, snacid, &bs);

        byte_stream_destroy(&bs);
}

/* Subtype 0x0018 - Host versions */
static int
hostversions(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
{
        int vercount;
        guint8 *versions;

        /* This is frivolous. (Thank you SmarterChild.) */
        vercount = byte_stream_bytes_left(bs)/4;

        /* XXX: vercount probably should be used for reading versions. */
        (void)vercount;
        versions = byte_stream_getraw(bs, byte_stream_bytes_left(bs));
        g_free(versions);

        /*
         * Now request rates.
         */
        aim_srv_reqrates(od, conn);

        return 1;
}

/**
 * Subtype 0x001e - Extended Status/Extra Info.
 *
 * These settings are transient, not server-stored (i.e. they only
 * apply to this session, and must be re-set the next time you sign
 * on).
 *
 * You can set your ICQ status (available, away, do not disturb,
 * etc.), or whether your IP address should be hidden or not, or
 * if your status is visible on ICQ web sites, and you can set
 * your IP address info and what not.
 *
 * You can also set your "available" message.  This is currently
 * only supported by iChat, Purple and other 3rd party clients.
 *
 * These are the same TLVs seen in user info.  You can
 * also set 0x0008 and 0x000c.
 */
int
aim_srv_setextrainfo(OscarData *od,
                gboolean seticqstatus, guint32 icqstatus,
                gboolean setstatusmsg, const char *statusmsg, const char *itmsurl)
{
        FlapConnection *conn;
        ByteStream bs;
        aim_snacid_t snacid;
        GSList *tlvlist = NULL;

        if (!od || !(conn = flap_connection_findbygroup(od, SNAC_FAMILY_ICBM)))
                return -EINVAL;

        if (seticqstatus)
        {
                aim_tlvlist_add_32(&tlvlist, 0x0006, icqstatus |
                                AIM_ICQ_STATE_HIDEIP | AIM_ICQ_STATE_DIRECTREQUIREAUTH);
        }

        if (setstatusmsg)
        {
                size_t statusmsglen, itmsurllen;
                ByteStream tmpbs;

                statusmsglen = (statusmsg != NULL) ? strlen(statusmsg) : 0;
                itmsurllen = (itmsurl != NULL) ? strlen(itmsurl) : 0;

                byte_stream_new(&tmpbs, statusmsglen + 8 + itmsurllen + 8);
                byte_stream_put_bart_asset_str(&tmpbs, 0x0002, statusmsg);
                byte_stream_put_bart_asset_str(&tmpbs, 0x0009, itmsurl);

                aim_tlvlist_add_raw(&tlvlist, 0x001d,
                                byte_stream_curpos(&tmpbs), tmpbs.data);
                byte_stream_destroy(&tmpbs);
        }

        byte_stream_new(&bs, aim_tlvlist_size(tlvlist));

        aim_tlvlist_write(&bs, &tlvlist);
        aim_tlvlist_free(tlvlist);

        snacid = aim_cachesnac(od, SNAC_FAMILY_OSERVICE, 0x001e, 0x0000, NULL, 0);
        flap_connection_send_snac(od, conn, SNAC_FAMILY_OSERVICE, 0x001e, snacid, &bs);

        byte_stream_destroy(&bs);

        return 0;
}

/* Send dummy DC (direct connect) information to the server.
 * Direct connect is ICQ's counterpart for AIM's DirectIM,
 * as far as I can tell. Anyway, we don't support it;
 * the reason to send this packet is that some clients
 * (Miranda, QIP) won't send us channel 2 ICBM messages
 * unless we specify DC version >= 8.
 *
 * See #12044 for more information.
 */
void
aim_srv_set_dc_info(OscarData *od)
{
        FlapConnection *conn;

        ByteStream bs, tlv0c;
        aim_snacid_t snacid;
        GSList *tlvlist = NULL;

        /* http://iserverd.khstu.ru/oscar/snac_01_1e.html has a nice analysis of what goes in 0xc tlv.
         * Kopete sends a dummy DC info, too, so I just copied the values from them.
         */
        byte_stream_new(&tlv0c, 4*2 + 1 + 2 + 4*6 + 2);
        byte_stream_put32(&tlv0c, 0x0);
        byte_stream_put32(&tlv0c, 0x0);
        byte_stream_put8(&tlv0c, 0x0); /* We don't support DC */
        byte_stream_put16(&tlv0c, 8); /* DC version */
        byte_stream_put32(&tlv0c, 0x0);
        byte_stream_put32(&tlv0c, 0x50);
        byte_stream_put32(&tlv0c, 0x3);
        byte_stream_put32(&tlv0c, 0x0);
        byte_stream_put32(&tlv0c, 0x0);
        byte_stream_put32(&tlv0c, 0x0);
        byte_stream_put16(&tlv0c, 0x0);
        aim_tlvlist_add_raw(&tlvlist, 0x000c, byte_stream_curpos(&tlv0c), tlv0c.data);
        byte_stream_destroy(&tlv0c);

        byte_stream_new(&bs, aim_tlvlist_size(tlvlist));
        aim_tlvlist_write(&bs, &tlvlist);
        aim_tlvlist_free(tlvlist);

        snacid = aim_cachesnac(od, SNAC_FAMILY_OSERVICE, 0x001e, 0x0000, NULL, 0);
        conn = flap_connection_findbygroup(od, SNAC_FAMILY_ICBM);
        g_warn_if_fail(conn != NULL);
        if (conn) {
                flap_connection_send_snac(od, conn, SNAC_FAMILY_OSERVICE,
                        0x001e, snacid, &bs);
        }

        byte_stream_destroy(&bs);
}

/*
 * Subtype 0x0021 - Receive our extended status
 *
 * This is used for iChat's "available" messages, and maybe ICQ extended
 * status messages?  It's also used to tell the client whether or not it
 * needs to upload an SSI buddy icon... who engineers this stuff, anyway?
 */
static int
aim_parse_extstatus(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
{
        guint16 type = byte_stream_get16(bs);
        if (type == 0x0000 || type == 0x0001) {
                /* buddy icon checksum */
                /* not sure what the difference between 1 and 0 is */
                guint8 flags = byte_stream_get8(bs);
                guint8 length = byte_stream_get8(bs);
                guint8 *md5 = byte_stream_getraw(bs, length);

                if ((flags == 0x00) || (flags == 0x41)) {
                        if (!flap_connection_getbytype(od, SNAC_FAMILY_BART) && !od->iconconnecting) {
                                od->iconconnecting = TRUE;
                                od->set_icon = TRUE;
                                aim_srv_requestnew(od, SNAC_FAMILY_BART);
                        } else {
                                PurpleAccount *account = purple_connection_get_account(od->gc);
                                PurpleImage *img = purple_buddy_icons_find_account_icon(account);
                                if (img == NULL) {
                                        aim_ssi_delicon(od);
                                } else {

                                        purple_debug_info("oscar",
                                                                        "Uploading icon to icon server\n");
                                        aim_bart_upload(od,
                                                purple_image_get_data(img),
                                                purple_image_get_data_size(img));
                                        g_object_unref(img);
                                }
                        }
                } else if (flags == 0x81) {
                        PurpleAccount *account = purple_connection_get_account(od->gc);
                        PurpleImage *img = purple_buddy_icons_find_account_icon(account);
                        if (img == NULL)
                                aim_ssi_delicon(od);
                        else {
                                aim_ssi_seticon(od, md5, length);
                                g_object_unref(img);
                        }
                }

                g_free(md5);
        }

        return 0;
}

static int
snachandler(OscarData *od, FlapConnection *conn, aim_module_t *mod, FlapFrame *frame, aim_modsnac_t *snac, ByteStream *bs)
{
        if (snac->subtype == 0x0003)
                return hostonline(od, conn, mod, frame, snac, bs);
        else if (snac->subtype == 0x0005)
                return redirect(od, conn, mod, frame, snac, bs);
        else if (snac->subtype == 0x0007)
                return rateresp(od, conn, mod, frame, snac, bs);
        else if (snac->subtype == 0x000a)
                return ratechange(od, conn, mod, frame, snac, bs);
        else if (snac->subtype == 0x000b)
                return serverpause(od, conn, mod, frame, snac, bs);
        else if (snac->subtype == 0x000d)
                return serverresume(od, conn, mod, frame, snac, bs);
        else if (snac->subtype == 0x000f)
                return selfinfo(od, conn, mod, frame, snac, bs);
        else if (snac->subtype == 0x0010)
                return evilnotify(od, conn, mod, frame, snac, bs);
        else if (snac->subtype == 0x0012)
                return migrate(od, conn, mod, frame, snac, bs);
        else if (snac->subtype == 0x0013)
                return motd(od, conn, mod, frame, snac, bs);
        else if (snac->subtype == 0x0018)
                return hostversions(od, conn, mod, frame, snac, bs);
        else if (snac->subtype == 0x0021)
                return aim_parse_extstatus(od, conn, mod, frame, snac, bs);

        return 0;
}

int service_modfirst(OscarData *od, aim_module_t *mod)
{
        mod->family = SNAC_FAMILY_OSERVICE;
        mod->version = 0x0003;
        mod->toolid = 0x0110;
        mod->toolversion = 0x0629;
        mod->flags = 0;
        strncpy(mod->name, "oservice", sizeof(mod->name));
        mod->snachandler = snachandler;

        return 0;
}