void DataFlash_MAVLink::stats_log()
{
if (!_initialised || !_logging_started) {
return;
}
if (stats.collection_count == 0) {
return;
}
Log_Write_DF_MAV(*this);
#if REMOTE_LOG_DEBUGGING
printf("D:%d Retry:%d Resent:%d E:%d SF:%d/%d/%d SP:%d/%d/%d SS:%d/%d/%d SR:%d/%d/%d\n",
dropped,
_blocks_retry.sent_count,
stats.resends,
internal_errors,
stats.state_free_min,
stats.state_free_max,
stats.state_free/stats.collection_count,
stats.state_pending_min,
stats.state_pending_max,
stats.state_pending/stats.collection_count,
stats.state_sent_min,
stats.state_sent_max,
stats.state_sent/stats.collection_count,
stats.state_retry_min,
stats.state_retry_max,
stats.state_retry/stats.collection_count
);
#endif
stats_reset();
}
static inline void stats_reset(statsnode *n) {
statsnode *a;
n->counter = 0;
for (a=n->firstchild ; a ; a=a->nextsibling) {
stats_reset(a);
}
}
void stats_reset_all(void) {
statsnode *a;
pthread_mutex_lock(&glock);
for (a=firstnode ; a ; a=a->nextsibling) {
stats_reset(a);
}
pthread_mutex_unlock(&glock);
}
static void end_hotspot_period(struct smq_policy *mq)
{
clear_bitset(mq->hotspot_hit_bits, mq->nr_hotspot_blocks);
update_promote_levels(mq);
if (time_after(jiffies, mq->next_hotspot_period)) {
update_level_jump(mq);
q_redistribute(&mq->hotspot);
stats_reset(&mq->hotspot_stats);
mq->next_hotspot_period = jiffies + HOTSPOT_UPDATE_PERIOD;
}
}
static void end_cache_period(struct smq_policy *mq)
{
if (time_after(jiffies, mq->next_cache_period)) {
clear_bitset(mq->cache_hit_bits, from_cblock(mq->cache_size));
q_redistribute(&mq->dirty);
q_redistribute(&mq->clean);
stats_reset(&mq->cache_stats);
mq->next_cache_period = jiffies + CACHE_UPDATE_PERIOD;
}
}
void ovs_flow_stats_clear(struct sw_flow *flow)
{
int cpu, cur_cpu;
if (!flow->stats.is_percpu) {
stats_reset(flow->stats.stat);
} else {
cur_cpu = get_cpu();
for_each_possible_cpu(cpu) {
if (cpu == cur_cpu)
local_bh_disable();
stats_reset(per_cpu_ptr(flow->stats.cpu_stats, cpu));
if (cpu == cur_cpu)
local_bh_enable();
}
put_cpu();
}
}
gboolean gstreamer_run_pipeline(GMainLoop *loop, const char *s, StartupState state) {
main_set_real_time_scheduling_policy();
GError *error = NULL;
pipeline = gst_parse_launch(s, &error);
if (!pipeline) {
printf("Error: Could not create gstreamer pipeline.\n");
printf("Parse error: %s\n", error->message);
return FALSE;
}
bus_quit_on_playing = FALSE;
GstBus *bus;
bus = gst_pipeline_get_bus(GST_PIPELINE(pipeline));
bus_watch_id = gst_bus_add_watch(bus, bus_callback, loop);
if (main_have_gui())
#if GST_CHECK_VERSION(1, 0, 0)
gst_bus_set_sync_handler(bus, (GstBusSyncHandler)bus_sync_handler, NULL, NULL);
#else
gst_bus_set_sync_handler(bus, (GstBusSyncHandler)bus_sync_handler, NULL);
#endif
gst_object_unref(bus);
// Iterate over all elements of the pipeline to hook a handler
// listing newly created pads.
if (created_pads_list != NULL) {
g_list_free(created_pads_list);
created_pads_list = NULL;
}
GstIterator *iterator = gst_bin_iterate_elements(GST_BIN(pipeline));
gst_iterator_foreach(iterator, for_each_pipeline_element, NULL);
gst_iterator_free(iterator);
stats_reset();
gst_element_set_state(pipeline, GST_STATE_READY);
state_change_to_playing_already_occurred = FALSE;
if (state == STARTUP_PLAYING)
gst_element_set_state(pipeline, GST_STATE_PLAYING);
else
gst_element_set_state(pipeline, GST_STATE_PAUSED);
pipeline_description = s;
end_of_stream = FALSE;
inform_pipeline_destroyed_cb_list = NULL;
return TRUE;
}
static int calibrate(aeEventLoop *loop, long long id, void *data) {
thread *thread = data;
uint64_t elapsed_ms = (time_us() - thread->start) / 1000;
uint64_t req_per_ms = thread->requests / elapsed_ms;
if (!req_per_ms) return CALIBRATE_DELAY_MS / 2;
thread->rate = (req_per_ms * SAMPLE_INTERVAL_MS) / 10;
thread->start = time_us();
thread->requests = 0;
stats_reset(thread->latency);
aeCreateTimeEvent(loop, SAMPLE_INTERVAL_MS, sample_rate, thread, NULL);
return AE_NOMORE;
}
int
stats_init(config_t *config)
{
inside_screen = !is_null_or_empty(env_get(SCREEN_ENVVAR));
inside_tmux = !is_null_or_empty(env_get(TMUX_ENVVAR));
load_def_values(&curr_stats, config);
determine_fuse_umount_cmd(&curr_stats);
set_gtk_available(&curr_stats);
curr_stats.exec_env_type = get_exec_env_type();
stats_update_shell_type(config->shell);
(void)hist_init(&curr_stats.cmd_hist, config->history_len);
(void)hist_init(&curr_stats.search_hist, config->history_len);
(void)hist_init(&curr_stats.prompt_hist, config->history_len);
(void)hist_init(&curr_stats.filter_hist, config->history_len);
hists_resize(config->history_len);
return stats_reset(config);
}
static int sample_rate(aeEventLoop *loop, long long id, void *data) {
thread *thread = data;
uint64_t elapsed_ms = (time_us() - thread->start) / 1000;
uint64_t requests = (thread->requests / elapsed_ms) * 1000;
uint64_t missed = thread->rate - MIN(thread->rate, thread->latency->limit);
uint64_t count = thread->rate - missed;
pthread_mutex_lock(&statistics.mutex);
stats_sample(statistics.latency, &thread->rand, count, thread->latency);
stats_record(statistics.requests, requests);
pthread_mutex_unlock(&statistics.mutex);
uint64_t max = thread->latency->max;
thread->missed += missed;
thread->requests = 0;
thread->start = time_us();
stats_reset(thread->latency);
thread->latency->max = max;
return SAMPLE_INTERVAL_MS;
}
void gstreamer_destroy_pipeline() {
main_set_normal_scheduling_policy();
GstState state, pending;
gst_element_set_state (pipeline, GST_STATE_PAUSED);
gst_element_get_state (pipeline, &state, &pending, GST_CLOCK_TIME_NONE);
/* Iterate main loop to process pending stuff. */
while (g_main_context_iteration (NULL, FALSE));
gst_element_set_state (pipeline, GST_STATE_READY);
gst_element_get_state (pipeline, &state, &pending, GST_CLOCK_TIME_NONE);
gst_element_set_state(pipeline, GST_STATE_NULL);
g_source_remove(bus_watch_id);
gst_object_unref(GST_OBJECT(pipeline));
pipeline_description = "";
GList *list = g_list_first(inform_pipeline_destroyed_cb_list);
GValue value = G_VALUE_INIT;
g_value_init(&value, G_TYPE_POINTER);
g_value_set_pointer(&value, NULL);
while (list != NULL) {
GClosure *closure = list->data;
g_closure_invoke(closure, NULL, 1, &value, NULL);
g_closure_unref(closure);
list = g_list_next(list);
}
g_value_unset(&value);
g_list_free(inform_pipeline_destroyed_cb_list);
stats_reset();
gui_set_window_title("gstplay");
}
/*
* Start.
*/
extern void stats_start(void)
{
stats_reset();
stat_time = timer();
}
void DataFlash_MAVLink::stats_init() {
dropped = 0;
internal_errors = 0;
stats.resends = 0;
stats_reset();
}
/*
* Clear all the global "character" data
*/
static void player_wipe(void)
{
int i;
/* Hack -- free the "last message" string */
if (p_ptr->last_message) z_string_free(p_ptr->last_message);
/* Hack -- zero the struct */
(void)WIPE(p_ptr, player_type);
p_ptr->mimic_form = MIMIC_NONE;
/* Start with no artifacts made yet */
for (i = 0; i < max_a_idx; i++)
{
artifact_type *a_ptr = &a_info[i];
a_ptr->generated = FALSE;
a_ptr->found = FALSE;
}
/* Reset the objects */
k_info_reset();
e_info_reset();
stats_reset();
/* Reset the "monsters" */
for (i = 1; i < max_r_idx; i++)
{
monster_race *r_ptr = &r_info[i];
/* Hack -- Reset the counter */
r_ptr->cur_num = 0;
/* Hack -- Reset the max counter */
r_ptr->max_num = 100;
r_ptr->flagsx = 0;
/* Hack -- Reset the max counter */
if (r_ptr->flags1 & RF1_UNIQUE) r_ptr->max_num = 1;
/* Hack -- Non-unique Nazguls are semi-unique */
else if (r_ptr->flags7 & RF7_NAZGUL) r_ptr->max_num = MAX_NAZGUL_NUM;
else if (i == MON_CAMELOT_KNIGHT) r_ptr->max_num = MAX_CAMELOT_KNIGHT_NUM;
/* Clear visible kills in this life */
r_ptr->r_pkills = 0;
/* Clear all kills in this life */
r_ptr->r_akills = 0;
r_ptr->r_skills = 0;
r_ptr->stolen_ct = 0;
/* Wipe out pact alliances from previous character
Currently, flagsr is only set to make the memory field
work, but perhaps it would be better to set this once
and for all when a pact is made? This would break
my savefiles though ...*/
r_ptr->flagsr &= ~(RFR_PACT_MONSTER);
r_ptr->r_flagsr &= ~(RFR_PACT_MONSTER);
}
/* Hack -- Well fed player */
p_ptr->food = PY_FOOD_FULL - 1;
/* Wipe the spells */
if (p_ptr->pclass == CLASS_SORCERER)
{
p_ptr->spell_learned1 = p_ptr->spell_learned2 = 0xffffffffL;
p_ptr->spell_worked1 = p_ptr->spell_worked2 = 0xffffffffL;
}
else
{
p_ptr->spell_learned1 = p_ptr->spell_learned2 = 0L;
p_ptr->spell_worked1 = p_ptr->spell_worked2 = 0L;
}
p_ptr->spell_forgotten1 = p_ptr->spell_forgotten2 = 0L;
for (i = 0; i < 64; i++) p_ptr->spell_order[i] = 99;
p_ptr->learned_spells = 0;
p_ptr->add_spells = 0;
p_ptr->knowledge = 0;
/* Clean the mutation count */
mutant_regenerate_mod = 100;
/* Clear "cheat" options */
cheat_peek = FALSE;
cheat_hear = FALSE;
cheat_room = FALSE;
cheat_xtra = FALSE;
cheat_live = FALSE;
cheat_save = FALSE;
/* Assume no winning game */
p_ptr->total_winner = FALSE;
world_player = FALSE;
/* Assume no panic save */
p_ptr->panic_save = 0;
/* Assume no cheating */
p_ptr->noscore = 0;
p_ptr->wizard = FALSE;
/* Not waiting to report score */
p_ptr->wait_report_score = FALSE;
/* Default pet command settings */
p_ptr->pet_follow_distance = PET_FOLLOW_DIST;
p_ptr->pet_extra_flags = (PF_TELEPORT | PF_ATTACK_SPELL | PF_SUMMON_SPELL);
/* Wipe the recall depths */
for (i = 0; i < max_d_idx; i++)
{
max_dlv[i] = 0;
dungeon_flags[i] = 0;
}
p_ptr->wild_mode = FALSE;
for (i = 0; i < MAX_MAGIC_NUM; i++)
{
p_ptr->magic_num1[i] = 0;
p_ptr->magic_num2[i] = 0;
}
/* Level one */
p_ptr->max_plv = p_ptr->lev = 1;
/* Initialize arena and rewards information -KMW- */
p_ptr->arena_number = 0;
p_ptr->inside_arena = FALSE;
for (i = 0; i < MAX_MANE; i++)
{
p_ptr->mane_spell[i] = -1;
p_ptr->mane_dam[i] = 0;
}
p_ptr->mane_num = 0;
p_ptr->exit_bldg = TRUE; /* only used for arena now -KMW- */
/* Bounty */
p_ptr->today_mon = 0;
/* Reset monster arena */
battle_monsters();
/* Reset mutations */
for (i = 0; i < MUT_FLAG_SIZE; ++i)
{
p_ptr->muta[i] = 0;
p_ptr->muta_lock[i] = 0;
}
for (i = 0; i < MAX_DEMIGOD_POWERS; ++i)
p_ptr->demigod_power[i] = -1;
p_ptr->draconian_power = -1;
p_ptr->duelist_target_idx = 0;
/* Reset virtues*/
for (i = 0; i < 8; i++) p_ptr->virtues[i]=0;
/* Set the recall dungeon accordingly */
if (no_wilderness)
{
dungeon_type = 0;
p_ptr->recall_dungeon = DUNGEON_ANGBAND;
}
else
{
dungeon_type = 0;
p_ptr->recall_dungeon = DUNGEON_STRONGHOLD;
}
}
u08 cmd_parse(u08 len, const char *cmd)
{
u08 status;
switch(cmd[0]) {
// ----- v) version -----
case 'v':
uart_send_string("plip2slip " VERSION);
uart_send_crlf();
return SER_PARSE_CMD_OK;
// ----- x) exit -----
case 'x':
return SER_PARSE_CMD_EXIT;
// ----- s) stats -----
case 's':
if(len==1) {
// show stats
stats_dump();
return SER_PARSE_CMD_OK;
} else {
switch(cmd[1]) {
case 'r': // stats reset
stats_reset();
return SER_PARSE_CMD_OK;
default:
return SER_PARSE_CMD_UNKNOWN;
}
}
// ----- b) bench -----
case 'b':
bench_dump();
return SER_PARSE_CMD_OK;
// ----- p) param -----
case 'p':
if(len==1) {
// show params
param_dump();
return SER_PARSE_CMD_OK;
} else {
switch(cmd[1]) {
case 's': // param save
status = param_save();
return (status == PARAM_OK) ? SER_PARSE_CMD_OK : SER_PARSE_CMD_FAIL;
case 'l': // param load
status = param_load();
return (status == PARAM_OK) ? SER_PARSE_CMD_OK : SER_PARSE_CMD_FAIL;
case 'r': // param reset
param_reset();
return SER_PARSE_CMD_OK;
default:
return SER_PARSE_CMD_UNKNOWN;
}
}
return SER_PARSE_CMD_UNKNOWN;
// ----- m) mode -----
case 'm':
if(len==2) {
u08 value;
status = parse_nybble(cmd[1],&value);
if(!status || (value >= PARAM_MODE_TOTAL_NUMBER)) {
return SER_PARSE_CMD_FAIL;
}
param.mode = value;
return SER_PARSE_CMD_OK;
}
return SER_PARSE_CMD_UNKNOWN;
// ----- f) fake_tx -----
case 'f':
if(len==2) {
u08 value;
status = parse_nybble(cmd[1],&value);
if(!status) {
return SER_PARSE_CMD_FAIL;
}
param.fake_tx = value ? 1 : 0;
return SER_PARSE_CMD_OK;
}
return SER_PARSE_CMD_UNKNOWN;
// ----- l) log -----
case 'l':
if(len==1) {
// show log
log_dump();
return SER_PARSE_CMD_OK;
} else {
switch(cmd[1]) {
case 'r': // reset log
log_init();
return SER_PARSE_CMD_OK;
default:
return SER_PARSE_CMD_UNKNOWN;
}
}
return SER_PARSE_CMD_UNKNOWN;
// ----- e) error sim -----
case 'e':
if(len==2) {
u08 value;
status = parse_nybble(cmd[1],&value);
if(!status) {
return SER_PARSE_CMD_FAIL;
}
for(u08 i=0;i<value;i++) {
error_add();
}
return SER_PARSE_CMD_OK;
} else {
error_add();
}
return SER_PARSE_CMD_OK;
// unknown command
default:
return SER_PARSE_CMD_UNKNOWN;
}
}
void process_stat(conn *c, char *command) {
time_t now = time(0);
if (strcmp(command, "stats") == 0) {
char temp[512];
/* we report curr_conns - 1, because one conn is the listening one */
sprintf(temp, "STAT curr_items %u\r\nSTAT total_items %u\r\nSTAT bytes %llu\r\nSTAT curr_connections %u\r\nSTAT total_connections %u\r\nSTAT connection_structures %u\r\nSTAT age %u\r\nSTAT cmd_get %u\r\nSTAT cmd_set %u\r\nSTAT get_hits %u\r\nSTAT get_misses %u\r\nSTAT bytes_read %llu\r\nSTAT bytes_written %llu\r\nSTAT limit_maxbytes %u\r\nSTAT limit_maxitems %u\r\nEND",
stats.curr_items, stats.total_items, stats.curr_bytes, stats.curr_conns - 1, stats.total_conns, stats.conn_structs, (items_tail ? now - items_tail->time : 0), stats.get_cmds, stats.set_cmds, stats.get_hits, stats.get_misses, stats.bytes_read, stats.bytes_written, settings.maxbytes, settings.maxitems);
out_string(c, temp);
return;
}
if (strcmp(command, "stats reset") == 0) {
stats_reset();
out_string(c, "RESET");
}
if (strncmp(command, "stats cachedump", 15) == 0) {
char *start = command + 15;
int limit = 0;
int memlimit = 2*1024*1024;
char *buffer;
int bufcurr;
item *it = items_head;
int bytes = 0;
int len;
int shown = 0;
char temp[256];
limit = atoi(start);
buffer = malloc(memlimit);
if (buffer == 0) {
out_string(c, "SERVER_ERROR out of memory");
return;
}
bufcurr = 0;
while(1) {
if(limit && shown >=limit)
break;
if (!it)
break;
sprintf(temp, "ITEM %s [%u b; %u s]\r\n", it->key, it->nbytes - 2, it->time);
len = strlen(temp);
if (bufcurr + len +5 > memlimit) /* 5 is END\r\n */
break;
strcpy(buffer + bufcurr, temp);
bufcurr+=len;
shown++;
it = it->next;
}
strcpy(buffer+bufcurr, "END\r\n");
bufcurr+=5;
c->write_and_free = buffer;
c->wcurr = buffer;
c->wbytes = bufcurr;
c->state = conn_write;
return;
}
}
u08 bridge_loop(void)
{
u08 result = CMD_WORKER_IDLE;
uart_send_time_stamp_spc();
uart_send_pstring(PSTR("[BRIDGE] on\r\n"));
pb_proto_init(fill_pkt, proc_pkt, pkt_buf, PKT_BUF_SIZE);
pio_init(param.mac_addr, pio_util_get_init_flags());
stats_reset();
// online flag
flags = 0;
req_is_pending = 0;
u08 flow_control = param.flow_ctl;
u08 limit_flow = 0;
u08 first = 1;
while(run_mode == RUN_MODE_BRIDGE) {
// handle commands
result = cmd_worker();
if(result & CMD_WORKER_RESET) {
break;
}
// handle pbproto
pb_util_handle();
// incoming packet via PIO available?
u08 n = pio_has_recv();
if(n>0) {
// show first incoming packet
if(first) {
first = 0;
uart_send_time_stamp_spc();
uart_send_pstring(PSTR("FIRST INCOMING!\r\n"));
}
// if we are online then request the packet receiption
if(flags & FLAG_ONLINE) {
// if no request is pending then request it
trigger_request();
}
// offline: get and drop pio packet
else {
u16 size;
pio_util_recv_packet(&size);
uart_send_time_stamp_spc();
uart_send_pstring(PSTR("OFFLINE DROP: "));
uart_send_hex_word(size);
uart_send_crlf();
}
}
// flow control
if(flow_control) {
// flow limited
if(limit_flow) {
// disable again?
if(n==0) {
pio_control(PIO_CONTROL_FLOW, 0);
limit_flow = 0;
if(global_verbose) {
uart_send_time_stamp_spc();
uart_send_pstring(PSTR("FLOW off\r\n"));
}
}
}
// no flow limit
else {
// enable?
if(n>1) {
pio_control(PIO_CONTROL_FLOW, 1);
limit_flow = 1;
if(global_verbose) {
uart_send_time_stamp_spc();
uart_send_pstring(PSTR("FLOW on\r\n"));
}
}
}
}
}
stats_dump_all();
pio_exit();
uart_send_time_stamp_spc();
uart_send_pstring(PSTR("[BRIDGE] off\r\n"));
return result;
}
void process_stat(conn *c, char *command) {
time_t now = time(0);
if (strcmp(command, "stats") == 0) {
char temp[1024];
pid_t pid = getpid();
char *pos = temp;
struct rusage usage;
getrusage(RUSAGE_SELF, &usage);
pos += sprintf(pos, "STAT pid %u\r\n", pid);
pos += sprintf(pos, "STAT uptime %lu\r\n", now - stats.started);
pos += sprintf(pos, "STAT time %ld\r\n", now);
pos += sprintf(pos, "STAT version " VERSION "\r\n");
pos += sprintf(pos, "STAT rusage_user %ld.%06ld\r\n", usage.ru_utime.tv_sec, usage.ru_utime.tv_usec);
pos += sprintf(pos, "STAT rusage_system %ld.%06ld\r\n", usage.ru_stime.tv_sec, usage.ru_stime.tv_usec);
pos += sprintf(pos, "STAT curr_items %u\r\n", stats.curr_items);
pos += sprintf(pos, "STAT total_items %u\r\n", stats.total_items);
pos += sprintf(pos, "STAT bytes %llu\r\n", stats.curr_bytes);
pos += sprintf(pos, "STAT curr_connections %u\r\n", stats.curr_conns - 1); /* ignore listening conn */
pos += sprintf(pos, "STAT total_connections %u\r\n", stats.total_conns);
pos += sprintf(pos, "STAT connection_structures %u\r\n", stats.conn_structs);
pos += sprintf(pos, "STAT cmd_get %u\r\n", stats.get_cmds);
pos += sprintf(pos, "STAT cmd_set %u\r\n", stats.set_cmds);
pos += sprintf(pos, "STAT get_hits %u\r\n", stats.get_hits);
pos += sprintf(pos, "STAT get_misses %u\r\n", stats.get_misses);
pos += sprintf(pos, "STAT bytes_read %llu\r\n", stats.bytes_read);
pos += sprintf(pos, "STAT bytes_written %llu\r\n", stats.bytes_written);
pos += sprintf(pos, "STAT limit_maxbytes %u\r\n", settings.maxbytes);
pos += sprintf(pos, "END");
out_string(c, temp);
return;
}
if (strcmp(command, "stats reset") == 0) {
stats_reset();
out_string(c, "RESET");
return;
}
#ifdef HAVE_MALLOC_H
#ifdef HAVE_STRUCT_MALLINFO
if (strcmp(command, "stats malloc") == 0) {
char temp[512];
struct mallinfo info;
char *pos = temp;
info = mallinfo();
pos += sprintf(pos, "STAT arena_size %d\r\n", info.arena);
pos += sprintf(pos, "STAT free_chunks %d\r\n", info.ordblks);
pos += sprintf(pos, "STAT fastbin_blocks %d\r\n", info.smblks);
pos += sprintf(pos, "STAT mmapped_regions %d\r\n", info.hblks);
pos += sprintf(pos, "STAT mmapped_space %d\r\n", info.hblkhd);
pos += sprintf(pos, "STAT max_total_alloc %d\r\n", info.usmblks);
pos += sprintf(pos, "STAT fastbin_space %d\r\n", info.fsmblks);
pos += sprintf(pos, "STAT total_alloc %d\r\n", info.uordblks);
pos += sprintf(pos, "STAT total_free %d\r\n", info.fordblks);
pos += sprintf(pos, "STAT releasable_space %d\r\nEND", info.keepcost);
out_string(c, temp);
return;
}
#endif /* HAVE_STRUCT_MALLINFO */
#endif /* HAVE_MALLOC_H */
if (strcmp(command, "stats maps") == 0) {
char *wbuf;
int wsize = 8192; /* should be enough */
int fd;
int res;
wbuf = (char *)malloc(wsize);
if (wbuf == 0) {
out_string(c, "SERVER_ERROR out of memory");
return;
}
fd = open("/proc/self/maps", O_RDONLY);
if (fd == -1) {
out_string(c, "SERVER_ERROR cannot open the maps file");
free(wbuf);
return;
}
res = read(fd, wbuf, wsize - 6); /* 6 = END\r\n\0 */
if (res == wsize - 6) {
out_string(c, "SERVER_ERROR buffer overflow");
free(wbuf);
close(fd);
return;
}
if (res == 0 || res == -1) {
out_string(c, "SERVER_ERROR can't read the maps file");
free(wbuf);
close(fd);
return;
}
strcpy(wbuf + res, "END\r\n");
c->write_and_free=wbuf;
c->wcurr=wbuf;
c->wbytes = res + 6;
c->state = conn_write;
c->write_and_go = conn_read;
close(fd);
return;
}
if (strncmp(command, "stats cachedump", 15) == 0) {
char *buf;
unsigned int bytes, id, limit = 0;
char *start = command + 15;
if (sscanf(start, "%u %u\r\n", &id, &limit) < 1) {
out_string(c, "CLIENT_ERROR bad command line");
return;
}
buf = item_cachedump(id, limit, &bytes);
if (buf == 0) {
out_string(c, "SERVER_ERROR out of memory");
return;
}
c->write_and_free = buf;
c->wcurr = buf;
c->wbytes = bytes;
c->state = conn_write;
c->write_and_go = conn_read;
return;
}
if (strcmp(command, "stats slabs")==0) {
int bytes = 0;
char *buf = slabs_stats(&bytes);
if (!buf) {
out_string(c, "SERVER_ERROR out of memory");
return;
}
c->write_and_free = buf;
c->wcurr = buf;
c->wbytes = bytes;
c->state = conn_write;
c->write_and_go = conn_read;
return;
}
if (strcmp(command, "stats items")==0) {
char buffer[4096];
item_stats(buffer, 4096);
out_string(c, buffer);
return;
}
if (strcmp(command, "stats sizes")==0) {
int bytes = 0;
char *buf = item_stats_sizes(&bytes);
if (! buf) {
out_string(c, "SERVER_ERROR out of memory");
return;
}
c->write_and_free = buf;
c->wcurr = buf;
c->wbytes = bytes;
c->state = conn_write;
c->write_and_go = conn_read;
return;
}
out_string(c, "ERROR");
}
void cmd_get(int argc, char **argv)
{
list *gl;
int opt=GET_VERBOSE, c;
char *logfile = 0;
pid_t pid;
struct group *grp;
char *get_output = 0;
int stat_thresh = gvStatsThreshold;
#ifdef HAVE_REGEX
int ret;
char get_rx_errbuf[129];
#endif
struct option longopts[] = {
{"append", no_argument, 0, 'a'},
{"chmod", required_argument, 0, 'c'},
{"chgrp", required_argument, 0, '2'},
{"no-dereference", no_argument, 0, 'd'},
{"delete-after", no_argument, 0, 'D'},
{"dir-mask", required_argument, 0, '3'},
#ifdef HAVE_REGEX
{"dir-rx-mask", required_argument, 0, '4'},
#endif
{"interactive", no_argument, 0, 'i'},
{"skip-empty", no_argument, 0, 'e'},
{"force", no_argument, 0, 'f'},
{"force-newer", no_argument, 0, 'F'},
{"logfile", required_argument, 0, 'L'},
{"mask", required_argument, 0, 'm'},
#ifdef HAVE_REGEX
{"rx-mask", required_argument, 0, 'M'},
#endif
{"newer", no_argument, 0, 'n'},
{"nohup", no_argument, 0, 'H'},
{"verbose", no_argument, 0, 'v'},
{"preserve", no_argument, 0, 'p'},
{"parents", no_argument, 0, 'P'},
{"quiet", no_argument, 0, 'q'},
{"recursive", no_argument, 0, 'r'},
{"resume", no_argument, 0, 'R'},
{"skip-existing", no_argument, 0, 's'},
{"stats", optional_argument, 0, 'S'},
{"tagged", no_argument, 0, 't'},
{"type", required_argument, 0, '1'},
{"unique", no_argument, 0, 'u'},
{"output", required_argument, 0, 'o'},
{"help", no_argument, 0, 'h'},
{0, 0, 0, 0},
};
if(cmod) {
mode_free(cmod);
cmod = 0;
}
if(get_glob_mask) {
free(get_glob_mask);
get_glob_mask = 0;
}
if(get_dir_glob_mask) {
free(get_dir_glob_mask);
get_dir_glob_mask = 0;
}
#ifdef HAVE_REGEX
if(get_rx_mask_set) {
regfree(&get_rx_mask);
get_rx_mask_set = 0;
}
if(get_dir_rx_mask_set) {
regfree(&get_dir_rx_mask);
get_dir_rx_mask_set = 0;
}
#endif
get_skip_empty = false;
optind = 0; /* force getopt() to re-initialize */
while((c=getopt_long(argc, argv, "abHc:dDeio:fFL:tnpPvqrRsuT:m:M:",
longopts, 0)) != EOF)
{
switch(c) {
case 'a':
opt |= GET_APPEND;
break;
case 'c':
cmod = mode_compile(optarg, MODE_MASK_ALL);
if(cmod == NULL) {
fprintf(stderr, _("Invalid mode for --chmod: %s\n"), optarg);
return;
}
opt |= GET_CHMOD;
break;
case '2': /* --chgrp */
grp = getgrnam(optarg);
if(grp == 0) {
fprintf(stderr, _("%s is not a valid group name\n"), optarg);
return;
}
{
int i;
for(i=0; grp->gr_mem && grp->gr_mem[i]; i++) {
if(strcmp(gvUsername, grp->gr_mem[i]) == 0)
break;
}
if(!grp->gr_mem[i]) {
fprintf(stderr,
_("you are not a member of group %s\n"), optarg);
return;
}
}
group_change = grp->gr_gid;
opt |= GET_CHGRP;
break;
case 'D':
opt |= GET_DELETE_AFTER;
break;
case 'd':
opt |= GET_NO_DEREFERENCE;
break;
case 'e':
opt |= GET_SKIP_EMPTY;
get_skip_empty = true;
break;
case '3': /* --dir-mask=GLOB */
free(get_dir_glob_mask);
get_dir_glob_mask = xstrdup(optarg);
unquote(get_dir_glob_mask);
break;
#ifdef HAVE_REGEX
case '4': /* --dir-rx-mask=REGEXP */
if(get_dir_rx_mask_set) {
regfree(&get_dir_rx_mask);
get_dir_rx_mask_set = false;
}
unquote(optarg);
ret = regcomp(&get_dir_rx_mask, optarg, REG_EXTENDED);
if(ret != 0) {
regerror(ret, &get_dir_rx_mask, get_rx_errbuf, sizeof(get_rx_errbuf) - 1);
ftp_err(_("Regexp '%s' failed: %s\n"), optarg, get_rx_errbuf);
return;
} else
get_dir_rx_mask_set = true;
break;
#endif
case 'i':
opt |= GET_INTERACTIVE;
break;
case 'f':
opt |= GET_FORCE;
break;
case 'F':
opt |= GET_FORCE_NEWER;
break;
case 'm': /* --mask */
free(get_glob_mask);
get_glob_mask = xstrdup(optarg);
unquote(get_glob_mask);
break;
#ifdef HAVE_REGEX
case 'M': /* --rx-mask */
if(get_rx_mask_set) {
regfree(&get_rx_mask);
get_rx_mask_set = false;
}
unquote(optarg);
ret = regcomp(&get_rx_mask, optarg, REG_EXTENDED);
if(ret != 0) {
regerror(ret, &get_rx_mask, get_rx_errbuf, sizeof(get_rx_errbuf) - 1);
ftp_err(_("Regexp '%s' failed: %s\n"), optarg, get_rx_errbuf);
return;
} else
get_rx_mask_set = true;
break;
#endif
case 'o':
get_output = tilde_expand_home(optarg, gvLocalHomeDir);
/*stripslash(get_output);*/
unquote(get_output);
break;
case 'v':
opt |= GET_VERBOSE;
break;
case 'p':
opt |= GET_PRESERVE;
break;
case 'P':
opt |= GET_PARENTS;
break;
case 'H':
opt |= GET_NOHUP;
break;
case 'q':
opt &= ~GET_VERBOSE;
break;
case 'r':
opt |= GET_RECURSIVE;
break;
case 's':
opt |= GET_SKIP_EXISTING;
break;
case 'S':
stat_thresh = optarg ? atoi(optarg) : 0;
break;
case 'R':
opt |= GET_RESUME;
break;
case '1':
if(strncmp(optarg, "ascii", strlen(optarg)) == 0)
opt |= GET_ASCII;
else if(strncmp(optarg, "binary", strlen(optarg)) == 0)
opt |= GET_BINARY;
else {
printf(_("Invalid option argument --type=%s\n"), optarg);
return;
}
break;
case 'u':
opt |= GET_UNIQUE;
break;
case 'L':
free(logfile);
logfile = xstrdup(optarg);
unquote(logfile);
break;
case 't':
opt |= GET_TAGGED;
break;
case 'n':
opt |= GET_NEWER;
break;
case 'h':
print_get_syntax();
return;
case '?':
return;
}
}
if(optind>=argc && !test(opt, GET_TAGGED)) {
minargs(optind);
return;
}
need_connected();
need_loggedin();
gl = rglob_create();
while(optind < argc) {
stripslash(argv[optind]);
if(rglob_glob(gl, argv[optind], true, true, get_exclude_func) == -1)
fprintf(stderr, _("%s: no matches found\n"), argv[optind]);
optind++;
}
if(list_numitem(gl) == 0 && !test(opt, GET_TAGGED)) {
rglob_destroy(gl);
return;
}
if(test(opt, GET_TAGGED)
&& (!ftp->taglist || list_numitem(ftp->taglist)==0))
{
printf(_("no tagged files\n"));
if(list_numitem(gl) == 0) {
rglob_destroy(gl);
return;
}
}
get_quit = false;
get_batch = get_owbatch = get_delbatch = test(opt, GET_FORCE);
if(test(opt, GET_FORCE))
opt &= ~GET_INTERACTIVE;
if(get_output && !test(opt, GET_RECURSIVE) && list_numitem(gl) +
(test(opt, GET_TAGGED) ? list_numitem(ftp->taglist) : 0) == 1)
{
/* if the argument to --output ends with a slash, we assume the
* user wants the destination to be a directory
*/
char *e = strrchr(get_output, 0);
if(e && e[-1] != '/')
opt |= GET_OUTPUT_FILE;
}
stats_reset(gvStatsTransfer);
gvInTransfer = true;
gvInterrupted = false;
if(test(opt, GET_NOHUP)) {
int r = 0;
pid = fork();
if(pid == 0) {
r = transfer_init_nohup(logfile);
if(r != 0)
exit(0);
}
if(r != 0)
return;
if(pid == 0) { /* child process */
transfer_begin_nohup(argc, argv);
if(!test(opt, GET_FORCE) && !test(opt, GET_RESUME))
opt |= GET_UNIQUE;
opt |= GET_FORCE;
if(list_numitem(gl))
getfiles(gl, opt, get_output);
rglob_destroy(gl);
if(ftp->taglist && test(opt, GET_TAGGED))
getfiles(ftp->taglist, opt, get_output);
free(get_output);
transfer_end_nohup();
}
if(pid == -1) {
perror("fork()");
return;
}
/* parent process */
sleep(1);
printf("%d\n", pid);
input_save_history();
gvars_destroy();
reset_xterm_title();
exit(0);
}
if(list_numitem(gl))
getfiles(gl, opt, get_output);
rglob_destroy(gl);
if(ftp->taglist && test(opt, GET_TAGGED))
getfiles(ftp->taglist, opt, get_output);
free(get_output);
mode_free(cmod);
cmod = 0;
gvInTransfer = false;
stats_display(gvStatsTransfer, stat_thresh);
}
Stats *stats_create(void)
{
Stats *stats = (Stats *)xmalloc(sizeof(Stats));
stats_reset(stats);
return stats;
}
void
vifm_restart(void)
{
view_t *tmp_view;
curr_stats.restart_in_progress = 1;
/* All user mappings in all modes. */
vle_keys_user_clear();
/* User defined commands. */
vle_cmds_run("comclear");
/* Autocommands. */
vle_aucmd_remove(NULL, NULL);
/* All kinds of histories. */
cfg_resize_histories(0);
/* Session status. Must be reset _before_ options, because options take some
* of values from status. */
(void)stats_reset(&cfg);
/* Options of current pane. */
vle_opts_restore_defaults();
/* Options of other pane. */
tmp_view = curr_view;
curr_view = other_view;
load_view_options(other_view);
vle_opts_restore_defaults();
curr_view = tmp_view;
/* File types and viewers. */
ft_reset(curr_stats.exec_env_type == EET_EMULATOR_WITH_X);
/* Undo list. */
un_reset();
/* Directory stack. */
dir_stack_clear();
/* Registers. */
regs_reset();
/* Clear all marks and bookmarks. */
clear_all_marks();
bmarks_clear();
/* Reset variables. */
clear_envvars();
init_variables();
/* This update is needed as clear_variables() will reset $PATH. */
update_path_env(1);
reset_views();
read_info_file(1);
flist_hist_save(&lwin, NULL, NULL, -1);
flist_hist_save(&rwin, NULL, NULL, -1);
/* Color schemes. */
if(stroscmp(curr_stats.color_scheme, DEF_CS_NAME) != 0 &&
cs_exists(curr_stats.color_scheme))
{
cs_load_primary(curr_stats.color_scheme);
}
else
{
cs_load_defaults();
}
cs_load_pairs();
cfg_load();
/* Reloading of tabs needs to happen after configuration is read so that new
* values from lwin and rwin got propagated. */
tabs_reload();
exec_startup_commands(&vifm_args);
curr_stats.restart_in_progress = 0;
/* Trigger auto-commands for initial directories. */
(void)vifm_chdir(flist_get_dir(&lwin));
vle_aucmd_execute("DirEnter", flist_get_dir(&lwin), &lwin);
(void)vifm_chdir(flist_get_dir(&rwin));
vle_aucmd_execute("DirEnter", flist_get_dir(&rwin), &rwin);
update_screen(UT_REDRAW);
}
