/* create purple buddy without data and display with no-auth icon */
PurpleBuddy *qq_buddy_new(PurpleConnection *gc, guint32 uid)
{
PurpleBuddy *buddy;
PurpleGroup *group;
gchar *who;
gchar *group_name;
g_return_val_if_fail(gc->account != NULL && uid != 0, NULL);
group_name = g_strdup_printf(PURPLE_GROUP_QQ_FORMAT,
purple_account_get_username(gc->account));
group = qq_group_find_or_new(group_name);
if (group == NULL) {
purple_debug_error("QQ", "Failed creating group %s\n", group_name);
return NULL;
}
purple_debug_info("QQ", "Add new purple buddy: [%u]\n", uid);
who = uid_to_purple_name(uid);
buddy = purple_buddy_new(gc->account, who, NULL); /* alias is NULL */
purple_buddy_set_protocol_data(buddy, NULL);
g_free(who);
purple_blist_add_buddy(buddy, NULL, group, NULL);
g_free(group_name);
return buddy;
}
static void update_user_handler (struct tgl_state *TLS, struct tgl_user *user, unsigned flags) {
// if (!(flags & TGL_UPDATE_CREATED)) { return; }
if (TLS->our_id == tgl_get_peer_id (user->id)) {
if (flags & TGL_UPDATE_NAME) {
p2tgl_connection_set_display_name (TLS, (tgl_peer_t *)user);
}
} else {
PurpleBuddy *buddy = p2tgl_buddy_find (TLS, user->id);
if (!buddy) {
buddy = p2tgl_buddy_new (TLS, (tgl_peer_t *)user);
purple_blist_add_buddy (buddy, NULL, tggroup, NULL);
}
if (flags & TGL_UPDATE_CREATED) {
purple_buddy_set_protocol_data (buddy, (gpointer)user);
p2tgl_prpl_got_user_status (TLS, user->id, &user->status);
p2tgl_buddy_update (TLS, (tgl_peer_t *)user, flags);
}
if (flags & (TGL_UPDATE_NAME | TGL_UPDATE_REAL_NAME | TGL_UPDATE_USERNAME) && buddy) {
p2tgl_blist_alias_buddy (buddy, user);
}
if (flags & TGL_UPDATE_PHOTO) {
tgl_do_get_user_info (TLS, user->id, 0, on_user_get_info, 0);
}
if (flags & TGL_UPDATE_DELETED && buddy) {
purple_blist_remove_buddy (buddy);
}
}
}
/*load userlist from the Blist file cache*/
void
msn_userlist_load(MsnSession *session)
{
PurpleAccount *account = session->account;
PurpleConnection *gc = purple_account_get_connection(account);
GSList *l;
MsnUser * user;
g_return_if_fail(gc != NULL);
for (l = purple_find_buddies(account, NULL); l != NULL;
l = g_slist_delete_link(l, l)) {
PurpleBuddy *buddy = l->data;
user = msn_userlist_find_add_user(session->userlist,
purple_buddy_get_name(buddy), NULL);
purple_buddy_set_protocol_data(buddy, user);
msn_user_set_op(user, MSN_LIST_FL_OP);
}
for (l = session->account->permit; l != NULL; l = l->next)
{
user = msn_userlist_find_add_user(session->userlist,
(char *)l->data,NULL);
msn_user_set_op(user, MSN_LIST_AL_OP);
}
for (l = session->account->deny; l != NULL; l = l->next)
{
user = msn_userlist_find_add_user(session->userlist,
(char *)l->data,NULL);
msn_user_set_op(user, MSN_LIST_BL_OP);
}
}
/* remove a buddy and send packet to QQ server accordingly */
void qq_remove_buddy(PurpleConnection *gc, PurpleBuddy *buddy, PurpleGroup *group)
{
qq_data *qd;
qq_buddy_data *bd;
qq_buddy_opt_req *opt_req;
g_return_if_fail(gc != NULL && gc->proto_data != NULL);
g_return_if_fail(buddy != NULL);
qd = (qq_data *) gc->proto_data;
if (!qd->is_login)
return;
/* free it in qq_request_remove_buddy */
opt_req = g_new0(qq_buddy_opt_req, 1);
opt_req->gc = gc;
opt_req->uid = purple_name_to_uid(purple_buddy_get_name(buddy));
if (opt_req->uid > 0 && opt_req->uid != qd->uid) {
qq_request_auth_token(gc, QQ_AUTH_INFO_BUDDY, QQ_AUTH_INFO_REMOVE_BUDDY, 0, opt_req);
}
if ((bd = purple_buddy_get_protocol_data(buddy)) != NULL) {
qq_buddy_data_free(bd);
purple_buddy_set_protocol_data(buddy, NULL);
} else {
purple_debug_warning("QQ", "Empty buddy data of %s\n", purple_buddy_get_name(buddy));
}
}
/* remove a buddy and send packet to QQ server accordingly */
void qq_remove_buddy(PurpleConnection *gc, PurpleBuddy *buddy, PurpleGroup *group)
{
qq_data *qd;
qq_buddy_data *bd;
guint32 uid;
g_return_if_fail(gc != NULL && gc->proto_data != NULL);
g_return_if_fail(buddy != NULL);
qd = (qq_data *) gc->proto_data;
if (!qd->is_login)
return;
uid = purple_name_to_uid(purple_buddy_get_name(buddy));
if (uid > 0 && uid != qd->uid) {
if (qd->client_version > 2005) {
qq_request_auth_code(gc, QQ_AUTH_INFO_BUDDY, QQ_AUTH_INFO_REMOVE_BUDDY, uid);
} else {
request_remove_buddy(gc, uid);
request_buddy_remove_me(gc, uid);
}
}
if ((bd = purple_buddy_get_protocol_data(buddy)) != NULL) {
qq_buddy_data_free(bd);
purple_buddy_set_protocol_data(buddy, NULL);
} else {
purple_debug_warning("QQ", "Empty buddy data of %s\n", purple_buddy_get_name(buddy));
}
/* Do not call purple_blist_remove_buddy,
* otherwise purple segmentation fault */
}
PurpleBuddy * qq_buddy_find_or_new( PurpleConnection *gc, guint32 uid, guint8 group_id)
{
PurpleBuddy *buddy;
qq_buddy_data *bd;
qq_data *qd;
GSList *l;
qq_group * g;
PurpleGroup * old_group;
g_return_val_if_fail(gc->account != NULL && uid != 0, NULL);
qd = (qq_data *)gc->proto_data;
buddy = qq_buddy_find(gc, uid);
/* group_id==0xFF only when add an unknown stranger */
if (group_id==0xFF) {
if (buddy) goto buddy_data_check;
else group_id=0; //add stranger to group 0
}
/* find input group_id */
for (l=qd->group_list; l; l=l->next)
{
if (((qq_group *)(l->data))->group_id == group_id) break;
}
/* if group_id found */
if (l) {
if (buddy) //if buddy already exist, we need check if he is in new group
{
old_group = purple_buddy_get_group(buddy);
g = (qq_group *)l->data;
if (old_group != purple_find_group(g->group_name))
{
qq_buddy_free(buddy);
} else goto buddy_data_check;
}
old_group = purple_find_group(((qq_group *)(l->data))->group_name);
buddy = qq_buddy_new(gc, uid, old_group);
} else {
if (group_id==0)
{
if (!buddy)
buddy = qq_buddy_new(gc, uid, NULL);
goto buddy_data_check;
}
purple_debug_error("QQ","cannot find group id: %u", group_id);
return NULL;
}
buddy_data_check:
if (purple_buddy_get_protocol_data(buddy) != NULL)
return buddy;
bd = qq_buddy_data_new(uid);
purple_buddy_set_protocol_data(buddy, bd);
return buddy;
}
/* you are rejected by the person */
static void server_buddy_rejected_me(PurpleConnection *gc, gchar *from, gchar *to,
guint8 *data, gint data_len)
{
guint32 uid;
PurpleBuddy *buddy;
gchar *msg, *msg_utf8;
gint bytes;
gchar **segments;
gchar *primary, *secondary;
qq_buddy_data *bd;
g_return_if_fail(from != NULL && to != NULL);
qq_show_packet("server_buddy_rejected_me", data, data_len);
if (data_len <= 0) {
msg = g_strdup( _("No reason given") );
} else {
segments = g_strsplit((gchar *)data, "\x1f", 1);
if (segments != NULL && segments[0] != NULL) {
msg = g_strdup(segments[0]);
g_strfreev(segments);
bytes = strlen(msg) + 1;
if (bytes < data_len) {
server_buddy_check_code(gc, from, data + bytes, data_len - bytes);
}
} else {
msg = g_strdup( _("No reason given") );
}
}
msg_utf8 = qq_to_utf8(msg, QQ_CHARSET_DEFAULT);
if (msg_utf8 == NULL) {
msg_utf8 = g_strdup( _("Unknown reason") );
}
g_free(msg);
primary = g_strdup_printf(_("Rejected by %s"), from);
secondary = g_strdup_printf(_("Message: %s"), msg_utf8);
purple_notify_info(gc, _("QQ Buddy"), primary, secondary);
g_free(msg_utf8);
g_free(primary);
g_free(secondary);
uid = strtoul(from, NULL, 10);
g_return_if_fail(uid != 0);
buddy = qq_buddy_find(gc, uid);
if (buddy != NULL && (bd = purple_buddy_get_protocol_data(buddy)) != NULL) {
/* Not authorized now, free buddy data */
qq_buddy_data_free(bd);
purple_buddy_set_protocol_data(buddy, NULL);
}
}
static void
skypeweb_got_friend_profiles(SkypeWebAccount *sa, JsonNode *node, gpointer user_data)
{
JsonArray *contacts;
PurpleBuddy *buddy;
SkypeWebBuddy *sbuddy;
gint index, length;
if (node == NULL || json_node_get_node_type(node) != JSON_NODE_ARRAY)
return;
contacts = json_node_get_array(node);
length = json_array_get_length(contacts);
for(index = 0; index < length; index++)
{
JsonObject *contact = json_array_get_object_element(contacts, index);
const gchar *username = json_object_get_string_member(contact, "username");
const gchar *new_avatar;
buddy = purple_find_buddy(sa->account, username);
if (!buddy)
continue;
sbuddy = purple_buddy_get_protocol_data(buddy);
if (sbuddy == NULL) {
sbuddy = g_new0(SkypeWebBuddy, 1);
purple_buddy_set_protocol_data(buddy, sbuddy);
sbuddy->skypename = g_strdup(username);
sbuddy->sa = sa;
}
g_free(sbuddy->display_name); sbuddy->display_name = g_strdup(json_object_get_string_member(contact, "displayname"));
purple_serv_got_alias(sa->pc, username, sbuddy->display_name);
if (json_object_has_member(contact, "lastname")) {
gchar *fullname = g_strconcat(json_object_get_string_member(contact, "firstname"), " ", json_object_get_string_member(contact, "lastname"), NULL);
purple_blist_server_alias_buddy(buddy, fullname);
g_free(fullname);
} else {
purple_blist_server_alias_buddy(buddy, json_object_get_string_member(contact, "firstname"));
}
new_avatar = json_object_get_string_member(contact, "avatarUrl");
if (new_avatar && *new_avatar && (!sbuddy->avatar_url || !g_str_equal(sbuddy->avatar_url, new_avatar))) {
g_free(sbuddy->avatar_url);
sbuddy->avatar_url = g_strdup(new_avatar);
skypeweb_get_icon(buddy);
}
g_free(sbuddy->mood); sbuddy->mood = g_strdup(json_object_get_string_member(contact, "mood"));
}
}
static void qq_buddy_free(PurpleBuddy *buddy)
{
qq_buddy_data *bd;
g_return_if_fail(buddy);
if ((bd = purple_buddy_get_protocol_data(buddy)) != NULL) {
qq_buddy_data_free(bd);
}
purple_buddy_set_protocol_data(buddy, NULL);
purple_blist_remove_buddy(buddy);
}
static void
stress_login(PurpleAccount *account) {
PurpleConnection *pc = NULL;
PurpleGroup *g = NULL;
gint n_buddies = 0, i = 0, interval = 0, maxevents = 0;
/* build our possible events from the account settings */
add_event("trigger_signon", STRESS_EVENT_SIGN_ON, STRESS_EVENT_SIGN_OFF);
add_event("trigger_idle", STRESS_EVENT_IDLE, STRESS_EVENT_UNIDLE);
add_event("trigger_away", STRESS_EVENT_AWAY, STRESS_EVENT_BACK);
add_event("trigger_typing", STRESS_EVENT_TYPING, STRESS_EVENT_STOPPED_TYPING);
add_event("send_messages", STRESS_EVENT_SEND_MESSAGE, -1);
nevents = g_list_length(events);
/* get our connection and set it as online */
pc = purple_account_get_connection(account);
purple_connection_set_state(pc, PURPLE_CONNECTED);
/* grab the account settings we need for buddies */
n_buddies = purple_account_get_int(account, "nbuddies", 50);
maxevents = purple_account_get_int(account, "maxevents", 100);
interval = (guint)purple_account_get_int(account, "interval", 500);
message_min = purple_account_get_int(account, "message_min", 16);
message_max = purple_account_get_int(account, "message_max", 128);
g = purple_group_new("prpl-stress");
for(i = 0; i < n_buddies; i++) {
PurpleBuddy *b = NULL;
StressBuddy *sb = NULL;
gchar *name = NULL;
/* create the buddy and it's name */
name = g_strdup_printf("stress-%04x", i);
b = purple_buddy_new(account, name, NULL);
g_free(name);
/* add our data to the buddy */
sb = g_new0(StressBuddy, 1);
sb->buddy = b;
sb->maxevents = maxevents;
purple_buddy_set_protocol_data(b, sb);
/* add the buddy to our list and the purple blist */
buddies = g_list_prepend(buddies, sb);
purple_blist_add_buddy(b, NULL, g, NULL);
/* add our event timer to the buddy */
sb->timer_id = g_timeout_add(interval, stress_event_cb, sb);
}
}
plain_buddy_state *add_buddy_sdata(PurpleBuddy *buddy, plain_plugin_state *pstate)
{
plain_buddy_state *bstate;
bstate = g_new0(plain_buddy_state, 1);
bstate->name = g_strdup(buddy->name);
purple_buddy_set_protocol_data(buddy, bstate);
/* Append buddy data to plugin data list */
pstate->all_buddies = g_slist_append(pstate->all_buddies, buddy);
return bstate;
}
/*------------------------------------------------------------------------
* Free the resources used to store a buddy.
*
* @param buddy The buddy
*/
static void mxit_free_buddy( PurpleBuddy* buddy )
{
struct contact* contact;
contact = purple_buddy_get_protocol_data( buddy );
if ( contact ) {
g_free(contact->statusMsg);
g_free(contact->avatarId);
g_free(contact->msg);
if (contact->image)
g_object_unref(contact->image);
g_free( contact );
}
purple_buddy_set_protocol_data( buddy, NULL );
}
static void
skypeweb_buddy_free(PurpleBuddy *buddy)
{
SkypeWebBuddy *sbuddy = purple_buddy_get_protocol_data(buddy);
if (sbuddy != NULL)
{
purple_buddy_set_protocol_data(buddy, NULL);
g_free(sbuddy->skypename);
g_free(sbuddy->fullname);
g_free(sbuddy->display_name);
g_free(sbuddy->avatar_url);
g_free(sbuddy->mood);
g_free(sbuddy);
}
}
/*------------------------------------------------------------------------
* Free the resources used to store a buddy.
*
* @param buddy The buddy
*/
static void mxit_free_buddy( PurpleBuddy* buddy )
{
struct contact* contact;
purple_debug_info( MXIT_PLUGIN_ID, "mxit_free_buddy\n" );
contact = purple_buddy_get_protocol_data( buddy );
if ( contact ) {
if ( contact->statusMsg )
g_free( contact->statusMsg );
if ( contact->avatarId )
g_free( contact->avatarId );
if ( contact->msg )
g_free( contact->msg );
g_free( contact );
}
purple_buddy_set_protocol_data( buddy, NULL );
}
/*add group id to User object*/
void
msn_user_add_group_id(MsnUser *user, const char* group_id)
{
MsnUserList *userlist;
PurpleAccount *account;
PurpleBuddy *b;
PurpleGroup *g;
const char *passport;
const char *group_name;
g_return_if_fail(user != NULL);
g_return_if_fail(group_id != NULL);
user->group_ids = g_list_append(user->group_ids, g_strdup(group_id));
userlist = user->userlist;
account = userlist->session->account;
passport = msn_user_get_passport(user);
group_name = msn_userlist_find_group_name(userlist, group_id);
purple_debug_info("msn", "User: group id:%s,name:%s,user:%s\n", group_id, group_name, passport);
g = purple_find_group(group_name);
if ((group_id == NULL) && (g == NULL))
{
g = purple_group_new(group_name);
purple_blist_add_group(g, NULL);
}
b = purple_find_buddy_in_group(account, passport, g);
if (b == NULL)
{
b = purple_buddy_new(account, passport, NULL);
purple_blist_add_buddy(b, NULL, g, NULL);
}
purple_buddy_set_protocol_data(b, user);
/*Update the blist Node info*/
}
PurpleBuddy *qq_buddy_find_or_new(PurpleConnection *gc, guint32 uid)
{
PurpleBuddy *buddy;
qq_buddy_data *bd;
g_return_val_if_fail(gc->account != NULL && uid != 0, NULL);
buddy = qq_buddy_find(gc, uid);
if (buddy == NULL) {
buddy = qq_buddy_new(gc, uid);
if (buddy == NULL) {
return NULL;
}
}
if (purple_buddy_get_protocol_data(buddy) != NULL) {
return buddy;
}
bd = qq_buddy_data_new(uid);
purple_buddy_set_protocol_data(buddy, bd);
return buddy;
}
static void
skypeweb_get_friend_list_cb(SkypeWebAccount *sa, JsonNode *node, gpointer user_data)
{
JsonArray *friends;
PurpleGroup *group = NULL;
GSList *users_to_fetch = NULL;
gint index, length;
friends = json_node_get_array(node);
length = json_array_get_length(friends);
for(index = 0; index < length; index++)
{
JsonObject *friend = json_array_get_object_element(friends, index);
const gchar *skypename = json_object_get_string_member(friend, "skypename");
const gchar *fullname = json_object_get_string_member(friend, "fullname");
const gchar *display_name = json_object_get_string_member(friend, "display_name");
gboolean authorized = json_object_get_boolean_member(friend, "authorized");
gboolean blocked = json_object_get_boolean_member(friend, "blocked");
PurpleBuddy *buddy;
buddy = purple_find_buddy(sa->account, skypename);
if (!buddy)
{
if (!group)
{
group = purple_blist_find_group("Skype");
if (!group)
{
group = purple_group_new("Skype");
purple_blist_add_group(group, NULL);
}
}
buddy = purple_buddy_new(sa->account, skypename, display_name);
purple_blist_add_buddy(buddy, NULL, group, NULL);
}
SkypeWebBuddy *sbuddy = g_new0(SkypeWebBuddy, 1);
sbuddy->skypename = g_strdup(skypename);
sbuddy->sa = sa;
sbuddy->fullname = g_strdup(fullname);
sbuddy->display_name = g_strdup(display_name);
sbuddy->authorized = authorized;
sbuddy->blocked = blocked;
sbuddy->buddy = buddy;
purple_buddy_set_protocol_data(buddy, sbuddy);
purple_serv_got_alias(sa->pc, skypename, sbuddy->display_name);
purple_blist_server_alias_buddy(buddy, fullname);
users_to_fetch = g_slist_prepend(users_to_fetch, sbuddy->skypename);
}
if (users_to_fetch)
{
skypeweb_get_friend_profiles(sa, users_to_fetch);
skypeweb_subscribe_to_contact_status(sa, users_to_fetch);
g_slist_free(users_to_fetch);
}
}
void
_purple_connection_destroy(PurpleConnection *gc)
{
PurpleAccount *account;
GSList *buddies;
PurplePluginProtocolInfo *prpl_info = NULL;
gboolean remove = FALSE;
g_return_if_fail(gc != NULL);
account = purple_connection_get_account(gc);
purple_debug_info("connection", "Disconnecting connection %p\n", gc);
if (purple_connection_get_state(gc) != PURPLE_CONNECTING)
remove = TRUE;
purple_signal_emit(purple_connections_get_handle(), "signing-off", gc);
while (gc->buddy_chats)
{
PurpleConversation *b = gc->buddy_chats->data;
gc->buddy_chats = g_slist_remove(gc->buddy_chats, b);
purple_conv_chat_left(PURPLE_CONV_CHAT(b));
}
update_keepalive(gc, FALSE);
purple_proxy_connect_cancel_with_handle(gc);
prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
if (prpl_info->close)
(prpl_info->close)(gc);
/* Clear out the proto data that was freed in the prpl close method*/
buddies = purple_find_buddies(account, NULL);
while (buddies != NULL) {
PurpleBuddy *buddy = buddies->data;
purple_buddy_set_protocol_data(buddy, NULL);
buddies = g_slist_delete_link(buddies, buddies);
}
connections = g_list_remove(connections, gc);
purple_connection_set_state(gc, PURPLE_DISCONNECTED);
if (remove)
purple_blist_remove_account(account);
purple_signal_emit(purple_connections_get_handle(), "signed-off", gc);
purple_account_request_close_with_account(account);
purple_request_close_with_handle(gc);
purple_notify_close_with_handle(gc);
purple_debug_info("connection", "Destroying connection %p\n", gc);
purple_account_set_connection(account, NULL);
g_free(gc->password);
g_free(gc->display_name);
if (gc->disconnect_timeout > 0)
purple_timeout_remove(gc->disconnect_timeout);
PURPLE_DBUS_UNREGISTER_POINTER(gc);
g_free(gc);
}
static void
skypeweb_got_info(SkypeWebAccount *sa, JsonNode *node, gpointer user_data)
{
gchar *username = user_data;
PurpleNotifyUserInfo *user_info;
JsonObject *userobj;
PurpleBuddy *buddy;
SkypeWebBuddy *sbuddy;
const gchar *new_avatar;
if (node == NULL || json_node_get_node_type(node) != JSON_NODE_OBJECT)
return;
userobj = json_node_get_object(node);
user_info = purple_notify_user_info_new();
#define _SKYPE_USER_INFO(prop, key) if (prop && json_object_has_member(userobj, (prop)) && !json_object_get_null_member(userobj, (prop))) \
purple_notify_user_info_add_pair_html(user_info, _(key), json_object_get_string_member(userobj, (prop)));
_SKYPE_USER_INFO("firstname", "First Name");
_SKYPE_USER_INFO("lastname", "Last Name");
_SKYPE_USER_INFO("birthday", "Birthday");
//_SKYPE_USER_INFO("gender", "Gender");
if (json_object_has_member(userobj, "gender") && !json_object_get_null_member(userobj, "gender")) {
const gchar *gender = json_object_get_string_member(userobj, "gender");
const gchar *gender_output;
if (*gender == '1') {
gender_output = _("Male");
} else if (*gender == '2') {
gender_output = _("Female");
} else {
gender_output = _("Unknown");
}
purple_notify_user_info_add_pair_html(user_info, _("Gender"), gender_output);
}
_SKYPE_USER_INFO("language", "Language");
_SKYPE_USER_INFO("country", "Country");
_SKYPE_USER_INFO("province", "Province");
_SKYPE_USER_INFO("city", "City");
_SKYPE_USER_INFO("homepage", "Homepage");
_SKYPE_USER_INFO("about", "About");
_SKYPE_USER_INFO("jobtitle", "Job Title");
_SKYPE_USER_INFO("phoneMobile", "Phone - Mobile");
_SKYPE_USER_INFO("phoneHome", "Phone - Home");
_SKYPE_USER_INFO("phoneOffice", "Phone - Office");
//_SKYPE_USER_INFO("mood", "Mood");
//_SKYPE_USER_INFO("richMood", "Mood");
//_SKYPE_USER_INFO("avatarUrl", "Avatar");
buddy = purple_find_buddy(sa->account, username);
if (buddy) {
sbuddy = purple_buddy_get_protocol_data(buddy);
if (sbuddy == NULL) {
sbuddy = g_new0(SkypeWebBuddy, 1);
purple_buddy_set_protocol_data(buddy, sbuddy);
sbuddy->skypename = g_strdup(username);
sbuddy->sa = sa;
}
new_avatar = json_object_get_string_member(userobj, "avatarUrl");
if (new_avatar && (!sbuddy->avatar_url || !g_str_equal(sbuddy->avatar_url, new_avatar))) {
g_free(sbuddy->avatar_url);
sbuddy->avatar_url = g_strdup(new_avatar);
skypeweb_get_icon(buddy);
}
g_free(sbuddy->mood); sbuddy->mood = g_strdup(json_object_get_string_member(userobj, "mood"));
}
purple_notify_userinfo(sa->pc, username, user_info, NULL, NULL);
g_free(username);
}
static void
skypeweb_get_friend_list_cb(SkypeWebAccount *sa, JsonNode *node, gpointer user_data)
{
JsonObject *obj;
JsonArray *contacts;
PurpleGroup *group = NULL;
GSList *users_to_fetch = NULL;
guint index, length;
obj = json_node_get_object(node);
contacts = json_object_get_array_member(obj, "contacts");
length = json_array_get_length(contacts);
for(index = 0; index < length; index++)
{
JsonObject *contact = json_array_get_object_element(contacts, index);
const gchar *id = json_object_get_string_member(contact, "id");
const gchar *display_name = json_object_get_string_member(contact, "display_name");
const gchar *avatar_url = NULL;
gboolean authorized = json_object_get_boolean_member(contact, "authorized");
gboolean blocked = json_object_get_boolean_member(contact, "blocked");
const gchar *type = json_object_get_string_member(contact, "type");
JsonObject *name = json_object_get_object_member(contact, "name");
const gchar *firstname = json_object_get_string_member(name, "first");
const gchar *surname = NULL;
PurpleBuddy *buddy;
//TODO make this work for "pstn"
if (!g_str_equal(type, "skype") && !g_str_equal(type, "msn"))
continue;
if (json_object_has_member(contact, "suggested") && json_object_get_boolean_member(contact, "suggested") && !authorized) {
// suggested buddies wtf? some kind of advertising?
continue;
}
buddy = purple_find_buddy(sa->account, id);
if (!buddy)
{
if (!group)
{
group = purple_blist_find_group("Skype");
if (!group)
{
group = purple_group_new("Skype");
purple_blist_add_group(group, NULL);
}
}
buddy = purple_buddy_new(sa->account, id, display_name);
purple_blist_add_buddy(buddy, NULL, group, NULL);
}
if (json_object_has_member(name, "surname"))
surname = json_object_get_string_member(name, "surname");
// try to free the sbuddy here. no-op if it's not set before, otherwise prevents a leak.
skypeweb_buddy_free(buddy);
SkypeWebBuddy *sbuddy = g_new0(SkypeWebBuddy, 1);
sbuddy->skypename = g_strdup(id);
sbuddy->sa = sa;
sbuddy->fullname = g_strconcat(firstname, (surname ? " " : NULL), surname, NULL);
sbuddy->display_name = g_strdup(display_name);
sbuddy->authorized = authorized;
sbuddy->blocked = blocked;
sbuddy->avatar_url = g_strdup(purple_buddy_icons_get_checksum_for_user(buddy));
sbuddy->buddy = buddy;
purple_buddy_set_protocol_data(buddy, sbuddy);
purple_serv_got_alias(sa->pc, id, sbuddy->display_name);
purple_blist_server_alias_buddy(buddy, sbuddy->fullname);
if (json_object_has_member(contact, "avatar_url")) {
avatar_url = json_object_get_string_member(contact, "avatar_url");
if (avatar_url && *avatar_url && (!sbuddy->avatar_url || !g_str_equal(sbuddy->avatar_url, avatar_url))) {
g_free(sbuddy->avatar_url);
sbuddy->avatar_url = g_strdup(avatar_url);
skypeweb_get_icon(buddy);
}
}
if (blocked == TRUE) {
purple_privacy_deny_add(sa->account, id, TRUE);
} else {
users_to_fetch = g_slist_prepend(users_to_fetch, sbuddy->skypename);
}
}
if (users_to_fetch)
{
//skypeweb_get_friend_profiles(sa, users_to_fetch);
skypeweb_subscribe_to_contact_status(sa, users_to_fetch);
g_slist_free(users_to_fetch);
}
}
static void
skypeweb_close(PurpleConnection *pc)
{
SkypeWebAccount *sa;
GSList *buddies;
g_return_if_fail(pc != NULL);
sa = purple_connection_get_protocol_data(pc);
g_return_if_fail(sa != NULL);
purple_timeout_remove(sa->authcheck_timeout);
purple_timeout_remove(sa->poll_timeout);
purple_timeout_remove(sa->watchdog_timeout);
skypeweb_logout(sa);
purple_signal_disconnect(purple_conversations_get_handle(), "conversation-updated", pc, PURPLE_CALLBACK(skypeweb_mark_conv_seen));
purple_debug_info("skypeweb", "destroying %d waiting connections\n",
g_queue_get_length(sa->waiting_conns));
while (!g_queue_is_empty(sa->waiting_conns))
skypeweb_connection_destroy(g_queue_pop_tail(sa->waiting_conns));
g_queue_free(sa->waiting_conns);
purple_debug_info("skypeweb", "destroying %d incomplete connections\n",
g_slist_length(sa->conns));
while (sa->conns != NULL)
skypeweb_connection_destroy(sa->conns->data);
while (sa->dns_queries != NULL) {
PurpleDnsQueryData *dns_query = sa->dns_queries->data;
purple_debug_info("skypeweb", "canceling dns query for %s\n",
purple_dnsquery_get_host(dns_query));
sa->dns_queries = g_slist_remove(sa->dns_queries, dns_query);
purple_dnsquery_destroy(dns_query);
}
while (sa->url_datas) {
purple_util_fetch_url_cancel(sa->url_datas->data);
sa->url_datas = g_slist_delete_link(sa->url_datas, sa->url_datas);
}
buddies = purple_find_buddies(sa->account, NULL);
while (buddies != NULL) {
PurpleBuddy *buddy = buddies->data;
skypeweb_buddy_free(buddy);
purple_buddy_set_protocol_data(buddy, NULL);
buddies = g_slist_delete_link(buddies, buddies);
}
g_hash_table_destroy(sa->sent_messages_hash);
g_hash_table_destroy(sa->cookie_table);
g_hash_table_destroy(sa->hostname_ip_cache);
g_free(sa->messages_host);
g_free(sa->skype_token);
g_free(sa->registration_token);
g_free(sa->endpoint);
g_free(sa->username);
g_free(sa);
}
void qq_process_add_buddy_no_auth(PurpleConnection *gc,
guint8 *data, gint data_len, guint32 uid)
{
qq_data *qd;
gchar **segments;
gchar *dest_uid, *reply;
PurpleBuddy *buddy;
qq_buddy_data *bd;
g_return_if_fail(data != NULL && data_len != 0);
g_return_if_fail(uid != 0);
qd = (qq_data *) gc->proto_data;
purple_debug_info("QQ", "Process buddy add for id [%u]\n", uid);
qq_show_packet("buddy_add_no_auth", data, data_len);
if (NULL == (segments = split_data(data, data_len, "\x1f", 2)))
return;
dest_uid = segments[0];
reply = segments[1];
if (strtoul(dest_uid, NULL, 10) != qd->uid) { /* should not happen */
purple_debug_error("QQ", "Add buddy reply is to [%s], not me!\n", dest_uid);
g_strfreev(segments);
return;
}
if (strtol(reply, NULL, 10) == 0) {
/* add OK */
qq_buddy_find_or_new(gc, uid);
qq_request_buddy_info(gc, uid, 0, 0);
if (qd->client_version >= 2007) {
qq_request_get_level_2007(gc, uid);
} else {
qq_request_get_level(gc, uid);
}
qq_request_get_buddies_online(gc, 0, 0);
purple_debug_info("QQ", "Successed adding into %u's buddy list\n", uid);
g_strfreev(segments);
return;
}
/* need auth */
purple_debug_warning("QQ", "Failed adding buddy, need authorize\n");
buddy = qq_buddy_find(gc, uid);
if (buddy == NULL) {
buddy = qq_buddy_new(gc, uid);
}
if (buddy != NULL && (bd = purple_buddy_get_protocol_data(buddy)) != NULL) {
/* Not authorized now, free buddy data */
qq_buddy_data_free(bd);
purple_buddy_set_protocol_data(buddy, NULL);
}
add_buddy_authorize_input(gc, uid, NULL, 0);
g_strfreev(segments);
}
