static void pidgin_media_dispose(GObject *media) { PidginMedia *gtkmedia = PIDGIN_MEDIA(media); purple_debug_info("gtkmedia", "pidgin_media_dispose\n"); if (gtkmedia->priv->media) { purple_request_close_with_handle(gtkmedia); purple_media_remove_output_windows(gtkmedia->priv->media); pidgin_media_disconnect_levels(gtkmedia->priv->media, gtkmedia); g_object_unref(gtkmedia->priv->media); gtkmedia->priv->media = NULL; } if (gtkmedia->priv->ui) { g_object_unref(gtkmedia->priv->ui); gtkmedia->priv->ui = NULL; } if (gtkmedia->priv->timeout_id != 0) g_source_remove(gtkmedia->priv->timeout_id); if (gtkmedia->priv->recv_progressbars) { g_hash_table_destroy(gtkmedia->priv->recv_progressbars); g_hash_table_destroy(gtkmedia->priv->remote_videos); gtkmedia->priv->recv_progressbars = NULL; gtkmedia->priv->remote_videos = NULL; } G_OBJECT_CLASS(parent_class)->dispose(media); }
static void purple_xfer_destroy(PurpleXfer *xfer) { PurpleXferUiOps *ui_ops; g_return_if_fail(xfer != NULL); if (purple_debug_is_verbose()) purple_debug_info("xfer", "destroyed %p [%d]\n", xfer, xfer->ref); /* Close the file browser, if it's open */ purple_request_close_with_handle(xfer); if (purple_xfer_get_status(xfer) == PURPLE_XFER_STATUS_STARTED) purple_xfer_cancel_local(xfer); ui_ops = purple_xfer_get_ui_ops(xfer); if (ui_ops != NULL && ui_ops->destroy != NULL) ui_ops->destroy(xfer); g_free(xfer->who); g_free(xfer->filename); g_free(xfer->remote_ip); g_free(xfer->local_filename); g_hash_table_remove(xfers_data, xfer); PURPLE_DBUS_UNREGISTER_POINTER(xfer); xfers = g_list_remove(xfers, xfer); g_free(xfer); }
void purple_ssl_close(PurpleSslConnection *gsc) { PurpleSslOps *ops; g_return_if_fail(gsc != NULL); purple_request_close_with_handle(gsc); purple_notify_close_with_handle(gsc); ops = purple_ssl_get_ops(); (ops->close)(gsc); if (gsc->connect_data != NULL) purple_proxy_connect_cancel(gsc->connect_data); if (gsc->inpa > 0) purple_input_remove(gsc->inpa); if (gsc->fd >= 0) close(gsc->fd); g_free(gsc->host); g_free(gsc); }
static void purple_protocol_finalize(GObject *object) { PurpleProtocol *protocol = PURPLE_PROTOCOL(object); GList *accounts, *l; accounts = purple_accounts_get_all_active(); for (l = accounts; l != NULL; l = l->next) { PurpleAccount *account = PURPLE_ACCOUNT(l->data); if (purple_account_is_disconnected(account)) continue; if (purple_strequal(protocol->id, purple_account_get_protocol_id(account))) purple_account_disconnect(account); } g_list_free(accounts); purple_request_close_with_handle(protocol); purple_notify_close_with_handle(protocol); purple_signals_disconnect_by_handle(protocol); purple_signals_unregister_by_instance(protocol); purple_prefs_disconnect_by_handle(protocol); user_splits_free(protocol); account_options_free(protocol); icon_spec_free(protocol); PURPLE_DBUS_UNREGISTER_POINTER(protocol); parent_class->finalize(object); }
static void info_modify_dialogue(PurpleConnection *gc, gchar **segments, int iclass) { qq_data *qd; PurpleRequestFieldGroup *group; PurpleRequestFields *fields; modify_info_request *info_request; gchar *utf8_title, *utf8_prim; int index; qd = (qq_data *) gc->proto_data; /* Keep one dialog once a time */ purple_request_close_with_handle(gc); fields = purple_request_fields_new(); group = purple_request_field_group_new(NULL); purple_request_fields_add_group(fields, group); for (index = 1; segments[index] != NULL && index < QQ_INFO_LAST; index++) { if (field_infos[index].iclass != iclass) { continue; } field_request_new(group, index, segments); } switch (iclass) { case QQ_FIELD_CONTACT: utf8_title = g_strdup(_("Modify Contact")); utf8_prim = g_strdup_printf("%s for %s", _("Modify Contact"), segments[0]); case QQ_FIELD_ADDR: utf8_title = g_strdup(_("Modify Address")); utf8_prim = g_strdup_printf("%s for %s", _("Modify Address"), segments[0]); case QQ_FIELD_EXT: utf8_title = g_strdup(_("Modify Extended Information")); utf8_prim = g_strdup_printf("%s for %s", _("Modify Extended Information"), segments[0]); break; case QQ_FIELD_BASE: default: utf8_title = g_strdup(_("Modify Information")); utf8_prim = g_strdup_printf("%s for %s", _("Modify Information"), segments[0]); } info_request = g_new0(modify_info_request, 1); info_request->gc = gc; info_request->iclass = iclass; info_request->segments = segments; purple_request_fields(gc, utf8_title, utf8_prim, NULL, fields, _("Update"), G_CALLBACK(info_modify_ok_cb), _("Cancel"), G_CALLBACK(info_modify_cancel_cb), purple_connection_get_account(gc), NULL, NULL, info_request); g_free(utf8_title); g_free(utf8_prim); }
static void pounces_manager_delete_confirm_cb(PurplePounce *pounce) { gnt_tree_remove(GNT_TREE(pounces_manager->tree), pounce); purple_request_close_with_handle(pounce); purple_pounce_destroy(pounce); }
/* memo modify dialogue */ static void memo_modify_dialogue(PurpleConnection *gc, guint32 bd_uid, gchar **segments, guint32 action) { modify_memo_request *memo_request; PurpleRequestField *field; PurpleRequestFields *fields; PurpleRequestFieldGroup *group; int index; gchar *utf8_title; gchar *utf8_primary; g_return_if_fail(NULL != gc && NULL != segments); switch (action) { case QQ_BUDDY_MEMO_GET: memo_free(segments); break; case QQ_BUDDY_MEMO_MODIFY: /* keep one dialog once a time */ purple_request_close_with_handle(gc); /* show dialog */ fields = purple_request_fields_new(); group = purple_request_field_group_new(NULL); purple_request_fields_add_group(fields, group); for(index = 0; index < QQ_MEMO_SIZE; index++) { /* purple_debug_info("QQ", "id:%s txt:%s segment:%s\n", memo_id[index], memo_txt[index], segments[index]); */ field = purple_request_field_string_new(memo_id[index], memo_txt[index], segments[index], FALSE); purple_request_field_group_add_field(group, field); } /* for upload cb */ memo_request = g_new0(modify_memo_request, 1); memo_request->gc = gc; memo_request->bd_uid = bd_uid; memo_request->segments = segments; /* callback */ utf8_title = g_strdup(_("Buddy Memo")); utf8_primary = g_strdup(_("Change his/her memo as you like")); purple_request_fields(gc, utf8_title, utf8_primary, NULL, fields, _("_Modify"), G_CALLBACK(memo_modify_ok_cb), _("_Cancel"), G_CALLBACK(memo_modify_cancle_cb), purple_connection_get_account(gc), NULL, NULL, memo_request); g_free(utf8_title); g_free(utf8_primary); break; default: purple_debug_info("QQ", "Error...unknown memo action, please tell us\n"); break; } }
static void silcpurple_wb_request(SilcClient client, const unsigned char *message, SilcUInt32 message_len, SilcClientEntry sender, SilcChannelEntry channel) { char tmp[256]; SilcPurpleWbRequest req; PurpleConnection *gc; SilcPurple sg; gc = client->application; sg = gc->proto_data; /* Open whiteboard automatically if requested */ if (purple_account_get_bool(sg->account, "open-wb", FALSE)) { PurpleWhiteboard *wb; if (!channel) wb = silcpurple_wb_init(sg, sender); else wb = silcpurple_wb_init_ch(sg, channel); silcpurple_wb_parse(wb->proto_data, wb, (unsigned char *)message, message_len); return; } /* Close any previous unaccepted requests */ purple_request_close_with_handle(sender); if (!channel) { g_snprintf(tmp, sizeof(tmp), _("%s sent message to whiteboard. Would you like " "to open the whiteboard?"), sender->nickname); } else { g_snprintf(tmp, sizeof(tmp), _("%s sent message to whiteboard on %s channel. " "Would you like to open the whiteboard?"), sender->nickname, channel->channel_name); } req = silc_calloc(1, sizeof(*req)); if (!req) return; req->message = silc_memdup(message, message_len); req->message_len = message_len; req->sender = sender; req->channel = channel; req->sg = sg; purple_request_action(gc, _("Whiteboard"), tmp, NULL, 1, sg->account, sender->nickname, NULL, req, 2, _("Yes"), G_CALLBACK(silcpurple_wb_request_cb), _("No"), G_CALLBACK(silcpurple_wb_request_cb)); }
static void destroy_cb(GtkWidget *w, gint resp, struct log_viewer_hash_t *ht) { PidginLogViewer *lv = syslog_viewer; #ifdef _WIN32 if (resp == GTK_RESPONSE_HELP) { GtkTreeSelection *sel; GtkTreeIter iter; GtkTreeModel *model; PurpleLog *log = NULL; char *logdir; if (ht != NULL) lv = g_hash_table_lookup(log_viewers, ht); model = GTK_TREE_MODEL(lv->treestore); sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(lv->treeview)); if (gtk_tree_selection_get_selected(sel, &model, &iter)) { GValue val; val.g_type = 0; gtk_tree_model_get_value (model, &iter, 1, &val); log = g_value_get_pointer(&val); g_value_unset(&val); } if (log == NULL) logdir = g_build_filename(purple_user_dir(), "logs", NULL); else logdir = purple_log_get_log_dir(log->type, log->name, log->account); winpidgin_shell_execute(logdir, "explore", NULL); g_free(logdir); return; } #endif if (ht != NULL) { lv = g_hash_table_lookup(log_viewers, ht); g_hash_table_remove(log_viewers, ht); g_free(ht->screenname); g_free(ht); } else syslog_viewer = NULL; purple_request_close_with_handle(lv); g_list_foreach(lv->logs, (GFunc)purple_log_free, NULL); g_list_free(lv->logs); g_free(lv->search); g_free(lv); gtk_widget_destroy(w); }
static void install_plugin_cb(GntWidget *w, gpointer null) { static int handle; purple_request_close_with_handle(&handle); purple_request_file(&handle, _("Select plugin to install"), NULL, FALSE, G_CALLBACK(install_selected_file_cb), NULL, NULL, &handle); g_signal_connect_swapped(G_OBJECT(w), "destroy", G_CALLBACK(purple_request_close_with_handle), &handle); }
static void purple_request_close_info(PurpleRequestInfo *info) { PurpleRequestUiOps *ops; ops = purple_request_get_ui_ops(); purple_notify_close_with_handle(info->ui_handle); purple_request_close_with_handle(info->ui_handle); if (ops != NULL && ops->close_request != NULL) ops->close_request(info->type, info->ui_handle); g_free(info); }
static gboolean peer_connection_destroy_cb(gpointer data) { PeerConnection *conn; conn = data; purple_request_close_with_handle(conn); peer_connection_close(conn); if (conn->checksum_data != NULL) peer_oft_checksum_destroy(conn->checksum_data); if (conn->xfer != NULL) { PurpleXferStatusType status; conn->xfer->data = NULL; status = purple_xfer_get_status(conn->xfer); if ((status != PURPLE_XFER_STATUS_DONE) && (status != PURPLE_XFER_STATUS_CANCEL_LOCAL) && (status != PURPLE_XFER_STATUS_CANCEL_REMOTE)) { if ((conn->disconnect_reason == OSCAR_DISCONNECT_REMOTE_CLOSED) || (conn->disconnect_reason == OSCAR_DISCONNECT_REMOTE_REFUSED)) purple_xfer_cancel_remote(conn->xfer); else purple_xfer_cancel_local(conn->xfer); } purple_xfer_unref(conn->xfer); conn->xfer = NULL; } g_free(conn->bn); g_free(conn->error_message); g_free(conn->proxyip); g_free(conn->clientip); g_free(conn->verifiedip); g_free(conn->xferdata.name); purple_circ_buffer_destroy(conn->buffer_outgoing); conn->od->peer_connections = g_slist_remove(conn->od->peer_connections, conn); g_free(conn); return FALSE; }
static void pidgin_media_stream_info_cb(PurpleMedia *media, PurpleMediaInfoType type, gchar *sid, gchar *name, gboolean local, PidginMedia *gtkmedia) { if (type == PURPLE_MEDIA_INFO_REJECT) { pidgin_media_emit_message(gtkmedia, _("You have rejected the call.")); } else if (type == PURPLE_MEDIA_INFO_ACCEPT) { if (local == TRUE) purple_request_close_with_handle(gtkmedia); pidgin_media_set_state(gtkmedia, PIDGIN_MEDIA_ACCEPTED); pidgin_media_emit_message(gtkmedia, _("Call in progress.")); gtk_statusbar_push(GTK_STATUSBAR(gtkmedia->priv->statusbar), 0, _("Call in progress.")); gtk_widget_show(GTK_WIDGET(gtkmedia)); } }
static void pidgin_media_dispose(GObject *media) { PidginMedia *gtkmedia = PIDGIN_MEDIA(media); purple_debug_info("gtkmedia", "pidgin_media_dispose\n"); if (gtkmedia->priv->media) { purple_request_close_with_handle(gtkmedia); purple_media_remove_output_windows(gtkmedia->priv->media); pidgin_media_disconnect_levels(gtkmedia->priv->media, gtkmedia); g_object_unref(gtkmedia->priv->media); gtkmedia->priv->media = NULL; } if (gtkmedia->priv->ui) { g_object_unref(gtkmedia->priv->ui); gtkmedia->priv->ui = NULL; } G_OBJECT_CLASS(parent_class)->dispose(media); }
void AccountCollector::collectNow(PurpleAccount *account, bool remove) { if (account->ui_data == NULL) { Log("AccountCollector","freeing account " << purple_account_get_username(account)); if (remove) g_hash_table_remove(m_accounts, purple_account_get_username(account)); purple_account_set_enabled(account, purple_core_get_ui(), FALSE); purple_notify_close_with_handle(account); purple_request_close_with_handle(account); purple_accounts_remove(account); GSList *buddies = purple_find_buddies(account, NULL); while(buddies) { PurpleBuddy *b = (PurpleBuddy *) buddies->data; purple_blist_remove_buddy(b); buddies = g_slist_delete_link(buddies, buddies); } /* Remove any open conversation for this account */ for (GList *it = purple_get_conversations(); it; ) { PurpleConversation *conv = (PurpleConversation *) it->data; it = it->next; if (purple_conversation_get_account(conv) == account) purple_conversation_destroy(conv); } /* Remove this account's pounces */ // purple_pounce_destroy_all_by_account(account); /* This will cause the deletion of an old buddy icon. */ purple_buddy_icons_set_account_icon(account, NULL, 0); purple_account_destroy(account); // VALGRIND_DO_LEAK_CHECK; } }
void flist_close(PurpleConnection *pc) { FListAccount *fla = pc->proto_data; if(!fla) return; if(fla->gsc) purple_ssl_close(fla->gsc); if(fla->username) g_free(fla->username); if(fla->character) g_free(fla->character); if(fla->password) g_free(fla->password); if(fla->proper_character) g_free(fla->proper_character); if(fla->ticket_request) flist_web_request_cancel(fla->ticket_request); if(fla->ticket_timer) purple_timeout_remove(fla->ticket_timer); if(fla->fls_cookie) g_free(fla->fls_cookie); g_free(fla->rx_buf); if(fla->ping_timeout_handle) purple_timeout_remove(fla->ping_timeout_handle); g_hash_table_destroy(fla->all_characters); if(fla->global_ops) g_hash_table_destroy(fla->global_ops); /* login options */ if(fla->server_address) g_free(fla->server_address); if(fla->input_request) purple_request_close_with_handle((void*) pc); flist_friends_unload(fla); flist_fetch_icon_cancel_all(fla); flist_global_kinks_unload(pc); flist_profile_unload(pc); flist_channel_subsystem_unload(fla); g_free(fla); pc->proto_data = NULL; }
void purple_xfer_cancel_remote(PurpleXfer *xfer) { PurpleXferUiOps *ui_ops; gchar *msg; PurpleAccount *account; PurpleBuddy *buddy; g_return_if_fail(xfer != NULL); purple_request_close_with_handle(xfer); purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_REMOTE); xfer->end_time = time(NULL); account = purple_xfer_get_account(xfer); buddy = purple_find_buddy(account, xfer->who); if (purple_xfer_get_filename(xfer) != NULL) { msg = g_strdup_printf(_("%s cancelled the transfer of %s"), buddy ? purple_buddy_get_alias(buddy) : xfer->who, purple_xfer_get_filename(xfer)); } else { msg = g_strdup_printf(_("%s cancelled the file transfer"), buddy ? purple_buddy_get_alias(buddy) : xfer->who); } purple_xfer_conversation_write(xfer, msg, TRUE); purple_xfer_error(purple_xfer_get_type(xfer), account, xfer->who, msg); g_free(msg); if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND) { if (xfer->ops.cancel_send != NULL) xfer->ops.cancel_send(xfer); } else { if (xfer->ops.cancel_recv != NULL) xfer->ops.cancel_recv(xfer); } if (xfer->watcher != 0) { purple_input_remove(xfer->watcher); xfer->watcher = 0; } if (xfer->fd != -1) close(xfer->fd); if (xfer->dest_fp != NULL) { fclose(xfer->dest_fp); xfer->dest_fp = NULL; } ui_ops = purple_xfer_get_ui_ops(xfer); if (ui_ops != NULL && ui_ops->cancel_remote != NULL) ui_ops->cancel_remote(xfer); xfer->bytes_remaining = 0; purple_xfer_unref(xfer); }
gboolean purple_plugin_unload(PurplePlugin *plugin) { #ifdef PURPLE_PLUGINS GList *l; GList *ll; g_return_val_if_fail(plugin != NULL, FALSE); g_return_val_if_fail(purple_plugin_is_loaded(plugin), FALSE); purple_debug_info("plugins", "Unloading plugin %s\n", plugin->info->name); /* Unload all plugins that depend on this plugin. */ for (l = plugin->dependent_plugins; l != NULL; l = ll) { const char * dep_name = (const char *)l->data; PurplePlugin *dep_plugin; /* Store a pointer to the next element in the list. * This is because we'll be modifying this list in the loop. */ ll = l->next; dep_plugin = purple_plugins_find_with_id(dep_name); if (dep_plugin != NULL && purple_plugin_is_loaded(dep_plugin)) { if (!purple_plugin_unload(dep_plugin)) { g_free(plugin->error); plugin->error = g_strdup_printf(_("%s requires %s, but it failed to unload."), _(plugin->info->name), _(dep_plugin->info->name)); return FALSE; } else { #if 0 /* This isn't necessary. This has already been done when unloading dep_plugin. */ plugin->dependent_plugins = g_list_delete_link(plugin->dependent_plugins, l); #endif } } } /* Remove this plugin from each dependency's dependent_plugins list. */ for (l = plugin->info->dependencies; l != NULL; l = l->next) { const char *dep_name = (const char *)l->data; PurplePlugin *dependency; dependency = purple_plugins_find_with_id(dep_name); if (dependency != NULL) dependency->dependent_plugins = g_list_remove(dependency->dependent_plugins, plugin->info->id); else purple_debug_error("plugins", "Unable to remove from dependency list for %s\n", dep_name); } if (plugin->native_plugin) { if (plugin->info->unload && !plugin->info->unload(plugin)) return FALSE; if (plugin->info->type == PURPLE_PLUGIN_PROTOCOL) { PurplePluginProtocolInfo *prpl_info; GList *l; prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(plugin); for (l = prpl_info->user_splits; l != NULL; l = l->next) purple_account_user_split_destroy(l->data); for (l = prpl_info->protocol_options; l != NULL; l = l->next) purple_account_option_destroy(l->data); if (prpl_info->user_splits != NULL) { g_list_free(prpl_info->user_splits); prpl_info->user_splits = NULL; } if (prpl_info->protocol_options != NULL) { g_list_free(prpl_info->protocol_options); prpl_info->protocol_options = NULL; } } } else { PurplePlugin *loader; PurplePluginLoaderInfo *loader_info; loader = find_loader_for_plugin(plugin); if (loader == NULL) return FALSE; loader_info = PURPLE_PLUGIN_LOADER_INFO(loader); if (loader_info->unload && !loader_info->unload(plugin)) return FALSE; } /* cancel any pending dialogs the plugin has */ purple_request_close_with_handle(plugin); purple_notify_close_with_handle(plugin); purple_signals_disconnect_by_handle(plugin); purple_plugin_ipc_unregister_all(plugin); loaded_plugins = g_list_remove(loaded_plugins, plugin); if ((plugin->info != NULL) && PURPLE_IS_PROTOCOL_PLUGIN(plugin)) protocol_plugins = g_list_remove(protocol_plugins, plugin); plugins_to_disable = g_list_remove(plugins_to_disable, plugin); plugin->loaded = FALSE; /* We wouldn't be anywhere near here if the plugin wasn't loaded, so * if plugin->error is set at all, it had to be from a previous * unload failure. It's obviously okay now. */ g_free(plugin->error); plugin->error = NULL; purple_signal_emit(purple_plugins_get_handle(), "plugin-unload", plugin); purple_prefs_disconnect_by_handle(plugin); return TRUE; #else return TRUE; #endif /* PURPLE_PLUGINS */ }
void _purple_connection_destroy(PurpleConnection *gc) { PurpleAccount *account; GSList *buddies; PurplePluginProtocolInfo *prpl_info = NULL; gboolean remove = FALSE; g_return_if_fail(gc != NULL); account = purple_connection_get_account(gc); purple_debug_info("connection", "Disconnecting connection %p\n", gc); if (purple_connection_get_state(gc) != PURPLE_CONNECTING) remove = TRUE; purple_signal_emit(purple_connections_get_handle(), "signing-off", gc); while (gc->buddy_chats) { PurpleConversation *b = gc->buddy_chats->data; gc->buddy_chats = g_slist_remove(gc->buddy_chats, b); purple_conv_chat_left(PURPLE_CONV_CHAT(b)); } update_keepalive(gc, FALSE); purple_proxy_connect_cancel_with_handle(gc); prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl); if (prpl_info->close) (prpl_info->close)(gc); /* Clear out the proto data that was freed in the prpl close method*/ buddies = purple_find_buddies(account, NULL); while (buddies != NULL) { PurpleBuddy *buddy = buddies->data; purple_buddy_set_protocol_data(buddy, NULL); buddies = g_slist_delete_link(buddies, buddies); } connections = g_list_remove(connections, gc); purple_connection_set_state(gc, PURPLE_DISCONNECTED); if (remove) purple_blist_remove_account(account); purple_signal_emit(purple_connections_get_handle(), "signed-off", gc); purple_account_request_close_with_account(account); purple_request_close_with_handle(gc); purple_notify_close_with_handle(gc); purple_debug_info("connection", "Destroying connection %p\n", gc); purple_account_set_connection(account, NULL); g_free(gc->password); g_free(gc->display_name); if (gc->disconnect_timeout > 0) purple_timeout_remove(gc->disconnect_timeout); PURPLE_DBUS_UNREGISTER_POINTER(gc); g_free(gc); }