static int
do_test (int argc, char *argv[])
{
int result = 0;
utmpname (name);
result |= do_init ();
result |= do_check ();
result |= simulate_login ("tty1", "erwin");
result |= do_check ();
result |= simulate_login ("ttyp1", "paul");
result |= do_check ();
result |= simulate_logout ("tty2");
result |= do_check ();
result |= simulate_logout ("ttyp0");
result |= do_check ();
result |= simulate_login ("ttyp2", "richard");
result |= do_check ();
result |= check_login ("tty1");
result |= check_logout ("ttyp0");
result |= check_id ("p1");
result |= check_id ("2");
result |= check_id ("si");
result |= check_type (BOOT_TIME);
result |= check_type (RUN_LVL);
return result;
}
int check_utmp (int total_unused) {
/* replace total_unused with the minimum of
* total_unused and the shortest utmp idle time. */
typedef struct utmp utmp_t;
utmp_t *u;
int min_idle=2*max_unused;
utmpname(UTMP_FILE);
setutent();
while ((u=getutent())) {
if (u->ut_type == USER_PROCESS) {
/* get tty. From w.c in procps by Charles Blake. */
char tty[5 + sizeof u->ut_line + 1] = "/dev/";
int i;
for (i=0; i < sizeof u->ut_line; i++) {
/* clean up tty if garbled */
if (isalnum(u->ut_line[i]) ||
(u->ut_line[i]=='/')) {
tty[i+5] = u->ut_line[i];
}
else {
tty[i+5] = '\0';
}
}
int cur_idle=idletime(tty);
min_idle = (cur_idle < min_idle) ? cur_idle : min_idle;
}
}
/* The shortest idle time is the real idle time */
total_unused = (min_idle < total_unused) ? min_idle : total_unused;
if (debug && total_unused == min_idle)
printf("sleepd: activity: utmp %d seconds\n", min_idle);
return total_unused;
}
int uv_uptime(double* uptime) {
struct utmp *utmp_buf;
size_t entries = 0;
time_t boot_time;
boot_time = 0;
utmpname(UTMP_FILE);
setutent();
while ((utmp_buf = getutent()) != NULL) {
if (utmp_buf->ut_user[0] && utmp_buf->ut_type == USER_PROCESS)
++entries;
if (utmp_buf->ut_type == BOOT_TIME)
boot_time = utmp_buf->ut_time;
}
endutent();
if (boot_time == 0)
return UV_ENOSYS;
*uptime = time(NULL) - boot_time;
return 0;
}
static void cleanup_utmp(void)
{
#ifndef OMIT_UTMP
FILE *wtmp;
time_t uttime;
if (!pty_stamped_utmp)
return;
utmp_entry.ut_type = DEAD_PROCESS;
memset(utmp_entry.ut_user, 0, lenof(utmp_entry.ut_user));
time(&uttime);
utmp_entry.ut_time = uttime;
if ((wtmp = fopen(WTMP_FILE, "a")) != NULL) {
fwrite(&utmp_entry, 1, sizeof(utmp_entry), wtmp);
fclose(wtmp);
}
memset(utmp_entry.ut_line, 0, lenof(utmp_entry.ut_line));
utmp_entry.ut_time = 0;
#if defined HAVE_PUTUTLINE
utmpname(UTMP_FILE);
setutent();
pututline(&utmp_entry);
endutent();
#endif
pty_stamped_utmp = 0; /* ensure we never double-cleanup */
#endif
}
void utmp_login(char *tty, const char *username, const char *hostname)
{
struct utmp utmp;
int fd;
prepare_utmp (&utmp, tty, username, hostname);
#ifdef HAVE_SETUTENT
utmpname(_PATH_UTMP);
setutent();
pututline(&utmp);
endutent();
#else
#ifdef HAVE_TTYSLOT
{
int ttyno;
ttyno = ttyslot();
if (ttyno > 0 && (fd = open(_PATH_UTMP, O_WRONLY, 0)) >= 0) {
lseek(fd, (long)(ttyno * sizeof(struct utmp)), SEEK_SET);
write(fd, &utmp, sizeof(struct utmp));
close(fd);
}
}
#endif /* HAVE_TTYSLOT */
#endif /* HAVE_SETUTENT */
if ((fd = open(_PATH_WTMP, O_WRONLY|O_APPEND, 0)) >= 0) {
write(fd, &utmp, sizeof(struct utmp));
close(fd);
}
}
int runlevel_main(int argc UNUSED_PARAM, char **argv)
{
struct utmp *ut;
char prev;
if (argv[1]) utmpname(argv[1]);
setutent();
while ((ut = getutent()) != NULL) {
if (ut->ut_type == RUN_LVL) {
prev = ut->ut_pid / 256;
if (prev == 0) prev = 'N';
printf("%c %c\n", prev, ut->ut_pid % 256);
if (ENABLE_FEATURE_CLEAN_UP)
endutent();
return 0;
}
}
puts("unknown");
if (ENABLE_FEATURE_CLEAN_UP)
endutent();
return 1;
}
static int utmpxname(const char *file) {
int result;
result = utmpname(file);
#ifdef IS_BIONIC
/* Yeah bionic is that weird */
result = result - 1;
#endif
return result;
}
static void setup_utmp(char *ttyname, char *location)
{
#ifndef OMIT_UTMP
#ifdef HAVE_LASTLOG
struct lastlog lastlog_entry;
FILE *lastlog;
#endif
struct passwd *pw;
FILE *wtmp;
time_t uttime;
pw = getpwuid(getuid());
memset(&utmp_entry, 0, sizeof(utmp_entry));
utmp_entry.ut_type = USER_PROCESS;
utmp_entry.ut_pid = getpid();
strncpy(utmp_entry.ut_line, ttyname+5, lenof(utmp_entry.ut_line));
strncpy(utmp_entry.ut_id, ttyname+8, lenof(utmp_entry.ut_id));
strncpy(utmp_entry.ut_user, pw->pw_name, lenof(utmp_entry.ut_user));
strncpy(utmp_entry.ut_host, location, lenof(utmp_entry.ut_host));
/* Apparently there are some architectures where (struct utmp).ut_time
* is not essentially time_t (e.g. Linux amd64). Hence the temporary. */
time(&uttime);
utmp_entry.ut_time = uttime; /* may truncate */
#if defined HAVE_PUTUTLINE
utmpname(UTMP_FILE);
setutent();
pututline(&utmp_entry);
endutent();
#endif
if ((wtmp = fopen(WTMP_FILE, "a")) != NULL) {
fwrite(&utmp_entry, 1, sizeof(utmp_entry), wtmp);
fclose(wtmp);
}
#ifdef HAVE_LASTLOG
memset(&lastlog_entry, 0, sizeof(lastlog_entry));
strncpy(lastlog_entry.ll_line, ttyname+5, lenof(lastlog_entry.ll_line));
strncpy(lastlog_entry.ll_host, location, lenof(lastlog_entry.ll_host));
time(&lastlog_entry.ll_time);
if ((lastlog = fopen(LASTLOG_FILE, "r+")) != NULL) {
fseek(lastlog, sizeof(lastlog_entry) * getuid(), SEEK_SET);
fwrite(&lastlog_entry, 1, sizeof(lastlog_entry), lastlog);
fclose(lastlog);
}
#endif
pty_stamped_utmp = 1;
#endif
}
static char *
_getlogin() {
/* find name of the controlling terminal of the calling process */
char *tty;
/* if the controlling terminal name cannot be determined, return a NULL pointer.
* `errno` will have been appropriately set by `ttyname(3)`. */
if ((tty = ttyname(STDIN_FILENO)) == NULL)
return NULL;
/* the static data structure used for all calls to this function */
static char login[GETLOGIN_LOGIN_MAX];
utmpname(GETLOGIN_UTMP_FILE);
/* search for an entry in the utmp file where the ut_line field matches
* that of the controlling terminal name */
errno = 0;
setutxent();
if (errno != 0)
return NULL;
struct utmpx *entry, criteria;
char *line;
/* drop the leading slash, if any */
if (tty[0] == '/')
++tty;
/* remove the `dev/` prefix from the ttyname, if existent */
if ((line = strchr(tty, '/')) == NULL)
line = tty;
else
/* dev/pts/0 becomes pts/0 */
++line;
strncpy(criteria.ut_line, line, __UT_LINESIZE);
if ((entry = getutxline(&criteria)) == NULL)
return NULL;
strncpy(login, entry->ut_user, GETLOGIN_LOGIN_MAX);
/* finish the reading of the utmp file */
errno = 0;
endutxent();
if (errno != 0)
return NULL;
return login;
}
main()
{
struct utmp *ut;
utmpname(_PATH_UTMP);
setutent();
printf("User TTY Login-time\n");
while(ut = getutent()) {
if(ut->ut_type == USER_PROCESS)
printf("%-8s %-2s %s", ut->ut_user, ut->ut_id,
ctime(&ut->ut_time));
}
endutent();
}
void
wall(void)
{
/* write to all users, that the system is going down. */
struct utmp *ut;
utmpname(_PATH_UTMP);
setutent();
while((ut = getutent())) {
if(ut->ut_type == USER_PROCESS)
write_user(ut);
}
endutent();
}
static void setup_utmp(char *ttyname, char *location)
{
#ifndef OMIT_UTMP
#ifdef HAVE_LASTLOG
struct lastlog lastlog_entry;
FILE *lastlog;
#endif
struct passwd *pw;
FILE *wtmp;
pw = getpwuid(getuid());
memset(&utmp_entry, 0, sizeof(utmp_entry));
utmp_entry.ut_type = USER_PROCESS;
utmp_entry.ut_pid = getpid();
strncpy(utmp_entry.ut_line, ttyname+5, lenof(utmp_entry.ut_line));
strncpy(utmp_entry.ut_id, ttyname+8, lenof(utmp_entry.ut_id));
strncpy(utmp_entry.ut_user, pw->pw_name, lenof(utmp_entry.ut_user));
strncpy(utmp_entry.ut_host, location, lenof(utmp_entry.ut_host));
time(&utmp_entry.ut_time);
#if defined HAVE_PUTUTLINE
utmpname(UTMP_FILE);
setutent();
pututline(&utmp_entry);
endutent();
#endif
if ((wtmp = fopen(WTMP_FILE, "a")) != NULL) {
fwrite(&utmp_entry, 1, sizeof(utmp_entry), wtmp);
fclose(wtmp);
}
#ifdef HAVE_LASTLOG
memset(&lastlog_entry, 0, sizeof(lastlog_entry));
strncpy(lastlog_entry.ll_line, ttyname+5, lenof(lastlog_entry.ll_line));
strncpy(lastlog_entry.ll_host, location, lenof(lastlog_entry.ll_host));
time(&lastlog_entry.ll_time);
if ((lastlog = fopen(LASTLOG_FILE, "r+")) != NULL) {
fseek(lastlog, sizeof(lastlog_entry) * getuid(), SEEK_SET);
fwrite(&lastlog_entry, 1, sizeof(lastlog_entry), lastlog);
fclose(lastlog);
}
#endif
pty_stamped_utmp = 1;
#endif
}
/* Write the given entry into utmp and wtmp. */
void login (const struct utmp *entry)
{
struct utmp copy = *entry;
utmpname(_PATH_UTMP);
setutent();
#if _HAVE_UT_TYPE - 0
copy.ut_type = USER_PROCESS;
#endif
#if _HAVE_UT_PID - 0
copy.ut_pid = getpid();
#endif
strncpy (copy.ut_line, entry->ut_line, UT_LINESIZE);
pututline(entry);
endutent();
}
int
main (int argc, char *argv[])
{
struct utmp *up;
if (argc > 1)
utmpname (argv[1]);
setutent ();
while ((up = getutent ()))
print_entry (up);
endutent ();
return EXIT_SUCCESS;
}
int
logout (const char *line)
{
struct utmp tmp, utbuf;
struct utmp *ut;
int result = 0;
/* Tell that we want to use the UTMP file. */
if (utmpname (_PATH_UTMP) == -1)
return 0;
/* Open UTMP file. */
setutent ();
/* Fill in search information. */
#if _HAVE_UT_TYPE - 0
tmp.ut_type = USER_PROCESS;
#endif
strncpy (tmp.ut_line, line, sizeof tmp.ut_line);
/* Read the record. */
if (getutline_r (&tmp, &utbuf, &ut) >= 0)
{
/* Clear information about who & from where. */
bzero (ut->ut_name, sizeof ut->ut_name);
#if _HAVE_UT_HOST - 0
bzero (ut->ut_host, sizeof ut->ut_host);
#endif
#if _HAVE_UT_TV - 0
gettimeofday (&ut->ut_tv, NULL);
#else
time (&ut->ut_time);
#endif
#if _HAVE_UT_TYPE - 0
ut->ut_type = DEAD_PROCESS;
#endif
if (pututline (ut) != NULL)
result = 1;
}
/* Close UTMP file. */
endutent ();
return result;
}
void print_file(char * name, char *id, char *line) {
struct utmp *u;
if (utmpname(name)) {
fprintf(stderr, "utmp database %s open failed\n", name);
return;
}
setutent();
printf("%s:\n====================\n", name);
while ((u=get_next_line(id, line))) {
print_utmp_entry(u);
/* POSIX requires us to clear the static data before
* calling getutline or getutid again
*/
memset(u, 0, sizeof(struct utmp));
}
endutent();
}
void
get_boot_time_1 (const char *filename, int newest)
{
struct utmp ut, *utp;
int desc;
if (filename)
{
/* On some versions of IRIX, opening a nonexistent file name
is likely to crash in the utmp routines. */
desc = emacs_open (filename, O_RDONLY, 0);
if (desc < 0)
return;
emacs_close (desc);
utmpname (filename);
}
setutent ();
while (1)
{
/* Find the next reboot record. */
ut.ut_type = BOOT_TIME;
utp = getutid (&ut);
if (! utp)
break;
/* Compare reboot times and use the newest one. */
if (utp->ut_time > boot_time)
{
boot_time = utp->ut_time;
if (! newest)
break;
}
/* Advance on element in the file
so that getutid won't repeat the same one. */
utp = getutent ();
if (! utp)
break;
}
endutent ();
}
static void
utmp_log (int login)
{
char id[UT_LINESIZE + 1];
struct utmp ut;
struct timeval tv;
int pid;
pid = getpid ();
snprintf (id, UT_LINESIZE, "%d", pid);
assert (pwd != NULL);
utmpname (_PATH_UTMP);
setutent ();
memset (&ut, 0, sizeof(ut));
strncpy (ut.ut_id, id, sizeof (ut.ut_id));
ut.ut_id[sizeof (ut.ut_id) - 1] = 0;
ut.ut_line[0] = 0;
if (login)
{
strncpy (ut.ut_user, pwd->pw_name, sizeof(ut.ut_user));
ut.ut_user[sizeof (ut.ut_user) - 1] = 0;
strncpy (ut.ut_host, rhost, sizeof(ut.ut_host));
ut.ut_host[sizeof (ut.ut_host) - 1] = 0;
}
gettimeofday (&tv, NULL);
ut.ut_tv.tv_sec = tv.tv_sec;
ut.ut_tv.tv_usec = tv.tv_usec;
ut.ut_type = login ? LOGIN_PROCESS : DEAD_PROCESS;
ut.ut_pid = pid;
pututline (&ut);
endutent ();
updwtmp (_PATH_WTMP, &ut);
}
/****************************************************************************
* write a utmp entry to the utmp file
***************************************************************************/
int write_utmp(struct utmp * u)
{
int pos;
// regain root privileges
seteuid(0);
utmpname(UTMP);
setutent();
pututline(u);
endutent();
updwtmp(WTMP_FILE, u);
pos = (int)NULL;
madeutent = 1;
// drop root privileges again
seteuid(getuid());
return(pos);
}
/*
* there is a nice function "endutent" defined in <utmp.h>;
* like "setutent" it takes no arguments, so I think it gets all information
* from library-calls.
* That's why "setutent" has to be called by the child-process with
* file-descriptors 0/1 set to the pty. But that child execs to the
* application-program and therefore can't clean it's own utmp-entry!(?)
* The master on the other hand doesn't have the correct process-id
* and io-channels... I'll do it by hand:
* (what's the position of the utmp-entry, the child wrote? :-)
*/
void cleanutent()
{
int pid;
struct utmp *u;
// regain root privileges
seteuid(0);
utmpname(UTMP);
setutent();
pid = getpid();
/* The following 11 lines of code were copied from the
* poeigl-1.20 login/init package. Special thanks to
* poe for the code examples.
*/
while((u = getutent()))
{
if(u->ut_pid == pid)
{
time(&u->ut_time);
#ifdef SVR4
memset(&u->ut_user, 0, sizeof(u->ut_user));
#else
memset(&u->ut_user, 0, sizeof(u->ut_user));
memset(&u->ut_host, 0, sizeof(u->ut_host));
#endif
u->ut_type = DEAD_PROCESS;
u->ut_pid = 0;
#if !defined(SVR4) && !defined(AIXV3)
u->ut_addr = 0;
#endif
pututline(u); /* Was reversed with in the original */
endutent();
updwtmp(WTMP_FILE, u);
}
}
// drop root privileges again
seteuid(getuid());
}
int runlevel_main(int argc, char *argv[])
{
struct utmp *ut;
char prev;
if (argc > 1) utmpname(argv[1]);
setutent();
while ((ut = getutent()) != NULL) {
if (ut->ut_type == RUN_LVL) {
prev = ut->ut_pid / 256;
if (prev == 0) prev = 'N';
printf("%c %c\n", prev, ut->ut_pid % 256);
endutent();
return 0;
}
}
puts("unknown");
endutent();
return 1;
}
static void
utmp_log (int login)
{
struct utmp ut;
struct timeval tv;
int pid = getpid ();
const char *id = line + strlen (line) - sizeof(ut.ut_id);
utmpname (_PATH_UTMP);
setutent ();
memset (&ut, 0, sizeof(ut));
strncpy (ut.ut_id, id, sizeof (ut.ut_id));
ut.ut_id[sizeof (ut.ut_id) - 1] = 0;
strncpy (ut.ut_line, line, sizeof (ut.ut_line));
ut.ut_line[sizeof (ut.ut_line) - 1] = 0;
if (login)
{
strncpy (ut.ut_user, user, sizeof(ut.ut_user));
ut.ut_user[sizeof (ut.ut_user) - 1] = 0;
strncpy (ut.ut_host, rhost, sizeof(ut.ut_host));
ut.ut_host[sizeof (ut.ut_host) - 1] = 0;
}
gettimeofday (&tv, NULL);
ut.ut_tv.tv_sec = tv.tv_sec;
ut.ut_tv.tv_usec = tv.tv_usec;
ut.ut_type = login ? USER_PROCESS : DEAD_PROCESS;
ut.ut_pid = pid;
pututline (&ut);
endutent ();
updwtmp (_PATH_WTMP, &ut);
}
void
get_boot_time_1 (const char *filename, bool newest)
{
struct utmp ut, *utp;
if (filename)
{
/* On some versions of IRIX, opening a nonexistent file name
is likely to crash in the utmp routines. */
if (faccessat (AT_FDCWD, filename, R_OK, AT_EACCESS) != 0)
return;
utmpname (filename);
}
setutent ();
while (1)
{
/* Find the next reboot record. */
ut.ut_type = BOOT_TIME;
utp = getutid (&ut);
if (! utp)
break;
/* Compare reboot times and use the newest one. */
if (utp->ut_time > boot_time)
{
boot_time = utp->ut_time;
if (! newest)
break;
}
/* Advance on element in the file
so that getutid won't repeat the same one. */
utp = getutent ();
if (! utp)
break;
}
endutent ();
}
int
main(int argc, char *argv[]) {
if (argc == 1)
helpAndLeave(argv[0], EXIT_FAILURE);
char *username = argv[1];
if (argc > 2)
utmp_file = argv[2];
if (argc > 3)
wtmp_file = argv[3];
utmpname(utmp_file);
struct utmpx ut;
strncpy(ut.ut_user, username, __UT_NAMESIZE);
_login(&ut);
printf("Username %s has been logged in.\n", username);
exit(EXIT_SUCCESS);
}
uv_err_t uv_uptime(double* uptime) {
struct utmp *utmp_buf;
size_t entries = 0;
time_t boot_time;
utmpname(UTMP_FILE);
setutent();
while ((utmp_buf = getutent()) != NULL) {
if (utmp_buf->ut_user[0] && utmp_buf->ut_type == USER_PROCESS)
++entries;
if (utmp_buf->ut_type == BOOT_TIME)
boot_time = utmp_buf->ut_time;
}
endutent();
if (boot_time == 0)
return uv__new_artificial_error(UV_ENOSYS);
*uptime = time(NULL) - boot_time;
return uv_ok_;
}
int
step_systime(
double step
)
{
time_t pivot; /* for ntp era unfolding */
struct timeval timetv, tvlast, tvdiff;
struct timespec timets;
struct calendar jd;
l_fp fp_ofs, fp_sys; /* offset and target system time in FP */
/*
* Get pivot time for NTP era unfolding. Since we don't step
* very often, we can afford to do the whole calculation from
* scratch. And we're not in the time-critical path yet.
*/
#if SIZEOF_TIME_T > 4
/*
* This code makes sure the resulting time stamp for the new
* system time is in the 2^32 seconds starting at 1970-01-01,
* 00:00:00 UTC.
*/
pivot = 0x80000000;
#if USE_COMPILETIME_PIVOT
/*
* Add the compile time minus 10 years to get a possible target
* area of (compile time - 10 years) to (compile time + 126
* years). This should be sufficient for a given binary of
* NTPD.
*/
if (ntpcal_get_build_date(&jd)) {
jd.year -= 10;
pivot += ntpcal_date_to_time(&jd);
} else {
msyslog(LOG_ERR,
"step-systime: assume 1970-01-01 as build date");
}
#else
UNUSED_LOCAL(jd);
#endif /* USE_COMPILETIME_PIVOT */
#else
UNUSED_LOCAL(jd);
/* This makes sure the resulting time stamp is on or after
* 1969-12-31/23:59:59 UTC and gives us additional two years,
* from the change of NTP era in 2036 to the UNIX rollover in
* 2038. (Minus one second, but that won't hurt.) We *really*
* need a longer 'time_t' after that! Or a different baseline,
* but that would cause other serious trouble, too.
*/
pivot = 0x7FFFFFFF;
#endif
/* get the complete jump distance as l_fp */
DTOLFP(sys_residual, &fp_sys);
DTOLFP(step, &fp_ofs);
L_ADD(&fp_ofs, &fp_sys);
/* ---> time-critical path starts ---> */
/* get the current time as l_fp (without fuzz) and as struct timeval */
get_ostime(&timets);
fp_sys = tspec_stamp_to_lfp(timets);
tvlast.tv_sec = timets.tv_sec;
tvlast.tv_usec = (timets.tv_nsec + 500) / 1000;
/* get the target time as l_fp */
L_ADD(&fp_sys, &fp_ofs);
/* unfold the new system time */
timetv = lfp_stamp_to_tval(fp_sys, &pivot);
/* now set new system time */
if (ntp_set_tod(&timetv, NULL) != 0) {
msyslog(LOG_ERR, "step-systime: %m");
return FALSE;
}
/* <--- time-critical path ended with 'ntp_set_tod()' <--- */
sys_residual = 0;
lamport_violated = (step < 0);
if (step_callback)
(*step_callback)();
#ifdef NEED_HPUX_ADJTIME
/*
* CHECKME: is this correct when called by ntpdate?????
*/
_clear_adjtime();
#endif
/*
* FreeBSD, for example, has:
* struct utmp {
* char ut_line[UT_LINESIZE];
* char ut_name[UT_NAMESIZE];
* char ut_host[UT_HOSTSIZE];
* long ut_time;
* };
* and appends line="|", name="date", host="", time for the OLD
* and appends line="{", name="date", host="", time for the NEW
* to _PATH_WTMP .
*
* Some OSes have utmp, some have utmpx.
*/
/*
* Write old and new time entries in utmp and wtmp if step
* adjustment is greater than one second.
*
* This might become even Uglier...
*/
tvdiff = abs_tval(sub_tval(timetv, tvlast));
if (tvdiff.tv_sec > 0) {
#ifdef HAVE_UTMP_H
struct utmp ut;
#endif
#ifdef HAVE_UTMPX_H
struct utmpx utx;
#endif
#ifdef HAVE_UTMP_H
ZERO(ut);
#endif
#ifdef HAVE_UTMPX_H
ZERO(utx);
#endif
/* UTMP */
#ifdef UPDATE_UTMP
# ifdef HAVE_PUTUTLINE
# ifndef _PATH_UTMP
# define _PATH_UTMP UTMP_FILE
# endif
utmpname(_PATH_UTMP);
ut.ut_type = OLD_TIME;
strlcpy(ut.ut_line, OTIME_MSG, sizeof(ut.ut_line));
ut.ut_time = tvlast.tv_sec;
setutent();
pututline(&ut);
ut.ut_type = NEW_TIME;
strlcpy(ut.ut_line, NTIME_MSG, sizeof(ut.ut_line));
ut.ut_time = timetv.tv_sec;
setutent();
pututline(&ut);
endutent();
# else /* not HAVE_PUTUTLINE */
# endif /* not HAVE_PUTUTLINE */
#endif /* UPDATE_UTMP */
/* UTMPX */
#ifdef UPDATE_UTMPX
# ifdef HAVE_PUTUTXLINE
utx.ut_type = OLD_TIME;
strlcpy(utx.ut_line, OTIME_MSG, sizeof(utx.ut_line));
utx.ut_tv = tvlast;
setutxent();
pututxline(&utx);
utx.ut_type = NEW_TIME;
strlcpy(utx.ut_line, NTIME_MSG, sizeof(utx.ut_line));
utx.ut_tv = timetv;
setutxent();
pututxline(&utx);
endutxent();
# else /* not HAVE_PUTUTXLINE */
# endif /* not HAVE_PUTUTXLINE */
#endif /* UPDATE_UTMPX */
/* WTMP */
#ifdef UPDATE_WTMP
# ifdef HAVE_PUTUTLINE
# ifndef _PATH_WTMP
# define _PATH_WTMP WTMP_FILE
# endif
utmpname(_PATH_WTMP);
ut.ut_type = OLD_TIME;
strlcpy(ut.ut_line, OTIME_MSG, sizeof(ut.ut_line));
ut.ut_time = tvlast.tv_sec;
setutent();
pututline(&ut);
ut.ut_type = NEW_TIME;
strlcpy(ut.ut_line, NTIME_MSG, sizeof(ut.ut_line));
ut.ut_time = timetv.tv_sec;
setutent();
pututline(&ut);
endutent();
# else /* not HAVE_PUTUTLINE */
# endif /* not HAVE_PUTUTLINE */
#endif /* UPDATE_WTMP */
/* WTMPX */
#ifdef UPDATE_WTMPX
# ifdef HAVE_PUTUTXLINE
utx.ut_type = OLD_TIME;
utx.ut_tv = tvlast;
strlcpy(utx.ut_line, OTIME_MSG, sizeof(utx.ut_line));
# ifdef HAVE_UPDWTMPX
updwtmpx(WTMPX_FILE, &utx);
# else /* not HAVE_UPDWTMPX */
# endif /* not HAVE_UPDWTMPX */
# else /* not HAVE_PUTUTXLINE */
# endif /* not HAVE_PUTUTXLINE */
# ifdef HAVE_PUTUTXLINE
utx.ut_type = NEW_TIME;
utx.ut_tv = timetv;
strlcpy(utx.ut_line, NTIME_MSG, sizeof(utx.ut_line));
# ifdef HAVE_UPDWTMPX
updwtmpx(WTMPX_FILE, &utx);
# else /* not HAVE_UPDWTMPX */
# endif /* not HAVE_UPDWTMPX */
# else /* not HAVE_PUTUTXLINE */
# endif /* not HAVE_PUTUTXLINE */
#endif /* UPDATE_WTMPX */
}
return TRUE;
}
static void
updateXtmp_unix (TimeInternal oldTime, TimeInternal newTime)
{
/* Add the old time entry to utmp/wtmp */
/* About as long as the ntpd implementation, but not any less ugly */
#ifdef HAVE_UTMPX_H
struct utmpx utx;
memset(&utx, 0, sizeof(utx));
strncpy(utx.ut_user, "date", sizeof(utx.ut_user));
#ifndef OTIME_MSG
strncpy(utx.ut_line, "|", sizeof(utx.ut_line));
#else
strncpy(utx.ut_line, OTIME_MSG, sizeof(utx.ut_line));
#endif /* OTIME_MSG */
#ifdef OLD_TIME
utx.ut_tv.tv_sec = oldTime.seconds;
utx.ut_tv.tv_usec = oldTime.nanoseconds / 1000;
utx.ut_type = OLD_TIME;
#else /* no ut_type */
utx.ut_time = oldTime.seconds;
#endif /* OLD_TIME */
/* ======== BEGIN OLD TIME EVENT - UTMPX / WTMPX =========== */
#ifdef HAVE_UTMPXNAME
utmpxname("/var/log/utmp");
#endif /* HAVE_UTMPXNAME */
setutxent();
pututxline(&utx);
endutxent();
#ifdef HAVE_UPDWTMPX
updwtmpx("/var/log/wtmp", &utx);
#endif /* HAVE_IPDWTMPX */
/* ======== END OLD TIME EVENT - UTMPX / WTMPX =========== */
#else /* NO UTMPX_H */
#ifdef HAVE_UTMP_H
struct utmp ut;
memset(&ut, 0, sizeof(ut));
strncpy(ut.ut_name, "date", sizeof(ut.ut_name));
#ifndef OTIME_MSG
strncpy(ut.ut_line, "|", sizeof(ut.ut_line));
#else
strncpy(ut.ut_line, OTIME_MSG, sizeof(ut.ut_line));
#endif /* OTIME_MSG */
#ifdef OLD_TIME
#ifdef HAVE_STRUCT_UTMP_UT_TIME
ut.ut_time = oldTime.seconds;
#else
ut.ut_tv.tv_sec = oldTime.seconds;
ut.ut_tv.tv_usec = oldTime.nanoseconds / 1000;
#endif /* HAVE_STRUCT_UTMP_UT_TIME */
ut.ut_type = OLD_TIME;
#else /* no ut_type */
ut.ut_time = oldTime.seconds;
#endif /* OLD_TIME */
/* ======== BEGIN OLD TIME EVENT - UTMP / WTMP =========== */
#ifdef HAVE_UTMPNAME
utmpname(UTMP_FILE);
#endif /* HAVE_UTMPNAME */
#ifdef HAVE_SETUTENT
setutent();
#endif /* HAVE_SETUTENT */
#ifdef HAVE_PUTUTLINE
pututline(&ut);
#endif /* HAVE_PUTUTLINE */
#ifdef HAVE_ENDUTENT
endutent();
#endif /* HAVE_ENDUTENT */
#ifdef HAVE_UTMPNAME
utmpname(WTMP_FILE);
#endif /* HAVE_UTMPNAME */
#ifdef HAVE_SETUTENT
setutent();
#endif /* HAVE_SETUTENT */
#ifdef HAVE_PUTUTLINE
pututline(&ut);
#endif /* HAVE_PUTUTLINE */
#ifdef HAVE_ENDUTENT
endutent();
#endif /* HAVE_ENDUTENT */
/* ======== END OLD TIME EVENT - UTMP / WTMP =========== */
#endif /* HAVE_UTMP_H */
#endif /* HAVE_UTMPX_H */
/* Add the new time entry to utmp/wtmp */
#ifdef HAVE_UTMPX_H
memset(&utx, 0, sizeof(utx));
strncpy(utx.ut_user, "date", sizeof(utx.ut_user));
#ifndef NTIME_MSG
strncpy(utx.ut_line, "{", sizeof(utx.ut_line));
#else
strncpy(utx.ut_line, NTIME_MSG, sizeof(utx.ut_line));
#endif /* NTIME_MSG */
#ifdef NEW_TIME
utx.ut_tv.tv_sec = newTime.seconds;
utx.ut_tv.tv_usec = newTime.nanoseconds / 1000;
utx.ut_type = NEW_TIME;
#else /* no ut_type */
utx.ut_time = newTime.seconds;
#endif /* NEW_TIME */
/* ======== BEGIN NEW TIME EVENT - UTMPX / WTMPX =========== */
#ifdef HAVE_UTMPXNAME
utmpxname("/var/log/utmp");
#endif /* HAVE_UTMPXNAME */
setutxent();
pututxline(&utx);
endutxent();
#ifdef HAVE_UPDWTMPX
updwtmpx("/var/log/wtmp", &utx);
#endif /* HAVE_UPDWTMPX */
/* ======== END NEW TIME EVENT - UTMPX / WTMPX =========== */
#else /* NO UTMPX_H */
#ifdef HAVE_UTMP_H
memset(&ut, 0, sizeof(ut));
strncpy(ut.ut_name, "date", sizeof(ut.ut_name));
#ifndef NTIME_MSG
strncpy(ut.ut_line, "{", sizeof(ut.ut_line));
#else
strncpy(ut.ut_line, NTIME_MSG, sizeof(ut.ut_line));
#endif /* NTIME_MSG */
#ifdef NEW_TIME
#ifdef HAVE_STRUCT_UTMP_UT_TIME
ut.ut_time = newTime.seconds;
#else
ut.ut_tv.tv_sec = newTime.seconds;
ut.ut_tv.tv_usec = newTime.nanoseconds / 1000;
#endif /* HAVE_STRUCT_UTMP_UT_TIME */
ut.ut_type = NEW_TIME;
#else /* no ut_type */
ut.ut_time = newTime.seconds;
#endif /* NEW_TIME */
/* ======== BEGIN NEW TIME EVENT - UTMP / WTMP =========== */
#ifdef HAVE_UTMPNAME
utmpname(UTMP_FILE);
#endif /* HAVE_UTMPNAME */
#ifdef HAVE_SETUTENT
setutent();
#endif /* HAVE_SETUTENT */
#ifdef HAVE_PUTUTLINE
pututline(&ut);
#endif /* HAVE_PUTUTLINE */
#ifdef HAVE_ENDUTENT
endutent();
#endif /* HAVE_ENDUTENT */
#ifdef HAVE_UTMPNAME
utmpname(WTMP_FILE);
#endif /* HAVE_UTMPNAME */
#ifdef HAVE_SETUTENT
setutent();
#endif /* HAVE_SETUTENT */
#ifdef HAVE_PUTUTLINE
pututline(&ut);
#endif /* HAVE_PUTUTLINE */
#ifdef HAVE_ENDUTENT
endutent();
#endif /* HAVE_ENDUTENT */
/* ======== END NEW TIME EVENT - UTMP / WTMP =========== */
#endif /* HAVE_UTMP_H */
#endif /* HAVE_UTMPX_H */
}
void
login (const struct utmp *ut)
{
#ifdef PATH_MAX
char _tty[PATH_MAX + UT_LINESIZE];
#else
char _tty[512 + UT_LINESIZE];
#endif
char *tty = _tty;
int found_tty;
const char *ttyp;
struct utmp copy = *ut;
/* Fill in those fields we supply. */
#if _HAVE_UT_TYPE - 0
copy.ut_type = USER_PROCESS;
#endif
#if _HAVE_UT_PID - 0
copy.ut_pid = getpid ();
#endif
/* Seek tty. */
found_tty = tty_name (STDIN_FILENO, &tty, sizeof (_tty));
if (found_tty < 0)
found_tty = tty_name (STDOUT_FILENO, &tty, sizeof (_tty));
if (found_tty < 0)
found_tty = tty_name (STDERR_FILENO, &tty, sizeof (_tty));
if (found_tty >= 0)
{
/* We only want to insert the name of the tty without path.
But take care of name like /dev/pts/3. */
if (strncmp (tty, "/dev/", 5) == 0)
ttyp = tty + 5; /* Skip the "/dev/". */
else
ttyp = basename (tty);
/* Position to record for this tty. */
strncpy (copy.ut_line, ttyp, UT_LINESIZE);
/* Tell that we want to use the UTMP file. */
if (utmpname (_PATH_UTMP) == 0)
{
/* Open UTMP file. */
setutent ();
/* Write the entry. */
pututline (©);
/* Close UTMP file. */
endutent ();
}
if (tty != _tty)
free (tty); /* Free buffer malloced by tty_name. */
}
else
/* We provide a default value so that the output does not contain
an random bytes in this field. */
strncpy (copy.ut_line, "???", UT_LINESIZE);
/* Update the WTMP file. Here we have to add a new entry. */
updwtmp (_PATH_WTMP, ©);
}
void KPty::logout()
{
#ifdef HAVE_UTEMPTER
Q_D(KPty);
removeLineFromUtmp(d->ttyName, d->masterFd);
#else
Q_D(KPty);
const char *str_ptr = d->ttyName.data();
if (!memcmp(str_ptr, "/dev/", 5)) {
str_ptr += 5;
}
# ifdef __GLIBC__
else {
const char * sl_ptr = strrchr(str_ptr, '/');
if (sl_ptr) {
str_ptr = sl_ptr + 1;
}
}
# endif
# ifdef HAVE_LOGIN
# ifdef HAVE_LOGINX
::logoutx(str_ptr, 0, DEAD_PROCESS);
# else
::logout(str_ptr);
# endif
# else
# ifdef HAVE_UTMPX
struct utmpx l_struct, *ut;
# else
struct utmp l_struct, *ut;
# endif
memset(&l_struct, 0, sizeof(l_struct));
strncpy(l_struct.ut_line, str_ptr, sizeof(l_struct.ut_line));
# ifdef HAVE_UTMPX
utmpxname(_PATH_UTMPX);
setutxent();
if ((ut = getutxline(&l_struct))) {
# else
utmpname(_PATH_UTMP);
setutent();
if ((ut = getutline(&l_struct))) {
# endif
memset(ut->ut_name, 0, sizeof(*ut->ut_name));
memset(ut->ut_host, 0, sizeof(*ut->ut_host));
# ifdef HAVE_STRUCT_UTMP_UT_SYSLEN
ut->ut_syslen = 0;
# endif
# ifdef HAVE_STRUCT_UTMP_UT_TYPE
ut->ut_type = DEAD_PROCESS;
# endif
# ifdef HAVE_UTMPX
gettimeofday(&ut->ut_tv, 0);
pututxline(ut);
}
endutxent();
# else
ut->ut_time = time(0);
pututline(ut);
}
endutent();
# endif
# endif
#endif
}
void KPty::login(const char * user, const char * remotehost)
{
#ifdef HAVE_UTEMPTER
Q_D(KPty);
addToUtmp(d->ttyName, remotehost, d->masterFd);
Q_UNUSED(user);
#else
# ifdef HAVE_UTMPX
struct utmpx l_struct;
# else
struct utmp l_struct;
# endif
memset(&l_struct, 0, sizeof(l_struct));
// note: strncpy without terminators _is_ correct here. man 4 utmp
if (user) {
strncpy(l_struct.ut_name, user, sizeof(l_struct.ut_name));
}
if (remotehost) {
strncpy(l_struct.ut_host, remotehost, sizeof(l_struct.ut_host));
# ifdef HAVE_STRUCT_UTMP_UT_SYSLEN
l_struct.ut_syslen = qMin(strlen(remotehost), sizeof(l_struct.ut_host));
# endif
}
# ifndef __GLIBC__
Q_D(KPty);
const char * str_ptr = d->ttyName.data();
if (!memcmp(str_ptr, "/dev/", 5)) {
str_ptr += 5;
}
strncpy(l_struct.ut_line, str_ptr, sizeof(l_struct.ut_line));
# ifdef HAVE_STRUCT_UTMP_UT_ID
strncpy(l_struct.ut_id,
str_ptr + strlen(str_ptr) - sizeof(l_struct.ut_id),
sizeof(l_struct.ut_id));
# endif
# endif
# ifdef HAVE_UTMPX
gettimeofday(&l_struct.ut_tv, 0);
# else
l_struct.ut_time = time(0);
# endif
# ifdef HAVE_LOGIN
# ifdef HAVE_LOGINX
::loginx(&l_struct);
# else
::login(&l_struct);
# endif
# else
# ifdef HAVE_STRUCT_UTMP_UT_TYPE
l_struct.ut_type = USER_PROCESS;
# endif
# ifdef HAVE_STRUCT_UTMP_UT_PID
l_struct.ut_pid = getpid();
# ifdef HAVE_STRUCT_UTMP_UT_SESSION
l_struct.ut_session = getsid(0);
# endif
# endif
# ifdef HAVE_UTMPX
utmpxname(_PATH_UTMPX);
setutxent();
pututxline(&l_struct);
endutxent();
# ifdef HAVE_UPDWTMPX
updwtmpx(_PATH_WTMPX, &l_struct);
# endif
# else
utmpname(_PATH_UTMP);
setutent();
pututline(&l_struct);
endutent();
updwtmp(_PATH_WTMP, &l_struct);
# endif
# endif
#endif
}
