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