gboolean
msn_userlist_rem_buddy_from_group(MsnUserList *userlist, const char *who,
const char *group_name)
{
const gchar * group_id;
MsnUser *user;
g_return_val_if_fail(userlist != NULL, FALSE);
g_return_val_if_fail(group_name != NULL, FALSE);
g_return_val_if_fail(who != NULL, FALSE);
purple_debug_info("msn", "Removing buddy with passport %s from group %s\n", who, group_name);
if ( (group_id = msn_userlist_find_group_id(userlist, group_name)) == NULL) {
purple_debug_error("msn", "Group %s has no guid!\n", group_name);
return FALSE;
}
if ( (user = msn_userlist_find_user(userlist, who)) == NULL) {
purple_debug_error("msn", "User %s not found!\n", who);
return FALSE;
}
msn_user_remove_group_id(user, group_id);
return TRUE;
}
void
msn_userlist_rem_buddy(MsnUserList *userlist, const char *who)
{
MsnUser *user = NULL;
g_return_if_fail(userlist != NULL);
g_return_if_fail(userlist->session != NULL);
g_return_if_fail(who != NULL);
user = msn_userlist_find_user(userlist, who);
msn_userlist_rem_buddy_from_list(userlist, who, MSN_LIST_FL);
/* delete the contact from address book via soap action */
if (user != NULL) {
if (0 /*not ready yet*/ && userlist->session->passport_info.email_enabled) {
MsnUserlistABData *ab = g_new0(MsnUserlistABData, 1);
ab->session = userlist->session;
ab->uid = g_strdup(user->uid); /* Not necessary? */
purple_request_yes_no(userlist->session->account,
_("Delete Buddy from Address Book?"),
_("Do you want to delete this buddy from your address book as well?"),
user->passport, 0, userlist->session->account, user->passport,
NULL, ab,
G_CALLBACK(userlist_ab_delete_cb), G_CALLBACK(userlist_ab_delete_cb));
} else
msn_delete_contact(userlist->session, user);
}
}
static void
rem_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
{
MsnSession *session;
MsnUser *user;
const char *list;
const char *passport;
MsnListId list_id;
int group_id;
session = cmdproc->session;
list = cmd->params[1];
passport = cmd->params[3];
user = msn_userlist_find_user(session->userlist, passport);
g_return_if_fail(user != NULL);
list_id = msn_get_list_id(list);
if (cmd->param_count == 5)
group_id = atoi(cmd->params[4]);
else
group_id = -1;
msn_got_rem_user(session, user, list_id, group_id);
msn_user_update(user);
}
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
msn_userlist_add_buddy(MsnUserList *userlist,
const char *who, int list_id,
const char *group_name)
{
MsnUser *user;
int group_id;
const char *list;
const char *friendly_name;
group_id = -1;
if (!purple_email_is_valid(who))
{
/* only notify the user about problems adding to the friends list
* maybe we should do something else for other lists, but it probably
* won't cause too many problems if we just ignore it */
if (list_id == MSN_LIST_FL)
{
char *str = g_strdup_printf(_("Unable to add \"%s\"."), who);
purple_notify_error(NULL, NULL, str,
_("The username specified is invalid."));
g_free(str);
}
return;
}
if (group_name != NULL)
{
group_id = msn_userlist_find_group_id(userlist, group_name);
if (group_id < 0)
{
/* Whoa, we must add that group first. */
msn_request_add_group(userlist, who, NULL, group_name);
return;
}
}
user = msn_userlist_find_user(userlist, who);
/* First we're going to check if it's already there. */
if (user_is_there(user, list_id, group_id))
{
list = lists[list_id];
purple_debug_error("msn", "User '%s' is already there: %s\n", who, list);
return;
}
friendly_name = (user != NULL) ? get_friendly_name(user) : who;
/* Then request the add to the server. */
list = lists[list_id];
msn_notification_add_buddy(userlist->session->notification, list, who,
friendly_name, group_id);
}
static void
msn_session_sync_users(MsnSession *session)
{
PurpleConnection *gc = purple_account_get_connection(session->account);
GList *to_remove = NULL;
GSList *buddies;
g_return_if_fail(gc != NULL);
/* The core used to use msn_add_buddy to add all buddies before
* being logged in. This no longer happens, so we manually iterate
* over the whole buddy list to identify sync issues.
*/
for (buddies = purple_blist_find_buddies(session->account, NULL); buddies;
buddies = g_slist_delete_link(buddies, buddies)) {
PurpleBuddy *buddy = buddies->data;
const gchar *buddy_name = purple_buddy_get_name(buddy);
const gchar *group_name = purple_group_get_name(purple_buddy_get_group(buddy));
MsnUser *remote_user;
gboolean found = FALSE;
remote_user = msn_userlist_find_user(session->userlist, buddy_name);
if (remote_user && remote_user->list_op & MSN_LIST_FL_OP) {
GList *l;
for (l = remote_user->group_ids; l; l = l->next) {
const char *name = msn_userlist_find_group_name(remote_user->userlist, l->data);
if (name && !g_ascii_strcasecmp(group_name, name)) {
found = TRUE;
break;
}
}
/* We don't care if they're in a different group, as long as they're on the
* list somewhere. If we check for the group, we cause pain, agony and
* suffering for people who decide to re-arrange their buddy list elsewhere.
*/
if (!found) {
if ((remote_user == NULL) || !(remote_user->list_op & MSN_LIST_FL_OP)) {
/* The user is not on the server list */
msn_error_sync_issue(session, buddy_name, group_name);
} else {
/* The user is not in that group on the server list */
to_remove = g_list_prepend(to_remove, buddy);
}
}
}
}
if (to_remove != NULL) {
g_list_foreach(to_remove, (GFunc)purple_blist_remove_buddy, NULL);
g_list_free(to_remove);
}
}
MsnUser *
msn_userlist_find_add_user(MsnUserList *userlist,const char *passport,const char *userName)
{
MsnUser *user;
user = msn_userlist_find_user(userlist, passport);
if (user == NULL)
{
user = msn_user_new(userlist, passport, userName);
msn_userlist_add_user(userlist, user);
} else {
msn_user_set_friendly_name(user, userName);
}
return user;
}
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_is_yahoo(PurpleAccount *account, const char *name)
{
MsnSession *session = NULL;
MsnUser *user;
PurpleConnection *gc;
gc = purple_account_get_connection(account);
if (gc != NULL)
session = gc->proto_data;
if ((session != NULL) && (user = msn_userlist_find_user(session->userlist, name)) != NULL)
{
return (user->networkid == MSN_NETWORK_YAHOO);
}
return (strstr(name,"@yahoo.") != NULL);
}
static void
fln_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
{
MsnSlpLink *slplink;
MsnUser *user;
user = msn_userlist_find_user(cmdproc->session->userlist, cmd->params[0]);
user->status = "offline";
msn_user_update(user);
slplink = msn_session_find_slplink(cmdproc->session, cmd->params[0]);
if (slplink != NULL)
msn_slplink_destroy(slplink);
}
void
msn_userlist_rem_buddy_from_list(MsnUserList *userlist, const char *who,
MsnListId list_id)
{
MsnUser *user;
const gchar *list;
MsnListOp list_op = 1 << list_id;
user = msn_userlist_find_user(userlist, who);
g_return_if_fail(user != NULL);
if ( !msn_userlist_user_is_in_list(user, list_id)) {
list = lists[list_id];
purple_debug_info("msn", "User %s is not in list %s, not removing.\n", who, list);
return;
}
msn_user_unset_op(user, list_op);
msn_notification_rem_buddy_from_list(userlist->session->notification, list_id, user);
}
void
msn_userlist_rem_buddy(MsnUserList *userlist,
const char *who, int list_id, const char *group_name)
{
MsnUser *user;
int group_id;
const char *list;
user = msn_userlist_find_user(userlist, who);
group_id = -1;
if (group_name != NULL)
{
group_id = msn_userlist_find_group_id(userlist, group_name);
if (group_id < 0)
{
/* Whoa, there is no such group. */
purple_debug_error("msn", "Group doesn't exist: %s\n", group_name);
return;
}
}
/* First we're going to check if not there. */
if (!(user_is_there(user, list_id, group_id)))
{
list = lists[list_id];
purple_debug_error("msn", "User '%s' is not there: %s\n",
who, list);
return;
}
/* Then request the rem to the server. */
list = lists[list_id];
msn_notification_rem_buddy(userlist->session->notification, list, who, group_id);
}
static void
add_cmd(MsnCmdProc *cmdproc, MsnCommand *cmd)
{
MsnSession *session;
MsnUser *user;
const char *list;
const char *passport;
const char *friendly;
MsnListId list_id;
int group_id;
list = cmd->params[1];
passport = cmd->params[3];
friendly = gaim_url_decode(cmd->params[4]);
session = cmdproc->session;
user = msn_userlist_find_user(session->userlist, passport);
if (user == NULL)
{
user = msn_user_new(session->userlist, passport, friendly);
msn_userlist_add_user(session->userlist, user);
}
else
msn_user_set_friendly_name(user, friendly);
list_id = msn_get_list_id(list);
if (cmd->param_count >= 6)
group_id = atoi(cmd->params[5]);
else
group_id = -1;
msn_got_add_user(session, user, list_id, group_id);
msn_user_update(user);
}
static void
msn_switchboard_add_user(MsnSwitchBoard *swboard, const char *user)
{
MsnCmdProc *cmdproc;
PurpleAccount *account;
MsnUserList *userlist;
MsnUser *msnuser;
char *semicolon;
char *passport;
g_return_if_fail(swboard != NULL);
cmdproc = swboard->cmdproc;
account = cmdproc->session->account;
semicolon = strchr(user, ';');
/* We don't really care about the machine ID. */
if (semicolon)
passport = g_strndup(user, semicolon - user);
else
passport = g_strdup(user);
userlist = swboard->session->userlist;
msnuser = msn_userlist_find_user(userlist, passport);
/* Don't add multiple endpoints to the conversation. */
if (g_list_find_custom(swboard->users, passport, (GCompareFunc)msn_user_passport_cmp)) {
g_free(passport);
return;
}
/* Don't add ourselves either... */
if (g_str_equal(passport, purple_account_get_username(account))) {
g_free(passport);
return;
}
if (!msnuser) {
purple_debug_info("msn","User %s is not on our list.\n", passport);
msnuser = msn_user_new(userlist, passport, NULL);
} else
msn_user_ref(msnuser);
g_free(passport);
swboard->users = g_list_prepend(swboard->users, msnuser);
swboard->current_users++;
swboard->empty = FALSE;
if (purple_debug_is_verbose())
purple_debug_info("msn", "user=[%s], total=%d\n",
user, swboard->current_users);
if (!(swboard->flag & MSN_SB_FLAG_IM) && (swboard->conv != NULL))
{
/* This is a helper switchboard. */
purple_debug_error("msn", "switchboard_add_user: conv != NULL\n");
return;
}
if ((swboard->conv != NULL) &&
(purple_conversation_get_type(swboard->conv) == PURPLE_CONV_TYPE_CHAT))
{
purple_conv_chat_add_user(PURPLE_CONV_CHAT(swboard->conv), msnuser->passport, NULL,
PURPLE_CBFLAGS_NONE, TRUE);
msn_servconn_set_idle_timeout(swboard->servconn, 0);
}
else if (swboard->current_users > 1)
{
msn_servconn_set_idle_timeout(swboard->servconn, 0);
if (swboard->conv == NULL ||
purple_conversation_get_type(swboard->conv) != PURPLE_CONV_TYPE_CHAT)
{
GList *l;
#if 0
/* this is bad - it causes msn_switchboard_close to be called on the
* switchboard we're in the middle of using :( */
if (swboard->conv != NULL)
purple_conversation_destroy(swboard->conv);
#endif
swboard->chat_id = msn_switchboard_get_chat_id();
swboard->flag |= MSN_SB_FLAG_IM;
swboard->conv = serv_got_joined_chat(account->gc,
swboard->chat_id,
"MSN Chat");
for (l = swboard->users; l != NULL; l = l->next)
{
const char *tmp_user;
tmp_user = ((MsnUser*)l->data)->passport;
purple_conv_chat_add_user(PURPLE_CONV_CHAT(swboard->conv),
tmp_user, NULL, PURPLE_CBFLAGS_NONE, TRUE);
}
purple_conv_chat_add_user(PURPLE_CONV_CHAT(swboard->conv),
purple_account_get_username(account),
NULL, PURPLE_CBFLAGS_NONE, TRUE);
g_free(swboard->im_user);
swboard->im_user = NULL;
}
}
else if (swboard->conv == NULL)
{
swboard->conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM,
msnuser->passport, account);
}
else
{
purple_debug_warning("msn", "switchboard_add_user: This should not happen!\n");
}
}
static void
msn_session_sync_users(MsnSession *session)
{
PurpleBlistNode *gnode, *cnode, *bnode;
PurpleConnection *gc = purple_account_get_connection(session->account);
GList *to_remove = NULL;
g_return_if_fail(gc != NULL);
/* The core used to use msn_add_buddy to add all buddies before
* being logged in. This no longer happens, so we manually iterate
* over the whole buddy list to identify sync issues. */
for (gnode = purple_blist_get_root(); gnode; gnode = gnode->next) {
PurpleGroup *group = (PurpleGroup *)gnode;
const char *group_name = group->name;
if(!PURPLE_BLIST_NODE_IS_GROUP(gnode))
continue;
for(cnode = gnode->child; cnode; cnode = cnode->next) {
if(!PURPLE_BLIST_NODE_IS_CONTACT(cnode))
continue;
for(bnode = cnode->child; bnode; bnode = bnode->next) {
PurpleBuddy *b;
if(!PURPLE_BLIST_NODE_IS_BUDDY(bnode))
continue;
b = (PurpleBuddy *)bnode;
if(purple_buddy_get_account(b) == purple_connection_get_account(gc)) {
MsnUser *remote_user;
gboolean found = FALSE;
remote_user = msn_userlist_find_user(session->userlist, purple_buddy_get_name(b));
if ((remote_user != NULL) && (remote_user->list_op & MSN_LIST_FL_OP))
{
int group_id;
GList *l;
group_id = msn_userlist_find_group_id(remote_user->userlist,
group_name);
for (l = remote_user->group_ids; l != NULL; l = l->next)
{
if (group_id == GPOINTER_TO_INT(l->data))
{
found = TRUE;
break;
}
}
}
/* We don't care if they're in a different group, as long as they're on the
* list somewhere. If we check for the group, we cause pain, agony and
* suffering for people who decide to re-arrange their buddy list elsewhere.
*/
if (!found)
{
if ((remote_user == NULL) || !(remote_user->list_op & MSN_LIST_FL_OP)) {
/* The user is not on the server list */
msn_show_sync_issue(session, purple_buddy_get_name(b), group_name);
} else {
/* The user is not in that group on the server list */
to_remove = g_list_prepend(to_remove, b);
}
}
}
}
}
}
if (to_remove != NULL) {
g_list_foreach(to_remove, (GFunc)purple_blist_remove_buddy, NULL);
g_list_free(to_remove);
}
}
static void
msn_session_sync_users(MsnSession *session)
{
PurpleBlistNode *gnode, *cnode, *bnode;
PurpleConnection *gc = purple_account_get_connection(session->account);
g_return_if_fail(gc != NULL);
/* The core used to use msn_add_buddy to add all buddies before
* being logged in. This no longer happens, so we manually iterate
* over the whole buddy list to identify sync issues. */
for (gnode = purple_blist_get_root(); gnode; gnode = gnode->next) {
PurpleGroup *group = (PurpleGroup *)gnode;
const char *group_name = group->name;
if(!PURPLE_BLIST_NODE_IS_GROUP(gnode))
continue;
for(cnode = gnode->child; cnode; cnode = cnode->next) {
if(!PURPLE_BLIST_NODE_IS_CONTACT(cnode))
continue;
for(bnode = cnode->child; bnode; bnode = bnode->next) {
PurpleBuddy *b;
if(!PURPLE_BLIST_NODE_IS_BUDDY(bnode))
continue;
b = (PurpleBuddy *)bnode;
if(purple_buddy_get_account(b) == purple_connection_get_account(gc)) {
MsnUser *remote_user;
gboolean found = FALSE;
remote_user = msn_userlist_find_user(session->userlist, purple_buddy_get_name(b));
if ((remote_user != NULL) && (remote_user->list_op & MSN_LIST_FL_OP))
{
int group_id;
GList *l;
group_id = msn_userlist_find_group_id(remote_user->userlist,
group_name);
for (l = remote_user->group_ids; l != NULL; l = l->next)
{
if (group_id == GPOINTER_TO_INT(l->data))
{
found = TRUE;
break;
}
}
}
if (!found)
{
/* The user was not on the server list or not in that group
* on the server list */
msn_show_sync_issue(session, purple_buddy_get_name(b), group_name);
}
}
}
}
}
}
