int
ftime (struct timeb *timebuf)
{
int save = errno;
struct tm tp;
__set_errno (0);
if (time (&timebuf->time) == (time_t) -1 && errno != 0)
return -1;
timebuf->millitm = 0;
if (__localtime_r (&timebuf->time, &tp) == NULL)
return -1;
timebuf->timezone = tp.tm_gmtoff / 60;
timebuf->dstflag = tp.tm_isdst;
__set_errno (save);
return 0;
}
void
__vsyslog_chk(int pri, int flag, const char *fmt, va_list ap)
{
struct tm now_tm;
time_t now;
int fd;
FILE *f;
char *buf = 0;
size_t bufsize = 0;
size_t msgoff;
#ifndef NO_SIGPIPE
struct sigaction action, oldaction;
int sigpipe;
#endif
int saved_errno = errno;
char failbuf[3 * sizeof (pid_t) + sizeof "out of memory []"];
#define INTERNALLOG LOG_ERR|LOG_CONS|LOG_PERROR|LOG_PID
/* Check for invalid bits. */
if (pri & ~(LOG_PRIMASK|LOG_FACMASK)) {
syslog(INTERNALLOG,
"syslog: unknown facility/priority: %x", pri);
pri &= LOG_PRIMASK|LOG_FACMASK;
}
/* Check priority against setlogmask values. */
if ((LOG_MASK (LOG_PRI (pri)) & LogMask) == 0)
return;
/* Set default facility if none specified. */
if ((pri & LOG_FACMASK) == 0)
pri |= LogFacility;
/* Build the message in a memory-buffer stream. */
f = __open_memstream (&buf, &bufsize);
if (f == NULL)
{
/* We cannot get a stream. There is not much we can do but
emitting an error messages. */
char numbuf[3 * sizeof (pid_t)];
char *nump;
char *endp = __stpcpy (failbuf, "out of memory [");
pid_t pid = __getpid ();
nump = numbuf + sizeof (numbuf);
/* The PID can never be zero. */
do
*--nump = '0' + pid % 10;
while ((pid /= 10) != 0);
endp = __mempcpy (endp, nump, (numbuf + sizeof (numbuf)) - nump);
*endp++ = ']';
*endp = '\0';
buf = failbuf;
bufsize = endp - failbuf;
msgoff = 0;
}
else
{
__fsetlocking (f, FSETLOCKING_BYCALLER);
fprintf (f, "<%d>", pri);
(void) time (&now);
f->_IO_write_ptr += __strftime_l (f->_IO_write_ptr,
f->_IO_write_end
- f->_IO_write_ptr,
"%h %e %T ",
__localtime_r (&now, &now_tm),
_nl_C_locobj_ptr);
msgoff = ftell (f);
if (LogTag == NULL)
LogTag = __progname;
if (LogTag != NULL)
__fputs_unlocked (LogTag, f);
if (LogStat & LOG_PID)
fprintf (f, "[%d]", (int) __getpid ());
if (LogTag != NULL)
{
putc_unlocked (':', f);
putc_unlocked (' ', f);
}
/* Restore errno for %m format. */
__set_errno (saved_errno);
/* We have the header. Print the user's format into the
buffer. */
if (flag == -1)
vfprintf (f, fmt, ap);
else
__vfprintf_chk (f, flag, fmt, ap);
/* Close the memory stream; this will finalize the data
into a malloc'd buffer in BUF. */
fclose (f);
}
/* Output to stderr if requested. */
if (LogStat & LOG_PERROR) {
struct iovec iov[2];
struct iovec *v = iov;
v->iov_base = buf + msgoff;
v->iov_len = bufsize - msgoff;
/* Append a newline if necessary. */
if (buf[bufsize - 1] != '\n')
{
++v;
v->iov_base = (char *) "\n";
v->iov_len = 1;
}
__libc_cleanup_push (free, buf == failbuf ? NULL : buf);
/* writev is a cancellation point. */
(void)__writev(STDERR_FILENO, iov, v - iov + 1);
__libc_cleanup_pop (0);
}
/* Prepare for multiple users. We have to take care: open and
write are cancellation points. */
struct cleanup_arg clarg;
clarg.buf = buf;
clarg.oldaction = NULL;
__libc_cleanup_push (cancel_handler, &clarg);
__libc_lock_lock (syslog_lock);
#ifndef NO_SIGPIPE
/* Prepare for a broken connection. */
memset (&action, 0, sizeof (action));
action.sa_handler = sigpipe_handler;
sigemptyset (&action.sa_mask);
sigpipe = __sigaction (SIGPIPE, &action, &oldaction);
if (sigpipe == 0)
clarg.oldaction = &oldaction;
#endif
/* Get connected, output the message to the local logger. */
if (!connected)
openlog_internal(LogTag, LogStat | LOG_NDELAY, 0);
/* If we have a SOCK_STREAM connection, also send ASCII NUL as
a record terminator. */
if (LogType == SOCK_STREAM)
++bufsize;
if (!connected || __send(LogFile, buf, bufsize, send_flags) < 0)
{
if (connected)
{
/* Try to reopen the syslog connection. Maybe it went
down. */
closelog_internal ();
openlog_internal(LogTag, LogStat | LOG_NDELAY, 0);
}
if (!connected || __send(LogFile, buf, bufsize, send_flags) < 0)
{
closelog_internal (); /* attempt re-open next time */
/*
* Output the message to the console; don't worry
* about blocking, if console blocks everything will.
* Make sure the error reported is the one from the
* syslogd failure.
*/
if (LogStat & LOG_CONS &&
(fd = __open(_PATH_CONSOLE, O_WRONLY|O_NOCTTY, 0)) >= 0)
{
__dprintf (fd, "%s\r\n", buf + msgoff);
(void)__close(fd);
}
}
}
#ifndef NO_SIGPIPE
if (sigpipe == 0)
__sigaction (SIGPIPE, &oldaction, (struct sigaction *) NULL);
#endif
/* End of critical section. */
__libc_cleanup_pop (0);
__libc_lock_unlock (syslog_lock);
if (buf != failbuf)
free (buf);
}
struct tm *localtime(const time_t *t)
{
static struct tm tm;
return __localtime_r(t, &tm);
}
/* Return a string as returned by asctime which is the representation
of *T in that form. Reentrant version. */
char *
ctime_r (const time_t *t, char *buf)
{
struct tm tm;
return __asctime_r (__localtime_r (t, &tm), buf);
}
int
__getdate_r (const char *string, struct tm *tp)
{
FILE *fp;
char *line;
size_t len;
char *datemsk;
char *result = NULL;
time_t timer;
struct tm tm;
struct stat64 st;
int mday_ok = 0;
datemsk = getenv ("DATEMSK");
if (datemsk == NULL || *datemsk == '\0')
return 1;
if (stat64 (datemsk, &st) < 0)
return 3;
if (!S_ISREG (st.st_mode))
return 4;
if (__access (datemsk, R_OK) < 0)
return 2;
/* Open the template file. */
fp = fopen (datemsk, "rce");
if (fp == NULL)
return 2;
/* No threads reading this stream. */
__fsetlocking (fp, FSETLOCKING_BYCALLER);
line = NULL;
len = 0;
do
{
ssize_t n;
n = __getline (&line, &len, fp);
if (n < 0)
break;
if (line[n - 1] == '\n')
line[n - 1] = '\0';
/* Do the conversion. */
tp->tm_year = tp->tm_mon = tp->tm_mday = tp->tm_wday = INT_MIN;
tp->tm_hour = tp->tm_sec = tp->tm_min = INT_MIN;
tp->tm_isdst = -1;
tp->tm_gmtoff = 0;
tp->tm_zone = NULL;
result = strptime (string, line, tp);
if (result && *result == '\0')
break;
}
while (!feof_unlocked (fp));
/* Free the buffer. */
free (line);
/* Check for errors. */
if (ferror_unlocked (fp))
{
fclose (fp);
return 5;
}
/* Close template file. */
fclose (fp);
if (result == NULL || *result != '\0')
return 7;
/* Get current time. */
time (&timer);
__localtime_r (&timer, &tm);
/* If only the weekday is given, today is assumed if the given day
is equal to the current day and next week if it is less. */
if (tp->tm_wday >= 0 && tp->tm_wday <= 6 && tp->tm_year == INT_MIN
&& tp->tm_mon == INT_MIN && tp->tm_mday == INT_MIN)
{
tp->tm_year = tm.tm_year;
tp->tm_mon = tm.tm_mon;
tp->tm_mday = tm.tm_mday + (tp->tm_wday - tm.tm_wday + 7) % 7;
mday_ok = 1;
}
/* If only the month is given, the current month is assumed if the
given month is equal to the current month and next year if it is
less and no year is given (the first day of month is assumed if
no day is given. */
if (tp->tm_mon >= 0 && tp->tm_mon <= 11 && tp->tm_mday == INT_MIN)
{
if (tp->tm_year == INT_MIN)
tp->tm_year = tm.tm_year + (((tp->tm_mon - tm.tm_mon) < 0) ? 1 : 0);
tp->tm_mday = first_wday (tp->tm_year, tp->tm_mon, tp->tm_wday);
mday_ok = 1;
}
/* If no hour, minute and second are given the current hour, minute
and second are assumed. */
if (tp->tm_hour == INT_MIN && tp->tm_min == INT_MIN && tp->tm_sec == INT_MIN)
{
tp->tm_hour = tm.tm_hour;
tp->tm_min = tm.tm_min;
tp->tm_sec = tm.tm_sec;
}
/* Fill in the gaps. */
if (tp->tm_hour == INT_MIN)
tp->tm_hour = 0;
if (tp->tm_min == INT_MIN)
tp->tm_min = 0;
if (tp->tm_sec == INT_MIN)
tp->tm_sec = 0;
/* If no date is given, today is assumed if the given hour is
greater than the current hour and tomorrow is assumed if
it is less. */
if (tp->tm_hour >= 0 && tp->tm_hour <= 23
&& tp->tm_mon == INT_MIN
&& tp->tm_mday == INT_MIN && tp->tm_wday == INT_MIN)
{
tp->tm_mon = tm.tm_mon;
tp->tm_mday = tm.tm_mday + ((tp->tm_hour - tm.tm_hour) < 0 ? 1 : 0);
mday_ok = 1;
}
/* More fillers. */
if (tp->tm_year == INT_MIN)
tp->tm_year = tm.tm_year;
if (tp->tm_mon == INT_MIN)
tp->tm_mon = tm.tm_mon;
/* Check if the day of month is within range, and if the time can be
represented in a time_t. We make use of the fact that the mktime
call normalizes the struct tm. */
if ((!mday_ok && !check_mday (TM_YEAR_BASE + tp->tm_year, tp->tm_mon,
tp->tm_mday))
|| mktime (tp) == (time_t) -1)
return 8;
return 0;
}
