/*!
* \internal
* \brief Clear failure-related attributes
*
* \param[in] peer Peer that sent clear request
* \param[in] xml Request XML
*/
static void
attrd_peer_clear_failure(crm_node_t *peer, xmlNode *xml)
{
const char *rsc = crm_element_value(xml, F_ATTRD_RESOURCE);
const char *host = crm_element_value(xml, F_ATTRD_HOST);
const char *op = crm_element_value(xml, F_ATTRD_OPERATION);
const char *interval_spec = crm_element_value(xml, F_ATTRD_INTERVAL);
guint interval_ms = crm_parse_interval_spec(interval_spec);
char *attr = NULL;
GHashTableIter iter;
regex_t regex;
if (attrd_failure_regex(®ex, rsc, op, interval_ms) != pcmk_ok) {
crm_info("Ignoring invalid request to clear failures for %s",
(rsc? rsc : "all resources"));
return;
}
crm_xml_add(xml, F_ATTRD_TASK, ATTRD_OP_UPDATE);
/* Make sure value is not set, so we delete */
if (crm_element_value(xml, F_ATTRD_VALUE)) {
crm_xml_replace(xml, F_ATTRD_VALUE, NULL);
}
g_hash_table_iter_init(&iter, attributes);
while (g_hash_table_iter_next(&iter, (gpointer *) &attr, NULL)) {
if (regexec(®ex, attr, 0, NULL, 0) == 0) {
crm_trace("Matched %s when clearing %s",
attr, (rsc? rsc : "all resources"));
crm_xml_add(xml, F_ATTRD_ATTRIBUTE, attr);
attrd_peer_update(peer, xml, host, FALSE);
}
}
regfree(®ex);
}
static void zeromq_beacon_show_peers( cloneclient_t* cc )
{
return;
printf("--- zeromq_beacon_show_peers(top)\n" );
time_t tt = time(0);
GHashTableIter iter;
gpointer key, value;
g_hash_table_iter_init (&iter, peers);
while (g_hash_table_iter_next (&iter, &key, &value))
{
beacon_announce_t* ba = (beacon_announce_t*)value;
printf("----------\n" );
printf("uuid:%s\n", ba->uuid );
printf("user:%s\n", ba->username );
printf("mach:%s\n", ba->machinename );
printf("ip :%s\n", ba->ip );
printf("port:%d\n", ba->port );
printf("seconds since last msg:%d\n", (int)(tt - ba->last_msg_from_peer_time) );
}
printf("--- zeromq_beacon_show_peers(end)\n" );
}
const gchar * xsl_params(GHashTable * params) {
if(params == NULL)
return NULL;
GHashTableIter iter;
gint hashtablesize = g_hash_table_size(params);
gint arraysize = (hashtablesize * 2) + 1;
gint i = 0;
const gchar * params_array[arraysize];
gchar * key, * value;
g_hash_table_iter_init (&iter, params);
while (g_hash_table_iter_next (&iter, &key, &value))
{
params_array[i] = key;
params_array[++i] = value;
++i;
}
params_array[i] = NULL;
return params_array;
}
static void
on_manager_call_forwarded (DBusGProxy *proxy,
char const *type,
gpointer user_data)
{
DEBUG ("%s", type);
ModemCallService *self = MODEM_CALL_SERVICE (user_data);
ModemCall *ci = NULL;
GHashTableIter iter[1];
g_hash_table_iter_init (iter, self->priv->instances);
while (g_hash_table_iter_next (iter, NULL, (gpointer)&ci))
{
ModemCallState state;
g_object_get (ci, "state", &state, NULL);
if (state == MODEM_CALL_STATE_INCOMING && strcmp(type, "incoming") == 0)
{
break;
}
else if (state == MODEM_CALL_STATE_DIALING && strcmp(type, "outgoing") == 0)
{
break;
}
}
if (ci)
{
g_signal_emit_by_name (ci, "forwarded");
}
else
{
self->priv->forwarded = g_strdup(type);
}
}
void git_allbuildable() {
GHashTable* repos = get_repos();
GHashTableIter iter;
gpointer repo, value;
g_hash_table_iter_init (&iter, repos);
while (g_hash_table_iter_next(&iter, &repo, &value)) {
gchar* source_path = get_config_subdir_file_name("repos", repo);
if(!g_file_test(source_path, G_FILE_TEST_EXISTS |
G_FILE_TEST_IS_REGULAR)) {
g_error("Missing repo for %s, which should be in %s\n", (gchar*)repo, source_path);
}
printf("Tags for repo %s:\n", (gchar*)repo);
gchar* fetchcmd = g_strconcat("cd ",
source_path,
" && git tag | sort",
NULL);
int result = system(fetchcmd);
if(result != 0) {
g_error("Cannot get a list of git tags.\n");
}
g_free(fetchcmd);
g_free(source_path);
}
}
static struct gateway_data *lookup_gateway_data(struct gateway_config *config)
{
GHashTableIter iter;
gpointer value, key;
if (!config)
return NULL;
g_hash_table_iter_init(&iter, gateway_hash);
while (g_hash_table_iter_next(&iter, &key, &value)) {
struct gateway_data *data = value;
if (data->ipv4_gateway &&
data->ipv4_gateway == config)
return data;
if (data->ipv6_gateway &&
data->ipv6_gateway == config)
return data;
}
return NULL;
}
static void print_target_config(TargetConfig *target_config, unsigned int indent_level) {
GHashTableIter iter;
gpointer key, value;
print_indent(indent_level);
g_print("lastPort = %d;\n", target_config->last_port);
print_indent(indent_level);
g_print("minPort = %d;\n", target_config->min_port);
print_indent(indent_level);
g_print("maxPort = %d;\n", target_config->max_port);
print_indent(indent_level);
g_print("servicesToPorts = {\n");
g_hash_table_iter_init(&iter, target_config->services_to_ports);
while(g_hash_table_iter_next(&iter, &key, &value))
{
gint *port = (gint*)value;
print_indent(indent_level + 1);
g_print("%s = %d;\n", (gchar*)key, *port);
}
print_indent(indent_level);
g_print("};\n");
}
static void
jaw_impl_finalize(GObject *gobject)
{
JawObject *jaw_obj = JAW_OBJECT(gobject);
jobject global_ac = jaw_obj->acc_context;
JawImpl *jaw_impl = (JawImpl*)jaw_obj;
JNIEnv *jniEnv = jaw_util_get_jni_env();
object_table_remove( jniEnv, global_ac );
(*jniEnv)->DeleteGlobalRef(jniEnv, global_ac);
jaw_obj->acc_context = NULL;
/* Interface finalize */
GHashTableIter iter;
gpointer value;
g_hash_table_iter_init(&iter, jaw_impl->ifaceTable);
while (g_hash_table_iter_next(&iter, NULL, &value))
{
JawInterfaceInfo *info = (JawInterfaceInfo*)value;
info->finalize(info->data);
g_free(info);
g_hash_table_iter_remove(&iter);
}
if (jaw_impl->ifaceTable != NULL)
{
g_hash_table_unref(jaw_impl->ifaceTable);
g_hash_table_destroy(jaw_obj->storedData);
}
/* Chain up to parent's finalize */
G_OBJECT_CLASS(jaw_impl_parent_class)->finalize(gobject);
}
void fchat_select_buddies_list(FChatConnection *fchat_conn, const gchar *msg_text, GHashTable *buddies, FChatSelectBuddiesListCb *ok_cb, FChatSelectBuddiesListCb *cancel_cb, void *user_data) {
PurpleRequestFields *fields;
PurpleRequestFieldGroup *group;
PurpleRequestField *field;
fields = purple_request_fields_new();
group = purple_request_field_group_new(NULL);
purple_request_fields_add_group(fields, group);
field = purple_request_field_list_new("buddies", _("Buddies"));
purple_request_field_list_set_multi_select(field, TRUE);
GHashTableIter iter;
gchar *buddy_host;
FChatBuddy *buddy;
g_hash_table_iter_init (&iter, buddies);
while (g_hash_table_iter_next (&iter, (gpointer *)&buddy_host, (gpointer *)&buddy)) {
gchar *item = g_strdup_printf("%s (%s)", buddy->host, buddy->alias ? buddy->alias : "");
purple_request_field_list_add(field, item, buddy);
g_free(item);
/* purple_request_field_list_add_selected(field, item, buddy); */
}
purple_request_field_group_add_field(group, field);
FChatSelectBuddiesListCbData *fchat_select_buddies_list_cb_data = g_new(FChatSelectBuddiesListCbData, 1);
fchat_select_buddies_list_cb_data->fchat_conn = fchat_conn;
fchat_select_buddies_list_cb_data->ok_cb = ok_cb;
fchat_select_buddies_list_cb_data->cancel_cb = cancel_cb;
fchat_select_buddies_list_cb_data->user_data = user_data;
purple_request_fields(fchat_conn->gc, _("Select buddies"),
msg_text, _("Use Ctrl or Shift keys for multiply select"), fields,
_("Ok"), G_CALLBACK(fchat_select_buddies_list_ok_cb),
_("Cancel"), G_CALLBACK(fchat_select_buddies_list_cancel_cb),
fchat_conn->gc->account, NULL, NULL,
fchat_select_buddies_list_cb_data);
}
gchar *
gupnp_dlna_info_set_to_string (GUPnPDLNAInfoSet *info_set)
{
GString *str;
GHashTableIter iter;
gpointer key;
gpointer value;
g_return_val_if_fail (info_set != NULL, NULL);
if (gupnp_dlna_info_set_is_empty (info_set))
return g_strdup ("EMPTY");
str = g_string_new (info_set->mime ? info_set->mime : "(null)");
g_hash_table_iter_init (&iter, info_set->entries);
while (g_hash_table_iter_next (&iter, &key, &value)) {
gchar *raw = gupnp_dlna_info_value_to_string (value);
g_string_append_printf (str, ", %s=%s", (gchar *) key, raw);
g_free (raw);
}
return g_string_free (str, FALSE);
}
/**
* as_pool_get_components_by_provided_item:
* @pool: An instance of #AsPool.
* @kind: An #AsProvidesKind
* @item: The value of the provided item.
*
* Find components in the AppStream data pool whcih provide a certain item.
*
* Returns: (transfer container) (element-type AsComponent): an array of #AsComponent objects which have been found.
*/
GPtrArray*
as_pool_get_components_by_provided_item (AsPool *pool,
AsProvidedKind kind,
const gchar *item)
{
AsPoolPrivate *priv = GET_PRIVATE (pool);
GHashTableIter iter;
gpointer value;
GPtrArray *results;
/* sanity check */
g_return_val_if_fail (item != NULL, NULL);
results = g_ptr_array_new_with_free_func (g_object_unref);
g_hash_table_iter_init (&iter, priv->cpt_table);
while (g_hash_table_iter_next (&iter, NULL, &value)) {
GPtrArray *provided = NULL;
guint i;
AsComponent *cpt = AS_COMPONENT (value);
provided = as_component_get_provided (cpt);
for (i = 0; i < provided->len; i++) {
AsProvided *prov = AS_PROVIDED (g_ptr_array_index (provided, i));
if (kind != AS_PROVIDED_KIND_UNKNOWN) {
/* check if the kind matches. an unknown kind matches all provides types */
if (as_provided_get_kind (prov) != kind)
continue;
}
if (as_provided_has_item (prov, item))
g_ptr_array_add (results, g_object_ref (cpt));
}
}
return results;
}
static void
tp_connection_get_contact_list_attributes_cb(TpConnection* connection,
GHashTable *out_Attributes,
const GError* error,
gpointer user_data,
GObject* /*weak_object*/)
{
UT_DEBUGMSG(("tp_connection_get_contact_list_attributes\n"));
if (error)
UT_DEBUGMSG(("%s\n", error->message));
UT_return_if_fail(!error);
std::vector<TpHandle> handles;
// get the list of contact handles
gpointer key;
GHashTableIter iter;
g_hash_table_iter_init(&iter, out_Attributes);
while (g_hash_table_iter_next(&iter, &key, NULL))
{
TpHandle contact_handle = GPOINTER_TO_UINT(key);
handles.push_back(contact_handle);
}
// fetch the contacts belonging to the handles
static TpContactFeature features[] = {
TP_CONTACT_FEATURE_ALIAS,
TP_CONTACT_FEATURE_PRESENCE
};
tp_connection_get_contacts_by_handle (connection,
handles.size(), &handles[0],
G_N_ELEMENTS (features), features,
list_contacts_for_connection_cb,
user_data, NULL, NULL);
}
/* Evicts all cached textures for named icons */
static void
st_texture_cache_evict_icons (StTextureCache *cache)
{
GHashTableIter iter;
gpointer key;
gpointer value;
g_debug ("%s: Pre-evict count: %d\n", G_STRFUNC, g_hash_table_size (cache->priv->keyed_cache));
g_hash_table_iter_init (&iter, cache->priv->keyed_cache);
while (g_hash_table_iter_next (&iter, &key, &value))
{
const char *cache_key = key;
/* This is too conservative - it takes out all cached textures
* for GIcons even when they aren't named icons, but it's not
* worth the complexity of parsing the key and calling
* g_icon_new_for_string(); icon theme changes aren't normal */
if (g_str_has_prefix (cache_key, CACHE_PREFIX_ICON))
g_hash_table_iter_remove (&iter);
}
g_debug ("%s: Post-evict count: %d\n", G_STRFUNC, g_hash_table_size (cache->priv->keyed_cache));
}
void
_nm_object_cache_clear (NMObject *except)
{
GHashTableIter iter;
NMObject *obj;
const char *path;
char *foo;
_init_cache ();
g_hash_table_iter_init (&iter, cache);
while (g_hash_table_iter_next (&iter, (gpointer) &path, (gpointer) &obj)) {
if (obj != except) {
/* Remove the callback so that if the object isn't yet released
* by a client, when it does finally get unrefed, it won't trigger
* the cache removal for a new object with the same path as the
* one being released.
*/
foo = g_object_steal_data (G_OBJECT (obj), "nm-object-cache-tag");
g_free (foo);
g_hash_table_iter_remove (&iter);
}
}
}
char *uri_resolver_dump(UriResolver const *u)
{
char *result = NULL;
if (!u)
return result;
result = g_strdup("");
GHashTableIter it1;
g_hash_table_iter_init(&it1, u->documents);
char const *document = NULL;
GHashTable *fragments = NULL;
while (g_hash_table_iter_next(&it1, (void **) &document, (void **) &fragments))
{
char *sd = g_strconcat(document, ":", NULL);
if (fragments)
{
GList *keys = g_hash_table_get_keys(fragments);
keys = g_list_sort(keys, _compare_key);
GList *head = keys;
while (head)
{
char *sf = g_strconcat(sd, " ", head->data, NULL);
g_free(sd);
sd = sf;
head = g_list_next(head);
}
g_list_free(keys);
}
char *r2 = g_strconcat(result, sd, "\n", NULL);
g_free(sd);
g_free(result);
result = r2;
}
return result;
}
static gboolean
finish_list_cached_users (gpointer user_data)
{
ListUserData *data = user_data;
GPtrArray *object_paths;
GHashTableIter iter;
const gchar *name;
User *user;
uid_t uid;
const gchar *shell;
object_paths = g_ptr_array_new ();
g_hash_table_iter_init (&iter, data->daemon->priv->users);
while (g_hash_table_iter_next (&iter, (gpointer *)&name, (gpointer *)&user)) {
uid = user_get_uid (user);
shell = user_get_shell (user);
if (!user_classify_is_human (uid, name, shell, NULL)) {
g_debug ("user %s %ld excluded", name, (long) uid);
continue;
}
g_debug ("user %s %ld not excluded", name, (long) uid);
g_ptr_array_add (object_paths, (gpointer) user_get_object_path (user));
}
g_ptr_array_add (object_paths, NULL);
accounts_accounts_complete_list_cached_users (NULL, data->context, (const gchar * const *) object_paths->pdata);
g_ptr_array_free (object_paths, TRUE);
list_user_data_free (data);
return FALSE;
}
static GList *
tp_contact_list_get_groups (EmpathyContactList *list,
EmpathyContact *contact)
{
EmpathyTpContactListPriv *priv = GET_PRIV (list);
GList *ret = NULL;
GHashTableIter iter;
gpointer group_name;
gpointer channel;
TpHandle handle;
handle = empathy_contact_get_handle (contact);
g_hash_table_iter_init (&iter, priv->groups);
while (g_hash_table_iter_next (&iter, &group_name, &channel)) {
const TpIntSet *members;
members = tp_channel_group_get_members (channel);
if (tp_intset_is_member (members, handle)) {
ret = g_list_prepend (ret, g_strdup (group_name));
}
}
return ret;
}
static void
egg_state_machine__property_object_weak_notify (gpointer data,
GObject *where_object_was)
{
EggStateProperty *state_prop = data;
EggStateMachine *self = state_prop->state_machine;
EggStateMachinePrivate *priv = egg_state_machine_get_instance_private (self);
GHashTableIter iter;
EggState *state;
g_assert (EGG_IS_STATE_MACHINE (self));
g_assert (where_object_was != NULL);
state_prop->object = NULL;
g_hash_table_iter_init (&iter, priv->states);
while (g_hash_table_iter_next (&iter, NULL, (gpointer)&state))
{
if (g_ptr_array_remove_fast (state->properties, state_prop))
return;
}
g_critical ("Failed to find property for %p", where_object_was);
}
static void
main_window_destroy_cb (GtkWidget *widget,
EmpathyMainWindow *window)
{
GHashTableIter iter;
gpointer key, value;
/* Save user-defined accelerators. */
main_window_accels_save ();
g_list_free (window->actions_connected);
g_object_unref (window->account_manager);
g_object_unref (window->list_store);
g_hash_table_destroy (window->errors);
/* disconnect all handlers of status-changed signal */
g_hash_table_iter_init (&iter, window->status_changed_handlers);
while (g_hash_table_iter_next (&iter, &key, &value))
g_signal_handler_disconnect (TP_ACCOUNT (key),
GPOINTER_TO_UINT (value));
g_hash_table_destroy (window->status_changed_handlers);
g_signal_handlers_disconnect_by_func (window->event_manager,
main_window_event_added_cb,
window);
g_signal_handlers_disconnect_by_func (window->event_manager,
main_window_event_removed_cb,
window);
g_object_unref (window->event_manager);
g_object_unref (window->ui_manager);
g_object_unref (window->chatroom_manager);
g_free (window);
}
gboolean
lw_index_are_equal (LwIndex *index1,
LwIndex *index2)
{
//Declarations
GHashTableIter iter;
gchar *key1;
LwOffset *value1, *value2;
LwIndexTableType type = 0;
for (type = 0; type < TOTAL_LW_INDEX_TABLES; type++)
{
g_hash_table_iter_init (&iter, index1->table[type]);
while (g_hash_table_iter_next (&iter, (gpointer*) &key1, (gpointer*) &value1))
{
value2 = _lw_index_get_data_offsets (index2, type, key1);
if (value2 == NULL) return FALSE;
if (*value1 != *value2) return FALSE;
if (memcmp(value1, value2, *value1) != 0) return FALSE;
}
}
return TRUE;
}
bool
_LSPrivateInrospection(LSHandle* sh, LSMessage *message, void *ctx)
{
LSError lserror;
LSErrorInit(&lserror);
GHashTableIter iter_category, iter_element;
gpointer name_category, table_category, name_element, callback;
struct LSCategoryTable *pTable = NULL;
struct json_object *ret_obj = NULL;
struct json_object *category_obj = NULL;
struct json_object *element_obj = NULL;
ret_obj = json_object_new_object();
g_hash_table_iter_init(&iter_category, sh->tableHandlers);
while (g_hash_table_iter_next(&iter_category, &name_category, &table_category))
{
// skip hidden method
if (strcmp("/com/palm/luna/private", name_category) == 0)
continue;
pTable = (struct LSCategoryTable *)table_category;
category_obj = json_object_new_object();
// methods
g_hash_table_iter_init(&iter_element, pTable->methods);
while (g_hash_table_iter_next(&iter_element, &name_element, &callback))
{
element_obj = json_object_new_string("METHOD");
json_object_object_add(category_obj, name_element, element_obj);
}
// signals
g_hash_table_iter_init(&iter_element, pTable->signals);
while (g_hash_table_iter_next(&iter_element, &name_element, &callback))
{
element_obj = json_object_new_string("SIGNAL");
json_object_object_add(category_obj, name_element, element_obj);
}
json_object_object_add(ret_obj, name_category, category_obj);
}
bool reply_ret = LSMessageReply(sh, message, json_object_to_json_string(ret_obj), &lserror);
if (!reply_ret)
{
g_critical("%s: sending introspection data failed", __FUNCTION__);
LSErrorPrint(&lserror, stderr);
LSErrorFree(&lserror);
goto error;
}
json_object_put(ret_obj);
return true;
error:
if (!JSON_ERROR(ret_obj)) json_object_put(ret_obj);
if (!JSON_ERROR(category_obj)) json_object_put(category_obj);
if (!JSON_ERROR(element_obj)) json_object_put(element_obj);
return false;
}
gboolean
tp_base_connection_manager_register (TpBaseConnectionManager *self)
{
GError *error = NULL;
TpBaseConnectionManagerClass *cls;
GString *string = NULL;
guint i;
GHashTableIter iter;
gpointer name, protocol;
g_assert (TP_IS_BASE_CONNECTION_MANAGER (self));
cls = TP_BASE_CONNECTION_MANAGER_GET_CLASS (self);
if (!tp_base_connection_manager_ensure_dbus (self, &error))
goto except;
if (cls->protocol_params != NULL)
{
for (i = 0; cls->protocol_params[i].name != NULL; i++)
{
TpBaseProtocol *p = _tp_legacy_protocol_new (self,
cls->protocol_params + i);
tp_base_connection_manager_add_protocol (self, p);
g_object_unref (p);
}
}
g_assert (self->priv->dbus_daemon != NULL);
string = g_string_new (TP_CM_BUS_NAME_BASE);
g_string_append (string, cls->cm_dbus_name);
if (!tp_dbus_daemon_request_name (self->priv->dbus_daemon, string->str,
TRUE, &error))
goto except;
g_string_assign (string, TP_CM_OBJECT_PATH_BASE);
g_string_append (string, cls->cm_dbus_name);
tp_dbus_daemon_register_object (self->priv->dbus_daemon, string->str, self);
g_hash_table_iter_init (&iter, self->priv->protocols);
while (g_hash_table_iter_next (&iter, &name, &protocol))
{
TpBaseProtocolClass *protocol_class =
TP_BASE_PROTOCOL_GET_CLASS (protocol);
if (!tp_connection_manager_check_valid_protocol_name (name, &error))
{
g_critical ("%s", error->message);
goto except;
}
/* don't export uninformative "stub" protocol objects on D-Bus */
if (protocol_class->is_stub)
continue;
g_string_assign (string, TP_CM_OBJECT_PATH_BASE);
g_string_append (string, cls->cm_dbus_name);
g_string_append_c (string, '/');
g_string_append (string, name);
g_strdelimit (string->str, "-", '_');
tp_dbus_daemon_register_object (self->priv->dbus_daemon, string->str,
protocol);
}
g_string_free (string, TRUE);
self->priv->registered = TRUE;
return TRUE;
except:
WARNING ("Couldn't claim bus name. If you are trying to debug this "
"connection manager, disable all accounts and kill any running "
"copies of this CM, then try again. %s", error->message);
g_error_free (error);
if (string != NULL)
g_string_free (string, TRUE);
return FALSE;
}
static void
reload_connections (gpointer config)
{
SCPluginIfnet *self = SC_PLUGIN_IFNET (config);
SCPluginIfnetPrivate *priv = SC_PLUGIN_IFNET_GET_PRIVATE (self);
GList *conn_names = NULL, *n_iter = NULL;
/* save names for removing unused connections */
GHashTable *new_conn_names = NULL;
GHashTableIter iter;
gpointer key;
gpointer value;
if (priv->unmanaged_well_known)
return;
if (!reload_parsers ())
return;
PLUGIN_PRINT (IFNET_PLUGIN_NAME, "Loading connections");
conn_names = ifnet_get_connection_names ();
new_conn_names =
g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
for (n_iter = conn_names; n_iter; n_iter = g_list_next (n_iter)) {
NMIfnetConnection *exported;
NMIfnetConnection *old;
gchar *conn_name = g_strdup (n_iter->data);
/* add the new connection */
exported = nm_ifnet_connection_new (conn_name);
if (!exported) {
g_free (conn_name);
continue;
}
g_signal_connect (G_OBJECT (exported), "ifnet_setup_monitors",
G_CALLBACK (setup_monitors), config);
g_signal_connect (G_OBJECT (exported), "ifnet_cancel_monitors",
G_CALLBACK (cancel_monitors), config);
old = g_hash_table_lookup (priv->config_connections, conn_name);
if (old && exported) {
gchar *auto_refresh =
ifnet_get_global_setting (IFNET_KEY_FILE_GROUP,
"auto_refresh");
if (auto_refresh && is_true (auto_refresh)) {
if (!nm_connection_compare (NM_CONNECTION (old),
NM_CONNECTION
(exported),
NM_SETTING_COMPARE_FLAG_EXACT))
{
PLUGIN_PRINT (IFNET_PLUGIN_NAME,
"Auto refreshing %s",
conn_name);
g_signal_emit_by_name (old,
NM_SETTINGS_CONNECTION_INTERFACE_REMOVED);
g_hash_table_remove
(priv->config_connections,
conn_name);
g_hash_table_insert
(priv->config_connections,
g_strdup (conn_name), exported);
if (is_managed (conn_name))
g_signal_emit_by_name (self,
NM_SYSTEM_CONFIG_INTERFACE_CONNECTION_ADDED,
exported);
}
} else
update_old_connection (conn_name, old,
exported, priv);
g_signal_emit_by_name (self,
NM_SYSTEM_CONFIG_INTERFACE_UNMANAGED_SPECS_CHANGED);
} else if (exported) {
g_hash_table_insert (priv->config_connections,
g_strdup (conn_name), exported);
if (is_managed (conn_name))
g_signal_emit_by_name (self,
NM_SYSTEM_CONFIG_INTERFACE_CONNECTION_ADDED,
exported);
}
g_hash_table_insert (new_conn_names, conn_name, conn_name);
}
/* remove unused connections */
g_hash_table_iter_init (&iter, priv->config_connections);
while (g_hash_table_iter_next (&iter, &key, &value)) {
if (!g_hash_table_lookup (new_conn_names, key)) {
g_signal_emit_by_name (value,
NM_SETTINGS_CONNECTION_INTERFACE_REMOVED);
g_hash_table_remove (priv->config_connections, key);
}
}
g_hash_table_remove_all (new_conn_names);
g_hash_table_destroy (new_conn_names);
g_list_free (conn_names);
}
/*
* Initialize and run the language listing parser. This call must be
* made only once, at program initialization, but after language_init().
*/
void
gimp_language_store_parser_init (void)
{
GHashTable *base_lang_list;
gchar *current_env;
GDir *locales_dir;
GHashTableIter lang_iter;
gpointer key;
if (l10n_lang_list != NULL)
{
g_warning ("gimp_language_store_parser_init() must be run only once.");
return;
}
current_env = g_strdup (g_getenv ("LANGUAGE"));
l10n_lang_list = g_hash_table_new_full (g_str_hash, g_str_equal,
(GDestroyNotify) g_free,
(GDestroyNotify) g_free);
all_lang_list = g_hash_table_new_full (g_str_hash, g_str_equal,
(GDestroyNotify) g_free,
(GDestroyNotify) g_free);
base_lang_list = g_hash_table_new_full (g_str_hash, g_str_equal,
(GDestroyNotify) g_free,
(GDestroyNotify) g_free);
/* Check all locales we have translations for. */
locales_dir = g_dir_open (gimp_locale_directory (), 0, NULL);
if (locales_dir)
{
const gchar *locale;
while ((locale = g_dir_read_name (locales_dir)) != NULL)
{
gchar *filename = g_build_filename (gimp_locale_directory (),
locale,
"LC_MESSAGES",
GETTEXT_PACKAGE ".mo",
NULL);
if (g_file_test (filename, G_FILE_TEST_EXISTS))
{
gchar *delimiter = NULL;
gchar *base_code = NULL;
delimiter = strchr (locale, '_');
if (delimiter)
base_code = g_strndup (locale, delimiter - locale);
else
base_code = g_strdup (locale);
delimiter = strchr (base_code, '@');
if (delimiter)
{
gchar *temp = base_code;
base_code = g_strndup (base_code, delimiter - base_code);
g_free (temp);
}
/* Save the full language code. */
g_hash_table_insert (l10n_lang_list, g_strdup (locale), NULL);
/* Save the base language code. */
g_hash_table_insert (base_lang_list, base_code, NULL);
}
g_free (filename);
}
g_dir_close (locales_dir);
}
/* Parse ISO-639 file to get full list of language and their names. */
parse_iso_codes (base_lang_list, NULL);
/* Generate the localized language names. */
g_hash_table_iter_init (&lang_iter, l10n_lang_list);
while (g_hash_table_iter_next (&lang_iter, &key, NULL))
{
gchar *code = (gchar*) key;
gchar *localized_name = NULL;
gchar *english_name = NULL;
gchar *delimiter = NULL;
gchar *base_code = NULL;
delimiter = strchr (code, '_');
if (delimiter)
base_code = g_strndup (code, delimiter - code);
else
base_code = g_strdup (code);
delimiter = strchr (base_code, '@');
if (delimiter)
{
gchar *temp = base_code;
base_code = g_strndup (base_code, delimiter - base_code);
g_free (temp);
}
english_name = (gchar*) (g_hash_table_lookup (base_lang_list, base_code));
if (english_name)
{
gchar *semicolon;
/* If possible, we want to localize a language in itself.
* If it fails, gettext fallbacks to C (en_US) itself.
*/
g_setenv ("LANGUAGE", code, TRUE);
setlocale (LC_ALL, "");
localized_name = g_strdup (dgettext ("iso_639", english_name));
/* If original and localized names are the same for other than English,
* maybe localization failed. Try now in the main dialect. */
if (g_strcmp0 (english_name, localized_name) == 0 &&
g_strcmp0 (base_code, "en") != 0 &&
g_strcmp0 (code, base_code) != 0)
{
g_free (localized_name);
g_setenv ("LANGUAGE", base_code, TRUE);
setlocale (LC_ALL, "");
localized_name = g_strdup (dgettext ("iso_639", english_name));
}
/* there might be several language names; use the first one */
semicolon = strchr (localized_name, ';');
if (semicolon)
{
gchar *temp = localized_name;
localized_name = g_strndup (localized_name, semicolon - localized_name);
g_free (temp);
}
}
g_hash_table_replace (l10n_lang_list, g_strdup(code),
g_strdup_printf ("%s [%s]",
localized_name ?
localized_name : "???",
code));
g_free (localized_name);
g_free (base_code);
}
/* Add special entries for system locale.
* We want the system locale to be localized in itself. */
g_setenv ("LANGUAGE", setlocale (LC_ALL, NULL), TRUE);
setlocale (LC_ALL, "");
/* g_str_hash() does not accept NULL. I give an empty code instead.
* Other solution would to create a custom hash. */
g_hash_table_insert (l10n_lang_list, g_strdup(""),
g_strdup (_("System Language")));
/* Go back to original localization. */
if (current_env)
{
g_setenv ("LANGUAGE", current_env, TRUE);
g_free (current_env);
}
else
g_unsetenv ("LANGUAGE");
setlocale (LC_ALL, "");
/* Add special entry for C (en_US). */
g_hash_table_insert (l10n_lang_list, g_strdup ("en_US"),
g_strdup ("English [en_US]"));
g_hash_table_destroy (base_lang_list);
}
gboolean
ostree_builtin_fsck (int argc, char **argv, OstreeCommandInvocation *invocation, GCancellable *cancellable, GError **error)
{
g_autoptr(OstreeRepo) repo = NULL;
gboolean found_corruption = FALSE;
g_autoptr(GOptionContext) context = g_option_context_new ("");
if (!ostree_option_context_parse (context, options, &argc, &argv, invocation, &repo, cancellable, error))
return FALSE;
if (!opt_quiet)
g_print ("Validating refs...\n");
/* Validate that the commit for each ref is available */
g_autoptr(GHashTable) all_refs = NULL;
if (!ostree_repo_list_refs (repo, NULL, &all_refs,
cancellable, error))
return FALSE;
GHashTableIter hash_iter;
gpointer key, value;
g_hash_table_iter_init (&hash_iter, all_refs);
while (g_hash_table_iter_next (&hash_iter, &key, &value))
{
const char *refspec = key;
const char *checksum = value;
g_autofree char *ref_name = NULL;
if (!ostree_parse_refspec (refspec, NULL, &ref_name, error))
return FALSE;
if (!fsck_commit_for_ref (repo, checksum, NULL, ref_name,
&found_corruption, cancellable, error))
return FALSE;
}
if (!opt_quiet)
g_print ("Validating refs in collections...\n");
g_autoptr(GHashTable) all_collection_refs = NULL; /* (element-type OstreeCollectionRef utf8) */
if (!ostree_repo_list_collection_refs (repo, NULL, &all_collection_refs,
OSTREE_REPO_LIST_REFS_EXT_EXCLUDE_REMOTES,
cancellable, error))
return FALSE;
g_hash_table_iter_init (&hash_iter, all_collection_refs);
while (g_hash_table_iter_next (&hash_iter, &key, &value))
{
const OstreeCollectionRef *ref = key;
if (!fsck_commit_for_ref (repo, value, ref->collection_id, ref->ref_name,
&found_corruption, cancellable, error))
return FALSE;
}
if (!opt_quiet)
g_print ("Enumerating objects...\n");
g_autoptr(GHashTable) objects = NULL;
if (!ostree_repo_list_objects (repo, OSTREE_REPO_LIST_OBJECTS_ALL,
&objects, cancellable, error))
return FALSE;
g_autoptr(GHashTable) commits = g_hash_table_new_full (ostree_hash_object_name, g_variant_equal,
(GDestroyNotify)g_variant_unref, NULL);
g_autoptr(GPtrArray) tombstones = NULL;
if (opt_add_tombstones)
tombstones = g_ptr_array_new_with_free_func (g_free);
if (opt_verify_back_refs)
opt_verify_bindings = TRUE;
guint n_partial = 0;
g_hash_table_iter_init (&hash_iter, objects);
while (g_hash_table_iter_next (&hash_iter, &key, &value))
{
GVariant *serialized_key = key;
const char *checksum;
OstreeObjectType objtype;
OstreeRepoCommitState commitstate = 0;
g_autoptr(GVariant) commit = NULL;
ostree_object_name_deserialize (serialized_key, &checksum, &objtype);
if (objtype == OSTREE_OBJECT_TYPE_COMMIT)
{
if (!ostree_repo_load_commit (repo, checksum, &commit, &commitstate, error))
return FALSE;
/* If requested, check that all the refs listed in the ref-bindings
* for this commit resolve back to this commit. */
if (opt_verify_back_refs)
{
g_autoptr(GVariant) metadata = g_variant_get_child_value (commit, 0);
const char *collection_id = NULL;
if (!g_variant_lookup (metadata,
OSTREE_COMMIT_META_KEY_COLLECTION_BINDING,
"&s",
&collection_id))
collection_id = NULL;
g_autofree const char **refs = NULL;
if (g_variant_lookup (metadata,
OSTREE_COMMIT_META_KEY_REF_BINDING,
"^a&s",
&refs))
{
for (const char **iter = refs; *iter != NULL; ++iter)
{
g_autofree char *checksum_for_ref = NULL;
if (collection_id != NULL)
{
const OstreeCollectionRef collection_ref = { (char *) collection_id, (char *) *iter };
if (!ostree_repo_resolve_collection_ref (repo, &collection_ref,
TRUE,
OSTREE_REPO_RESOLVE_REV_EXT_NONE,
&checksum_for_ref,
cancellable,
error))
return FALSE;
}
else
{
if (!ostree_repo_resolve_rev (repo, *iter, TRUE,
&checksum_for_ref, error))
return FALSE;
}
if (checksum_for_ref == NULL)
{
if (collection_id != NULL)
return glnx_throw (error,
"Collection–ref (%s, %s) in bindings for commit %s does not exist",
collection_id, *iter, checksum);
else
return glnx_throw (error,
"Ref ‘%s’ in bindings for commit %s does not exist",
*iter, checksum);
}
else if (g_strcmp0 (checksum_for_ref, checksum) != 0)
{
if (collection_id != NULL)
return glnx_throw (error,
"Collection–ref (%s, %s) in bindings for commit %s does not resolve to that commit",
collection_id, *iter, checksum);
else
return glnx_throw (error,
"Ref ‘%s’ in bindings for commit %s does not resolve to that commit",
*iter, checksum);
}
}
}
}
if (opt_add_tombstones)
{
GError *local_error = NULL;
g_autofree char *parent = ostree_commit_get_parent (commit);
if (parent)
{
g_autoptr(GVariant) parent_commit = NULL;
if (!ostree_repo_load_variant (repo, OSTREE_OBJECT_TYPE_COMMIT, parent,
&parent_commit, &local_error))
{
if (g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
{
g_ptr_array_add (tombstones, g_strdup (checksum));
g_clear_error (&local_error);
}
else
{
g_propagate_error (error, local_error);
return FALSE;
}
}
}
}
if (commitstate & OSTREE_REPO_COMMIT_STATE_PARTIAL)
n_partial++;
else
g_hash_table_add (commits, g_variant_ref (serialized_key));
}
}
g_clear_pointer (&objects, (GDestroyNotify) g_hash_table_unref);
if (!opt_quiet)
g_print ("Verifying content integrity of %u commit objects...\n",
(guint)g_hash_table_size (commits));
if (!fsck_reachable_objects_from_commits (repo, commits, &found_corruption,
cancellable, error))
return FALSE;
if (opt_add_tombstones)
{
guint i;
if (tombstones->len)
{
if (!ot_enable_tombstone_commits (repo, error))
return FALSE;
}
for (i = 0; i < tombstones->len; i++)
{
const char *checksum = tombstones->pdata[i];
g_print ("Adding tombstone for commit %s\n", checksum);
if (!ostree_repo_delete_object (repo, OSTREE_OBJECT_TYPE_COMMIT, checksum, cancellable, error))
return FALSE;
}
}
else if (n_partial > 0)
{
g_print ("%u partial commits not verified\n", n_partial);
}
if (found_corruption)
return glnx_throw (error, "Repository corruption encountered");
return TRUE;
}
static void
allservice_check_start_HT(struct namespace_data_s *ns_data, GHashTable *ht)
{
gsize offset;
struct taskdata_checksrv_s td_scheme;
GHashTableIter iter_serv;
gpointer k, v;
g_hash_table_iter_init(&iter_serv, ht);
while (g_hash_table_iter_next(&iter_serv, &k, &v)) {
struct service_info_s *si = v;
gboolean srv_check_enabled = TRUE;
/* Services can disable TCP checks (enabled by default) */
service_tag_t *tag = service_info_get_tag(si->tags,
NAME_TAGNAME_AGENT_CHECK);
if (tag) {
GError *err = NULL;
if (tag->type == STVT_BOOL) {
service_tag_get_value_boolean(tag, &srv_check_enabled, &err);
} else {
gchar buf[64] = {0};
service_tag_get_value_string(tag, buf, sizeof(buf), &err);
srv_check_enabled = metautils_cfg_get_bool(buf, TRUE);
}
g_clear_error(&err);
}
memset(&td_scheme, 0x00, sizeof(td_scheme));
offset = g_snprintf(td_scheme.task_name, sizeof(td_scheme.task_name), "%s.", TASK_ID);
addr_info_to_string(&(si->addr), td_scheme.task_name+offset, sizeof(td_scheme.task_name)-offset);
g_strlcpy(td_scheme.ns_name, ns_data->name, sizeof(td_scheme.ns_name)-1);
if (!srv_check_enabled) {
GRID_DEBUG("Task [%s] disabled by "
NAME_TAGNAME_AGENT_CHECK, td_scheme.task_name);
} else if (!is_task_scheduled(td_scheme.task_name)) {
GError *error_local = NULL;
task_t *task = NULL;
struct taskdata_checksrv_s *task_data;
agent_get_service_key(si, td_scheme.srv_key, sizeof(td_scheme.srv_key));
g_strlcpy(td_scheme.srv_key, (gchar*)k, sizeof(td_scheme.srv_key)-1);
/* prepare the task structure */
task_data = g_memdup(&td_scheme, sizeof(td_scheme));
if (!task_data) {
ERROR("Memory allocation failure");
continue;
}
task = create_task(period_check_services, td_scheme.task_name);
task = set_task_callbacks(task, _check_tcp_service_task,
g_free, task_data);
if (!task) {
ERROR("Memory allocation failure");
continue;
}
/* now start the task! */
if (add_task_to_schedule(task, &error_local))
INFO("Task started: %s", td_scheme.task_name);
else {
ERROR("Failed to add task to scheduler [%s] : %s", td_scheme.task_name, gerror_get_message(error_local));
g_free(task);
}
if (error_local)
g_clear_error(&error_local);
}
}
}
static void
_detect_obsolete_services(struct namespace_data_s *ns_data)
{
guint counter;
time_t time_now, time_down, time_broken;
GHashTableIter s_iterator;
gpointer s_k, s_v;
gchar *str_key;
struct service_info_s *si;
time_now = g_get_real_time()/1000000;
time_down = time_now - 5;
time_broken = time_now - 30;
counter = 0;
if (!ns_data->configured) {
return;
}
/*move services from UP to DOWN */
g_hash_table_iter_init(&s_iterator, ns_data->local_services);
while (g_hash_table_iter_next(&s_iterator, &s_k, &s_v)) {
str_key = s_k;
si = s_v;
si->score.value = -2;/*score not set*/
if (si->score.timestamp < time_down) {
gchar str_addr[STRLEN_ADDRINFO];
addr_info_to_string(&(si->addr),str_addr,sizeof(str_addr));
DEBUG("Timeout on service [%s/%s/%s] (%"G_GINT32_FORMAT" < %ld) --> DOWN",
si->ns_name, si->type, str_addr, si->score.timestamp, time_down);
g_hash_table_iter_steal(&s_iterator);
g_hash_table_insert(ns_data->down_services, str_key, si);
invalidate_conscience_service(ns_data,si);
zero_service_stats(si->tags);
service_tag_set_value_boolean(service_info_ensure_tag(si->tags,"tag.up"), FALSE);
counter++;
}
}
/*remove services DOWN from a long time ago */
g_hash_table_iter_init(&s_iterator, ns_data->down_services);
while (g_hash_table_iter_next(&s_iterator, &s_k, &s_v)) {
str_key = s_k;
si = s_v;
si->score.value = -2;/*score not set*/
if (si->score.timestamp < time_broken) {
gchar str_addr[STRLEN_ADDRINFO];
addr_info_to_string(&(si->addr),str_addr,sizeof(str_addr));
DEBUG("Service obsolete [%s/%s/%s] --> DELETED", si->ns_name, si->type, str_addr);
g_hash_table_iter_remove(&s_iterator);
counter++;
}
else
zero_service_stats(si->tags);
}
if (counter)
DEBUG("[task_id=%s] %u services states have changed", TASK_ID, counter);
}
static void
contact_widget_location_update (EmpathyContactWidget *information)
{
GHashTable *location;
GValue *value;
gdouble lat = 0.0, lon = 0.0;
gboolean has_position = TRUE;
GtkWidget *label;
guint row = 0;
GHashTableIter iter;
gpointer key, pvalue;
if (!(information->flags & EMPATHY_CONTACT_WIDGET_SHOW_LOCATION))
{
gtk_widget_hide (information->vbox_location);
return;
}
location = empathy_contact_get_location (information->contact);
if (location == NULL || g_hash_table_size (location) == 0)
{
gtk_widget_hide (information->vbox_location);
return;
}
value = g_hash_table_lookup (location, EMPATHY_LOCATION_LAT);
if (value == NULL)
has_position = FALSE;
else
lat = g_value_get_double (value);
value = g_hash_table_lookup (location, EMPATHY_LOCATION_LON);
if (value == NULL)
has_position = FALSE;
else
lon = g_value_get_double (value);
value = g_hash_table_lookup (location, EMPATHY_LOCATION_TIMESTAMP);
if (value == NULL)
gtk_label_set_markup (GTK_LABEL (information->label_location), _("<b>Location</b>"));
else
{
gchar *user_date;
gchar *text;
gint64 stamp;
time_t time;
stamp = g_value_get_int64 (value);
time = stamp;
user_date = empathy_time_to_string_relative (time);
text = g_strconcat ( _("<b>Location</b>, "), user_date, NULL);
gtk_label_set_markup (GTK_LABEL (information->label_location), text);
g_free (text);
}
/* Prepare the location information table */
if (information->table_location != NULL)
{
gtk_widget_destroy (information->table_location);
}
information->table_location = gtk_table_new (1, 2, FALSE);
gtk_box_pack_start (GTK_BOX (information->subvbox_location),
information->table_location, FALSE, FALSE, 5);
g_hash_table_iter_init (&iter, location);
while (g_hash_table_iter_next (&iter, &key, &pvalue))
{
const gchar *skey;
const gchar* user_label;
GValue *gvalue;
char *svalue = NULL;
skey = (const gchar *) key;
user_label = location_key_to_label (skey);
gvalue = (GValue *) pvalue;
label = gtk_label_new (user_label);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_table_attach (GTK_TABLE (information->table_location),
label, 0, 1, row, row + 1, GTK_FILL, GTK_FILL, 10, 0);
gtk_widget_show (label);
if (G_VALUE_TYPE (gvalue) == G_TYPE_DOUBLE)
{
gdouble dvalue;
dvalue = g_value_get_double (gvalue);
svalue = g_strdup_printf ("%f", dvalue);
}
else if (G_VALUE_TYPE (gvalue) == G_TYPE_STRING)
{
svalue = g_value_dup_string (gvalue);
}
else if (G_VALUE_TYPE (gvalue) == G_TYPE_INT64)
{
time_t time;
time = g_value_get_int64 (value);
svalue = empathy_time_to_string_utc (time, _("%B %e, %Y at %R UTC"));
}
if (svalue != NULL)
{
label = gtk_label_new (svalue);
gtk_table_attach_defaults (GTK_TABLE (information->table_location),
label, 1, 2, row, row + 1);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
gtk_widget_show (label);
}
g_free (svalue);
row++;
}
gtk_widget_show (information->table_location);
#if HAVE_LIBCHAMPLAIN
/* Cannot be displayed in tooltips until Clutter-Gtk can deal with such
* windows
*/
if (has_position &&
!(information->flags & EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP))
{
ClutterActor *marker;
ChamplainLayer *layer;
information->map_view_embed = gtk_champlain_embed_new ();
information->map_view = gtk_champlain_embed_get_view (
GTK_CHAMPLAIN_EMBED (information->map_view_embed));
gtk_container_add (GTK_CONTAINER (information->viewport_map),
information->map_view_embed);
g_object_set (G_OBJECT (information->map_view), "show-license", FALSE,
"scroll-mode", CHAMPLAIN_SCROLL_MODE_KINETIC,
NULL);
layer = champlain_layer_new ();
champlain_view_add_layer (information->map_view, layer);
marker = champlain_marker_new_with_text (
empathy_contact_get_name (information->contact), NULL, NULL, NULL);
champlain_base_marker_set_position (CHAMPLAIN_BASE_MARKER (marker), lat, lon);
clutter_container_add (CLUTTER_CONTAINER (layer), marker, NULL);
champlain_view_center_on (information->map_view, lat, lon);
gtk_widget_show_all (information->viewport_map);
}
#endif
gtk_widget_show (information->vbox_location);
}
static void
on_apps_tree_changed_cb (GMenuTree *tree,
gpointer user_data)
{
ShellAppSystem *self = SHELL_APP_SYSTEM (user_data);
GError *error = NULL;
GHashTable *new_apps;
GHashTableIter iter;
gpointer key, value;
GSList *removed_apps = NULL;
GSList *removed_node;
g_assert (tree == self->priv->apps_tree);
g_hash_table_remove_all (self->priv->visible_id_to_app);
g_slist_free_full (self->priv->known_vendor_prefixes, g_free);
self->priv->known_vendor_prefixes = NULL;
if (!gmenu_tree_load_sync (self->priv->apps_tree, &error))
{
if (error)
{
g_warning ("Failed to load apps: %s", error->message);
g_error_free (error);
}
else
{
g_warning ("Failed to load apps");
}
return;
}
new_apps = get_flattened_entries_from_tree (self->priv->apps_tree);
g_hash_table_iter_init (&iter, new_apps);
while (g_hash_table_iter_next (&iter, &key, &value))
{
const char *id = key;
GMenuTreeEntry *entry = value;
GMenuTreeEntry *old_entry;
char *prefix;
ShellApp *app;
prefix = get_prefix_for_entry (entry);
if (prefix != NULL
&& !g_slist_find_custom (self->priv->known_vendor_prefixes, prefix,
(GCompareFunc)g_strcmp0))
self->priv->known_vendor_prefixes = g_slist_append (self->priv->known_vendor_prefixes,
prefix);
else
g_free (prefix);
app = g_hash_table_lookup (self->priv->id_to_app, id);
if (app != NULL)
{
/* We hold a reference to the original entry temporarily,
* because otherwise the hash table would be referencing
* potentially free'd memory until we replace it below with
* the new data.
*/
old_entry = shell_app_get_tree_entry (app);
gmenu_tree_item_ref (old_entry);
_shell_app_set_entry (app, entry);
g_object_ref (app); /* Extra ref, removed in _replace below */
}
else
{
old_entry = NULL;
app = _shell_app_new (entry);
}
/* Note that "id" is owned by app->entry. Since we're always
* setting a new entry, even if the app already exists in the
* hash table we need to replace the key so that the new id
* string is pointed to.
*/
g_hash_table_replace (self->priv->id_to_app, (char*)id, app);
if (!gmenu_tree_entry_get_is_nodisplay_recurse (entry))
g_hash_table_replace (self->priv->visible_id_to_app, (char*)id, app);
if (old_entry)
gmenu_tree_item_unref (old_entry);
}
/* Now iterate over the apps again; we need to unreference any apps
* which have been removed. The JS code may still be holding a
* reference; that's fine.
*/
g_hash_table_iter_init (&iter, self->priv->id_to_app);
while (g_hash_table_iter_next (&iter, &key, &value))
{
const char *id = key;
if (!g_hash_table_lookup (new_apps, id))
removed_apps = g_slist_prepend (removed_apps, (char*)id);
}
for (removed_node = removed_apps; removed_node; removed_node = removed_node->next)
{
const char *id = removed_node->data;
g_hash_table_remove (self->priv->id_to_app, id);
}
g_slist_free (removed_apps);
g_hash_table_destroy (new_apps);
g_signal_emit (self, signals[INSTALLED_CHANGED], 0);
}
static void
init (NMSettingsPlugin *config)
{
SettingsPluginIfupdown *self = SETTINGS_PLUGIN_IFUPDOWN (config);
SettingsPluginIfupdownPrivate *priv = SETTINGS_PLUGIN_IFUPDOWN_GET_PRIVATE (self);
GHashTable *auto_ifaces;
if_block *block = NULL;
GList *keys, *iter;
GHashTableIter con_iter;
const char *block_name;
NMIfupdownConnection *connection;
const char *subsys[2] = { "net", NULL };
auto_ifaces = g_hash_table_new (g_str_hash, g_str_equal);
if(!priv->connections)
priv->connections = g_hash_table_new (g_str_hash, g_str_equal);
if(!priv->kernel_ifaces)
priv->kernel_ifaces = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
if(!priv->eni_ifaces)
priv->eni_ifaces = g_hash_table_new (g_str_hash, g_str_equal);
nm_log_info (LOGD_SETTINGS, "init!");
priv->client = g_udev_client_new (subsys);
if (!priv->client) {
nm_log_warn (LOGD_SETTINGS, " error initializing libgudev");
} else
g_signal_connect (priv->client, "uevent", G_CALLBACK (handle_uevent), self);
/* Read in all the interfaces */
ifparser_init (ENI_INTERFACES_FILE, 0);
block = ifparser_getfirst ();
while (block) {
if(!strcmp ("auto", block->type) || !strcmp ("allow-hotplug", block->type))
g_hash_table_insert (auto_ifaces, block->name, GUINT_TO_POINTER (1));
else if (!strcmp ("iface", block->type)) {
NMIfupdownConnection *exported;
/* Bridge configuration */
if(!strncmp ("br", block->name, 2)) {
/* Try to find bridge ports */
const char *ports = ifparser_getkey (block, "bridge-ports");
if (ports) {
int i;
int state = 0;
char **port_ifaces;
nm_log_info (LOGD_SETTINGS, "found bridge ports %s for %s", ports, block->name);
port_ifaces = g_strsplit_set (ports, " \t", -1);
for (i = 0; i < g_strv_length (port_ifaces); i++) {
char *token = port_ifaces[i];
/* Skip crazy stuff like regex or all */
if (!strcmp ("all", token)) {
continue;
}
/* Small SM to skip everything inside regex */
if (!strcmp ("regex", token)) {
state++;
continue;
}
if (!strcmp ("noregex", token)) {
state--;
continue;
}
if (state == 0 && strlen (token) > 0) {
nm_log_info (LOGD_SETTINGS, "adding bridge port %s to eni_ifaces", token);
g_hash_table_insert (priv->eni_ifaces, g_strdup (token), "known");
}
}
g_strfreev (port_ifaces);
}
goto next;
}
/* Skip loopback configuration */
if(!strcmp ("lo", block->name)) {
goto next;
}
/* Remove any connection for this block that was previously found */
exported = g_hash_table_lookup (priv->connections, block->name);
if (exported) {
nm_log_info (LOGD_SETTINGS, "deleting %s from connections", block->name);
nm_settings_connection_delete (NM_SETTINGS_CONNECTION (exported), NULL, NULL);
g_hash_table_remove (priv->connections, block->name);
}
/* add the new connection */
exported = nm_ifupdown_connection_new (block);
if (exported) {
nm_log_info (LOGD_SETTINGS, "adding %s to connections", block->name);
g_hash_table_insert (priv->connections, block->name, exported);
}
nm_log_info (LOGD_SETTINGS, "adding iface %s to eni_ifaces", block->name);
g_hash_table_insert (priv->eni_ifaces, block->name, "known");
} else if (!strcmp ("mapping", block->type)) {
g_hash_table_insert (priv->eni_ifaces, block->name, "known");
nm_log_info (LOGD_SETTINGS, "adding mapping %s to eni_ifaces", block->name);
}
next:
block = block->next;
}
/* Make 'auto' interfaces autoconnect=TRUE */
g_hash_table_iter_init (&con_iter, priv->connections);
while (g_hash_table_iter_next (&con_iter, (gpointer) &block_name, (gpointer) &connection)) {
NMSettingConnection *setting;
if (g_hash_table_lookup (auto_ifaces, block_name)) {
setting = nm_connection_get_setting_connection (NM_CONNECTION (connection));
g_object_set (setting, NM_SETTING_CONNECTION_AUTOCONNECT, TRUE, NULL);
nm_log_info (LOGD_SETTINGS, "autoconnect");
}
}
g_hash_table_destroy (auto_ifaces);
/* Check the config file to find out whether to manage interfaces */
priv->unmanage_well_known = !nm_config_data_get_value_boolean (NM_CONFIG_GET_DATA_ORIG,
NM_CONFIG_KEYFILE_GROUP_IFUPDOWN,
NM_CONFIG_KEYFILE_KEY_IFUPDOWN_MANAGED,
!IFUPDOWN_UNMANAGE_WELL_KNOWN_DEFAULT);
nm_log_info (LOGD_SETTINGS, "management mode: %s", priv->unmanage_well_known ? "unmanaged" : "managed");
/* Add well-known interfaces */
keys = g_udev_client_query_by_subsystem (priv->client, "net");
for (iter = keys; iter; iter = g_list_next (iter)) {
udev_device_added (self, G_UDEV_DEVICE (iter->data));
g_object_unref (G_UDEV_DEVICE (iter->data));
}
g_list_free (keys);
/* Now if we're running in managed mode, let NM know there are new connections */
if (!priv->unmanage_well_known) {
GList *con_list = g_hash_table_get_values (priv->connections);
GList *cl_iter;
for (cl_iter = con_list; cl_iter; cl_iter = g_list_next (cl_iter)) {
g_signal_emit_by_name (self,
NM_SETTINGS_PLUGIN_CONNECTION_ADDED,
NM_SETTINGS_CONNECTION (cl_iter->data));
}
g_list_free (con_list);
}
nm_log_info (LOGD_SETTINGS, "end _init.");
}