/**
* soup_message_body_truncate:
* @body: a #SoupMessageBody
*
* Deletes all of the data in @body.
**/
void
soup_message_body_truncate (SoupMessageBody *body)
{
SoupMessageBodyPrivate *priv = (SoupMessageBodyPrivate *)body;
g_slist_free_full (priv->chunks, (GDestroyNotify)soup_buffer_free);
priv->chunks = priv->last = NULL;
priv->base_offset = 0;
if (priv->flattened) {
soup_buffer_free (priv->flattened);
priv->flattened = NULL;
body->data = NULL;
}
body->length = 0;
}
static void media_endpoint_destroy(struct media_endpoint *endpoint)
{
DBG("sender=%s path=%s", endpoint->sender, endpoint->path);
media_endpoint_cancel_all(endpoint);
g_slist_free_full(endpoint->transports,
(GDestroyNotify) media_transport_destroy);
g_dbus_remove_watch(btd_get_dbus_connection(), endpoint->watch);
g_free(endpoint->capabilities);
g_free(endpoint->sender);
g_free(endpoint->path);
g_free(endpoint->uuid);
g_free(endpoint);
}
static void deviceinfo_free(gpointer user_data)
{
struct deviceinfo *d = user_data;
if (d->attioid > 0)
btd_device_remove_attio_callback(d->dev, d->attioid);
if (d->attrib != NULL)
g_attrib_unref(d->attrib);
g_slist_free_full(d->chars, g_free);
btd_device_unref(d->dev);
g_free(d->svc_range);
g_free(d);
}
static void
kms_sdp_media_handler_finalize (GObject * object)
{
KmsSdpMediaHandler *self = KMS_SDP_MEDIA_HANDLER (object);
GST_DEBUG_OBJECT (self, "finalize");
g_free (self->priv->proto);
g_free (self->priv->addr);
g_free (self->priv->addr_type);
g_array_free (self->priv->bwtypes, TRUE);
g_slist_free_full (self->priv->extensions, g_object_unref);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
/* Must be called with the agent lock released as it could dispose of
* NiceIOStreams. */
static void
nice_stream_finalize (GObject *obj)
{
NiceStream *stream;
stream = NICE_STREAM (obj);
g_free (stream->name);
g_slist_free_full (stream->components, (GDestroyNotify) g_object_unref);
g_atomic_int_inc (&n_streams_destroyed);
nice_debug ("Destroyed NiceStream (%u created, %u destroyed)",
n_streams_created, n_streams_destroyed);
G_OBJECT_CLASS (nice_stream_parent_class)->finalize (obj);
}
static void
gtk_css_animated_style_dispose (GObject *object)
{
GtkCssAnimatedStyle *style = GTK_CSS_ANIMATED_STYLE (object);
if (style->animated_values)
{
g_ptr_array_unref (style->animated_values);
style->animated_values = NULL;
}
g_slist_free_full (style->animations, g_object_unref);
style->animations = NULL;
G_OBJECT_CLASS (gtk_css_animated_style_parent_class)->dispose (object);
}
void test_file_in_directory_to_gslist()
{
GSList *list = file_in_directory_to_gslist("./tests", "lines");
GSList *list_iterator;
gchar *data = (gchar*) list->data;
g_assert_cmpstr(data, ==, "foo");
list_iterator = list->next;
data = (gchar*) list_iterator->data;
g_assert_cmpstr(data, ==, "bar");
list_iterator = list_iterator->next;
data = (gchar*) list_iterator->data;
g_assert_cmpstr(data, ==, "foo2");
list_iterator = list_iterator->next;
g_assert_null(list_iterator);
g_slist_free_full(list, g_free);
}
static void hev_scgi_task_dispatcher_finalize(GObject * obj)
{
HevSCGITaskDispatcher * self = HEV_SCGI_TASK_DISPATCHER_CAST(obj);
HevSCGITaskDispatcherPrivate * priv = HEV_SCGI_TASK_DISPATCHER_GET_PRIVATE(self);
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
if(priv->handler_slist)
{
g_slist_free_full(priv->handler_slist,
g_object_unref);
priv->handler_slist = NULL;
}
G_OBJECT_CLASS(hev_scgi_task_dispatcher_parent_class)->finalize(obj);
}
void
cons_show_received_subs(void)
{
GSList *received = presence_get_subscription_requests();
if (received == NULL) {
cons_show("No outstanding subscription requests.");
} else {
cons_show("Outstanding subscription requests from:",
g_slist_length(received));
while (received != NULL) {
cons_show(" %s", received->data);
received = g_slist_next(received);
}
g_slist_free_full(received, g_free);
}
}
static void start_ra(int ifindex, GSList *prefix)
{
if (prefixes)
g_slist_free_full(prefixes, g_free);
prefixes = g_dhcpv6_copy_prefixes(prefix);
enable_ipv6_forward(true);
if (timer_ra > 0)
g_source_remove(timer_ra);
send_ra(NULL);
timer_ra = g_timeout_add_seconds(DEFAULT_RA_INTERVAL, send_ra, NULL);
}
void dt_control_cleanup(dt_control_t *s)
{
// vacuum TODO: optional?
// DT_DEBUG_SQLITE3_EXEC(dt_database_get(darktable.db), "PRAGMA incremental_vacuum(0)", NULL, NULL, NULL);
// DT_DEBUG_SQLITE3_EXEC(dt_database_get(darktable.db), "vacuum", NULL, NULL, NULL);
dt_pthread_mutex_destroy(&s->queue_mutex);
dt_pthread_mutex_destroy(&s->cond_mutex);
dt_pthread_mutex_destroy(&s->log_mutex);
dt_pthread_mutex_destroy(&s->run_mutex);
dt_pthread_mutex_destroy(&s->progress_system.mutex);
pthread_rwlock_destroy(&s->xprofile_lock);
if(s->accelerator_list)
{
g_slist_free_full(s->accelerator_list, g_free);
}
}
static void deviceinfo_driver_remove(struct btd_service *service)
{
struct deviceinfo *d = btd_service_get_user_data(service);
if (d->attioid > 0)
btd_device_remove_attio_callback(d->dev, d->attioid);
if (d->attrib != NULL)
g_attrib_unref(d->attrib);
g_slist_free_full(d->chars, g_free);
btd_device_unref(d->dev);
g_free(d->svc_range);
g_free(d);
}
static void stop_ra(int ifindex)
{
__connman_inet_ipv6_send_ra(ifindex, NULL, prefixes, 0);
if (timer_ra > 0) {
g_source_remove(timer_ra);
timer_ra = 0;
}
enable_ipv6_forward(false);
if (prefixes) {
g_slist_free_full(prefixes, g_free);
prefixes = NULL;
}
}
void rm_buffer_pool_destroy(RmBufferPool *pool) {
rm_log_debug_line("had %" G_GSIZE_FORMAT " unused read buffers",
pool->min_kept_buffers);
/* Wait for all buffers to come back */
g_mutex_lock(&pool->lock);
{
/* Free 'em */
g_slist_free_full(pool->stack, (GDestroyNotify)rm_buffer_free);
}
g_mutex_unlock(&pool->lock);
g_mutex_clear(&pool->lock);
g_cond_clear(&pool->change);
g_slice_free(RmBufferPool, pool);
}
void audio_service_free(struct audio_service *service)
{
LSError error;
LSErrorInit(&error);
if (service->handle != NULL && LSUnregister(service->handle, &error) < 0) {
g_warning("Could not unregister service: %s", error.message);
LSErrorFree(&error);
}
g_slist_free_full(sample_list, g_free);
g_free(service->default_sink_name);
g_free(service);
}
static void write_chunks_to_output_stream (GioDownload *download)
{
if (download->priv->chunks == NULL)
return;
GError *error = NULL;
download->priv->chunks = g_slist_reverse (download->priv->chunks); /* Important */
MemChunk *chunk = flatten_mem_chunks (download->priv->chunks);
g_output_stream_write (G_OUTPUT_STREAM (download->priv->output), chunk->data, chunk->size, NULL, &error);
handle_critical_error (error);
g_slist_free_full (download->priv->chunks, (GDestroyNotify)mem_chunk_free);
download->priv->chunks = NULL;
mem_chunk_free (chunk);
}
int main(int argc, char **argv)
{
setlocale(LC_ALL, "");
g_test_init(&argc, &argv, NULL);
GSList *slist = NULL;
std::vector<bool> reverse;
reverse.push_back(false);
reverse.push_back(true);
for(std::vector<bool>::iterator it_reverse = reverse.begin(); it_reverse != reverse.end(); ++it_reverse)
{
std::vector<float> scale;
scale.push_back(0.75f);
scale.push_back(1.25f);
for(std::vector<float>::iterator it_scale = scale.begin(); it_scale != scale.end(); ++it_scale)
{
std::vector<size_t> align;
align.push_back(0);
align.push_back(4 * sizeof(float)); // SSE
//align.push_back(8 * sizeof(float)); // AVX
//align.push_back(16 * sizeof(float)); // AVX512
for(std::vector<size_t>::iterator it_align = align.begin(); it_align != align.end(); ++it_align)
{
lfTestParams *p = (lfTestParams *)g_malloc(sizeof(lfTestParams));
p->reverse = *it_reverse;
p->scale = *it_scale;
p->alignment = *it_align;
add_set_item(p);
slist = g_slist_append(slist, p);
}
}
}
const int res = g_test_run();
g_slist_free_full(slist, (GDestroyNotify)g_free);
return res;
}
static void
test_trie_multi_replace(void) {
PurpleTrie *trie1, *trie2, *trie3;
GSList *tries = NULL;
const gchar *in;
gchar *out;
trie1 = purple_trie_new();
trie2 = purple_trie_new();
trie3 = purple_trie_new();
/* appending is not efficient, but we have only 3 elements */
tries = g_slist_append(tries, trie1);
tries = g_slist_append(tries, trie2);
tries = g_slist_append(tries, trie3);
purple_trie_add(trie1, "test", (gpointer)0x5011);
purple_trie_add(trie1, "trie1", (gpointer)0x5012);
purple_trie_add(trie1, "Alice", (gpointer)0x5013);
purple_trie_add(trie2, "test", (gpointer)0x5021);
purple_trie_add(trie2, "trie2", (gpointer)0x5022);
purple_trie_add(trie2, "example", (gpointer)0x5023);
purple_trie_add(trie2, "Ali", (gpointer)0x5024);
/* "tester" without last (accepting) letter of "test" */
purple_trie_add(trie3, "teser", (gpointer)0x5031);
purple_trie_add(trie3, "trie3", (gpointer)0x5032);
purple_trie_add(trie3, "tester", (gpointer)0x5033);
purple_trie_add(trie3, "example", (gpointer)0x5034);
purple_trie_add(trie3, "Al", (gpointer)0x5035);
in = "test tester trie trie1 trie2 trie3 example Alice";
out = purple_trie_multi_replace(tries, in,
test_trie_replace_cb, (gpointer)5);
g_assert_cmpstr(
"[5:5011] [5:5011]er trie [5:5012] [5:5022] "
"[5:5032] [5:5023] [5:5035]ice",
==,
out
);
g_slist_free_full(tries, g_object_unref);
g_free(out);
}
static GtkWidget *
csv_get_preview (EImport *ei,
EImportTarget *target,
EImportImporter *im)
{
GtkWidget *preview;
GSList *contacts = NULL;
EContact *contact;
EImportTargetURI *s = (EImportTargetURI *) target;
gchar *filename;
FILE *file;
CSVImporter *gci;
filename = g_filename_from_uri (s->uri_src, NULL, NULL);
if (filename == NULL) {
g_message (G_STRLOC ": Couldn't get filename from URI '%s'", s->uri_src);
return NULL;
}
file = g_fopen (filename, "r");
g_free (filename);
if (file == NULL) {
g_message (G_STRLOC ": Can't open .csv file");
return NULL;
}
gci = g_malloc0 (sizeof (*gci));
gci->file = file;
gci->fields_map = NULL;
gci->count = 0;
fseek (file, 0, SEEK_END);
gci->size = ftell (file);
fseek (file, 0, SEEK_SET);
while (contact = getNextCSVEntry (gci, gci->file), contact != NULL) {
contacts = g_slist_prepend (contacts, contact);
}
contacts = g_slist_reverse (contacts);
preview = evolution_contact_importer_get_preview_widget (contacts);
g_slist_free_full (contacts, (GDestroyNotify) g_object_unref);
fclose (file);
g_free (gci);
return preview;
}
static void server_free(struct network_server *ns)
{
if (!ns)
return;
/* FIXME: Missing release/free all bnepX interfaces */
if (ns->record_id)
remove_record_from_server(ns->record_id);
g_free(ns->iface);
g_free(ns->name);
g_free(ns->bridge);
g_slist_free_full(ns->sessions, session_free);
g_free(ns);
}
static void server_remove_sessions(struct network_server *ns)
{
GSList *list;
for (list = ns->sessions; list; list = list->next) {
struct network_session *session = list->data;
if (*session->dev == '\0')
continue;
bnep_server_delete(ns->bridge, session->dev, &session->dst);
}
g_slist_free_full(ns->sessions, session_free);
ns->sessions = NULL;
}
int main(int argc, char *argv[])
{
GOptionContext *context;
GError *err = NULL;
struct sigaction sa;
guint server_id;
context = g_option_context_new(NULL);
g_option_context_add_main_entries(context, options, NULL);
g_option_context_parse(context, &argc, &argv, &err);
if (err != NULL) {
g_printerr("%s\n", err->message);
g_error_free(err);
exit(EXIT_FAILURE);
}
if (option_root && chdir(option_root) < 0) {
perror("chdir:");
exit(EXIT_FAILURE);
}
if (option_bluetooth)
server_id = bluetooth_listen();
else
server_id = unix_listen();
if (server_id == 0)
exit(EXIT_FAILURE);
memset(&sa, 0, sizeof(sa));
sa.sa_handler = sig_term;
sigaction(SIGINT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
main_loop = g_main_loop_new(NULL, FALSE);
g_main_loop_run(main_loop);
g_source_remove(server_id);
g_slist_free_full(clients, (GDestroyNotify) g_obex_unref);
g_option_context_free(context);
g_main_loop_unref(main_loop);
exit(EXIT_SUCCESS);
}
static void
gtk_file_chooser_native_finalize (GObject *object)
{
GtkFileChooserNative *self = GTK_FILE_CHOOSER_NATIVE (object);
g_clear_pointer (&self->current_name, g_free);
g_clear_object (&self->current_file);
g_clear_object (&self->current_folder);
g_clear_pointer (&self->accept_label, g_free);
g_clear_pointer (&self->cancel_label, g_free);
gtk_widget_destroy (self->dialog);
g_slist_free_full (self->custom_files, g_object_unref);
G_OBJECT_CLASS (gtk_file_chooser_native_parent_class)->finalize (object);
}
static void cleanup(void)
{
if (timer_uplink != 0) {
g_source_remove(timer_uplink);
timer_uplink = 0;
}
if (timer_hash) {
g_hash_table_destroy(timer_hash);
timer_hash = NULL;
}
if (prefixes) {
g_slist_free_full(prefixes, g_free);
prefixes = NULL;
}
}
static void
test_trie_multi_find(void) {
PurpleTrie *trie1, *trie2, *trie3;
GSList *tries = NULL;
const gchar *in;
int out;
trie1 = purple_trie_new();
trie2 = purple_trie_new();
trie3 = purple_trie_new();
purple_trie_set_reset_on_match(trie1, FALSE);
purple_trie_set_reset_on_match(trie2, TRUE);
purple_trie_set_reset_on_match(trie3, FALSE);
/* appending is not efficient, but we have only 3 elements */
tries = g_slist_append(tries, trie1);
tries = g_slist_append(tries, trie2);
tries = g_slist_append(tries, trie3);
purple_trie_add(trie1, "test", (gpointer)0x10011);
purple_trie_add(trie1, "trie1", (gpointer)0x10012);
purple_trie_add(trie1, "Alice", (gpointer)0x10013);
purple_trie_add(trie2, "test", (gpointer)0x10021);
purple_trie_add(trie2, "trie2", (gpointer)0x10022);
purple_trie_add(trie2, "example", (gpointer)0x10023);
purple_trie_add(trie2, "Ali", (gpointer)0x10024);
/* "tester" without last (accepting) letter of "test" */
purple_trie_add(trie3, "teser", (gpointer)0x10031);
purple_trie_add(trie3, "trie3", (gpointer)0x10032);
purple_trie_add(trie3, "tester", (gpointer)0x10033);
purple_trie_add(trie3, "example", (gpointer)0x10034);
purple_trie_add(trie3, "Al", (gpointer)0x10035);
in = "test tester trie trie1 trie2 trie3 example Alice";
out = purple_trie_multi_find(tries, in,
test_trie_find_cb, (gpointer)0x10);
g_assert_cmpint(9, ==, out);
g_assert_cmpint(2 * 0x11 + 0x33 + 0x12 + 0x22 +
0x32 + 0x23 + 0x35 + 0x13, ==, find_sum);
g_slist_free_full(tries, g_object_unref);
}
static void
kms_sdp_group_manager_finalize (GObject * object)
{
KmsSdpGroupManager *self = KMS_SDP_GROUP_MANAGER (object);
GST_DEBUG_OBJECT (self, "finalize");
g_hash_table_foreach (self->priv->connected_signals,
disconnect_pending_signals, NULL);
g_hash_table_unref (self->priv->connected_signals);
g_hash_table_unref (self->priv->mids);
g_hash_table_unref (self->priv->groups);
g_hash_table_unref (self->priv->handlers);
g_slist_free_full (self->priv->used_mids, g_free);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
/**
* Shutdown libsigrokdecode.
*
* This frees all the memory allocated for protocol decoders and shuts down
* the Python interpreter.
*
* This function should only be called if there was a (successful!) invocation
* of srd_init() before. Calling this function multiple times in a row, without
* any successful srd_init() calls in between, is not allowed.
*
* @return SRD_OK upon success, a (negative) error code otherwise.
*
* @since 0.1.0
*/
SRD_API int srd_exit(void)
{
srd_dbg("Exiting libsigrokdecode.");
g_slist_foreach(sessions, (GFunc)srd_session_destroy, NULL);
srd_decoder_unload_all();
g_slist_free_full(searchpaths, g_free);
searchpaths = NULL;
/* Py_Finalize() returns void, any finalization errors are ignored. */
Py_Finalize();
max_session_id = -1;
return SRD_OK;
}
static void
kms_webrtc_data_session_bin_finalize (GObject * object)
{
KmsWebRtcDataSessionBin *self = KMS_WEBRTC_DATA_SESSION_BIN (object);
GST_DEBUG_OBJECT (self, "finalize");
g_rec_mutex_clear (&self->priv->mutex);
g_hash_table_unref (self->priv->channels);
g_hash_table_unref (self->priv->data_channels);
g_slist_free_full (self->priv->pending, g_object_unref);
g_thread_pool_free (self->priv->pool, FALSE, FALSE);
/* chain up */
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static void timeserver_stop(void)
{
DBG(" ");
if (resolv) {
g_resolv_unref(resolv);
resolv = NULL;
}
g_slist_free_full(ts_list, g_free);
ts_list = NULL;
__connman_ntp_stop();
ts_recheck_disable();
}
static void
_caps_destroy(Capabilities *caps)
{
if (caps != NULL) {
free(caps->category);
free(caps->type);
free(caps->name);
free(caps->software);
free(caps->software_version);
free(caps->os);
free(caps->os_version);
if (caps->features != NULL) {
g_slist_free_full(caps->features, free);
}
free(caps);
}
}
