static void
iln_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
{
MsnSession *session;
GaimAccount *account;
GaimConnection *gc;
MsnUser *user;
MsnObject *msnobj;
const char *state, *passport, *friendly;
session = cmdproc->session;
account = session->account;
gc = gaim_account_get_connection(account);
state = cmd->params[1];
passport = cmd->params[2];
friendly = gaim_url_decode(cmd->params[3]);
user = msn_userlist_find_user(session->userlist, passport);
serv_got_alias(gc, passport, friendly);
msn_user_set_friendly_name(user, friendly);
if (session->protocol_ver >= 9 && cmd->param_count == 6)
{
msnobj = msn_object_new_from_string(gaim_url_decode(cmd->params[5]));
msn_user_set_object(user, msnobj);
}
msn_user_set_state(user, state);
msn_user_update(user);
}
void p2tgl_got_alias (struct tgl_state *TLS, tgl_peer_id_t who, const char *alias) {
char *name = peer_strdup_id(who);
serv_got_alias(tg_get_conn(TLS), name, alias);
g_free (name);
}
static void
jabber_vcard_parse_avatar(JabberStream *js, const char *from,
JabberIqType type, const char *id,
xmlnode *packet, gpointer blah)
{
JabberBuddy *jb = NULL;
xmlnode *vcard, *photo, *binval, *fn, *nick;
char *text;
if(!from)
return;
jb = jabber_buddy_find(js, from, TRUE);
js->pending_avatar_requests = g_slist_remove(js->pending_avatar_requests, jb);
if((vcard = xmlnode_get_child(packet, "vCard")) ||
(vcard = xmlnode_get_child_with_namespace(packet, "query", "vcard-temp"))) {
/* The logic here regarding the nickname and full name is copied from
* buddy.c:jabber_vcard_parse. */
gchar *nickname = NULL;
if ((fn = xmlnode_get_child(vcard, "FN")))
nickname = xmlnode_get_data(fn);
if ((nick = xmlnode_get_child(vcard, "NICKNAME"))) {
char *tmp = xmlnode_get_data(nick);
char *bare_jid = jabber_get_bare_jid(from);
if (tmp && strstr(bare_jid, tmp) == NULL) {
g_free(nickname);
nickname = tmp;
} else if (tmp)
g_free(tmp);
g_free(bare_jid);
}
if (nickname) {
serv_got_alias(js->gc, from, nickname);
g_free(nickname);
}
if ((photo = xmlnode_get_child(vcard, "PHOTO")) &&
(binval = xmlnode_get_child(photo, "BINVAL")) &&
(text = xmlnode_get_data(binval))) {
guchar *data;
gsize size;
data = purple_base64_decode(text, &size);
if (data) {
gchar *hash = jabber_calculate_data_hash(data, size, "sha1");
purple_buddy_icons_set_for_user(js->gc->account, from, data,
size, hash);
g_free(hash);
}
g_free(text);
}
}
}
static void
nln_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
{
MsnSession *session;
GaimAccount *account;
GaimConnection *gc;
MsnUser *user;
MsnObject *msnobj;
int clientid;
const char *state, *passport, *friendly, *old_friendly;
session = cmdproc->session;
account = session->account;
gc = gaim_account_get_connection(account);
state = cmd->params[0];
passport = cmd->params[1];
friendly = gaim_url_decode(cmd->params[2]);
user = msn_userlist_find_user(session->userlist, passport);
old_friendly = msn_user_get_friendly_name(user);
if (!old_friendly || (old_friendly && strcmp(old_friendly, friendly)))
{
serv_got_alias(gc, passport, friendly);
msn_user_set_friendly_name(user, friendly);
}
if (session->protocol_ver >= 9)
{
if (cmd->param_count == 5)
{
msnobj =
msn_object_new_from_string(gaim_url_decode(cmd->params[4]));
msn_user_set_object(user, msnobj);
}
else
{
msn_user_set_object(user, NULL);
}
}
clientid = atoi(cmd->params[3]);
user->mobile = (clientid & MSN_CLIENT_CAP_MSNMOBILE);
msn_user_set_state(user, state);
msn_user_update(user);
}
gboolean
msn_user_set_friendly_name(MsnUser *user, const char *name)
{
g_return_val_if_fail(user != NULL, FALSE);
if (user->friendly_name && name && (!strcmp(user->friendly_name, name) ||
!strcmp(user->passport, name)))
return FALSE;
g_free(user->friendly_name);
user->friendly_name = g_strdup(name);
serv_got_alias(purple_account_get_connection(user->userlist->session->account),
user->passport, name);
return TRUE;
}
static void jabber_nick_cb(JabberStream *js, const char *from, xmlnode *items) {
/* it doesn't make sense to have more than one item here, so let's just pick the first one */
xmlnode *item = xmlnode_get_child(items, "item");
JabberBuddy *buddy = jabber_buddy_find(js, from, FALSE);
xmlnode *nick;
char *nickname = NULL;
/* ignore the nick of people not on our buddy list */
if (!buddy || !item)
return;
nick = xmlnode_get_child_with_namespace(item, "nick", "http://jabber.org/protocol/nick");
if (!nick)
return;
nickname = xmlnode_get_data(nick);
serv_got_alias(js->gc, from, nickname);
g_free(nickname);
}
void
msn_got_lst_user(MsnSession *session, MsnUser *user,
int list_op, GSList *group_ids)
{
PurpleConnection *gc;
PurpleAccount *account;
const char *passport;
const char *store;
account = session->account;
gc = purple_account_get_connection(account);
passport = msn_user_get_passport(user);
store = msn_user_get_friendly_name(user);
if (list_op & MSN_LIST_AL_OP)
{
/* These are users who are allowed to see our status. */
purple_privacy_deny_remove(account, passport, TRUE);
purple_privacy_permit_add(account, passport, TRUE);
}
if (list_op & MSN_LIST_BL_OP)
{
/* These are users who are not allowed to see our status. */
purple_privacy_permit_remove(account, passport, TRUE);
purple_privacy_deny_add(account, passport, TRUE);
}
if (list_op & MSN_LIST_FL_OP)
{
GSList *c;
for (c = group_ids; c != NULL; c = g_slist_next(c))
{
int group_id;
group_id = GPOINTER_TO_INT(c->data);
msn_user_add_group_id(user, group_id);
}
/* FIXME: It might be a real alias */
/* Umm, what? This might fix bug #1385130 */
serv_got_alias(gc, passport, store);
}
if (list_op & MSN_LIST_RL_OP)
{
/* These are users who have us on their buddy list. */
/*
* TODO: What is store name set to when this happens?
* For one of my accounts "*****@*****.**"
* the store name was "something." Maybe we
* should use the friendly name, instead? --KingAnt
*/
if (!(list_op & (MSN_LIST_AL_OP | MSN_LIST_BL_OP)))
{
got_new_entry(gc, passport, store);
}
}
user->list_op = list_op;
}
void
msn_got_add_user(MsnSession *session, MsnUser *user,
MsnListId list_id, int group_id)
{
PurpleAccount *account;
const char *passport;
const char *friendly;
account = session->account;
passport = msn_user_get_passport(user);
friendly = msn_user_get_friendly_name(user);
if (list_id == MSN_LIST_FL)
{
PurpleConnection *gc;
gc = purple_account_get_connection(account);
serv_got_alias(gc, passport, friendly);
if (group_id >= 0)
{
msn_user_add_group_id(user, group_id);
}
else
{
/* session->sync->fl_users_count++; */
}
}
else if (list_id == MSN_LIST_AL)
{
purple_privacy_permit_add(account, passport, TRUE);
}
else if (list_id == MSN_LIST_BL)
{
purple_privacy_deny_add(account, passport, TRUE);
}
else if (list_id == MSN_LIST_RL)
{
PurpleConnection *gc;
PurpleConversation *convo;
gc = purple_account_get_connection(account);
purple_debug_info("msn",
"%s has added you to his or her buddy list.\n",
passport);
convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, passport, account);
if (convo) {
PurpleBuddy *buddy;
char *msg;
buddy = purple_find_buddy(account, passport);
msg = g_strdup_printf(
_("%s has added you to his or her buddy list."),
buddy ? purple_buddy_get_contact_alias(buddy) : passport);
purple_conv_im_write(PURPLE_CONV_IM(convo), passport, msg,
PURPLE_MESSAGE_SYSTEM, time(NULL));
g_free(msg);
}
if (!(user->list_op & (MSN_LIST_AL_OP | MSN_LIST_BL_OP)))
{
/*
* TODO: The friendly name was NULL for me when I
* looked at this. Maybe we should use the store
* name instead? --KingAnt
*/
got_new_entry(gc, passport, friendly);
}
}
user->list_op |= (1 << list_id);
/* purple_user_add_list_id (user, list_id); */
}
static void add_purple_buddy_to_groups(JabberStream *js, const char *jid,
const char *alias, GSList *groups)
{
GSList *buddies, *l;
PurpleAccount *account = purple_connection_get_account(js->gc);
buddies = purple_find_buddies(js->gc->account, jid);
if(!groups) {
if(!buddies)
groups = g_slist_append(groups, g_strdup(_("Buddies")));
else {
/* TODO: What should we do here? Removing the local buddies
* is wrong, but so is letting the group state get out of sync with
* the server.
*/
g_slist_free(buddies);
return;
}
}
while(buddies) {
PurpleBuddy *b = buddies->data;
PurpleGroup *g = purple_buddy_get_group(b);
buddies = g_slist_delete_link(buddies, buddies);
/* XMPP groups are case-sensitive, but libpurple groups are
* case-insensitive. We treat a buddy in both "Friends" and "friends"
* as only being in one group, but if we push changes about the buddy
* to the server, the buddy will be dropped from one of the groups.
* Not optimal, but better than the alternative, I think.
*/
if((l = g_slist_find_custom(groups, purple_group_get_name(g), (GCompareFunc)purple_utf8_strcasecmp))) {
/* The buddy is already on the local list. Update info. */
const char *servernick, *balias;
/* Previously stored serverside / buddy-supplied alias */
if((servernick = purple_blist_node_get_string((PurpleBlistNode*)b, "servernick")))
serv_got_alias(js->gc, jid, servernick);
/* Alias from our roster retrieval */
balias = purple_buddy_get_local_buddy_alias(b);
if(alias && !purple_strequal(alias, balias))
purple_serv_got_private_alias(js->gc, jid, alias);
g_free(l->data);
groups = g_slist_delete_link(groups, l);
} else {
/* This buddy isn't in the group on the server anymore */
purple_debug_info("jabber", "jabber_roster_parse(): Removing %s "
"from group '%s' on the local list\n",
purple_buddy_get_name(b),
purple_group_get_name(g));
purple_blist_remove_buddy(b);
}
}
if (groups) {
char *tmp = roster_groups_join(groups);
purple_debug_info("jabber", "jabber_roster_parse(): Adding %s to "
"groups: %s\n", jid, tmp);
g_free(tmp);
}
while(groups) {
PurpleGroup *g = purple_find_group(groups->data);
PurpleBuddy *b = purple_buddy_new(account, jid, alias);
if(!g) {
g = purple_group_new(groups->data);
purple_blist_add_group(g, NULL);
}
purple_blist_add_buddy(b, NULL, g, NULL);
purple_blist_alias_buddy(b, alias);
g_free(groups->data);
groups = g_slist_delete_link(groups, groups);
}
g_slist_free(buddies);
}
static gboolean
handle_presence_contact(JabberStream *js, JabberPresence *presence)
{
JabberBuddyResource *jbr;
PurpleAccount *account;
PurpleBuddy *b;
char *buddy_name;
PurpleConversation *conv;
buddy_name = jabber_id_get_bare_jid(presence->jid_from);
account = purple_connection_get_account(js->gc);
b = purple_find_buddy(account, buddy_name);
/*
* Unbind/unlock from sending messages to a specific resource on
* presence changes. This is locked to a specific resource when
* receiving a message (in message.c).
*/
conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM,
buddy_name, account);
if (conv) {
purple_debug_info("jabber", "Changed conversation binding from %s to %s\n",
purple_conversation_get_name(conv), buddy_name);
purple_conversation_set_name(conv, buddy_name);
}
if (b == NULL) {
if (presence->jb != js->user_jb) {
purple_debug_warning("jabber", "Got presence for unknown buddy %s on account %s (%p)\n",
buddy_name, purple_account_get_username(account), account);
g_free(buddy_name);
return FALSE;
} else {
/* this is a different resource of our own account. Resume even when this account isn't on our blist */
}
}
if (b && presence->vcard_avatar_hash) {
const char *ah = presence->vcard_avatar_hash[0] != '\0' ?
presence->vcard_avatar_hash : NULL;
const char *ah2 = purple_buddy_icons_get_checksum_for_user(b);
if (!purple_strequal(ah, ah2)) {
/* XXX this is a crappy way of trying to prevent
* someone from spamming us with presence packets
* and causing us to DoS ourselves...what we really
* need is a queue system that can throttle itself,
* but i'm too tired to write that right now */
if(!g_slist_find(js->pending_avatar_requests, presence->jb)) {
JabberIq *iq;
xmlnode *vcard;
js->pending_avatar_requests =
g_slist_prepend(js->pending_avatar_requests, presence->jb);
iq = jabber_iq_new(js, JABBER_IQ_GET);
xmlnode_set_attrib(iq->node, "to", buddy_name);
vcard = xmlnode_new_child(iq->node, "vCard");
xmlnode_set_namespace(vcard, "vcard-temp");
jabber_iq_set_callback(iq, jabber_vcard_parse_avatar, NULL);
jabber_iq_send(iq);
}
}
}
if (presence->state == JABBER_BUDDY_STATE_ERROR ||
presence->type == JABBER_PRESENCE_UNAVAILABLE ||
presence->type == JABBER_PRESENCE_UNSUBSCRIBED) {
jabber_buddy_remove_resource(presence->jb, presence->jid_from->resource);
} else {
jbr = jabber_buddy_track_resource(presence->jb,
presence->jid_from->resource, presence->priority,
presence->state, presence->status);
jbr->idle = presence->idle ? time(NULL) - presence->idle : 0;
}
jbr = jabber_buddy_find_resource(presence->jb, NULL);
if (jbr) {
jabber_google_presence_incoming(js, buddy_name, jbr);
purple_prpl_got_user_status(account, buddy_name,
jabber_buddy_state_get_status_id(jbr->state),
"priority", jbr->priority,
"message", jbr->status,
NULL);
purple_prpl_got_user_idle(account, buddy_name,
jbr->idle, jbr->idle);
if (presence->nickname)
serv_got_alias(js->gc, buddy_name, presence->nickname);
} else {
purple_prpl_got_user_status(account, buddy_name,
jabber_buddy_state_get_status_id(JABBER_BUDDY_STATE_UNAVAILABLE),
presence->status ? "message" : NULL, presence->status,
NULL);
}
g_free(buddy_name);
return TRUE;
}
/**
* If the buddy does not yet exist, then create it and add it to
* our buddy list. In either case we set the correct status for
* the buddy.
*/
void
bonjour_buddy_add_to_purple(BonjourBuddy *bonjour_buddy)
{
PurpleBuddy *buddy;
PurpleGroup *group;
PurpleAccount *account = bonjour_buddy->account;
const char *status_id, *old_hash, *new_hash;
/* Translate between the Bonjour status and the Purple status */
if (bonjour_buddy->status != NULL && g_ascii_strcasecmp("dnd", bonjour_buddy->status) == 0)
status_id = BONJOUR_STATUS_ID_AWAY;
else
status_id = BONJOUR_STATUS_ID_AVAILABLE;
/*
* TODO: Figure out the idle time by getting the "away"
* field from the DNS SD.
*/
/* Make sure the Bonjour group exists in our buddy list */
group = purple_find_group(BONJOUR_GROUP_NAME); /* Use the buddy's domain, instead? */
if (group == NULL) {
group = purple_group_new(BONJOUR_GROUP_NAME);
purple_blist_add_group(group, NULL);
}
/* Make sure the buddy exists in our buddy list */
buddy = purple_find_buddy(account, bonjour_buddy->name);
if (buddy == NULL) {
buddy = purple_buddy_new(account, bonjour_buddy->name, NULL);
buddy->proto_data = bonjour_buddy;
purple_blist_node_set_flags((PurpleBlistNode *)buddy, PURPLE_BLIST_NODE_FLAG_NO_SAVE);
purple_blist_add_buddy(buddy, NULL, group, NULL);
}
/* Create the alias for the buddy using the first and the last name */
if (bonjour_buddy->nick)
serv_got_alias(purple_account_get_connection(account), buddy->name, bonjour_buddy->nick);
else {
gchar *alias = NULL;
const char *first, *last;
first = bonjour_buddy->first;
last = bonjour_buddy->last;
if ((first && *first) || (last && *last))
alias = g_strdup_printf("%s%s%s",
(first && *first ? first : ""),
(first && *first && last && *last ? " " : ""),
(last && *last ? last : ""));
serv_got_alias(purple_account_get_connection(account), buddy->name, alias);
g_free(alias);
}
/* Set the user's status */
if (bonjour_buddy->msg != NULL)
purple_prpl_got_user_status(account, buddy->name, status_id,
"message", bonjour_buddy->msg, NULL);
else
purple_prpl_got_user_status(account, buddy->name, status_id, NULL);
purple_prpl_got_user_idle(account, buddy->name, FALSE, 0);
/* TODO: Because we don't save Bonjour buddies in blist.xml,
* we will always have to look up the buddy icon at login time.
* I think we should figure out a way to do something about this. */
/* Deal with the buddy icon */
old_hash = purple_buddy_icons_get_checksum_for_user(buddy);
new_hash = (bonjour_buddy->phsh && *(bonjour_buddy->phsh)) ? bonjour_buddy->phsh : NULL;
if (new_hash && (!old_hash || strcmp(old_hash, new_hash) != 0)) {
/* Look up the new icon data */
/* TODO: Make sure the hash assigned to the retrieved buddy icon is the same
* as what we looked up. */
bonjour_dns_sd_retrieve_buddy_icon(bonjour_buddy);
} else if (!new_hash)
purple_buddy_icons_set_for_user(account, buddy->name, NULL, 0, NULL);
}
//End VoxOx
static void add_purple_buddies_to_groups(JabberStream *js, const char *jid,
const char *alias, GSList *groups)
{
GSList *buddies, *g2, *l;
gchar *my_bare_jid;
GList *pool = NULL;
buddies = purple_find_buddies(js->gc->account, jid);
g2 = groups;
if(!groups) {
if(!buddies)
g2 = g_slist_append(g2, g_strdup(_("Buddies")));
else {
g_slist_free(buddies);
return;
}
}
my_bare_jid = g_strdup_printf("%s@%s", js->user->node, js->user->domain);
while(buddies) {
PurpleBuddy *b = buddies->data;
PurpleGroup *g = purple_buddy_get_group(b);
buddies = g_slist_remove(buddies, b);
if((l = g_slist_find_custom(g2, g->name, (GCompareFunc)strcmp))) {
const char *servernick;
/* Previously stored serverside / buddy-supplied alias */
if((servernick = purple_blist_node_get_string((PurpleBlistNode*)b, "servernick")))
serv_got_alias(js->gc, jid, servernick);
/* Alias from our roster retrieval */
if(alias && (!b->alias || strcmp(b->alias, alias)))
purple_serv_got_private_alias(js->gc, jid, alias);
g_free(l->data);
g2 = g_slist_delete_link(g2, l);
} else {
pool = g_list_prepend(pool, b);
}
}
while(g2) {
PurpleGroup *g = purple_find_group(g2->data);
PurpleBuddy *b = NULL;
if (pool) {
b = pool->data;
pool = g_list_delete_link(pool, pool);
} else {
b = purple_buddy_new(js->gc->account, jid, alias);
}
if(!g) {
g = purple_group_new(g2->data);
purple_blist_add_group(g, NULL);
}
purple_blist_add_buddy(b, NULL, g, NULL);
purple_blist_alias_buddy(b, alias);
/* If we just learned about ourself, then fake our status,
* because we won't be receiving a normal presence message
* about ourself. */
if(!strcmp(b->name, my_bare_jid)) {
PurplePresence *gpresence;
PurpleStatus *status;
gpresence = purple_account_get_presence(js->gc->account);
status = purple_presence_get_active_status(gpresence);
jabber_presence_fake_to_self(js, status);
}
g_free(g2->data);
g2 = g_slist_delete_link(g2, g2);
}
while (pool) {
PurpleBuddy *b = pool->data;
purple_blist_remove_buddy(b);
pool = g_list_delete_link(pool, pool);
}
g_free(my_bare_jid);
g_slist_free(buddies);
}
static void
yahoo_fetch_aliases_cb(PurpleUtilFetchUrlData *url_data, gpointer user_data, const gchar *url_text, size_t len, const gchar *error_message)
{
PurpleConnection *gc = user_data;
YahooData *yd = gc->proto_data;
yd->url_datas = g_slist_remove(yd->url_datas, url_data);
if (len == 0) {
purple_debug_info("yahoo", "No Aliases to process.%s%s\n",
error_message ? " Error:" : "", error_message ? error_message : "");
} else {
gchar *full_name, *nick_name;
const char *yid, *id, *fn, *ln, *nn, *alias, *mn;
const char *hp, *wp, *mo;
YahooFriend *f;
PurpleBuddy *b;
xmlnode *item, *contacts;
PurpleAccount *account;
account = purple_connection_get_account(gc);
/* Put our web response into a xmlnode for easy management */
contacts = xmlnode_from_str(url_text, -1);
if (contacts == NULL) {
purple_debug_error("yahoo", "Badly formed Alias XML\n");
return;
}
purple_debug_info("yahoo", "Fetched %" G_GSIZE_FORMAT
" bytes of alias data\n", len);
/* Loop around and around and around until we have gone through all the received aliases */
for(item = xmlnode_get_child(contacts, "ct"); item; item = xmlnode_get_next_twin(item)) {
/* Yahoo replies with two types of contact (ct) record, we are only interested in the alias ones */
if ((yid = xmlnode_get_attrib(item, "yi"))) {
YahooPersonalDetails *ypd = NULL;
/* Grab all the bits of information we can */
fn = xmlnode_get_attrib(item, "fn");
ln = xmlnode_get_attrib(item, "ln");
nn = xmlnode_get_attrib(item, "nn");
mn = xmlnode_get_attrib(item, "mn");
id = xmlnode_get_attrib(item, "id");
hp = xmlnode_get_attrib(item, "hp");
wp = xmlnode_get_attrib(item, "wp");
mo = xmlnode_get_attrib(item, "mo");
full_name = nick_name = NULL;
alias = NULL;
/* Yahoo stores first and last names separately, lets put them together into a full name */
if (yd->jp)
full_name = g_strstrip(g_strdup_printf("%s %s", (ln != NULL ? ln : "") , (fn != NULL ? fn : "")));
else
full_name = g_strstrip(g_strdup_printf("%s %s", (fn != NULL ? fn : "") , (ln != NULL ? ln : "")));
nick_name = (nn != NULL ? g_strstrip(g_strdup(nn)) : NULL);
if (nick_name != NULL)
alias = nick_name; /* If we have a nickname from Yahoo, let's use it */
else if (strlen(full_name) != 0)
alias = full_name; /* If no Yahoo nickname, we can use the full_name created above */
/* Find the local buddy that matches */
f = yahoo_friend_find(gc, yid);
b = purple_find_buddy(account, yid);
/* If we don't find a matching buddy, ignore the alias !! */
if (f != NULL && b != NULL) {
const char *buddy_alias = purple_buddy_get_alias(b);
yahoo_friend_set_alias_id(f, id);
/* Finally, if we received an alias, we better update the buddy list */
if (alias != NULL) {
serv_got_alias(gc, yid, alias);
purple_debug_info("yahoo", "Fetched alias '%s' (%s)\n", alias, id);
} else if (buddy_alias != NULL && strcmp(buddy_alias, "") != 0) {
/* Or if we have an alias that Yahoo doesn't, send it up */
yahoo_update_alias(gc, yid, buddy_alias);
purple_debug_info("yahoo", "Sent updated alias '%s'\n", buddy_alias);
}
}
if (f != NULL)
ypd = &f->ypd;
else {
/* May be the alias is for the account? */
const char *yidn = purple_normalize(account, yid);
if (purple_strequal(yidn, purple_connection_get_display_name(gc))) {
ypd = &yd->ypd;
}
}
if (ypd) {
yahoo_personal_details_reset(ypd, TRUE);
ypd->id = g_strdup(id);
ypd->names.first = g_strdup(fn);
ypd->names.middle = g_strdup(mn);
ypd->names.last = g_strdup(ln);
ypd->names.nick = g_strdup(nn);
ypd->phone.work = g_strdup(wp);
ypd->phone.home = g_strdup(hp);
ypd->phone.mobile = g_strdup(mo);
}
g_free(full_name);
g_free(nick_name);
}
}
xmlnode_free(contacts);
}
}
static gboolean
parse_contact_details(YahooData *yd, const char *who, const char *xml)
{
xmlnode *node, *nd;
YahooFriend *f;
char *yid;
node = xmlnode_from_str(xml, -1);
if (!node) {
purple_debug_info("yahoo", "Received malformed XML for contact details from '%s':\n%s\n",
who, xml);
return FALSE;
}
nd = xmlnode_get_child(node, "yi");
if (!nd || !(yid = xmlnode_get_data(nd))) {
xmlnode_free(node);
return FALSE;
}
if (!purple_strequal(yid, who)) {
/* The user may not want to set the contact details about folks in the buddylist
to what some random dude might have sent. So it would be good if we popped
up a prompt requiring the user to confirm the details before we set them.
However, someone could send details about hundreds of users at the same time,
which would make things really bad. So for now, until we have a better way of
dealing with this, ignore this details. */
purple_debug_info("yahoo", "Ignoring contact details sent by %s about %s\n",
who, yid);
g_free(yid);
xmlnode_free(node);
return FALSE;
}
f = yahoo_friend_find(yd->gc, yid);
if (!f) {
g_free(yid);
xmlnode_free(node);
return FALSE;
} else {
int i;
YahooPersonalDetails *ypd = &f->ypd;
char *alias = NULL;
struct {
char *id;
char **field;
} details[] = {
{"fn", &ypd->names.first},
{"mn", &ypd->names.middle},
{"ln", &ypd->names.last},
{"nn", &ypd->names.nick},
{"wp", &ypd->phone.work},
{"hp", &ypd->phone.home},
{"mo", &ypd->phone.mobile},
{NULL, NULL}
};
yahoo_personal_details_reset(ypd, FALSE);
for (i = 0; details[i].id; i++) {
nd = xmlnode_get_child(node, details[i].id);
*details[i].field = nd ? xmlnode_get_data(nd) : NULL;
}
if (ypd->names.nick)
alias = ypd->names.nick;
else if (ypd->names.first || ypd->names.last) {
alias = g_strstrip(g_strdup_printf("%s %s",
ypd->names.first ? ypd->names.first : "",
ypd->names.last ? ypd->names.last : ""));
}
if (alias) {
serv_got_alias(yd->gc, yid, alias);
if (alias != ypd->names.nick)
g_free(alias);
}
}
xmlnode_free(node);
g_free(yid);
return TRUE;
}
static void got_buddy_list_cb(FacebookAccount *fba, gchar *data,
gsize data_len, gpointer userdata)
{
GSList *buddies_list;
GSList *online_buddies_list = NULL;
PurpleBuddy *buddy;
FacebookBuddy *fbuddy;
gchar *uid;
gchar *name;
gchar *status_text;
gchar *status_time_text;
gchar *buddy_icon_url;
gboolean idle;
guint32 error_number;
gchar *search_start;
gchar *search_tmp;
gchar *tmp;
gchar *largest_buddy_search_point = NULL;
PurpleGroup *fb_group = NULL;
gboolean current_buddy_online = FALSE;
purple_debug_info("facebook", "parsing buddy list\n");
purple_debug_misc("facebook", "buddy list\n%s\n", data);
if (fba == NULL)
return;
if (data == NULL) {
purple_connection_error_reason(fba->pc,
PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
_("Could not retrieve buddy list"));
return;
}
/* Check if the facebook group already exists (fixes #13) */
fb_group = purple_find_group("Facebook");
/* if logged out, this comes up */
/* for (;;);{"error":1357001,"errorSummary":"Not Logged In",
"errorDescription":"You must be logged in to do that.",
"payload":null,"bootload":[{"name":"js\/common.js.pkg.php",
"type":"js","src":"http:\/\/static.ak.fbcdn.net\/rsrc.php\/pkg\/59\
/98561\/js\/common.js.pkg.php"}]} */
tmp = g_strstr_len(data, data_len, "\"error\":");
if (tmp != NULL)
{
tmp += 9;
tmp = g_strndup(tmp, strchr(tmp, ',')-tmp);
error_number = atoi(tmp);
g_free(tmp);
if (error_number)
{
/* error :( */
tmp = g_strstr_len(data, data_len, "\"errorDescription\":");
tmp += 20;
tmp = g_strndup(tmp, strchr(tmp, '"')-tmp);
/* TODO: Use purple_connection_error_reason() */
purple_connection_error(fba->pc, tmp);
g_free(tmp);
return;
}
}
/* look for "userInfos":{ ... }, */
search_start = strstr(data, "\"userInfos\":{");
if (search_start == NULL)
return;
search_start += 13;
while (*search_start != '}' && (search_start - data < data_len))
{
tmp = strchr(search_start, ':');
uid = g_strndup(search_start+1, tmp-search_start-2);
/* purple_debug_misc("facebook", "uid: %s\n", uid); */
search_start += strlen(uid) + 2;
search_tmp = strstr(search_start, "\"name\":") + 8;
if (search_tmp > largest_buddy_search_point)
largest_buddy_search_point = search_tmp;
search_tmp = g_strndup(search_tmp, strchr(search_tmp, '"')-search_tmp);
name = fb_convert_unicode(search_tmp);
g_free(search_tmp);
/* purple_debug_misc("facebook", "name: %s\n", name); */
/* try updating the alias, just in case it was removed locally */
serv_got_alias(fba->pc, uid, name);
/* look for "uid":{"i":_____} */
tmp = g_strdup_printf("\"%s\":{\"i\":", uid);
search_tmp = g_strstr_len(data, data_len, tmp);
if (search_tmp != NULL)
{
search_tmp += strlen(tmp);
if (search_tmp > largest_buddy_search_point)
largest_buddy_search_point = search_tmp;
search_tmp = g_strndup(search_tmp, strchr(search_tmp, '}')-search_tmp);
/* purple_debug_misc("facebook", "buddy idle: %s\n", search_tmp); */
buddy = purple_find_buddy(fba->account, uid);
idle = g_str_equal(search_tmp, "true");
g_free(search_tmp);
current_buddy_online = TRUE;
} else {
/* if we're here, the buddy's info has been sent, but they're not actually online */
current_buddy_online = FALSE;
idle = FALSE;
}
g_free(tmp);
/* Set the buddy status text and time */
search_tmp = strstr(search_start, "\"status\":");
if (search_tmp != NULL && *(search_tmp + 9) == '"')
{
search_tmp += 10;
if (search_tmp > largest_buddy_search_point)
largest_buddy_search_point = strstr(search_tmp, ",\"statusTime");
search_tmp = g_strndup(search_tmp, strstr(search_tmp, ",\"statusTime")-1-search_tmp);
status_text = fb_convert_unicode(search_tmp);
g_free(search_tmp);
} else {
status_text = NULL;
}
/* is this us? */
if (atoi(uid) == fba->uid)
{
purple_connection_set_display_name(fba->pc, name);
/* set our last known status so that we don't re-set it */
if (status_text && !fba->last_status_message)
fba->last_status_message = g_strdup(status_text);
/* check that we don't want to show ourselves */
if (purple_account_get_bool(fba->account, "facebook_hide_self", TRUE))
{
g_free(status_text);
g_free(name);
g_free(uid);
/* Move pointer to the end of the buddy entry */
search_start = strchr(largest_buddy_search_point, '}') + 1;
while (*search_start == ',' && (search_start - data < data_len))
search_start++;
/* go on to the next buddy */
continue;
} else {
current_buddy_online = TRUE;
}
}
/* Is this a new buddy? */
buddy = purple_find_buddy(fba->account, uid);
if (buddy == NULL)
{
buddy = purple_buddy_new(fba->account, uid, NULL);
if (fb_group == NULL)
{
fb_group = purple_group_new("Facebook");
purple_blist_add_group(fb_group, NULL);
}
purple_blist_add_buddy(buddy, NULL, fb_group, NULL);
}
serv_got_alias(fba->pc, uid, name);
purple_presence_set_idle(purple_buddy_get_presence(buddy), idle, 0);
/* Set the FacebookBuddy structure */
if (buddy->proto_data == NULL)
{
fbuddy = g_new0(FacebookBuddy, 1);
fbuddy->buddy = buddy;
fbuddy->fba = fba;
fbuddy->uid = atoi(uid);
fbuddy->name = g_strdup(name);
/* load the old buddy icon from the account settings */
tmp = g_strdup_printf("buddy_icon_%d_cache", fbuddy->uid);
fbuddy->thumb_url = g_strdup(purple_account_get_string(fba->account, tmp, ""));
g_free(tmp);
buddy->proto_data = fbuddy;
} else {
fbuddy = buddy->proto_data;
}
g_free(uid);
g_free(name);
if (status_text != NULL)
{
tmp = fb_strdup_withhtml(status_text);
g_free(status_text);
status_text = tmp;
/* purple_debug_misc("facebook", "status: %s\n", status_text); */
search_tmp = strstr(search_start, "\"statusTimeRel\":") + 17;
if (search_tmp > largest_buddy_search_point)
largest_buddy_search_point = strchr(search_tmp, '"');
search_tmp = g_strndup(search_tmp, strchr(search_tmp, '"')-search_tmp);
status_time_text = fb_convert_unicode(search_tmp);
g_free(search_tmp);
if (g_str_equal(status_time_text, "ull,"))
{
g_free(status_time_text);
status_time_text = NULL;
}
g_free(fbuddy->status_rel_time);
if (status_time_text != NULL)
{
fbuddy->status_rel_time = fb_strdup_withhtml(status_time_text);
g_free(status_time_text);
/* purple_debug_misc("facebook", "status time: %s\n", fbuddy->status_rel_time); */
} else {
fbuddy->status_rel_time = NULL;
}
/* if the buddy status has changed, update the contact list */
if (fbuddy->status == NULL || !g_str_equal(fbuddy->status, status_text))
{
tmp = fbuddy->status;
fbuddy->status = status_text;
g_free(tmp);
if (current_buddy_online)
purple_prpl_got_user_status(fba->account, buddy->name, purple_primitive_get_id_from_type(PURPLE_STATUS_AVAILABLE), NULL);
} else {
g_free(status_text);
}
} else {
if (fbuddy->status != NULL)
{
g_free(fbuddy->status);
fbuddy->status = NULL;
if (current_buddy_online)
{
/* update the status in the contact list */
purple_prpl_got_user_status(fba->account, buddy->name, purple_primitive_get_id_from_type(PURPLE_STATUS_AVAILABLE), NULL);
}
}
}
/* Set the buddy icon (if it hasn't changed) */
search_tmp = strstr(search_start, "\"thumbSrc\":") + 12;
if (search_tmp > largest_buddy_search_point)
largest_buddy_search_point = search_tmp;
buddy_icon_url = g_strndup(search_tmp, strchr(search_tmp, '"')-search_tmp);
if (fbuddy->thumb_url == NULL || !g_str_equal(fbuddy->thumb_url, buddy_icon_url))
{
g_free(fbuddy->thumb_url);
fbuddy->thumb_url = g_strdup(buddy_icon_url);
/* Save the buddy icon so that they don't all need to be reloaded at startup */
tmp = g_strdup_printf("buddy_icon_%d_cache", fbuddy->uid);
purple_account_set_string(fba->account, tmp, buddy_icon_url);
g_free(tmp);
/* Turn the \/ into / */
tmp = g_strcompress(buddy_icon_url);
/* small icon at http://profile.ak.facebook.com/profile6/1845/74/q800753867_2878.jpg */
/* bigger icon at http://profile.ak.facebook.com/profile6/1845/74/n800753867_2878.jpg */
search_tmp = strstr(tmp, "/q");
if (search_tmp)
*(search_tmp + 1) = 'n';
if (g_str_equal(tmp, "http://static.ak.fbcdn.net/pics/q_silhouette.gif"))
/* User has no icon */
purple_buddy_icons_set_for_user(fba->account,
purple_buddy_get_name(buddy), NULL, 0, NULL);
else
/* Fetch their icon */
fb_post_or_get(fba, FB_METHOD_GET, "profile.ak.facebook.com",
tmp + strlen("http://profile.ak.facebook.com"), NULL,
buddy_icon_cb, g_strdup(purple_buddy_get_name(buddy)),
FALSE);
g_free(tmp);
}
g_free(buddy_icon_url);
if (current_buddy_online)
{
/* Add buddy to the list of online buddies */
online_buddies_list = g_slist_append(online_buddies_list, buddy);
/* Update the display of the buddy in the buddy list and make the user online */
if (!PURPLE_BUDDY_IS_ONLINE(buddy))
purple_prpl_got_user_status(fba->account, buddy->name, purple_primitive_get_id_from_type(PURPLE_STATUS_AVAILABLE), NULL);
}
/* Move pointer after any user configurable data */
search_start = search_tmp;
/* Move pointer to the end of the buddy entry */
search_start = strchr(largest_buddy_search_point, '}') + 1;
while (*search_start == ',' && (search_start - data < data_len))
search_start++;
}
buddies_list = purple_find_buddies(fba->account, NULL);
if (buddies_list != NULL)
{
g_slist_foreach(buddies_list, (GFunc)set_buddies_offline, online_buddies_list);
g_slist_free(buddies_list);
}
g_slist_free(online_buddies_list);
}
