/**
* Stringify value of the general stats to buffer.
*
* @param dst destination buffer
* @param size length of destination buffer
* @param stats the statistics array
* @param idx the index within the general statistics of value to format
*/
void
gnet_stats_gui_general_to_string_buf(char *dst, size_t size,
const gnet_stats_t *stats, int idx)
{
const uint64 value = stats->general[idx];
if (0 == value)
g_strlcpy(dst, "-", size);
else {
switch (idx) {
case GNR_QUERY_COMPACT_SIZE:
case GNR_IGNORED_DATA:
case GNR_SUNK_DATA:
case GNR_UDP_READ_AHEAD_BYTES_SUM:
case GNR_UDP_READ_AHEAD_BYTES_MAX:
case GNR_RUDP_TX_BYTES:
case GNR_RUDP_RX_BYTES:
g_strlcpy(dst, compact_size(value, show_metric_units()), size);
break;
case GNR_UDP_READ_AHEAD_DELAY_MAX:
g_strlcpy(dst, compact_time(value), size);
break;
default:
uint64_to_string_buf(value, dst, size);
}
}
}
/**
* Updates the horizon statistics in the statusbar.
*
* This is an event-driven callback called from the HSEP code
* using the event listener framework. In addition to taking into account
* the HSEP information, the number of established non-HSEP nodes and
* their library size (if provided) are added to the values displayed.
*/
void
gnet_stats_gui_horizon_update(hsep_triple *table, guint32 triples)
{
const guint32 hops = 4U; /* must be <= HSEP_N_MAX */
guint64 val;
hsep_triple other;
if (triples <= hops) /* should not happen */
return;
g_assert((gint32) triples > 0);
guc_hsep_get_non_hsep_triple(&other);
/*
* Update the 3 labels in the statusbar with the horizon values for a
* distance of 'hops' hops.
*/
val = table[hops][HSEP_IDX_NODES] + other[HSEP_IDX_NODES];
gtk_label_printf(GTK_LABEL(
gui_main_window_lookup("label_statusbar_horizon_node_count")),
"%s %s", uint64_to_string(val), NG_("node", "nodes", val));
val = table[hops][HSEP_IDX_FILES] + other[HSEP_IDX_FILES];
gtk_label_printf(GTK_LABEL(
gui_main_window_lookup("label_statusbar_horizon_file_count")),
"%s %s", uint64_to_string(val), NG_("file", "files", val));
val = table[hops][HSEP_IDX_KIB] + other[HSEP_IDX_KIB];
gtk_label_printf(GTK_LABEL(
gui_main_window_lookup("label_statusbar_horizon_kb_count")),
"%s", short_kb_size(val, show_metric_units()));
}
void
upload_stats_gui_add(struct ul_stats *us)
{
GtkCList *clist = clist_ul_stats();
const gchar *rowdata[c_us_num];
enum c_us i;
int row;
char size_tmp[16];
char attempts_tmp[16];
char complete_tmp[16];
char norm_tmp[16];
char rtime_tmp[64];
char dtime_tmp[64];
g_strlcpy(size_tmp, short_size(us->size, show_metric_units()),
sizeof size_tmp);
gm_snprintf(attempts_tmp, sizeof attempts_tmp, "%u", us->attempts);
gm_snprintf(complete_tmp, sizeof complete_tmp, "%u", us->complete);
gm_snprintf(norm_tmp, sizeof norm_tmp, "%.3f", us->norm);
if (us->rtime) {
timestamp_to_string_buf(us->rtime, rtime_tmp, sizeof rtime_tmp);
} else {
rtime_tmp[0] = '\0';
}
if (us->dtime) {
timestamp_to_string_buf(us->dtime, dtime_tmp, sizeof dtime_tmp);
} else {
dtime_tmp[0] = '\0';
}
for (i = 0; i < c_us_num; i++)
switch (i) {
case c_us_filename:
rowdata[i] = lazy_utf8_to_ui_string(us->filename);
break;
case c_us_size: rowdata[i] = size_tmp; break;
case c_us_attempts: rowdata[i] = attempts_tmp; break;
case c_us_complete: rowdata[i] = complete_tmp; break;
case c_us_norm: rowdata[i] = norm_tmp; break;
case c_us_rtime: rowdata[i] = rtime_tmp; break;
case c_us_dtime: rowdata[i] = dtime_tmp; break;
case c_us_num: g_assert_not_reached();
}
row = gtk_clist_append(clist, deconstify_gpointer(rowdata));
g_return_if_fail(row >= 0);
ul_stats_set_row(us, row);
gtk_clist_set_row_data_full(clist, row, us, on_clist_ul_stats_row_removed);
/* FIXME: should use auto_sort? */
if (0 == clist->freeze_count) {
gtk_clist_sort(clist);
clist_sync_rows(clist, on_clist_ul_stats_row_moved);
}
}
static void
cell_renderer_func(GtkTreeViewColumn *column,
GtkCellRenderer *cell, GtkTreeModel *model, GtkTreeIter *iter,
gpointer udata)
{
static const GValue zero_value;
const struct upload_data *data;
const gchar *text = NULL;
gchar buf[64];
GValue value;
if (!gtk_tree_view_column_get_visible(column))
return;
value = zero_value;
gtk_tree_model_get_value(model, iter, 0, &value);
data = g_value_get_pointer(&value);
switch ((enum c_us) GPOINTER_TO_UINT(udata)) {
case c_us_filename:
text = data->filename;
break;
case c_us_size:
text = short_size(data->us->size, show_metric_units());
break;
case c_us_attempts:
text = uint64_to_string(data->us->attempts);
break;
case c_us_complete:
text = uint64_to_string(data->us->attempts);
break;
case c_us_norm:
str_bprintf(buf, sizeof buf, "%1.3f", data->us->norm);
text = buf;
break;
case c_us_rtime:
text = data->us->rtime ? timestamp_to_string(data->us->rtime) : NULL;
break;
case c_us_dtime:
text = data->us->dtime ? timestamp_to_string(data->us->dtime) : NULL;
break;
case c_us_num:
g_assert_not_reached();
}
g_object_set(cell, "text", text, (void *) 0);
}
static void
cell_renderer(GtkTreeViewColumn *column, GtkCellRenderer *cell,
GtkTreeModel *model, GtkTreeIter *iter, gpointer udata)
{
const struct result_data *data;
const struct results_set *rs;
const gchar *text;
enum c_sr_columns id;
if (!gtk_tree_view_column_get_visible(column))
return;
text = NULL; /* default to nothing */
id = GPOINTER_TO_UINT(udata);
data = get_result_data(model, iter);
rs = data->record->results_set;
switch (id) {
case c_sr_filename:
text = data->record->utf8_name;
break;
case c_sr_ext:
text = data->record->ext;
break;
case c_sr_mime:
text = mime_type_to_string(mime_type_from_extension(data->record->ext));
break;
case c_sr_vendor:
if (!(ST_LOCAL & rs->status))
text = vendor_code_get_name(rs->vendor);
break;
case c_sr_info:
text = data->record->info;
break;
case c_sr_size:
text = compact_size(data->record->size, show_metric_units());
break;
case c_sr_count:
text = data->children ? uint32_to_string(1 + data->children) : NULL;
break;
case c_sr_loc:
if (ISO3166_INVALID != rs->country)
text = iso3166_country_cc(rs->country);
break;
case c_sr_charset:
if (!(ST_LOCAL & rs->status))
text = data->record->charset;
break;
case c_sr_route:
text = search_gui_get_route(rs);
break;
case c_sr_protocol:
if (!((ST_LOCAL | ST_BROWSE) & rs->status))
text = ST_UDP & rs->status ?
(ST_SR_UDP & rs->status ? N_("UDP (semi-reliable)") : "UDP")
: "TCP";
break;
case c_sr_hops:
if (!((ST_LOCAL | ST_BROWSE) & rs->status))
text = uint32_to_string(rs->hops);
break;
case c_sr_ttl:
if (!((ST_LOCAL | ST_BROWSE) & rs->status))
text = uint32_to_string(rs->ttl);
break;
case c_sr_spam:
if (SR_SPAM & data->record->flags) {
text = "S"; /* Spam */
} else if (ST_SPAM & rs->status) {
text = "maybe"; /* maybe spam */
}
break;
case c_sr_owned:
if (SR_OWNED & data->record->flags) {
text = _("owned");
} else if (SR_PARTIAL & data->record->flags) {
text = _("partial");
} else if (SR_SHARED & data->record->flags) {
text = _("shared");
}
break;
case c_sr_hostile:
if (ST_HOSTILE & rs->status) {
text = "H";
}
break;
case c_sr_sha1:
if (data->record->sha1) {
text = sha1_base32(data->record->sha1);
}
break;
case c_sr_ctime:
if ((time_t) -1 != data->record->create_time) {
text = timestamp_to_string(data->record->create_time);
}
break;
case c_sr_num:
g_assert_not_reached();
break;
}
g_object_set(cell,
"text", text,
"foreground-gdk", gui_color_get(data->color),
"background-gdk", gui_color_get(GUI_COLOR_BACKGROUND),
(void *) 0);
}
/**
* Compute info string for node.
*
* @return pointer to static data.
*/
const gchar *
nodes_gui_common_status_str(const gnet_node_status_t *n)
{
static gchar gui_tmp[4096];
const gchar *a;
switch (n->status) {
case GTA_NODE_CONNECTING:
a = _("Connecting...");
break;
case GTA_NODE_HELLO_SENT:
a = _("Hello sent");
break;
case GTA_NODE_WELCOME_SENT:
a = _("Welcome sent");
break;
case GTA_NODE_CONNECTED:
if (n->sent || n->received) {
size_t slen = 0;
if (!GUI_PROPERTY(node_show_detailed_info)) {
str_bprintf(gui_tmp, sizeof(gui_tmp),
"TX=%u RX=%u Q=%u,%u%% %s",
n->sent, n->received,
n->mqueue_count, n->mqueue_percent_used,
n->in_tx_swift_control ? " [SW]" :
n->in_tx_flow_control ? " [FC]" : "");
a = gui_tmp;
break;
}
if (n->tx_compressed && GUI_PROPERTY(show_gnet_info_txc))
slen += str_bprintf(gui_tmp, sizeof(gui_tmp), "TXc=%u,%d%%",
n->sent, (int) (n->tx_compression_ratio * 100.0));
else
slen += str_bprintf(gui_tmp, sizeof(gui_tmp), "TX=%u",
n->sent);
if (
GUI_PROPERTY(show_gnet_info_tx_speed) ||
GUI_PROPERTY(show_gnet_info_tx_wire)
) {
gboolean is_first = TRUE;
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
" (" /* ')' */);
if (GUI_PROPERTY(show_gnet_info_tx_wire)) {
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
"%s", compact_size(n->tx_written, show_metric_units()));
is_first = FALSE;
}
if (GUI_PROPERTY(show_gnet_info_tx_speed))
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
"%s%s", is_first ? "" : ", ",
compact_rate(n->tx_bps, show_metric_units()));
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
/* '(' */ ")");
}
if (n->rx_compressed && GUI_PROPERTY(show_gnet_info_rxc))
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
" RXc=%u,%d%%",
n->received, (int) (n->rx_compression_ratio * 100.0));
else
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
" RX=%u", n->received);
if (
GUI_PROPERTY(show_gnet_info_rx_speed) ||
GUI_PROPERTY(show_gnet_info_rx_wire)
) {
gboolean is_first = TRUE;
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
" (" /* ')' */);
if (GUI_PROPERTY(show_gnet_info_rx_wire)) {
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
"%s", compact_size(n->rx_given, show_metric_units()));
is_first = FALSE;
}
if (GUI_PROPERTY(show_gnet_info_rx_speed))
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
"%s%s", is_first ? "" : ", ",
compact_rate(n->rx_bps, show_metric_units()));
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
/* '(' */ ")");
}
if (
GUI_PROPERTY(show_gnet_info_tx_queries) ||
GUI_PROPERTY(show_gnet_info_rx_queries) ||
GUI_PROPERTY(show_gnet_info_gen_queries) ||
GUI_PROPERTY(show_gnet_info_sq_queries)
) {
gboolean is_first = TRUE;
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
" Query(" /* ')' */);
if (GUI_PROPERTY(show_gnet_info_gen_queries)) {
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
"Gen=%u", n->squeue_sent);
is_first = FALSE;
}
if (GUI_PROPERTY(show_gnet_info_sq_queries)) {
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
"%sQ=%u", is_first ? "" : ", ", n->squeue_count);
is_first = FALSE;
}
if (GUI_PROPERTY(show_gnet_info_tx_queries)) {
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
"%sTX=%u", is_first ? "" : ", ", n->tx_queries);
is_first = FALSE;
}
if (GUI_PROPERTY(show_gnet_info_rx_queries))
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
"%sRX=%u", is_first ? "" : ", ", n->rx_queries);
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
/* '(' */ ")");
}
if (
GUI_PROPERTY(show_gnet_info_tx_hits) ||
GUI_PROPERTY(show_gnet_info_rx_hits)
) {
gboolean is_first = TRUE;
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
" QHit(" /* ')' */);
if (GUI_PROPERTY(show_gnet_info_tx_hits)) {
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
"TX=%u", n->tx_qhits);
is_first = FALSE;
}
if (GUI_PROPERTY(show_gnet_info_rx_hits))
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
"%sRX=%u", is_first ? "" : ", ", n->rx_qhits);
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
/* '(' */ ")");
}
if (
GUI_PROPERTY(show_gnet_info_tx_dropped) ||
GUI_PROPERTY(show_gnet_info_rx_dropped)
) {
gboolean is_first = TRUE;
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
" Drop(" /* ')' */);
if (GUI_PROPERTY(show_gnet_info_tx_dropped)) {
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
"TX=%u", n->tx_dropped);
is_first = FALSE;
}
if (GUI_PROPERTY(show_gnet_info_rx_dropped))
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
"%sRX=%u", is_first ? "" : ", ", n->rx_dropped);
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
/* '(' */ ")");
}
if (
GUI_PROPERTY(show_gnet_info_shared_size) ||
GUI_PROPERTY(show_gnet_info_shared_files)
) {
gboolean is_first = TRUE;
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
" Lib(" /* ')' */);
if (
GUI_PROPERTY(show_gnet_info_shared_size) &&
n->gnet_info_known
) {
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
"%s",
compact_kb_size(n->gnet_files_count
? n->gnet_kbytes_count : 0, show_metric_units()));
is_first = FALSE;
}
if (
GUI_PROPERTY(show_gnet_info_shared_files) &&
n->gnet_info_known
) {
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
"%s#=%u", is_first ? "" : ", ", n->gnet_files_count);
}
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
/* '(' */ "%s)", n->gnet_info_known ? "" : "?");
}
if (GUI_PROPERTY(show_gnet_info_qrp_stats)) {
if (n->has_qrp)
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
" QRP=%u%%",
(guint) (n->qrp_efficiency * 100.0));
if (n->qrt_slots != 0)
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
" QRT(%s, g=%u, f=%u%%, t=%u%%, e=%u%%)",
compact_size(n->qrt_slots, show_metric_units()),
n->qrt_generation,
n->qrt_fill_ratio, n->qrt_pass_throw,
(guint) (n->qrp_efficiency * 100.0));
}
if (GUI_PROPERTY(show_gnet_info_dbw))
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
" Dup=%u Bad=%u W=%u H=%u S=%u E=%u",
n->n_dups, n->n_bad, n->n_weird,
n->n_hostile, n->n_spam, n->n_evil);
if (GUI_PROPERTY(show_gnet_info_rt)) {
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
" RT(avg=%u, last=%u", n->rt_avg, n->rt_last); /* ) */
if (n->tcp_rtt)
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
", tcp=%u", n->tcp_rtt);
if (n->udp_rtt)
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
", udp=%u", n->udp_rtt);
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
/* ( */ ")");
}
slen += str_bprintf(&gui_tmp[slen], sizeof(gui_tmp)-slen,
" Q=%u,%u%% %s",
n->mqueue_count, n->mqueue_percent_used,
n->in_tx_swift_control ? " [SW]" :
n->in_tx_flow_control ? " [FC]" : "");
a = gui_tmp;
} else if (n->is_pseudo) {
a = _("No UDP traffic yet");
} else {
a = _("Connected");
}
break;
case GTA_NODE_SHUTDOWN:
{
str_bprintf(gui_tmp, sizeof(gui_tmp),
_("Closing: %s [Stop in %us] RX=%u Q=%u,%u%%"),
n->message, n->shutdown_remain, n->received,
n->mqueue_count, n->mqueue_percent_used);
a = gui_tmp;
}
break;
case GTA_NODE_REMOVING:
a = *n->message ? n->message : _("Removing");
break;
case GTA_NODE_RECEIVING_HELLO:
a = _("Receiving hello");
break;
default:
a = _("UNKNOWN STATUS");
}
return a;
}
/**
* @return a pointer to a static buffer containing a string which
* describes the current status of the upload.
*/
const gchar *
uploads_gui_status_str(const gnet_upload_status_t *u,
const upload_row_data_t *data)
{
static gchar tmpstr[256];
if (u->pos < data->range_start)
return _("No output yet..."); /* Never wrote anything yet */
switch (u->status) {
case GTA_UL_PUSH_RECEIVED:
return _("Got push, connecting back...");
case GTA_UL_COMPLETE:
{
time_delta_t d = delta_time(data->last_update, data->start_date);
filesize_t requested = data->range_end - data->range_start + 1;
size_t rw;
rw = str_bprintf(tmpstr, sizeof(tmpstr),
"%s (%s) %s %s#%u", _("Completed"),
d > 0 ? short_rate(requested / d, show_metric_units())
: _("< 1s"),
d > 0 ? short_time(d) : "",
u->parq_quick ? _("(quick) ") : "",
u->reqnum);
if (u->error_count)
rw += str_bprintf(&tmpstr[rw], sizeof(tmpstr)-rw,
_(" E=%u"), u->error_count);
}
break;
case GTA_UL_SENDING:
{
/* Time Remaining at the current rate, in seconds */
filesize_t tr = (data->range_end + 1 - u->pos) / MAX(1, u->avg_bps);
gdouble p = uploads_gui_progress(u, data);
time_t now = tm_time();
gboolean stalled = delta_time(now, data->last_update) > IO_STALLED;
gchar pbuf[32];
size_t rw;
str_bprintf(pbuf, sizeof pbuf, "%5.02f%% ", p * 100.0);
rw = str_bprintf(tmpstr, sizeof tmpstr, _("%s(%s) TR: %s %s#%u"),
p > 1.0 ? pbuf : "",
stalled ? _("stalled")
: short_rate(u->bps, show_metric_units()),
short_time(tr),
u->parq_quick ? _("(quick) ") : "",
u->reqnum);
if (u->error_count)
rw += str_bprintf(&tmpstr[rw], sizeof(tmpstr)-rw,
_(" E=%u"), u->error_count);
}
break;
case GTA_UL_HEADERS:
return _("Waiting for headers...");
case GTA_UL_EXPECTING:
if (u->error_count)
str_bprintf(tmpstr, sizeof(tmpstr),
_("%s %s#%u E=%u"), _("Waiting for further request..."),
u->parq_quick ? _("(quick) ") : "", u->reqnum, u->error_count);
else
str_bprintf(tmpstr, sizeof(tmpstr),
"%s %s#%u", _("Waiting for further request..."),
u->parq_quick ? _("(quick) ") : "", u->reqnum);
break;
case GTA_UL_WAITING:
return _("Reading follow-up request...");
case GTA_UL_ABORTED:
return _("Transmission aborted");
case GTA_UL_CLOSED:
return _("Transmission complete");
case GTA_UL_QUEUED: /* Actively queued */
{
guint32 max_up, cur_up;
gboolean queued;
guint available = 0;
gchar tbuf[64];
size_t rw;
gnet_prop_get_guint32_val(PROP_MAX_UPLOADS, &max_up);
gnet_prop_get_guint32_val(PROP_UL_RUNNING, &cur_up);
if (cur_up < max_up)
available = max_up - cur_up;
/*
* We'll flag as "Waiting" instead of "Queued" uploads
* that are actively queued and whose position is low
* enough to possibly get scheduled at the next request,
* given the amount of free slots.
* --RAM, 2007-08-21
*/
queued = u->parq_position > available;
if (u->parq_retry > 0) {
str_bprintf(tbuf, sizeof tbuf,
" %s,", short_time(u->parq_retry));
} else {
tbuf[0] = '\0';
}
rw = str_bprintf(tmpstr, sizeof tmpstr,
_("%s [%d] (slot %d/%d)%s %s %s"),
u->parq_frozen ? _("Frozen") :
queued ? _("Queued") : _("Waiting"),
u->parq_queue_no,
u->parq_position,
u->parq_size,
tbuf,
_("lifetime:"),
short_time(u->parq_lifetime));
if (u->error_count)
rw += str_bprintf(&tmpstr[rw], sizeof(tmpstr)-rw,
_(" E=%u"), u->error_count);
}
break;
case GTA_UL_QUEUE:
/*
* PARQ wants to inform a client that action from the client its side
* is wanted. So it is trying to connect back.
* -- JA, 15/04/2003
*/
return _("Sending QUEUE, connecting back...");
case GTA_UL_QUEUE_WAITING:
/*
* PARQ made a connect back because some action from the client is
* wanted. The connection is established and now waiting for some action
* -- JA, 15/04/2003
*/
return _("Sent QUEUE, waiting for headers...");
}
return tmpstr;
}
