static void waprpl_chat_join (PurpleConnection *gc, GHashTable *data) {
whatsapp_connection * wconn = purple_connection_get_protocol_data(gc);
const char *groupname = g_hash_table_lookup(data, "subject");
char * id = g_hash_table_lookup(data, "id");
int prplid = chatid_to_convo(id);
purple_debug_info(WHATSAPP_ID, "joining group %s\n", groupname);
if (!purple_find_chat(gc, prplid)) {
// Notify chat add
PurpleConversation * conv = serv_got_joined_chat(gc, prplid, groupname);
// Add people in the chat
char *subject, *owner, *part;
if (!waAPI_getgroupinfo(wconn->waAPI, id, &subject, &owner, &part)) return;
purple_debug_info(WHATSAPP_ID, "group info ID(%s) SUBJECT(%s) OWNER(%s)\n", id, subject, owner);
gchar **plist = g_strsplit(part,",",0);
while (*plist) {
purple_conv_chat_add_user (purple_conversation_get_chat_data(conv),
*plist,"",PURPLE_CBFLAGS_NONE | (!strcmp(owner,*plist) ? PURPLE_CBFLAGS_FOUNDER : 0),FALSE);
plist++;
}
}
}
/*------------------------------------------------------------------------
* Update the full GroupChat member list.
*
* @param session The MXit session object
* @param multimx The MultiMX room object
* @param data The nicknames of the users in the room (separated by \n)
*/
static void member_update(struct MXitSession* session, struct multimx* multimx, char* data)
{
PurpleConversation *convo;
gchar** userlist;
int i = 0;
purple_debug_info(MXIT_PLUGIN_ID, "member_update: '%s'\n", data);
convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, multimx->roomname, session->acc);
if (convo == NULL) {
purple_debug_error(MXIT_PLUGIN_ID, "Conversation '%s' not found\n", multimx->roomname);
return;
}
/* Clear list */
purple_conv_chat_clear_users(PURPLE_CONV_CHAT(convo));
/* Add each member */
data = g_strstrip(data); /* string leading & trailing whitespace */
userlist = g_strsplit(data, "\n", 0); /* tokenize string */
while (userlist[i] != NULL) {
purple_debug_info(MXIT_PLUGIN_ID, "member_update - adding: '%s'\n", userlist[i]);
purple_conv_chat_add_user(PURPLE_CONV_CHAT(convo), userlist[i], NULL, PURPLE_CBFLAGS_NONE, FALSE);
i++;
}
g_strfreev(userlist);
}
static void waprpl_chat_invite(PurpleConnection *gc, int id, const char *message, const char *name) {
whatsapp_connection * wconn = purple_connection_get_protocol_data(gc);
PurpleAccount *account = purple_connection_get_account(gc);
PurpleConversation *convo = purple_find_chat(gc, id);
PurpleBlistNode* node = purple_blist_get_root();
GHashTable* hasht = NULL;
while (node != 0) {
if (PURPLE_BLIST_NODE_IS_CHAT(node)) {
PurpleChat * ch = PURPLE_CHAT(node);
if (purple_chat_get_account(ch) == account) {
hasht = purple_chat_get_components(ch);
if (chatid_to_convo(g_hash_table_lookup(hasht, "id")) == id) {
break;
}
}
}
node = purple_blist_node_next(node,FALSE);
}
char * chat_id = g_hash_table_lookup(hasht, "id");
if (strstr(name,"@s.whatsapp.net") == 0) name = g_strdup_printf("*****@*****.**",name);
waAPI_manageparticipant(wconn->waAPI, chat_id, name, "add");
purple_conv_chat_add_user (purple_conversation_get_chat_data(convo), name, "", PURPLE_CBFLAGS_NONE, FALSE);
waprpl_check_output(gc);
return 1;
}
/* void ggp_confer_participants_add(PurpleConnection *gc, const gchar *chat_name, const uin_t *recipients, int count) {{{ */
void ggp_confer_participants_add(PurpleConnection *gc, const gchar *chat_name,
const uin_t *recipients, int count)
{
GGPInfo *info = gc->proto_data;
GList *l;
gchar *str_uin;
for (l = info->chats; l != NULL; l = l->next) {
GGPChat *chat = l->data;
int i;
if (g_utf8_collate(chat->name, chat_name) != 0)
continue;
for (i = 0; i < count; i++) {
PurpleConversation *conv;
if (g_list_find(chat->participants,
GINT_TO_POINTER(recipients[i])) != NULL) {
continue;
}
chat->participants = g_list_append(chat->participants,
GINT_TO_POINTER(recipients[i]));
str_uin = g_strdup_printf("%lu", (unsigned long int)recipients[i]);
conv = ggp_confer_find_by_name(gc, chat_name);
purple_conv_chat_add_user(PURPLE_CONV_CHAT(conv),
str_uin, NULL,
PURPLE_CBFLAGS_NONE, TRUE);
g_free(str_uin);
}
break;
}
}
void yahoo_chat_add_user(PurpleConvChat *chat, const char *user, const char *reason)
{
if (purple_conv_chat_find_user(chat, user))
return;
purple_conv_chat_add_user(chat, user, reason, PURPLE_CBFLAGS_NONE, TRUE);
}
static void yahoo_conf_join(YahooData *yd, PurpleConversation *c, const char *dn, const char *room,
const char *topic, const char *members)
{
struct yahoo_packet *pkt;
char **memarr = NULL;
int i;
if (members)
memarr = g_strsplit(members, "\n", 0);
pkt = yahoo_packet_new(YAHOO_SERVICE_CONFLOGON, YAHOO_STATUS_AVAILABLE, yd->session_id);
yahoo_packet_hash(pkt, "sss", 1, dn, 3, dn, 57, room);
if (memarr) {
for(i = 0 ; memarr[i]; i++) {
if (!strcmp(memarr[i], "") || !strcmp(memarr[i], dn))
continue;
yahoo_packet_hash_str(pkt, 3, memarr[i]);
purple_conv_chat_add_user(PURPLE_CONV_CHAT(c), memarr[i], NULL, PURPLE_CBFLAGS_NONE, TRUE);
}
}
yahoo_packet_send_and_free(pkt, yd);
if (memarr)
g_strfreev(memarr);
}
void p2tgl_conv_add_user (PurpleConversation *conv, struct tgl_chat_user user, char *message, int flags, int new_arrival) {
PurpleConvChat *cdata = purple_conversation_get_chat_data(conv);
char *name = g_strdup_printf("%d", user.user_id);
purple_conv_chat_add_user(cdata, name, message, flags, new_arrival);
g_free(name);
}
/* this is slow, and different from the purple_* version in that it (hopefully) won't add a user twice */
void yahoo_chat_add_users(PurpleConvChat *chat, GList *newusers)
{
GList *i;
for (i = newusers; i; i = i->next) {
if (purple_conv_chat_find_user(chat, i->data))
continue;
purple_conv_chat_add_user(chat, i->data, NULL, PURPLE_CBFLAGS_NONE, TRUE);
}
}
static void conv_add_participants(PurpleConversation * conv, const char *part, const char *owner)
{
gchar **plist = g_strsplit(part, ",", 0);
gchar **p;
purple_conv_chat_clear_users(purple_conversation_get_chat_data(conv));
for (p = plist; *p; p++)
purple_conv_chat_add_user(purple_conversation_get_chat_data(conv), *p, "", PURPLE_CBFLAGS_NONE | (!strcmp(owner, *p) ? PURPLE_CBFLAGS_FOUNDER : 0), FALSE);
g_strfreev(plist);
}
void irc_msg_join(struct irc_conn *irc, const char *name, const char *from, char **args)
{
PurpleConnection *gc = purple_account_get_connection(irc->account);
PurpleConversation *convo;
char *nick = irc_mask_nick(from), *userhost;
struct irc_buddy *ib;
static int id = 1;
if (!gc) {
g_free(nick);
return;
}
if (!purple_utf8_strcasecmp(nick, purple_connection_get_display_name(gc))) {
/* We are joining a channel for the first time */
serv_got_joined_chat(gc, id++, args[0]);
g_free(nick);
convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT,
args[0],
irc->account);
if (convo == NULL) {
purple_debug_error("irc", "tried to join %s but couldn't\n", args[0]);
return;
}
purple_conversation_set_data(convo, IRC_NAMES_FLAG,
GINT_TO_POINTER(FALSE));
/* Until purple_conversation_present does something that
* one would expect in Pidgin, this call produces buggy
* behavior both for the /join and auto-join cases. */
/* purple_conversation_present(convo); */
return;
}
convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, args[0], irc->account);
if (convo == NULL) {
purple_debug(PURPLE_DEBUG_ERROR, "irc", "JOIN for %s failed\n", args[0]);
g_free(nick);
return;
}
userhost = irc_mask_userhost(from);
purple_conv_chat_add_user(PURPLE_CONV_CHAT(convo), nick, userhost, PURPLE_CBFLAGS_NONE, TRUE);
if ((ib = g_hash_table_lookup(irc->buddies, nick)) != NULL) {
ib->flag = TRUE;
irc_buddy_status(nick, ib, irc);
}
g_free(userhost);
g_free(nick);
}
/*------------------------------------------------------------------------
* Another user has join the GroupChat, add them to the member-list.
*
* @param session The MXit session object
* @param multimx The MultiMX room object
* @param nickname The nickname of the user who joined the room
*/
static void member_added(struct MXitSession* session, struct multimx* multimx, const char* nickname)
{
PurpleConversation *convo;
purple_debug_info(MXIT_PLUGIN_ID, "member_added: '%s'\n", nickname);
convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, multimx->roomname, session->acc);
if (convo == NULL) {
purple_debug_error(MXIT_PLUGIN_ID, "Conversation '%s' not found\n", multimx->roomname);
return;
}
purple_conv_chat_add_user(PURPLE_CONV_CHAT(convo), nickname, NULL, PURPLE_CBFLAGS_NONE, TRUE);
}
static void waprpl_chat_invite(PurpleConnection * gc, int id, const char *message, const char *name)
{
whatsapp_connection *wconn = purple_connection_get_protocol_data(gc);
PurpleConversation *convo = purple_find_chat(gc, id);
PurpleChat *ch = blist_find_chat_by_convo(gc, id);
GHashTable *hasht = purple_chat_get_components(ch);
char *chat_id = g_hash_table_lookup(hasht, "id");
if (strstr(name, "@s.whatsapp.net") == 0)
name = g_strdup_printf("*****@*****.**", name);
waAPI_manageparticipant(wconn->waAPI, chat_id, name, "add");
purple_conv_chat_add_user(purple_conversation_get_chat_data(convo), name, "", PURPLE_CBFLAGS_NONE, FALSE);
waprpl_check_output(gc);
}
void hon_parse_chat_join(PurpleConnection *gc,gchar* buffer){
hon_account* hon = gc->proto_data;
guint32 account_id;
guint32 chan_id,purple_flags = PURPLE_CBFLAGS_NONE;
PurpleConversation* conv;
guint8 status,flags;
const gchar* extra;
const gchar* nick;
gchar* shield,*icon,*flag;
chan_id = read_guint32(buffer);
nick = read_string(buffer);
account_id = read_guint32(buffer);
conv = purple_find_chat(gc,chan_id);
if (!conv)
return;
extra = nick;
nick = hon_normalize_nick(gc->account,nick);
status = read_byte(buffer);
flags = read_byte(buffer);
flag = read_string(buffer);
shield = read_string(buffer);
icon = read_string(buffer);
//flags |= GPOINTER_TO_INT(g_hash_table_lookup(conv->data,GINT_TO_POINTER(account_id)));
flags = GPOINTER_TO_INT(g_hash_table_lookup(conv->data,GINT_TO_POINTER(account_id)));
flags &= 0xF;
if (flags == HON_FLAGS_CHAT_ADMINISTRATOR)
purple_flags = PURPLE_CBFLAGS_FOUNDER;
else if (flags == HON_FLAGS_CHAT_LEADER)
purple_flags = PURPLE_CBFLAGS_OP;
else if (flags == HON_FLAGS_CHAT_OFFICER)
purple_flags = PURPLE_CBFLAGS_HALFOP;
if (conv)
{
purple_conv_chat_add_user(PURPLE_CONV_CHAT(conv),nick,extra,purple_flags,TRUE);
}
if (!g_hash_table_lookup(hon->id2nick,GINT_TO_POINTER(account_id)))
{
g_hash_table_insert(hon->id2nick,GINT_TO_POINTER(account_id),g_strdup(nick));
}
}
void PurpleLine::handle_group_invite(
line::Group &group,
line::Contact &invitee,
line::Contact &inviter)
{
blist_update_buddy(invitee, true);
if (invitee.mid == profile.mid) {
// Current user was invited - show popup
GHashTable *components = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
g_hash_table_insert(components, g_strdup("type"),
g_strdup(chat_type_to_string[ChatType::GROUP_INVITE].c_str()));
g_hash_table_insert(components, g_strdup("id"), g_strdup(group.id.c_str()));
// Invites on initial sync do not have inviter data
std::string who = (inviter.__isset.mid)
? inviter.displayName
: std::string("A member");
serv_got_chat_invite(
conn,
group.name.c_str(),
who.c_str(),
nullptr,
components);
} else {
// Another user was invited - if a chat is open, add the user
PurpleConversation *conv = purple_find_conversation_with_account(
PURPLE_CONV_TYPE_CHAT,
group.id.c_str(),
acct);
if (conv) {
std::string msg = "Invited by " + inviter.displayName;
purple_conv_chat_add_user(
PURPLE_CONV_CHAT(conv),
invitee.mid.c_str(),
msg.c_str(),
PURPLE_CBFLAGS_AWAY,
TRUE);
}
}
}
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");
}
}
void hon_parse_chat_entering(PurpleConnection *gc,gchar* buffer)
{
PurpleConversation *convo;
hon_account* hon = gc->proto_data;
guint8 unknown,flags;
guint32 op_count,chat_id,count;
guint32 purple_flags = 0;
gchar* topic,*topic_raw;
const gchar* extra;
GHashTable* ops = NULL;
gchar* buf;
gchar* room = read_string(buffer);
chat_id = read_guint32(buffer);
unknown = read_byte(buffer);
buf = read_string(buffer);
topic = hon2html(buf);
topic_raw = hon_strip(buf,FALSE);
op_count = read_guint32(buffer);
ops = g_hash_table_new(g_direct_hash,g_direct_equal);
if (op_count != 0)
{
guint32 op_id,op_type;
while (op_count--)
{
op_id = read_guint32(buffer);
op_type = read_byte(buffer);
g_hash_table_insert(ops,GINT_TO_POINTER(op_id),GINT_TO_POINTER(op_type));
}
}
count = read_guint32(buffer);
convo = serv_got_joined_chat(gc, chat_id, room);
purple_conv_chat_set_topic(PURPLE_CONV_CHAT(convo), NULL, topic_raw);
while (count--)
{
guint32 account_id, unk32;
guint8 status;
const gchar* nickname;
gchar *flag,*shield,*icon;
buf = read_string(buffer);
nickname = buf;
account_id = read_guint32(buffer);
status = read_byte(buffer);
flags = read_byte(buffer);
flag = read_string(buffer);
shield = read_string(buffer);
icon = read_string(buffer);
unk32 = read_guint32(buffer);
purple_debug_info(HON_DEBUG_PREFIX, "room participant: %s , id=%d,status=%d,flags=%d,flag:%s,shield=%s,icon=%s\n",
nickname,account_id,status,flags,flag,shield,icon);
#if 0
honpurple_get_icon(gc->account,nickname,icon,account_id);
#endif
//flags |= GPOINTER_TO_INT(g_hash_table_lookup(ops,GINT_TO_POINTER(account_id)));
flags = GPOINTER_TO_INT(g_hash_table_lookup(ops,GINT_TO_POINTER(account_id)));
flags &= 0xF;
purple_flags = PURPLE_CBFLAGS_NONE;
if (flags == HON_FLAGS_CHAT_ADMINISTRATOR)
purple_flags = PURPLE_CBFLAGS_FOUNDER;
else if (flags == HON_FLAGS_CHAT_LEADER)
purple_flags = PURPLE_CBFLAGS_OP;
else if (flags == HON_FLAGS_CHAT_OFFICER)
purple_flags = PURPLE_CBFLAGS_HALFOP;
extra = nickname;
nickname = hon_normalize_nick(gc->account,nickname);
purple_conv_chat_add_user(PURPLE_CONV_CHAT(convo), nickname, extra, purple_flags, FALSE);
if (!g_hash_table_lookup(hon->id2nick,GINT_TO_POINTER(account_id)))
{
g_hash_table_insert(hon->id2nick,GINT_TO_POINTER(account_id),g_strdup(nickname));
}
}
flags = 0;
purple_flags = PURPLE_CBFLAGS_NONE;
flags = GPOINTER_TO_INT(g_hash_table_lookup(ops,GINT_TO_POINTER(hon->self.account_id)));
if (convo->data != NULL)
g_hash_table_destroy(convo->data);
convo->data = ops;
if (flags == HON_FLAGS_CHAT_ADMINISTRATOR)
purple_flags = PURPLE_CBFLAGS_FOUNDER;
else if (flags == HON_FLAGS_CHAT_LEADER)
purple_flags = PURPLE_CBFLAGS_OP;
else if (flags == HON_FLAGS_CHAT_OFFICER)
purple_flags = PURPLE_CBFLAGS_HALFOP;
purple_conv_chat_write(PURPLE_CONV_CHAT(convo), "", topic, PURPLE_MESSAGE_SYSTEM|PURPLE_MESSAGE_NO_LOG, time(NULL));
g_free(topic);
g_free(topic_raw);
purple_conv_chat_add_user(PURPLE_CONV_CHAT(convo), hon->self.nickname, NULL,purple_flags , FALSE);
}
static gboolean
handle_presence_chat(JabberStream *js, JabberPresence *presence, xmlnode *packet)
{
static int i = 1;
PurpleConvChatBuddyFlags flags = PURPLE_CBFLAGS_NONE;
JabberChat *chat = presence->chat;
if (presence->state == JABBER_BUDDY_STATE_ERROR) {
char *title, *msg = jabber_parse_error(js, packet, NULL);
if (!chat->conv) {
title = g_strdup_printf(_("Error joining chat %s"), presence->from);
purple_serv_got_join_chat_failed(js->gc, chat->components);
} else {
title = g_strdup_printf(_("Error in chat %s"), presence->from);
if (g_hash_table_size(chat->members) == 0)
serv_got_chat_left(js->gc, chat->id);
}
purple_notify_error(js->gc, title, title, msg);
g_free(title);
g_free(msg);
if (g_hash_table_size(chat->members) == 0)
/* Only destroy the chat if the error happened while joining */
jabber_chat_destroy(chat);
return FALSE;
}
if (presence->type == JABBER_PRESENCE_AVAILABLE) {
const char *jid = NULL;
const char *affiliation = NULL;
const char *role = NULL;
gboolean is_our_resource = FALSE; /* Is the presence about us? */
JabberBuddyResource *jbr;
/*
* XEP-0045 mandates the presence to include a resource (which is
* treated as the chat nick). Some non-compliant servers allow
* joining without a nick.
*/
if (!presence->jid_from->resource)
return FALSE;
if (presence->chat_info.item) {
jid = xmlnode_get_attrib(presence->chat_info.item, "jid");
affiliation = xmlnode_get_attrib(presence->chat_info.item, "affiliation");
role = xmlnode_get_attrib(presence->chat_info.item, "role");
}
if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(110)) ||
g_str_equal(presence->jid_from->resource, chat->handle) ||
purple_strequal(presence->to, jid))
is_our_resource = TRUE;
if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(201))) {
chat->config_dialog_type = PURPLE_REQUEST_ACTION;
chat->config_dialog_handle =
purple_request_action(js->gc,
_("Create New Room"),
_("Create New Room"),
_("You are creating a new room. Would"
" you like to configure it, or"
" accept the default settings?"),
/* Default Action */ 1,
purple_connection_get_account(js->gc), NULL, chat->conv,
chat, 2,
_("_Configure Room"), G_CALLBACK(jabber_chat_request_room_configure),
_("_Accept Defaults"), G_CALLBACK(jabber_chat_create_instant_room));
}
if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(210))) {
/* server rewrote room-nick */
g_free(chat->handle);
chat->handle = g_strdup(presence->jid_from->resource);
}
if (purple_strequal(affiliation, "owner"))
flags |= PURPLE_CBFLAGS_FOUNDER;
if (role) {
if (g_str_equal(role, "moderator"))
flags |= PURPLE_CBFLAGS_OP;
else if (g_str_equal(role, "participant"))
flags |= PURPLE_CBFLAGS_VOICE;
}
if(!chat->conv) {
char *room_jid = g_strdup_printf("%s@%s", presence->jid_from->node, presence->jid_from->domain);
chat->id = i++;
chat->conv = serv_got_joined_chat(js->gc, chat->id, room_jid);
purple_conv_chat_set_nick(PURPLE_CONV_CHAT(chat->conv), chat->handle);
jabber_chat_disco_traffic(chat);
g_free(room_jid);
}
jbr = jabber_buddy_track_resource(presence->jb, presence->jid_from->resource, presence->priority, presence->state, presence->status);
jbr->commands_fetched = TRUE;
jabber_chat_track_handle(chat, presence->jid_from->resource, jid, affiliation, role);
if(!jabber_chat_find_buddy(chat->conv, presence->jid_from->resource))
purple_conv_chat_add_user(PURPLE_CONV_CHAT(chat->conv), presence->jid_from->resource,
jid, flags, chat->joined > 0 && ((!presence->delayed) || (presence->sent > chat->joined)));
else
purple_conv_chat_user_set_flags(PURPLE_CONV_CHAT(chat->conv), presence->jid_from->resource,
flags);
if (is_our_resource && chat->joined == 0)
chat->joined = time(NULL);
} else if (presence->type == JABBER_PRESENCE_UNAVAILABLE) {
gboolean nick_change = FALSE;
gboolean kick = FALSE;
gboolean is_our_resource = FALSE; /* Is the presence about us? */
const char *jid = NULL;
/* If the chat nick is invalid, we haven't yet joined, or we've
* already left (it was probably us leaving after we closed the
* chat), we don't care.
*/
if (!presence->jid_from->resource || !chat->conv || chat->left) {
if (chat->left &&
presence->jid_from->resource && chat->handle && !strcmp(presence->jid_from->resource, chat->handle))
jabber_chat_destroy(chat);
return FALSE;
}
is_our_resource = g_str_equal(presence->jid_from->resource, chat->handle);
jabber_buddy_remove_resource(presence->jb, presence->jid_from->resource);
if (presence->chat_info.item)
jid = xmlnode_get_attrib(presence->chat_info.item, "jid");
if (chat->muc) {
if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(110))) {
is_our_resource = TRUE;
chat->joined = 0;
}
if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(301))) {
/* XXX: We got banned. YAY! (No GIR, that's bad) */
}
if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(303))) {
const char *nick = NULL;
if (presence->chat_info.item)
nick = xmlnode_get_attrib(presence->chat_info.item, "nick");
/* nick change */
if (!nick) {
purple_debug_warning("jabber", "Chat presence indicating a nick change, but no new nickname!\n");
} else {
nick_change = TRUE;
if (g_str_equal(presence->jid_from->resource, chat->handle)) {
/* Changing our own nickname */
g_free(chat->handle);
/* TODO: This should be resourceprep'd */
chat->handle = g_strdup(nick);
}
purple_conv_chat_rename_user(PURPLE_CONV_CHAT(chat->conv),
presence->jid_from->resource,
nick);
jabber_chat_remove_handle(chat,
presence->jid_from->resource);
}
}
if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(307))) {
/* Someone was kicked from the room */
const char *actor = NULL;
char *reason = NULL;
char *tmp;
kick = TRUE;
if (presence->chat_info.item) {
xmlnode *node;
node = xmlnode_get_child(presence->chat_info.item, "actor");
if (node)
actor = xmlnode_get_attrib(node, "jid");
node = xmlnode_get_child(presence->chat_info.item, "reason");
if (node)
reason = xmlnode_get_data(node);
}
if (reason == NULL)
reason = g_strdup(_("No reason"));
if (is_our_resource) {
if (actor)
tmp = g_strdup_printf(_("You have been kicked by %s: (%s)"),
actor, reason);
else
tmp = g_strdup_printf(_("You have been kicked: (%s)"),
reason);
} else {
if (actor)
tmp = g_strdup_printf(_("Kicked by %s (%s)"),
actor, reason);
else
tmp = g_strdup_printf(_("Kicked (%s)"),
reason);
}
g_free(presence->status);
presence->status = tmp;
g_free(reason);
}
if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(321))) {
/* XXX: removed due to an affiliation change */
}
if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(322))) {
/* XXX: removed because room is now members-only */
}
if (g_slist_find(presence->chat_info.codes, GINT_TO_POINTER(332))) {
/* XXX: removed due to system shutdown */
}
}
/*
* Possibly another connected resource of our JID (see XEP-0045
* v1.24 section 7.1.10) being disconnected. Should be
* distinguished by the item_jid.
* Also possibly works around bits of an Openfire bug. See
* #8319.
*/
if (is_our_resource && jid && !purple_strequal(presence->to, jid)) {
/* TODO: When the above is a loop, this needs to still act
* sanely for all cases (this code is a little fragile). */
if (!kick && !nick_change)
/* Presumably, kicks and nick changes also affect us. */
is_our_resource = FALSE;
}
if(!nick_change) {
if (is_our_resource) {
if (kick)
purple_conv_chat_write(PURPLE_CONV_CHAT(chat->conv), presence->jid_from->resource,
presence->status, PURPLE_MESSAGE_SYSTEM, time(NULL));
serv_got_chat_left(js->gc, chat->id);
jabber_chat_destroy(chat);
} else {
purple_conv_chat_remove_user(PURPLE_CONV_CHAT(chat->conv), presence->jid_from->resource,
presence->status);
jabber_chat_remove_handle(chat, presence->jid_from->resource);
}
}
}
return TRUE;
}
void coincoin_parse_message(HttpHandler* handler, gchar* response, gsize len, gpointer userdata)
{
CoinCoinAccount* cca = handler->data;
PurpleConversation* convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, "board", cca->account);
if(!convo)
return; // not on the board channel
xmlnode* node = coincoin_xmlparse(response, len);
xmlnode* post;
GSList *last_msg = cca->messages;
GSList *iter;
GSList *messages = NULL;
unsigned i;
if(!node)
{
purple_debug(PURPLE_DEBUG_ERROR, "coincoin", "Unable to parse response.\n");
return;
}
for(post = xmlnode_get_child(node, "post"); post; post = xmlnode_get_next_twin(post))
{
CoinCoinMessage* msg;
gint64 id = strtoul(xmlnode_get_attrib(post, "id"), NULL, 10);
/* Check if this message has already been showed. */
for(iter = last_msg; iter && ((CoinCoinMessage*)iter->data)->id != id; iter = iter->next)
;
if(iter)
break;
msg = coincoin_message_new(id, post);
if(!msg)
continue;
messages = g_slist_prepend(messages, msg);
if(strcmp(msg->from, purple_connection_get_display_name(cca->pc)))
{
PurpleConvChatBuddy* cb = purple_conv_chat_cb_find(PURPLE_CONV_CHAT(convo), msg->from);
if(!cb)
purple_conv_chat_add_user(PURPLE_CONV_CHAT(convo), msg->from, msg->info, PURPLE_CBFLAGS_NONE, FALSE);
}
}
/* Flush messages (in reversed order) */
for(iter = messages; iter; )
{
CoinCoinMessage* msg = iter->data;
if(!purple_account_get_bool(cca->account, "no_reformat_messages", FALSE))
coincoin_message_ref(msg, cca->messages);
serv_got_chat_in(cca->pc,
purple_conv_chat_get_id(PURPLE_CONV_CHAT(convo)),
msg->from,
PURPLE_MESSAGE_DELAYED,
msg->message,
msg->timestamp);
if(cca->messages && ((CoinCoinMessage*)cca->messages->data)->timestamp == msg->timestamp)
{
msg->multiple = ((CoinCoinMessage*)cca->messages->data)->multiple = TRUE;
msg->ref = ((CoinCoinMessage*)cca->messages->data)->ref + 1;
}
GSList* link = iter;
iter = iter->next;
link->next = cca->messages;
cca->messages = link;
}
/* Now purge extra-messages */
for(i = 0, iter = last_msg; iter; ++i)
{
if(i < CC_LAST_MESSAGE_MAX)
iter = iter->next;
else if(i == CC_LAST_MESSAGE_MAX)
{
GSList* prev;
prev = iter;
iter = iter->next;
prev->next = NULL;
}
else
{
/* This user doesn't participate to conversation
* anymore. So it can leave channel.
*/
CoinCoinMessage* cur = iter->data;
if(strcmp(cur->from, purple_connection_get_display_name(cca->pc)) &&
purple_conv_chat_cb_find(PURPLE_CONV_CHAT(convo), cur->from))
{
GSList* it = cca->messages;
while(it && it != iter && strcmp(((CoinCoinMessage*)it->data)->from, cur->from))
it = it->next;
if(it == iter || !it)
purple_conv_chat_remove_user(PURPLE_CONV_CHAT(convo), cur->from, NULL);
}
coincoin_message_free(cur);
iter->data = NULL;
iter = g_slist_delete_link(iter, iter);
}
}
xmlnode_free(node);
}
static void waprpl_process_incoming_events(PurpleConnection *gc) {
whatsapp_connection * wconn = purple_connection_get_protocol_data(gc);
PurpleAccount * acc = purple_connection_get_account(gc);
switch (waAPI_loginstatus(wconn->waAPI)) {
case 0:
purple_connection_update_progress(gc, "Connecting", 0, 4);
break;
case 1:
purple_connection_update_progress(gc, "Sending auth", 1, 4);
break;
case 2:
purple_connection_update_progress(gc, "Waiting response", 2, 4);
break;
case 3:
purple_connection_update_progress(gc, "Connected", 3, 4);
purple_connection_set_state(gc, PURPLE_CONNECTED);
if (!wconn->connected)
waprpl_insert_contacts(gc);
wconn->connected = 1;
break;
default:
break;
};
char * msg, * who, * prev, * url, *author;
int status; int size;
double lat,lng;
// Incoming messages
while (waAPI_querychat(wconn->waAPI, &who, &msg, &author)) {
purple_debug_info(WHATSAPP_ID, "Got chat message from %s: %s\n", who,msg);
if (isgroup(who)) {
// Search fot the combo
PurpleBlistNode* node = purple_blist_get_root();
GHashTable* hasht = NULL;
while (node != 0) {
if (PURPLE_BLIST_NODE_IS_CHAT(node)) {
PurpleChat * ch = PURPLE_CHAT(node);
if (purple_chat_get_account(ch) == acc) {
hasht = purple_chat_get_components(ch);
if (strcmp(g_hash_table_lookup(hasht, "id"),who) == 0) {
break;
}
}
}
node = purple_blist_node_next(node,FALSE);
}
int convo_id = chatid_to_convo(who);
PurpleConversation *convo = purple_find_chat(gc, convo_id);
// Create a window if it's not open yet
if (!convo)
waprpl_chat_join(gc,hasht);
if (convo != NULL) {
serv_got_chat_in(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(convo)), author, PURPLE_MESSAGE_RECV, msg, time(NULL));
}else{
printf("Received group message but could not find the group! %s\n",msg);
}
}else{
// Search fot the combo
PurpleConversation *convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, who, acc);
if (!convo)
convo = purple_conversation_new(PURPLE_CONV_TYPE_IM, acc, who);
serv_got_chat_in(gc, purple_conv_chat_get_id(PURPLE_CONV_IM(convo)), who, PURPLE_MESSAGE_RECV, msg, time(NULL));
purple_conv_im_write(PURPLE_CONV_IM(convo), who, msg, PURPLE_MESSAGE_RECV, time(NULL));
}
}
while (waAPI_querychatimage(wconn->waAPI, &who, &prev, &size, &url)) {
printf("Got chat image %s %s\n",who,url);
purple_debug_info(WHATSAPP_ID, "Got image from %s: %s\n", who,url);
// Search fot the combo
PurpleConversation *convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, who, acc);
if (!convo)
convo = purple_conversation_new(PURPLE_CONV_TYPE_IM, acc, who);
int imgid = purple_imgstore_add_with_id(g_memdup(prev, size), size, NULL);
serv_got_chat_in(gc, purple_conv_chat_get_id(PURPLE_CONV_IM(convo)), who, PURPLE_MESSAGE_RECV, msg, time(NULL));
purple_conv_im_write(PURPLE_CONV_IM(convo), who, g_strdup_printf("<a href=\"%s\"><img id=\"%u\"></a>",url,imgid),
PURPLE_MESSAGE_RECV | PURPLE_MESSAGE_IMAGES, time(NULL));
}
while (waAPI_querychatlocation(wconn->waAPI, &who, &prev, &size, &lat, &lng)) {
purple_debug_info(WHATSAPP_ID, "Got geomessage from: %s Coordinates (%f %f)\n", who,(float)lat,(float)lng);
// Search fot the combo
PurpleConversation *convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, who, acc);
if (!convo)
convo = purple_conversation_new(PURPLE_CONV_TYPE_IM, acc, who);
int imgid = purple_imgstore_add_with_id(g_memdup(prev, size), size, NULL);
serv_got_chat_in(gc, purple_conv_chat_get_id(PURPLE_CONV_IM(convo)), who, PURPLE_MESSAGE_RECV, msg, time(NULL));
purple_conv_im_write(PURPLE_CONV_IM(convo), who,
g_strdup_printf("<a href=\"http://openstreetmap.org/?lat=%f&lon=%f&zoom=16\"><img src=\"%u\"></a>",lat,lng,imgid),
PURPLE_MESSAGE_RECV | PURPLE_MESSAGE_IMAGES, time(NULL));
}
while (waAPI_querychatsound(wconn->waAPI, &who, &url)) {
purple_debug_info(WHATSAPP_ID, "Got chat sound from %s: %s\n", who,url);
// Search fot the combo
PurpleConversation *convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, who, acc);
if (!convo)
convo = purple_conversation_new(PURPLE_CONV_TYPE_IM, acc, who);
serv_got_chat_in(gc, purple_conv_chat_get_id(PURPLE_CONV_IM(convo)), who, PURPLE_MESSAGE_RECV, msg, time(NULL));
purple_conv_im_write(PURPLE_CONV_IM(convo), who, g_strdup_printf("<a href=\"%s\">%s</a>",url,url),
PURPLE_MESSAGE_RECV , time(NULL));
}
// User status change
while (waAPI_querystatus(wconn->waAPI, &who, &status)) {
if (status == 1) {
purple_prpl_got_user_status(acc, who, "available", "message","", NULL);
}
else {
purple_prpl_got_user_status(acc, who, "unavailable", "message","", NULL);
}
}
// User typing info notify
while (waAPI_querytyping(wconn->waAPI, &who, &status)) {
if (status == 1) {
serv_got_typing(gc,who,0,PURPLE_TYPING);
}
else {
serv_got_typing_stopped(gc,who);
}
}
// User profile picture
char * icon, * hash;
int len;
while (waAPI_queryicon(wconn->waAPI, &who, &icon, &len, &hash)) {
purple_buddy_icons_set_for_user(acc,who, g_memdup(icon,len),len, hash);
}
// Groups update
if (waAPI_getgroupsupdated(wconn->waAPI)) {
// Delete/update the chats that are in our list
PurpleBlistNode* node = purple_blist_get_root();
while (node != 0) {
if (PURPLE_BLIST_NODE_IS_CHAT(node)) {
PurpleChat * ch = PURPLE_CHAT(node);
if (purple_chat_get_account(ch) == acc) {
int found = 0;
GHashTable *hasht = purple_chat_get_components(ch);
char * grid = g_hash_table_lookup(hasht, "id");
char * glist = waAPI_getgroups(wconn->waAPI);
gchar **gplist = g_strsplit(glist,",",0);
while (*gplist) {
if (strcmp(*gplist,grid) == 0) {
// The group is in the system, update the fields
char *id,*sub,*own;
waAPI_getgroupinfo(wconn->waAPI, *gplist, &sub, &own, 0);
g_hash_table_insert(hasht, g_strdup("subject"), g_strdup(sub));
g_hash_table_insert(hasht, g_strdup("owner"), g_strdup(own));
found = 1;
break;
}
gplist++;
}
// The group was deleted
if (!found) {
PurpleBlistNode* del = node;
node = purple_blist_node_next(node,FALSE);
purple_blist_remove_chat(del);
}
}
}
node = purple_blist_node_next(node,FALSE);
}
// Add new groups
char * glist = waAPI_getgroups(wconn->waAPI);
gchar **gplist = g_strsplit(glist,",",0);
while (*gplist) {
int found = 0;
PurpleBlistNode* node = purple_blist_get_root();
PurpleChat * ch;
while (node != 0) {
if (PURPLE_BLIST_NODE_IS_CHAT(node)) {
ch = PURPLE_CHAT(node);
if (purple_chat_get_account(ch) == acc) {
char * grid = g_hash_table_lookup(purple_chat_get_components(ch), "id");
if (strcmp(*gplist,grid) == 0) {
found = 1;
break;
}
}
}
node = purple_blist_node_next(node,FALSE);
}
if (!found) {
char *sub,*own;
waAPI_getgroupinfo(wconn->waAPI, *gplist, &sub, &own, 0);
purple_debug_info("waprpl", "New group found %s %s\n", *gplist,sub);
GHashTable * htable = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
g_hash_table_insert(htable, g_strdup("subject"), g_strdup(sub));
g_hash_table_insert(htable, g_strdup("id"), g_strdup(*gplist));
g_hash_table_insert(htable, g_strdup("owner"), g_strdup(own));
ch = purple_chat_new(acc,sub,htable);
purple_blist_add_chat(ch,NULL,NULL);
}
// Now update the open conversation that may exist
char * id = g_hash_table_lookup(purple_chat_get_components(ch), "id");
int prplid = chatid_to_convo(id);
PurpleConversation * conv = purple_find_chat(gc, prplid);
if (conv) {
char *subject, *owner, *part;
if (!waAPI_getgroupinfo(wconn->waAPI, id, &subject, &owner, &part)) return;
purple_conv_chat_clear_users(purple_conversation_get_chat_data(conv));
gchar **plist = g_strsplit(part,",",0);
while (*plist) {
purple_conv_chat_add_user (purple_conversation_get_chat_data(conv),
*plist,"",PURPLE_CBFLAGS_NONE | (!strcmp(owner,*plist) ? PURPLE_CBFLAGS_FOUNDER : 0),FALSE);
plist++;
}
}
gplist++;
}
}
}
static void parse_new_messages(PurpleConnection *pc, FacebookAccount *fba, JsonArray *messages)
{
int i;
PurpleBuddy *buddy;
purple_debug_info("facebook", "parsing new messages\n");
for (i = 0; i < json_array_get_length(messages); i++) {
const gchar *type;
gchar *from, *to;
JsonObject *object = json_node_get_object(json_array_get_element(messages, i));
type = json_node_get_string(json_object_get_member(object, "type"));
from = g_strdup_printf("%" G_GINT64_FORMAT, (gint64)json_node_get_int(json_object_get_member(object, "from")));
to = g_strdup_printf("%" G_GINT64_FORMAT, (gint64)json_node_get_int(json_object_get_member(object, "to")));
/* Use the in-line buddy name if the buddy list hasn't been downloaded yet */
buddy = purple_find_buddy(pc->account, from);
if (buddy == NULL || buddy->server_alias == NULL || buddy->alias == NULL)
{
if (json_object_has_member(object, "from_name"))
{
const gchar *from_name = json_node_get_string(json_object_get_member(
object, "from_name"));
fb_blist_set_alias(fba, from, from_name);
}
}
if (from && to && g_str_equal(type, "msg")) {
JsonObject *messageObj = json_node_get_object(json_object_get_member(object, "msg"));
parse_message(pc, fba, messageObj, from, to, PURPLE_CONV_TYPE_IM);
} else if (from && g_str_equal(type, "typ")) {
purple_debug_info("facebook", "handling typing notification\n");
gint typing = json_node_get_int(json_object_get_member(object, "st"));
if (typing == 0) {
serv_got_typing(pc, from, 10, PURPLE_NOT_TYPING);
} else {
serv_got_typing(pc, from, 10, PURPLE_TYPING);
}
} else if (g_str_equal(type, "group_msg")) {
PurpleConversation *conv = fb_find_chat(fba, to);
if (conv != NULL)
{
if (json_object_has_member(object, "to_name"))
{
const gchar *to_name = json_node_get_string(json_object_get_member(
object, "to_name"));
purple_conversation_set_title(conv, to_name);
PurpleChat *chat = purple_blist_find_chat(fba->account, to);
purple_blist_alias_chat(chat, to_name);
}
if (!purple_conv_chat_cb_find(PURPLE_CONV_CHAT(conv), from))
{
purple_conv_chat_add_user(PURPLE_CONV_CHAT(conv), from, NULL, PURPLE_CBFLAGS_NONE, FALSE);
}
if (!purple_find_buddy(fba->account, from))
{
const char *from_name = json_node_get_string(json_object_get_member(
object, "from_name"));
buddy = purple_buddy_new(fba->account, from, from_name);
purple_blist_node_set_flags((PurpleBlistNode *)buddy, PURPLE_BLIST_NODE_FLAG_NO_SAVE);
purple_blist_add_buddy(buddy, NULL, purple_find_group(DEFAULT_GROUP_NAME), NULL);
}
}
JsonObject *messageObj = json_node_get_object(json_object_get_member(object, "msg"));
parse_message(pc, fba, messageObj, from, to, PURPLE_CONV_TYPE_CHAT);
}
/*
* we've received something from a buddy, assume they're online
* only if it's not from ourselves
*/
if (from && fba->uid != atoll(from)) {
purple_prpl_got_user_status(
fba->account, from,
purple_primitive_get_id_from_type(PURPLE_STATUS_AVAILABLE), NULL);
}
g_free(from);
g_free(to);
fba->message_fetch_sequence++;
}
}
static void
nap_callback(gpointer data, gint source, PurpleInputCondition condition) {
PurpleConnection *gc = data;
struct nap_data *ndata = gc->proto_data;
PurpleAccount *account = NULL;
PurpleConversation *c = NULL;
PurpleNotifyUserInfo *pnui = NULL;
gchar *buf = NULL, *buf2 = NULL, *buf3 = NULL, **res = NULL;
unsigned short header[2] = { 0 , 0 };
int len = 0;
int command = 0;
int i;
account = purple_connection_get_account(gc);
if (read(source, (void*)header, 4) != 4) {
purple_connection_error(gc, _("Unable to read header from server"));
return;
}
len = header[0];
command = header[1];
buf = (gchar *)g_malloc((len + 1) * sizeof(gchar));
buf[len] = '\0';
i = 0;
do {
int tmp = read(source, buf + i, len - i);
if (tmp <= 0) {
g_free(buf);
buf = g_strdup_printf(_("Unable to read message from server: %s. Command is %hd, length is %hd."), strerror(errno), len, command);
purple_connection_error(gc, buf);
g_free(buf);
return;
}
i += tmp;
} while (i != len);
purple_debug(PURPLE_DEBUG_MISC, "napster", "R %3hd: %s\n", command, buf);
switch (command) {
case 000: /* MSG_SERVER_ERROR */
purple_notify_error(gc, NULL, buf, NULL);
purple_input_remove(gc->inpa);
gc->inpa = 0;
close(source);
purple_connection_error(gc, _("Unknown server error."));
break;
case 003: /* MSG_SERVER_EMAIL */
purple_debug(PURPLE_DEBUG_MISC, "napster", "Registered with e-mail address: %s\n", buf);
ndata->email = g_strdup(buf);
/* Our signon is complete */
purple_connection_set_state(gc, PURPLE_CONNECTED);
/* Send the server our buddy list */
nap_send_buddylist(gc);
break;
case 201: /* MSG_SERVER_SEARCH_RESULT */
res = g_strsplit(buf, " ", 0);
purple_prpl_got_user_status(account, res[0], "available", NULL);
g_strfreev(res);
break;
case 202: /* MSG_SERVER_SEARCH_END */
purple_prpl_got_user_status(account, buf, "offline", NULL);
break;
case 205: /* MSG_CLIENT_PRIVMSG */
res = g_strsplit(buf, " ", 2);
buf2 = g_markup_escape_text(res[1], -1);
serv_got_im(gc, res[0], buf2, 0, time(NULL));
g_free(buf2);
g_strfreev(res);
break;
case 209: /* MSG_SERVER_USER_SIGNON */
/* USERNAME SPEED */
res = g_strsplit(buf, " ", 2);
purple_prpl_got_user_status(account, res[0], "available", NULL);
g_strfreev(res);
break;
case 210: /* MSG_SERVER_USER_SIGNOFF */
/* USERNAME SPEED */
res = g_strsplit(buf, " ", 2);
purple_prpl_got_user_status(account, res[0], "offline", NULL);
g_strfreev(res);
break;
case 214: /* MSG_SERVER_STATS */
res = g_strsplit(buf, " ", 3);
buf2 = g_strdup_printf(_("users: %s, files: %s, size: %sGB"), res[0], res[1], res[2]);
serv_got_im(gc, "server", buf2, 0, time(NULL));
g_free(buf2);
g_strfreev(res);
break;
case 301: /* MSG_SERVER_HOTLIST_ACK */
/* Our buddy was added successfully */
break;
case 302: /* MSG_SERVER_HOTLIST_ERROR */
buf2 = g_strdup_printf(_("Unable to add \"%s\" to your Napster hotlist"), buf);
purple_notify_error(gc, NULL, buf2, NULL);
g_free(buf2);
break;
case 316: /* MSG_SERVER_DISCONNECTING */
/* we have been kicked off =^( */
purple_connection_error(gc, _("You were disconnected from the server."));
break;
case 401: /* MSG_CLIENT_PART */
c = nap_find_chat(gc, buf);
if (c)
serv_got_chat_left(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(c)));
break;
case 403: /* MSG_SERVER_PUBLIC */
res = g_strsplit(buf, " ", 3);
c = nap_find_chat(gc, res[0]);
if (c)
serv_got_chat_in(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(c)), res[1], 0, res[2], time((time_t)NULL));
g_strfreev(res);
break;
case 404: /* MSG_SERVER_NOSUCH */
/* abused by opennap servers to broadcast stuff */
buf2 = g_markup_escape_text(buf, -1);
serv_got_im(gc, "server", buf2, 0, time(NULL));
g_free(buf2);
break;
case 405: /* MSG_SERVER_JOIN_ACK */
c = nap_find_chat(gc, buf);
if (!c)
serv_got_joined_chat(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(c)), buf);
break;
case 407: /* MSG_SERVER_PART */
res = g_strsplit(buf, " ", 0);
c = nap_find_chat(gc, res[0]);
purple_conv_chat_remove_user(PURPLE_CONV_CHAT(c), res[1], NULL);
g_strfreev(res);
break;
case 406: /* MSG_SERVER_JOIN */
case 408: /* MSG_SERVER_CHANNEL_USER_LIST */
res = g_strsplit(buf, " ", 4);
c = nap_find_chat(gc, res[0]);
purple_conv_chat_add_user(PURPLE_CONV_CHAT(c), res[1], NULL, PURPLE_CBFLAGS_NONE, TRUE);
g_strfreev(res);
break;
case 409: /* MSG_SERVER_CHANNEL_USER_LIST_END */
break;
case 410: /* MSG_SERVER_TOPIC */
/* display the topic in the channel */
res = g_strsplit(buf, " ", 2);
c = nap_find_chat(gc, res[0]);
purple_conv_chat_set_topic(PURPLE_CONV_CHAT(c), res[0], res[1]);
g_strfreev(res);
break;
case 603: /* MSG_CLIENT_WHOIS */
buf2 = g_strdup_printf(_("%s requested your information"), buf);
serv_got_im(gc, "server", buf2, 0, time(NULL));
g_free(buf2);
break;
case 604: /* MSG_SERVER_WHOIS_RESPONSE */
/* XXX - Format is: "Elite" 37 " " "Active" 0 0 0 0 "purple 0.63cvs" 0 0 192.168.1.41 32798 0 unknown flounder */
res = g_strsplit(buf, " ", 2);
/* res[0] == username */
pnui = purple_notify_user_info_new();
purple_notify_user_info_add_pair(pnui, _("Napster User Info:"), res[1]);
purple_notify_userinfo(gc, res[0], pnui, NULL, NULL);
g_strfreev(res);
break;
case 621:
case 622: /* MSG_CLIENT_MOTD */
/* also replaces MSG_SERVER_MOTD, so we should display it */
buf2 = g_markup_escape_text(buf, -1);
serv_got_im(gc, "motd", buf2, 0, time(NULL));
g_free(buf2);
break;
case 627: /* MSG_CLIENT_WALLOP */
/* abused by opennap server maintainers to broadcast stuff */
buf2 = g_markup_escape_text(buf, -1);
serv_got_im(gc, "wallop", buf2, 0, time(NULL));
g_free(buf2);
break;
case 628: /* MSG_CLIENT_ANNOUNCE */
buf2 = g_markup_escape_text(buf, -1);
serv_got_im(gc, "announce", buf2, 0, time(NULL));
g_free(buf);
break;
case 748: /* MSG_SERVER_GHOST */
/* Looks like someone logged in as us! =-O */
purple_connection_error(gc, _("You have signed on from another location."));
break;
case 751: /* MSG_CLIENT_PING */
buf2 = g_strdup_printf(_("%s requested a PING"), buf);
serv_got_im(gc, "server", buf2, 0, time(NULL));
g_free(buf2);
/* send back a pong */
/* MSG_CLIENT_PONG */
nap_write_packet(gc, 752, "%s", buf);
break;
case 752: /* MSG_CLIENT_PONG */
buf2 = g_strdup_printf("Received pong from %s", buf);
purple_notify_info(gc, NULL, buf2, NULL);
g_free(buf2);
break;
case 824: /* MSG_CLIENT_EMOTE */
res = g_strsplit(buf, " ", 3);
buf2 = g_strndup(res[2]+1, strlen(res[2]) - 2); /* chomp off the surround quotes */
buf3 = g_strdup_printf("/me %s", buf2);
g_free(buf2);
if ((c = nap_find_chat(gc, res[0]))) {
purple_conv_chat_write(PURPLE_CONV_CHAT(c), res[1], buf3, PURPLE_MESSAGE_NICK, time(NULL));
}
g_free(buf3);
g_strfreev(res);
break;
default:
purple_debug(PURPLE_DEBUG_MISC, "napster", "Unknown packet %hd: %s\n", command, buf);
break;
}
g_free(buf);
}
static void
msn_switchboard_add_user(MsnSwitchBoard *swboard, const char *user)
{
MsnCmdProc *cmdproc;
PurpleAccount *account;
g_return_if_fail(swboard != NULL);
cmdproc = swboard->cmdproc;
account = cmdproc->session->account;
swboard->users = g_list_prepend(swboard->users, g_strdup(user));
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), user, NULL,
PURPLE_CBFLAGS_NONE, TRUE);
msn_servconn_set_idle_timeout(swboard->servconn, 0);
}
else if (swboard->current_users > 1 || swboard->total_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 = l->data;
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,
user, account);
}
else
{
purple_debug_warning("msn", "switchboard_add_user: This should not happen!\n");
}
}
void
fb_got_facepile(FacebookAccount *fba, const gchar *data, gsize data_len, gpointer user_data)
{
gchar *group = user_data;
JsonParser *parser;
JsonObject *object, *payload, *user_obj;
JsonArray *facepile;
PurpleConversation *conv;
PurpleConvChat *chat;
gchar *uid;
guint i;
PurpleGroup *pgroup;
purple_debug_info("facebook", "got facepile %s\n", data?data:"(null)");
conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, group, fba->account);
chat = PURPLE_CONV_CHAT(conv);
parser = fb_get_parser(data, data_len);
if (!parser)
{
purple_debug_warning("facebook",
"could not fetch facepile for group %s\n", group);
g_free(group);
return;
}
object = fb_get_json_object(parser, NULL);
payload = json_node_get_object(
json_object_get_member(object, "payload"));
facepile = json_node_get_array(
json_object_get_member(payload, "facepile_click_info"));
pgroup = purple_find_group(DEFAULT_GROUP_NAME);
if (!pgroup)
{
pgroup = purple_group_new(DEFAULT_GROUP_NAME);
purple_blist_add_group(pgroup, NULL);
}
purple_conv_chat_clear_users(chat);
uid = g_strdup_printf("%" G_GINT64_FORMAT, fba->uid);
purple_conv_chat_add_user(chat, uid, NULL, PURPLE_CBFLAGS_NONE, FALSE);
if (!purple_find_buddy(fba->account, uid))
{
PurpleBuddy *buddy = purple_buddy_new(fba->account, uid, "You");
purple_blist_node_set_flags((PurpleBlistNode *)buddy, PURPLE_BLIST_NODE_FLAG_NO_SAVE);
purple_blist_add_buddy(buddy, NULL, pgroup, NULL);
}
g_free(uid);
for (i = 0; i < json_array_get_length(facepile); i++)
{
user_obj = json_node_get_object(
json_array_get_element(facepile, i));
uid = g_strdup_printf("%" G_GINT64_FORMAT, (gint64)json_node_get_int(json_object_get_member(user_obj, "uid")));
purple_conv_chat_add_user(PURPLE_CONV_CHAT(conv), uid, NULL, PURPLE_CBFLAGS_NONE, FALSE);
if (!purple_find_buddy(fba->account, uid))
{
const char *alias = json_node_get_string(json_object_get_member(user_obj, "name"));
PurpleBuddy *buddy = purple_buddy_new(fba->account, uid, alias);
purple_blist_node_set_flags((PurpleBlistNode *)buddy, PURPLE_BLIST_NODE_FLAG_NO_SAVE);
purple_blist_add_buddy(buddy, NULL, pgroup, NULL);
}
g_free(uid);
}
g_free(group);
}
