void write_stats(int what)
{
StatsEntry stats = STATS_ENTRY__INIT;
DumpStatsEntry dstats = DUMP_STATS_ENTRY__INIT;
char *name;
int fd;
pr_info("Writing stats\n");
if (what == DUMP_STATS) {
stats.dump = &dstats;
encode_time(TIME_FREEZING, &dstats.freezing_time);
encode_time(TIME_FROZEN, &dstats.frozen_time);
encode_time(TIME_MEMDUMP, &dstats.memdump_time);
encode_time(TIME_MEMWRITE, &dstats.memwrite_time);
dstats.pages_scanned = counts[CNT_PAGES_SCANNED];
dstats.pages_skipped_parent = counts[CNT_PAGES_SKIPPED_PARENT];
dstats.pages_written = counts[CNT_PAGES_WRITTEN];
name = "dump";
} else
return;
fd = open_image(CR_FD_STATS, O_DUMP, name);
if (fd >= 0) {
pb_write_one(fd, &stats, PB_STATS);
close(fd);
}
}
Fl_Date_Time::Fl_Date_Time (const char * dat) {
int i;
// NLS stuff
for (i=0; i<7;i++) dayname[i]=_(dayname[i]);
for (i=0; i<12;i++) mname[i]=_(mname[i]);
Fl_String s1( Fl_String(dat).trim() );
Fl_String s2;
if (!*dat) {
m_dateTime = 0;
return;
}
int p = s1.pos(" ");
if (p >= 0) {
s2 = s1.sub_str(p+1,20).trim();
s1[p] = 0;
}
if ( strchr(s1.c_str(),dateSeparator) ) {
encode_date(m_dateTime, s1.c_str());
if ( strchr(s2.c_str(),timeSeparator) ) {
double dt;
encode_time(dt, s2.c_str());
m_dateTime += dt;
}
}
else encode_time(m_dateTime, s1.c_str());
}
void ls_to_buf(char *lsbuf, struct sbuf *sb)
{
int n;
char *p;
time_t time;
const char *f;
struct stat *statp=&sb->statp;
*lsbuf='\0';
p=encode_mode(statp->st_mode, lsbuf);
n=sprintf(p, " %2d ", (uint32_t)statp->st_nlink);
p+=n;
n=sprintf(p, "%5d %5d", (uint32_t)statp->st_uid,
(uint32_t)statp->st_gid);
p+=n;
n=sprintf(p, " %7lu ", (unsigned long)statp->st_size);
p+=n;
if(statp->st_ctime>statp->st_mtime) time=statp->st_ctime;
else time=statp->st_mtime;
// Display most recent time.
p=encode_time(time, p);
*p++=' ';
for(f=sb->path.buf; *f; ) *p++=*f++;
*p=0;
}
void ls_output(char *buf, const char *fname, struct stat *statp)
{
char *p;
const char *f;
int n;
time_t time;
p = encode_mode(statp->st_mode, buf);
n = sprintf(p, " %2d ", (uint32_t)statp->st_nlink);
p += n;
n = sprintf(p, "%5d %5d",
(uint32_t)statp->st_uid,
(uint32_t)statp->st_gid);
p += n;
n = sprintf(p, " %7lu ", (unsigned long) statp->st_size);
p += n;
if (statp->st_ctime > statp->st_mtime)
time = statp->st_ctime;
else
time = statp->st_mtime;
/* Display most recent time */
p = encode_time(time, p);
*p++ = ' ';
for (f=fname; *f; )
*p++ = *f++;
*p = 0;
}
Fl_Date_Time Fl_Date_Time::convert(const long tt) {
struct tm *t = localtime((time_t*)&tt);
double dat,tim;
encode_date(dat,short(t->tm_year+1900),short(t->tm_mon+1),short(t->tm_mday));
encode_time(tim,short(t->tm_hour),short(t->tm_min),short(t->tm_sec),short(0));
return dat + tim;
}
void Fl_Date_Time::encode_date(double &dt,const char *dat) {
char bdat[64];
short datePart[7], partNumber = 0;
char *ptr = NULL;
int i;
memset(datePart,0,sizeof(datePart));
upperCase(bdat, dat, sizeof(bdat));
if (strcmp(bdat,"TODAY") == 0) {
dt = Date(); // Sets the current date
return;
} else {
int len = strlen(bdat);
for(i = 0; i <= len && partNumber < 7; i++) {
char c = bdat[i];
if (c == dateSeparator || c == timeSeparator || c == ' ' || c == 0) {
if (c == timeSeparator && partNumber < 3) partNumber = 3;
if (ptr) { // end of token
bdat[i] = 0;
datePart[partNumber] = (short)atoi(ptr);
partNumber++;
ptr = NULL;
}
} else {
if (!isdigit(c)) {
dt = 0;
return;
}
if (!ptr) ptr = bdat + i;
}
}
if (partNumber < 3) { // Not enough date parts
dt = 0;
return;
}
short month=0, day=0, year=0;
for(i = 0; i < 3; i++)
switch (datePartsOrder[i]) {
case 'M': month = datePart[i]; break;
case 'D': day = datePart[i]; break;
case 'Y': year = datePart[i]; break;
}
if (year < 100) {
if (year < 35) year = short(year + 2000);
else year = short(year + 1900);
}
double dd;
encode_date(dd,year,month,day);
if (partNumber > 3) { // Time part included into string
double d;
encode_time(d,datePart[3],datePart[4],datePart[5],datePart[6]);
dd += d;
}
dt = dd;
}
}
ISC_TIMESTAMP TimeStamp::encode_timestamp(const struct tm* times, const int fractions)
{
fb_assert(fractions >= 0 && fractions < ISC_TIME_SECONDS_PRECISION);
ISC_TIMESTAMP ts;
ts.timestamp_date = encode_date(times);
ts.timestamp_time = encode_time(times->tm_hour, times->tm_min, times->tm_sec, fractions);
return ts;
}
//----------------------------------------------------------------
// Constructors
//----------------------------------------------------------------
Fl_Date_Time::Fl_Date_Time (short year,short month,short day,short hour,short minute,short second) {
double t;
int i;
// NLS stuff
for (i=0; i<7;i++) dayname[i]=_(dayname[i]);
for (i=0; i<12;i++) mname[i]=_(mname[i]);
encode_date(m_dateTime,year,month,day);
encode_time(t,hour,minute,second);
m_dateTime += t;
}
void
encode_event(DBusMessageIter *iter, int *err, const alarm_event_t *eve,
const char **def_args)
{
encode_cookie (iter, err, &eve->ALARMD_PRIVATE(cookie));
encode_time (iter, err, &eve->ALARMD_PRIVATE(trigger));
encode_string (iter, err, &eve->title);
encode_string (iter, err, &eve->message);
encode_string (iter, err, &eve->sound);
encode_string (iter, err, &eve->icon);
encode_unsigned (iter, err, &eve->flags);
encode_string (iter, err, &eve->alarm_appid);
encode_time (iter, err, &eve->alarm_time);
encode_tm (iter, err, &eve->alarm_tm);
encode_string (iter, err, &eve->alarm_tz);
encode_time (iter, err, &eve->recur_secs);
encode_int (iter, err, &eve->recur_count);
encode_time (iter, err, &eve->snooze_secs);
encode_time (iter, err, &eve->snooze_total);
encode_size (iter, err, &eve->action_cnt);
encode_int (iter, err, &eve->response);
for( size_t i = 0; i < eve->action_cnt; ++i )
{
encode_action(iter, err, &eve->action_tab[i], def_args);
}
encode_size (iter, err, &eve->recurrence_cnt);
for( size_t i = 0; i < eve->recurrence_cnt; ++i )
{
encode_recur(iter, err, &eve->recurrence_tab[i]);
}
encode_size (iter, err, &eve->attr_cnt);
for( size_t i = 0; i < eve->attr_cnt; ++i )
{
encode_attr(iter, err, eve->attr_tab[i]);
}
}
void Fl_Date_Time::encode_time(double& dt,const char *tim) {
char bdat[32];
short timePart[4] = { 0, 0, 0, 0},
partNumber = 0;
char *ptr = NULL;
bool afternoon = false;
upperCase(bdat, tim, sizeof(bdat));
if (!trimRight(bdat)) {
dt = 0;
return;
}
if (strcmp(bdat,"TIME") == 0) {
dt = Time(); // Sets the current date
return;
} else {
char *p = strstr(bdat,"AM");
if (p) {
*p = 0;
} else {
p = strstr(bdat,"PM");
if (p) {
*p = 0;
afternoon = true;
}
}
trimRight(bdat);
int len = strlen(bdat);
for (int i = 0; i <= len && partNumber < 4; i++) {
char c = bdat[i];
if (c == timeSeparator || c == ' ' || c == '.' || c == 0) {
if (ptr) { // end of token
bdat[i] = 0;
timePart[partNumber] = (short) atoi(ptr);
partNumber++;
ptr = NULL;
}
} else {
if (!isdigit(c)) {
dt = 0;
return;
}
if (!ptr) ptr = bdat + i;
}
}
if (afternoon && timePart[0] != 12)
timePart[0] = short(timePart[0] + 12);
encode_time(dt,timePart[0],timePart[1],timePart[2],timePart[3]);
}
}
/*----------------------------------------------------------------------------*/
void disp_rec_time(void)
{
u16 encoder_time;
u8 min,sec;
encoder_time = encode_time();
min = encoder_time / 60;
sec = encoder_time % 60;
printf_num(sec,2,2);
printf_num(min,0,2);
led_putchar(':',0);
}
void
encode_attr(DBusMessageIter *iter, int *err, const alarm_attr_t *att)
{
encode_string(iter, err, &att->attr_name);
encode_int (iter, err, &att->attr_type);
switch( att->attr_type )
{
case ALARM_ATTR_NULL: break;
case ALARM_ATTR_INT: encode_int (iter, err, &att->attr_data.ival); break;
case ALARM_ATTR_TIME: encode_time (iter, err, &att->attr_data.tval); break;
case ALARM_ATTR_STRING:encode_string(iter, err, &att->attr_data.sval); break;
}
}
/*
* Print an ls style message, also send M_RESTORED
*/
void print_ls_output(JCR *jcr, ATTR *attr)
{
char buf[5000];
char ec1[30];
char en1[30], en2[30];
char *p, *f;
guid_list *guid;
if (attr->type == FT_DELETED) { /* TODO: change this to get last seen values */
bsnprintf(buf, sizeof(buf),
"---------- - - - - ---------- -------- %s\n", attr->ofname);
Dmsg1(20, "%s", buf);
Jmsg(jcr, M_RESTORED, 1, "%s", buf);
return;
}
if (!jcr->id_list) {
jcr->id_list = new_guid_list();
}
guid = jcr->id_list;
p = encode_mode(attr->statp.st_mode, buf);
p += sprintf(p, " %2d ", (uint32_t)attr->statp.st_nlink);
p += sprintf(p, "%-8.8s %-8.8s",
guid->uid_to_name(attr->statp.st_uid, en1, sizeof(en1)),
guid->gid_to_name(attr->statp.st_gid, en2, sizeof(en2)));
p += sprintf(p, "%10.10s ", edit_int64(attr->statp.st_size, ec1));
p = encode_time(attr->statp.st_ctime, p);
*p++ = ' ';
*p++ = ' ';
for (f=attr->ofname; *f && (p-buf) < (int)sizeof(buf)-10; ) {
*p++ = *f++;
}
if (attr->type == FT_LNK) {
*p++ = ' ';
*p++ = '-';
*p++ = '>';
*p++ = ' ';
/* Copy link name */
for (f=attr->olname; *f && (p-buf) < (int)sizeof(buf)-10; ) {
*p++ = *f++;
}
}
*p++ = '\n';
*p = 0;
Dmsg1(20, "%s", buf);
Jmsg(jcr, M_RESTORED, 1, "%s", buf);
}
void write_stats(int what)
{
StatsEntry stats = STATS_ENTRY__INIT;
DumpStatsEntry ds_entry = DUMP_STATS_ENTRY__INIT;
RestoreStatsEntry rs_entry = RESTORE_STATS_ENTRY__INIT;
char *name;
struct cr_img *img;
pr_info("Writing stats\n");
if (what == DUMP_STATS) {
stats.dump = &ds_entry;
encode_time(TIME_FREEZING, &ds_entry.freezing_time);
encode_time(TIME_FROZEN, &ds_entry.frozen_time);
encode_time(TIME_MEMDUMP, &ds_entry.memdump_time);
encode_time(TIME_MEMWRITE, &ds_entry.memwrite_time);
ds_entry.has_irmap_resolve = true;
encode_time(TIME_IRMAP_RESOLVE, &ds_entry.irmap_resolve);
ds_entry.pages_scanned = dstats->counts[CNT_PAGES_SCANNED];
ds_entry.pages_skipped_parent = dstats->counts[CNT_PAGES_SKIPPED_PARENT];
ds_entry.pages_written = dstats->counts[CNT_PAGES_WRITTEN];
ds_entry.pages_zero = dstats->counts[CNT_PAGES_ZERO];
ds_entry.pages_lazy = dstats->counts[CNT_PAGES_LAZY];
name = "dump";
} else if (what == RESTORE_STATS) {
stats.restore = &rs_entry;
rs_entry.pages_compared = atomic_read(&rstats->counts[CNT_PAGES_COMPARED]);
rs_entry.pages_skipped_cow = atomic_read(&rstats->counts[CNT_PAGES_SKIPPED_COW]);
rs_entry.has_pages_restored = true;
rs_entry.pages_restored = atomic_read(&rstats->counts[CNT_PAGES_RESTORED]);
encode_time(TIME_FORK, &rs_entry.forking_time);
encode_time(TIME_RESTORE, &rs_entry.restore_time);
name = "restore";
} else
return;
img = open_image_at(AT_FDCWD, CR_FD_STATS, O_DUMP, name);
if (img) {
pb_write_one(img, &stats, PB_STATS);
close_image(img);
}
}
static void print_ls_output(char *fname, char *link, int type, struct stat *statp)
{
char buf[2000];
char ec1[30];
char *p, *f;
int n;
if (type == FT_LNK) {
statp->st_mtime = 0;
statp->st_mode |= 0777;
}
p = encode_mode(statp->st_mode, buf);
n = sprintf(p, " %2d ", (uint32_t)statp->st_nlink);
p += n;
n = sprintf(p, "%-4d %-4d", (int)statp->st_uid, (int)statp->st_gid);
p += n;
n = sprintf(p, "%10.10s ", edit_uint64(statp->st_size, ec1));
p += n;
if (S_ISCHR(statp->st_mode) || S_ISBLK(statp->st_mode)) {
n = sprintf(p, "%4x ", (int)statp->st_rdev);
} else {
n = sprintf(p, " ");
}
p += n;
p = encode_time(statp->st_mtime, p);
*p++ = ' ';
/* Copy file name */
for (f=fname; *f && (p-buf) < (int)sizeof(buf); )
*p++ = *f++;
if (type == FT_LNK) {
*p++ = '-';
*p++ = '>';
*p++ = ' ';
/* Copy link name */
for (f=link; *f && (p-buf) < (int)sizeof(buf); )
*p++ = *f++;
}
*p++ = '\n';
*p = 0;
fputs(buf, stdout);
}
static int sdp_encode (session_desc_t *sptr, sdp_encode_t *se)
{
int temp, temp1;
media_desc_t *mptr;
char buffer[80];
if (sptr->create_addr_type == NULL ||
sptr->create_addr == NULL) {
return (ESDP_ORIGIN);
}
ADD_STR_TO_ENCODE_WITH_RETURN(se, "v=0\no=");
ADD_STR_TO_ENCODE_WITH_RETURN(se,
sptr->orig_username == NULL ?
"-" : sptr->orig_username);
sprintf(buffer, " "D64" "D64" IN ",
sptr->session_id,
sptr->session_version);
ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->create_addr_type);
ADD_STR_TO_ENCODE_WITH_RETURN(se, " ");
ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->create_addr);
ADD_STR_TO_ENCODE_WITH_RETURN(se, "\ns=");
ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->session_name);
ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
if (sptr->session_desc != NULL) {
ADD_STR_TO_ENCODE_WITH_RETURN(se, "i=");
ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->session_desc);
ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
}
if (sptr->uri != NULL) {
ADD_STR_TO_ENCODE_WITH_RETURN(se, "u=");
ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->uri);
ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
}
CHECK_RETURN(encode_string_list(sptr->admin_email, se, "e=", &temp));
CHECK_RETURN(encode_string_list(sptr->admin_phone, se, "p=", &temp1));
if (temp + temp1 == 0) {
ADD_STR_TO_ENCODE_WITH_RETURN(se, "e=NONE\n");
}
if (sptr->session_connect.used) {
CHECK_RETURN(encode_connect(&sptr->session_connect, se));
}
CHECK_RETURN(encode_bandwidth(sptr->session_bandwidth, se));
CHECK_RETURN(encode_time(sptr->time_desc, se));
CHECK_RETURN(encode_time_adj(sptr->time_adj_desc, se));
CHECK_RETURN(encode_key(&sptr->key, se));
if (sptr->control_string) {
ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=control:");
ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->control_string);
ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
}
CHECK_RETURN(encode_category(sptr->category_list, se));
if (sptr->keywds) {
ADD_STR_TO_ENCODE_WITH_RETURN(se, "u=");
ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->uri);
ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
}
CHECK_RETURN(encode_conf_type(sptr, se));
if (sptr->tool) {
ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=tool:");
ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->tool);
ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
}
if (sptr->charset) {
ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=charset:");
ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->charset);
ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
}
if (sptr->sdplang) {
ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=sdplang:");
ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->sdplang);
ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
}
if (sptr->lang) {
ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=lang:");
ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->lang);
ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
}
if (sptr->etag) {
ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=etag:");
ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->etag);
ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
}
CHECK_RETURN(encode_range(&sptr->session_range, se));
CHECK_RETURN(encode_a_ints(sptr->recvonly,
sptr->sendrecv,
sptr->sendonly,
se));
CHECK_RETURN(encode_string_list(sptr->unparsed_a_lines, se, "", NULL));
mptr = sptr->media;
while (mptr != NULL) {
CHECK_RETURN(encode_media(mptr, se));
mptr = mptr->next;
}
return (0);
}
