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