PurpleCmdRet flist_global_kick_ban_unban_cmd(PurpleConversation *convo, const gchar *cmd, gchar **args, gchar **error, void *data) {
PurpleConnection *pc = purple_conversation_get_gc(convo);
FListAccount *fla = pc->proto_data;
const gchar *character, *code;
JsonObject *json;
FListFlags flags;
flags = flist_get_flags(fla, NULL, fla->proper_character);
if(!(flags & (FLIST_FLAG_ADMIN | FLIST_FLAG_GLOBAL_OP))) {
*error = g_strdup(_("You must be a global operator to globally kick, ban, or unban."));
return PURPLE_CMD_STATUS_FAILED;
}
if(!purple_utf8_strcasecmp(cmd, "gkick")) code = FLIST_GLOBAL_KICK;
if(!purple_utf8_strcasecmp(cmd, "ipban")) code = FLIST_GLOBAL_IP_BAN;
if(!purple_utf8_strcasecmp(cmd, "accountban")) code = FLIST_GLOBAL_ACCOUNT_BAN;
if(!purple_utf8_strcasecmp(cmd, "gunban")) code = FLIST_GLOBAL_UNBAN;
if(!code) return PURPLE_CMD_STATUS_NOT_FOUND;
character = args[0];
json = json_object_new();
json_object_set_string_member(json, "character", character);
flist_request(pc, code, json);
json_object_unref(json);
return PURPLE_CMD_STATUS_OK;
}
gboolean
purple_privacy_check(PurpleAccount *account, const char *who)
{
GSList *list;
switch (account->perm_deny) {
case PURPLE_PRIVACY_ALLOW_ALL:
return TRUE;
case PURPLE_PRIVACY_DENY_ALL:
return FALSE;
case PURPLE_PRIVACY_ALLOW_USERS:
who = purple_normalize(account, who);
for (list=account->permit; list!=NULL; list=list->next) {
if (!purple_utf8_strcasecmp(who, (char *)list->data))
return TRUE;
}
return FALSE;
case PURPLE_PRIVACY_DENY_USERS:
who = purple_normalize(account, who);
for (list=account->deny; list!=NULL; list=list->next) {
if (!purple_utf8_strcasecmp(who, (char *)list->data ))
return FALSE;
}
return TRUE;
case PURPLE_PRIVACY_ALLOW_BUDDYLIST:
return (purple_find_buddy(account, who) != NULL);
default:
g_return_val_if_reached(TRUE);
}
}
PurpleCmdRet flist_create_kill_channel_cmd(PurpleConversation *convo, const gchar *cmd, gchar **args, gchar **error, void *data) {
PurpleConnection *pc = purple_conversation_get_gc(convo);
FListAccount *fla = pc->proto_data;
const gchar *channel, *code;
JsonObject *json;
FListFlags flags;
flags = flist_get_flags(fla, NULL, fla->proper_character);
if(!(flags & (FLIST_FLAG_ADMIN | FLIST_FLAG_GLOBAL_OP))) {
*error = g_strdup(_("You must be a global operator to create or delete public channels."));
return PURPLE_CMD_STATUS_FAILED;
}
if(!purple_utf8_strcasecmp(cmd, "createchannel")) code = FLIST_PUBLIC_CHANNEL_CREATE;
if(!purple_utf8_strcasecmp(cmd, "killchannel")) code = FLIST_PUBLIC_CHANNEL_DELETE;
if(!code) return PURPLE_CMD_STATUS_NOT_FOUND;
channel = args[0];
json = json_object_new();
json_object_set_string_member(json, "channel", channel);
flist_request(pc, code, json);
json_object_unref(json);
return PURPLE_CMD_STATUS_OK;
}
PurpleCmdRet flist_admin_op_deop_cmd(PurpleConversation *convo, const gchar *cmd, gchar **args, gchar **error, void *data) {
PurpleConnection *pc = purple_conversation_get_gc(convo);
FListAccount *fla = pc->proto_data;
const gchar *character, *code;
JsonObject *json;
FListFlags flags;
flags = flist_get_flags(fla, NULL, fla->proper_character);
if(!(flags & FLIST_FLAG_ADMIN)) {
*error = g_strdup(_("You must be an administrator to add or remove global operators."));
return PURPLE_CMD_STATUS_FAILED;
}
if(!purple_utf8_strcasecmp(cmd, "op")) code = FLIST_CHANNEL_BAN;
if(!purple_utf8_strcasecmp(cmd, "deop")) code = FLIST_CHANNEL_UNBAN;
if(!code) return PURPLE_CMD_STATUS_NOT_FOUND;
character = args[0];
json = json_object_new();
json_object_set_string_member(json, "character", character);
flist_request(pc, code, json);
json_object_unref(json);
return PURPLE_CMD_STATUS_OK;
}
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);
} else if (pair->key == 109) {
if (g_utf8_validate(pair->value, -1, NULL)) {
who = pair->value;
} else {
purple_debug_warning("yahoo", "yahoo_process_chat_exit "
"got non-UTF-8 string for key %d\n", pair->key);
}
}
}
if (who && room) {
PurpleChatConversation *c = purple_conversations_find_chat(gc, YAHOO_CHAT_ID);
if (c && !purple_utf8_strcasecmp(purple_conversation_get_name(
PURPLE_CONVERSATION(c)), room))
purple_chat_conversation_remove_user(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);
}
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;
}
static gint compare_protocol(PurpleBlistNode *node1, PurpleBlistNode *node2) {
PurpleAccount *acc1=NULL, *acc2=NULL;
if(!node1) {
return 0;
}
if(PURPLE_BLIST_NODE_IS_CHAT(node1)) {
acc1 = ((PurpleChat *)node1)->account;
} else if(PURPLE_BLIST_NODE_IS_BUDDY(node1)) {
acc1 = ((PurpleBuddy *)node1)->account;
} else if(PURPLE_BLIST_NODE_IS_CONTACT(node1)) {
acc1 = (purple_contact_get_priority_buddy((PurpleContact *)node1))->account;
}
if(node2) {
if(PURPLE_BLIST_NODE_IS_CHAT(node2)) {
acc2 = ((PurpleChat *)node2)->account;
} else if(PURPLE_BLIST_NODE_IS_BUDDY(node2)) {
acc2 = ((PurpleBuddy *)node2)->account;
} else if(PURPLE_BLIST_NODE_IS_CONTACT(node2)) {
acc2 = (purple_contact_get_priority_buddy((PurpleContact *)node2))->account;
}
}
return purple_utf8_strcasecmp(
purple_account_get_protocol_id(acc1),
acc2 ? purple_account_get_protocol_id(acc2) : NULL
);
}
PurplePounce *
purple_find_pounce(const PurpleAccount *pouncer, const char *pouncee,
PurplePounceEvent events)
{
PurplePounce *pounce = NULL;
GList *l;
char *norm_pouncee;
g_return_val_if_fail(pouncer != NULL, NULL);
g_return_val_if_fail(pouncee != NULL, NULL);
g_return_val_if_fail(events != PURPLE_POUNCE_NONE, NULL);
norm_pouncee = g_strdup(purple_normalize(pouncer, pouncee));
for (l = purple_pounces_get_all(); l != NULL; l = l->next)
{
pounce = (PurplePounce *)l->data;
if ((purple_pounce_get_events(pounce) & events) &&
(purple_pounce_get_pouncer(pounce) == pouncer) &&
!purple_utf8_strcasecmp(purple_normalize(pouncer, purple_pounce_get_pouncee(pounce)),
norm_pouncee))
{
break;
}
pounce = NULL;
}
g_free(norm_pouncee);
return pounce;
}
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 gint compare_last_name(PurpleBlistNode *node1, PurpleBlistNode *node2) {
const char *name1=NULL, *name2=NULL;
const char *tmp=NULL;
if(PURPLE_BLIST_NODE_IS_CONTACT(node1)) {
name1 = purple_contact_get_alias((PurpleContact *)node1);
}
if(!name1) {
name1 = PURPLE_BLIST_NODE_NAME(node1);
}
if(PURPLE_BLIST_NODE_IS_CONTACT(node2)) {
name2 = purple_contact_get_alias((PurpleContact *)node2);
}
if(!name2) {
name2 = PURPLE_BLIST_NODE_NAME(node2);
}
/* Searches for last space in name and, if found, sorts based on characters remaining */
tmp = strrchr(name1, ' ');
if(tmp != NULL) {
name1 = tmp;
}
tmp = strrchr(name2, ' ');
if(tmp != NULL) {
name2 = tmp;
}
return purple_utf8_strcasecmp(name1, name2);
}
const gchar *fb_get_list_id(FacebookAccount *fba, const gchar *list_name)
{
if (!purple_utf8_strcasecmp(list_name, DEFAULT_GROUP_NAME)) {
return "-1";
}
return g_hash_table_lookup(fba->friend_lists_reverse, purple_normalize_nocase(NULL, list_name));
}
static void reset_sort_method() {
if(purple_utf8_strcasecmp(
purple_prefs_get_string(PIDGIN_PREFS_ROOT "/blist/sort_type"),
"ext_blist_sort"
) == 0) {
if(purple_utf8_strcasecmp(
purple_prefs_get_string(PLUGIN_PREFS_PREFIX "/old_sort_method"),
""
) != 0) {
purple_prefs_set_string(
PIDGIN_PREFS_ROOT "/blist/sort_type",
purple_prefs_get_string(PLUGIN_PREFS_PREFIX "/old_sort_method")
);
} else {
purple_prefs_set_string(PIDGIN_PREFS_ROOT "/blist/sort_type", "none");
}
}
}
static const gfire_game *gfire_game_by_name(const gchar *p_name)
{
GList *cur = gfire_games;
for(; cur; cur = g_list_next(cur))
{
if(!purple_utf8_strcasecmp(((gfire_game*)cur->data)->name, p_name))
return (gfire_game*)cur->data;
}
return NULL;
}
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);
}
static PurpleConversation *
nap_find_chat(PurpleConnection *gc, const char *name) {
GSList *bcs = gc->buddy_chats;
while (bcs) {
PurpleConversation *b = bcs->data;
if (!purple_utf8_strcasecmp(b->name, name))
return b;
bcs = bcs->next;
}
return NULL;
}
static void ycht_process_chatpart(YchtConn *ycht, YchtPkt *pkt)
{
char *room, *who;
room = g_list_nth_data(pkt->data, 0);
who = g_list_nth_data(pkt->data, 1);
if (who && room) {
PurpleChatConversation *c = purple_conversations_find_chat(ycht->gc, YAHOO_CHAT_ID);
if (c && !purple_utf8_strcasecmp(purple_conversation_get_name(PURPLE_CONVERSATION(c)), room))
purple_chat_conversation_remove_user(c, who, NULL);
}
}
static PurpleConversation *yahoo_find_conference(PurpleConnection *gc, const char *name)
{
YahooData *yd;
GSList *l;
yd = gc->proto_data;
for (l = yd->confs; l; l = l->next) {
PurpleConversation *c = l->data;
if (!purple_utf8_strcasecmp(purple_conversation_get_name(c), name))
return c;
}
return NULL;
}
static PurpleChatConversation *yahoo_find_conference(PurpleConnection *gc, const char *name)
{
YahooData *yd;
GSList *l;
yd = purple_connection_get_protocol_data(gc);
for (l = yd->confs; l; l = l->next) {
PurpleChatConversation *c = l->data;
if (!purple_utf8_strcasecmp(purple_conversation_get_name(PURPLE_CONVERSATION(c)), name))
return c;
}
return NULL;
}
static PurpleCmdRet
plonk_cmd_cb(PurpleConversation *c, const gchar *cmd, gchar **args, gchar **error, void *data) {
/* this is the funky 'mass block/ignore' routine.
* given a/n list of ID/'s it'll add that|those to all block|ignore lists
* of each account of the same prpl type.
*/
/*
* gchar* g_strdelimit (gchar *string, const gchar *delimiters, gchar new_delimiter);
* gchar** g_strsplit (const gchar *string, const gchar *delimiter, gint max_tokens);
*/
PurpleConversationUiOps *ops;
GSList *l;
char *room = NULL;
GList *plonks = NULL;
GList *members = NULL;
gchar **tmp;
if(!args[0]) {
purple_debug_info("Plonkers", "Bad arg: %s\n", args[0]);
return PURPLE_CMD_RET_FAILED;
}
if(!g_utf8_validate(*args, -1, NULL)) {
purple_debug_info("Plonkers", "Invalid UTF8: %s\n", args[0]);
return PURPLE_CMD_RET_FAILED;
}
purple_debug_info("plonkers", "Plonk arg: %s\n", args[0]);
g_strdelimit (*args, "_-|> <.,:;", ' ');
purple_debug_info("plonkers", "Plonk delimited arg: %s\n", args[0]);
tmp = g_strsplit(args[0], " ", 0);
purple_debug_info("plonkers", "Plonk strsplit length: %i\n", g_strv_length(tmp));
/* next step, remove duplicates in the array */
ops = purple_conversation_get_ui_ops(c);
PurpleAccount *account = purple_conversation_get_account(c);
members = purple_conv_chat_get_users(PURPLE_CONV_CHAT(c));
for (l = account->deny; l != NULL; l = l->next) {
for (plonks = members; plonks; plonks = plonks->next) {
if (!purple_utf8_strcasecmp((char *)l->data, plonks->data)) {
purple_debug_info("plonkers", "Ignoring room member %s in room %s\n" ,(gchar *)plonks->data, room);
/* purple_conv_chat_ignore(PURPLE_CONV_CHAT(c),plonks->data);
* ops->chat_update_user((c), plonks->data); */
}
}
}
g_list_free(plonks);
g_list_free(members);
g_strfreev(tmp);
return PURPLE_CMD_RET_OK;
}
void
purple_pounce_execute(const PurpleAccount *pouncer, const char *pouncee,
PurplePounceEvent events)
{
PurplePounce *pounce;
PurplePounceHandler *handler;
PurplePresence *presence;
GList *l, *l_next;
char *norm_pouncee;
g_return_if_fail(pouncer != NULL);
g_return_if_fail(pouncee != NULL);
g_return_if_fail(events != PURPLE_POUNCE_NONE);
norm_pouncee = g_strdup(purple_normalize(pouncer, pouncee));
for (l = purple_pounces_get_all(); l != NULL; l = l_next)
{
pounce = (PurplePounce *)l->data;
l_next = l->next;
presence = purple_account_get_presence(pouncer);
if ((purple_pounce_get_events(pounce) & events) &&
(purple_pounce_get_pouncer(pounce) == pouncer) &&
!purple_utf8_strcasecmp(purple_normalize(pouncer, purple_pounce_get_pouncee(pounce)),
norm_pouncee) &&
(pounce->options == PURPLE_POUNCE_OPTION_NONE ||
(pounce->options & PURPLE_POUNCE_OPTION_AWAY &&
!purple_presence_is_available(presence))))
{
handler = g_hash_table_lookup(pounce_handlers, pounce->ui_type);
if (handler != NULL && handler->cb != NULL)
{
handler->cb(pounce, events, purple_pounce_get_data(pounce));
if (!purple_pounce_get_save(pounce))
purple_pounce_destroy(pounce);
}
}
}
g_free(norm_pouncee);
}
PurpleConversation *
jabber_find_unnormalized_conv(const char *name, PurpleAccount *account)
{
PurpleConversation *c = NULL;
GList *cnv;
g_return_val_if_fail(name != NULL, NULL);
for(cnv = purple_get_conversations(); cnv; cnv = cnv->next) {
c = (PurpleConversation*)cnv->data;
if(purple_conversation_get_type(c) == PURPLE_CONV_TYPE_IM &&
!purple_utf8_strcasecmp(name, purple_conversation_get_name(c)) &&
account == purple_conversation_get_account(c))
return c;
}
return NULL;
}
void fb_group_buddy_move(PurpleConnection *pc, const char *who,
const char *old_group, const char *new_group)
{
FacebookAccount *fba;
MoveRequest *request;
const gchar *new_list_id;
if (!purple_account_get_bool(pc->account, "facebook_use_groups", TRUE))
{
//Dont do anything if we're ignoring groups
return;
}
fba = pc->proto_data;
purple_debug_info("facebook", "handling move of %s from %s to %s\n",
who, old_group, new_group);
// Don't do anything if groups are not actually changing.
if (!purple_utf8_strcasecmp(old_group, new_group)) {
purple_debug_info("facebook", "groups are same, not moving\n");
return;
}
// Facebook doesn't support moving yourself because you can't be in a
// friend list. Let buddy list be updated as appropriate.
if (atoll(who) == fba->uid) {
purple_debug_info("facebook",
"moving self, do not update server\n");
return;
}
request = g_new0(MoveRequest, 1);
request->old_group = g_utf8_strdown(old_group, -1);
request->new_group = g_utf8_strdown(new_group, -1);
request->who = g_strdup(who);
new_list_id = fb_get_list_id(fba, request->new_group);
if (new_list_id) {
handle_move_request(fba, request);
} else {
create_friend_list(fba, new_group, request);
}
}
gboolean
purple_privacy_permit_remove(PurpleAccount *account, const char *who,
gboolean local_only)
{
GSList *l;
const char *name;
PurpleBuddy *buddy;
char *del;
g_return_val_if_fail(account != NULL, FALSE);
g_return_val_if_fail(who != NULL, FALSE);
name = purple_normalize(account, who);
for (l = account->permit; l != NULL; l = l->next) {
if (!purple_utf8_strcasecmp(name, (char *)l->data))
break;
}
if (l == NULL)
return FALSE;
/* We should not free l->data just yet. There can be occasions where
* l->data == who. In such cases, freeing l->data here can cause crashes
* later when who is used. */
del = l->data;
account->permit = g_slist_delete_link(account->permit, l);
if (!local_only && purple_account_is_connected(account))
serv_rem_permit(purple_account_get_connection(account), who);
if (privacy_ops != NULL && privacy_ops->permit_removed != NULL)
privacy_ops->permit_removed(account, who);
purple_blist_schedule_save();
buddy = purple_find_buddy(account, name);
if (buddy != NULL) {
purple_signal_emit(purple_blist_get_handle(),
"buddy-privacy-changed", buddy);
}
g_free(del);
return TRUE;
}
static void irc_msg_handle_privmsg(struct irc_conn *irc, const char *name, const char *from, const char *to, const char *rawmsg, gboolean notice)
{
PurpleConnection *gc = purple_account_get_connection(irc->account);
PurpleConversation *convo;
char *tmp;
char *msg;
char *nick;
if (!gc)
return;
nick = irc_mask_nick(from);
tmp = irc_parse_ctcp(irc, nick, to, rawmsg, notice);
if (!tmp) {
g_free(nick);
return;
}
msg = irc_escape_privmsg(tmp, -1);
g_free(tmp);
tmp = irc_mirc2html(msg);
g_free(msg);
msg = tmp;
if (notice) {
tmp = g_strdup_printf("(notice) %s", msg);
g_free(msg);
msg = tmp;
}
if (!purple_utf8_strcasecmp(to, purple_connection_get_display_name(gc))) {
serv_got_im(gc, nick, msg, 0, time(NULL));
} else {
convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, to, irc->account);
if (convo)
serv_got_chat_in(gc, purple_conv_chat_get_id(PURPLE_CONV_CHAT(convo)), nick, 0, msg, time(NULL));
else
purple_debug_error("irc", "Got a %s on %s, which does not exist\n",
notice ? "NOTICE" : "PRIVMSG", to);
}
g_free(msg);
g_free(nick);
}
gboolean
purple_privacy_deny_remove(PurpleAccount *account, const char *who,
gboolean local_only)
{
GSList *l;
const char *normalized;
char *name;
PurpleBuddy *buddy;
g_return_val_if_fail(account != NULL, FALSE);
g_return_val_if_fail(who != NULL, FALSE);
normalized = purple_normalize(account, who);
for (l = account->deny; l != NULL; l = l->next) {
if (!purple_utf8_strcasecmp(normalized, (char *)l->data))
break;
}
buddy = purple_find_buddy(account, normalized);
if (l == NULL)
return FALSE;
name = l->data;
account->deny = g_slist_delete_link(account->deny, l);
if (!local_only && purple_account_is_connected(account))
serv_rem_deny(purple_account_get_connection(account), name);
if (privacy_ops != NULL && privacy_ops->deny_removed != NULL)
privacy_ops->deny_removed(account, who);
if (buddy != NULL) {
purple_signal_emit(purple_blist_get_handle(),
"buddy-privacy-changed", buddy);
}
g_free(name);
purple_blist_schedule_save();
return TRUE;
}
static gint compare_name(PurpleBlistNode *node1, PurpleBlistNode *node2) {
const char *name1=NULL, *name2=NULL;
if(PURPLE_BLIST_NODE_IS_CONTACT(node1)) {
name1 = purple_contact_get_alias((PurpleContact *)node1);
}
if(!name1) {
name1 = PURPLE_BLIST_NODE_NAME(node1);
}
if(PURPLE_BLIST_NODE_IS_CONTACT(node2)) {
name2 = purple_contact_get_alias((PurpleContact *)node2);
}
if(!name2) {
name2 = PURPLE_BLIST_NODE_NAME(node2);
}
return purple_utf8_strcasecmp(name1, name2);
}
gboolean
purple_privacy_permit_add(PurpleAccount *account, const char *who,
gboolean local_only)
{
GSList *l;
char *name;
PurpleBuddy *buddy;
g_return_val_if_fail(account != NULL, FALSE);
g_return_val_if_fail(who != NULL, FALSE);
name = g_strdup(purple_normalize(account, who));
for (l = account->permit; l != NULL; l = l->next) {
if (!purple_utf8_strcasecmp(name, (char *)l->data))
break;
}
if (l != NULL)
{
g_free(name);
return FALSE;
}
account->permit = g_slist_append(account->permit, name);
if (!local_only && purple_account_is_connected(account))
serv_add_permit(purple_account_get_connection(account), who);
if (privacy_ops != NULL && privacy_ops->permit_added != NULL)
privacy_ops->permit_added(account, who);
purple_blist_schedule_save();
/* This lets the UI know a buddy has had its privacy setting changed */
buddy = purple_find_buddy(account, name);
if (buddy != NULL) {
purple_signal_emit(purple_blist_get_handle(),
"buddy-privacy-changed", buddy);
}
return TRUE;
}
void BuddyListGroup::GroupContextMenu::renameResponseHandler(
CppConsUI::InputDialog& activator,
CppConsUI::AbstractDialog::ResponseType response)
{
if (response != CppConsUI::AbstractDialog::RESPONSE_OK)
return;
const char *name = activator.getText();
PurpleGroup *group = parent_group->getPurpleGroup();
PurpleGroup *other = purple_find_group(name);
if (other && !purple_utf8_strcasecmp(name, purple_group_get_name(group))) {
LOG->message(_("Specified group is already in the list."));
/* TODO Add group merging. Note that purple_blist_rename_group() can do
* the merging. */
}
else
purple_blist_rename_group(group, name);
// close context menu
close();
}
void irc_msg_away(struct irc_conn *irc, const char *name, const char *from, char **args)
{
PurpleConnection *gc;
char *msg;
if (!args || !args[1])
return;
if (irc->whois.nick && !purple_utf8_strcasecmp(irc->whois.nick, args[1])) {
/* We're doing a whois, show this in the whois dialog */
irc_msg_whois(irc, name, from, args);
return;
}
gc = purple_account_get_connection(irc->account);
if (gc) {
msg = g_markup_escape_text(args[2], -1);
serv_got_im(gc, args[1], msg, PURPLE_MESSAGE_AUTO_RESP, time(NULL));
g_free(msg);
}
}
