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
purplemot_chat_invite(PurpleConnection *gc, int id, const char *message,
const char *who)
{
const char *username = gc->account->username;
PurpleConversation *conv = purple_find_chat(gc, id);
const char *room = conv->name;
PurpleAccount *to_acct = purple_accounts_find(who, PURPLEMOT_ID);
purple_debug_info("purplemot", "%s is inviting %s to join chat room %s\n",
username, who, room);
if (to_acct) {
PurpleConversation *to_conv = purple_find_chat(to_acct->gc, id);
if (to_conv) {
char *tmp = g_strdup_printf("%s is already in chat room %s.", who, room);
purple_debug_info("purplemot",
"%s is already in chat room %s; "
"ignoring invitation from %s\n",
who, room, username);
purple_notify_info(gc, _("Chat invitation"), _("Chat invitation"), tmp);
g_free(tmp);
} else {
GHashTable *components;
components = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, g_free);
g_hash_table_replace(components, "room", g_strdup(room));
g_hash_table_replace(components, "invited_by", g_strdup(username));
serv_got_chat_invite(to_acct->gc, room, username, message, components);
}
}
}
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 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 on_chat_get_info (struct tgl_state *TLS, void *extra, int success, struct tgl_chat *C) {
assert (success);
debug ("on_chat_joined(%d)\n", tgl_get_peer_id (C->id));
telegram_conn *conn = TLS->ev_base;
PurpleConversation *conv;
if (!(conv = purple_find_chat(conn->gc, tgl_get_peer_id(C->id)))) {
// chat conversation is not existing, create it
conv = serv_got_joined_chat(conn->gc, tgl_get_peer_id(C->id), C->title);
}
purple_conv_chat_clear_users(purple_conversation_get_chat_data(conv));
chat_add_all_users(conv, C);
struct message_text *mt = 0;
while ((mt = g_queue_pop_head (conn->new_messages))) {
if (!chat_add_message(TLS, mt->M, mt->text)) {
warning ("WARNING, chat %d still not existing... \n", tgl_get_peer_id (C->id));
break;
}
if (mt->text) {
g_free (mt->text);
}
free (mt);
}
gchar *name = g_strdup_printf ("%d", tgl_get_peer_id(C->id));
g_hash_table_remove (conn->joining_chats, name);
g_free (name);
}
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_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);
}
}
}
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++;
}
}
}
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 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);
}
static void on_update_chat_participants (struct tgl_state *TLS, struct tgl_chat *chat) {
PurpleConversation *pc = purple_find_chat(tg_get_conn(TLS), tgl_get_peer_id(chat->id));
if (pc) {
purple_conv_chat_clear_users (purple_conversation_get_chat_data(pc));
chat_add_all_users (pc, chat);
}
}
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;
}
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");
if (!id) {
gchar *tmp = g_strdup_printf("Joining %s requires an invitation.", groupname);
purple_notify_error(gc, "Invitation only", "Invitation only", tmp);
g_free(tmp);
return;
}
int prplid = chatid_to_convo(id);
purple_debug_info(WHATSAPP_ID, "joining group %s\n", groupname);
if (!purple_find_chat(gc, prplid)) {
char *subject, *owner, *part;
if (!waAPI_getgroupinfo(wconn->waAPI, id, &subject, &owner, &part))
return;
/* Notify chat add */
PurpleConversation *conv = serv_got_joined_chat(gc, prplid, groupname);
/* Add people in the chat */
purple_debug_info(WHATSAPP_ID, "group info ID(%s) SUBJECT(%s) OWNER(%s)\n", id, subject, owner);
conv_add_participants(conv, part, owner);
}
}
void tgp_chat_users_update (struct tgl_state *TLS, struct tgl_chat *C) {
PurpleConversation *pc = purple_find_chat (tg_get_conn (TLS), tgl_get_peer_id (C->id));
if (pc) {
purple_conv_chat_clear_users (purple_conversation_get_chat_data (pc));
tgp_chat_add_all_users (TLS, pc, C);
}
}
static int irc_chat_send(PurpleConnection *gc, int id, const char *what, PurpleMessageFlags flags)
{
struct irc_conn *irc = gc->proto_data;
PurpleConversation *convo = purple_find_chat(gc, id);
const char *args[2];
char *tmp;
if (!convo) {
purple_debug(PURPLE_DEBUG_ERROR, "irc", "chat send on nonexistent chat\n");
return -EINVAL;
}
#if 0
if (*what == '/') {
return irc_parse_cmd(irc, convo->name, what + 1);
}
#endif
purple_markup_html_to_xhtml(what, NULL, &tmp);
args[0] = convo->name;
args[1] = tmp;
irc_cmd_privmsg(irc, "msg", NULL, args);
serv_got_chat_in(gc, id, purple_connection_get_display_name(gc), 0, what, time(NULL));
g_free(tmp);
return 0;
}
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 yahoo_process_chat_message(PurpleConnection *gc, struct yahoo_packet *pkt)
{
char *room = NULL, *who = NULL, *msg = NULL, *msg2;
int msgtype = 1, utf8 = 1; /* default to utf8 */
PurpleConversation *c = NULL;
GSList *l;
for (l = pkt->hash; l; l = l->next) {
struct yahoo_pair *pair = l->data;
switch (pair->key) {
case 97:
utf8 = strtol(pair->value, NULL, 10);
break;
case 104:
g_free(room);
room = yahoo_string_decode(gc, pair->value, TRUE);
break;
case 109:
who = pair->value;
break;
case 117:
msg = pair->value;
break;
case 124:
msgtype = strtol(pair->value, NULL, 10);
break;
}
}
c = purple_find_chat(gc, YAHOO_CHAT_ID);
if (!who || !c) {
if (room)
g_free(room);
/* we still get messages after we part, funny that */
return;
}
if (!msg) {
purple_debug_misc("yahoo", "Got a message packet with no message.\nThis probably means something important, but we're ignoring it.\n");
return;
}
msg2 = yahoo_string_decode(gc, msg, utf8);
msg = yahoo_codes_to_html(msg2);
g_free(msg2);
if (msgtype == 2 || msgtype == 3) {
char *tmp;
tmp = g_strdup_printf("/me %s", msg);
g_free(msg);
msg = tmp;
}
serv_got_chat_in(gc, YAHOO_CHAT_ID, who, 0, msg, time(NULL));
g_free(msg);
g_free(room);
}
static void
join_chat(PurpleConnection * gc, GHashTable * data)
{
if (!purple_find_chat(gc, CHAT_ID)) {
purple_debug_misc(PLUGIN_ID, "JOIN CHAT\n");
serv_got_joined_chat(gc, CHAT_ID, CHAT_NAME);
gc->proto_data = (void*)purple_timeout_add_seconds(1, timer_cb, gc);
}
}
/* 401 - MSG_CLIENT_PART */
static void
nap_chat_leave(PurpleConnection *gc, int id) {
PurpleConversation *c = purple_find_chat(gc, id);
if (!c)
return;
nap_write_packet(gc, 401, "%s", c->name);
}
int PurpleLine::chat_send(int id, const char *message, PurpleMessageFlags flags) {
PurpleConversation *conv = purple_find_chat(conn, id);
if (!conv) {
purple_debug_warning("line", "Tried to send to a nonexistent chat.\n");
return 0;
}
return send_message(purple_conversation_get_name(conv), message);
}
static void
purplemot_get_cb_info(PurpleConnection *gc, int id, const char *who)
{
PurpleConversation *conv = purple_find_chat(gc, id);
purple_debug_info("purplemot",
"retrieving %s's info for %s in chat room %s\n", who,
gc->account->username, conv->name);
purplemot_get_info(gc, who);
}
void hon_parse_channel_silenced(PurpleConnection* gc,gchar* buffer){
PurpleConversation *convo;
guint32 chan_id = read_guint32(buffer);
convo = purple_find_chat(gc,chan_id);
if (!convo) {
purple_debug(PURPLE_DEBUG_ERROR, HON_DEBUG_PREFIX, "Got a silenced message for %d, which doesn't exist\n", chan_id);
return;
}
purple_conv_chat_write(PURPLE_CONV_CHAT(convo), "", _("You are silenced in this channel and cannot talk."), PURPLE_MESSAGE_SYSTEM, time(NULL));
}
static void
chat_sent_im(PurpleAccount *account, const char *message, int id)
{
PurpleConversation *conv = NULL;
if (purple_prefs_get_bool("/plugins/gtk/X11/notify/notify_send")) {
conv = purple_find_chat(purple_account_get_connection(account), id);
unnotify(conv, TRUE);
}
}
PurpleConversation *tgp_chat_show (struct tgl_state *TLS, struct tgl_chat *C) {
connection_data *conn = TLS->ev_base;
PurpleConversation *convo = purple_find_chat (conn->gc, tgl_get_peer_id (C->id));
PurpleConvChat *chat = purple_conversation_get_chat_data (convo);
if (! convo || (chat && purple_conv_chat_has_left (chat))) {
convo = serv_got_joined_chat (conn->gc, tgl_get_peer_id (C->id), C->print_title);
tgp_chat_users_update (conn->TLS, C);
}
return convo;
}
static void
chat_msg_sent_cb(PurpleAccount *account, const char *message,
int id, PurpleSoundEventID event)
{
PurpleConnection *conn = purple_account_get_connection(account);
PurpleConversation *conv = NULL;
if (conn!=NULL)
conv = purple_find_chat(conn, id);
play_conv_event(conv, event);
}
void
fb_chat_fake_leave(PurpleConnection *pc, int id)
{
PurpleConversation *conv;
const char *group;
conv = purple_find_chat(pc, id);
if (conv != NULL)
{
group = purple_conversation_get_name(conv);
fb_conversation_closed(pc, group);
}
}
/* a timer based callback function that sends the next message in the queue */
static gboolean
send_message_timer_cb( message_to_conv *msg_to_conv ) {
PurpleAccount *account;
PurpleConversation *conv;
gchar *msg;
g_return_val_if_fail(msg_to_conv != NULL, FALSE);
g_return_val_if_fail(msg_to_conv->messages != NULL, FALSE);
g_return_val_if_fail(msg_to_conv->sender_username != NULL, FALSE);
g_return_val_if_fail(msg_to_conv->sender_protocol_id != NULL, FALSE);
msg = g_queue_pop_head(msg_to_conv->messages);
if( msg == NULL )
{
/* clean up and terminate timer callback */
g_queue_free(msg_to_conv->messages);
g_free(msg_to_conv->sender_username);
g_free(msg_to_conv->sender_protocol_id);
if( msg_to_conv->type == PURPLE_CONV_TYPE_IM &&
msg_to_conv->receiver != NULL )
g_free(msg_to_conv->receiver);
g_free(msg_to_conv);
return FALSE;
}
else
{
/* find account info (it may have changed) and try and create a new
conversation window (it may have been closed) or find the existing
chat, and finally send the message */
account = purple_accounts_find(msg_to_conv->sender_username,
msg_to_conv->sender_protocol_id);
g_return_val_if_fail(account != NULL, FALSE);
if( msg_to_conv->type == PURPLE_CONV_TYPE_IM && msg_to_conv->receiver != NULL )
conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, msg_to_conv->receiver);
else if( msg_to_conv->type == PURPLE_CONV_TYPE_CHAT )
conv = purple_find_chat(account->gc, msg_to_conv->id);
else
conv = NULL;
g_return_val_if_fail(conv != NULL, FALSE);
splitter_common_send(conv, msg, PURPLE_MESSAGE_SEND);
g_free(msg);
return TRUE;
}
}
static void yahoo_chat_leave(PurpleConnection *gc, const char *room, const char *dn, gboolean logout)
{
YahooData *yd = gc->proto_data;
struct yahoo_packet *pkt;
char *eroom;
gboolean utf8 = 1;
if (yd->wm) {
g_return_if_fail(yd->ycht != NULL);
ycht_chat_leave(yd->ycht, room, logout);
return;
}
eroom = yahoo_string_encode(gc, room, &utf8);
pkt = yahoo_packet_new(YAHOO_SERVICE_CHATEXIT, YAHOO_STATUS_AVAILABLE, yd->session_id);
yahoo_packet_hash(pkt, "sss", 104, eroom, 109, dn, 108, "1");
yahoo_packet_hash_str(pkt, 112, "0"); /* what does this one mean? */
yahoo_packet_send_and_free(pkt, yd);
yd->in_chat = 0;
if (yd->chat_name) {
g_free(yd->chat_name);
yd->chat_name = NULL;
}
if (purple_find_chat(gc, YAHOO_CHAT_ID) != NULL)
serv_got_chat_left(gc, YAHOO_CHAT_ID);
if (!logout)
return;
pkt = yahoo_packet_new(YAHOO_SERVICE_CHATLOGOUT,
YAHOO_STATUS_AVAILABLE, yd->session_id);
yahoo_packet_hash_str(pkt, 1, dn);
yahoo_packet_send_and_free(pkt, yd);
yd->chat_online = FALSE;
g_free(yd->pending_chat_room);
yd->pending_chat_room = NULL;
g_free(yd->pending_chat_id);
yd->pending_chat_id = NULL;
g_free(yd->pending_chat_topic);
yd->pending_chat_topic = NULL;
g_free(yd->pending_chat_goto);
yd->pending_chat_goto = NULL;
g_free(eroom);
}
static void irc_chat_invite(PurpleConnection *gc, int id, const char *message, const char *name)
{
struct irc_conn *irc = gc->proto_data;
PurpleConversation *convo = purple_find_chat(gc, id);
const char *args[2];
if (!convo) {
purple_debug(PURPLE_DEBUG_ERROR, "irc", "Got chat invite request for bogus chat\n");
return;
}
args[0] = name;
args[1] = purple_conversation_get_name(convo);
irc_cmd_invite(irc, "invite", purple_conversation_get_name(convo), args);
}
static void irc_chat_leave (PurpleConnection *gc, int id)
{
struct irc_conn *irc = gc->proto_data;
PurpleConversation *convo = purple_find_chat(gc, id);
const char *args[2];
if (!convo)
return;
args[0] = purple_conversation_get_name(convo);
args[1] = NULL;
irc_cmd_part(irc, "part", purple_conversation_get_name(convo), args);
serv_got_chat_left(gc, id);
}
