void show_event() {
static char desc[80];
static char t1[SHORT_TIME_LEN];
static char t2[SHORT_TIME_LEN];
if(selected_event) {
short_time(&(selected_event->start),t1);
short_time(&(selected_event->end),t2);
struct tm *tick_time = localtime(&selected_event->start);
snprintf(desc,80,"%s-%s:\n%s",t1,t2,selected_event->description);
if(selected_event->hype_id) {
if(selected_bitmap) {
gbitmap_destroy(selected_bitmap);
selected_bitmap=0;
}
selected_bitmap=gbitmap_create_with_resource(selected_event->hype_id);
bitmap_layer_set_bitmap(layer_logo, selected_bitmap);
layer_set_hidden((Layer*) layer_logo,false);
} else {
layer_set_hidden((Layer*) layer_logo,true);
}
text_layer_set_text(layer_details, desc);
// day
static char banner[30];
static char day_buffer[10];
strftime(day_buffer, 10, "%A", tick_time);
snprintf(banner,30,"%s/%s",day_buffer,get_location(selected_location_id));
text_layer_set_text(layer_location,banner);
} else {
text_layer_set_text(layer_details,"no event selected");
text_layer_set_text(layer_location,get_location(selected_location_id));
}
}
static void
cell_renderer_func(GtkTreeViewColumn *column,
GtkCellRenderer *cell, GtkTreeModel *model, GtkTreeIter *iter,
gpointer udata)
{
static const GValue zero_value;
const struct node_data *data;
const gchar *s, *attr;
GValue value;
if (!gtk_tree_view_column_get_visible(column))
return;
attr = "text";
value = zero_value;
gtk_tree_model_get_value(model, iter, 0, &value);
data = g_value_get_pointer(&value);
switch (GPOINTER_TO_UINT(udata)) {
case c_gnet_user_agent:
s = data->user_agent;
break;
case c_gnet_flags:
s = data->flags;
attr = "markup";
break;
case c_gnet_loc:
s = iso3166_country_name(data->country);
break;
case c_gnet_version:
s = data->version;
break;
case c_gnet_host:
s = data->host;
break;
case c_gnet_connected:
s = short_time(data->connected);
break;
case c_gnet_uptime:
s = data->uptime > 0 ? short_time(data->uptime) : NULL;
break;
case c_gnet_info:
s = data->info;
break;
default:
s = NULL;
}
if (data->fg) {
g_object_set(cell,
attr, s,
"foreground-gdk", data->fg,
"foreground-set", TRUE,
(void *) 0);
} else {
g_object_set(cell, attr, s, (void *) 0);
}
}
int
main(int argc, char **argv)
{
int ch, ret;
ret = 0;
while ((ch = getopt(argc, argv, "tseES")) != -1) {
switch (ch) {
case 't':
ret |= trivial();
break;
case 's':
ret |= with_signal();
break;
case 'e':
ret |= time_elapsed();
break;
case 'E':
ret |= time_elapsed_with_signal();
break;
case 'S':
ret |= short_time();
default:
fprintf(stderr, "Usage: nanosleep [-tse]\n");
exit(1);
}
}
return (ret);
}
char *
bitzi_gui_get_metadata(const bitzi_data_t *data)
{
g_assert(data != NULL);
/*
* Build string
*/
if (
data->judgment == BITZI_FJ_FAILURE ||
data->judgment == BITZI_FJ_WRONG_FILESIZE
) {
return h_strdup(bitzi_fj_to_string(data->judgment));
} else if (data->mime_type) {
if (data->mime_desc) {
return h_strdup_printf("%s (%1.1f): %s (%s)%s%s",
bitzi_fj_to_string(data->judgment),
data->goodness,
data->mime_type,
data->mime_desc,
data->duration != 0 ? "; " : "",
data->duration != 0 ? short_time(data->duration) : "");
} else {
return h_strdup_printf("%s (%1.1f): %s%s%s",
bitzi_fj_to_string(data->judgment),
data->goodness,
data->mime_type,
data->duration != 0 ? "; " : "",
data->duration != 0 ? short_time(data->duration) : "");
}
} else if (data->judgment != BITZI_FJ_UNKNOWN) {
return h_strdup_printf("%s (%1.1f): %s",
bitzi_fj_to_string(data->judgment),
data->goodness,
_("No other data"));
}
return NULL;
}
DataFrame LNLP::get_short_output()
{
vec short_time(which_pred.size(), qnan);
vec short_obs(which_pred.size(), qnan);
vec short_pred(which_pred.size(), qnan);
for(size_t i = 0; i < which_pred.size(); ++i)
{
short_time[i] = target_time[which_pred[i]];
short_obs[i] = targets[which_pred[i]];
short_pred[i] = predicted[which_pred[i]];
}
return DataFrame::create( Named("time") = short_time,
Named("obs") = short_obs,
Named("pred") = short_pred);
}
int main()
{
int requests[INPUT_SIZE];
int i = 0;
int num = 0;
while(scanf("%d", &num) == 1)
{
if (num < 0)
break;
requests[i] = num;
i++;
}
first_come(requests, i);
// short_job(requests, i);
short_time(requests, i);
round_robin(requests, i, 4);
return 0;
}
/**
* Displays assorted status information
*/
enum shell_reply
shell_exec_status(struct gnutella_shell *sh, int argc, const char *argv[])
{
const char *cur;
const option_t options[] = {
{ "i", &cur },
};
int parsed;
char buf[2048];
time_t now;
shell_check(sh);
g_assert(argv);
g_assert(argc > 0);
parsed = shell_options_parse(sh, argv, options, G_N_ELEMENTS(options));
if (parsed < 0)
return REPLY_ERROR;
argv += parsed; /* args[0] is first command argument */
argc -= parsed; /* counts only command arguments now */
now = tm_time();
/* Leading flags */
{
char flags[47];
const char *fw;
const char *fd;
const char *pmp;
const char *dht;
/*
* The flags are displayed as followed:
*
* UMP port mapping configured via UPnP
* NMP port mapping configured via NAT-PMP
* pmp port mapping available (UPnP or NAT-PMP), un-configured
* CLK clock, GTKG expired
* !FD or FD red or yellow bombs for fd shortage
* STL upload stalls
* gUL/yUL/rUL green, yellow or red upload early stalling levels
* CPU cpu overloaded
* MOV file moving
* SHA SHA-1 rebuilding or verifying
* TTH TTH rebuilding or verifying
* LIB library rescan
* :FW or FW indicates whether hole punching is possible
* udp or UDP indicates UDP firewalling (lowercased for hole punching)
* TCP indicates TCP-firewalled
* - the happy face: no firewall
* sDH/lDH/bDH seeded, own KUID looking or bootstrapping DHT
* A or P active or passive DHT mode
* UP or LF ultrapeer or leaf mode
*/
pmp = (GNET_PROPERTY(upnp_possible) || GNET_PROPERTY(natpmp_possible))
? "pmp " : empty;
if (
(GNET_PROPERTY(enable_upnp) || GNET_PROPERTY(enable_natpmp)) &&
GNET_PROPERTY(port_mapping_successful)
) {
pmp = GNET_PROPERTY(enable_natpmp) ? "NMP " : "UMP ";
}
if (dht_enabled()) {
dht = empty;
switch ((enum dht_bootsteps) GNET_PROPERTY(dht_boot_status)) {
case DHT_BOOT_NONE:
case DHT_BOOT_SHUTDOWN:
break;
case DHT_BOOT_SEEDED:
dht = "sDH ";
break;
case DHT_BOOT_OWN:
dht = "lDH ";
break;
case DHT_BOOT_COMPLETING:
dht = "bDH ";
break;
case DHT_BOOT_COMPLETED:
dht = dht_is_active() ? "A " : "P ";
break;
case DHT_BOOT_MAX_VALUE:
g_assert_not_reached();
}
} else {
dht = empty;
}
if (GNET_PROPERTY(is_firewalled) && GNET_PROPERTY(is_udp_firewalled)) {
fw = GNET_PROPERTY(recv_solicited_udp) ? ":FW " : "FW ";
} else if (GNET_PROPERTY(is_firewalled)) {
fw = "TCP ";
} else if (GNET_PROPERTY(is_udp_firewalled)) {
fw = GNET_PROPERTY(recv_solicited_udp) ? "udp " : "UDP ";
} else {
fw = "- ";
}
if (GNET_PROPERTY(file_descriptor_runout)) {
fd = "!FD ";
} else if (GNET_PROPERTY(file_descriptor_shortage)) {
fd = "FD ";
} else {
fd = empty;
}
gm_snprintf(flags, sizeof flags,
"<%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s>",
pmp,
GNET_PROPERTY(download_queue_frozen) ? "DFZ " : empty,
GNET_PROPERTY(ancient_version) ? "CLK " : empty,
fd,
GNET_PROPERTY(uploads_stalling) ? "STL " : empty,
GNET_PROPERTY(uploads_bw_ignore_stolen) ? "gUL " : empty,
GNET_PROPERTY(uploads_bw_uniform) ? "yUL " : empty,
GNET_PROPERTY(uploads_bw_no_stealing) ? "rUL " : empty,
GNET_PROPERTY(overloaded_cpu) ? "CPU " : empty,
GNET_PROPERTY(file_moving) ? "MOV " : empty,
(GNET_PROPERTY(sha1_rebuilding) || GNET_PROPERTY(sha1_verifying)) ?
"SHA " : empty,
(GNET_PROPERTY(tth_rebuilding) || GNET_PROPERTY(tth_verifying)) ?
"TTH " : empty,
GNET_PROPERTY(library_rebuilding) ? "LIB " : empty,
fw, dht,
settings_is_ultra() ? "UP" : "LF");
gm_snprintf(buf, sizeof buf,
"+%s+\n"
"| %-18s%51s |\n"
"|%s|\n",
dashes, "Status", flags, equals);
shell_write(sh, buf);
}
/* General status */
{
const char *blackout;
short_string_t leaf_switch;
short_string_t ultra_check;
leaf_switch = timestamp_get_string(
GNET_PROPERTY(node_last_ultra_leaf_switch));
ultra_check = timestamp_get_string(
GNET_PROPERTY(node_last_ultra_check));
if (GNET_PROPERTY(is_firewalled) && GNET_PROPERTY(is_udp_firewalled)) {
blackout =
GNET_PROPERTY(recv_solicited_udp) ? "TCP,udp" : "TCP,UDP";
} else if (GNET_PROPERTY(is_firewalled)) {
blackout = "TCP";
} else if (GNET_PROPERTY(is_udp_firewalled)) {
blackout = GNET_PROPERTY(recv_solicited_udp) ? "udp" : "UDP";
} else {
blackout = "None";
}
gm_snprintf(buf, sizeof buf,
"| Mode: %-9s Last Switch: %-19s%2s|\n"
"| Uptime: %-9s Last Check: %-19s%2s|\n"
"| Port: %-9u Blackout: %-7s%14s|\n"
"|%s|\n",
GNET_PROPERTY(online_mode)
? node_peermode_to_string(GNET_PROPERTY(current_peermode))
: "offline",
GNET_PROPERTY(node_last_ultra_leaf_switch)
? leaf_switch.str : "never", space,
short_time(delta_time(now, GNET_PROPERTY(start_stamp))),
GNET_PROPERTY(node_last_ultra_check)
? ultra_check.str : "never", space,
socket_listen_port(), blackout, space,
equals);
shell_write(sh, buf);
}
/* IPv4 info */
switch (GNET_PROPERTY(network_protocol)) {
case NET_USE_BOTH:
case NET_USE_IPV4:
gm_snprintf(buf, sizeof buf,
"| IPv4: %-44s Since: %-12s|\n",
host_addr_to_string(listen_addr()),
short_time(delta_time(now, GNET_PROPERTY(current_ip_stamp))));
shell_write(sh, buf);
}
/* IPv6 info */
switch (GNET_PROPERTY(network_protocol)) {
case NET_USE_BOTH:
gm_snprintf(buf, sizeof buf, "|%s|\n", dashes);
shell_write(sh, buf);
/* FALL THROUGH */
case NET_USE_IPV6:
gm_snprintf(buf, sizeof buf,
"| IPv6: %-44s Since: %-12s|\n",
host_addr_to_string(listen_addr6()),
short_time(delta_time(now, GNET_PROPERTY(current_ip6_stamp))));
shell_write(sh, buf);
}
/* Node counts */
gm_snprintf(buf, sizeof buf,
"|%s|\n"
"| Peers: %-7u Ultra %4u/%-7u Leaf %4u/%-6u Legacy %4u/%-4u |\n"
"| Downloads %4u/%-4u Uploads %4u/%-7u Browse %4u/%-4u |\n"
"|%s|\n",
equals,
GNET_PROPERTY(node_ultra_count)
+ GNET_PROPERTY(node_leaf_count)
+ GNET_PROPERTY(node_normal_count),
GNET_PROPERTY(node_ultra_count),
settings_is_ultra() ?
GNET_PROPERTY(max_connections) : GNET_PROPERTY(max_ultrapeers),
GNET_PROPERTY(node_leaf_count),
GNET_PROPERTY(max_leaves),
GNET_PROPERTY(node_normal_count),
GNET_PROPERTY(normal_connections),
GNET_PROPERTY(dl_active_count), GNET_PROPERTY(dl_running_count),
GNET_PROPERTY(ul_running), GNET_PROPERTY(ul_registered),
GNET_PROPERTY(html_browse_served) + GNET_PROPERTY(qhits_browse_served),
GNET_PROPERTY(html_browse_count) + GNET_PROPERTY(qhits_browse_count),
equals);
shell_write(sh, buf);
/* Bandwidths */
{
const bool metric = GNET_PROPERTY(display_metric_units);
short_string_t gnet_in, http_in, leaf_in, gnet_out, http_out, leaf_out;
short_string_t dht_in, dht_out;
gnet_bw_stats_t bw_stats, bw2_stats;
const char *bwtype = cur ? "(cur)" : "(avg)";
gnet_get_bw_stats(BW_GNET_IN, &bw_stats);
gnet_get_bw_stats(BW_GNET_UDP_IN, &bw2_stats);
gnet_in = short_rate_get_string(
cur ? bw_stats.current + bw2_stats.current
: bw_stats.average + bw2_stats.average, metric);
gnet_get_bw_stats(BW_GNET_OUT, &bw_stats);
gnet_get_bw_stats(BW_GNET_UDP_OUT, &bw2_stats);
gnet_out = short_rate_get_string(
cur ? bw_stats.current + bw2_stats.current
: bw_stats.average + bw2_stats.average, metric);
gnet_get_bw_stats(BW_HTTP_IN, &bw_stats);
http_in = short_rate_get_string(
cur ? bw_stats.current : bw_stats.average, metric);
gnet_get_bw_stats(BW_HTTP_OUT, &bw_stats);
http_out = short_rate_get_string(
cur ? bw_stats.current : bw_stats.average, metric);
gnet_get_bw_stats(BW_LEAF_IN, &bw_stats);
leaf_in = short_rate_get_string(
cur ? bw_stats.current : bw_stats.average, metric);
gnet_get_bw_stats(BW_LEAF_OUT, &bw_stats);
leaf_out = short_rate_get_string(
cur ? bw_stats.current : bw_stats.average, metric);
gnet_get_bw_stats(BW_DHT_IN, &bw_stats);
dht_in = short_rate_get_string(
cur ? bw_stats.current : bw_stats.average, metric);
gnet_get_bw_stats(BW_DHT_OUT, &bw_stats);
dht_out = short_rate_get_string(
cur ? bw_stats.current : bw_stats.average, metric);
gm_snprintf(buf, sizeof buf,
"| %-70s|\n"
"|%71s|\n"
"| %5s In: %13s %13s %13s %13s |\n"
"| %5s Out: %13s %13s %13s %13s |\n",
"Bandwidth:"
" Gnutella Leaf HTTP DHT",
dashes,
bwtype, gnet_in.str, leaf_in.str, http_in.str, dht_in.str,
bwtype, gnet_out.str, leaf_out.str, http_out.str, dht_out.str);
shell_write(sh, buf);
}
{
char line[128];
bool metric = GNET_PROPERTY(display_metric_units);
gm_snprintf(buf, sizeof buf, "|%s|\n", equals);
shell_write(sh, buf);
concat_strings(line, sizeof line,
"Shares ",
uint64_to_string(shared_files_scanned()),
" file",
shared_files_scanned() == 1 ? "" : "s",
" ",
short_kb_size(shared_kbytes_scanned(), metric),
" total",
(void *) 0);
gm_snprintf(buf, sizeof buf,
"| %-35s Up: %-11s Down: %-11s |\n",
line,
short_byte_size(GNET_PROPERTY(ul_byte_count), metric),
short_byte_size2(GNET_PROPERTY(dl_byte_count), metric));
shell_write(sh, buf);
gm_snprintf(buf, sizeof buf, "+%s+\n", dashes);
shell_write(sh, buf);
}
return REPLY_READY;
}
/**
* @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;
}
