/** * Free an XML node. * * This is the user-visible routine that can succeed only if the node is * not part of a tree structure. */ void xnode_free(xnode_t *xn) { etree_t t; xnode_check(xn); etree_init_root(&t, xn, TRUE, offsetof(xnode_t, node)); g_assert(etree_is_standalone(&t, xn)); switch (xn->type) { case XNODE_T_COMMENT: HFREE_NULL(xn->u.c.text); break; case XNODE_T_TEXT: HFREE_NULL(xn->u.t.text); break; case XNODE_T_PI: atom_str_free_null(&xn->u.pi.name); HFREE_NULL(xn->u.pi.target); break; case XNODE_T_ELEMENT: atom_str_free_null(&xn->u.e.name); atom_str_free_null(&xn->u.e.ns_uri); nv_table_free_null(&xn->u.e.ns); xattr_table_free_null(&xn->u.e.attrs); break; case XNODE_T_MAX: g_assert_not_reached(); } xn->magic = 0; WFREE(xn); }
void magnet_resource_free(struct magnet_resource **res_ptr) { struct magnet_resource *res = *res_ptr; if (res) { GSList *sl; atom_str_free_null(&res->display_name); atom_sha1_free_null(&res->sha1); atom_tth_free_null(&res->tth); atom_str_free_null(&res->parq_id); atom_str_free_null(&res->guid); atom_str_free_null(&res->vendor); for (sl = res->sources; sl != NULL; sl = g_slist_next(sl)) { struct magnet_source *ms = sl->data; magnet_source_free(&ms); } gm_slist_free_null(&res->sources); for (sl = res->searches; sl != NULL; sl = g_slist_next(sl)) { const char *s = sl->data; atom_str_free_null(&s); } gm_slist_free_null(&res->searches); wfree(res, sizeof *res); *res_ptr = NULL; } }
/** * Free an attribute key/value. */ static void xattr_free(struct xattr *xa) { g_assert(xa != NULL); atom_str_free_null(&xa->uri); atom_str_free_null(&xa->local); HFREE_NULL(xa->value); WFREE(xa); }
/** * Free service description. */ static void upnp_service_free(upnp_service_t *usd) { upnp_service_check(usd); atom_str_free_null(&usd->control_url); atom_str_free_null(&usd->scpd_url); nv_table_free_null(&usd->api); usd->magic = 0; WFREE(usd); }
/** * Free a SOAP request. */ static void soap_rpc_free(soap_rpc_t *sr) { soap_rpc_check(sr); atom_str_free_null(&sr->url); atom_str_free_null(&sr->action); cq_cancel(&sr->delay_ev); http_async_cancel_null(&sr->ha); header_free_null(&sr->header); pmsg_free_null(&sr->mb); HFREE_NULL(sr->reply_data); sr->magic = 0; WFREE(sr); }
static void destroy_entry(struct st_entry *entry) { g_assert(entry != NULL); atom_str_free_null(&entry->string); shared_file_unref(&entry->sf); WFREE(entry); }
/** * Free watchdog. */ static void wd_free(watchdog_t *wd) { watchdog_check(wd); wd_sleep(wd); atom_str_free_null(&wd->name); WFREE(wd); }
/** * Free an UPnP control request. */ static void upnp_ctrl_free(upnp_ctrl_t *ucd) { upnp_ctrl_check(ucd); g_assert(NULL == ucd->sr); atom_str_free_null(&ucd->action); ucd->magic = 0; WFREE(ucd); }
static void uhc_free(struct uhc **ptr) { if (*ptr) { struct uhc *uu = *ptr; atom_str_free_null(&uu->host); WFREE(uu); *ptr = NULL; } }
void magnet_source_free(struct magnet_source **ms_ptr) { struct magnet_source *ms = *ms_ptr; if (ms) { atom_str_free_null(&ms->hostname); atom_str_free_null(&ms->path); atom_str_free_null(&ms->url); atom_sha1_free_null(&ms->sha1); atom_tth_free_null(&ms->tth); atom_guid_free_null(&ms->guid); if (ms->proxies) { free_proxies_list(ms->proxies); ms->proxies = NULL; } wfree(ms, sizeof *ms); *ms_ptr = NULL; } }
static void node_data_free(gpointer value) { struct node_data *data = value; atom_str_free_null(&data->user_agent); WFREE_NULL(data->host, data->host_size); WFREE_NULL(data->info, data->info_size); nid_unref(data->node_id); WFREE(data); }
/** * Dispose of current URL atom, if defined. * When `discard' is set, we remove the current URL physically from our cache. */ static void gwc_clear_current_url(bool discard) { if (gwc_current_url == NULL) return; if (discard) gwc_forget_url(gwc_current_url); atom_str_free_null(&gwc_current_url); }
/** * Clear all the upload stats data structure. */ static G_GNUC_COLD void upload_stats_free_all(void) { if (upload_stats_list) { struct ul_stats *s; while (NULL != (s = hash_list_head(upload_stats_list))) { hash_list_remove(upload_stats_list, s); atom_str_free_null(&s->pathname); atom_str_free_null(&s->filename); if (s->sha1) g_hash_table_remove(upload_stats_by_sha1, s->sha1); atom_sha1_free_null(&s->sha1); WFREE(s); } hash_list_free(&upload_stats_list); gm_hash_table_destroy_null(&upload_stats_by_sha1); } dirty = TRUE; }
/** * Record given string magnet resource at the supplied location. */ static void magnet_resource_set_string(const char **p, const char *str) { const char *atom; g_return_if_fail(p); g_return_if_fail(str); atom = atom_str_get(str); atom_str_free_null(p); *p = atom; }
void magnet_set_display_name(struct magnet_resource *res, const char *name) { const char *atom; g_return_if_fail(res); g_return_if_fail(name); atom = atom_str_get(name); atom_str_free_null(&res->display_name); res->display_name = atom; }
static void free_upload_data(const void *unused_key, void *value, void *unused_data) { struct upload_data *data = value; (void) unused_key; (void) unused_data; g_assert(data->us); g_assert(data->filename); data->us = NULL; atom_str_free_null(&data->filename); WFREE(data); }
/** * Dispose of header formatting context. */ void header_fmt_free(header_fmt_t **hf_ptr) { header_fmt_t *hf = *hf_ptr; if (hf) { header_fmt_check(hf); str_destroy_null(&hf->header); atom_str_free_null(&hf->sep); hf->magic = 0; WFREE(hf); *hf_ptr = NULL; } }
/** * Ensures that we have a valid `gwc_current_url' or pick a new one. * Also force change a the current URL after too many uses. * * @return TRUE if we got a valid URL. */ static bool gwc_check_current_url(void) { if (gwc_current_url == NULL || gwc_current_reused >= MAX_GWC_REUSE) { /* * `gwc_current_url' must be an atom since we may replace the value * in the cache at any time: we could be using a cache even after * its entry has been superseded. */ const char *ptr = gwc_pick(); atom_str_free_null(&gwc_current_url); gwc_current_url = ptr == NULL ? NULL : atom_str_get(ptr); gwc_current_reused = 0; } else gwc_current_reused++; return gwc_current_url != NULL; }
static void adns_cache_free_entry(adns_cache_t *cache, unsigned i) { adns_cache_entry_t *entry; g_assert(cache); g_assert(i < G_N_ELEMENTS(cache->entries)); entry = cache->entries[i]; if (entry) { g_assert(i == entry->id); g_assert(entry->hostname); g_assert(entry->n > 0); atom_str_free_null(&entry->hostname); wfree(entry, adns_cache_entry_size(entry->n)); cache->entries[i] = NULL; } }
/** * Terminate host browsing. */ void browse_host_dl_free(struct browse_ctx **ptr) { struct browse_ctx *bc = *ptr; if (bc) { atom_str_free_null(&bc->vendor); if (bc->rx) { rx_free(bc->rx); bc->rx = NULL; } if (!bc->closed) { search_dissociate_browse(bc->sh, bc->owner); } HFREE_NULL(bc->data); WFREE(bc); *ptr = NULL; } }
/** * Updates vendor, version and info column. */ static void nodes_gui_update_node_info(struct node_data *data, gnet_node_info_t *info) { gnet_node_status_t status; g_assert(info != NULL); if (data == NULL) data = find_node(info->node_id); g_assert(NULL != data); g_assert(data->node_id == info->node_id); if (guc_node_get_status(info->node_id, &status)) { str_bprintf(data->version, sizeof data->version, "%u.%u", info->proto_major, info->proto_minor); atom_str_free_null(&data->user_agent); data->user_agent = info->vendor ? atom_str_get(info->vendor) : NULL; data->country = info->country; } }
static void file_object_free(struct file_object * const fo) { g_return_if_fail(fo); file_object_check(fo); g_return_if_fail(1 == fo->ref_count); if (fo->removed) { const struct file_object *xfo; xfo = hikset_lookup(file_object_mode_get_table(fo->accmode), fo->pathname); g_assert(xfo != fo); } else { file_object_remove(fo); } fd_close(&fo->fd); atom_str_free_null(&fo->pathname); fo->magic = 0; WFREE(fo); }
/** * Free the callout queue and all contained event objects. */ static void cq_free(cqueue_t *cq) { cevent_t *ev; cevent_t *ev_next; int i; struct chash *ch; cqueue_check(cq); if (cq->cq_current != NULL) { s_carp("%s(): %squeue \"%s\" still within cq_clock()", G_STRFUNC, CSUBQUEUE_MAGIC == cq->cq_magic ? "sub" : "", cq->cq_name); } mutex_lock(&cq->cq_lock); for (ch = cq->cq_hash, i = 0; i < HASH_SIZE; i++, ch++) { for (ev = ch->ch_head; ev; ev = ev_next) { ev_next = ev->ce_bnext; ev->ce_magic = 0; WFREE(ev); } } if (cq->cq_periodic) { hset_foreach_remove(cq->cq_periodic, cq_free_periodic, NULL); hset_free_null(&cq->cq_periodic); } if (cq->cq_idle) { hset_foreach_remove(cq->cq_idle, cq_free_idle, cq); hset_free_null(&cq->cq_idle); } XFREE_NULL(cq->cq_hash); atom_str_free_null(&cq->cq_name); /* * Unlocking the cq->cq_lock mutex (taken above) prevents a loud warning in * mutex_destroy() in case the mutex was already locked by our thread, * meaning we were already in cq_clock(). In that situation however, * we already warned upon entry, and therefore there is no need for a * second warning. * * If the mutex was not taken and someone else attempts to grab it at that * stage, there will be a slight window which fortunately will be loudly * detected by mutex_destroy(), as a case of a mutex being destroyed * whilst owned by another thread. * * No valid application code should attempt to sneak in at this stage to * grab that mutex anyway, so our logic is safe and we will be copiously * warned if something unexpected happens. * --RAM, 2012-12-04. */ mutex_unlock(&cq->cq_lock); mutex_destroy(&cq->cq_lock); mutex_destroy(&cq->cq_idle_lock); /* * If freeing a sub-queue, the object is a bit larger than a queue, * and we have more cleanup to do... */ if (CSUBQUEUE_MAGIC == cq->cq_magic) { cq_subqueue_free((struct csubqueue *) cq); } else { cq->cq_magic = 0; WFREE(cq); } }
/** * Locate statistics structure for the file. * * If a SHA1 is given, we search by SHA1. Otherwise we search by (name, size) * and if the record is missing the SHA1, probably because it was not * available at the time of insertion, then it is added to the structure * and recorded as such. */ static struct ul_stats * upload_stats_find(const struct sha1 *sha1, const char *pathname, guint64 size) { struct ul_stats *s = NULL; if (upload_stats_list) { static const struct ul_stats zero_stats; struct ul_stats key; gconstpointer orig_key; g_assert(upload_stats_by_sha1); if (sha1) { s = g_hash_table_lookup(upload_stats_by_sha1, sha1); if (s) goto done; /* Found it by SHA1 */ } key = zero_stats; key.pathname = atom_str_get(pathname); key.size = size; if (hash_list_find(upload_stats_list, &key, &orig_key)) s = deconstify_gpointer(orig_key); atom_str_free_null(&key.pathname); if (s && sha1) { /* Was missing from the by-SHA1 table */ if (NULL == s->sha1) { /* SHA1 was unknown */ s->sha1 = atom_sha1_get(sha1); } else { /* SHA1 changed, file was modified */ struct ul_stats *old = g_hash_table_lookup(upload_stats_by_sha1, s->sha1); g_assert(old == s); /* Must be the same filename entry */ g_hash_table_remove(upload_stats_by_sha1, s->sha1); atom_sha1_free(s->sha1); s->sha1 = atom_sha1_get(sha1); } gm_hash_table_insert_const(upload_stats_by_sha1, s->sha1, s); } } done: /* We guarantee the SHA1 is present in the record if known */ g_assert(!(s && sha1) || s->sha1); /* Postcondition: if we return something, it must be "correct" */ if (s != NULL) { g_assert(atom_is_str(s->pathname)); g_assert(atom_is_str(s->filename)); g_assert(s->norm >= 0.0); } return s; }
/** * Destroy a GHC. */ static void ghc_free(struct ghc *ghc) { atom_str_free_null(&ghc->url); WFREE(ghc); }
/** * Free a namesize structure. */ void namesize_free(namesize_t *ns) { atom_str_free_null(&ns->name); WFREE(ns); }
/** * Add new URL to cache, possibly pushing off an older one if cache is full. * * @return TRUE if the URL was added, FALSE otherwise. */ static bool gwc_add(const char *new_url) { const char *url_atom; const char *old_url; char *url, *ret; url = h_strdup(new_url); /* url_normalize() can modify the URL */ ret = url_normalize(url, URL_POLICY_GWC_RULES); if (!ret) { g_warning("%s(): ignoring bad web cache URL \"%s\"", G_STRFUNC, new_url); HFREE_NULL(url); return FALSE; } if (ret != url) { HFREE_NULL(url); url = ret; } /* * Don't add duplicates to the cache. */ if ( hset_contains(gwc_known_url, url) || hset_contains(gwc_failed_url, url) ) { HFREE_NULL(url); return FALSE; } /* * OK, record new entry at the `gwc_url_slot'. */ if (++gwc_url_slot >= MAX_GWC_URLS) gwc_url_slot = 0; g_assert(url != NULL); url_atom = atom_str_get(url); HFREE_NULL(url); /* * Expire any entry present at the slot we're about to write into. */ old_url = gwc_url[gwc_url_slot].url; if (old_url != NULL) { g_assert(hset_contains(gwc_known_url, old_url)); hset_remove(gwc_known_url, old_url); atom_str_free_null(&old_url); gwc_url[gwc_url_slot].url = NULL; } hset_insert(gwc_known_url, url_atom); gwc_url[gwc_url_slot].url = url_atom; gwc_url[gwc_url_slot].stamp = 0; gwc_file_dirty = TRUE; if (GNET_PROPERTY(bootstrap_debug)) { g_debug("%s(): loaded GWC URL %s", G_STRFUNC, url_atom); } return TRUE; }