/* So it turns out some requests have no account context at all, because * libpurple hates us. This means that query_del_by_conn() won't remove those * on logout, and will segfault if the user replies. That's why this exists. */ static void prplcb_close_request(PurpleRequestType type, void *data) { struct prplcb_request_action_data *pqad; struct request_input_data *ri; struct purple_data *pd; if (!data) { return; } switch (type) { case PURPLE_REQUEST_ACTION: pqad = data; /* if this is null, it's because query_del was run already */ if (pqad->bee_data) { query_del(local_bee->ui_data, pqad->bee_data); } g_free(pqad); break; case PURPLE_REQUEST_INPUT: ri = data; pd = ri->ic->proto_data; imcb_remove_buddy(ri->ic, ri->buddy, NULL); g_free(ri->buddy); g_hash_table_remove(pd->input_requests, GUINT_TO_POINTER(ri->id)); break; default: g_free(data); break; } }
static gboolean sasl_oauth2_remove_contact( gpointer data, gint fd, b_input_condition cond ) { struct im_connection *ic = data; if( g_slist_find( jabber_connections, ic ) ) imcb_remove_buddy( ic, JABBER_OAUTH_HANDLE, NULL ); return FALSE; }
static xt_status jabber_parse_roster( struct im_connection *ic, struct xt_node *node, struct xt_node *orig ) { struct xt_node *query, *c; int initial = ( orig != NULL ); if( !( query = xt_find_node( node->children, "query" ) ) ) { imcb_log( ic, "Warning: Received NULL roster packet" ); return XT_HANDLED; } c = query->children; while( ( c = xt_find_node( c, "item" ) ) ) { struct xt_node *group = xt_find_node( c->children, "group" ); char *jid = xt_find_attr( c, "jid" ); char *name = xt_find_attr( c, "name" ); char *sub = xt_find_attr( c, "subscription" ); if( jid && sub ) { if( ( strcmp( sub, "both" ) == 0 || strcmp( sub, "to" ) == 0 ) ) { imcb_add_buddy( ic, jid, ( group && group->text_len ) ? group->text : NULL ); if( name ) imcb_rename_buddy( ic, jid, name ); } else if( strcmp( sub, "remove" ) == 0 ) { jabber_buddy_remove_bare( ic, jid ); imcb_remove_buddy( ic, jid, NULL ); } } c = c->next; } if( initial ) imcb_connected( ic ); return XT_HANDLED; }
/** * Processes a #SteamApiMsg. * * @param sata The #SteamData. * @param msg The #SteamUserMsg. * @param time The timestamp (UTC) of the message, or 0 for now. **/ static void steam_user_msg(SteamData *sata, SteamUserMsg *msg, gint64 time) { SteamUserInfo *info = msg->info; bee_user_t *bu; gchar *str; guint32 f; gchar sid[STEAM_ID_STR_MAX]; STEAM_ID_STR(info->id, sid); STEAM_UTIL_DEBUGLN("Incoming message from %s (Type: %u, Act: %u)", sid, msg->type, info->act); switch (msg->type) { case STEAM_USER_MSG_TYPE_EMOTE: case STEAM_USER_MSG_TYPE_SAYTEXT: bu = imcb_buddy_by_handle(sata->ic, sid); if ((bu != NULL) && (bu->flags & OPT_TYPING)) imcb_buddy_typing(sata->ic, sid, 0); if (msg->type == STEAM_USER_MSG_TYPE_EMOTE) str = g_strconcat("/me ", msg->text, NULL); else str = g_strdup(msg->text); imcb_buddy_msg(sata->ic, sid, str, 0, time); g_free(str); return; case STEAM_USER_MSG_TYPE_LEFT_CONV: imcb_buddy_typing(sata->ic, sid, 0); return; case STEAM_USER_MSG_TYPE_RELATIONSHIP: goto relationship; case STEAM_USER_MSG_TYPE_TYPING: bu = imcb_buddy_by_handle(sata->ic, sid); if (G_UNLIKELY(bu == NULL)) return; f = (bu->flags & OPT_TYPING) ? 0 : OPT_TYPING; imcb_buddy_typing(sata->ic, sid, f); return; default: steam_user_status(sata, info, NULL); return; } relationship: switch (info->act) { case STEAM_USER_ACT_REMOVE: case STEAM_USER_ACT_IGNORE: imcb_remove_buddy(sata->ic, sid, NULL); return; case STEAM_USER_ACT_REQUEST: imcb_ask_auth(sata->ic, sid, info->nick); return; case STEAM_USER_ACT_ADD: imcb_add_buddy(sata->ic, sid, NULL); imcb_buddy_nick_hint(sata->ic, sid, info->nick); imcb_rename_buddy(sata->ic, sid, info->fullname); steam_user_status(sata, info, NULL); return; default: return; } }
/* Not really the same syntax as the normal pkt_ functions, but this isn't called by the xmltree parser directly and this way I can add some extra parameters so we won't have to repeat too many things done by the caller already. */ void jabber_chat_pkt_presence(struct im_connection *ic, struct jabber_buddy *bud, struct xt_node *node) { struct groupchat *chat; struct xt_node *c; char *type = xt_find_attr(node, "type"); struct jabber_data *jd = ic->proto_data; struct jabber_chat *jc; char *s; if ((chat = jabber_chat_by_jid(ic, bud->bare_jid)) == NULL) { /* How could this happen?? We could do kill( self, 11 ) now or just wait for the OS to do it. :-) */ return; } jc = chat->data; if (type == NULL && !(bud->flags & JBFLAG_IS_CHATROOM)) { bud->flags |= JBFLAG_IS_CHATROOM; /* If this one wasn't set yet, this buddy just joined the chat. Slightly hackish way of finding out eh? ;-) */ /* This is pretty messy... Here it sets ext_jid to the real JID of the participant. Works for non-anonymized channels. Might break if someone joins a chat twice, though. */ for (c = node->children; (c = xt_find_node(c, "x")); c = c->next) { if ((s = xt_find_attr(c, "xmlns")) && (strcmp(s, XMLNS_MUC_USER) == 0)) { struct xt_node *item; item = xt_find_node(c->children, "item"); if ((s = xt_find_attr(item, "jid"))) { /* Yay, found what we need. :-) */ bud->ext_jid = jabber_normalize(s); break; } } } /* Make up some other handle, if necessary. */ if (bud->ext_jid == NULL) { if (bud == jc->me) { bud->ext_jid = g_strdup(jd->me); } else { int i; /* Don't want the nick to be at the end, so let's think of some slightly different notation to use for anonymous groupchat participants in BitlBee. */ bud->ext_jid = g_strdup_printf("%s=%s", bud->resource, bud->bare_jid); /* And strip any unwanted characters. */ for (i = 0; bud->resource[i]; i++) { if (bud->ext_jid[i] == '=' || bud->ext_jid[i] == '@') { bud->ext_jid[i] = '_'; } } /* Some program-specific restrictions. */ imcb_clean_handle(ic, bud->ext_jid); } bud->flags |= JBFLAG_IS_ANONYMOUS; } if (bud != jc->me && bud->flags & JBFLAG_IS_ANONYMOUS) { /* If JIDs are anonymized, add them to the local list for the duration of this chat. */ imcb_add_buddy(ic, bud->ext_jid, NULL); imcb_buddy_nick_hint(ic, bud->ext_jid, bud->resource); } if (bud == jc->me && jc->invite != NULL) { char *msg = g_strdup_printf("Please join me in room %s", jc->name); jabber_chat_invite(chat, jc->invite, msg); g_free(jc->invite); g_free(msg); jc->invite = NULL; } s = strchr(bud->ext_jid, '/'); if (s) { *s = 0; /* Should NEVER be NULL, but who knows... */ } imcb_chat_add_buddy(chat, bud->ext_jid); if (s) { *s = '/'; } } else if (type) { /* type can only be NULL or "unavailable" in this function */ if ((bud->flags & JBFLAG_IS_CHATROOM) && bud->ext_jid) { char *reason = NULL; char *status = NULL; char *status_text = NULL; if ((c = xt_find_node_by_attr(node->children, "x", "xmlns", XMLNS_MUC_USER))) { struct xt_node *c2 = c->children; while ((c2 = xt_find_node(c2, "status"))) { char *code = xt_find_attr(c2, "code"); if (g_strcmp0(code, "301") == 0) { status = "Banned"; break; } else if (g_strcmp0(code, "303") == 0) { /* This could be handled in a cleverer way, * but let's just show a literal part/join for now */ status = "Changing nicks"; break; } else if (g_strcmp0(code, "307") == 0) { status = "Kicked"; break; } c2 = c2->next; } /* Sometimes the status message is in presence/x/item/reason */ if ((c2 = xt_find_path(c, "item/reason")) && c2->text && c2->text_len) { status_text = c2->text; } } /* Sometimes the status message is right inside <presence> */ if ((c = xt_find_node(node->children, "status")) && c->text && c->text_len) { status_text = c->text; } if (status_text && status) { reason = g_strdup_printf("%s: %s", status, status_text); } else { reason = g_strdup(status_text ? : status); } s = strchr(bud->ext_jid, '/'); if (s) { *s = 0; } imcb_chat_remove_buddy(chat, bud->ext_jid, reason); if (bud != jc->me && bud->flags & JBFLAG_IS_ANONYMOUS) { imcb_remove_buddy(ic, bud->ext_jid, reason); } if (s) { *s = '/'; } g_free(reason); } if (bud == jc->me) { jabber_chat_free(chat); } }