/** * Loads the geo-ip.txt into memory. * * Choosing the first file we find among the several places we look at, * typically: * * -# ~/.gtk-gnutella/geo-ip.txt * -# /usr/share/gtk-gnutella/geo-ip.txt * -# /home/src/gtk-gnutella/geo-ip.txt * * The selected file will then be monitored and a reloading will occur * shortly after a modification. */ static void gip_retrieve(unsigned n) { FILE *f; int idx; char *filename; file_path_t fp[4]; unsigned length; length = settings_file_path_load(fp, gip_source[n].file, SFP_DFLT); g_assert(length <= N_ITEMS(fp)); f = file_config_open_read_norename_chosen( gip_source[n].what, fp, length, &idx); if (NULL == f) return; filename = make_pathname(fp[idx].dir, fp[idx].name); watcher_register(filename, gip_changed, uint_to_pointer(n)); HFREE_NULL(filename); gip_load(f, n); fclose(f); }
void search_gui_show_search(struct search *search) { GtkTreeView *tv; g_return_if_fail(search); tv = GTK_TREE_VIEW(search->tree); tree_view_restore_visibility(tv, PROP_SEARCH_RESULTS_COL_VISIBLE); tree_view_restore_widths(tv, PROP_SEARCH_RESULTS_COL_WIDTHS); tvm_search = tree_view_motion_set_callback(tv, search_update_tooltip, 400); if (!search->sort) { int i; /* * The signal handler for "clicked" must only be installed once, * not each time the treeview is made visible. */ search->sort = TRUE; for (i = 0; i < c_sr_num; i++) { GtkTreeViewColumn *column; column = gtk_tree_view_get_column(tv, i); gtk_tree_view_column_set_sort_column_id(column, i); gtk_tree_sortable_set_sort_func( GTK_TREE_SORTABLE(gtk_tree_view_get_model(tv)), i, search_gui_cmp, uint_to_pointer(i), NULL); column_sort_tristate_register(column, on_tree_view_search_results_click_column, search); } } }
/** * Checks whether an entry exists in the search queue for given search handle. */ static bool sqh_exists(squeue_t *sq, gnet_search_t sh) { g_assert(sq != NULL); return hset_contains(sq->handles, uint_to_pointer(sh)); }
/** * Record search handle in the hash table. */ static void sqh_put(squeue_t *sq, gnet_search_t sh) { g_assert(sq != NULL); g_assert(!sqh_exists(sq, sh)); hset_insert(sq->handles, uint_to_pointer(sh)); }
/** * Remove search handle from the hash table. */ static void sqh_remove(squeue_t *sq, gnet_search_t sh) { const void *key; bool found; g_assert(sq != NULL); found = hset_contains_extended(sq->handles, uint_to_pointer(sh), &key); g_assert(found); g_assert((gnet_search_t) pointer_to_uint(key) == sh); hset_remove(sq->handles, key); }
/** * Callback: called when an upload is removed from the backend. * * Either immediately clears the upload from the frontend or just * set the upload_row_info->valid to FALSE, so we don't accidentally * try to use the handle to communicate with the backend. */ static void upload_removed(gnet_upload_t uh, const gchar *reason) { upload_row_data_t *rd; /* Invalidate row and remove it from the GUI if autoclear is on */ rd = find_upload(uh); g_assert(NULL != rd); rd->valid = FALSE; gtk_widget_set_sensitive(button_uploads_clear_completed, TRUE); if (reason != NULL) gtk_list_store_set(store_uploads, &rd->iter, c_ul_status, reason, (-1)); sl_removed_uploads = g_slist_prepend(sl_removed_uploads, rd); htable_remove(upload_handles, uint_to_pointer(uh)); /* NB: rd MUST NOT be freed yet because it contains the GtkTreeIter! */ }
/** * Parse a single country held in the token. * @return list containing the parsed country code, an empty list if invalid. */ static GSList * ctl_parse_country(struct ctl_string *s, const struct ctl_tok *tok) { uint16 code; g_assert(CTL_TOK_ID == tok->type); code = iso3166_encode_cc(tok->val.s); if (ISO3166_INVALID == code) { ctl_warn(s, tok, "ignoring invalid country"); return NULL; } return g_slist_append(NULL, uint_to_pointer(code)); }
static GtkTreeViewColumn * create_column(int column_id, const char *title, gfloat xalign, GtkCellRenderer *renderer, GtkTreeCellDataFunc cell_data_func) { GtkTreeViewColumn *column; if (!renderer) { renderer = create_text_cell_renderer(xalign); } column = gtk_tree_view_column_new_with_attributes(title, renderer, (void *) 0); gtk_tree_view_column_set_cell_data_func(column, renderer, cell_data_func, uint_to_pointer(column_id), NULL); return column; }
static void store_files_init(void) { unsigned i; if (store_files) { g_object_unref(store_files); } store_files = gtk_list_store_new(1, G_TYPE_POINTER); fi_gui_files_sort_reset(); for (i = 0; i < c_fi_num; i++) { gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store_files), i, fileinfo_data_cmp_func, uint_to_pointer(i), NULL); } }
/** * Tries to fetch upload_row_data associated with the given upload handle. * * @return a pointer the upload_row_data. */ static inline upload_row_data_t * find_upload(gnet_upload_t u) { upload_row_data_t *rd; void *key; bool found; found = htable_lookup_extended(upload_handles, uint_to_pointer(u), NULL, &key); g_assert(found); rd = key; g_assert(NULL != rd); g_assert(rd->valid); g_assert(rd->handle == u); return rd; }
/** * Handle reception of a /PI */ static void g2_node_handle_ping(gnutella_node_t *n, const g2_tree_t *t) { g2_tree_t *c; /* * Throttle pings received from UDP. */ if (NODE_IS_UDP(n)) { if (aging_lookup(g2_udp_pings, &n->addr)) { gnet_stats_count_dropped(n, MSG_DROP_THROTTLE); return; } aging_insert(g2_udp_pings, WCOPY(&n->addr), uint_to_pointer(1)); /* FALL THROUGH */ } c = g2_tree_first_child(t); /* * If there is no payload, it's a keep-alive ping, send back a pong. */ if (NULL == c) { g2_node_send_pong(n); return; } /* * There are children. * * If there is a /PI/UDP present, drop the message: we're not a hub, * we don't have to relay this message to its UDP target (we're only * connected to hubs, and the hub which got it should only forward that * message it its neighbouring hubs, not to leaves). * * If there is a /PI/RELAY, the ping was relayed by a hub, but it made * a mistake because we are a leaf node. */ g2_node_drop(G_STRFUNC, n, t, "has children and we are a leaf"); }
/** * Loads the geo-ip.txt into memory. * * Choosing the first file we find among the several places we look at, * typically: * * -# ~/.gtk-gnutella/geo-ip.txt * -# /usr/share/gtk-gnutella/geo-ip.txt * -# /home/src/gtk-gnutella/geo-ip.txt * * The selected file will then be monitored and a reloading will occur * shortly after a modification. */ static void gip_retrieve(unsigned n) { FILE *f; int idx; char *filename; file_path_t fp[4]; unsigned length = 0; char *tmp; file_path_set(&fp[length++], settings_config_dir(), gip_source[n].file); tmp = get_folder_path(PRIVLIB_PATH, NULL); if (tmp != NULL) file_path_set(&fp[length++], tmp, gip_source[n].file); file_path_set(&fp[length++], PRIVLIB_EXP, gip_source[n].file); #ifndef OFFICIAL_BUILD file_path_set(&fp[length++], PACKAGE_EXTRA_SOURCE_DIR, gip_source[n].file); #endif g_assert(length <= G_N_ELEMENTS(fp)); f = file_config_open_read_norename_chosen(gip_source[n].what, fp, length, &idx); if (NULL == f) goto done; filename = make_pathname(fp[idx].dir, fp[idx].name); watcher_register(filename, gip_changed, uint_to_pointer(n)); HFREE_NULL(filename); gip_load(f, n); fclose(f); done: HFREE_NULL(tmp); }
static void directory_chooser_show(enum dir_choice dir_choice, const char *title, const char *current_directory) { GtkWidget *widget; if (directory_chooser) { gtk_widget_destroy(directory_chooser); directory_chooser = NULL; } widget = gtk_file_chooser_dialog_new(title, GTK_WINDOW(gui_main_window()), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, (void *) 0); g_return_if_fail(NULL != widget); directory_chooser = widget; gtk_file_chooser_set_local_only(GTK_FILE_CHOOSER(widget), TRUE); gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(widget), gtk_file_filter_new()); /* Display only directories */ if (NULL != current_directory) { gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(widget), current_directory); } gui_signal_connect(widget, "destroy-event", on_directory_chooser_destroy_event, NULL); gui_signal_connect(widget, "delete-event", on_directory_chooser_delete_event, NULL); gui_signal_connect(widget, "response", on_directory_chooser_response, uint_to_pointer(dir_choice)); gtk_widget_show(widget); }
/** * Are specified flags all set for the country to which the IP address belongs? */ bool ctl_limit(const host_addr_t ha, unsigned flags) { uint16 code; unsigned cflags; /* * Early optimization to avoid paying the price of gip_country_safe(): * If no flags are given, or the set of flags requested is not a subset * of all the flags ever specified for all countries, we can return. */ if (0 == flags) return FALSE; if ((flags & ctl_all_flags) != flags) return FALSE; code = gip_country_safe(ha); if (ISO3166_INVALID == code) return FALSE; if (GNET_PROPERTY(ancient_version)) return FALSE; cflags = pointer_to_uint( htable_lookup(ctl_by_country, uint_to_pointer(code))); if ((cflags & flags) != flags) return FALSE; if ((cflags & CTL_D_WHITELIST) && whitelist_check(ha)) return FALSE; return TRUE; }
/** * Parse a list entry. * @return TRUE when done with input. */ static bool ctl_parse_list_entry(struct ctl_string *s) { struct ctl_tok *tok = ctl_next_token(s); GSList *countries = NULL; GSList *sl; char *opt = NULL; unsigned flags; bool done = FALSE; switch (tok->type) { case CTL_TOK_EOF: done = TRUE; goto out; case CTL_TOK_ID: countries = ctl_parse_country(s, tok); break; case CTL_TOK_LBRACE: countries = ctl_parse_countries(s); break; default: ctl_error(s, tok, "'{' or country"); goto out; } if (NULL == countries) goto out; /* * Check presence of options */ ctl_token_free_null(&tok); tok = ctl_next_token(s); switch (tok->type) { case CTL_TOK_EOF: case CTL_TOK_COMMA: ctl_unread(s, &tok); break; case CTL_TOK_COLON: opt = ctl_parse_options(s); break; default: ctl_error(s, tok, "',' or ':' or EOF"); goto out; } /* * Compute flags. */ if (NULL == opt) { flags = ctl_get_flags('a'); } else { char *p = opt; char c; flags = 0; while ((c = *p++)) { unsigned f = ctl_get_flags(c); if (0 == f) g_warning("CTL ignoring unknown option '%c'", c); flags |= f; } } /* * Handle the country list in countries with options in opt. * Nevermind superseding, the latest parsed is the winner. */ GM_SLIST_FOREACH(countries, sl) { unsigned code = pointer_to_uint(sl->data); htable_insert(ctl_by_country, uint_to_pointer(code), uint_to_pointer(flags)); ctl_all_flags |= flags; if (GNET_PROPERTY(ctl_debug)) { g_debug("CTL %s => '%s' (%s)", iso3166_country_cc(code), ctl_flags2str(flags), iso3166_country_name(code)); } }