gboolean
Skype_connected (gpointer data, void* source, b_input_condition condition)
{
im_connection* connection = data;
SkypeData* skype = connection->proto_data;
if (source == NULL) {
skype->ssl = NULL;
imcb_error(connection, "Could not connect to server");
imc_logout(connection, TRUE);
return FALSE;
}
imcb_log(connection, "Connected to server, logging in");
return Skype_begin(connection);
}
gboolean msn_ns_connect( struct im_connection *ic, struct msn_handler_data *handler, const char *host, int port )
{
if( handler->fd >= 0 )
closesocket( handler->fd );
handler->exec_command = msn_ns_command;
handler->exec_message = msn_ns_message;
handler->data = ic;
handler->fd = proxy_connect( host, port, msn_ns_connected, handler );
if( handler->fd < 0 )
{
imcb_error( ic, "Could not connect to server" );
imc_logout( ic, TRUE );
return FALSE;
}
return TRUE;
}
gboolean
Skype_loop (gpointer data, gint fd, b_input_condition condition)
{
im_connection* connection = data;
SkypeData* skype = connection->proto_data;
char buffer[IRC_LINE_SIZE];
if (ssl_read(skype->ssl, buffer, sizeof(buffer)) <= 0 && !sockerr_again()) {
closesocket(skype->fd);
skype->fd = -1;
imcb_error(connection, "Error while reading from server");
imc_logout(connection, TRUE);
return FALSE;
}
return TRUE;
}
static xt_status jabber_chat_join_failed(struct im_connection *ic, struct xt_node *node, struct xt_node *orig)
{
struct jabber_error *err;
struct jabber_buddy *bud;
char *room;
room = xt_find_attr(orig, "to");
bud = jabber_buddy_by_jid(ic, room, 0);
err = jabber_error_parse(xt_find_node(node->children, "error"), XMLNS_STANZA_ERROR);
if (err) {
imcb_error(ic, "Error joining groupchat %s: %s%s%s", room, err->code,
err->text ? ": " : "", err->text ? err->text : "");
jabber_error_free(err);
}
if (bud) {
jabber_chat_free(jabber_chat_by_jid(ic, bud->bare_jid));
}
return XT_HANDLED;
}
struct groupchat *purple_chat_join(struct im_connection *ic, const char *room, const char *nick, const char *password,
set_t **sets)
{
struct purple_data *pd = ic->proto_data;
PurplePlugin *prpl = purple_plugins_find_with_id(pd->account->protocol_id);
PurplePluginProtocolInfo *pi = prpl->info->extra_info;
GHashTable *chat_hash;
PurpleConversation *conv;
GList *info, *l;
if (!pi->chat_info || !pi->chat_info_defaults ||
!(info = pi->chat_info(purple_account_get_connection(pd->account)))) {
imcb_error(ic, "Joining chatrooms not supported by this protocol");
return NULL;
}
if ((conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT,
room, pd->account))) {
purple_conversation_destroy(conv);
}
chat_hash = pi->chat_info_defaults(
purple_account_get_connection(pd->account), room
);
for (l = info; l; l = l->next) {
struct proto_chat_entry *pce = l->data;
if (strcmp(pce->identifier, "handle") == 0) {
g_hash_table_replace(chat_hash, "handle", g_strdup(nick));
} else if (strcmp(pce->identifier, "password") == 0) {
g_hash_table_replace(chat_hash, "password", g_strdup(password));
} else if (strcmp(pce->identifier, "passwd") == 0) {
g_hash_table_replace(chat_hash, "passwd", g_strdup(password));
}
}
serv_join_chat(purple_account_get_connection(pd->account), chat_hash);
return NULL;
}
/**
* Implements #prpl->add_buddy(). This adds a buddy.
*
* @param ic The #im_connection.
* @param name The name of the buddy to add.
* @param group The group of the buddy. (Irrelevant to this plugin)
**/
static void steam_add_buddy(struct im_connection *ic, char *name, char *group)
{
SteamData *sata = ic->proto_data;
SteamApiReq *req;
gchar *str;
if (g_ascii_strncasecmp(name, "steamid:", 8) != 0) {
req = steam_api_req_new(sata->api, steam_cb_user_search, sata);
steam_api_req_user_search(req, name, 5);
return;
}
str = strchr(name, ':');
if ((str != NULL) && ((++str)[0] != 0)) {
req = steam_api_req_new(sata->api, steam_cb_user_action, sata);
steam_api_req_user_add(req, STEAM_ID_NEW_STR(str));
} else {
imcb_error(sata->ic, "No Steam ID specified");
}
}
static void
steam_cb_user_search(SteamApiReq *req, gpointer data)
{
const gchar *tag;
gchar sid[STEAM_ID_STRMAX];
GList *l;
guint i;
SteamData *sata = data;
SteamUserInfo *info;
if (steam_req_error(sata, req, TRUE)) {
return;
}
for (l = req->infs->head, i = 0; (l != NULL) && (i < 2); l = l->next, i++);
switch (i) {
case 0:
imcb_error(sata->ic, "Failed to find any friend(s)");
return;
case 1:
info = req->infs->head->data;
req = steam_api_req_new(req->api, steam_cb_user_action, sata);
steam_api_req_user_add(req, info->id);
return;
}
imcb_log(sata->ic, "Select from one of the following Steam Friends:");
tag = sata->ic->acc->tag;
for (l = req->infs->head, i = 1; l != NULL; l = l->next, i++) {
info = l->data;
STEAM_ID_STR(info->id, sid);
imcb_log(sata->ic, "%u. `%s' %s", i, info->nick, info->profile);
imcb_log(sata->ic, "-- add %s steamid:%s", tag, sid);
}
}
xt_status sasl_pkt_challenge( struct xt_node *node, gpointer data )
{
struct im_connection *ic = data;
struct jabber_data *jd = ic->proto_data;
struct xt_node *reply_pkt = NULL;
char *nonce = NULL, *realm = NULL, *cnonce = NULL;
unsigned char cnonce_bin[30];
char *digest_uri = NULL;
char *dec = NULL;
char *s = NULL, *reply = NULL;
xt_status ret = XT_ABORT;
if( node->text_len == 0 )
goto error;
dec = frombase64( node->text );
if( jd->flags & JFLAG_SASL_FB )
{
/* New-style Facebook OAauth2 support. Instead of sending a refresh
token, they just send an access token that should never expire. */
GSList *p_in = NULL, *p_out = NULL;
char time[33];
oauth_params_parse( &p_in, dec );
oauth_params_add( &p_out, "nonce", oauth_params_get( &p_in, "nonce" ) );
oauth_params_add( &p_out, "method", oauth_params_get( &p_in, "method" ) );
oauth_params_free( &p_in );
g_snprintf( time, sizeof( time ), "%lld", (long long) ( gettime() * 1000 ) );
oauth_params_add( &p_out, "call_id", time );
oauth_params_add( &p_out, "api_key", oauth2_service_facebook.consumer_key );
oauth_params_add( &p_out, "v", "1.0" );
oauth_params_add( &p_out, "format", "XML" );
oauth_params_add( &p_out, "access_token", jd->oauth2_access_token );
reply = oauth_params_string( p_out );
oauth_params_free( &p_out );
}
else if( !( s = sasl_get_part( dec, "rspauth" ) ) )
{
/* See RFC 2831 for for information. */
md5_state_t A1, A2, H;
md5_byte_t A1r[16], A2r[16], Hr[16];
char A1h[33], A2h[33], Hh[33];
int i;
nonce = sasl_get_part( dec, "nonce" );
realm = sasl_get_part( dec, "realm" );
if( !nonce )
goto error;
/* Jabber.Org considers the realm part optional and doesn't
specify one. Oh well, actually they're right, but still,
don't know if this is right... */
if( !realm )
realm = g_strdup( jd->server );
random_bytes( cnonce_bin, sizeof( cnonce_bin ) );
cnonce = base64_encode( cnonce_bin, sizeof( cnonce_bin ) );
digest_uri = g_strdup_printf( "%s/%s", "xmpp", jd->server );
/* Generate the MD5 hash of username:realm:password,
I decided to call it H. */
md5_init( &H );
s = g_strdup_printf( "%s:%s:%s", jd->username, realm, ic->acc->pass );
md5_append( &H, (unsigned char *) s, strlen( s ) );
g_free( s );
md5_finish( &H, Hr );
/* Now generate the hex. MD5 hash of H:nonce:cnonce, called A1. */
md5_init( &A1 );
s = g_strdup_printf( ":%s:%s", nonce, cnonce );
md5_append( &A1, Hr, 16 );
md5_append( &A1, (unsigned char *) s, strlen( s ) );
g_free( s );
md5_finish( &A1, A1r );
for( i = 0; i < 16; i ++ )
sprintf( A1h + i * 2, "%02x", A1r[i] );
/* A2... */
md5_init( &A2 );
s = g_strdup_printf( "%s:%s", "AUTHENTICATE", digest_uri );
md5_append( &A2, (unsigned char *) s, strlen( s ) );
g_free( s );
md5_finish( &A2, A2r );
for( i = 0; i < 16; i ++ )
sprintf( A2h + i * 2, "%02x", A2r[i] );
/* Final result: A1:nonce:00000001:cnonce:auth:A2. Let's reuse H for it. */
md5_init( &H );
s = g_strdup_printf( "%s:%s:%s:%s:%s:%s", A1h, nonce, "00000001", cnonce, "auth", A2h );
md5_append( &H, (unsigned char *) s, strlen( s ) );
g_free( s );
md5_finish( &H, Hr );
for( i = 0; i < 16; i ++ )
sprintf( Hh + i * 2, "%02x", Hr[i] );
/* Now build the SASL response string: */
reply = g_strdup_printf( "username=\"%s\",realm=\"%s\",nonce=\"%s\",cnonce=\"%s\","
"nc=%08x,qop=auth,digest-uri=\"%s\",response=%s,charset=%s",
jd->username, realm, nonce, cnonce, 1, digest_uri, Hh, "utf-8" );
}
else
{
/* We found rspauth, but don't really care... */
g_free( s );
}
s = reply ? tobase64( reply ) : NULL;
reply_pkt = xt_new_node( "response", s, NULL );
xt_add_attr( reply_pkt, "xmlns", XMLNS_SASL );
if( !jabber_write_packet( ic, reply_pkt ) )
goto silent_error;
ret = XT_HANDLED;
goto silent_error;
error:
imcb_error( ic, "Incorrect SASL challenge received" );
imc_logout( ic, FALSE );
silent_error:
g_free( digest_uri );
g_free( cnonce );
g_free( nonce );
g_free( reply );
g_free( realm );
g_free( dec );
g_free( s );
xt_free_node( reply_pkt );
return ret;
}
/* Separate this from jabber_login() so we can do OAuth first if necessary.
Putting this in io.c would probably be more correct. */
void jabber_connect( struct im_connection *ic )
{
account_t *acc = ic->acc;
struct jabber_data *jd = ic->proto_data;
int i;
char *connect_to;
struct ns_srv_reply **srvl = NULL, *srv = NULL;
/* Figure out the hostname to connect to. */
if( acc->server && *acc->server )
connect_to = acc->server;
else if( ( srvl = srv_lookup( "xmpp-client", "tcp", jd->server ) ) ||
( srvl = srv_lookup( "jabber-client", "tcp", jd->server ) ) )
{
/* Find the lowest-priority one. These usually come
back in random/shuffled order. Not looking at
weights etc for now. */
srv = *srvl;
for( i = 1; srvl[i]; i ++ )
if( srvl[i]->prio < srv->prio )
srv = srvl[i];
connect_to = srv->name;
}
else
connect_to = jd->server;
imcb_log( ic, "Connecting" );
for( i = 0; jabber_port_list[i] > 0; i ++ )
if( set_getint( &acc->set, "port" ) == jabber_port_list[i] )
break;
if( jabber_port_list[i] == 0 )
{
imcb_log( ic, "Illegal port number" );
imc_logout( ic, FALSE );
return;
}
/* For non-SSL connections we can try to use the port # from the SRV
reply, but let's not do that when using SSL, SSL usually runs on
non-standard ports... */
if( set_getbool( &acc->set, "ssl" ) )
{
jd->ssl = ssl_connect( connect_to, set_getint( &acc->set, "port" ), FALSE, jabber_connected_ssl, ic );
jd->fd = jd->ssl ? ssl_getfd( jd->ssl ) : -1;
}
else
{
jd->fd = proxy_connect( connect_to, srv ? srv->port : set_getint( &acc->set, "port" ), jabber_connected_plain, ic );
}
srv_free( srvl );
if( jd->fd == -1 )
{
imcb_error( ic, "Could not connect to server" );
imc_logout( ic, TRUE );
return;
}
if( set_getbool( &acc->set, "xmlconsole" ) )
{
jd->flags |= JFLAG_XMLCONSOLE;
/* Shouldn't really do this at this stage already, maybe. But
I think this shouldn't break anything. */
imcb_add_buddy( ic, JABBER_XMLCONSOLE_HANDLE, NULL );
}
jabber_generate_id_hash( jd );
}
static void jabber_login( account_t *acc )
{
struct im_connection *ic = imcb_new( acc );
struct jabber_data *jd = g_new0( struct jabber_data, 1 );
char *s;
/* For now this is needed in the _connected() handlers if using
GLib event handling, to make sure we're not handling events
on dead connections. */
jabber_connections = g_slist_prepend( jabber_connections, ic );
jd->ic = ic;
ic->proto_data = jd;
jabber_set_me( ic, acc->user );
jd->fd = jd->r_inpa = jd->w_inpa = -1;
if( jd->server == NULL )
{
imcb_error( ic, "Incomplete account name (format it like <*****@*****.**>)" );
imc_logout( ic, FALSE );
return;
}
if( ( s = strchr( jd->server, '/' ) ) )
{
*s = 0;
set_setstr( &acc->set, "resource", s + 1 );
/* Also remove the /resource from the original variable so we
won't have to do this again every time. */
s = strchr( acc->user, '/' );
*s = 0;
}
jd->node_cache = g_hash_table_new_full( g_str_hash, g_str_equal, NULL, jabber_cache_entry_free );
jd->buddies = g_hash_table_new( g_str_hash, g_str_equal );
if( set_getbool( &acc->set, "oauth" ) )
{
GSList *p_in = NULL;
const char *tok;
jd->fd = jd->r_inpa = jd->w_inpa = -1;
if( strstr( jd->server, ".live.com" ) )
jd->oauth2_service = &oauth2_service_mslive;
else if( strstr( jd->server, ".facebook.com" ) )
jd->oauth2_service = &oauth2_service_facebook;
else
jd->oauth2_service = &oauth2_service_google;
oauth_params_parse( &p_in, ic->acc->pass );
/* First see if we have a refresh token, in which case any
access token we *might* have has probably expired already
anyway. */
if( ( tok = oauth_params_get( &p_in, "refresh_token" ) ) )
{
sasl_oauth2_refresh( ic, tok );
}
/* If we don't have a refresh token, let's hope the access
token is still usable. */
else if( ( tok = oauth_params_get( &p_in, "access_token" ) ) )
{
jd->oauth2_access_token = g_strdup( tok );
jabber_connect( ic );
}
/* If we don't have any, start the OAuth process now. Don't
even open an XMPP connection yet. */
else
{
sasl_oauth2_init( ic );
ic->flags |= OPT_SLOW_LOGIN;
}
oauth_params_free( &p_in );
}
else
jabber_connect( ic );
}
xt_status jabber_pkt_iq( struct xt_node *node, gpointer data )
{
struct im_connection *ic = data;
struct jabber_data *jd = ic->proto_data;
struct xt_node *c, *reply = NULL;
char *type, *s;
int st, pack = 1;
type = xt_find_attr( node, "type" );
if( !type )
{
imcb_error( ic, "Received IQ packet without type." );
imc_logout( ic, TRUE );
return XT_ABORT;
}
if( strcmp( type, "result" ) == 0 || strcmp( type, "error" ) == 0 )
{
return jabber_cache_handle_packet( ic, node );
}
else if( strcmp( type, "get" ) == 0 )
{
if( !( ( c = xt_find_node( node->children, "query" ) ) ||
( c = xt_find_node( node->children, "ping" ) ) ||
( c = xt_find_node( node->children, "time" ) ) ) ||
!( s = xt_find_attr( c, "xmlns" ) ) )
{
/* Sigh. Who decided to suddenly invent new elements
instead of just sticking with <query/>? */
return XT_HANDLED;
}
reply = xt_new_node( "query", NULL, NULL );
xt_add_attr( reply, "xmlns", s );
/* Of course this is a very essential query to support. ;-) */
if( strcmp( s, XMLNS_VERSION ) == 0 )
{
xt_add_child( reply, xt_new_node( "name", set_getstr( &ic->acc->set, "user_agent" ), NULL ) );
xt_add_child( reply, xt_new_node( "version", BITLBEE_VERSION, NULL ) );
xt_add_child( reply, xt_new_node( "os", ARCH, NULL ) );
}
else if( strcmp( s, XMLNS_TIME_OLD ) == 0 )
{
time_t time_ep;
char buf[1024];
buf[sizeof(buf)-1] = 0;
time_ep = time( NULL );
strftime( buf, sizeof( buf ) - 1, "%Y%m%dT%H:%M:%S", gmtime( &time_ep ) );
xt_add_child( reply, xt_new_node( "utc", buf, NULL ) );
strftime( buf, sizeof( buf ) - 1, "%Z", localtime( &time_ep ) );
xt_add_child( reply, xt_new_node( "tz", buf, NULL ) );
}
else if( strcmp( s, XMLNS_TIME ) == 0 )
{
time_t time_ep;
char buf[1024];
buf[sizeof(buf)-1] = 0;
time_ep = time( NULL );
xt_free_node( reply );
reply = xt_new_node( "time", NULL, NULL );
xt_add_attr( reply, "xmlns", XMLNS_TIME );
strftime( buf, sizeof( buf ) - 1, "%Y%m%dT%H:%M:%SZ", gmtime( &time_ep ) );
xt_add_child( reply, xt_new_node( "utc", buf, NULL ) );
strftime( buf, sizeof( buf ) - 1, "%z", localtime( &time_ep ) );
if( strlen( buf ) >= 5 )
{
buf[6] = '\0';
buf[5] = buf[4];
buf[4] = buf[3];
buf[3] = ':';
}
xt_add_child( reply, xt_new_node( "tzo", buf, NULL ) );
}
else if( strcmp( s, XMLNS_PING ) == 0 )
{
xt_free_node( reply );
reply = jabber_make_packet( "iq", "result", xt_find_attr( node, "from" ), NULL );
if( ( s = xt_find_attr( node, "id" ) ) )
xt_add_attr( reply, "id", s );
pack = 0;
}
else if( strcmp( s, XMLNS_DISCO_INFO ) == 0 )
{
const char *features[] = { XMLNS_DISCO_INFO,
XMLNS_VERSION,
XMLNS_TIME_OLD,
XMLNS_TIME,
XMLNS_CHATSTATES,
XMLNS_MUC,
XMLNS_PING,
XMLNS_SI,
XMLNS_BYTESTREAMS,
XMLNS_FILETRANSFER,
NULL };
const char **f;
c = xt_new_node( "identity", NULL, NULL );
xt_add_attr( c, "category", "client" );
xt_add_attr( c, "type", "pc" );
xt_add_attr( c, "name", set_getstr( &ic->acc->set, "user_agent" ) );
xt_add_child( reply, c );
for( f = features; *f; f ++ )
{
c = xt_new_node( "feature", NULL, NULL );
xt_add_attr( c, "var", *f );
xt_add_child( reply, c );
}
}
else
{
xt_free_node( reply );
reply = jabber_make_error_packet( node, "feature-not-implemented", "cancel", NULL );
pack = 0;
}
}
else if( strcmp( type, "set" ) == 0 )
{
if( ( c = xt_find_node( node->children, "si" ) ) &&
( s = xt_find_attr( c, "xmlns" ) ) &&
( strcmp( s, XMLNS_SI ) == 0 ) )
{
return jabber_si_handle_request( ic, node, c );
}
else if( !( c = xt_find_node( node->children, "query" ) ) ||
!( s = xt_find_attr( c, "xmlns" ) ) )
{
return XT_HANDLED;
}
else if( strcmp( s, XMLNS_ROSTER ) == 0 )
{
/* This is a roster push. XMPP servers send this when someone
was added to (or removed from) the buddy list. AFAIK they're
sent even if we added this buddy in our own session. */
int bare_len = strlen( jd->me );
if( ( s = xt_find_attr( node, "from" ) ) == NULL ||
( strncmp( s, jd->me, bare_len ) == 0 &&
( s[bare_len] == 0 || s[bare_len] == '/' ) ) )
{
jabber_parse_roster( ic, node, NULL );
/* Should we generate a reply here? Don't think it's
very important... */
}
else
{
imcb_log( ic, "Warning: %s tried to fake a roster push!", s ? s : "(unknown)" );
xt_free_node( reply );
reply = jabber_make_error_packet( node, "not-allowed", "cancel", NULL );
pack = 0;
}
}
else if( strcmp( s, XMLNS_BYTESTREAMS ) == 0 )
{
/* Bytestream Request (stage 2 of file transfer) */
return jabber_bs_recv_request( ic, node, c );
}
else
{
xt_free_node( reply );
reply = jabber_make_error_packet( node, "feature-not-implemented", "cancel", NULL );
pack = 0;
}
}
/* If we recognized the xmlns and managed to generate a reply,
finish and send it. */
if( reply )
{
/* Normally we still have to pack it into an iq-result
packet, but for errors, for example, we don't. */
if( pack )
{
reply = jabber_make_packet( "iq", "result", xt_find_attr( node, "from" ), reply );
if( ( s = xt_find_attr( node, "id" ) ) )
xt_add_attr( reply, "id", s );
}
st = jabber_write_packet( ic, reply );
xt_free_node( reply );
if( !st )
return XT_ABORT;
}
return XT_HANDLED;
}
static int parseinfo_create(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs, aim_snac_t *snac2)
{
aim_rxcallback_t userfunc;
aim_tlvlist_t *tlvlist, *innerlist;
char *ck = NULL, *fqcn = NULL, *name = NULL;
guint16 exchange = 0, instance = 0, unknown = 0, flags = 0, maxmsglen = 0, maxoccupancy = 0;
guint32 createtime = 0;
guint8 createperms = 0, detaillevel;
int cklen;
aim_tlv_t *bigblock;
int ret = 0;
aim_bstream_t bbbs;
tlvlist = aim_readtlvchain(bs);
if (!(bigblock = aim_gettlv(tlvlist, 0x0004, 1))) {
imcb_error(sess->aux_data, "no bigblock in top tlv in create room response");
aim_freetlvchain(&tlvlist);
return 0;
}
aim_bstream_init(&bbbs, bigblock->value, bigblock->length);
exchange = aimbs_get16(&bbbs);
cklen = aimbs_get8(&bbbs);
ck = aimbs_getstr(&bbbs, cklen);
instance = aimbs_get16(&bbbs);
detaillevel = aimbs_get8(&bbbs);
if (detaillevel != 0x02) {
imcb_error(sess->aux_data, "unknown detaillevel in create room response");
aim_freetlvchain(&tlvlist);
g_free(ck);
return 0;
}
unknown = aimbs_get16(&bbbs);
innerlist = aim_readtlvchain(&bbbs);
if (aim_gettlv(innerlist, 0x006a, 1))
fqcn = aim_gettlv_str(innerlist, 0x006a, 1);
if (aim_gettlv(innerlist, 0x00c9, 1))
flags = aim_gettlv16(innerlist, 0x00c9, 1);
if (aim_gettlv(innerlist, 0x00ca, 1))
createtime = aim_gettlv32(innerlist, 0x00ca, 1);
if (aim_gettlv(innerlist, 0x00d1, 1))
maxmsglen = aim_gettlv16(innerlist, 0x00d1, 1);
if (aim_gettlv(innerlist, 0x00d2, 1))
maxoccupancy = aim_gettlv16(innerlist, 0x00d2, 1);
if (aim_gettlv(innerlist, 0x00d3, 1))
name = aim_gettlv_str(innerlist, 0x00d3, 1);
if (aim_gettlv(innerlist, 0x00d5, 1))
createperms = aim_gettlv8(innerlist, 0x00d5, 1);
if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype))) {
ret = userfunc(sess, rx, snac2->type, fqcn, instance, exchange, flags, createtime, maxmsglen, maxoccupancy, createperms, unknown, name, ck);
}
g_free(ck);
g_free(name);
g_free(fqcn);
aim_freetlvchain(&innerlist);
aim_freetlvchain(&tlvlist);
return ret;
}
/* Separate this from jabber_login() so we can do OAuth first if necessary.
Putting this in io.c would probably be more correct. */
void jabber_connect(struct im_connection *ic)
{
account_t *acc = ic->acc;
struct jabber_data *jd = ic->proto_data;
int i;
char *connect_to;
struct ns_srv_reply **srvl = NULL, *srv = NULL;
/* Figure out the hostname to connect to. */
if (acc->server && *acc->server) {
connect_to = acc->server;
} else if ((srvl = srv_lookup("xmpp-client", "tcp", jd->server)) ||
(srvl = srv_lookup("jabber-client", "tcp", jd->server))) {
/* Find the lowest-priority one. These usually come
back in random/shuffled order. Not looking at
weights etc for now. */
srv = *srvl;
for (i = 1; srvl[i]; i++) {
if (srvl[i]->prio < srv->prio) {
srv = srvl[i];
}
}
connect_to = srv->name;
} else {
connect_to = jd->server;
}
imcb_log(ic, "Connecting");
for (i = 0; jabber_port_list[i] > 0; i++) {
if (set_getint(&acc->set, "port") == jabber_port_list[i]) {
break;
}
}
if (jabber_port_list[i] == 0) {
imcb_log(ic, "Illegal port number");
imc_logout(ic, FALSE);
return;
}
/* For non-SSL connections we can try to use the port # from the SRV
reply, but let's not do that when using SSL, SSL usually runs on
non-standard ports... */
if (set_getbool(&acc->set, "ssl")) {
jd->ssl = ssl_connect(connect_to, set_getint(&acc->set, "port"), set_getbool(&acc->set,
"tls_verify"), jabber_connected_ssl,
ic);
jd->fd = jd->ssl ? ssl_getfd(jd->ssl) : -1;
} else {
jd->fd = proxy_connect(connect_to, srv ? srv->port : set_getint(&acc->set,
"port"), jabber_connected_plain, ic);
}
srv_free(srvl);
if (jd->fd == -1) {
imcb_error(ic, "Could not connect to server");
imc_logout(ic, TRUE);
return;
}
if (set_getbool(&acc->set, "xmlconsole")) {
jabber_xmlconsole_enable(ic);
}
if (set_getbool(&acc->set, "mail_notifications")) {
/* It's gmail specific, but it checks for server support before enabling it */
jd->flags |= JFLAG_GMAILNOTIFY;
if (set_getstr(&acc->set, "mail_notifications_handle")) {
imcb_add_buddy(ic, set_getstr(&acc->set, "mail_notifications_handle"), NULL);
}
}
jabber_generate_id_hash(jd);
}
static int outgoingim(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
{
int i, ret = 0;
aim_rxcallback_t userfunc;
guint16 channel;
aim_tlvlist_t *tlvlist;
char *sn;
int snlen;
guint16 icbmflags = 0;
guint8 flag1 = 0, flag2 = 0;
char *msg = NULL;
aim_tlv_t *msgblock;
/* ICBM Cookie. */
for (i = 0; i < 8; i++)
aimbs_get8(bs);
/* Channel ID */
channel = aimbs_get16(bs);
if (channel != 0x01) {
imcb_error(sess->aux_data, "icbm: ICBM received on unsupported channel. Ignoring.");
return 0;
}
snlen = aimbs_get8(bs);
sn = aimbs_getstr(bs, snlen);
tlvlist = aim_readtlvchain(bs);
if (aim_gettlv(tlvlist, 0x0003, 1))
icbmflags |= AIM_IMFLAGS_ACK;
if (aim_gettlv(tlvlist, 0x0004, 1))
icbmflags |= AIM_IMFLAGS_AWAY;
if ((msgblock = aim_gettlv(tlvlist, 0x0002, 1))) {
aim_bstream_t mbs;
int featurelen, msglen;
aim_bstream_init(&mbs, msgblock->value, msgblock->length);
aimbs_get8(&mbs);
aimbs_get8(&mbs);
for (featurelen = aimbs_get16(&mbs); featurelen; featurelen--)
aimbs_get8(&mbs);
aimbs_get8(&mbs);
aimbs_get8(&mbs);
msglen = aimbs_get16(&mbs) - 4; /* final block length */
flag1 = aimbs_get16(&mbs);
flag2 = aimbs_get16(&mbs);
msg = aimbs_getstr(&mbs, msglen);
}
if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
ret = userfunc(sess, rx, channel, sn, msg, icbmflags, flag1, flag2);
g_free(sn);
aim_freetlvchain(&tlvlist);
return ret;
}
static void skype_parse_call(struct im_connection *ic, char *line)
{
struct skype_data *sd = ic->proto_data;
char *id = strchr(line, ' ');
char buf[IRC_LINE_SIZE];
if (!++id)
return;
char *info = strchr(id, ' ');
if (!info)
return;
*info = '\0';
info++;
if (!strncmp(info, "FAILUREREASON ", 14))
sd->failurereason = atoi(strchr(info, ' '));
else if (!strcmp(info, "STATUS RINGING")) {
if (sd->call_id)
g_free(sd->call_id);
sd->call_id = g_strdup(id);
skype_printf(ic, "GET CALL %s PARTNER_HANDLE\n", id);
sd->call_status = SKYPE_CALL_RINGING;
} else if (!strcmp(info, "STATUS MISSED")) {
skype_printf(ic, "GET CALL %s PARTNER_HANDLE\n", id);
sd->call_status = SKYPE_CALL_MISSED;
} else if (!strcmp(info, "STATUS CANCELLED")) {
skype_printf(ic, "GET CALL %s PARTNER_HANDLE\n", id);
sd->call_status = SKYPE_CALL_CANCELLED;
} else if (!strcmp(info, "STATUS FINISHED")) {
skype_printf(ic, "GET CALL %s PARTNER_HANDLE\n", id);
sd->call_status = SKYPE_CALL_FINISHED;
} else if (!strcmp(info, "STATUS REFUSED")) {
skype_printf(ic, "GET CALL %s PARTNER_HANDLE\n", id);
sd->call_status = SKYPE_CALL_REFUSED;
} else if (!strcmp(info, "STATUS UNPLACED")) {
if (sd->call_id)
g_free(sd->call_id);
/* Save the ID for later usage (Cancel/Finish). */
sd->call_id = g_strdup(id);
sd->call_out = TRUE;
} else if (!strcmp(info, "STATUS FAILED")) {
imcb_error(ic, "Call failed: %s",
skype_call_strerror(sd->failurereason));
sd->call_id = NULL;
} else if (!strncmp(info, "DURATION ", 9)) {
if (sd->call_duration)
g_free(sd->call_duration);
sd->call_duration = g_strdup(info+9);
} else if (!strncmp(info, "PARTNER_HANDLE ", 15)) {
info += 15;
if (!sd->call_status)
return;
switch (sd->call_status) {
case SKYPE_CALL_RINGING:
if (sd->call_out)
imcb_log(ic, "You are currently ringing the user %s.", info);
else {
g_snprintf(buf, IRC_LINE_SIZE,
"The user %s is currently ringing you.",
info);
skype_call_ask(ic, sd->call_id, buf);
}
break;
case SKYPE_CALL_MISSED:
imcb_log(ic, "You have missed a call from user %s.",
info);
break;
case SKYPE_CALL_CANCELLED:
imcb_log(ic, "You cancelled the call to the user %s.",
info);
sd->call_status = 0;
sd->call_out = FALSE;
break;
case SKYPE_CALL_REFUSED:
if (sd->call_out)
imcb_log(ic, "The user %s refused the call.",
info);
else
imcb_log(ic,
"You refused the call from user %s.",
info);
sd->call_out = FALSE;
break;
case SKYPE_CALL_FINISHED:
if (sd->call_duration)
imcb_log(ic,
"You finished the call to the user %s "
"(duration: %s seconds).",
info, sd->call_duration);
else
imcb_log(ic,
"You finished the call to the user %s.",
info);
sd->call_out = FALSE;
break;
default:
/* Don't be noisy, ignore other statuses for now. */
break;
}
sd->call_status = 0;
}
}
/*
* It can easily be said that parsing ICBMs is THE single
* most difficult thing to do in the in AIM protocol. In
* fact, I think I just did say that.
*
* Below is the best damned solution I've come up with
* over the past sixteen months of battling with it. This
* can parse both away and normal messages from every client
* I have access to. Its not fast, its not clean. But it works.
*
*/
static int incomingim(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
{
int i, ret = 0;
guint8 cookie[8];
guint16 channel;
aim_userinfo_t userinfo;
memset(&userinfo, 0x00, sizeof(aim_userinfo_t));
/*
* Read ICBM Cookie. And throw away.
*/
for (i = 0; i < 8; i++)
cookie[i] = aimbs_get8(bs);
/*
* Channel ID.
*
* Channel 0x0001 is the message channel. There are
* other channels for things called "rendevous"
* which represent chat and some of the other new
* features of AIM2/3/3.5.
*
* Channel 0x0002 is the Rendevous channel, which
* is where Chat Invitiations and various client-client
* connection negotiations come from.
*
* Channel 0x0004 is used for ICQ authorization, or
* possibly any system notice.
*
*/
channel = aimbs_get16(bs);
/*
* Extract the standard user info block.
*
* Note that although this contains TLVs that appear contiguous
* with the TLVs read below, they are two different pieces. The
* userinfo block contains the number of TLVs that contain user
* information, the rest are not even though there is no seperation.
* aim_extractuserinfo() returns the number of bytes used by the
* userinfo tlvs, so you can start reading the rest of them right
* afterward.
*
* That also means that TLV types can be duplicated between the
* userinfo block and the rest of the message, however there should
* never be two TLVs of the same type in one block.
*
*/
aim_extractuserinfo(sess, bs, &userinfo);
/*
* From here on, its depends on what channel we're on.
*
* Technically all channels have a TLV list have this, however,
* for the common channel 1 case, in-place parsing is used for
* performance reasons (less memory allocation).
*/
if (channel == 1) {
ret = incomingim_ch1(sess, mod, rx, snac, channel, &userinfo, bs, cookie);
} else if (channel == 2) {
aim_tlvlist_t *tlvlist;
/*
* Read block of TLVs (not including the userinfo data). All
* further data is derived from what is parsed here.
*/
tlvlist = aim_readtlvchain(bs);
ret = incomingim_ch2(sess, mod, rx, snac, channel, &userinfo, tlvlist, cookie);
aim_freetlvchain(&tlvlist);
} else if (channel == 4) {
aim_tlvlist_t *tlvlist;
tlvlist = aim_readtlvchain(bs);
ret = incomingim_ch4(sess, mod, rx, snac, channel, &userinfo, tlvlist, cookie);
aim_freetlvchain(&tlvlist);
} else {
imcb_error(sess->aux_data, "ICBM received on an unsupported channel. Ignoring.");
return 0;
}
return ret;
}
static gboolean jabber_read_callback( gpointer data, gint fd, b_input_condition cond )
{
struct im_connection *ic = data;
struct jabber_data *jd = ic->proto_data;
char buf[512];
int st;
if( jd->fd == -1 )
return FALSE;
if( jd->ssl )
st = ssl_read( jd->ssl, buf, sizeof( buf ) );
else
st = read( jd->fd, buf, sizeof( buf ) );
if( st > 0 )
{
/* Parse. */
if( xt_feed( jd->xt, buf, st ) < 0 )
{
imcb_error( ic, "XML stream error" );
imc_logout( ic, TRUE );
return FALSE;
}
/* Execute all handlers. */
if( !xt_handle( jd->xt, NULL, 1 ) )
{
/* Don't do anything, the handlers should have
aborted the connection already. */
return FALSE;
}
if( jd->flags & JFLAG_STREAM_RESTART )
{
jd->flags &= ~JFLAG_STREAM_RESTART;
jabber_start_stream( ic );
}
/* Garbage collection. */
xt_cleanup( jd->xt, NULL, 1 );
/* This is a bit hackish, unfortunately. Although xmltree
has nifty event handler stuff, it only calls handlers
when nodes are complete. Since the server should only
send an opening <stream:stream> tag, we have to check
this by hand. :-( */
if( !( jd->flags & JFLAG_STREAM_STARTED ) && jd->xt && jd->xt->root )
{
if( g_strcasecmp( jd->xt->root->name, "stream:stream" ) == 0 )
{
jd->flags |= JFLAG_STREAM_STARTED;
/* If there's no version attribute, assume
this is an old server that can't do SASL
authentication. */
if( !sasl_supported( ic ) )
{
/* If there's no version= tag, we suppose
this server does NOT implement: XMPP 1.0,
SASL and TLS. */
if( set_getbool( &ic->acc->set, "tls" ) )
{
imcb_error( ic, "TLS is turned on for this "
"account, but is not supported by this server" );
imc_logout( ic, FALSE );
return FALSE;
}
else
{
return jabber_init_iq_auth( ic );
}
}
}
else
{
imcb_error( ic, "XML stream error" );
imc_logout( ic, TRUE );
return FALSE;
}
}
}
else if( st == 0 || ( st < 0 && !ssl_sockerr_again( jd->ssl ) ) )
{
closesocket( jd->fd );
jd->fd = -1;
imcb_error( ic, "Error while reading from server" );
imc_logout( ic, TRUE );
return FALSE;
}
if( ssl_pending( jd->ssl ) )
/* OpenSSL empties the TCP buffers completely but may keep some
data in its internap buffers. select() won't see that, but
ssl_pending() does. */
return jabber_read_callback( data, fd, cond );
else
return TRUE;
}
static int
discord_ws_callback(struct lws *wsi,
enum lws_callback_reasons reason,
void *user, void *in, size_t len)
{
struct im_connection *ic = NULL;
discord_data *dd = NULL;
if (wsi == NULL) {
return 0;
}
struct lws_context *wsctx = lws_get_context(wsi);
if (wsctx != NULL) {
ic = lws_context_user(wsctx);
dd = ic->proto_data;
}
switch(reason) {
case LWS_CALLBACK_CLIENT_ESTABLISHED:
dd->state = WS_CONNECTED;
lws_callback_on_writable(wsi);
break;
case LWS_CALLBACK_CLIENT_CONNECTION_ERROR:
imcb_error(ic, "Websocket connection error");
if (in != NULL) {
imcb_error(ic, in);
}
b_event_remove(dd->keepalive_loop_id);
dd->keepalive_loop_id = 0;
dd->state = WS_CLOSING;
break;
case LWS_CALLBACK_CLIENT_WRITEABLE:
if (dd->state == WS_CONNECTED) {
GString *buf = g_string_new("");
g_string_printf(buf, "{\"d\":{\"v\":3,\"token\":\"%s\",\"properties\":{\"$referring_domain\":\"\",\"$browser\":\"bitlbee-discord\",\"$device\":\"bitlbee\",\"$referrer\":\"\",\"$os\":\"linux\"}},\"op\":2}", dd->token);
discord_ws_send_payload(wsi, buf->str, buf->len);
g_string_free(buf, TRUE);
} else if (dd->state == WS_READY) {
GString *buf = g_string_new("");
g_string_printf(buf, "{\"op\":1,\"d\":%tu}", time(NULL));
discord_ws_send_payload(dd->lws, buf->str, buf->len);
g_string_free(buf, TRUE);
} else {
g_print("%s: Unhandled writable callback\n", __func__);
}
break;
case LWS_CALLBACK_CLIENT_RECEIVE:
{
size_t rpload = lws_remaining_packet_payload(wsi);
if (dd->ws_buf == NULL) {
dd->ws_buf = g_string_new("");
}
dd->ws_buf = g_string_append(dd->ws_buf, in);
if (rpload == 0) {
discord_parse_message(ic);
g_string_free(dd->ws_buf, TRUE);
dd->ws_buf = NULL;
}
break;
}
case LWS_CALLBACK_CLOSED:
b_event_remove(dd->keepalive_loop_id);
dd->keepalive_loop_id = 0;
dd->state = WS_CLOSING;
lws_cancel_service(dd->lwsctx);
break;
case LWS_CALLBACK_ADD_POLL_FD:
{
struct lws_pollargs *pargs = in;
dd->main_loop_id = b_input_add(pargs->fd, B_EV_IO_READ,
discord_ws_service_loop, ic);
break;
}
case LWS_CALLBACK_DEL_POLL_FD:
b_event_remove(dd->main_loop_id);
break;
case LWS_CALLBACK_CHANGE_MODE_POLL_FD:
{
struct lws_pollargs *pargs = in;
int flags = 0;
b_event_remove(dd->main_loop_id);
if (pargs->events & POLLIN) {
flags |= B_EV_IO_READ;
}
if (pargs->events & POLLOUT) {
flags |= B_EV_IO_WRITE;
}
dd->main_loop_id = b_input_add(pargs->fd, flags,
discord_ws_service_loop, ic);
break;
}
case LWS_CALLBACK_CLIENT_CONFIRM_EXTENSION_SUPPORTED:
case LWS_CALLBACK_GET_THREAD_ID:
case LWS_CALLBACK_LOCK_POLL:
case LWS_CALLBACK_UNLOCK_POLL:
case LWS_CALLBACK_OPENSSL_LOAD_EXTRA_CLIENT_VERIFY_CERTS:
case LWS_CALLBACK_PROTOCOL_INIT:
case LWS_CALLBACK_PROTOCOL_DESTROY:
case LWS_CALLBACK_CLIENT_APPEND_HANDSHAKE_HEADER:
case LWS_CALLBACK_CLIENT_FILTER_PRE_ESTABLISH:
case LWS_CALLBACK_WSI_CREATE:
case LWS_CALLBACK_WSI_DESTROY:
// Ignoring these, this block should be removed when defult is set to
// stay silent.
break;
default:
g_print("%s: unknown rsn=%d\n", __func__, reason);
break;
}
return 0;
}
/**
* Login method. Since the twitter API works with separate HTTP request we
* only save the user and pass to the twitter_data object.
*/
static void twitter_login(account_t * acc)
{
struct im_connection *ic = imcb_new(acc);
struct twitter_data *td;
char name[strlen(acc->user) + 9];
url_t url;
char *s;
if (!url_set(&url, set_getstr(&ic->acc->set, "base_url")) ||
(url.proto != PROTO_HTTP && url.proto != PROTO_HTTPS)) {
imcb_error(ic, "Incorrect API base URL: %s", set_getstr(&ic->acc->set, "base_url"));
imc_logout(ic, FALSE);
return;
}
if (!strstr(url.host, "twitter.com") &&
set_getbool(&ic->acc->set, "stream")) {
imcb_error(ic, "Warning: The streaming API is only supported by Twitter, "
"and you seem to be connecting to a different service.");
}
imcb_log(ic, "Connecting");
twitter_connections = g_slist_append(twitter_connections, ic);
td = g_new0(struct twitter_data, 1);
ic->proto_data = td;
td->user = g_strdup(acc->user);
td->url_ssl = url.proto == PROTO_HTTPS;
td->url_port = url.port;
td->url_host = g_strdup(url.host);
if (strcmp(url.file, "/") != 0)
td->url_path = g_strdup(url.file);
else {
td->url_path = g_strdup("");
if (g_str_has_suffix(url.host, "twitter.com"))
/* May fire for people who turned on HTTPS. */
imcb_error(ic, "Warning: Twitter requires a version number in API calls "
"now. Try resetting the base_url account setting.");
}
/* Hacky string mangling: Turn identi.ca into identi.ca and api.twitter.com
into twitter, and try to be sensible if we get anything else. */
td->prefix = g_strdup(url.host);
if (g_str_has_suffix(td->prefix, ".com"))
td->prefix[strlen(url.host) - 4] = '\0';
if ((s = strrchr(td->prefix, '.')) && strlen(s) > 4) {
/* If we have at least 3 chars after the last dot, cut off the rest.
(mostly a www/api prefix or sth) */
s = g_strdup(s + 1);
g_free(td->prefix);
td->prefix = s;
}
if (strstr(acc->pass, "oauth_token="))
td->oauth_info = oauth_from_string(acc->pass, get_oauth_service(ic));
sprintf(name, "%s_%s", td->prefix, acc->user);
imcb_add_buddy(ic, name, NULL);
imcb_buddy_status(ic, name, OPT_LOGGED_IN, NULL, NULL);
td->log = g_new0(struct twitter_log_data, TWITTER_LOG_LENGTH);
td->log_id = -1;
s = set_getstr(&ic->acc->set, "mode");
if (g_strcasecmp(s, "one") == 0)
td->flags |= TWITTER_MODE_ONE;
else if (g_strcasecmp(s, "many") == 0)
td->flags |= TWITTER_MODE_MANY;
else
td->flags |= TWITTER_MODE_CHAT;
twitter_login_finish(ic);
}
/*
* Grab a single command sequence off the socket, and enqueue
* it in the incoming event queue in a seperate struct.
*/
int aim_get_command(aim_session_t *sess, aim_conn_t *conn)
{
guint8 flaphdr_raw[6];
aim_bstream_t flaphdr;
aim_frame_t *newrx;
guint16 payloadlen;
if (!sess || !conn)
return 0;
if (conn->fd == -1)
return -1; /* its a aim_conn_close()'d connection */
/* KIDS, THIS IS WHAT HAPPENS IF YOU USE CODE WRITTEN FOR GUIS IN A DAEMON!
And wouldn't it make sense to return something that prevents this function
from being called again IMMEDIATELY (and making the program suck up all
CPU time)?...
if (conn->fd < 3)
return 0;
*/
if (conn->status & AIM_CONN_STATUS_INPROGRESS)
return aim_conn_completeconnect(sess, conn);
aim_bstream_init(&flaphdr, flaphdr_raw, sizeof(flaphdr_raw));
/*
* Read FLAP header. Six bytes:
*
* 0 char -- Always 0x2a
* 1 char -- Channel ID. Usually 2 -- 1 and 4 are used during login.
* 2 short -- Sequence number
* 4 short -- Number of data bytes that follow.
*/
if (aim_bstream_recv(&flaphdr, conn->fd, 6) < 6) {
aim_conn_close(conn);
return -1;
}
aim_bstream_rewind(&flaphdr);
/*
* This shouldn't happen unless the socket breaks, the server breaks,
* or we break. We must handle it just in case.
*/
if (aimbs_get8(&flaphdr) != 0x2a) {
aim_bstream_rewind(&flaphdr);
aimbs_get8(&flaphdr);
imcb_error(sess->aux_data, "FLAP framing disrupted");
aim_conn_close(conn);
return -1;
}
/* allocate a new struct */
if (!(newrx = (aim_frame_t *)g_new0(aim_frame_t,1)))
return -1;
/* we're doing FLAP if we're here */
newrx->hdrtype = AIM_FRAMETYPE_FLAP;
newrx->hdr.flap.type = aimbs_get8(&flaphdr);
newrx->hdr.flap.seqnum = aimbs_get16(&flaphdr);
payloadlen = aimbs_get16(&flaphdr);
newrx->nofree = 0; /* free by default */
if (payloadlen) {
guint8 *payload = NULL;
if (!(payload = (guint8 *) g_malloc(payloadlen))) {
aim_frame_destroy(newrx);
return -1;
}
aim_bstream_init(&newrx->data, payload, payloadlen);
/* read the payload */
if (aim_bstream_recv(&newrx->data, conn->fd, payloadlen) < payloadlen) {
aim_frame_destroy(newrx); /* free's payload */
aim_conn_close(conn);
return -1;
}
} else
aim_bstream_init(&newrx->data, NULL, 0);
aim_bstream_rewind(&newrx->data);
newrx->conn = conn;
newrx->next = NULL; /* this will always be at the bottom */
if (!sess->queue_incoming)
sess->queue_incoming = newrx;
else {
aim_frame_t *cur;
for (cur = sess->queue_incoming; cur->next; cur = cur->next)
;
cur->next = newrx;
}
newrx->conn->lastactivity = time(NULL);
return 0;
}
xt_status sasl_pkt_mechanisms( struct xt_node *node, gpointer data )
{
struct im_connection *ic = data;
struct jabber_data *jd = ic->proto_data;
struct xt_node *c, *reply;
char *s;
int sup_plain = 0, sup_digest = 0, sup_gtalk = 0, sup_fb = 0;
int want_oauth = FALSE;
GString *mechs;
if( !sasl_supported( ic ) )
{
/* Should abort this now, since we should already be doing
IQ authentication. Strange things happen when you try
to do both... */
imcb_log( ic, "XMPP 1.0 non-compliant server seems to support SASL, please report this as a BitlBee bug!" );
return XT_HANDLED;
}
s = xt_find_attr( node, "xmlns" );
if( !s || strcmp( s, XMLNS_SASL ) != 0 )
{
imcb_log( ic, "Stream error while authenticating" );
imc_logout( ic, FALSE );
return XT_ABORT;
}
want_oauth = set_getbool( &ic->acc->set, "oauth" );
mechs = g_string_new( "" );
c = node->children;
while( ( c = xt_find_node( c, "mechanism" ) ) )
{
if( c->text && g_strcasecmp( c->text, "PLAIN" ) == 0 )
sup_plain = 1;
else if( c->text && g_strcasecmp( c->text, "DIGEST-MD5" ) == 0 )
sup_digest = 1;
else if( c->text && g_strcasecmp( c->text, "X-OAUTH2" ) == 0 )
sup_gtalk = 1;
else if( c->text && g_strcasecmp( c->text, "X-FACEBOOK-PLATFORM" ) == 0 )
sup_fb = 1;
if( c->text )
g_string_append_printf( mechs, " %s", c->text );
c = c->next;
}
if( !want_oauth && !sup_plain && !sup_digest )
{
if( !sup_gtalk && !sup_fb )
imcb_error( ic, "This server requires OAuth "
"(supported schemes:%s)", mechs->str );
else
imcb_error( ic, "BitlBee does not support any of the offered SASL "
"authentication schemes:%s", mechs->str );
imc_logout( ic, FALSE );
g_string_free( mechs, TRUE );
return XT_ABORT;
}
g_string_free( mechs, TRUE );
reply = xt_new_node( "auth", NULL, NULL );
xt_add_attr( reply, "xmlns", XMLNS_SASL );
if( sup_gtalk && want_oauth )
{
int len;
/* X-OAUTH2 is, not *the* standard OAuth2 SASL/XMPP implementation.
It's currently used by GTalk and vaguely documented on
http://code.google.com/apis/cloudprint/docs/rawxmpp.html . */
xt_add_attr( reply, "mechanism", "X-OAUTH2" );
len = strlen( jd->username ) + strlen( jd->oauth2_access_token ) + 2;
s = g_malloc( len + 1 );
s[0] = 0;
strcpy( s + 1, jd->username );
strcpy( s + 2 + strlen( jd->username ), jd->oauth2_access_token );
reply->text = base64_encode( (unsigned char *)s, len );
reply->text_len = strlen( reply->text );
g_free( s );
}
else if( sup_fb && want_oauth )
{
xt_add_attr( reply, "mechanism", "X-FACEBOOK-PLATFORM" );
jd->flags |= JFLAG_SASL_FB;
}
else if( want_oauth )
{
imcb_error( ic, "OAuth requested, but not supported by server" );
imc_logout( ic, FALSE );
xt_free_node( reply );
return XT_ABORT;
}
else if( sup_digest )
{
xt_add_attr( reply, "mechanism", "DIGEST-MD5" );
/* The rest will be done later, when we receive a <challenge/>. */
}
else if( sup_plain )
{
int len;
xt_add_attr( reply, "mechanism", "PLAIN" );
/* With SASL PLAIN in XMPP, the text should be b64(\0user\0pass) */
len = strlen( jd->username ) + strlen( ic->acc->pass ) + 2;
s = g_malloc( len + 1 );
s[0] = 0;
strcpy( s + 1, jd->username );
strcpy( s + 2 + strlen( jd->username ), ic->acc->pass );
reply->text = base64_encode( (unsigned char *)s, len );
reply->text_len = strlen( reply->text );
g_free( s );
}
if( reply && !jabber_write_packet( ic, reply ) )
{
xt_free_node( reply );
return XT_ABORT;
}
xt_free_node( reply );
/* To prevent classic authentication from happening. */
jd->flags |= JFLAG_STREAM_STARTED;
return XT_HANDLED;
}
static int msn_ns_command( struct msn_handler_data *handler, char **cmd, int num_parts )
{
struct im_connection *ic = handler->data;
struct msn_data *md = ic->proto_data;
if( num_parts == 0 )
{
/* Hrrm... Empty command...? Ignore? */
return( 1 );
}
if( strcmp( cmd[0], "VER" ) == 0 )
{
if( cmd[2] && strncmp( cmd[2], MSNP_VER, 5 ) != 0 )
{
imcb_error( ic, "Unsupported protocol" );
imc_logout( ic, FALSE );
return( 0 );
}
return( msn_ns_write( ic, handler->fd, "CVR %d 0x0409 mac 10.2.0 ppc macmsgs 3.5.1 macmsgs %s\r\n",
++md->trId, ic->acc->user ) );
}
else if( strcmp( cmd[0], "CVR" ) == 0 )
{
/* We don't give a damn about the information we just received */
return msn_ns_write( ic, handler->fd, "USR %d SSO I %s\r\n", ++md->trId, ic->acc->user );
}
else if( strcmp( cmd[0], "XFR" ) == 0 )
{
char *server;
int port;
if( num_parts >= 6 && strcmp( cmd[2], "NS" ) == 0 )
{
b_event_remove( handler->inpa );
handler->inpa = -1;
server = strchr( cmd[3], ':' );
if( !server )
{
imcb_error( ic, "Syntax error" );
imc_logout( ic, TRUE );
return( 0 );
}
*server = 0;
port = atoi( server + 1 );
server = cmd[3];
imcb_log( ic, "Transferring to other server" );
return msn_ns_connect( ic, handler, server, port );
}
else if( num_parts >= 6 && strcmp( cmd[2], "SB" ) == 0 )
{
struct msn_switchboard *sb;
server = strchr( cmd[3], ':' );
if( !server )
{
imcb_error( ic, "Syntax error" );
imc_logout( ic, TRUE );
return( 0 );
}
*server = 0;
port = atoi( server + 1 );
server = cmd[3];
if( strcmp( cmd[4], "CKI" ) != 0 )
{
imcb_error( ic, "Unknown authentication method for switchboard" );
imc_logout( ic, TRUE );
return( 0 );
}
debug( "Connecting to a new switchboard with key %s", cmd[5] );
if( ( sb = msn_sb_create( ic, server, port, cmd[5], MSN_SB_NEW ) ) == NULL )
{
/* Although this isn't strictly fatal for the NS connection, it's
definitely something serious (we ran out of file descriptors?). */
imcb_error( ic, "Could not create new switchboard" );
imc_logout( ic, TRUE );
return( 0 );
}
if( md->msgq )
{
struct msn_message *m = md->msgq->data;
GSList *l;
sb->who = g_strdup( m->who );
/* Move all the messages to the first user in the message
queue to the switchboard message queue. */
l = md->msgq;
while( l )
{
m = l->data;
l = l->next;
if( strcmp( m->who, sb->who ) == 0 )
{
sb->msgq = g_slist_append( sb->msgq, m );
md->msgq = g_slist_remove( md->msgq, m );
}
}
}
}
else
{
imcb_error( ic, "Syntax error" );
imc_logout( ic, TRUE );
return( 0 );
}
}
else if( strcmp( cmd[0], "USR" ) == 0 )
{
if( num_parts >= 6 && strcmp( cmd[2], "SSO" ) == 0 &&
strcmp( cmd[3], "S" ) == 0 )
{
g_free( md->pp_policy );
md->pp_policy = g_strdup( cmd[4] );
msn_soap_passport_sso_request( ic, cmd[5] );
}
else if( strcmp( cmd[2], "OK" ) == 0 )
{
/* If the number after the handle is 0, the e-mail
address is unverified, which means we can't change
the display name. */
if( cmd[4][0] == '0' )
md->flags |= MSN_EMAIL_UNVERIFIED;
imcb_log( ic, "Authenticated, getting buddy list" );
msn_soap_memlist_request( ic );
}
else
{
imcb_error( ic, "Unknown authentication type" );
imc_logout( ic, FALSE );
return( 0 );
}
}
else if( strcmp( cmd[0], "MSG" ) == 0 )
{
if( num_parts < 4 )
{
imcb_error( ic, "Syntax error" );
imc_logout( ic, TRUE );
return( 0 );
}
handler->msglen = atoi( cmd[3] );
if( handler->msglen <= 0 )
{
imcb_error( ic, "Syntax error" );
imc_logout( ic, TRUE );
return( 0 );
}
}
else if( strcmp( cmd[0], "BLP" ) == 0 )
{
msn_ns_send_adl_start( ic );
return msn_ns_finish_login( ic );
}
else if( strcmp( cmd[0], "ADL" ) == 0 )
{
if( num_parts >= 3 && strcmp( cmd[2], "OK" ) == 0 )
{
msn_ns_send_adl( ic );
return msn_ns_finish_login( ic );
}
else if( num_parts >= 3 )
{
handler->msglen = atoi( cmd[2] );
}
}
else if( strcmp( cmd[0], "PRP" ) == 0 )
{
imcb_connected( ic );
}
else if( strcmp( cmd[0], "CHL" ) == 0 )
{
char *resp;
int st;
if( num_parts < 3 )
{
imcb_error( ic, "Syntax error" );
imc_logout( ic, TRUE );
return( 0 );
}
resp = msn_p11_challenge( cmd[2] );
st = msn_ns_write( ic, -1, "QRY %d %s %zd\r\n%s",
++md->trId, MSNP11_PROD_ID,
strlen( resp ), resp );
g_free( resp );
return st;
}
else if( strcmp( cmd[0], "ILN" ) == 0 || strcmp( cmd[0], "NLN" ) == 0 )
{
const struct msn_away_state *st;
const char *handle;
int cap = 0;
if( num_parts < 6 )
{
imcb_error( ic, "Syntax error" );
imc_logout( ic, TRUE );
return( 0 );
}
/* ILN and NLN are more or less the same, except ILN has a trId
at the start, and NLN has a capability field at the end.
Does ILN still exist BTW? */
if( cmd[0][1] == 'I' )
cmd ++;
else
cap = atoi( cmd[4] );
handle = msn_normalize_handle( cmd[2] );
if( strcmp( handle, ic->acc->user ) == 0 )
return 1; /* That's me! */
http_decode( cmd[3] );
imcb_rename_buddy( ic, handle, cmd[3] );
st = msn_away_state_by_code( cmd[1] );
if( !st )
{
/* FIXME: Warn/Bomb about unknown away state? */
st = msn_away_state_list + 1;
}
imcb_buddy_status( ic, handle, OPT_LOGGED_IN |
( st != msn_away_state_list ? OPT_AWAY : 0 ) |
( cap & 1 ? OPT_MOBILE : 0 ),
st->name, NULL );
msn_sb_stop_keepalives( msn_sb_by_handle( ic, handle ) );
}
else if( strcmp( cmd[0], "FLN" ) == 0 )
{
const char *handle;
if( cmd[1] == NULL )
return 1;
handle = msn_normalize_handle( cmd[1] );
imcb_buddy_status( ic, handle, 0, NULL, NULL );
msn_sb_start_keepalives( msn_sb_by_handle( ic, handle ), TRUE );
}
else if( strcmp( cmd[0], "RNG" ) == 0 )
{
struct msn_switchboard *sb;
char *server;
int session, port;
if( num_parts < 7 )
{
imcb_error( ic, "Syntax error" );
imc_logout( ic, TRUE );
return( 0 );
}
session = atoi( cmd[1] );
server = strchr( cmd[2], ':' );
if( !server )
{
imcb_error( ic, "Syntax error" );
imc_logout( ic, TRUE );
return( 0 );
}
*server = 0;
port = atoi( server + 1 );
server = cmd[2];
if( strcmp( cmd[3], "CKI" ) != 0 )
{
imcb_error( ic, "Unknown authentication method for switchboard" );
imc_logout( ic, TRUE );
return( 0 );
}
debug( "Got a call from %s (session %d). Key = %s", cmd[5], session, cmd[4] );
if( ( sb = msn_sb_create( ic, server, port, cmd[4], session ) ) == NULL )
{
/* Although this isn't strictly fatal for the NS connection, it's
definitely something serious (we ran out of file descriptors?). */
imcb_error( ic, "Could not create new switchboard" );
imc_logout( ic, TRUE );
return( 0 );
}
else
{
sb->who = g_strdup( msn_normalize_handle( cmd[5] ) );
}
}
else if( strcmp( cmd[0], "OUT" ) == 0 )
{
int allow_reconnect = TRUE;
if( cmd[1] && strcmp( cmd[1], "OTH" ) == 0 )
{
imcb_error( ic, "Someone else logged in with your account" );
allow_reconnect = FALSE;
}
else if( cmd[1] && strcmp( cmd[1], "SSD" ) == 0 )
{
imcb_error( ic, "Terminating session because of server shutdown" );
}
else
{
imcb_error( ic, "Session terminated by remote server (%s)",
cmd[1] ? cmd[1] : "reason unknown)" );
}
imc_logout( ic, allow_reconnect );
return( 0 );
}
else if( strcmp( cmd[0], "IPG" ) == 0 )
{
imcb_error( ic, "Received IPG command, we don't handle them yet." );
handler->msglen = atoi( cmd[1] );
if( handler->msglen <= 0 )
{
imcb_error( ic, "Syntax error" );
imc_logout( ic, TRUE );
return( 0 );
}
}
#if 0
else if( strcmp( cmd[0], "ADG" ) == 0 )
{
char *group = g_strdup( cmd[3] );
int groupnum, i;
GSList *l, *next;
http_decode( group );
if( sscanf( cmd[4], "%d", &groupnum ) == 1 )
{
if( groupnum >= md->groupcount )
{
md->grouplist = g_renew( char *, md->grouplist, groupnum + 1 );
for( i = md->groupcount; i <= groupnum; i ++ )
md->grouplist[i] = NULL;
md->groupcount = groupnum + 1;
}
g_free( md->grouplist[groupnum] );
md->grouplist[groupnum] = group;
}
static int incomingim_ch2(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, guint16 channel, aim_userinfo_t *userinfo, aim_tlvlist_t *tlvlist, guint8 *cookie)
{
aim_rxcallback_t userfunc;
aim_tlv_t *block1, *servdatatlv;
aim_tlvlist_t *list2;
struct aim_incomingim_ch2_args args;
aim_bstream_t bbs, sdbs, *sdbsptr = NULL;
guint8 *cookie2;
int ret = 0;
char clientip1[30] = {""};
char clientip2[30] = {""};
char verifiedip[30] = {""};
memset(&args, 0, sizeof(args));
/*
* There's another block of TLVs embedded in the type 5 here.
*/
block1 = aim_gettlv(tlvlist, 0x0005, 1);
aim_bstream_init(&bbs, block1->value, block1->length);
/*
* First two bytes represent the status of the connection.
*
* 0 is a request, 1 is a deny (?), 2 is an accept
*/
args.status = aimbs_get16(&bbs);
/*
* Next comes the cookie. Should match the ICBM cookie.
*/
cookie2 = aimbs_getraw(&bbs, 8);
if (memcmp(cookie, cookie2, 8) != 0)
imcb_error(sess->aux_data, "rend: warning cookies don't match!");
memcpy(args.cookie, cookie2, 8);
g_free(cookie2);
/*
* The next 16bytes are a capability block so we can
* identify what type of rendezvous this is.
*/
args.reqclass = aim_getcap(sess, &bbs, 0x10);
/*
* What follows may be TLVs or nothing, depending on the
* purpose of the message.
*
* Ack packets for instance have nothing more to them.
*/
list2 = aim_readtlvchain(&bbs);
/*
* IP address from the perspective of the client.
*/
if (aim_gettlv(list2, 0x0002, 1)) {
aim_tlv_t *iptlv;
iptlv = aim_gettlv(list2, 0x0002, 1);
g_snprintf(clientip1, sizeof(clientip1), "%d.%d.%d.%d",
aimutil_get8(iptlv->value+0),
aimutil_get8(iptlv->value+1),
aimutil_get8(iptlv->value+2),
aimutil_get8(iptlv->value+3));
}
/*
* Secondary IP address from the perspective of the client.
*/
if (aim_gettlv(list2, 0x0003, 1)) {
aim_tlv_t *iptlv;
iptlv = aim_gettlv(list2, 0x0003, 1);
g_snprintf(clientip2, sizeof(clientip2), "%d.%d.%d.%d",
aimutil_get8(iptlv->value+0),
aimutil_get8(iptlv->value+1),
aimutil_get8(iptlv->value+2),
aimutil_get8(iptlv->value+3));
}
/*
* Verified IP address (from the perspective of Oscar).
*
* This is added by the server.
*/
if (aim_gettlv(list2, 0x0004, 1)) {
aim_tlv_t *iptlv;
iptlv = aim_gettlv(list2, 0x0004, 1);
g_snprintf(verifiedip, sizeof(verifiedip), "%d.%d.%d.%d",
aimutil_get8(iptlv->value+0),
aimutil_get8(iptlv->value+1),
aimutil_get8(iptlv->value+2),
aimutil_get8(iptlv->value+3));
}
/*
* Port number for something.
*/
if (aim_gettlv(list2, 0x0005, 1))
args.port = aim_gettlv16(list2, 0x0005, 1);
/*
* Error code.
*/
if (aim_gettlv(list2, 0x000b, 1))
args.errorcode = aim_gettlv16(list2, 0x000b, 1);
/*
* Invitation message / chat description.
*/
if (aim_gettlv(list2, 0x000c, 1))
args.msg = aim_gettlv_str(list2, 0x000c, 1);
/*
* Character set.
*/
if (aim_gettlv(list2, 0x000d, 1))
args.encoding = aim_gettlv_str(list2, 0x000d, 1);
/*
* Language.
*/
if (aim_gettlv(list2, 0x000e, 1))
args.language = aim_gettlv_str(list2, 0x000e, 1);
/* Unknown -- two bytes = 0x0001 */
if (aim_gettlv(list2, 0x000a, 1))
;
/* Unknown -- no value */
if (aim_gettlv(list2, 0x000f, 1))
;
if (strlen(clientip1))
args.clientip = (char *)clientip1;
if (strlen(clientip2))
args.clientip2 = (char *)clientip2;
if (strlen(verifiedip))
args.verifiedip = (char *)verifiedip;
/*
* This is must be present in PROPOSALs, but will probably not
* exist in CANCELs and ACCEPTs.
*
* Service Data blocks are module-specific in format.
*/
if ((servdatatlv = aim_gettlv(list2, 0x2711 /* 10001 */, 1))) {
aim_bstream_init(&sdbs, servdatatlv->value, servdatatlv->length);
sdbsptr = &sdbs;
}
if (args.reqclass & AIM_CAPS_ICQSERVERRELAY)
incomingim_ch2_icqserverrelay(sess, mod, rx, snac, userinfo, &args, sdbsptr);
else if (args.reqclass & AIM_CAPS_CHAT)
incomingim_ch2_chat(sess, mod, rx, snac, userinfo, &args, sdbsptr);
if ((userfunc = aim_callhandler(sess, rx->conn, snac->family, snac->subtype)))
ret = userfunc(sess, rx, channel, userinfo, &args);
if (args.destructor)
((ch2_args_destructor_t)args.destructor)(sess, &args);
g_free((char *)args.msg);
g_free((char *)args.encoding);
g_free((char *)args.language);
aim_freetlvchain(&list2);
return ret;
}
static xt_status jabber_pkt_features( struct xt_node *node, gpointer data )
{
struct im_connection *ic = data;
struct jabber_data *jd = ic->proto_data;
struct xt_node *c, *reply;
int trytls;
trytls = g_strcasecmp( set_getstr( &ic->acc->set, "tls" ), "try" ) == 0;
c = xt_find_node( node->children, "starttls" );
if( c && !jd->ssl )
{
/* If the server advertises the STARTTLS feature and if we're
not in a secure connection already: */
c = xt_find_node( c->children, "required" );
if( c && ( !trytls && !set_getbool( &ic->acc->set, "tls" ) ) )
{
imcb_error( ic, "Server requires TLS connections, but TLS is turned off for this account" );
imc_logout( ic, FALSE );
return XT_ABORT;
}
/* Only run this if the tls setting is set to true or try: */
if( ( trytls || set_getbool( &ic->acc->set, "tls" ) ) )
{
reply = xt_new_node( "starttls", NULL, NULL );
xt_add_attr( reply, "xmlns", XMLNS_TLS );
if( !jabber_write_packet( ic, reply ) )
{
xt_free_node( reply );
return XT_ABORT;
}
xt_free_node( reply );
return XT_HANDLED;
}
}
else if( !c && !jd->ssl )
{
/* If the server does not advertise the STARTTLS feature and
we're not in a secure connection already: (Servers have a
habit of not advertising <starttls/> anymore when already
using SSL/TLS. */
if( !trytls && set_getbool( &ic->acc->set, "tls" ) )
{
imcb_error( ic, "TLS is turned on for this account, but is not supported by this server" );
imc_logout( ic, FALSE );
return XT_ABORT;
}
}
/* This one used to be in jabber_handlers[], but it has to be done
from here to make sure the TLS session will be initialized
properly before we attempt SASL authentication. */
if( ( c = xt_find_node( node->children, "mechanisms" ) ) )
{
if( sasl_pkt_mechanisms( c, data ) == XT_ABORT )
return XT_ABORT;
}
/* If the server *SEEMS* to support SASL authentication but doesn't
support it after all, we should try to do authentication the
other way. jabber.com doesn't seem to do SASL while it pretends
to be XMPP 1.0 compliant! */
else if( !( jd->flags & JFLAG_AUTHENTICATED ) && sasl_supported( ic ) )
{
if( !jabber_init_iq_auth( ic ) )
return XT_ABORT;
}
if( ( c = xt_find_node( node->children, "bind" ) ) )
{
reply = xt_new_node( "bind", NULL, xt_new_node( "resource", set_getstr( &ic->acc->set, "resource" ), NULL ) );
xt_add_attr( reply, "xmlns", XMLNS_BIND );
reply = jabber_make_packet( "iq", "set", NULL, reply );
jabber_cache_add( ic, reply, jabber_pkt_bind_sess );
if( !jabber_write_packet( ic, reply ) )
return XT_ABORT;
jd->flags |= JFLAG_WAIT_BIND;
}
if( ( c = xt_find_node( node->children, "session" ) ) )
{
reply = xt_new_node( "session", NULL, NULL );
xt_add_attr( reply, "xmlns", XMLNS_SESSION );
reply = jabber_make_packet( "iq", "set", NULL, reply );
jabber_cache_add( ic, reply, jabber_pkt_bind_sess );
if( !jabber_write_packet( ic, reply ) )
return XT_ABORT;
jd->flags |= JFLAG_WAIT_SESSION;
}
/* This flag is already set if we authenticated via SASL, so now
we can resume the session in the new stream, if we don't have
to bind/initialize the session. */
if( jd->flags & JFLAG_AUTHENTICATED && ( jd->flags & ( JFLAG_WAIT_BIND | JFLAG_WAIT_SESSION ) ) == 0 )
{
if( !jabber_get_roster( ic ) )
return XT_ABORT;
}
return XT_HANDLED;
}
/**
* Subtype 0x0003 - Response to 0x0015/0x002, contains an ICQesque packet.
*/
static int icqresponse(aim_session_t *sess, aim_module_t *mod, aim_frame_t *rx, aim_modsnac_t *snac, aim_bstream_t *bs)
{
int ret = 0;
aim_tlvlist_t *tl;
aim_tlv_t *datatlv;
aim_bstream_t qbs;
guint32 ouruin;
guint16 cmdlen, cmd, reqid;
if (!(tl = aim_readtlvchain(bs)) || !(datatlv = aim_gettlv(tl, 0x0001, 1))) {
aim_freetlvchain(&tl);
imcb_error(sess->aux_data, "corrupt ICQ response\n");
return 0;
}
aim_bstream_init(&qbs, datatlv->value, datatlv->length);
cmdlen = aimbs_getle16(&qbs);
ouruin = aimbs_getle32(&qbs);
cmd = aimbs_getle16(&qbs);
reqid = aimbs_getle16(&qbs);
if (cmd == 0x0041) { /* offline message */
guint16 msglen;
struct aim_icq_offlinemsg msg;
aim_rxcallback_t userfunc;
memset(&msg, 0, sizeof(msg));
msg.sender = aimbs_getle32(&qbs);
msg.year = aimbs_getle16(&qbs);
msg.month = aimbs_getle8(&qbs);
msg.day = aimbs_getle8(&qbs);
msg.hour = aimbs_getle8(&qbs);
msg.minute = aimbs_getle8(&qbs);
msg.type = aimbs_getle16(&qbs);
msglen = aimbs_getle16(&qbs);
msg.msg = aimbs_getstr(&qbs, msglen);
if ((userfunc = aim_callhandler(sess, rx->conn, AIM_CB_FAM_ICQ, AIM_CB_ICQ_OFFLINEMSG)))
ret = userfunc(sess, rx, &msg);
g_free(msg.msg);
} else if (cmd == 0x0042) {
aim_rxcallback_t userfunc;
if ((userfunc = aim_callhandler(sess, rx->conn, AIM_CB_FAM_ICQ, AIM_CB_ICQ_OFFLINEMSGCOMPLETE)))
ret = userfunc(sess, rx);
} else if (cmd == 0x07da) { /* information */
guint16 subtype;
struct aim_icq_info *info;
aim_rxcallback_t userfunc;
subtype = aimbs_getle16(&qbs);
aim_bstream_advance(&qbs, 1); /* 0x0a */
/* find another data from the same request */
for (info = sess->icq_info; info && (info->reqid != reqid); info = info->next);
if (!info) {
info = g_new0(struct aim_icq_info, 1);
info->reqid = reqid;
info->next = sess->icq_info;
sess->icq_info = info;
}
