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); }