コード例 #1
0
ファイル: gnc-gobject-utils.c プロジェクト: Gnucash/gnucash
static gboolean
gnc_gobject_tracking_forget_internal (GObject *object)
{
    GHashTable *table;
    GList *list, *item;
    const gchar *name;

    g_return_val_if_fail(G_IS_OBJECT(object), FALSE);

    name = G_OBJECT_TYPE_NAME(object);
    //printf("Enter %s: object %p of type %s\n", G_STRFUNC, object, name);
    table = gnc_gobject_tracking_table();
    list = g_hash_table_lookup(table, name);
    if (!list)
    {
        //printf("Leave %s: list for %s objects not found.\n", G_STRFUNC, name);
        return FALSE;
    }

    item = g_list_find(list, object);
    if (!item)
    {
        //printf("Leave %s: object %p not in %s object list.\n", G_STRFUNC,
        //       object, name);
        return FALSE;
    }

    list = g_list_remove_link(list, item);
    if (list)
    {
        g_hash_table_replace(table, g_strdup(name), list);
        //printf("Leave %s: object removed.\n", G_STRFUNC);
    }
    else
    {
        g_hash_table_remove(table, name);
        //printf("Leave %s: object and list removed.\n", G_STRFUNC);
    }
    return TRUE;
}
コード例 #2
0
ファイル: treemerge.c プロジェクト: arthurtiteica/rmlint
void rm_tm_feed(RmTreeMerger *self, RmFile *file) {
    RM_DEFINE_PATH(file);
    char *dirname = g_path_get_dirname(file_path);

    /* See if we know that directory already */
    RmDirectory *directory = rm_trie_search(&self->dir_tree, dirname);

    if(directory == NULL) {
        /* Get the actual file count */
        int file_count = GPOINTER_TO_INT(rm_trie_search(&self->count_tree, dirname));
        if(file_count == 0) {
            rm_log_error(
                RED "Empty directory or weird RmFile encountered; rejecting.\n" RESET);
            file_count = -1;
        }

        directory = rm_directory_new(dirname);
        directory->file_count = file_count;

        /* Make the new directory known */
        rm_trie_insert(&self->dir_tree, dirname, directory);

        g_queue_push_head(&self->valid_dirs, directory);
    } else {
        g_free(dirname);
    }

    rm_directory_add(directory, file);

    /* Add the file to this directory */
    g_queue_push_head(&directory->known_files, file);

    /* Remember the digest (if only to free it later...) */
    g_hash_table_replace(self->known_hashs, file->digest, NULL);

    /* Check if the directory reached the number of actual files in it */
    if(directory->dupe_count == directory->file_count && directory->file_count > 0) {
        rm_tm_insert_dir(self, directory);
    }
}
コード例 #3
0
ファイル: cockpitwebserver.c プロジェクト: Legun/cockpit
gboolean
cockpit_web_server_parse_cookies (GHashTable *headers,
                                  GHashTable **out_cookies,
                                  GError **error)
{
  gboolean ret = FALSE;
  GHashTableIter hash_iter;
  const gchar *key;
  const gchar *value;
  gs_unref_hashtable GHashTable *ret_cookies = NULL;

  ret_cookies = cockpit_web_server_new_table ();

  g_hash_table_iter_init (&hash_iter, headers);
  while (g_hash_table_iter_next (&hash_iter, (gpointer)&key, (gpointer)&value))
    {
      if (g_ascii_strcasecmp (key, "Cookie") == 0)
        {
          gs_strfreev gchar** elements = NULL;
          guint n;
          elements = g_strsplit (value, ";", 0);
          for (n = 0; elements[n] != NULL; n++)
            {
              gchar *cookie_name;
              gchar *cookie_value;
              g_strstrip(elements[n]);
              if (!parse_cookie_pair (elements[n], &cookie_name, &cookie_value, error))
		goto out;
              /* adopt strings */
              g_hash_table_replace (ret_cookies, cookie_name, cookie_value);
            }
        }
    }

  ret = TRUE;
  *out_cookies = ret_cookies;
  ret_cookies = NULL;
out:
  return ret;
}
コード例 #4
0
static gboolean
location_gps_nmea_take_trace (MMLocationGpsNmea *self,
                              gchar *trace)
{
    gchar *i;
    gchar *trace_type;

    i = strchr (trace, ',');
    if (!i || i == trace)
        return FALSE;

    trace_type = g_malloc (i - trace + 1);
    memcpy (trace_type, trace, i - trace);
    trace_type[i - trace] = '\0';

    /* Some traces are part of a SEQUENCE; so we need to decide whether we
     * completely replace the previous trace, or we append the new one to
     * the already existing list */
    if (check_append_or_replace (self, trace)) {
        /* Append */
        const gchar *previous;

        previous = g_hash_table_lookup (self->priv->traces, trace_type);
        if (previous) {
            gchar *sequence;

            sequence = g_strdup_printf ("%s%s%s",
                                        previous,
                                        g_str_has_suffix (previous, "\r\n") ? "" : "\r\n",
                                        trace);
            g_free (trace);
            trace = sequence;
        }
    }

    g_hash_table_replace (self->priv->traces,
                          trace_type,
                          trace);
    return TRUE;
}
コード例 #5
0
ファイル: gaym.c プロジェクト: BackupTheBerlios/qrc-svn
static void gaym_chat_join(GaimConnection * gc, GHashTable * data)
{
    struct gaym_conn *gaym = gc->proto_data;
    const char *args[1];
    char *alias = NULL;

    GaimChat *c = NULL;

    /**
     * need a copy, because data gets
     * destroyed in roomlist.c
     */
    GHashTable *chatinfo = NULL;

    args[0] = g_hash_table_lookup(data, "channel");

    if (args[0]) {
        alias = g_hash_table_lookup(data, "description");
        c = gaim_blist_find_chat(gaim_connection_get_account(gc), args[0]);
        if (!c) {
            chatinfo = g_hash_table_new(g_str_hash, g_str_equal);

            g_hash_table_replace(chatinfo, "channel", g_strdup(args[0]));

            c = gaim_chat_new(gaim_connection_get_account(gc),
                              alias, chatinfo);

            gaim_blist_add_chat(c, NULL, NULL);
        }
    }

    if (!args[0] || *args[0] != '#') {
        /**
         * Trigger a room search in config.txt....
         */
        return;
    }

    gaym_cmd_join(gaym, "join", NULL, args);
}
コード例 #6
0
ファイル: container.c プロジェクト: beekhof/pacemaker
void
container_expand(resource_t * rsc, pe_working_set_t * data_set)
{
    container_variant_data_t *container_data = NULL;

    CRM_CHECK(rsc != NULL, return);

    get_container_variant_data(container_data, rsc);

    if(container_data->child) {
        container_data->child->cmds->expand(container_data->child, data_set);
    }

    for (GListPtr gIter = container_data->tuples; gIter != NULL; gIter = gIter->next) {
        container_grouping_t *tuple = (container_grouping_t *)gIter->data;

        CRM_ASSERT(tuple);
        if (tuple->remote && tuple->docker && container_fix_remote_addr(tuple->remote)) {
            // REMOTE_CONTAINER_HACK: Allow remote nodes that start containers with pacemaker remote inside
            xmlNode *nvpair = get_xpath_object("//nvpair[@name='addr']", tuple->remote->xml, LOG_ERR);
            const char *calculated_addr = container_fix_remote_addr_in(tuple->remote, nvpair, "value");

            if (calculated_addr) {
                crm_trace("Fixed addr for %s on %s", tuple->remote->id, calculated_addr);
                g_hash_table_replace(tuple->remote->parameters, strdup("addr"), strdup(calculated_addr));
            } else {
                crm_err("Could not fix addr for %s", tuple->remote->id);
            }
        }
        if(tuple->ip) {
            tuple->ip->cmds->expand(tuple->ip, data_set);
        }
        if(tuple->docker) {
            tuple->docker->cmds->expand(tuple->docker, data_set);
        }
        if(tuple->remote) {
            tuple->remote->cmds->expand(tuple->remote, data_set);
        }
    }
}
コード例 #7
0
ファイル: glibht.c プロジェクト: AllenYang0308/goaccess
/* process host agent strings */
int
process_host_agents (char *host, char *agent)
{
  char *ptr_value, *tmp, *a;
  GHashTable *ht = ht_hosts_agents;
  gpointer value_ptr;
  size_t len1, len2;

  if ((ht == NULL) || (host == NULL) || (agent == NULL))
    return (EINVAL);

  a = xstrdup (agent);

  value_ptr = g_hash_table_lookup (ht, host);
  if (value_ptr != NULL) {
    ptr_value = (char *) value_ptr;
    if (strstr (ptr_value, a)) {
      if (a != NULL)
        free (a);
      return 0;
    }

    len1 = strlen (ptr_value);
    len2 = strlen (a);

    tmp = xmalloc (len1 + len2 + 2);
    memcpy (tmp, ptr_value, len1);
    tmp[len1] = '|';
    /*
     * NUL-terminated
     */
    memcpy (tmp + len1 + 1, a, len2 + 1);
  } else
    tmp = alloc_string (a);

  g_hash_table_replace (ht, g_strdup (host), tmp);
  if (a != NULL)
    free (a);
  return 0;
}
コード例 #8
0
ファイル: log.c プロジェクト: dotoole/profanity
void
groupchat_log_chat(const gchar * const login, const gchar * const room,
    const gchar * const nick, const gchar * const msg)
{
    gchar *room_copy = strdup(room);
    struct dated_chat_log *dated_log = g_hash_table_lookup(groupchat_logs, room_copy);

    // no log for room
    if (dated_log == NULL) {
        dated_log = _create_groupchat_log(room_copy, login);
        g_hash_table_insert(groupchat_logs, room_copy, dated_log);

    // log exists but needs rolling
    } else if (_log_roll_needed(dated_log)) {
        dated_log = _create_groupchat_log(room_copy, login);
        g_hash_table_replace(logs, room_copy, dated_log);
    }

    GDateTime *dt = g_date_time_new_now_local();

    gchar *date_fmt = g_date_time_format(dt, "%H:%M:%S");

    FILE *logp = fopen(dated_log->filename, "a");
    if (logp != NULL) {
        if (strncmp(msg, "/me ", 4) == 0) {
            fprintf(logp, "%s - *%s %s\n", date_fmt, nick, msg + 4);
        } else {
            fprintf(logp, "%s - %s: %s\n", date_fmt, nick, msg);
        }

        fflush(logp);
        int result = fclose(logp);
        if (result == EOF) {
            log_error("Error closing file %s, errno = %d", dated_log->filename, errno);
        }
    }

    g_free(date_fmt);
    g_date_time_unref(dt);
}
コード例 #9
0
/* utility routine to allocate a hash table and load it with the appropriate 
 * name mapping data from the browser xml file 
 */
static void
load_name_map_hash_table (NautilusCustomizationData *data)
{
	char *xml_path;
	char *filename, *display_name;

	xmlDocPtr browser_data;
	xmlNodePtr category_node, current_node;
	
	/* allocate the hash table */
	data->name_map_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
	
	/* build the path name to the browser.xml file and load it */
	xml_path = g_build_filename (NAUTILUS_DATADIR, "browser.xml", NULL);
	if (xml_path) {
		browser_data = xmlParseFile (xml_path);
		g_free (xml_path);

		if (browser_data) {
			/* get the category node */
			category_node = eel_xml_get_root_child_by_name_and_property (browser_data, "category", "name", data->customization_name);
			current_node = category_node->children;	
			
			/* loop through the entries, adding a mapping to the hash table */
			while (current_node != NULL) {
				display_name = eel_xml_get_property_translated (current_node, "display_name");
				filename = xmlGetProp (current_node, "filename");
				if (display_name && filename) {
					g_hash_table_replace (data->name_map_hash, g_strdup (filename), g_strdup (display_name));
				}
				xmlFree (filename);		
				xmlFree (display_name);
				current_node = current_node->next;
			}
			
			/* close the xml file */
			xmlFreeDoc (browser_data);
		}		
	}	
}
コード例 #10
0
static void
dir_changed_cb (GFileMonitor *monitor,
		GFile *file,
		GFile *other_file,
		GFileMonitorEvent event,
		EphyGreasemonkeyExtension *extension)
{
	char *uri;
	char *path;
	char *basename;
	GreasemonkeyScript *script;

	uri = g_file_get_uri (file);
	path = g_file_get_path (file);
	LOG ("Activity on %s", uri);

	if (g_str_has_suffix (uri, ".user.js") == FALSE) return;

	basename = g_file_get_basename (file);

	switch (event)
	{
		case G_FILE_MONITOR_EVENT_CREATED:
		case G_FILE_MONITOR_EVENT_CHANGED:
			script = greasemonkey_script_new (path);
			g_hash_table_replace (extension->priv->scripts,
					      g_strdup (basename), script);
			break;
		case G_FILE_MONITOR_EVENT_DELETED:
			g_hash_table_remove (extension->priv->scripts,
					     basename);
			break;
		default:
			break;
	}

	g_free (basename);
	g_free (uri);
	g_free (path);
}
コード例 #11
0
static void _simpletcp_activateServer(SimpleTCP* h, int sd, uint32_t events) 
{
	struct epoll_event ev;
	
	if(events & EPOLLOUT)
		h->shdlib->log(SHADOW_LOG_LEVEL_DEBUG, __FUNCTION__, 
			"EPOLLOUT is set");
	if(events & EPOLLIN) 
		h->shdlib->log(SHADOW_LOG_LEVEL_DEBUG, __FUNCTION__, 
			"EPOLLIN is set");

	if(sd == h->server.sd) {
		/* data on a listening socket means a new client connection */
		assert(events & EPOLLIN);

		/* accept new connection from a remote client */
		int newClientSD = accept(sd, NULL, NULL);
		gint *sd_key;
		struct timeval *conn_time;

		h->shdlib->log(SHADOW_LOG_LEVEL_DEBUG, __FUNCTION__, 
			"ACCEPT: %s", strerror(errno));
		
		/* We have to store the connection time.
		 * We do this using a hashtable. */
		sd_key = g_new0(gint, 1);
		conn_time = g_new0(struct timeval, 1);
		
		*sd_key = newClientSD;
		gettimeofday(conn_time, NULL);
		
		g_hash_table_replace(h->server.hashtab, sd_key, conn_time);
		
		/* now register this new socket so we know when its ready */
		memset(&ev, 0, sizeof(struct epoll_event));
		ev.events = EPOLLIN;
		ev.data.fd = newClientSD;
		epoll_ctl(h->ed, EPOLL_CTL_ADD, newClientSD, &ev);
	} else {
コード例 #12
0
ファイル: urf-device-ofono.c プロジェクト: kaijanmaki/urfkill
static void
modem_signal_cb (GDBusProxy *proxy,
                 gchar *sender_name,
                 gchar *signal_name,
                 GVariant *parameters,
                 gpointer user_data)
{
	UrfDeviceOfono *modem = URF_DEVICE_OFONO (user_data);
	UrfDeviceOfonoPrivate *priv = URF_DEVICE_OFONO_GET_PRIVATE (modem);

	if (g_strcmp0 (signal_name, "PropertyChanged") == 0) {
		gchar *prop_name;
		GVariant *prop_value = NULL;

		g_debug ("properties changed for %s: %s",
		         priv->object_path,
		         g_variant_print (parameters, TRUE));

		g_variant_get_child (parameters, 0, "s", &prop_name);
		g_variant_get_child (parameters, 1, "v", &prop_value);

		if (prop_value)
			g_hash_table_replace (priv->properties,
			                      g_strdup (prop_name),
			                      g_variant_ref (prop_value));

		if (g_strcmp0 ("Powered", prop_name) == 0) {
			gboolean powered = FALSE;

			powered = g_variant_get_boolean (prop_value);

			if (powered)
				set_soft (URF_DEVICE (modem), priv->soft);
		}

		g_free (prop_name);
		g_variant_unref (prop_value);
	}
}
コード例 #13
0
ファイル: provider.c プロジェクト: bq/cervantes-conman
int __connman_provider_append_user_route(struct connman_provider *provider,
			int family, const char *network, const char *netmask)
{
	struct connman_route *route;
	char *key = g_strdup_printf("%d/%s/%s", family, network, netmask);

	DBG("family %d network %s netmask %s", family, network, netmask);

	route = g_hash_table_lookup(provider->user_routes, key);
	if (route == NULL) {
		route = g_try_new0(struct connman_route, 1);
		if (route == NULL) {
			connman_error("out of memory");
			return -ENOMEM;
		}

		route->family = family;
		route->host = g_strdup(network);
		route->netmask = g_strdup(netmask);

		g_hash_table_replace(provider->user_routes, key, route);
	} else
コード例 #14
0
ファイル: main.c プロジェクト: colindean/picocoin
static bool do_setting(const char *arg)
{
    char *key, *value;

    if (!parse_kvstr(arg, &key, &value))
        return false;

    g_hash_table_replace(settings, key, value);

    /*
     * trigger special setting-specific behaviors
     */

    if (!strcmp(key, "config") || !strcmp(key, "c"))
        return read_config_file(value);

    /* clear previous wallet, if new wallet file seen */
    if (!strcmp(key, "wallet") || !strcmp(key, "w"))
        cur_wallet_free();

    return true;
}
コード例 #15
0
ファイル: emoji-parser.c プロジェクト: Archer-sys/ibus
static void
update_emoji_dict (EmojiData *data)
{
    GSList *annotations = data->annotations;
    while (annotations) {
        const gchar *annotation = (const gchar *) annotations->data;
        GSList *emojis = g_hash_table_lookup (data->dict, annotation);
        if (emojis) {
            GSList *duplicated = g_slist_find_custom (emojis,
                                                      data->emoji,
                                                      (GCompareFunc) g_strcmp0);
            if (duplicated != NULL)
                 continue;
            emojis = g_slist_copy_deep (emojis, (GCopyFunc) g_strdup, NULL);
        }
        emojis = g_slist_append (emojis, g_strdup (data->emoji));
        g_hash_table_replace (data->dict,
                              g_strdup (annotation),
                              emojis);
        annotations = annotations->next;
    }
}
コード例 #16
0
ファイル: conf.c プロジェクト: skoobe/riofs
void conf_list_set_string (ConfData *conf, const gchar *full_path, const gchar *val)
{
    ConfNode *conf_node;
    GList *l;

    conf_node = g_hash_table_lookup (conf->h_conf, full_path);
    if (conf_node) {
        l = (GList *) conf_node->value;
        l = g_list_append (l, g_strdup (val));
        conf_node->value = (gpointer) l;
    } else {
        l = NULL;
        l = g_list_append (l, g_strdup (val));

        conf_node = g_new0 (ConfNode, 1);
        conf_node->full_name = g_strdup (full_path);
        conf_node->name = g_strdup (full_path);
        conf_node->type = CT_LIST;
        conf_node->value = l;
        g_hash_table_replace (conf->h_conf, conf_node->full_name, conf_node);
    }
}
コード例 #17
0
static void
search_provider_hits_added (NautilusSearchProvider *provider,
                            GList                  *hits,
                            NautilusSearchEngine   *engine)
{
    NautilusSearchEnginePrivate *priv;
    GList *added = NULL;
    GList *l;

    priv = nautilus_search_engine_get_instance_private (engine);

    if (!priv->running || priv->restart)
    {
        DEBUG ("Ignoring hits-added, since engine is %s",
               !priv->running ? "not running" : "waiting to restart");
        return;
    }

    for (l = hits; l != NULL; l = l->next)
    {
        NautilusSearchHit *hit = l->data;
        int count;
        const char *uri;

        uri = nautilus_search_hit_get_uri (hit);
        count = GPOINTER_TO_INT (g_hash_table_lookup (priv->uris, uri));
        if (count == 0)
        {
            added = g_list_prepend (added, hit);
        }
        g_hash_table_replace (priv->uris, g_strdup (uri), GINT_TO_POINTER (++count));
    }
    if (added != NULL)
    {
        added = g_list_reverse (added);
        nautilus_search_provider_hits_added (NAUTILUS_SEARCH_PROVIDER (engine), added);
        g_list_free (added);
    }
}
コード例 #18
0
ファイル: media.c プロジェクト: adityakamath/ArduHack
static gboolean set_property(struct media_player *mp, const char *key,
							const char *value)
{
	const char *curval;
	GList *settings;

	curval = g_hash_table_lookup(mp->settings, key);
	if (g_strcmp0(curval, value) == 0)
		return TRUE;

	DBG("%s=%s", key, value);

	g_hash_table_replace(mp->settings, g_strdup(key), g_strdup(value));

	settings = list_settings(mp);

	avrcp_player_event(mp->player, AVRCP_EVENT_SETTINGS_CHANGED, settings);

	g_list_free(settings);

	return TRUE;
}
コード例 #19
0
ファイル: dcore.c プロジェクト: choldrim/deepin-installer
void get_enabled_plugins(GSettings* gsettings, char const* key)
{
    char * schema_id = get_schema_id(gsettings);
    char const* id_prefix = NULL;
    if (g_str_has_suffix(schema_id, "desktop")) {
        id_prefix = "desktop:";
    }

    g_free(schema_id);
    g_assert(id_prefix != NULL);

    char** values = g_settings_get_strv(gsettings, key);
    for (int i = 0; values[i] != NULL; ++i) {
        g_hash_table_add(enabled_plugins,
                         g_strconcat(id_prefix, values[i], NULL));
        g_hash_table_replace(plugins_state,
                             g_strconcat(id_prefix, values[i], NULL),
                             GINT_TO_POINTER(ENABLED_PLUGIN));
    }

    g_strfreev(values);
}
コード例 #20
0
ファイル: shd-main.c プロジェクト: desphunter/shadow
static gulong _main_getTLSUsedByProcess(TLSCountingState* state,
        ConfigurationPluginElement* pluginElement, ConfigurationPluginElement* preloadElement) {
    /* figure out how much TLS is used to load both into the same namespace.
     * only do the actual dlmopens once and then cache the result, so that we
     * don't repeat the loads for every host. */

    utility_assert(pluginElement);
    utility_assert(pluginElement->id.isSet && pluginElement->id.string);
    utility_assert(pluginElement->path.isSet && pluginElement->path.string);
    if(preloadElement) {
        utility_assert(preloadElement->id.isSet && preloadElement->id.string);
        utility_assert(preloadElement->path.isSet && preloadElement->path.string);
    }

    /* the id for the cache map is the concatenation of the plugin and preload ids */
    gchar* cacheID = NULL;
    gint result = asprintf(&cacheID, "%s-%s", pluginElement->id.string->str,
            preloadElement ? preloadElement->id.string->str : "NULL");
    if(result < 0) {
        return 0;
    }

    /* first check if we can get the size from the cache */
    gulong* cachedSizePointer = NULL;
    cachedSizePointer = g_hash_table_lookup(state->cachedProcessTLSSize, cacheID);
    if(cachedSizePointer != NULL) {
        /* cache hit, we can avoid doing the dlmopens */
        state->numCacheHits++;
        return *cachedSizePointer;
    } else {
        /* cache miss, do the dlmopens and cache the result */
        state->numCacheMisses++;
        cachedSizePointer = g_new0(gulong, 1);
        *cachedSizePointer = _main_computeProcessLoadSize(pluginElement->path.string->str,
            preloadElement ? preloadElement->path.string->str : NULL);
        g_hash_table_replace(state->cachedProcessTLSSize, cacheID, cachedSizePointer);
        return *cachedSizePointer;
    }
}
コード例 #21
0
void
hippo_data_cache_add_post(HippoDataCache *cache,
                          HippoPost      *post)
{
    HippoChatRoom *room;
    
    g_return_if_fail(hippo_data_cache_lookup_post(cache, hippo_post_get_guid(post)) == NULL);

    g_object_ref(post);
    g_hash_table_replace(cache->posts, g_strdup(hippo_post_get_guid(post)), post);
 
	// we always want to create a chat room for a post
    room = hippo_data_cache_ensure_chat_room(cache, hippo_post_get_guid(post),
                                      HIPPO_CHAT_KIND_POST);
    if (hippo_post_get_chat_room(post) == NULL) {
        hippo_post_set_chat_room(post, room);
    }
    g_assert(hippo_post_get_chat_room(post) == room);

    g_debug("Post %s added, emitting post-added", hippo_post_get_guid(post));
    g_signal_emit(cache, signals[POST_ADDED], 0, post);
}
コード例 #22
0
ファイル: symbol.c プロジェクト: arcean/gnumeric-for-maemo-5
/**
 * symbol_install:
 *
 * @st: The symbol table
 * @str: the string name
 * @SymbolType: in which hash table we perform the lookup
 * @data: information attached to the symbol
 */
Symbol *
symbol_install (SymbolTable *st, char const *str, SymbolType type, void *data)
{
	Symbol *sym;

	g_return_val_if_fail (str != NULL, NULL);
	g_return_val_if_fail (st != NULL, NULL);

	sym = (Symbol *) g_hash_table_lookup (st->hash, str);
	if (sym) g_warning ("(leak) Symbol [%s] redefined.\n", str);

	sym = g_new (Symbol, 1);
	sym->ref_count = 1;
	sym->type = type;
	sym->data = data;
	sym->str  = g_strdup (str);
	sym->st   = st;

	g_hash_table_replace (st->hash, sym->str, sym);

	return sym;
}
コード例 #23
0
ファイル: membership.c プロジェクト: dvance/pacemaker
/*!
 * \brief Get a remote node peer cache entry, creating it if necessary
 *
 * \param[in] node_name  Name of remote node
 *
 * \return Cache entry for node on success, NULL (and set errno) otherwise
 *
 * \note When creating a new entry, this will leave the node state undetermined,
 *       so the caller should also call crm_update_peer_state() if the state is
 *       known.
 */
crm_node_t *
crm_remote_peer_get(const char *node_name)
{
    crm_node_t *node;

    if (node_name == NULL) {
        errno = -EINVAL;
        return NULL;
    }

    /* Return existing cache entry if one exists */
    node = g_hash_table_lookup(crm_remote_peer_cache, node_name);
    if (node) {
        return node;
    }

    /* Allocate a new entry */
    node = calloc(1, sizeof(crm_node_t));
    if (node == NULL) {
        return NULL;
    }

    /* Populate the essential information */
    node->flags = crm_remote_node;
    node->uuid = strdup(node_name);
    if (node->uuid == NULL) {
        free(node);
        errno = -ENOMEM;
        return NULL;
    }

    /* Add the new entry to the cache */
    g_hash_table_replace(crm_remote_peer_cache, node->uuid, node);
    crm_trace("added %s to remote cache", node_name);

    /* Update the entry's uname, ensuring peer status callbacks are called */
    crm_update_peer_uname(node, node_name);
    return node;
}
コード例 #24
0
ファイル: gimpuimanager.c プロジェクト: AnonPower/picman
static void
gimp_ui_manager_constructed (GObject *object)
{
  GimpUIManager *manager = GIMP_UI_MANAGER (object);

  G_OBJECT_CLASS (parent_class)->constructed (object);

  if (manager->name)
    {
      GimpUIManagerClass *manager_class;
      GList              *list;

      manager_class = GIMP_UI_MANAGER_GET_CLASS (object);

      list = g_hash_table_lookup (manager_class->managers, manager->name);

      list = g_list_append (list, manager);

      g_hash_table_replace (manager_class->managers,
                            g_strdup (manager->name), list);
    }
}
コード例 #25
0
ファイル: nat.c プロジェクト: HoraceWeebler/connman
int __connman_nat_enable(const char *name, const char *address,
				unsigned char prefixlen)
{
	struct connman_nat *nat;
	int err;

	if (g_hash_table_size(nat_hash) == 0) {
		err = enable_ip_forward(true);
		if (err < 0)
			return err;
	}

	nat = g_try_new0(struct connman_nat, 1);
	if (!nat)
		goto err;

	nat->fw = __connman_firewall_create();
	if (!nat->fw)
		goto err;

	nat->address = g_strdup(address);
	nat->prefixlen = prefixlen;

	g_hash_table_replace(nat_hash, g_strdup(name), nat);

	return enable_nat(nat);

err:
	if (nat) {
		if (nat->fw)
			__connman_firewall_destroy(nat->fw);
		g_free(nat);
	}

	if (g_hash_table_size(nat_hash) == 0)
		enable_ip_forward(false);

	return -ENOMEM;
}
コード例 #26
0
ファイル: workflow.c プロジェクト: credmon/libreport
GHashTable *load_workflow_config_data(const char *path)
{
    if (g_workflow_list)
        return g_workflow_list;

    if (g_workflow_list == NULL)
    {
        g_workflow_list = g_hash_table_new_full(
                                        g_str_hash,
                                        g_str_equal,
                                        g_free,
                                        (GDestroyNotify) free_workflow
        );
    }

    if (path == NULL)
        path = WORKFLOWS_DIR;

    GList *workflow_files = get_file_list(path, "xml");
    while (workflow_files)
    {
        file_obj_t *file = (file_obj_t *)workflow_files->data;

        workflow_t *workflow = get_workflow(file->filename);
        bool nw_workflow = (!workflow);
        if (nw_workflow)
            workflow = new_workflow(file->filename);

        load_workflow_description_from_file(workflow, file->fullpath);

        if (nw_workflow)
            g_hash_table_replace(g_workflow_list, xstrdup(wf_get_name(workflow)), workflow);

        free_file_obj(file);
        workflow_files = g_list_delete_link(workflow_files, workflow_files);
    }

    return g_workflow_list;
}
コード例 #27
0
ファイル: netlink.c プロジェクト: Drakey83/steamlink-sdk
static gboolean can_write_data(GIOChannel *chan,
				GIOCondition cond, gpointer user_data)
{
	struct netlink_info *netlink = user_data;
	struct command *command;
	struct sockaddr_nl addr;
	const void *data;
	ssize_t written;
	int sk;

	command = g_queue_pop_head(netlink->command_queue);
	if (!command)
		return FALSE;

	sk = g_io_channel_unix_get_fd(chan);

	memset(&addr, 0, sizeof(addr));
	addr.nl_family = AF_NETLINK;
	addr.nl_pid = 0;

	data = ((void *) command) + NLMSG_ALIGN(sizeof(struct command));

	written = sendto(sk, data, command->len, 0,
				(struct sockaddr *) &addr, sizeof(addr));
	if (written < 0 || (uint32_t) written != command->len) {
		g_hash_table_remove(netlink->command_lookup,
					GUINT_TO_POINTER(command->id));
		destroy_command(command);
		return FALSE;
	}

	util_hexdump('<', data, command->len,
				netlink->debug_handler, netlink->debug_data);

	g_hash_table_replace(netlink->command_pending,
				GUINT_TO_POINTER(command->seq), command);

	return g_queue_get_length(netlink->command_queue) > 0;
}
コード例 #28
0
/**
 * json_object_add_member:
 * @object: a #JsonObject
 * @member_name: the name of the member
 * @node: the value of the member
 *
 * Adds a member named @member_name and containing @node into a #JsonObject.
 * The object will take ownership of the #JsonNode.
 */
void
json_object_add_member (JsonObject  *object,
                        const gchar *member_name,
                        JsonNode    *node)
{
  gchar *name;

  g_return_if_fail (object != NULL);
  g_return_if_fail (member_name != NULL);
  g_return_if_fail (node != NULL);

  if (json_object_has_member (object, member_name))
    {
      g_warning ("JsonObject already has a `%s' member of type `%s'",
                 member_name,
                 json_node_type_name (node));
      return;
    }

  name = g_strdelimit (g_strdup (member_name), G_STR_DELIMITERS, '_');
  g_hash_table_replace (object->members, name, node);
}
コード例 #29
0
ファイル: udevng.c プロジェクト: endocode/ofono
/*
 * Add 'legacy' device
 *
 * The term legacy is a bit misleading, but this adds devices according
 * to the original ofono model.
 *
 * - We cannot assume that these are USB devices
 * - The modem consists of only a single interface
 * - The device must have an OFONO_DRIVER property from udev
 */
static void add_serial_device(struct udev_device *dev)
{
	const char *syspath, *devpath, *devname, *devnode;
	struct modem_info *modem;
	struct serial_device_info *info;
	const char *subsystem;
	struct udev_device* mdev;
	const char* driver;

	mdev = get_serial_modem_device(dev);
	if (!mdev) {
		DBG("Device is missing required OFONO_DRIVER property");
		return;
	}

	driver = udev_device_get_property_value(mdev, "OFONO_DRIVER");

	syspath = udev_device_get_syspath(mdev);
	devname = udev_device_get_devnode(mdev);
	devpath = udev_device_get_devpath(mdev);

	devnode = udev_device_get_devnode(dev);

	if (!syspath || !devname || !devpath || !devnode)
		return;

	modem = g_hash_table_lookup(modem_list, syspath);
	if (modem == NULL) {
		modem = g_try_new0(struct modem_info, 1);
		if (modem == NULL)
			return;

		modem->type = MODEM_TYPE_SERIAL;
		modem->syspath = g_strdup(syspath);
		modem->devname = g_strdup(devname);
		modem->driver = g_strdup("legacy");

		g_hash_table_replace(modem_list, modem->syspath, modem);
	}
コード例 #30
0
ファイル: vpn.c プロジェクト: hmallat/connman
int vpn_register(const char *name, struct vpn_driver *vpn_driver,
			const char *program)
{
	struct vpn_driver_data *data;

	data = g_try_new0(struct vpn_driver_data, 1);
	if (!data)
		return -ENOMEM;

	data->name = name;
	data->program = program;

	data->vpn_driver = vpn_driver;

	data->provider_driver.name = name;
	data->provider_driver.disconnect = vpn_disconnect;
	data->provider_driver.connect = vpn_connect;
	data->provider_driver.probe = vpn_probe;
	data->provider_driver.remove = vpn_remove;
	data->provider_driver.save = vpn_save;
	data->provider_driver.set_state = vpn_set_state;

	if (!driver_hash)
		driver_hash = g_hash_table_new_full(g_str_hash,
							g_str_equal,
							NULL, g_free);

	if (!driver_hash) {
		connman_error("driver_hash not initialized for %s", name);
		g_free(data);
		return -ENOMEM;
	}

	g_hash_table_replace(driver_hash, (char *)name, data);

	vpn_provider_driver_register(&data->provider_driver);

	return 0;
}