static gboolean
range_to_string (const GstRTSPTimeRange * range, GString * string)
{
gboolean res;
if (!(res = time_to_string (&range->min, &range->min2, string)))
goto done;
g_string_append (string, "-");
if (!(res = time_to_string (&range->max, &range->max2, string)))
goto done;
done:
return res;
}
//! Convert to string
Cookie::operator std::pair<std::string, std::string> () const {
std::stringstream ss;
ss << name << "=\"" << value << "\"";
if (!comment.empty()) {
ss << "; Comment=\"" << comment << "\"";
}
if (!domain.empty()) {
ss << "; Domain=\"" << domain << "\"";
}
if (removed) {
ss << "; Expires=Fri, 01-Jan-1971 01:00:00 GMT";
ss << "; Max-Age=0";
} else if (max_age > 0) {
ss << "; Max-Age=" << max_age;
ss << "; Expires=" << time_to_string("%a, %d-%b-%Y %H:%M:%S GMT", max_age);
}
if (!path.empty()) {
ss << "; Path=\"" << path << "\"";
}
if (secure) {
ss << "; Secure";
}
if (http_only) {
ss << "; HttpOnly";
}
ss << "; Version=\"1\"";
return std::make_pair("Set-Cookie", ss.str());
}
// Log informational messages to system specific places
//
void log_message_startup(const char* msg) {
char evt_msg[2048];
char* time_string = time_to_string(dtime());
snprintf(evt_msg, sizeof(evt_msg),
"%s %s\n",
time_string, msg
);
if (!gstate.executing_as_daemon) {
fprintf(stdout, "%s", evt_msg);
#ifdef _WIN32
// MSVCRT doesn't support line buffered streams
fflush(stdout);
#endif
} else {
#ifdef _WIN32
LogEventInfoMessage(evt_msg);
#elif defined(__EMX__)
#elif defined (__APPLE__)
#elif defined (ANDROID)
__android_log_print(ANDROID_LOG_INFO, "BOINC", evt_msg);
#else
syslog(LOG_DAEMON|LOG_INFO, "%s", evt_msg);
#endif
}
}
static void
TargPrintNode(GNode *gn, bool full)
{
if (OP_NOP(gn->type))
return;
switch((gn->special & SPECIAL_MASK)) {
case SPECIAL_SUFFIXES:
case SPECIAL_PHONY:
case SPECIAL_ORDER:
case SPECIAL_NOTHING:
case SPECIAL_MAIN:
case SPECIAL_IGNORE:
return;
default:
break;
}
if (full) {
printf("# %d unmade prerequisites\n", gn->unmade);
if (! (gn->type & (OP_JOIN|OP_USE|OP_EXEC))) {
if (!is_out_of_date(gn->mtime)) {
printf("# last modified %s: %s\n",
time_to_string(&gn->mtime),
status_to_string(gn));
} else if (gn->built_status != UNKNOWN) {
printf("# non-existent (maybe): %s\n",
status_to_string(gn));
} else {
printf("# unmade\n");
}
}
}
if (!Lst_IsEmpty(&gn->parents)) {
printf("# parent targets: ");
Lst_Every(&gn->parents, TargPrintName);
fputc('\n', stdout);
}
if (gn->impliedsrc)
printf("# implied prerequisite: %s\n", gn->impliedsrc->name);
printf("%-16s", gn->name);
switch (gn->type & OP_OPMASK) {
case OP_DEPENDS:
printf(": "); break;
case OP_FORCE:
printf("! "); break;
case OP_DOUBLEDEP:
printf(":: "); break;
}
Targ_PrintType(gn->type);
Lst_Every(&gn->children, TargPrintName);
fputc('\n', stdout);
Lst_Every(&gn->commands, Targ_PrintCmd);
printf("\n\n");
if (gn->type & OP_DOUBLEDEP) {
LstNode ln;
for (ln = Lst_First(&gn->cohorts); ln != NULL; ln = Lst_Adv(ln))
TargPrintNode((GNode *)Lst_Datum(ln), full);
}
}
void svg_waiting(int Yslot, u64 start, u64 end)
{
char *text;
const char *style;
double font_size;
if (!svgfile)
return;
style = "waiting";
if (end-start > 10 * 1000000) /* 10 msec */
style = "WAITING";
text = time_to_string(end-start);
font_size = 1.0 * (time2pixels(end)-time2pixels(start));
if (font_size > 3)
font_size = 3;
font_size = round_text_size(font_size);
fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\">\n", time2pixels(start), Yslot * SLOT_MULT);
fprintf(svgfile, "<rect x=\"0\" width=\"%4.8f\" y=\"0\" height=\"%4.1f\" class=\"%s\"/>\n",
time2pixels(end)-time2pixels(start), SLOT_HEIGHT, style);
if (font_size > MIN_TEXT_SIZE)
fprintf(svgfile, "<text transform=\"rotate(90)\" font-size=\"%1.8fpt\"> %s</text>\n",
font_size, text);
fprintf(svgfile, "</g>\n");
}
/**
* Extension of print_time to print the time along with the .s for timer mode
* @param d device to print to
* @param time time to print
*/
void print_time_ex(device_t d, unsigned int time) {
static char tmp[9];
time_to_string(time, tmp);
dputs(d, tmp);
dputchar(d, '.');
dputchar(d, '0' + (time/100)%10);
}
int main(int argc, char** argv)
{
boost::asio::io_service io;
std::string post_url = "http://bbs.tianya.cn/post-culture-520191-1.shtml"; // http://bbs.tianya.cn/list.jsp?item=culture&grade=1&order=1 http://bbs.tianya.cn/post-culture-354078-1.shtml
if (argc == 2)
post_url = std::string(argv[1]);
std::locale::global(std::locale(""));
auto obj = std::make_shared<tianya_context>(boost::ref(io));
obj->start(post_url);
obj->filter_reply(true);
boost::asio::signal_set terminator_signal(io);
terminator_signal.add(SIGINT);
terminator_signal.add(SIGTERM);
#if defined(SIGQUIT)
terminator_signal.add(SIGQUIT);
#endif // defined(SIGQUIT)
terminator_signal.async_wait(boost::bind(&terminator, boost::ref(io), boost::ref(obj)));
io.run();
// 输出到文件.
std::string name = time_to_string(aux::gettime()) + ".txt";
obj->serialize_to_file(name);
return 0;
}
void svg_process(int cpu, u64 start, u64 end, int pid, const char *name, const char *backtrace)
{
double width;
const char *type;
if (!svgfile)
return;
if (svg_highlight && end - start >= svg_highlight)
type = "sample_hi";
else if (svg_highlight_name && strstr(name, svg_highlight_name))
type = "sample_hi";
else
type = "sample";
fprintf(svgfile, "<g transform=\"translate(%.8f,%.8f)\">\n", time2pixels(start), cpu2y(cpu));
fprintf(svgfile, "<title>%d %s running %s</title>\n", pid, name, time_to_string(end - start));
if (backtrace)
fprintf(svgfile, "<desc>Switched because:\n%s</desc>\n", backtrace);
fprintf(svgfile, "<rect x=\"0\" width=\"%.8f\" y=\"0\" height=\"%.1f\" class=\"%s\"/>\n",
time2pixels(end)-time2pixels(start), SLOT_MULT+SLOT_HEIGHT, type);
width = time2pixels(end)-time2pixels(start);
if (width > 6)
width = 6;
width = round_text_size(width);
if (width > MIN_TEXT_SIZE)
fprintf(svgfile, "<text transform=\"rotate(90)\" font-size=\"%.8fpt\">%s</text>\n",
width, name);
fprintf(svgfile, "</g>\n");
}
// Log error messages to system specific places
//
void log_message_error(const char* msg) {
char evt_msg[2048];
char* time_string = time_to_string(dtime());
#ifdef _WIN32
char buf[1024];
snprintf(evt_msg, sizeof(evt_msg),
"%s %s\n"
"GLE: %s\n",
time_string, msg,
windows_format_error_string(GetLastError(), buf, sizeof(buf))
);
#else
snprintf(evt_msg, sizeof(evt_msg),
"%s %s\n",
time_string, msg
);
#endif
if (!gstate.executing_as_daemon) {
fprintf(stderr, "%s", evt_msg);
} else {
#ifdef _WIN32
LogEventErrorMessage(evt_msg);
#elif defined(__EMX__)
#elif defined (__APPLE__)
#elif defined (ANDROID)
__android_log_print(ANDROID_LOG_ERROR, "BOINC", evt_msg);
#else
syslog(LOG_DAEMON|LOG_ERR, "%s", evt_msg);
#endif
}
}
void svg_running(int Yslot, int cpu, u64 start, u64 end, const char *backtrace)
{
double text_size;
const char *type;
if (!svgfile)
return;
if (svg_highlight && end - start > svg_highlight)
type = "sample_hi";
else
type = "sample";
fprintf(svgfile, "<g>\n");
fprintf(svgfile, "<title>#%d running %s</title>\n",
cpu, time_to_string(end - start));
if (backtrace)
fprintf(svgfile, "<desc>Switched because:\n%s</desc>\n", backtrace);
fprintf(svgfile, "<rect x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\" class=\"%s\"/>\n",
time2pixels(start), time2pixels(end)-time2pixels(start), Yslot * SLOT_MULT, SLOT_HEIGHT,
type);
text_size = (time2pixels(end)-time2pixels(start));
if (cpu > 9)
text_size = text_size/2;
if (text_size > 1.25)
text_size = 1.25;
text_size = round_text_size(text_size);
if (text_size > MIN_TEXT_SIZE)
fprintf(svgfile, "<text x=\"%1.8f\" y=\"%1.8f\" font-size=\"%1.8fpt\">%i</text>\n",
time2pixels(start), Yslot * SLOT_MULT + SLOT_HEIGHT - 1, text_size, cpu + 1);
fprintf(svgfile, "</g>\n");
}
static int
report_mount(
FILE *fp,
__uint32_t id,
char *name,
uint form,
uint type,
fs_path_t *mount,
uint flags)
{
fs_disk_quota_t d;
char *dev = mount->fs_name;
char c[8], h[8], s[8];
uint qflags;
int count;
if (xfsquotactl(XFS_GETQUOTA, dev, type, id, (void *)&d) < 0) {
if (errno != ENOENT && errno != ENOSYS)
perror("XFS_GETQUOTA");
return 0;
}
if (flags & TERSE_FLAG) {
count = 0;
if ((form & XFS_BLOCK_QUOTA) && d.d_bcount)
count++;
if ((form & XFS_INODE_QUOTA) && d.d_icount)
count++;
if ((form & XFS_RTBLOCK_QUOTA) && d.d_rtbcount)
count++;
if (!count)
return 0;
}
if (!(flags & NO_HEADER_FLAG))
report_header(fp, form, type, mount, flags);
fprintf(fp, "%-10s", name);
if (form & XFS_BLOCK_QUOTA) {
qflags = (flags & HUMAN_FLAG);
if (d.d_blk_hardlimit && d.d_bcount > d.d_blk_hardlimit)
qflags |= LIMIT_FLAG;
if (d.d_blk_softlimit && d.d_bcount > d.d_blk_softlimit)
qflags |= QUOTA_FLAG;
if (flags & HUMAN_FLAG)
fprintf(fp, " %6s %6s %6s %02d %8s",
bbs_to_string(d.d_bcount, c, sizeof(c)),
bbs_to_string(d.d_blk_softlimit, s, sizeof(s)),
bbs_to_string(d.d_blk_hardlimit, h, sizeof(h)),
d.d_bwarns,
time_to_string(d.d_btimer, qflags));
else
fprintf(fp, " %10llu %10llu %10llu %02d %9s",
(unsigned long long)d.d_bcount >> 1,
(unsigned long long)d.d_blk_softlimit >> 1,
(unsigned long long)d.d_blk_hardlimit >> 1,
d.d_bwarns,
time_to_string(d.d_btimer, qflags));
}
char *execp_get_tooltip(void *obj)
{
Execp *execp = obj;
if (execp->backend->tooltip) {
if (strlen(execp->backend->tooltip) > 0)
return strdup(execp->backend->tooltip);
else
return NULL;
}
time_t now = time(NULL);
char tmp_buf1[256];
char tmp_buf2[256];
char tmp_buf3[256];
if (execp->backend->child_pipe < 0) {
// Not executing command
if (execp->backend->last_update_finish_time) {
// We updated at least once
if (execp->backend->interval > 0) {
sprintf(execp->backend->tooltip_text,
"Last update finished %s ago (took %s). Next update starting in %s.",
time_to_string((int)(now - execp->backend->last_update_finish_time), tmp_buf1),
time_to_string((int)execp->backend->last_update_duration, tmp_buf2),
time_to_string((int)(execp->backend->interval - (now - execp->backend->last_update_finish_time)),
tmp_buf3));
} else {
sprintf(execp->backend->tooltip_text,
"Last update finished %s ago (took %s).",
time_to_string((int)(now - execp->backend->last_update_finish_time), tmp_buf1),
time_to_string((int)execp->backend->last_update_duration, tmp_buf2));
}
} else {
// we never requested an update
sprintf(execp->backend->tooltip_text, "Never updated. No update scheduled.");
}
} else {
// Currently executing command
if (execp->backend->last_update_finish_time) {
// we finished updating at least once
sprintf(execp->backend->tooltip_text,
"Last update finished %s ago. Update in progress (started %s ago).",
time_to_string((int)(now - execp->backend->last_update_finish_time), tmp_buf1),
time_to_string((int)(now - execp->backend->last_update_start_time), tmp_buf3));
} else {
// we never finished an update
sprintf(execp->backend->tooltip_text,
"First update in progress (started %s seconds ago).",
time_to_string((int)(now - execp->backend->last_update_start_time), tmp_buf1));
}
}
return strdup(execp->backend->tooltip_text);
}
static void
state_timelimit(
FILE *fp,
uint form,
__uint32_t timelimit)
{
fprintf(fp, _("%s grace time: %s\n"),
form_to_string(form),
time_to_string(timelimit, VERBOSE_FLAG | ABSOLUTE_FLAG));
}
int main(void) {
init();
GPIO_map = (gpio_map_t*) GPIO_BASE;
//Start system clock
volatile systick_t* sys_tick;
sys_tick = (systick_t*) SYSTICK_BASE;
sys_tick->CTRL = 0b0111;
sys_tick->LOAD = FREQUENCY;
//Set LED to output
GPIO_map->port[LED_PORT].DOUT = 0;
GPIO_map->port[LED_PORT].MODEL = ((~(0b1111<<8))&GPIO_map->port[LED_PORT].MODEL)|(GPIO_MODE_OUTPUT<<8);
//Button interrupt setup
//Set input mode button pin
GPIO_map->port[BUTTON_PORT].DOUT = 0;
GPIO_map->port[BUTTON_PORT].MODEH = ((~(0b1111<<4))&GPIO_map->port[BUTTON_PORT].MODEH)|(GPIO_MODE_INPUT<<4);
//Set select port B pin 9
GPIO_map->EXTIPSELH = ((~(0b1111<<4))&GPIO_map->EXTIPSELH)|(0b0001<<4);
//Set falling edge trigger pin 9
GPIO_map->EXTIFALL = GPIO_map->EXTIFALL|(1<<9);
//Set IF to 0 for safety
GPIO_map->IFC = GPIO_map->IFC|(1<<9);
//Set interrupt enable pin 9
GPIO_map->IEN = GPIO_map->IEN|(1<<9);
//Set input mode button pin 2
GPIO_map->port[BUTTON_PORT].MODEH = ((~(0b1111<<8))&GPIO_map->port[BUTTON_PORT].MODEH)|(GPIO_MODE_INPUT<<8);
//Set select port B pin 10
GPIO_map->EXTIPSELH = ((~(0b1111<<8))&GPIO_map->EXTIPSELH)|(0b0001<<8);
//Set falling edge trigger pin 10
GPIO_map->EXTIFALL = GPIO_map->EXTIFALL|(1<<10);
//Set IF to 0 for safety
GPIO_map->IFC = GPIO_map->IFC|(1<<10);
//Set interrupt enable pin 10
GPIO_map->IEN = GPIO_map->IEN|(1<<10);
//Initial state setup
seconds = 0;
minutes = 0;
hours = 0;
state = SECONDS_STATE;
//Loop to keep alive
while(1) {
char str[7];
time_to_string(str, hours, minutes, seconds);
lcd_write(str);
}
return 0;
}
QString HrZones::summarize(int rnum, QVector<double> &time_in_zone) const
{
assert(rnum < ranges.size());
const HrZoneRange &range = ranges[rnum];
if (time_in_zone.size() < range.zones.size()) return "";
QString summary;
if(range.lt > 0){
summary += "<table align=\"center\" width=\"70%\" border=\"0\">";
summary += "<tr><td align=\"center\">";
summary += tr("Threshold (bpm): %1").arg(range.lt);
summary += "</td></tr></table>";
}
summary += "<table align=\"center\" width=\"70%\" ";
summary += "border=\"0\">";
summary += "<tr>";
summary += tr("<td align=\"center\">Zone</td>");
summary += tr("<td align=\"center\">Description</td>");
summary += tr("<td align=\"center\">Low (bpm)</td>");
summary += tr("<td align=\"center\">High (bpm)</td>");
summary += tr("<td align=\"center\">Time</td>");
summary += tr("<td align=\"center\">%</td>");
summary += "</tr>";
QColor color = QApplication::palette().alternateBase().color();
color = QColor::fromHsv(color.hue(), color.saturation() * 2, color.value());
double duration = 0;
foreach(double v, time_in_zone) { duration += v; }
for (int zone = 0; zone < time_in_zone.size(); ++zone) {
if (time_in_zone[zone] > 0.0) {
QString name, desc;
int lo, hi;
double trimp;
zoneInfo(rnum, zone, name, desc, lo, hi, trimp);
if (zone % 2 == 0)
summary += "<tr bgcolor='" + color.name() + "'>";
else
summary += "<tr>";
summary += QString("<td align=\"center\">%1</td>").arg(name);
summary += QString("<td align=\"center\">%1</td>").arg(desc);
summary += QString("<td align=\"center\">%1</td>").arg(lo);
if (hi == INT_MAX)
summary += "<td align=\"center\">MAX</td>";
else
summary += QString("<td align=\"center\">%1</td>").arg(hi);
summary += QString("<td align=\"center\">%1</td>")
.arg(time_to_string((unsigned) round(time_in_zone[zone])));
summary += QString("<td align=\"center\">%1</td>")
.arg((double)time_in_zone[zone]/duration * 100, 0, 'f', 0);
summary += "</tr>";
}
}
summary += "</table>";
return summary;
}
/********************************************************************
* FUNCTION tstamp_time2datetime
*
* Convert the specified time_t to a YANG data-and-time format
*
* INPUTS:
* timerec == pointer to time_t to convert
* buff == pointer to buffer to hold output
* MUST BE AT LEAST 21 CHARS
* OUTPUTS:
* buff is filled in
*********************************************************************/
void
tstamp_time2datetime (time_t *timerec,
xmlChar *buff)
{
assert(timerec && "timerec is NULL!");
assert(buff && "buff is NULL!");
struct tm *curtime = gmtime(timerec);
time_to_string(curtime, buff);
} /* tstamp_time2datetime */
/********************************************************************
* FUNCTION tstamp_datetime
*
* Set the current date and time in an XML dateTime string format
*
* INPUTS:
* buff == pointer to buffer to hold output
* MUST BE AT LEAST 21 CHARS
* OUTPUTS:
* buff is filled in
*********************************************************************/
void
tstamp_datetime (xmlChar *buff)
{
assert(buff && "buff is NULL!");
time_t utime;
(void)time(&utime);
struct tm *curtime = gmtime(&utime);
time_to_string(curtime, buff);
} /* tstamp_datetime */
QString TwitterDialog::metricToString(const RideMetric *m, SummaryMetrics &metrics, bool metricUnits)
{
QString s = "%1%2";
if (m->units(metricUnits) == "seconds" || m->units(metricUnits) == tr("seconds")) {
s = s.arg(time_to_string(metrics.getForSymbol(m->symbol())));
s = s.arg(""); // no units
} else {
s = s.arg(metrics.getForSymbol(m->symbol()) * (metricUnits ? 1 : m->conversion()), 0, 'f', m->precision() + (metricUnits ? 0 : m->conversionSum()));
s = s.arg(m->units(metricUnits));
}
return s;
}
void svg_blocked(int Yslot, int cpu, u64 start, u64 end, const char *backtrace)
{
if (!svgfile)
return;
fprintf(svgfile, "<g>\n");
fprintf(svgfile, "<title>#%d blocked %s</title>\n", cpu,
time_to_string(end - start));
if (backtrace)
fprintf(svgfile, "<desc>Blocked on:\n%s</desc>\n", backtrace);
svg_box(Yslot, start, end, "blocked");
fprintf(svgfile, "</g>\n");
}
struct command *
create_cmd(char *text, struct list *vars)
{
APP_DEBUG_FNAME;
if (check_line(text) != LINE_COMMAND) {
ERR("create_cmd()");
myabort();
}
struct command *cmd;
struct command_config c;
size_t n;
#define asterisk (strcmp(text, "*") == 0) ? -1 : strtol(text, NULL, 10)
n = run_r(CONF_REGEX_COMMAND_MIN, text);
c.min = asterisk;
text += n;
n = run_r(CONF_REGEX_COMMAND_HOUR, text);
c.hour = asterisk;
text += n;
n = run_r(CONF_REGEX_COMMAND_DOM, text);
c.dom = asterisk;
text += n;
n = run_r(CONF_REGEX_COMMAND_MON, text);
c.month = asterisk;
text += n;
n = run_r(CONF_REGEX_COMMAND_DOW, text);
c.dow = asterisk;
text += n;
if (strlen(text) <= 0) {
ERR("command_length <= 0");
myabort();
}
c.cmd = alloc_string(text);
strcpy(c.cmd, text);
cmd = transform(&c);
substitute(cmd->cmd, vars, cmd->cmd);
DEBUG("command '%s: %s' created",
time_to_string(cmd->seconds), cmd->cmd);
return (cmd);
}
ds_head_content read_camera_head_contents(const uint8_t(&flash_data_buffer)[SPI_FLASH_SECTOR_SIZE_IN_BYTES], uint32_t & serial_number)
{
//auto header = reinterpret_cast<const CameraHeadContents &>(flash_data_buffer[CAM_INFO_BLOCK_LEN]);
ds_head_content head_content = reinterpret_cast<const ds_head_content &>(flash_data_buffer[CAM_INFO_BLOCK_LEN]);
serial_number = head_content.serial_number;
LOG_INFO("Serial number = " << head_content.serial_number);
LOG_INFO("Model number = " << head_content.imager_model_number);
LOG_INFO("Revision number = " << head_content.module_revision_number);
LOG_INFO("Camera head contents version = " << head_content.camera_head_contents_version);
if (head_content.camera_head_contents_version != ds_head_content::DS_HEADER_VERSION_NUMBER) LOG_WARNING("Camera head contents version != 12, data may be missing/incorrect");
LOG_INFO("Module version = " << (int)head_content.module_version << "." << (int)head_content.module_major_version << "." << (int)head_content.module_minor_version << "." << (int)head_content.module_skew_version);
LOG_INFO("OEM ID = " << head_content.oem_id);
LOG_INFO("Lens type for left/right imagers = " << head_content.lens_type);
LOG_INFO("Lens type for third imager = " << head_content.lens_type_third_imager);
LOG_INFO("Lens coating for left/right imagers = " << head_content.lens_coating_type);
LOG_INFO("Lens coating for third imager = " << head_content.lens_coating_type_third_imager);
LOG_INFO("Nominal baseline (left to right) = " << head_content.nominal_baseline << " mm");
LOG_INFO("Nominal baseline (left to third) = " << head_content.nominal_baseline_third_imager << " mm");
LOG_INFO("Built on " << time_to_string(head_content.build_date) << " UTC");
LOG_INFO("Calibrated on " << time_to_string(head_content.calibration_date) << " UTC");
return head_content;
}
// delete files in antique files list, and empty the list.
// Returns number of files deleted, or negative for error.
//
// TODO: the list contains filenames, and we convert these to paths.
// This is wacked. The list should contain paths.
//
int delete_antique_files() {
int nfiles=0;
log_messages.printf(MSG_DEBUG,
"delete_antique_files(): start (%d files)\n",
(int)files_to_delete.size()
);
while (!files_to_delete.empty()) {
char timestamp[128];
char pathname[1024];
int retval;
FILE_RECORD fr = files_to_delete.front();
check_stop_daemons();
retval = get_file_path(
fr.name.c_str(), config.upload_dir,
config.uldl_dir_fanout, pathname
);
if (retval) {
log_messages.printf(MSG_CRITICAL,
"get_file_path(%s) failed: %s\n", fr.name.c_str(), boincerror(retval)
);
return retval;
}
strcpy(timestamp, time_to_string(fr.date_modified));
log_messages.printf(MSG_DEBUG,
"deleting [antique %s] %s\n",
timestamp, pathname
);
if (unlink(pathname)) {
int save_error=errno;
log_messages.printf(MSG_CRITICAL,
"unlink(%s) failed: %s\n",
pathname, strerror(save_error)
);
return retval;
} else {
nfiles++;
files_to_delete.pop_front();
}
}
log_messages.printf(MSG_DEBUG,
"delete_antique_files(): done, deleted %d files\n", nfiles
);
return 0;
}
static errno_t attr_time(TALLOC_CTX *mem_ctx,
struct sysdb_attrs *entry,
struct sss_domain_info *dom,
const char *attr,
const char **_value)
{
uint32_t value;
errno_t ret;
ret = sysdb_attrs_get_uint32_t(entry, attr, &value);
if (ret != EOK) {
return ret;
}
return time_to_string(mem_ctx, value, _value);
}
QString Zones::summarize(int rnum, QVector<double> &time_in_zone) const
{
assert(rnum < ranges.size());
ZoneRange *range = ranges[rnum];
assert(time_in_zone.size() == range->zones.size());
QString summary;
if(range->cp > 0){
summary += "<table align=\"center\" width=\"70%\" border=\"0\">";
summary += "<tr><td align=\"center\">";
summary += tr("Critical Power: %1").arg(range->cp);
summary += "</td></tr></table>";
}
summary += "<table align=\"center\" width=\"70%\" ";
summary += "border=\"0\">";
summary += "<tr>";
summary += "<td align=\"center\">Zone</td>";
summary += "<td align=\"center\">Description</td>";
summary += "<td align=\"center\">Low</td>";
summary += "<td align=\"center\">High</td>";
summary += "<td align=\"center\">Time</td>";
summary += "</tr>";
QColor color = QApplication::palette().alternateBase().color();
color = QColor::fromHsv(color.hue(), color.saturation() * 2, color.value());
for (int zone = 0; zone < time_in_zone.size(); ++zone) {
if (time_in_zone[zone] > 0.0) {
QString name, desc;
int lo, hi;
zoneInfo(rnum, zone, name, desc, lo, hi);
if (zone % 2 == 0)
summary += "<tr bgcolor='" + color.name() + "'>";
else
summary += "<tr>";
summary += QString("<td align=\"center\">%1</td>").arg(name);
summary += QString("<td align=\"center\">%1</td>").arg(desc);
summary += QString("<td align=\"center\">%1</td>").arg(lo);
if (hi == INT_MAX)
summary += "<td align=\"center\">MAX</td>";
else
summary += QString("<td align=\"center\">%1</td>").arg(hi);
summary += QString("<td align=\"center\">%1</td>")
.arg(time_to_string((unsigned) round(time_in_zone[zone])));
summary += "</tr>";
}
}
summary += "</table>";
return summary;
}
std::string cookie::dump() const
{
std::string result;
result.append(name_).append("=").append(value_);
if (expires_ != time_point::max())
result.append("; expires=")
.append(time_to_string(time_point::clock::to_time_t(expires_), "%a, %d-%b-%Y %T"));
if (!path_.empty())
result.append("; path=").append(path_);
if (!domain_.empty())
result.append("; domain=").append(domain_);
if (secure_)
result.append("; secure");
if (http_only_)
result.append("; httponly");
return result;
}
static int rfile_parse_eplf(rfile *f, char *str, const char *dirpath)
{
char *e;
if(!str || str[0] != '+')
return -1;
str++;
f->perm = xstrdup("-rw-r--r--");
f->size = 0L;
f->mtime = 0;
f->link = 0;
f->nhl = 0;
f->owner = xstrdup("owner");
f->group = xstrdup("group");
f->date = xstrdup("Jan 0 1900");
f->path = 0;
while((e = strqsep(&str, ',')) != 0) {
switch(*e) {
case '/':
f->perm[0] = 'd';
break;
case 'm':
f->mtime = strtoul(e+1, 0, 10);
free(f->date);
f->date = time_to_string(f->mtime);
break;
case 's':
f->size = strtoull(e+1, 0, 10);
break;
case '\t':
if (asprintf(&f->path, "%s/%s",
strcmp(dirpath, "/") ? dirpath : "", e+1) == -1)
f->path = NULL;
break;
}
}
if (!f->path)
return -1;
rfile_parse_colors(f);
return 0;
}
void html_gen(char * fileName, garage_stats_entry * entries, size_t count)
{
FILE * f = fopen(fileName, "w+");
char html_buf[HTML_BUFF_LEN] = "";
char table_buff[HTML_BUFF_LEN] = "";
strcat(table_buff, "<tr><th>ID</th><th>Type</th><th>ActionTime</th><th>Called</th></tr>");
for (int i = 0; i < count; i++)
{
char entry_buf[HTML_BUFF_LEN];
char time_str[1000];
time_to_string(entries[i].actionTime, time_str);
sprintf(entry_buf, "<tr><td>%i</td><td>%s</td><td>%s</td><td>%s</td></tr>", entries[i].id, entries[i].type, time_str, entries[i].called);
strcat(table_buff, entry_buf);
}
sprintf(html_buf, "<html><title>GARAGE STATS</title><body><table>%s</table></body></html>", table_buff);
fwrite(html_buf, sizeof(char), strlen(html_buf), f);
fclose(f);
}
void log_message_error(const char* msg, int error_code) {
char evt_msg[2048];
char* time_string = time_to_string(dtime());
snprintf(evt_msg, sizeof(evt_msg),
"%s %s\n"
"Error Code: %d\n",
time_string, msg, error_code
);
if (!gstate.executing_as_daemon) {
fprintf(stderr, "%s", evt_msg);
} else {
#ifdef _WIN32
LogEventErrorMessage(evt_msg);
#elif defined(__EMX__)
#elif defined (__APPLE__)
#elif defined (ANDROID)
__android_log_print(ANDROID_LOG_ERROR, "BOINC", evt_msg);
#else
syslog(LOG_DAEMON|LOG_ERR, "%s", evt_msg);
#endif
}
}
// Display a message to the user.
// Depending on the priority, the message may be more or less obtrusive
//
void show_message(PROJECT *p, char* msg, int priority) {
const char* x;
char message[1024];
time_t now = time(0);
char* time_string = time_to_string((double)now);
// Cycle the log files if we need to
diagnostics_cycle_logs();
if (priority == MSG_INTERNAL_ERROR) {
strcpy(message, "[error] ");
strlcpy(message+8, msg, sizeof(message)-8);
} else {
strlcpy(message, msg, sizeof(message));
}
// trim trailing \n's
//
while (strlen(message)&&message[strlen(message)-1] == '\n') {
message[strlen(message)-1] = 0;
}
if (p) {
x = p->get_project_name();
} else {
x = "---";
}
message_descs.insert(p, priority, (int)now, message);
printf("%s [%s] %s\n", time_string, x, message);
if (gstate.executing_as_daemon) {
#ifdef _WIN32
char event_message[2048];
sprintf(event_message, "%s [%s] %s\n", time_string, x, message);
::OutputDebugString(event_message);
#endif
}
}
static errno_t attr_initgr(TALLOC_CTX *mem_ctx,
struct sysdb_attrs *entry,
struct sss_domain_info *dom,
const char *attr,
const char **_value)
{
uint32_t value;
errno_t ret;
ret = sysdb_attrs_get_uint32_t(entry, attr, &value);
if (ret == ENOENT) {
*_value = "Initgroups were not yet performed";
return EOK;
} else if (ret != EOK) {
return ret;
}
if (value < time(NULL)) {
*_value = "Expired";
return EOK;
}
return time_to_string(mem_ctx, value, _value);
}
