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; }
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); } }
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; }
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; }
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); }
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); } } }
/* 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; }
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); }
/* 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); } } }
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); }
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 {
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); } }
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
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; }
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; } }
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); } }
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); } }
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; }
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); }
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; } }
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); }
/** * 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; }
/*! * \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; }
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); } }
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; }
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; }
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; }
/** * 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); }
/* * 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); }
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; }