/*------------------------------------------------------------------------
* 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);
}
int yahoo_c_send(PurpleConnection *gc, int id, const char *what, PurpleMessageFlags flags)
{
PurpleConversation *c;
int ret;
YahooData *yd;
yd = (YahooData *) gc->proto_data;
if (!yd)
return -1;
c = purple_find_chat(gc, id);
if (!c)
return -1;
if (id != YAHOO_CHAT_ID) {
ret = yahoo_conf_send(gc, purple_connection_get_display_name(gc),
purple_conversation_get_name(c), purple_conv_chat_get_users(PURPLE_CONV_CHAT(c)), what);
} else {
ret = yahoo_chat_send(gc, purple_connection_get_display_name(gc),
purple_conversation_get_name(c), what, flags);
if (!ret)
serv_got_chat_in(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(c)),
purple_connection_get_display_name(gc), flags, what, time(NULL));
}
return ret;
}
void yahoo_process_conference_logon(PurpleConnection *gc, struct yahoo_packet *pkt)
{
GSList *l;
char *room = NULL;
char *who = NULL;
PurpleConversation *c;
for (l = pkt->hash; l; l = l->next) {
struct yahoo_pair *pair = l->data;
switch (pair->key) {
case 57:
g_free(room);
room = yahoo_string_decode(gc, pair->value, FALSE);
break;
case 53:
who = pair->value;
break;
}
}
if (who && room) {
c = yahoo_find_conference(gc, room);
if (c)
{ /* Prevent duplicate users in the chat */
if( !purple_conv_chat_find_user(PURPLE_CONV_CHAT(c), who) )
yahoo_chat_add_user(PURPLE_CONV_CHAT(c), who, NULL);
}
g_free(room);
}
}
void hon_parse_channel_auth_list(PurpleConnection *gc,gchar* buffer)
{
PurpleConversation* chat;
guint32 count,chatid = read_guint32(buffer);
count = read_guint32(buffer);
chat = purple_find_chat(gc,chatid);
if (!chat)
return;
purple_conv_chat_write(PURPLE_CONV_CHAT(chat), "",
_("Listing Authorized Users..."),
PURPLE_MESSAGE_SYSTEM, time(NULL));
if (count == 0)
{
purple_conv_chat_write(PURPLE_CONV_CHAT(chat), "",
_("There are no authorized users for this channel."),
PURPLE_MESSAGE_SYSTEM, time(NULL));
}
else
{
while (count--)
{
purple_conv_chat_write(PURPLE_CONV_CHAT(chat), "",
buffer,
PURPLE_MESSAGE_SYSTEM, time(NULL));
read_string(buffer);
}
}
}
void irc_msg_kick(struct irc_conn *irc, const char *name, const char *from, char **args)
{
PurpleConnection *gc = purple_account_get_connection(irc->account);
PurpleConversation *convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, args[0], irc->account);
char *nick = irc_mask_nick(from), *buf;
if (!gc) {
g_free(nick);
return;
}
if (!convo) {
purple_debug(PURPLE_DEBUG_ERROR, "irc", "Recieved a KICK for unknown channel %s\n", args[0]);
g_free(nick);
return;
}
if (!purple_utf8_strcasecmp(purple_connection_get_display_name(gc), args[1])) {
buf = g_strdup_printf(_("You have been kicked by %s: (%s)"), nick, args[2]);
purple_conv_chat_write(PURPLE_CONV_CHAT(convo), args[0], buf, PURPLE_MESSAGE_SYSTEM, time(NULL));
g_free(buf);
serv_got_chat_left(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(convo)));
} else {
buf = g_strdup_printf(_("Kicked by %s (%s)"), nick, args[2]);
purple_conv_chat_remove_user(PURPLE_CONV_CHAT(convo), args[1], buf);
g_free(buf);
}
g_free(nick);
return;
}
/* merge this with the function below when we get everyone on the same page wrt /commands */
void jabber_chat_change_topic(JabberChat *chat, const char *topic)
{
if(topic && *topic) {
JabberMessage *jm;
jm = g_new0(JabberMessage, 1);
jm->js = chat->js;
jm->type = JABBER_MESSAGE_GROUPCHAT;
jm->subject = purple_markup_strip_html(topic);
jm->to = g_strdup_printf("%s@%s", chat->room, chat->server);
jabber_message_send(jm);
jabber_message_free(jm);
} else {
const char *cur = purple_conv_chat_get_topic(PURPLE_CONV_CHAT(chat->conv));
char *buf, *tmp, *tmp2;
if(cur) {
tmp = g_markup_escape_text(cur, -1);
tmp2 = purple_markup_linkify(tmp);
buf = g_strdup_printf(_("current topic is: %s"), tmp2);
g_free(tmp);
g_free(tmp2);
} else
buf = g_strdup(_("No topic is set"));
purple_conv_chat_write(PURPLE_CONV_CHAT(chat->conv), "", buf,
PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LOG, time(NULL));
g_free(buf);
}
}
static int waprpl_send_chat(PurpleConnection *gc, int id, const char *message, PurpleMessageFlags flags) {
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");
waAPI_sendchat(wconn->waAPI,chat_id,message);
waprpl_check_output(gc);
serv_got_chat_in(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(convo)), purple_connection_get_display_name(gc), PURPLE_MESSAGE_SEND, message, time(NULL));
purple_conv_im_write(PURPLE_CONV_CHAT(convo), purple_connection_get_display_name(gc), message, PURPLE_MESSAGE_SEND, time(NULL));
return 1;
}
void irc_msg_topic(struct irc_conn *irc, const char *name, const char *from, char **args)
{
char *chan, *topic, *msg, *nick, *tmp, *tmp2;
PurpleConversation *convo;
if (!strcmp(name, "topic")) {
chan = args[0];
topic = irc_mirc2txt (args[1]);
} else {
chan = args[1];
topic = irc_mirc2txt (args[2]);
}
convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, chan, irc->account);
if (!convo) {
purple_debug(PURPLE_DEBUG_ERROR, "irc", "Got a topic for %s, which doesn't exist\n", chan);
g_free(topic);
return;
}
/* If this is an interactive update, print it out */
tmp = g_markup_escape_text(topic, -1);
tmp2 = purple_markup_linkify(tmp);
g_free(tmp);
if (!strcmp(name, "topic")) {
const char *current_topic = purple_conv_chat_get_topic(PURPLE_CONV_CHAT(convo));
if (!(current_topic != NULL && strcmp(tmp2, current_topic) == 0))
{
char *nick_esc;
nick = irc_mask_nick(from);
nick_esc = g_markup_escape_text(nick, -1);
purple_conv_chat_set_topic(PURPLE_CONV_CHAT(convo), nick, topic);
if (*tmp2)
msg = g_strdup_printf(_("%s has changed the topic to: %s"), nick_esc, tmp2);
else
msg = g_strdup_printf(_("%s has cleared the topic."), nick_esc);
g_free(nick_esc);
g_free(nick);
purple_conv_chat_write(PURPLE_CONV_CHAT(convo), from, msg, PURPLE_MESSAGE_SYSTEM, time(NULL));
g_free(msg);
}
} else {
char *chan_esc = g_markup_escape_text(chan, -1);
msg = g_strdup_printf(_("The topic for %s is: %s"), chan_esc, tmp2);
g_free(chan_esc);
purple_conv_chat_set_topic(PURPLE_CONV_CHAT(convo), NULL, topic);
purple_conv_chat_write(PURPLE_CONV_CHAT(convo), "", msg, PURPLE_MESSAGE_SYSTEM, time(NULL));
g_free(msg);
}
g_free(tmp2);
g_free(topic);
}
static void irc_chat_remove_buddy(PurpleConversation *convo, char *data[2])
{
char *message, *stripped;
stripped = data[1] ? irc_mirc2txt(data[1]) : NULL;
message = g_strdup_printf("quit: %s", stripped);
g_free(stripped);
if (purple_conv_chat_find_user(PURPLE_CONV_CHAT(convo), data[0]))
purple_conv_chat_remove_user(PURPLE_CONV_CHAT(convo), data[0], message);
g_free(message);
}
void QuetzalChat::update(PurpleConvUpdateType type)
{
PurpleConvChat *chat = PURPLE_CONV_CHAT(m_conv);
if (type == PURPLE_CONV_UPDATE_CHATLEFT)
setJoined(chat->left);
else if (type == PURPLE_CONV_UPDATE_TOPIC) {
QString oldTopic = m_topic;
m_topic = purple_conv_chat_get_topic(PURPLE_CONV_CHAT(m_conv));
emit topicChanged(m_topic, oldTopic);
} else if (type == PURPLE_CONV_UPDATE_TITLE) {
// QString oldTitle = m_title;
// m_title = purple_PURPLE_CONV_CHAT(m_conv));
// emit topicChanged(m_topic, oldTopic);
}
}
void
translate_sending_chat_message_cb(const gchar *original_phrase, const gchar *translated_phrase, const gchar *detected_language, gpointer userdata)
{
struct TranslateConvMessage *convmsg = userdata;
gchar *html_text;
int err = 0;
html_text = purple_strdup_withhtml(translated_phrase);
err = serv_chat_send(purple_account_get_connection(convmsg->account), purple_conv_chat_get_id(PURPLE_CONV_CHAT(convmsg->conv)), html_text, convmsg->flags);
g_free(html_text);
html_text = purple_strdup_withhtml(original_phrase);
//if (err > 0)
//{
// purple_conversation_write(convmsg->conv, convmsg->sender, html_text, convmsg->flags, time(NULL));
//}
purple_signal_emit(purple_conversations_get_handle(), "sent-chat-msg",
convmsg->account, html_text,
purple_conv_chat_get_id(PURPLE_CONV_CHAT(convmsg->conv)));
g_free(html_text);
g_free(convmsg->sender);
g_free(convmsg);
}
gboolean
pop(gpointer p) {
char *reply = "";
queue_t *q = (queue_t*)p;
queue_item_t *item;
if (q->len > 0) {
item = q->q[0];
q->len--;
if (q->len > 0) {
memmove(q->q, &(q->q[1]), q->len * sizeof(queue_item_t*));
// q->q = realloc(q->q, q->len * sizeof(queue_item_t*));
}
if (purple_conversation_get_type(item->conv) == PURPLE_CONV_TYPE_IM) {
// reply = alice(item->name, item->msg, item->conv);
purple_conv_im_send(PURPLE_CONV_IM(item->conv), item->msg);
} else if (purple_conversation_get_type(item->conv) == PURPLE_CONV_TYPE_CHAT) {
// reply = alice(item->name, item->msg, item->conv);
purple_conv_chat_send(PURPLE_CONV_CHAT(item->conv), item->msg);
}
printf (NAME ": %s\n", reply);
free(item->name);
free(item->msg);
free(item);
}
return 1;
}
static void yahoo_conf_invite(PurpleConnection *gc, PurpleConversation *c,
const char *dn, const char *buddy, const char *room, const char *msg)
{
YahooData *yd = gc->proto_data;
struct yahoo_packet *pkt;
GList *members;
char *msg2 = NULL;
if (msg)
msg2 = yahoo_string_encode(gc, msg, NULL);
members = purple_conv_chat_get_users(PURPLE_CONV_CHAT(c));
pkt = yahoo_packet_new(YAHOO_SERVICE_CONFADDINVITE, YAHOO_STATUS_AVAILABLE, yd->session_id);
yahoo_packet_hash(pkt, "sssss", 1, dn, 51, buddy, 57, room, 58, msg?msg2:"", 13, "0");
for(; members; members = members->next) {
const char *name = purple_conv_chat_cb_get_name(members->data);
if (!strcmp(name, dn))
continue;
yahoo_packet_hash(pkt, "ss", 52, name, 53, name);
}
yahoo_packet_send_and_free(pkt, yd);
g_free(msg2);
}
void yahoo_process_chat_exit(PurpleConnection *gc, struct yahoo_packet *pkt)
{
char *who = NULL;
char *room = NULL;
GSList *l;
for (l = pkt->hash; l; l = l->next) {
struct yahoo_pair *pair = l->data;
if (pair->key == 104) {
g_free(room);
room = yahoo_string_decode(gc, pair->value, TRUE);
}
if (pair->key == 109)
who = pair->value;
}
if (who && room) {
PurpleConversation *c = purple_find_chat(gc, YAHOO_CHAT_ID);
if (c && !purple_utf8_strcasecmp(purple_conversation_get_name(c), room))
purple_conv_chat_remove_user(PURPLE_CONV_CHAT(c), who, NULL);
}
g_free(room);
}
void irc_msg_nick(struct irc_conn *irc, const char *name, const char *from, char **args)
{
PurpleConnection *gc = purple_account_get_connection(irc->account);
PurpleConversation *conv;
GSList *chats;
char *nick = irc_mask_nick(from);
irc->nickused = FALSE;
if (!gc) {
g_free(nick);
return;
}
chats = gc->buddy_chats;
if (!purple_utf8_strcasecmp(nick, purple_connection_get_display_name(gc))) {
purple_connection_set_display_name(gc, args[0]);
}
while (chats) {
PurpleConvChat *chat = PURPLE_CONV_CHAT(chats->data);
/* This is ugly ... */
if (purple_conv_chat_find_user(chat, nick))
purple_conv_chat_rename_user(chat, nick, args[0]);
chats = chats->next;
}
conv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM, nick,
irc->account);
if (conv != NULL)
purple_conversation_set_name(conv, args[0]);
g_free(nick);
}
static int waprpl_send_chat(PurpleConnection * gc, int id, const char *message, PurpleMessageFlags flags)
{
whatsapp_connection *wconn = purple_connection_get_protocol_data(gc);
PurpleAccount *account = purple_connection_get_account(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");
char *plain;
purple_markup_html_to_xhtml(message, NULL, &plain);
char msgid[128];
waAPI_getmsgid(wconn->waAPI, msgid);
purple_signal_emit(purple_connection_get_prpl(gc), "whatsapp-sending-message", gc, msgid, chat_id, message);
waAPI_sendchat(wconn->waAPI, msgid, chat_id, plain);
g_free(plain);
waprpl_check_output(gc);
const char *me = purple_account_get_string(account, "nick", "");
purple_conv_chat_write(PURPLE_CONV_CHAT(convo), me, message, PURPLE_MESSAGE_SEND, time(NULL));
return 1;
}
static void
notify_chat_nick (PurpleAccount *account,
const gchar *sender,
const gchar *message,
PurpleConversation *conv,
gpointer data)
{
gchar *nick;
nick = (gchar *)purple_conv_chat_get_nick (PURPLE_CONV_CHAT(conv));
#ifndef DEBUG /* in debug mode, always show notifications */
if (nick && !strcmp (sender, nick))
return;
#else
purple_debug_info (PLUGIN_ID, "Message would be suppressed normally because you said it yourself");
#endif
int triggermessagefound = 0;
int i;
for (i = 0; words[i]; i++ ) {
if (g_strstr_len(message, strlen(message), words[i])) {
triggermessagefound=1;
purple_debug_info (PLUGIN_ID, "found triggermessage in chat");
break;
}
}
if (!triggermessagefound){
purple_debug_info (PLUGIN_ID, "no triggermessage found in chat");
}
if (!triggermessagefound && !g_strstr_len(message, strlen(message), nick) && !purple_prefs_get_bool("/plugins/gtk/libnotify/othermsgs"))
return;
notify_msg_sent (account, conv, sender, message);
}
static gboolean should_hide_notice(PurpleConversation *conv, const char *name,
GHashTable *users)
{
PurpleConvChat *chat;
int threshold;
struct joinpart_key key;
time_t *last_said;
g_return_val_if_fail(conv != NULL, FALSE);
g_return_val_if_fail(purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_CHAT, FALSE);
/* If the room is small, don't bother. */
chat = PURPLE_CONV_CHAT(conv);
threshold = purple_prefs_get_int(THRESHOLD_PREF);
if (g_list_length(purple_conv_chat_get_users(chat)) < threshold)
return FALSE;
if (!purple_prefs_get_bool(HIDE_BUDDIES_PREF) &&
purple_find_buddy(purple_conversation_get_account(conv), name))
return FALSE;
/* Only show the notice if the user has spoken recently. */
key.conv = conv;
key.user = (gchar *)name;
last_said = g_hash_table_lookup(users, &key);
if (last_said != NULL)
{
int delay = purple_prefs_get_int(DELAY_PREF);
if (delay > 0 && (*last_said + (delay * 60)) >= time(NULL))
return FALSE;
}
return TRUE;
}
void jabber_chat_change_nick(JabberChat *chat, const char *nick)
{
xmlnode *presence;
char *full_jid;
PurplePresence *gpresence;
PurpleStatus *status;
JabberBuddyState state;
char *msg;
int priority;
if(!chat->muc) {
purple_conv_chat_write(PURPLE_CONV_CHAT(chat->conv), "",
_("Nick changing not supported in non-MUC chatrooms"),
PURPLE_MESSAGE_SYSTEM, time(NULL));
return;
}
gpresence = purple_account_get_presence(chat->js->gc->account);
status = purple_presence_get_active_status(gpresence);
purple_status_to_jabber(status, &state, &msg, &priority);
presence = jabber_presence_create(state, msg, priority);
full_jid = g_strdup_printf("%s@%s/%s", chat->room, chat->server, nick);
xmlnode_set_attrib(presence, "to", full_jid);
g_free(full_jid);
g_free(msg);
jabber_send(chat->js, presence);
xmlnode_free(presence);
}
PurpleConversation *get_open_combo(const char *who, PurpleConnection * gc)
{
PurpleAccount *acc = purple_connection_get_account(gc);
if (isgroup(who)) {
/* Search fot the combo */
PurpleChat *ch = blist_find_chat_by_id(gc, who);
GHashTable *hasht = purple_chat_get_components(ch);
int convo_id = chatid_to_convo(who);
const char *groupname = g_hash_table_lookup(hasht, "subject");
PurpleConversation *convo = purple_find_chat(gc, convo_id);
/* Create a window if it's not open yet */
if (!convo) {
waprpl_chat_join(gc, hasht);
convo = purple_find_chat(gc, convo_id);
}
else if (purple_conv_chat_has_left(PURPLE_CONV_CHAT(convo))) {
char *subject, *owner, *part;
whatsapp_connection *wconn = purple_connection_get_protocol_data(gc);
if (waAPI_getgroupinfo(wconn->waAPI, (char*)who, &subject, &owner, &part)) {
convo = serv_got_joined_chat(gc, convo_id, groupname);
purple_debug_info(WHATSAPP_ID, "group info ID(%s) SUBJECT(%s) OWNER(%s)\n", who, subject, owner);
conv_add_participants(convo, part, owner);
}
}
return convo;
} else {
/* Search for 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);
return convo;
}
}
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);
}
bool QuetzalChat::sendMessage(const Message &message)
{
if (!m_conv->account->gc)
return false;
purple_conv_chat_send(PURPLE_CONV_CHAT(m_conv), message.text().toUtf8().constData());
return true;
}
static gboolean
received_chat_msg_cb(PurpleAccount *account,
char *sender,
char *message,
PurpleConversation *conv,
PurpleMessageFlags flags,
gpointer data)
{
PurpleConvChat *chat = PURPLE_CONV_CHAT(conv);
purple_debug_info(PLUGIN_ID, "%s\n", message);
/* only listen to rooms on the list */
if (!g_list_find(chatroom_list, chat)) return FALSE;
/* stop duplicated messages from QQ Qun */
if (!strcmp(account->protocol_id, "prpl-qq") &&
(account->alias) &&
!strcmp(sender, account->alias)) return FALSE;
/* if received, push to other chatrooms on the list */
if ( (flags & PURPLE_MESSAGE_RECV) ) {
char *msg = format_message(sender, message);
void forward_chat_message(gpointer data, gpointer user_data) {
PurpleConvChat *chatroom = (PurpleConvChat*)data;
if(chatroom != chat) {
purple_conv_chat_send(chatroom, msg);
}
}
void hon_parse_channel_kick(PurpleConnection *gc,gchar* buffer){
hon_account* hon = gc->proto_data;
guint32 chatid,kickerid,kickedid;
gchar* kicked,*kicker,*msg;
PurpleConversation* chat;
chatid = read_guint32(buffer);
kickerid = read_guint32(buffer);
kickedid = read_guint32(buffer);
chat = purple_find_chat(gc,chatid);
if (!chat)
return;
if (kickerid == hon->self.account_id)
kicker = hon->self.nickname;
else if((kicker = g_hash_table_lookup(hon->id2nick,GINT_TO_POINTER(kickerid))))
{}
else
kicker = _("Someone");
if (kickedid == hon->self.account_id)
kicked = hon->self.nickname;
else if((kicked = g_hash_table_lookup(hon->id2nick,GINT_TO_POINTER(kickedid))))
{}
else
kicked = _("Someone");
msg = g_strdup_printf(_("%s was kicked from the channel by %s"),kicked,kicker);
purple_conv_chat_write(PURPLE_CONV_CHAT(chat), "", msg, PURPLE_MESSAGE_SYSTEM, time(NULL));
if (kickedid == hon->self.account_id)
serv_got_chat_left(gc, chatid);
g_free(msg);
}
void PurpleLine::write_message(PurpleConversation *conv, std::string &from, std::string &text,
time_t mtime, int flags)
{
if (!conv)
return;
PurpleConversationType type = purple_conversation_get_type(conv);
if (type == PURPLE_CONV_TYPE_IM) {
purple_conv_im_write(
PURPLE_CONV_IM(conv),
from.c_str(),
text.c_str(),
(PurpleMessageFlags)flags,
mtime);
} else if (type == PURPLE_CONV_TYPE_CHAT) {
purple_conv_chat_write(
PURPLE_CONV_CHAT(conv),
from.c_str(),
text.c_str(),
(PurpleMessageFlags)flags,
mtime);
} else {
purple_debug_warning("line", "write_message for weird conversation type: %d\n", type);
}
}
void hon_parse_channel_ban_unban(PurpleConnection *gc,gchar* buffer,guint16 packet_id)
{
hon_account* hon = gc->proto_data;
guint32 chatid,kickerid;
gchar* kicked,*kicker,*msg,*action;
PurpleConversation* chat;
chatid = read_guint32(buffer);
kickerid = read_guint32(buffer);
kicked = read_string(buffer);
chat = purple_find_chat(gc,chatid);
if (!chat)
return;
if (kickerid == hon->self.account_id)
kicker = hon->self.nickname;
else if((kicker = g_hash_table_lookup(hon->id2nick,GINT_TO_POINTER(kickerid))))
{}
else
kicker = _("Someone");
if (packet_id == HON_SC_CHANNEL_BAN)
action = _("banned");
else
action = _("unbanned");
msg = g_strdup_printf(_("%s was %s from the channel by %s."),kicked,action,kicker);
purple_conv_chat_write(PURPLE_CONV_CHAT(chat), "", msg, PURPLE_MESSAGE_SYSTEM, time(NULL));
g_free(msg);
}
void hon_parse_channel_auth_enable_disable(PurpleConnection *gc,gchar* buffer,guint16 packet_id)
{
PurpleConversation* chat;
guint32 chatid = read_guint32(buffer);
chat = purple_find_chat(gc,chatid);
if (!chat)
return;
if (packet_id == HON_SC_CHANNEL_AUTH_ENABLE)
purple_conv_chat_write(PURPLE_CONV_CHAT(chat), "",
_("Authorization has been enabled for this channel, you must now be on the authorized list to join."),
PURPLE_MESSAGE_SYSTEM, time(NULL));
else
purple_conv_chat_write(PURPLE_CONV_CHAT(chat), "",
_("Authorization has been disabled for this channel, all users can now join."),
PURPLE_MESSAGE_SYSTEM, time(NULL));
}
/* 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_process_conference_decline(PurpleConnection *gc, struct yahoo_packet *pkt)
{
GSList *l;
char *room = NULL;
char *who = NULL;
char *msg = NULL;
PurpleConversation *c = NULL;
int utf8 = 0;
for (l = pkt->hash; l; l = l->next) {
struct yahoo_pair *pair = l->data;
switch (pair->key) {
case 57:
g_free(room);
room = yahoo_string_decode(gc, pair->value, FALSE);
break;
case 54:
who = pair->value;
break;
case 14:
g_free(msg);
msg = yahoo_string_decode(gc, pair->value, FALSE);
break;
case 97:
utf8 = strtol(pair->value, NULL, 10);
break;
}
}
if (!purple_privacy_check(purple_connection_get_account(gc), who))
{
g_free(room);
g_free(msg);
return;
}
if (who && room) {
/* make sure we're in the room before we process a decline message for it */
if((c = yahoo_find_conference(gc, room))) {
char *tmp = NULL, *msg_tmp = NULL;
if(msg)
{
msg_tmp = yahoo_string_decode(gc, msg, utf8);
msg = yahoo_codes_to_html(msg_tmp);
serv_got_chat_in(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(c)), who, 0, msg, time(NULL));
g_free(msg_tmp);
g_free(msg);
}
tmp = g_strdup_printf(_("%s has declined to join."), who);
purple_conversation_write(c, NULL, tmp, PURPLE_MESSAGE_SYSTEM | PURPLE_MESSAGE_NO_LINKIFY, time(NULL));
g_free(tmp);
}
g_free(room);
}
}
JabberChat *jabber_chat_find_by_conv(PurpleConversation *conv)
{
PurpleAccount *account = purple_conversation_get_account(conv);
PurpleConnection *gc = purple_account_get_connection(account);
JabberStream *js = gc->proto_data;
int id = purple_conv_chat_get_id(PURPLE_CONV_CHAT(conv));
return jabber_chat_find_by_id(js, id);
}
