/*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ main() $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/
int
main(int argc, char *argv[])
{
int n,
status,
#ifdef WITHOUT_FIFO_RW_SUPPORT
aw_cmd_writefd,
#endif
aw_cmd_fd;
time_t diff_time,
next_report_time,
next_rescan_time = 0L,
now;
char archive_dir[MAX_PATH_LENGTH],
aw_cmd_fifo[MAX_PATH_LENGTH],
buffer[DEFAULT_BUFFER_SIZE],
work_dir[MAX_PATH_LENGTH];
fd_set rset;
struct timeval timeout;
struct stat stat_buf;
CHECK_FOR_VERSION(argc, argv);
/* First get working directory for the AFD. */
if (get_afd_path(&argc, argv, work_dir) < 0)
{
exit(INCORRECT);
}
else
{
char *ptr;
p_work_dir = work_dir;
/*
* Lock archive_watch so no other archive_watch can be started!
*/
if ((ptr = lock_proc(AW_LOCK_ID, NO)) != NULL)
{
system_log(ERROR_SIGN, __FILE__, __LINE__,
_("Process archive_watch already started by %s."), ptr);
exit(INCORRECT);
}
}
/* Initialize fifo to communicate with AFD. */
(void)strcpy(aw_cmd_fifo, work_dir);
(void)strcat(aw_cmd_fifo, FIFO_DIR);
(void)strcat(aw_cmd_fifo, AW_CMD_FIFO);
(void)strcpy(archive_dir, work_dir);
(void)strcat(archive_dir, AFD_ARCHIVE_DIR);
/* Now lets open the fifo to receive commands from the AFD. */
if ((stat(aw_cmd_fifo, &stat_buf) < 0) || (!S_ISFIFO(stat_buf.st_mode)))
{
if (make_fifo(aw_cmd_fifo) < 0)
{
system_log(ERROR_SIGN, __FILE__, __LINE__,
_("Could not create fifo `%s'."), aw_cmd_fifo);
exit(INCORRECT);
}
}
#ifdef WITHOUT_FIFO_RW_SUPPORT
if (open_fifo_rw(aw_cmd_fifo, &aw_cmd_fd, &aw_cmd_writefd) == -1)
#else
if ((aw_cmd_fd = coe_open(aw_cmd_fifo, O_RDWR)) == -1)
#endif
{
system_log(ERROR_SIGN, __FILE__, __LINE__,
_(": Could not open fifo `%s' : %s"),
aw_cmd_fifo, strerror(errno));
exit(INCORRECT);
}
#ifdef HAVE_SETPRIORITY
get_afd_config_value();
#endif
/* Do some cleanups when we exit. */
if (atexit(aw_exit) != 0)
{
system_log(ERROR_SIGN, __FILE__, __LINE__,
_("Could not register exit handler : %s"), strerror(errno));
exit(INCORRECT);
}
if ((signal(SIGINT, sig_exit) == SIG_ERR) ||
(signal(SIGQUIT, sig_exit) == SIG_ERR) ||
(signal(SIGTERM, SIG_IGN) == SIG_ERR) ||
(signal(SIGSEGV, sig_segv) == SIG_ERR) ||
(signal(SIGBUS, sig_bus) == SIG_ERR) ||
(signal(SIGHUP, SIG_IGN) == SIG_ERR))
{
system_log(WARN_SIGN, __FILE__, __LINE__,
_("Could not set signal handlers : %s"), strerror(errno));
}
system_log(INFO_SIGN, NULL, 0, "Starting %s (%s)",
ARCHIVE_WATCH, PACKAGE_VERSION);
next_report_time = (time(NULL) / 3600) * 3600 + 3600;
FD_ZERO(&rset);
for (;;)
{
if (time(&now) >= next_rescan_time)
{
next_rescan_time = (now / ARCHIVE_STEP_TIME) *
ARCHIVE_STEP_TIME + ARCHIVE_STEP_TIME;
}
/* Initialize descriptor set and timeout. */
FD_SET(aw_cmd_fd, &rset);
timeout.tv_usec = 0;
if ((diff_time = (next_rescan_time - now)) < 0)
{
diff_time = 0L;
}
timeout.tv_sec = diff_time;
/* Wait for message x seconds and then continue. */
status = select(aw_cmd_fd + 1, &rset, NULL, NULL, &timeout);
/* Report every hour how many archives have been deleted. */
#ifndef AFDBENCH_CONFIG
if ((now + diff_time) >= next_report_time)
{
next_report_time = ((now + diff_time) / 3600) * 3600 + 3600;
#endif
#ifdef _NO_ZERO_DELETION_REPORT
if ((removed_archives > 0) || (removed_files > 0))
{
system_log(INFO_SIGN, NULL, 0,
_("Removed %u archives with %u files."),
removed_archives, removed_files);
}
#else
system_log(INFO_SIGN, NULL, 0,
_("Removed %u archives with %u files."),
removed_archives, removed_files);
#endif
removed_archives = removed_files = 0;
#ifndef AFDBENCH_CONFIG
}
#endif
/* Huh? Did we just sleep? */
if (status == 0)
{
/* Lets go to work! */
current_time = now + diff_time;
inspect_archive(archive_dir);
}
else if (FD_ISSET(aw_cmd_fd, &rset))
{
/* Read the message. */
if ((n = read(aw_cmd_fd, buffer, DEFAULT_BUFFER_SIZE)) > 0)
{
while (n > 0)
{
#ifdef _FIFO_DEBUG
show_fifo_data('R', "aw_cmd", buffer, n, __FILE__, __LINE__);
#endif
if (buffer[0] == STOP)
{
system_log(INFO_SIGN, NULL, 0,
_("Stopped %s"), ARCHIVE_WATCH);
exit(SUCCESS);
}
else if (buffer[0] == RETRY)
{
system_log(INFO_SIGN, NULL, 0,
_("Rescaning archive directories."),
ARCHIVE_WATCH);
/* Remember to set current_time, since the */
/* function inspect_archive() depends on it. */
current_time = time(NULL);
inspect_archive(archive_dir);
}
else
{
system_log(DEBUG_SIGN, __FILE__, __LINE__,
_("Hmmm..., reading garbage [%d] on fifo `%s'."),
buffer[0], AW_CMD_FIFO);
}
n--;
} /* while (n > 0) */
}
}
else if (status < 0)
{
system_log(FATAL_SIGN, __FILE__, __LINE__,
_("select() error : %s"), strerror(errno));
exit(INCORRECT);
}
else
{
system_log(FATAL_SIGN, __FILE__, __LINE__,
_("Huh? Maybe YOU have a clue whats going on here!"));
exit(INCORRECT);
}
} /* for (;;) */
exit(SUCCESS);
}
/*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ main() $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/
int
main(int argc, char *argv[])
{
register int i,
j;
int current_year,
hour,
new_year,
status,
test_sec_counter,
test_hour_counter;
unsigned int ui_value; /* Temporary storage for uns. ints */
time_t next_rescan_time = 0L,
now;
long int sleep_time;
double d_value[MAX_NO_PARALLEL_JOBS]; /* Temporary storage */
/* for doubles. */
char work_dir[MAX_PATH_LENGTH],
istatistic_file_name[MAX_FILENAME_LENGTH],
statistic_file_name[MAX_FILENAME_LENGTH];
struct timeval timeout;
struct stat stat_buf;
struct tm *p_ts;
CHECK_FOR_VERSION(argc, argv);
/* Evaluate arguments */
statistic_file_name[0] = istatistic_file_name[0] = '\0';
if (get_afd_path(&argc, argv, work_dir) < 0)
{
exit(INCORRECT);
}
eval_input_as(argc, argv, work_dir, statistic_file_name,
istatistic_file_name);
#ifdef HAVE_SETPRIORITY
get_afd_config_value();
#endif
/* Initialize variables */
now = time(NULL);
p_ts = gmtime(&now);
/*
* NOTE: We must put the hour into a temporary storage since
* function system_log() uses the function localtime which seems
* to overwrite our p_ts->tm_hour with local time!?
*/
hour = p_ts->tm_hour;
current_year = p_ts->tm_year + 1900;
p_work_dir = work_dir;
if (statistic_file_name[0] == '\0')
{
char str_year[6];
(void)sprintf(str_year, ".%d", current_year);
(void)strcpy(statistic_file, work_dir);
(void)strcat(statistic_file, LOG_DIR);
(void)strcpy(new_statistic_file, statistic_file);
(void)strcat(new_statistic_file, NEW_STATISTIC_FILE);
(void)strcat(new_statistic_file, str_year);
(void)strcpy(new_istatistic_file, statistic_file);
(void)strcat(new_istatistic_file, NEW_ISTATISTIC_FILE);
(void)strcat(new_istatistic_file, str_year);
(void)strcpy(istatistic_file, statistic_file);
(void)strcat(istatistic_file, ISTATISTIC_FILE);
(void)strcat(istatistic_file, str_year);
(void)strcat(statistic_file, STATISTIC_FILE);
(void)strcat(statistic_file, str_year);
}
else
{
(void)strcpy(statistic_file, statistic_file_name);
(void)strcpy(new_statistic_file, statistic_file);
(void)strcat(new_statistic_file, ".NEW");
(void)strcpy(istatistic_file, istatistic_file_name);
(void)strcpy(new_istatistic_file, istatistic_file);
(void)strcat(new_istatistic_file, ".NEW");
}
if (other_file == NO)
{
char sys_log_fifo[MAX_PATH_LENGTH];
(void)strcpy(sys_log_fifo, work_dir);
(void)strcat(sys_log_fifo, FIFO_DIR);
(void)strcat(sys_log_fifo, SYSTEM_LOG_FIFO);
/* If the process AFD has not yet created the */
/* system log fifo create it now. */
if ((stat(sys_log_fifo, &stat_buf) < 0) || (!S_ISFIFO(stat_buf.st_mode)))
{
if (make_fifo(sys_log_fifo) < 0)
{
(void)fprintf(stderr,
"ERROR : Could not create fifo %s. (%s %d)\n",
sys_log_fifo, __FILE__, __LINE__);
exit(INCORRECT);
}
}
/* Open system log fifo */
#ifdef WITHOUT_FIFO_RW_SUPPORT
if (open_fifo_rw(sys_log_fifo, &sys_log_readfd, &sys_log_fd) == -1)
#else
if ((sys_log_fd = open(sys_log_fifo, O_RDWR)) == -1)
#endif
{
(void)fprintf(stderr, "ERROR : Could not open fifo %s : %s (%s %d)\n",
sys_log_fifo, strerror(errno), __FILE__, __LINE__);
exit(INCORRECT);
}
}
/* Attach to FSA (output) and FRA (input) so we can */
/* accumulate the statistics for both. */
if (fsa_attach(AFD_STAT) < 0)
{
system_log(FATAL_SIGN, __FILE__, __LINE__, "Failed to attach to FSA.");
exit(INCORRECT);
}
if (fra_attach() < 0)
{
system_log(FATAL_SIGN, __FILE__, __LINE__, "Failed to attach to FRA.");
exit(INCORRECT);
}
/*
* Read old AFD statistics database file if it is there. If not creat it!
*/
read_afd_stat_db(no_of_hosts);
read_afd_istat_db(no_of_dirs);
/* Tell user we are starting the AFD_STAT */
if (other_file == NO)
{
system_log(INFO_SIGN, NULL, 0, "Starting %s (%s)",
AFD_STAT, PACKAGE_VERSION);
}
/* Do some cleanups when we exit */
if (atexit(stat_exit) != 0)
{
system_log(FATAL_SIGN, __FILE__, __LINE__,
"Could not register exit handler : %s", strerror(errno));
exit(INCORRECT);
}
/* Ignore any SIGHUP signal. */
if ((signal(SIGINT, sig_exit) == SIG_ERR) ||
(signal(SIGQUIT, sig_exit) == SIG_ERR) ||
(signal(SIGTERM, sig_exit) == SIG_ERR) ||
(signal(SIGSEGV, sig_segv) == SIG_ERR) ||
(signal(SIGBUS, sig_bus) == SIG_ERR) ||
(signal(SIGHUP, SIG_IGN) == SIG_ERR))
{
system_log(DEBUG_SIGN, __FILE__, __LINE__,
"signal() error : %s", strerror(errno));
}
next_rescan_time = (now / STAT_RESCAN_TIME) *
STAT_RESCAN_TIME + STAT_RESCAN_TIME;
/* Initialize sec_counter, hour_counter and day_counter. */
test_sec_counter = (((p_ts->tm_min * 60) + p_ts->tm_sec) /
STAT_RESCAN_TIME) + 1;
for (i = 0; i < no_of_hosts; i++)
{
stat_db[i].sec_counter = test_sec_counter;
stat_db[i].hour_counter = hour;
stat_db[i].day_counter = p_ts->tm_yday;
}
for (i = 0; i < no_of_dirs; i++)
{
istat_db[i].sec_counter = test_sec_counter;
istat_db[i].hour_counter = hour;
istat_db[i].day_counter = p_ts->tm_yday;
}
for (;;)
{
if ((sleep_time = (next_rescan_time - time(NULL))) < 0)
{
sleep_time = 0L;
}
timeout.tv_usec = 0;
timeout.tv_sec = sleep_time;
status = select(0, NULL, NULL, NULL, &timeout);
/* Did we get a timeout? */
if (status == 0)
{
now = time(NULL);
if (now != next_rescan_time)
{
now = (now + (STAT_RESCAN_TIME / 2)) / STAT_RESCAN_TIME *
STAT_RESCAN_TIME;
}
next_rescan_time = (now / STAT_RESCAN_TIME) *
STAT_RESCAN_TIME + STAT_RESCAN_TIME;
p_ts = gmtime(&now);
test_sec_counter = ((p_ts->tm_min * 60) + p_ts->tm_sec) /
STAT_RESCAN_TIME;
test_hour_counter = p_ts->tm_hour;
if (test_sec_counter != stat_db[0].sec_counter)
{
if ((((stat_db[0].sec_counter - test_sec_counter) == 1) &&
(test_hour_counter == stat_db[0].hour_counter)) ||
((stat_db[0].sec_counter == 0) && (test_sec_counter == 719)))
{
(void)sleep(STAT_RESCAN_TIME);
}
else
{
system_log(DEBUG_SIGN, __FILE__, __LINE__,
"Hmmm..., second counter wrong [%d -> %d]. Correcting.",
stat_db[0].sec_counter, test_sec_counter);
for (i = 0; i < no_of_hosts; i++)
{
stat_db[i].sec_counter = test_sec_counter;
}
for (i = 0; i < no_of_dirs; i++)
{
istat_db[i].sec_counter = test_sec_counter;
}
}
}
if (test_hour_counter != stat_db[0].hour_counter)
{
if ((((test_hour_counter + 1) == stat_db[0].hour_counter) ||
((stat_db[0].hour_counter == 0) && (test_hour_counter == 23))) &&
(p_ts->tm_min == 59) && (p_ts->tm_sec > 54))
{
/* Sometimes it happens that current time is just one */
/* second behind and when this is just before the hour */
/* value changes we think we are an hour behind. */;
}
else
{
system_log(DEBUG_SIGN, __FILE__, __LINE__,
"Hmmm..., hour counter wrong [%d -> %d]. Correcting.",
stat_db[0].hour_counter, test_hour_counter);
for (i = 0; i < no_of_hosts; i++)
{
stat_db[i].hour_counter = test_hour_counter;
stat_db[i].day[stat_db[i].hour_counter].nfs = 0;
stat_db[i].day[stat_db[i].hour_counter].nbs = 0.0;
stat_db[i].day[stat_db[i].hour_counter].ne = 0;
stat_db[i].day[stat_db[i].hour_counter].nc = 0;
}
for (i = 0; i < no_of_dirs; i++)
{
istat_db[i].hour_counter = test_hour_counter;
istat_db[i].day[istat_db[i].hour_counter].nfr = 0;
istat_db[i].day[istat_db[i].hour_counter].nbr = 0.0;
}
}
}
/*
* If the FSA or FRA canges we have to reread everything. This
* is easier then trying to find out where the change took
* place and change only that part. This is not very effective.
* But since changes in the FSA or FRA are very seldom and the
* size of the status is relative small, it seems to be
* the best solution at this point.
*/
if (check_fsa(NO, AFD_STAT) == YES)
{
read_afd_stat_db(no_of_hosts);
}
if (check_fra(NO) == YES)
{
read_afd_istat_db(no_of_dirs);
}
/*
* Now lets update the statistics. There are two methods that
* can be used to update the data. The first one is to have
* a pointer telling which is the newest data. In the second
* method we always move everything in the array one position
* backwards. The advantage of the first method is that we
* don't have to move around any data. However it is more
* difficult to evaluate the data when we want to display
* the information graphicaly. This can be done better with the
* second method.
* Lets try the first method first and see how it works.
*/
for (i = 0; i < no_of_hosts; i++)
{
/***********************************/
/* Handle structure entry for day. */
/***********************************/
/* Store number of files send. */
ui_value = fsa[i].file_counter_done;
if (ui_value >= stat_db[i].prev_nfs)
{
stat_db[i].hour[stat_db[i].sec_counter].nfs = ui_value - stat_db[i].prev_nfs;
}
else
{
/* Check if an overflow has occured */
if ((UINT_MAX - stat_db[i].prev_nfs) <= MAX_FILES_PER_SCAN)
{
stat_db[i].hour[stat_db[i].sec_counter].nfs = ui_value + UINT_MAX - stat_db[i].prev_nfs;
}
else /* To large. Lets assume it was a reset of the AFD. */
{
stat_db[i].hour[stat_db[i].sec_counter].nfs = ui_value;
}
}
stat_db[i].day[stat_db[i].hour_counter].nfs += stat_db[i].hour[stat_db[i].sec_counter].nfs;
stat_db[i].prev_nfs = ui_value;
/* Store number of bytes send. */
stat_db[i].hour[stat_db[i].sec_counter].nbs = 0.0;
for (j = 0; j < MAX_NO_PARALLEL_JOBS; j++)
{
d_value[j] = (double)fsa[i].job_status[j].bytes_send;
if (d_value[j] >= stat_db[i].prev_nbs[j])
{
stat_db[i].hour[stat_db[i].sec_counter].nbs += d_value[j] - stat_db[i].prev_nbs[j];
}
else
{
stat_db[i].hour[stat_db[i].sec_counter].nbs += d_value[j];
}
stat_db[i].prev_nbs[j] = d_value[j];
}
if (stat_db[i].hour[stat_db[i].sec_counter].nbs < 0.0)
{
stat_db[i].hour[stat_db[i].sec_counter].nbs = 0.0;
system_log(DEBUG_SIGN, __FILE__, __LINE__,
"Hmm.... Byte counter less then zero?!? [%d]", i);
}
stat_db[i].day[stat_db[i].hour_counter].nbs += stat_db[i].hour[stat_db[i].sec_counter].nbs;
/* Store number of errors. */
ui_value = fsa[i].total_errors;
if (ui_value >= stat_db[i].prev_ne)
{
stat_db[i].hour[stat_db[i].sec_counter].ne = ui_value - stat_db[i].prev_ne;
}
else
{
stat_db[i].hour[stat_db[i].sec_counter].ne = ui_value;
}
stat_db[i].day[stat_db[i].hour_counter].ne += stat_db[i].hour[stat_db[i].sec_counter].ne;
stat_db[i].prev_ne = ui_value;
/* Store number of connections. */
ui_value = fsa[i].connections;
if (ui_value >= stat_db[i].prev_nc)
{
stat_db[i].hour[stat_db[i].sec_counter].nc = ui_value - stat_db[i].prev_nc;
}
else
{
stat_db[i].hour[stat_db[i].sec_counter].nc = ui_value;
}
stat_db[i].day[stat_db[i].hour_counter].nc += stat_db[i].hour[stat_db[i].sec_counter].nc;
stat_db[i].prev_nc = ui_value;
stat_db[i].sec_counter++;
} /* for (i = 0; i < no_of_hosts; i++) */
/* Now do the same thing for the input. */
for (i = 0; i < no_of_dirs; i++)
{
/***********************************/
/* Handle structure entry for day. */
/***********************************/
/* Store number of files received. */
ui_value = fra[i].files_received;
if (ui_value >= istat_db[i].prev_nfr)
{
istat_db[i].hour[istat_db[i].sec_counter].nfr = ui_value - istat_db[i].prev_nfr;
}
else
{
/* Check if an overflow has occured */
if ((UINT_MAX - istat_db[i].prev_nfr) <= MAX_FILES_PER_SCAN)
{
istat_db[i].hour[istat_db[i].sec_counter].nfr = ui_value + UINT_MAX - istat_db[i].prev_nfr;
}
else /* To large. Lets assume it was a reset of the AFD. */
{
istat_db[i].hour[istat_db[i].sec_counter].nfr = ui_value;
}
}
istat_db[i].day[istat_db[i].hour_counter].nfr += istat_db[i].hour[istat_db[i].sec_counter].nfr;
istat_db[i].prev_nfr = ui_value;
/* Store number of bytes received. */
d_value[0] = (double)fra[i].bytes_received;
if (d_value[0] >= istat_db[i].prev_nbr)
{
istat_db[i].hour[istat_db[i].sec_counter].nbr = d_value[0] - istat_db[i].prev_nbr;
}
else
{
istat_db[i].hour[istat_db[i].sec_counter].nbr = d_value[0];
}
if (istat_db[i].hour[istat_db[i].sec_counter].nbr < 0.0)
{
istat_db[i].hour[istat_db[i].sec_counter].nbr = 0.0;
system_log(DEBUG_SIGN, __FILE__, __LINE__,
"Hmm.... Byte counter less then zero?!? [%d: %f %f]",
i, d_value[0], istat_db[i].prev_nbr);
}
istat_db[i].day[istat_db[i].hour_counter].nbr += istat_db[i].hour[istat_db[i].sec_counter].nbr;
istat_db[i].prev_nbr = d_value[0];
istat_db[i].sec_counter++;
} /* for (i = 0; i < no_of_dirs; i++) */
/* Did we reach another hour? */
if (stat_db[0].sec_counter >= SECS_PER_HOUR)
{
for (i = 0; i < no_of_hosts; i++)
{
/* Reset the counter for the day structure */
stat_db[i].sec_counter = 0;
stat_db[i].hour_counter++;
if (stat_db[i].hour_counter >= HOURS_PER_DAY)
{
stat_db[i].hour_counter = 0;
stat_db[i].year[stat_db[i].day_counter].nfs = 0;
stat_db[i].year[stat_db[i].day_counter].nbs = 0.0;
stat_db[i].year[stat_db[i].day_counter].ne = 0;
stat_db[i].year[stat_db[i].day_counter].nc = 0;
for (j = 0; j < HOURS_PER_DAY; j++)
{
stat_db[i].year[stat_db[i].day_counter].nfs += stat_db[i].day[j].nfs;
stat_db[i].year[stat_db[i].day_counter].nbs += stat_db[i].day[j].nbs;
stat_db[i].year[stat_db[i].day_counter].ne += stat_db[i].day[j].ne;
stat_db[i].year[stat_db[i].day_counter].nc += stat_db[i].day[j].nc;
}
stat_db[i].day_counter++;
}
stat_db[i].day[stat_db[i].hour_counter].nfs = 0;
stat_db[i].day[stat_db[i].hour_counter].nbs = 0.0;
stat_db[i].day[stat_db[i].hour_counter].ne = 0;
stat_db[i].day[stat_db[i].hour_counter].nc = 0;
}
for (i = 0; i < no_of_dirs; i++)
{
/* Reset the counter for the day structure */
istat_db[i].sec_counter = 0;
istat_db[i].hour_counter++;
if (istat_db[i].hour_counter >= HOURS_PER_DAY)
{
istat_db[i].hour_counter = 0;
istat_db[i].year[istat_db[i].day_counter].nfr = 0;
istat_db[i].year[istat_db[i].day_counter].nbr = 0.0;
for (j = 0; j < HOURS_PER_DAY; j++)
{
istat_db[i].year[istat_db[i].day_counter].nfr += istat_db[i].day[j].nfr;
istat_db[i].year[istat_db[i].day_counter].nbr += istat_db[i].day[j].nbr;
}
istat_db[i].day_counter++;
}
istat_db[i].day[istat_db[i].hour_counter].nfr = 0;
istat_db[i].day[istat_db[i].hour_counter].nbr = 0.0;
}
} /* if (stat_db[i].sec_counter >= SECS_PER_HOUR) */
/* Did we reach another year? */
new_year = p_ts->tm_year + 1900;
if (current_year != new_year)
{
if (other_file == NO)
{
save_old_input_year(new_year);
save_old_output_year(new_year);
}
current_year = new_year;
/*
* Reset all values in current memory mapped file. Watch out
* for leap seconds and NTP!
*/
if ((test_hour_counter == 23) && (p_ts->tm_min == 59) &&
(p_ts->tm_yday >= 363))
{
test_sec_counter = 0;
test_hour_counter = 0;
j = 0;
}
else
{
test_sec_counter = ((p_ts->tm_min * 60) + p_ts->tm_sec) /
STAT_RESCAN_TIME;
j = p_ts->tm_yday;
}
for (i = 0; i < no_of_hosts; i++)
{
stat_db[i].sec_counter = test_sec_counter;
stat_db[i].hour_counter = test_hour_counter;
stat_db[i].day_counter = j;
(void)memset(&stat_db[i].year, 0, (DAYS_PER_YEAR * sizeof(struct statistics)));
(void)memset(&stat_db[i].day, 0, (HOURS_PER_DAY * sizeof(struct statistics)));
(void)memset(&stat_db[i].hour, 0, (SECS_PER_HOUR * sizeof(struct statistics)));
}
for (i = 0; i < no_of_dirs; i++)
{
istat_db[i].sec_counter = test_sec_counter;
istat_db[i].hour_counter = test_hour_counter;
istat_db[i].day_counter = j;
(void)memset(&istat_db[i].year, 0, (DAYS_PER_YEAR * sizeof(struct istatistics)));
(void)memset(&istat_db[i].day, 0, (HOURS_PER_DAY * sizeof(struct istatistics)));
(void)memset(&istat_db[i].hour, 0, (SECS_PER_HOUR * sizeof(struct istatistics)));
}
}
if (stat_db[0].day_counter >= DAYS_PER_YEAR)
{
system_log(DEBUG_SIGN, __FILE__, __LINE__,
"Hmmm..., day counter wrong [%d -> 0]. Correcting.",
stat_db[0].day_counter);
for (i = 0; i < no_of_hosts; i++)
{
stat_db[i].day_counter = p_ts->tm_yday;
}
for (i = 0; i < no_of_dirs; i++)
{
istat_db[i].day_counter = p_ts->tm_yday;
}
}
}
/* An error has occured */
else if (status < 0)
{
system_log(FATAL_SIGN, __FILE__, __LINE__,
"select() error : %s", strerror(errno));
exit(INCORRECT);
}
else
{
system_log(FATAL_SIGN, __FILE__, __LINE__, "Unknown condition.");
exit(INCORRECT);
}
} /* for (;;) */
exit(SUCCESS);
}
