/**
* egg_icon_chooser_get_icon:
* @chooser: the chooser to examine.
*
* Retrieves the themed icon name string corresponding to the selected icon.
*
* Returns: a newly-allocated icon name string, which should be freed with
* g_free().
*
* Since: 2.8
**/
gchar *
egg_icon_chooser_get_icon (EggIconChooser *chooser)
{
EggIconChooserIface *iface;
GSList *list;
gchar *retval;
g_return_val_if_fail (EGG_IS_ICON_CHOOSER (chooser), NULL);
iface = EGG_ICON_CHOOSER_GET_IFACE (chooser);
g_return_val_if_fail (iface->get_icons != NULL, NULL);
list = (*iface->get_icons) (chooser);
if (list != NULL)
{
retval = list->data;
list = g_slist_remove_link (list, list);
while (list != NULL)
{
g_free (list->data);
list = g_slist_remove_link (list, list);
}
}
else
{
retval = NULL;
}
return retval;
}
static int handle_packet(const uint8_t *buf, struct sr_dev_inst *sdi, int idx)
{
float temperature, humidity;
struct sr_datafeed_packet packet;
struct sr_datafeed_analog analog;
struct sr_analog_encoding encoding;
struct sr_analog_meaning meaning;
struct sr_analog_spec spec;
struct dev_context *devc;
GSList *l;
int ret;
(void)idx;
devc = sdi->priv;
ret = packet_parse((const char *)buf, idx, &temperature, &humidity);
if (ret < 0) {
sr_err("Failed to parse packet.");
return SR_ERR;
}
sr_analog_init(&analog, &encoding, &meaning, &spec, 3);
/* Common values for both channels. */
packet.type = SR_DF_ANALOG;
packet.payload = &analog;
analog.num_samples = 1;
/* Temperature. */
l = g_slist_copy(sdi->channels);
l = g_slist_remove_link(l, g_slist_nth(l, 1));
meaning.channels = l;
meaning.mq = SR_MQ_TEMPERATURE;
meaning.unit = SR_UNIT_CELSIUS; /* TODO: Use C/F correctly. */
analog.data = &temperature;
sr_session_send(sdi, &packet);
g_slist_free(l);
/* Humidity. */
if (mic_devs[idx].has_humidity) {
l = g_slist_copy(sdi->channels);
l = g_slist_remove_link(l, g_slist_nth(l, 0));
meaning.channels = l;
meaning.mq = SR_MQ_RELATIVE_HUMIDITY;
meaning.unit = SR_UNIT_PERCENTAGE;
analog.data = &humidity;
sr_session_send(sdi, &packet);
g_slist_free(l);
}
devc->num_samples++;
return SR_OK;
}
static gint
timeout (C2NetworkTraffic *nt)
{
gint current_recv, current_send, record;
gint seconds_to_display; /* This is a dynamic value, the
* SECONDS_TO_DISPLAY constant
* is about how much we WISH to
* display, not how much we WILL
* display.
*/
GtkWidget *widget = GTK_WIDGET (nt);
seconds_to_display = widget->allocation.width / PIXELS_PER_SECOND;
current_recv = c2_net_speed_tracker_recv ();
current_send = c2_net_speed_tracker_send ();
if (g_slist_length (nt->recv) > seconds_to_display)
nt->recv = g_slist_remove_link (nt->recv, g_slist_last (nt->recv));
nt->recv = g_slist_prepend (nt->recv, (gpointer) current_recv);
if (g_slist_length (nt->send) > seconds_to_display)
nt->send = g_slist_remove_link (nt->send, g_slist_last (nt->send));
nt->send = g_slist_prepend (nt->send, (gpointer) current_send);
/* Update the maximum speed */
record = current_send > current_recv ? current_send : current_recv;
if (record > nt->top_speed)
nt->top_speed = record;
else
{
GSList *l;
nt->top_speed = 1024;
for (l = nt->send; l; l = g_slist_next (l))
if (GPOINTER_TO_INT (l->data) > nt->top_speed)
nt->top_speed = GPOINTER_TO_INT (l->data);
for (l = nt->recv; l; l = g_slist_next (l))
if (GPOINTER_TO_INT (l->data) > nt->top_speed)
nt->top_speed = GPOINTER_TO_INT (l->data);
}
/* Time to draw */
draw_background (nt);
draw_top_speed (nt);
draw_list (nt, nt->send);
draw_list (nt, nt->recv);
draw_screen (nt);
return TRUE;
}
__EXPORT void lttvwindow_events_request_remove_all(Tab *tab,
gconstpointer viewer)
{
GSList *element = tab->events_requests;
while((element =
g_slist_find_custom(element, viewer,
(GCompareFunc)find_viewer))
!= NULL) {
EventsRequest *events_request = (EventsRequest *)element->data;
// Modified so a viewer being destroyed won't have its after_request
// called. Not so important anyway. Note that a viewer that call this
// remove_all function will not get its after_request called.
//if(events_request->servicing == TRUE) {
// lttv_hooks_call(events_request->after_request, NULL);
//}
events_request_free(events_request);
//g_free(events_request);
tab->events_requests = g_slist_remove_link(tab->events_requests, element);
element = g_slist_next(element);
if(element == NULL) break; /* end of list */
}
if(g_slist_length(tab->events_requests) == 0) {
tab->events_request_pending = FALSE;
g_idle_remove_by_data(tab);
}
}
/* Purge server output, either all or for specified target */
void irc_server_purge_output(IRC_SERVER_REC *server, const char *target)
{
GSList *tmp, *next, *link;
REDIRECT_REC *redirect;
char *cmd;
if (target != NULL && *target == '\0')
target = NULL;
for (tmp = server->cmdqueue; tmp != NULL; tmp = next) {
next = tmp->next->next;
cmd = tmp->data;
redirect = tmp->next->data;
if ((target == NULL || command_has_target(cmd, target)) &&
g_ascii_strncasecmp(cmd, "PONG ", 5) != 0) {
/* remove the redirection */
link = tmp->next;
server->cmdqueue =
g_slist_remove_link(server->cmdqueue, link);
g_slist_free_1(link);
if (redirect != NULL)
server_redirect_destroy(redirect);
/* remove the command */
server->cmdqueue =
g_slist_remove(server->cmdqueue, cmd);
g_free(cmd);
server->cmdcount--;
}
}
}
/**
* main: Starts with an RPTable of 10 resources and fetches
* them randomly by the ResourceId and compares them against the original
* resource. A failed comparison means the test failed,
* otherwise the test passed.
*
* Return value: 0 on success, 1 on failure
**/
int main(int argc, char **argv)
{
RPTable *rptable = (RPTable *)g_malloc0(sizeof(RPTable));
guint i = 0, k = 0;
GSList *resources = NULL;
for (i = 0; rptentries[i].ResourceId != 0; i++) {
if (oh_add_resource(rptable, rptentries + i, NULL, 0))
return 1;
else
resources = g_slist_append(resources, rptentries + i);
}
for (; resources; i--) {
SaHpiRptEntryT *randentry = NULL, *tmpentry = NULL;
GSList *tmpnode = NULL;
k = (guint) (((gfloat)i)*rand()/(RAND_MAX+1.0));
tmpnode = g_slist_nth(resources, k);
randentry = (SaHpiRptEntryT *)tmpnode->data;
tmpentry =
oh_get_resource_by_id(rptable, randentry->ResourceId);
if (!tmpentry ||
memcmp(randentry, tmpentry, sizeof(SaHpiRptEntryT)))
return 1;
else {
resources = g_slist_remove_link(resources, tmpnode);
g_slist_free_1(tmpnode);
}
}
return 0;
}
/**
* Deliver all the signals queued so far for the task.
*/
static void
bg_task_deliver_signals(struct bgtask *bt)
{
bg_task_check(bt);
g_assert(bt->flags & TASK_F_RUNNING);
/*
* Stop when list is empty or task has exited.
*
* Note that it is possible for a task to enqueue another signal
* whilst it is processing another.
*/
while (bt->signals != NULL) {
GSList *lnk = bt->signals;
bgsig_t sig = (bgsig_t) GPOINTER_TO_UINT(lnk->data);
/*
* If signal kills the thread (it calls bg_task_exit() from the
* handler), then we won't come back.
*/
bg_task_kill(bt, sig);
bt->signals = g_slist_remove_link(bt->signals, lnk);
g_slist_free_1(lnk);
}
}
static void
cb_pm_button_directory_delete_clicked (PluginManagerGUI *pm_gui)
{
GtkTreeIter iter;
char *dir_name = NULL;
gboolean is_system = TRUE;
GSList *extra_dirs, *res;
if (!gtk_tree_selection_get_selected (pm_gui->selection_directory, NULL, &iter))
return;
gtk_tree_model_get (GTK_TREE_MODEL (pm_gui->model_directories), &iter,
DIR_NAME, &dir_name,
DIR_IS_SYSTEM, &is_system,
-1);
extra_dirs = go_string_slist_copy (gnm_conf_get_plugins_extra_dirs ());
res = is_system
? NULL
: g_slist_find_custom (extra_dirs, dir_name, go_str_compare);
if (res) {
extra_dirs = g_slist_remove_link (extra_dirs, res);
g_free (res->data);
g_slist_free_1 (res);
gnm_conf_set_plugins_extra_dirs (extra_dirs);
pm_gui_load_directory_page (pm_gui);
cb_pm_button_rescan_directories_clicked (pm_gui);
}
g_slist_free_full (extra_dirs, g_free);
g_free (dir_name);
}
/**
* snmp_bc_get_event:
* @hnd: Handler data pointer.
* @event: Infra-structure event pointer.
*
* Passes plugin events up to the infra-structure for processing.
*
* Return values:
* 1 - events to be processed.
* SA_OK - No events to be processed.
* SA_ERR_HPI_INVALID_PARAMS - @event is NULL.
**/
SaErrorT snmp_bc_get_event(void *hnd, struct oh_event *event)
{
SaErrorT err;
struct oh_handler_state *handle = (struct oh_handler_state *)hnd;
if (!event || !hnd) {
dbg("Invalid parameter");
return(SA_ERR_HPI_INVALID_PARAMS);
}
struct snmp_bc_hnd *custom_handle = (struct snmp_bc_hnd *)handle->data;
snmp_bc_lock_handler(custom_handle);
err = snmp_bc_check_selcache(handle, 1, SAHPI_NEWEST_ENTRY);
/* If err is encountered during el cache sync, */
/* log error but take no corrected action. */
/* New entry will still be there next time */
if (err) {
dbg("Event Log cache build/sync failed. Error=%s", oh_lookup_error(err));
/* return(err); */
}
if (g_slist_length(handle->eventq) > 0) {
memcpy(event, handle->eventq->data, sizeof(*event));
free(handle->eventq->data);
handle->eventq = g_slist_remove_link(handle->eventq, handle->eventq);
snmp_bc_unlock_handler(custom_handle);
return(1);
}
/* No events for infra-structure to process */
snmp_bc_unlock_handler(custom_handle);
return(SA_OK);
}
static void
cspi_internal_event_remove (const InternalEvent *e)
{
GSList *link = g_slist_find_custom (_cspi_event_queue, e, cspi_event_compare);
if (link)
_cspi_event_queue = g_slist_remove_link (_cspi_event_queue, link);
}
static GSList *
file_paths_to_strings (GtkFileSystem *fs,
GSList *paths,
gchar * (*convert_func) (GtkFileSystem *fs, const GtkFilePath *path))
{
GSList *strings;
strings = NULL;
while (paths != NULL)
{
GtkFilePath *path;
gchar *string;
path = paths->data;
string = (* convert_func) (fs, path);
/* Eat the list */
gtk_file_path_free (path);
paths = g_slist_remove_link (paths, paths);
if (string)
strings = g_slist_prepend (strings, string);
}
return g_slist_reverse (strings);
}
void rlib_free_variables(rlib *r, struct rlib_element *e) {
struct rlib_element *save;
for (; e != NULL; save = e, e = e->next, g_free(save)) {
struct rlib_report_variable *rv = e->data;
rlib_pcode_free(r, rv->code);
rlib_pcode_free(r, rv->ignore_code);
xmlFree(rv->xml_name.xml);
xmlFree(rv->xml_str_type.xml);
xmlFree(rv->xml_value.xml);
xmlFree(rv->xml_resetonbreak.xml);
xmlFree(rv->xml_precalculate.xml);
xmlFree(rv->xml_ignore.xml);
if(rv->precalculated_values != NULL) {
g_free(rv->precalculated_values->data);
rv->precalculated_values = g_slist_remove_link (rv->precalculated_values, rv->precalculated_values);
}
g_free(rv);
e->data = NULL;
}
}
/**
* snmp_bc_get_event:
* @hnd: Handler data pointer.
* @event: Infra-structure event pointer.
*
* Passes plugin events up to the infra-structure for processing.
*
* Return values:
* 1 - events to be processed.
* SA_OK - No events to be processed.
* SA_ERR_HPI_INVALID_PARAMS - @event is NULL.
**/
SaErrorT snmp_bc_get_event(void *hnd, struct oh_event *event)
{
SaErrorT err;
struct oh_handler_state *handle = (struct oh_handler_state *)hnd;
if (!event) {
dbg("Invalid parameter");
return(SA_ERR_HPI_INVALID_PARAMS);
}
err = snmp_bc_check_selcache(handle, 1, SAHPI_NEWEST_ENTRY);
if (err) {
dbg("Event Log cache build/sync failed. Error=%s", oh_lookup_error(err));
return(err);
}
if (g_slist_length(handle->eventq) > 0) {
memcpy(event, handle->eventq->data, sizeof(*event));
free(handle->eventq->data);
handle->eventq = g_slist_remove_link(handle->eventq, handle->eventq);
return(1);
}
/* No events for infra-structure to process */
return(SA_OK);
}
static void
cg_combo_flags_cell_layout_reorder (GtkCellLayout *layout,
GtkCellRenderer *cell,
gint position)
{
CgComboFlags *combo;
CgComboFlagsPrivate *priv;
CgComboFlagsCellInfo *info;
GSList *link;
combo = CG_COMBO_FLAGS (layout);
priv = CG_COMBO_FLAGS_PRIVATE (combo);
info = cg_combo_flags_get_cell_info (combo, cell);
g_return_if_fail (info != NULL);
link = g_slist_find (priv->cells, info);
g_return_if_fail (link != NULL);
priv->cells = g_slist_remove_link (priv->cells, link);
priv->cells = g_slist_insert (priv->cells, info, position);
if (priv->column != NULL)
gtk_cell_layout_reorder (GTK_CELL_LAYOUT (priv->column), cell, position);
gtk_widget_queue_draw (GTK_WIDGET (combo));
}
void
libnm_glib_unregister_callback (libnm_glib_ctx *ctx,
guint id)
{
GSList *elem;
g_return_if_fail (ctx != NULL);
g_return_if_fail (id > 0);
g_mutex_lock (ctx->callbacks_lock);
elem = ctx->callbacks;
while (elem)
{
libnm_glib_callback *callback = (libnm_glib_callback *)(elem->data);
if (callback && (callback->id == id))
{
_libnm_glib_unschedule_single_callback (ctx, callback);
ctx->callbacks = g_slist_remove_link (ctx->callbacks, elem);
break;
}
elem = g_slist_next (elem);
}
g_mutex_unlock (ctx->callbacks_lock);
}
void
gimp_plug_in_manager_history_add (GimpPlugInManager *manager,
GimpPlugInProcedure *procedure)
{
GSList *list;
gint history_size;
g_return_if_fail (GIMP_IS_PLUG_IN_MANAGER (manager));
g_return_if_fail (GIMP_IS_PLUG_IN_PROCEDURE (procedure));
/* return early if the procedure is already at the top */
if (manager->history && manager->history->data == procedure)
return;
history_size = gimp_plug_in_manager_history_size (manager);
manager->history = g_slist_remove (manager->history, procedure);
manager->history = g_slist_prepend (manager->history, procedure);
list = g_slist_nth (manager->history, history_size);
if (list)
{
manager->history = g_slist_remove_link (manager->history, list);
g_slist_free (list);
}
gimp_plug_in_manager_history_changed (manager);
}
/**
* clutter_binding_pool_remove_action:
* @pool: a #ClutterBindingPool
* @key_val: a key symbol
* @modifiers: a bitmask for the modifiers
*
* Removes the action matching the given @key_val, @modifiers pair,
* if any exists.
*
* Since: 1.0
*/
void
clutter_binding_pool_remove_action (ClutterBindingPool *pool,
guint key_val,
ClutterModifierType modifiers)
{
ClutterBindingEntry remove_entry = { 0, };
GSList *l;
g_return_if_fail (pool != NULL);
g_return_if_fail (key_val != 0);
modifiers = modifiers & BINDING_MOD_MASK;
remove_entry.key_val = key_val;
remove_entry.modifiers = modifiers;
for (l = pool->entries; l != NULL; l = l->data)
{
ClutterBindingEntry *e = l->data;
if (e->key_val == remove_entry.key_val &&
e->modifiers == remove_entry.modifiers)
{
pool->entries = g_slist_remove_link (pool->entries, l);
break;
}
}
g_hash_table_remove (pool->entries_hash, &remove_entry);
}
void nm_firewall_manager_cancel_call (NMFirewallManager *self, NMFirewallPendingCall call)
{
NMFirewallManagerPrivate *priv = NM_FIREWALL_MANAGER_GET_PRIVATE (self);
GSList *pending;
CBInfo *info;
g_return_if_fail (NM_IS_FIREWALL_MANAGER (self));
if (call == PENDING_CALL_DUMMY)
return;
pending = g_slist_find (priv->pending_calls, call);
if (!pending)
return;
priv->pending_calls = g_slist_remove_link (priv->pending_calls, pending);
info = (CBInfo *) call;
if (info->idle_id)
info->idle_id = 0;
else {
dbus_g_proxy_cancel_call (NM_FIREWALL_MANAGER_GET_PRIVATE (self)->proxy,
info->dbus_call);
}
}
void eee_accounts_manager_enable_account(EeeAccountsManager *self, const char *name)
{
GSList *accounts;
GSList *item;
g_return_if_fail(IS_EEE_ACCOUNTS_MANAGER(self));
g_return_if_fail(name != NULL);
accounts = gconf_client_get_list(self->priv->gconf, EEE_KEY "disabled_accounts", GCONF_VALUE_STRING, NULL);
while (TRUE)
{
item = g_slist_find_custom(accounts, name, (GCompareFunc)strcmp);
if (item == NULL)
{
break;
}
g_free(item->data);
accounts = g_slist_remove_link(accounts, item);
}
gconf_client_set_list(self->priv->gconf, EEE_KEY "disabled_accounts", GCONF_VALUE_STRING, accounts, NULL);
g_slist_foreach(accounts, (GFunc)g_free, NULL);
g_slist_free(accounts);
}
static void
remove_selected_layout (GtkWidget * button, GtkBuilder * dialog)
{
gint idx = find_selected_layout_idx (dialog);
if (idx != -1) {
GSList *layouts_list = xkb_layouts_get_selected_list ();
char *id = NULL;
GSList *node2Remove = g_slist_nth (layouts_list, idx);
layouts_list =
g_slist_remove_link (layouts_list, node2Remove);
id = (char *) node2Remove->data;
g_slist_free_1 (node2Remove);
g_free (id);
if (default_group > idx)
xkb_save_default_group (default_group - 1);
else if (default_group == idx)
xkb_save_default_group (-1);
xkb_layouts_set_selected_list (layouts_list);
clear_xkb_elements_list (layouts_list);
}
}
static void
message_cancelled (NaTrayManager *manager,
GtkWidget *icon,
glong id,
TraysScreen *trays_screen)
{
IconTip *icontip;
IconTipBuffer find_buffer;
GSList *cancel_buffer_l;
IconTipBuffer *cancel_buffer;
icontip = g_hash_table_lookup (trays_screen->tip_table, icon);
if (icontip == NULL)
return;
if (icontip->id == id)
{
icon_tip_show_next (icontip);
return;
}
find_buffer.id = id;
cancel_buffer_l = g_slist_find_custom (icontip->buffer, &find_buffer,
icon_tip_buffer_compare);
if (cancel_buffer_l == NULL)
return;
cancel_buffer = cancel_buffer_l->data;
icon_tip_buffer_free (cancel_buffer, NULL);
icontip->buffer = g_slist_remove_link (icontip->buffer, cancel_buffer_l);
g_slist_free_1 (cancel_buffer_l);
}
/**
* ilo2_ribcl_get_event:
* @hnd: Handler data pointer.
* @event: Infra-structure event pointer.
*
* Passes plugin events up to the infra-structure for processing.
*
* Return values:
* 1 - events to be processed.
* SA_OK - No events to be processed.
* SA_ERR_HPI_INVALID_PARAMS - @event is NULL.
**/
SaErrorT ilo2_ribcl_get_event(void *handler)
{
struct oh_handler_state *oh_handler =
(struct oh_handler_state *) handler;
ilo2_ribcl_handler_t *ilo2_ribcl_handler;
if (!handler) {
err("ilo2 ribcl get event: Invalid parameter");
return(SA_ERR_HPI_INVALID_PARAMS);
}
ilo2_ribcl_handler = (ilo2_ribcl_handler_t *) oh_handler->data;
if(! ilo2_ribcl_handler) {
err("ilo2 ribcl get event: Invalid parameter.");
return(SA_ERR_HPI_INVALID_PARAMS);
}
if (g_slist_length(ilo2_ribcl_handler->eventq) > 0) {
struct oh_event *e = ilo2_ribcl_handler->eventq->data;
e->hid = oh_handler->hid;
oh_evt_queue_push(oh_handler->eventq, e);
ilo2_ribcl_handler->eventq =
g_slist_remove_link(ilo2_ribcl_handler->eventq,
ilo2_ribcl_handler->eventq);
return(ILO2_RIBCL_EVENTS_PENDING);
}
/* No events for infrastructure to process */
return(SA_OK);
}
void gtk_clist_remove(GtkCList *clist, gint row)
{
if (row >= 0 && row < clist->rows) {
GSList *dellink;
GtkCListRow *delrow;
int i;
gtk_clist_unselect_row(clist, row, 0);
dellink = g_slist_nth(clist->rowdata, row);
delrow = (GtkCListRow *)dellink->data;
for (i = 0; i < clist->cols; i++) {
g_free(delrow->text[i]);
}
g_free(delrow->text);
clist->rowdata = g_slist_remove_link(clist->rowdata, dellink);
g_free(dellink);
clist->rows = g_slist_length(clist->rowdata);
if (GTK_WIDGET_REALIZED(GTK_WIDGET(clist))) {
HWND hWnd = GTK_WIDGET(clist)->hWnd;
SendMessage(hWnd, LB_DELETESTRING, (WPARAM)row, 0);
}
}
}
static void
_tarif_clear(gint tarif_id)
{
GSList **tarif = NULL;
GSList *link = NULL;
CCL_tarifpart *tp = NULL;
GData *freed = NULL;
tarif = g_new0(GSList *, 1);
*tarif = g_datalist_id_get_data(&ccl->tarifs, tarif_id);
g_assert(NULL != tarif);
g_datalist_init(&freed);
while ((link = g_slist_last(*tarif)) && *tarif)
{
*tarif = g_slist_remove_link(*tarif, link);
tp = (CCL_tarifpart *) link->data;
if (!g_datalist_id_get_data(&freed, GPOINTER_TO_INT(tp->prices)))
{
g_datalist_clear(tp->prices);
g_datalist_id_set_data(&freed, GPOINTER_TO_INT(tp->prices),
(void *)tp->prices);
g_free(tp->prices);
}
g_slist_free_1(link);
g_free(tp);
}
g_datalist_clear(&freed);
*tarif = NULL;
g_datalist_id_remove_data(&ccl->tarifs, tarif_id);
g_free(tarif);
}
void
nm_act_request_cancel_secrets (NMActRequest *self, guint32 call_id)
{
NMActRequestPrivate *priv;
GSList *iter;
g_return_if_fail (self);
g_return_if_fail (NM_IS_ACT_REQUEST (self));
g_return_if_fail (call_id > 0);
priv = NM_ACT_REQUEST_GET_PRIVATE (self);
for (iter = priv->secrets_calls; iter; iter = g_slist_next (iter)) {
GetSecretsInfo *info = iter->data;
/* Remove the matching info */
if (info->call_id == call_id) {
priv->secrets_calls = g_slist_remove_link (priv->secrets_calls, iter);
g_slist_free (iter);
nm_settings_connection_cancel_secrets (NM_SETTINGS_CONNECTION (priv->connection), call_id);
g_free (info);
break;
}
}
}
/* Returns the list containing exactly one INTERNET and one MMS access point */
static GSList *provision_normalize_apn_list(GSList *apns, const char* spn)
{
static const struct provision_ap_defaults internet_defaults =
{ OFONO_GPRS_CONTEXT_TYPE_INTERNET, "Internet", "internet" };
static const struct provision_ap_defaults mms_defaults =
{ OFONO_GPRS_CONTEXT_TYPE_MMS, "MMS", "mms" };
GSList *internet_apns = NULL;
GSList *mms_apns = NULL;
/* Split internet and mms apns, delete all others */
while (apns) {
GSList *link = apns;
struct ofono_gprs_provision_data *ap = link->data;
apns = g_slist_remove_link(apns, link);
if (ap->type == OFONO_GPRS_CONTEXT_TYPE_INTERNET) {
internet_apns = g_slist_concat(internet_apns, link);
} else if (ap->type == OFONO_GPRS_CONTEXT_TYPE_MMS) {
mms_apns = g_slist_concat(mms_apns, link);
} else {
g_slist_free_full(link, provision_free_ap);
}
}
/* Pick the best ap of each type and concatenate them */
return g_slist_concat(
provision_pick_best_ap(internet_apns, spn, &internet_defaults),
provision_pick_best_ap(mms_apns, spn, &mms_defaults));
}
void
grg_recent_dox_push (const guchar * file)
{
GSList *cur, *tmp;
if (file == NULL)
return;
tmp = grg_recent_dox;
while (tmp)
{
cur = tmp;
tmp = tmp->next;
if (STR_EQ (cur->data, file) ||
(g_slist_position (grg_recent_dox, cur) >=
GRG_RECENT_LIMIT - 1))
{
grg_recent_dox =
g_slist_remove_link (grg_recent_dox, cur);
g_free (cur->data);
g_slist_free_1 (cur);
}
}
grg_recent_dox =
g_slist_prepend (grg_recent_dox, g_strdup ((guchar *) file));
recent_dox_save ();
grg_menu_update ();
}
static void
impl_MateComponent_EventSource_removeListener (PortableServer_Servant servant,
const MateComponent_Listener listener,
CORBA_Environment *ev)
{
GSList *l, *next;
MateComponentEventSourcePrivate *priv;
priv = matecomponent_event_source_from_servant (servant)->priv;
for (l = priv->listeners; l; l = next) {
ListenerDesc *desc = l->data;
next = l->next;
if (CORBA_Object_is_equivalent (listener, desc->listener, ev)) {
priv->listeners = g_slist_remove_link (
priv->listeners, l);
g_slist_free_1 (l);
desc_free (desc, ev);
return;
}
}
CORBA_exception_set (ev, CORBA_USER_EXCEPTION,
ex_MateComponent_EventSource_UnknownListener,
NULL);
}
GSList*
g_slist_delete_link (GSList *list, GSList *link)
{
list = g_slist_remove_link (list, link);
g_slist_free_1 (link);
return list;
}
GIOPSendBuffer *
giop_send_buffer_use (GIOPVersion giop_version)
{
GIOPSendBuffer *buf;
g_return_val_if_fail (
((int) giop_version) >= 0 &&
giop_version < GIOP_NUM_VERSIONS, NULL);
LINK_MUTEX_LOCK (send_buffer_list_lock);
if (send_buffer_list) {
GSList *ltmp;
ltmp = send_buffer_list;
send_buffer_list = g_slist_remove_link (
send_buffer_list, ltmp);
LINK_MUTEX_UNLOCK (send_buffer_list_lock);
buf = ltmp->data;
g_slist_free_1 (ltmp);
buf->num_used = buf->indirect_left = 0;
if (giop_blank_wire_data) {
int i;
for (i = 0; i < buf->num_indirects_used; i++)
memset (buf->indirects [i].ptr, 0,
buf->indirects [i].size);
}
buf->num_indirects_used = 0;
} else {
LINK_MUTEX_UNLOCK (send_buffer_list_lock);
buf = g_new0 (GIOPSendBuffer, 1);
memcpy (buf->msg.header.magic, "GIOP", 4);
buf->msg.header.flags = GIOP_FLAG_ENDIANNESS;
buf->num_alloced = 8;
buf->iovecs = g_new (struct iovec, 8);
}
memcpy (buf->msg.header.version,
giop_version_ids [giop_version], 2);
buf->giop_version = giop_version;
g_assert (sizeof (buf->msg.header) == 12);
giop_send_buffer_append_real (
buf, (guchar *)&buf->msg.header, 12);
buf->msg.header.message_size = 0;
buf->header_size = 12;
return buf;
}
