void document_header(void) {
char date_time[MAX_DATETIME_LENGTH];
time_t expire_time;
time_t current_time;
time(¤t_time);
printf("Cache-Control: no-store\r\n");
printf("Pragma: no-cache\r\n");
get_time_string(¤t_time, date_time, (int)sizeof(date_time), HTTP_DATE_TIME);
printf("Last-Modified: %s\r\n", date_time);
expire_time = (time_t)0L;
get_time_string(&expire_time, date_time, (int)sizeof(date_time), HTTP_DATE_TIME);
printf("Expires: %s\r\n", date_time);
printf("Content-type: text/vnd.wap.wml\r\n\r\n");
printf("<?xml version=\"1.0\"?>\n");
printf("<!DOCTYPE wml PUBLIC \"-//WAPFORUM//DTD WML 1.1//EN\" \"http://www.wapforum.org/DTD/wml_1.1.xml\">\n");
printf("<wml>\n");
printf("<head>\n");
printf("<meta forua=\"true\" http-equiv=\"Cache-Control\" content=\"max-age=0\"/>\n");
printf("</head>\n");
return;
}
/*
* Print statistics in global/process pane. Called by print_sysglobal
* print_process.
*
* Parameters:
* window - the global or process statistics window.
* begin_line - where to start printing.
* count - how many lines should be printed.
* list - a stat_list.
*/
static void
print_statistics(WINDOW * window, int begin_line, int nlines, void *list)
{
uint64_t total;
int i = 0;
if (!display_initialized) {
return;
}
total = lt_stat_list_get_gtotal(list);
if (total == 0) {
return;
}
while (i < nlines && lt_stat_list_has_item(list, i)) {
char tmp[WIDTH_REASON_STRING];
const char *reason = lt_stat_list_get_reason(list, i);
uint64_t count = lt_stat_list_get_count(list, i);
if (count == 0) {
continue;
}
(void) snprintf(tmp, sizeof (tmp), "%s", reason);
(void) mvwprintw(window, i + begin_line, 0, "%s", tmp);
(void) snprintf(tmp, sizeof (tmp), "%llu", count);
fill_space_left(tmp, WIDTH_COUNT, sizeof (tmp));
(void) mvwprintw(window, i + begin_line, BEGIN_COUNT,
"%s", tmp);
(void) mvwprintw(window, i + begin_line, BEGIN_AVG,
"%s", get_time_string(
(double)lt_stat_list_get_sum(list, i) / count,
tmp, sizeof (tmp), WIDTH_AVG));
(void) mvwprintw(window, i + begin_line, BEGIN_MAX,
"%s", get_time_string(
(double)lt_stat_list_get_max(list, i),
tmp, sizeof (tmp), WIDTH_MAX));
if (LT_LIST_SPECIALS != current_list_type) {
(void) snprintf(tmp, sizeof (tmp), "%.1f %%",
(double)lt_stat_list_get_sum(list, i)
/ total * 100.0);
} else {
(void) snprintf(tmp, sizeof (tmp), "--- ");
}
fill_space_left(tmp, WIDTH_PCT, sizeof (tmp));
(void) mvwprintw(window, i + begin_line, BEGIN_PCT,
"%s", tmp);
i++;
}
}
static void show_total_dive_stats(void)
{
double value;
int decimals, seconds;
const char *unit;
char buffer[60];
stats_t *stats_ptr;
if (!stats_w.framelabel)
return;
stats_ptr = &stats_selection;
get_selected_dives_text(buffer, sizeof(buffer));
set_label(stats_w.framelabel, _("Statistics %s"), buffer);
set_label(stats_w.selection_size, "%d", stats_ptr->selection_size);
if (stats_ptr->selection_size == 0) {
clear_stats_widgets();
return;
}
if (stats_ptr->min_temp) {
value = get_temp_units(stats_ptr->min_temp, &unit);
set_label(stats_w.min_temp, "%.1f %s", value, unit);
}
if (stats_ptr->combined_temp && stats_ptr->combined_count)
set_label(stats_w.avg_temp, "%.1f %s", stats_ptr->combined_temp / stats_ptr->combined_count, unit);
if (stats_ptr->max_temp) {
value = get_temp_units(stats_ptr->max_temp, &unit);
set_label(stats_w.max_temp, "%.1f %s", value, unit);
}
set_label(stats_w.total_time, get_time_string(stats_ptr->total_time.seconds, 0));
seconds = stats_ptr->total_time.seconds;
if (stats_ptr->selection_size)
seconds /= stats_ptr->selection_size;
set_label(stats_w.avg_time, get_time_string(seconds, 0));
set_label(stats_w.longest_time, get_time_string(stats_ptr->longest_time.seconds, 0));
set_label(stats_w.shortest_time, get_time_string(stats_ptr->shortest_time.seconds, 0));
value = get_depth_units(stats_ptr->max_depth.mm, &decimals, &unit);
set_label(stats_w.max_overall_depth, "%.*f %s", decimals, value, unit);
value = get_depth_units(stats_ptr->min_depth.mm, &decimals, &unit);
set_label(stats_w.min_overall_depth, "%.*f %s", decimals, value, unit);
value = get_depth_units(stats_ptr->avg_depth.mm, &decimals, &unit);
set_label(stats_w.avg_overall_depth, "%.*f %s", decimals, value, unit);
value = get_volume_units(stats_ptr->max_sac.mliter, &decimals, &unit);
set_label(stats_w.max_sac, _("%.*f %s/min"), decimals, value, unit);
value = get_volume_units(stats_ptr->min_sac.mliter, &decimals, &unit);
set_label(stats_w.min_sac, _("%.*f %s/min"), decimals, value, unit);
value = get_volume_units(stats_ptr->avg_sac.mliter, &decimals, &unit);
set_label(stats_w.avg_sac, _("%.*f %s/min"), decimals, value, unit);
}
/*
* Print per-thread statistics in process pane.
* This is called when mode of operation is thread.
*/
static void
print_thread(pid_t pid, id_t tid)
{
void *list;
char header[256];
char tmp[30];
if (!display_initialized) {
return;
}
list = lt_stat_list_create(current_list_type, LT_LEVEL_THREAD,
pid, tid, 8, sort_type);
(void) werase(process_window);
(void) wattron(process_window, A_REVERSE);
(void) snprintf(header, sizeof (header),
"Process %s (%i), LWP %d",
lt_stat_proc_get_name(pid), pid, tid);
fill_space_right(header, screen_width, sizeof (header));
(void) mvwprintw(process_window, 0, 0, "%s", header);
if (current_list_type != LT_LIST_SPECIALS) {
(void) mvwprintw(process_window, 0, 48, "Total: %s",
get_time_string(
(double)lt_stat_list_get_gtotal(list),
tmp, sizeof (tmp), 12));
}
print_current_mode();
(void) wattroff(process_window, A_REVERSE);
print_statistics(process_window, 1, 8, list);
lt_stat_list_free(list);
(void) wrefresh(process_window);
}
void DiveLogExportDialog::exportHTMLstatistics(const QString &filename)
{
QFile file(filename);
file.open(QIODevice::WriteOnly | QIODevice::Text);
QTextStream out(&file);
int i = 0;
out << "divestat=[";
while (stats_yearly != NULL && stats_yearly[i].period) {
out << "{";
out << "\"YEAR\":\"" << stats_yearly[i].period << "\",";
out << "\"DIVES\":\"" << stats_yearly[i].selection_size << "\",";
out << "\"TOTAL_TIME\":\"" << get_time_string(stats_yearly[i].total_time.seconds, 0) << "\",";
out << "\"AVERAGE_TIME\":\"" << get_minutes(stats_yearly[i].total_time.seconds / stats_yearly[i].selection_size) << "\",";
out << "\"SHORTEST_TIME\":\"" << get_minutes(stats_yearly[i].shortest_time.seconds) << "\",";
out << "\"LONGEST_TIME\":\"" << get_minutes(stats_yearly[i].longest_time.seconds) << "\",";
out << "\"AVG_DEPTH\":\"" << get_depth_string(stats_yearly[i].avg_depth) << "\",";
out << "\"MIN_DEPTH\":\"" << get_depth_string(stats_yearly[i].min_depth) << "\",";
out << "\"MAX_DEPTH\":\"" << get_depth_string(stats_yearly[i].max_depth) << "\",";
out << "\"AVG_SAC\":\"" << get_volume_string(stats_yearly[i].avg_sac) << "\",";
out << "\"MIN_SAC\":\"" << get_volume_string(stats_yearly[i].min_sac) << "\",";
out << "\"MAX_SAC\":\"" << get_volume_string(stats_yearly[i].max_sac) << "\",";
out << "\"AVG_TEMP\":\"" << QString::number(stats_yearly[i].combined_temp / stats_yearly[i].combined_count, 'f', 1) << "\",";
out << "\"MIN_TEMP\":\"" << get_temp_units(stats_yearly[i].min_temp, NULL) << "\",";
out << "\"MAX_TEMP\":\"" << get_temp_units(stats_yearly[i].max_temp, NULL) << "\",";
out << "},";
i++;
}
out << "]";
file.close();
}
void get_now_string(char buffer[], unsigned buffer_size, char* pattern)
{
time_t rawtime;
time(&rawtime);
get_time_string(buffer, buffer_size, rawtime, pattern);
return;
}
static void resp_status_page(void)
{
char uptime_str[32];
char time_str[32];
get_time_string(time_str, sizeof(time_str));
get_uptime_string(uptime_str, sizeof(uptime_str));
puts("Content-type: text/html\n");
puts("<!DOCTYPE html>");
puts("<head>");
puts(" <meta charset=\"utf-8\">");
puts(" <meta http-equiv=\"Refresh\" content=\"10\">");
puts("<title>");
printf("%s Status Page", hostname);
puts("</title>");
puts("</head>");
puts("<body>");
puts("<p>Server: OK</p>");
printf("<p>%s</p>\n", time_str);
printf("<p>Uptime: %s</p>", uptime_str);
puts("</body>");
puts("</html>");
}
static void resp_time(void)
{
char time_str[32];
get_time_string(time_str, sizeof(time_str));
puts("Content-type: text/html\n");
printf("%s", time_str);
}
void place_id(const PalletMovement *movement)
{
printf("place_id: Adding tag to place [%s], with rfid tag [%s]\n", movement->id, movement->placement);
char *time = get_time_string();
const char *keys[4] = {
"reader", "place", "p", "time"
};
printf("Values place_id: reader: [%s] id: [%s] tag: [%s] time: [%s]\n", movement->reader, movement->id, movement->placement, time);
const char *values[4] = {
movement->reader,
movement->id,
movement->placement,
time
};
printf("URL snart");
char *parameters = to_parameters(4, keys, values);
char *URL = concat3(BASE_URL, SERVER_MOVE_START, parameters);
printf("URL: %s", URL);
movements_add(URL);
free(time);
free(parameters);
free(URL);
}
// move
void pallet_id(const PalletMovement *movement)
{
printf("pallet_id: Adding id [%s] to pallet with rfid [%s] and [%s]\n", movement->id, movement->pallet, movement->pallet2);
char *time = get_time_string();
const char *keys[5] = {
"reader", "palletId", "tag1", "tag2", "time"
};
const char *values[5] = {
movement->reader,
movement->id,
movement->pallet,
movement->pallet2,
time
};
char *parameters = to_parameters(5, keys, values);
char *URL = concat3(BASE_URL, SERVER_MOVE_START, parameters);
movements_add(URL);
free(time);
free(parameters);
free(URL);
}
void status_bar_ui::current_metadata_changed(metadata_optional_t const &new_metadata, bool const reset_playback_position)
{
if (new_metadata)
{
std::string title = get_metadata_value < std::string > (*new_metadata, "title", "");
if (title.empty())
current_song_title->setText("");
else
current_song_title->setText(QString::fromUtf8(title.c_str()));
unsigned int num_ticks = get_metadata_value < unsigned int > (*new_metadata, "num_ticks", 0);
current_num_ticks_per_second = get_metadata_value < unsigned int > (*new_metadata, "num_ticks_per_second", 0);
if (num_ticks > 0)
{
if (current_num_ticks_per_second > 0)
{
unsigned int length_in_seconds = num_ticks / current_num_ticks_per_second;
unsigned int minutes = length_in_seconds / 60;
unsigned int seconds = length_in_seconds % 60;
current_song_length->setText(get_time_string(minutes, seconds));
if (reset_playback_position)
current_playback_time->setText(get_time_string(0, 0));
}
else
{
current_song_length->setText("");
if (reset_playback_position)
current_playback_time->setText("");
}
}
else
{
current_song_length->setText("");
if (reset_playback_position)
current_playback_time->setText(get_time_string(0, 0));
}
}
else
{
current_song_title->setText("");
current_song_length->setText("");
if (reset_playback_position)
current_playback_time->setText("");
}
}
static void process_interval_stats(stats_t stats_interval, GtkTreeIter *parent, GtkTreeIter *row)
{
double value;
const char *unit;
char value_str[40];
GtkTreeStore *store;
store = GTK_TREE_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(yearly_tree)));
/* Year or month */
snprintf(value_str, sizeof(value_str), "%d", stats_interval.period);
add_row_to_tree(store, value_str, 0, row, parent);
/* Dives */
snprintf(value_str, sizeof(value_str), "%d", stats_interval.selection_size);
add_cell_to_tree(store, value_str, 1, row);
/* Total duration */
add_cell_to_tree(store, get_time_string(stats_interval.total_time.seconds, 0), 2, row);
/* Average dive duration */
add_cell_to_tree(store, get_minutes(stats_interval.total_time.seconds / stats_interval.selection_size), 3, row);
/* Shortest duration */
add_cell_to_tree(store, get_minutes(stats_interval.shortest_time.seconds), 4, row);
/* Longest duration */
add_cell_to_tree(store, get_minutes(stats_interval.longest_time.seconds), 5, row);
/* Average depth */
add_cell(store, row, stats_interval.avg_depth.mm, 6, TRUE);
/* Smallest maximum depth */
add_cell(store, row, stats_interval.min_depth.mm, 7, TRUE);
/* Deepest maximum depth */
add_cell(store, row, stats_interval.max_depth.mm, 8, TRUE);
/* Average air consumption */
add_cell(store, row, stats_interval.avg_sac.mliter, 9, FALSE);
/* Smallest average air consumption */
add_cell(store, row, stats_interval.min_sac.mliter, 10, FALSE);
/* Biggest air consumption */
add_cell(store, row, stats_interval.max_sac.mliter, 11, FALSE);
/* Average water temperature */
value = get_temp_units(stats_interval.min_temp, &unit);
if (stats_interval.combined_temp && stats_interval.combined_count) {
snprintf(value_str, sizeof(value_str), "%.1f %s", stats_interval.combined_temp / (stats_interval.combined_count * 1.0), unit);
add_cell_to_tree(store, value_str, 12, row);
} else {
add_cell_to_tree(store, "", 12, row);
}
/* Coldest water temperature */
if (value > -100.0) {
snprintf(value_str, sizeof(value_str), "%.1f %s\t", value, unit);
add_cell_to_tree(store, value_str, 13, row);
} else {
add_cell_to_tree(store, "", 13, row);
}
/* Warmest water temperature */
value = get_temp_units(stats_interval.max_temp, &unit);
if (value > -100.0) {
snprintf(value_str, sizeof(value_str), "%.1f %s", value, unit);
add_cell_to_tree(store, value_str, 14, row);
} else {
add_cell_to_tree(store, "", 14, row);
}
}
int
process_server( int sockfd_new )
{
while(1)
{
fd_set readfd;
FD_ZERO(&readfd);
FD_SET(sockfd_new ,&readfd);
struct timeval tv;
tv.tv_sec = TIME_OUT_DEFAULT;
tv.tv_usec = 0;
if( select(sockfd_new+1, &readfd, NULL, NULL, &tv) < 0 )
{
if( EINTR == errno )
{
continue;
}
SERVER_DEBUG( "select error:%s\n", strerror(errno) );
return -1;
} else if( FD_ISSET(sockfd_new, &readfd) ) {
char buffer[SO_BUF_LEN_MAX];
memset( buffer, 0, sizeof(buffer) );
SERVER_DEBUG( "receive message:\n" );
ssize_t length = 0;
if( ( length = read_wrapper(sockfd_new, buffer, sizeof(buffer)) ) < 0 )
{
SERVER_DEBUG( "read error:%s\n", strerror(errno) );
return -1;
}
SERVER_DEBUG( "read size = %d\n", length );
if( 0 < length )
{
SERVER_DEBUG( "send message:\n" );
const char* message = get_time_string();
if( ( length = write_wrapper( sockfd_new, message, strlen(message) ) ) < 0 )
{
SERVER_DEBUG( "write error:%s\n", strerror(errno) );
return -1;
}
SERVER_DEBUG( "write size = %d\n", length );
} else {
SERVER_DEBUG( "read error, close socket\n" );
return -1;
}
} else {
continue;
}
}
kill( parent, SIGCHLD );
return 0;
}
void document_header(int use_stylesheet) {
char date_time[MAX_DATETIME_LENGTH];
time_t current_time;
time_t expire_time;
printf("Cache-Control: no-store\r\n");
printf("Pragma: no-cache\r\n");
printf("Refresh: %d\r\n", refresh_rate);
time(¤t_time);
get_time_string(¤t_time, date_time, (int)sizeof(date_time), HTTP_DATE_TIME);
printf("Last-Modified: %s\r\n", date_time);
expire_time = (time_t)0L;
get_time_string(&expire_time, date_time, (int)sizeof(date_time), HTTP_DATE_TIME);
printf("Expires: %s\r\n", date_time);
printf("Content-type: text/html\r\n\r\n");
if(embedded == TRUE)
return;
printf("<html>\n");
printf("<head>\n");
printf("<link rel=\"shortcut icon\" href=\"%sfavicon.ico\" type=\"image/ico\">\n", url_images_path);
printf("<title>\n");
printf("Network Outages\n");
printf("</title>\n");
if(use_stylesheet == TRUE) {
printf("<LINK REL='stylesheet' TYPE='text/css' HREF='%s%s'>", url_stylesheets_path, COMMON_CSS);
printf("<LINK REL='stylesheet' TYPE='text/css' HREF='%s%s'>", url_stylesheets_path, OUTAGES_CSS);
}
printf("</head>\n");
printf("<body CLASS='outages'>\n");
/* include user SSI header */
include_ssi_files(OUTAGES_CGI, SSI_HEADER);
return;
}
void document_header(int use_stylesheet) {
char date_time[MAX_DATETIME_LENGTH];
time_t current_time;
time_t expire_time;
printf("Cache-Control: no-store\r\n");
printf("Pragma: no-cache\r\n");
time(¤t_time);
get_time_string(¤t_time, date_time, (int)sizeof(date_time), HTTP_DATE_TIME);
printf("Last-Modified: %s\r\n", date_time);
expire_time = (time_t)0L;
get_time_string(&expire_time, date_time, (int)sizeof(date_time), HTTP_DATE_TIME);
printf("Expires: %s\r\n", date_time);
printf("Content-type: text/html\r\n\r\n");
if(embedded == TRUE)
return;
printf("<HTML>\n");
printf("<HEAD>\n");
printf("<link rel=\"shortcut icon\" href=\"%sfavicon.ico\" type=\"image/ico\">\n",url_images_path);
printf("<meta http-equiv='content-type' content='text/html;charset=UTF-8'>\n");
printf("<meta http-equiv='Pragma' content='no-cache'>\n");
printf("<TITLE>\n");
printf("%s\n",_("Nagios Log File"));
printf("</TITLE>\n");
if(use_stylesheet == TRUE) {
printf("<LINK REL='stylesheet' TYPE='text/css' HREF='%s%s'>\n", url_stylesheets_path, COMMON_CSS);
printf("<LINK REL='stylesheet' TYPE='text/css' HREF='%s%s'>\n", url_stylesheets_path, SHOWLOG_CSS);
}
printf("</HEAD>\n");
printf("<BODY CLASS='showlog'>\n");
/* include user SSI header */
include_ssi_files(SHOWLOG_CGI, SSI_HEADER);
return;
}
/* This function will check the last reboot status. If the reboot is HARD reboot or due to
power failure, it will send the last stored logs to the upload queue*/
void check_last_reboot(void)
{
FILE *fp;
char status[50], file_path[FILE_PATH_LENGTH], time_buf[50], cmd[250];
memset(status, 0, sizeof(status));
memset(file_path, 0, sizeof(file_path));
memset(time_buf, 0, sizeof(time_buf));
DEBUG("%s : checking last reboot status...\n", __func__);
fp = fopen(SYSTEM_REBOOT_STATUS_FILE, "r");
if(fp == NULL)
{
ERROR("%s : Unable to open file \"%s\". Returning...\n", __func__, SYSTEM_REBOOT_STATUS_FILE);
return;
}
fscanf(fp, "%s", status);
fclose(fp);
if(file_is_present(SYSTEM_SERVER_LOG_FILE) == FAIL)
{
ERROR("%s : returning...\n", __func__);
return;
}
get_time_string(time_buf);
if(!strcmp(status, "system_server_test"))
{
DEBUG("%s : Last reboot was not normal... Sending the last system_server_test logs to upload queue...\n", __func__);
sprintf(file_path, "%stest_%s.log", SYSTEM_LOG_PATH, time_buf);
sprintf(cmd, "cp %s %s", SYSTEM_SERVER_LOG_FILE, file_path);
system(cmd);
sprintf(cmd, "echo 0>%s",SYSTEM_SERVER_LOG_FILE);
system(cmd);
enqueue_upload_file_list(LOG_FILE, file_path);
}
else if(!strcmp(status, "system_server"))
{
DEBUG("%s : Last reboot was not normal... Sending the last system_server logs to upload queue...\n", __func__);
sprintf(file_path, "%ssystem_%s.log", SYSTEM_LOG_PATH, time_buf);
sprintf(cmd, "cp %s %s", SYSTEM_SERVER_LOG_FILE, file_path);
system(cmd);
sprintf(cmd, "echo 0>%s",SYSTEM_SERVER_LOG_FILE);
system(cmd);
enqueue_upload_file_list(LOG_FILE, file_path);
}
else
{
DEBUG("%s : Last reboot was normal...\n", __func__);
}
return;
}
void menu_tape_control::populate()
{
if (current_device())
{
// name of tape
item_append(current_display_name().c_str(), current_device()->exists() ? current_device()->filename() : "No Tape Image loaded", current_display_flags(), TAPECMD_SELECT);
if (current_device()->exists())
{
std::string timepos;
cassette_state state;
double t0 = current_device()->get_position();
double t1 = current_device()->get_length();
UINT32 tapeflags = 0;
// state
if (t1 > 0)
{
if (t0 > 0)
tapeflags |= FLAG_LEFT_ARROW;
if (t0 < t1)
tapeflags |= FLAG_RIGHT_ARROW;
}
get_time_string(timepos, current_device(), nullptr, nullptr);
state = current_device()->get_state();
item_append(
(state & CASSETTE_MASK_UISTATE) == CASSETTE_STOPPED
? _("stopped")
: ((state & CASSETTE_MASK_UISTATE) == CASSETTE_PLAY
? ((state & CASSETTE_MASK_MOTOR) == CASSETTE_MOTOR_ENABLED ? _("playing") : _("(playing)"))
: ((state & CASSETTE_MASK_MOTOR) == CASSETTE_MOTOR_ENABLED ? _("recording") : _("(recording)"))
),
timepos.c_str(),
tapeflags,
TAPECMD_SLIDER);
// pause or stop
item_append(_("Pause/Stop"), nullptr, 0, TAPECMD_STOP);
// play
item_append(_("Play"), nullptr, 0, TAPECMD_PLAY);
// record
item_append(_("Record"), nullptr, 0, TAPECMD_RECORD);
// rewind
item_append(_("Rewind"), nullptr, 0, TAPECMD_REWIND);
// fast forward
item_append(_("Fast Forward"), nullptr, 0, TAPECMD_FAST_FORWARD);
}
}
}
void document_header(void) {
char date_time[MAX_DATETIME_LENGTH];
time_t current_time;
time_t expire_time;
printf("Cache-Control: no-store\r\n");
printf("Pragma: no-cache\r\n");
time(¤t_time);
get_time_string(¤t_time, date_time, sizeof(date_time), HTTP_DATE_TIME);
printf("Last-Modified: %s\r\n", date_time);
expire_time = 0L;
get_time_string(&expire_time, date_time, sizeof(date_time), HTTP_DATE_TIME);
printf("Expires: %s\r\n", date_time);
printf("Content-Type: x-world/x-vrml\r\n\r\n");
return;
}
local void Ctime(const char *cmd, const char *params, Player *p, const Target *target)
{
Arena *arena = p->arena;
int tout;
timerdata *td = P_ARENA_DATA(arena, tdkey);
char time_string[40];
if (td->enabled)
{
tout = TICK_DIFF(td->timeout, current_ticks());
get_time_string(tout, time_string);
chat->SendMessage(p, "Time left: %s.", time_string);
}
else if (td->timeout)
{
get_time_string(td->timeout, time_string);
chat->SendMessage(p, "Timer paused at: %s.", time_string);
}
else
chat->SendMessage(p, "Time left: 0 seconds.");
}
void
logd::log_access( map<string,string> &map_request )
{
//static int i_access_lines = wrap::CONF->get_elem("httpd.logging.access_lines");
string s_time = get_time_string();
string s_logstr = map_request["REMOTE_ADDR"] + " - - "+s_time+" \"" + map_request["QUERY_STRING"]+"\" 200 0 \""+map_request["request"]+"\" \""+map_request["User-Agent"]+"\"\n";
s_queue.push(s_logstr);
if ( s_queue.size() > i_lines )
flush();
}
local void Cpausetimer(const char *cmd, const char *params, Player *p, const Target *target)
{
Arena *arena = p->arena;
timerdata *td = P_ARENA_DATA(arena, tdkey);
char time_string[40];
if (td->gamelen) return;
if (td->enabled)
{
td->enabled = 0;
td->timeout -= current_ticks();
get_time_string(td->timeout, time_string);
chat->SendMessage(p,"Timer paused at: %s.", time_string);
}
else if (td->timeout)
{
get_time_string(td->timeout, time_string);
chat->SendMessage(p,"Timer resumed at: %s", time_string);
td->enabled = 1;
td->timeout += current_ticks();
}
}
QVariant YearStatisticsItem::data(int column, int role) const
{
double value;
QVariant ret;
if (role == Qt::FontRole) {
QFont font = defaultModelFont();
font.setBold(stats_interval.is_year);
return font;
} else if (role != Qt::DisplayRole) {
return ret;
}
switch(column) {
case YEAR:
if (stats_interval.is_trip) {
ret = stats_interval.location;
} else {
ret = stats_interval.period;
}
break;
case DIVES: ret = stats_interval.selection_size; break;
case TOTAL_TIME: ret = get_time_string(stats_interval.total_time.seconds, 0); break;
case AVERAGE_TIME: ret = get_minutes(stats_interval.total_time.seconds / stats_interval.selection_size); break;
case SHORTEST_TIME: ret = get_minutes(stats_interval.shortest_time.seconds); break;
case LONGEST_TIME: ret = get_minutes(stats_interval.longest_time.seconds); break;
case AVG_DEPTH: ret = get_depth_string(stats_interval.avg_depth); break;
case MIN_DEPTH: ret = get_depth_string(stats_interval.min_depth); break;
case MAX_DEPTH: ret = get_depth_string(stats_interval.max_depth); break;
case AVG_SAC: ret = get_volume_string(stats_interval.avg_sac); break;
case MIN_SAC: ret = get_volume_string(stats_interval.min_sac); break;
case MAX_SAC: ret = get_volume_string(stats_interval.max_sac); break;
case AVG_TEMP:
if (stats_interval.combined_temp && stats_interval.combined_count) {
ret = QString::number(stats_interval.combined_temp / stats_interval.combined_count, 'f', 1);
}
break;
case MIN_TEMP:
value = get_temp_units(stats_interval.min_temp, NULL);
if (value > -100.0)
ret = QString::number(value, 'f', 1);
break;
case MAX_TEMP:
value = get_temp_units(stats_interval.max_temp, NULL);
if (value > -100.0)
ret = QString::number(value, 'f', 1);
break;
}
return ret;
}
static bool_t log_to_file(const char *file_name, const char* txt) {
if (!file_name)
return False;
time_t _t = time(NULL);
struct tm* t = localtime(&_t);
std::string date(get_data_string(*t));
std::string fullPath = PUB_cat_path(log_dir, date + file_name);
std::ofstream of(fullPath.c_str(), std::ios::app);
if (!of.is_open())
return False;
of << get_time_string(*t) << txt << std::endl;
return True;
}
void status_bar_ui::set_current_time_label(unsigned int const current_position)
{
unsigned int time_in_seconds = 0;
if (current_num_ticks_per_second > 0)
{
time_in_seconds = current_position / current_num_ticks_per_second;
unsigned int minutes = time_in_seconds / 60;
unsigned int seconds = time_in_seconds % 60;
current_playback_time->setText(get_time_string(minutes, seconds));
}
else
current_playback_time->setText("");
}
int Indexer::save_index(const string& indexedDir)
{
string tmpIndexDir = indexedDir;
if(*(tmpIndexDir.end() - 1) != '/')
{
tmpIndexDir.append("/");
}
string timeStr;
get_time_string(timeStr);
string postingIndexFileAbsolutePath;
postingIndexFileAbsolutePath.append(tmpIndexDir).append(timeStr).append("_indexed").append(".idx");
string docSetFileAbsolutePath;
docSetFileAbsolutePath.append(tmpIndexDir).append(timeStr).append("_indexed").append(".dst");
fstream fsPostingIndex;
fstream fsDocSet;
fsPostingIndex.open(postingIndexFileAbsolutePath.c_str(), ios_base::out);
if(fsPostingIndex.fail())
{
fsPostingIndex.close();
cout<<postingIndexFileAbsolutePath<<" Open Failed"<<endl;
return -1;
}
fsDocSet.open(docSetFileAbsolutePath.c_str(), ios_base::out);
if(fsDocSet.fail())
{
fsDocSet.close();
cout<<docSetFileAbsolutePath<<" Open Failed"<<endl;
return -1;
}
boost::archive::text_oarchive oaPostingIndex(fsPostingIndex);
boost::archive::text_oarchive oaDocSet(fsDocSet);
oaPostingIndex<<m_postingIndex;
oaDocSet<<m_docSet;
fsPostingIndex.close();
fsDocSet.close();
return 0;
}
void
logd::log_simple_line( string s_line )
{
// Dont log empty lines!
if (s_line.empty())
return;
string s_time = get_time_string();
string s_logstr = s_time + " " + s_line;
s_queue.push(s_logstr);
if ( s_queue.size() > i_lines )
flush();
}
int execute_and_create_process(struct subprocess* process, struct inotify_event* event, char *command) { //Execute command using wrapper function.
process->start_time=(char*)malloc(sizeof(char)*9);
strcpy(process->start_time,get_time_string());
int pid=exec_pipe(command,0);
if (pid==-1) {
return -1;
}
process->pid=pid;
process->retries=0;
process->command=(char *)malloc(sizeof(char)*strlen(command));
process->event=event;
process->prev=NULL;
process->next=NULL;
strcpy(process->command,command);
process->path=(char *)malloc(sizeof(char)*(strlen(global_wd_list[event->wd]->path)+strlen(event->name)+2));
sprintf(process->path,"%s/%s",global_wd_list[event->wd]->path,event->name);
add_list_element(process);
return pid;
}
static void
set_header(pConnInfo conn_info) {
char *time_string = get_time_string(NULL);
conn_info->response_header->http_ver = "HTTP/1.1";
conn_info->response_header->status_code = 200;
conn_info->response_header->status = "OK";
add_header_param("Cache-Control", "private", conn_info->response_header);
add_header_param("Connection", "Keep-Alive", conn_info->response_header);
add_header_param("Vary", "Accept-Encoding", conn_info->response_header);
add_header_param("Server", UWS_SERVER, conn_info->response_header);
add_header_param("Date", time_string, conn_info->response_header);
char *len = itoa(header_body.content_len);
add_header_param("Content-Length", len, conn_info->response_header);
uws_free(len);
add_header_param("Content-Type", mime, conn_info->response_header);
header_body.header = conn_info->response_header;
uws_free(time_string);
}
void get_id(t_tree *tree, t_tree *ref, t_data *data)
{
struct passwd *uid;
struct group *gid;
char *s_len;
s_len = ft_itoa(tree->stat.st_size);
uid = getpwuid(tree->stat.st_uid);
gid = getgrgid(tree->stat.st_gid);
tree->uid = ft_strdup(uid->pw_name);
tree->gid = ft_strdup(gid->gr_name);
if (ft_strlen(tree->uid) > (size_t)ref->owner_len)
ref->owner_len = ft_strlen(tree->uid);
if (ft_strlen(tree->gid) > (size_t)ref->group_len)
ref->group_len = ft_strlen(tree->gid);
if (ft_strlen(s_len) > (size_t)ref->size_len)
ref->size_len = ft_strlen(s_len);
free(s_len);
get_time_string(tree, data);
}
/*
* @brief 处理当前目录下所有标记为N的文件
* @param DIR *dir:目录指针; char *folder:目录名; char *file:当前文件名
* @return 0表示处理成功且有新文件，可继续处理； -1表示处理失败，或处理成功但没有新文件，可休眠。
*/
int processdir(DIR *dir)
{
struct dirent *ptr;
int retv;
char fullpath[FULL_PATH_LEN];
while ((ptr = readdir(dir)) != NULL) {
if (ptr->d_name[0]=='N') {
snprintf(fullpath, FULL_PATH_LEN, "%s/%s", data_store_path, ptr->d_name);
get_time_string();
retv = send_2_server(fullpath);
if (retv >= 0) {
//ret =0 ok! 1 bad files
remove(fullpath);
} else {
//ret -1, can't send file, then return and have a rest
return -1;
}
}//if
}//while
return 0;
}
