rxvt-unicode/src/logging.C

/*--------------------------------*-C-*---------------------------------*
 * File:        logging.c
 *----------------------------------------------------------------------*
 * $Id: logging.C,v 1.3 2003/11/25 11:52:42 pcg Exp $
 *
 * All portions of code are copyright by their respective author/s.
 * Copyright (c) 1992      John Bovey <jdb@ukc.ac.uk>
 *                              - original version
 * Copyright (c) 1993      lipka
 * Copyright (c) 1993      Brian Stempien <stempien@cs.wmich.edu>
 * Copyright (c) 1995      Raul Garcia Garcia <rgg@tid.es>
 * Copyright (c) 1995      Piet W. Plomp <piet@idefix.icce.rug.nl>
 * Copyright (c) 1997      Raul Garcia Garcia <rgg@tid.es>
 * Copyright (c) 1998-2001 Geoff Wing <gcw@pobox.com>
 *                              - extensive modifications
 * Copyright (c) 1999      D J Hawkey Jr <hawkeyd@visi.com>
 *                              - lastlog support
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *----------------------------------------------------------------------*/
/*----------------------------------------------------------------------*
 * Public:
 *      extern void cleanutent (void);
 *      extern void makeutent (const char * pty, const char * hostname);
 *
 * Private:
 *      rxvt_update_wtmp ();
 *----------------------------------------------------------------------*/

#include "../config.h"          /* NECESSARY */
#include "rxvt.h"               /* NECESSARY */
#include "logging.h"
#ifdef UTMP_SUPPORT

/*
 * BSD style utmp entry
 *      ut_line, ut_name, ut_host, ut_time
 * SYSV style utmp (and utmpx) entry
 *      ut_user, ut_id, ut_line, ut_pid, ut_type, ut_exit, ut_time
 */

/* ------------------------------------------------------------------------- */

/*
 * make and write utmp and wtmp entries
 */
void
rxvt_term::makeutent (const char *pty, const char *hostname)
{
#ifdef HAVE_STRUCT_UTMP
    struct utmp    *ut = &(this->ut);
#endif
#ifdef HAVE_STRUCT_UTMPX
    struct utmpx   *utx = &(this->utx);
#endif
#ifdef HAVE_UTMP_PID
    int             i;
#endif
    char            ut_id[5];
    struct passwd  *pwent = getpwuid(getuid());

    if (!STRNCMP(pty, "/dev/", 5))
        pty += 5;               /* skip /dev/ prefix */

    if (!STRNCMP(pty, "pty", 3) || !STRNCMP(pty, "tty", 3)) {
        STRNCPY(ut_id, (pty + 3), sizeof(ut_id));
    }
#ifdef HAVE_UTMP_PID
    else if (sscanf(pty, "pts/%d", &i) == 1)
        sprintf(ut_id, "vt%02x", (i & 0xff));   /* sysv naming */
#endif
    else if (STRNCMP(pty, "pty", 3) && STRNCMP(pty, "tty", 3)) {
        rxvt_print_error("can't parse tty name \"%s\"", pty);
        return;
    }

#ifdef HAVE_STRUCT_UTMP
    MEMSET(ut, 0, sizeof(struct utmp));
# ifdef HAVE_UTMP_PID
    setutent();
    STRNCPY(ut->ut_id, ut_id, sizeof(ut->ut_id));
    ut->ut_type = DEAD_PROCESS;
    getutid(ut);                /* position to entry in utmp file */
    STRNCPY(ut_id, ut_id, sizeof(ut_id));
# endif
#endif

#ifdef HAVE_STRUCT_UTMPX
    MEMSET(utx, 0, sizeof(struct utmpx));
    setutxent();
    STRNCPY(utx->ut_id, ut_id, sizeof(utx->ut_id));
    utx->ut_type = DEAD_PROCESS;
    getutxid(utx);              /* position to entry in utmp file */
    STRNCPY(ut_id, ut_id, sizeof(ut_id));
#endif

#ifdef HAVE_STRUCT_UTMP
    STRNCPY(ut->ut_line, pty, sizeof(ut->ut_line));
    ut->ut_time = time(NULL);
# ifdef HAVE_UTMP_PID
    STRNCPY(ut->ut_user, (pwent && pwent->pw_name) ? pwent->pw_name : "?",
            sizeof(ut->ut_user));
    STRNCPY(ut->ut_id, ut_id, sizeof(ut->ut_id));
    ut->ut_time = time(NULL);
    ut->ut_pid = cmd_pid;
#  ifdef HAVE_UTMP_HOST
    STRNCPY(ut->ut_host, hostname, sizeof(ut->ut_host));
#  endif
    ut->ut_type = USER_PROCESS;
    pututline(ut);
    endutent();                 /* close the file */
    utmp_pos = 0;
# else
    STRNCPY(ut->ut_name, (pwent && pwent->pw_name) ? pwent->pw_name : "?",
            sizeof(ut->ut_name));
#  ifdef HAVE_UTMP_HOST
    STRNCPY(ut->ut_host, hostname, sizeof(ut->ut_host));
#  endif
# endif
#endif

#ifdef HAVE_STRUCT_UTMPX
    STRNCPY(utx->ut_line, pty, sizeof(utx->ut_line));
    STRNCPY(utx->ut_user, (pwent && pwent->pw_name) ? pwent->pw_name : "?",
            sizeof(utx->ut_user));
    STRNCPY(utx->ut_id, ut_id, sizeof(utx->ut_id));
    utx->ut_session = getsid(0);
    utx->ut_tv.tv_sec = time(NULL);
    utx->ut_tv.tv_usec = 0;
    utx->ut_pid = cmd_pid;
# ifdef HAVE_UTMPX_HOST
    STRNCPY(utx->ut_host, hostname, sizeof(utx->ut_host));
#  if 0
    {
        char           *colon;

        if ((colon = STRRCHR(ut->ut_host, ':')) != NULL)
            *colon = '\0';
    }
#  endif
# endif
    utx->ut_type = USER_PROCESS;
    pututxline(utx);
    endutxent();                /* close the file */
    utmp_pos = 0;
#endif

#if defined(HAVE_STRUCT_UTMP) && !defined(HAVE_UTMP_PID)
    {
        int             i;
# ifdef HAVE_TTYSLOT
        i = ttyslot();
        if (rxvt_write_bsd_utmp(i, ut))
            utmp_pos = i;
# else
        FILE           *fd0;

        if ((fd0 = fopen(TTYTAB_FILENAME, "r")) != NULL) {
            char            buf[256], name[256];

            buf[sizeof(buf) - 1] = '\0';
            for (i = 1; (fgets(buf, sizeof(buf) - 1, fd0) != NULL);) {
                if (*buf == '#' || sscanf(buf, "%s", name) != 1)
                    continue;
                if (!STRCMP(ut->ut_line, name)) {
                    if (!rxvt_write_bsd_utmp(i, ut))
                        i = 0;
                    utmp_pos = i;
                    fclose(fd0);
                    break;
                }
                i++;
            }
            fclose(fd0);
        }
# endif
    }
#endif

#ifdef WTMP_SUPPORT
# ifdef WTMP_ONLY_ON_LOGIN
    if (Options & Opt_loginShell)
# endif
    {
# ifdef HAVE_STRUCT_UTMP
#  ifdef HAVE_UPDWTMP
        updwtmp(RXVT_WTMP_FILE, ut);
#  else
        rxvt_update_wtmp(RXVT_WTMP_FILE, ut);
#  endif
# endif
# ifdef HAVE_STRUCT_UTMPX
        updwtmpx(RXVT_WTMPX_FILE, utx);
# endif
    }
#endif
#if defined(LASTLOG_SUPPORT) && defined(RXVT_LASTLOG_FILE)
    if (Options & Opt_loginShell)
        rxvt_update_lastlog(RXVT_LASTLOG_FILE, pty, hostname);
#endif
}

/* ------------------------------------------------------------------------- */
/*
 * remove utmp and wtmp entries
 */
void
rxvt_term::cleanutent ()
{
#ifdef HAVE_STRUCT_UTMP
    struct utmp    *ut = &(this->ut);
#endif
#ifdef HAVE_STRUCT_UTMPX
    struct utmpx   *tmputx, *utx = &(this->utx);
#endif

#ifdef HAVE_STRUCT_UTMP
# ifdef HAVE_UTMP_PID
    MEMSET(ut, 0, sizeof(struct utmp));
    setutent();
    STRNCPY(ut->ut_id, ut_id, sizeof(ut->ut_id));
    ut->ut_type = USER_PROCESS;
    {
        struct utmp    *tmput = getutid(ut);

        if (tmput)              /* position to entry in utmp file */
            ut = tmput;
    }
    ut->ut_type = DEAD_PROCESS;
# else 
    MEMSET(ut->ut_name, 0, sizeof(ut->ut_name));
#  ifdef HAVE_UTMP_HOST
    MEMSET(ut->ut_host, 0, sizeof(ut->ut_host));
#  endif
# endif
    ut->ut_time = time(NULL);
#endif

#ifdef HAVE_STRUCT_UTMPX
    MEMSET(utx, 0, sizeof(struct utmpx));
    setutxent();
    STRNCPY(utx->ut_id, ut_id, sizeof(utx->ut_id));
    utx->ut_type = USER_PROCESS;
    if ((tmputx = getutxid(utx)))       /* position to entry in utmp file */
        utx = tmputx;
    utx->ut_type = DEAD_PROCESS;
    utx->ut_session = getsid(0);
    utx->ut_tv.tv_sec = time(NULL);
    utx->ut_tv.tv_usec = 0;
#endif

    /*
     * Write ending wtmp entry
     */
#ifdef WTMP_SUPPORT
# ifdef WTMP_ONLY_ON_LOGIN
    if (Options & Opt_loginShell)
# endif
    {
# ifdef HAVE_STRUCT_UTMP
#  ifdef HAVE_UPDWTMP
        updwtmp(RXVT_WTMP_FILE, ut);
#  else
        rxvt_update_wtmp(RXVT_WTMP_FILE, ut);
#  endif
# endif
# ifdef HAVE_STRUCT_UTMPX
        updwtmpx(RXVT_WTMPX_FILE, utx);
# endif
    }
#endif

    /*
     * Write utmp entry
     */
#ifdef HAVE_STRUCT_UTMP
# ifdef HAVE_UTMP_PID
    if (ut->ut_pid == cmd_pid)
        pututline(ut);
    endutent();
# else
    MEMSET(ut, 0, sizeof(struct utmp));
    rxvt_write_bsd_utmp(utmp_pos, ut);
# endif
#endif
#ifdef HAVE_STRUCT_UTMPX
    if (utx->ut_pid == cmd_pid)
        pututxline(utx);
    endutxent();
#endif
}

/* ------------------------------------------------------------------------- */
/*
 * Write a BSD style utmp entry
 */
#ifdef HAVE_UTMP_H
/* INTPROTO */
int
rxvt_write_bsd_utmp(int utmp_pos, struct utmp *wu)
{
    int             fd;

    if (utmp_pos <= 0 || (fd = open(RXVT_UTMP_FILE, O_WRONLY)) == -1)
        return 0;

    if (lseek(fd, (off_t) (utmp_pos * sizeof(struct utmp)), SEEK_SET) != -1)
        write(fd, wu, sizeof(struct utmp));
    close(fd);
    return 1;
}
#endif

/* ------------------------------------------------------------------------- */
/*
 * Update a BSD style wtmp entry
 */
#if defined(WTMP_SUPPORT) && !defined(HAVE_UPDWTMP)
/* INTPROTO */
void
rxvt_update_wtmp(const char *fname, const struct utmp *putmp)
{
    int             fd, gotlock, retry;
    struct flock    lck;        /* fcntl locking scheme */
    struct stat     sbuf;

    if ((fd = open(fname, O_WRONLY | O_APPEND, 0)) < 0)
        return;

    lck.l_whence = SEEK_END;    /* start lock at current eof */
    lck.l_len = 0;              /* end at ``largest possible eof'' */
    lck.l_start = 0;
    lck.l_type = F_WRLCK;       /* we want a write lock */

    /* attempt lock with F_SETLK; F_SETLKW would cause a deadlock! */
    for (retry = 10, gotlock = 0; retry--;)
        if (fcntl(fd, F_SETLK, &lck) != -1) {
            gotlock = 1;
            break;
        } else if (errno != EAGAIN && errno != EACCES)
            break;
    if (!gotlock) {             /* give it up */
        close(fd);
        return;
    }
    if (fstat(fd, &sbuf) == 0)
        if (write(fd, putmp, sizeof(struct utmp)) != sizeof(struct utmp))
            ftruncate(fd, sbuf.st_size);        /* remove bad writes */

    lck.l_type = F_UNLCK;       /* unlocking the file */
    fcntl(fd, F_SETLK, &lck);
    close(fd);
}
#endif

/* ------------------------------------------------------------------------- */
#ifdef LASTLOG_SUPPORT
/* INTPROTO */
void
rxvt_update_lastlog(const char *fname, const char *pty, const char *host)
{
# ifdef HAVE_STRUCT_LASTLOGX
    struct lastlogx llx;
# endif
# ifdef HAVE_STRUCT_LASTLOG
    int             fd;
    struct lastlog  ll;
#  ifdef LASTLOG_IS_DIR
    char            lastlogfile[256];
#  endif
    struct passwd  *pwent;
# endif

# ifdef HAVE_STRUCT_LASTLOGX
    MEMSET(&llx, 0, sizeof(llx));
    llx.ll_tv.tv_sec = time(NULL);
    llx.ll_tv.tv_usec = 0;
    STRNCPY(llx.ll_line, pty, sizeof(llx.ll_line));
    STRNCPY(llx.ll_host, host, sizeof(llx.ll_host));
    updlastlogx(RXVT_LASTLOGX_FILE, getuid(), &llx);
# endif

# ifdef HAVE_STRUCT_LASTLOG
    pwent = getpwuid(getuid());
    if (!pwent) {
        rxvt_print_error("no entry in password file");
        return;
    }
    MEMSET(&ll, 0, sizeof(ll));
    ll.ll_time = time(NULL);
    STRNCPY(ll.ll_line, pty, sizeof(ll.ll_line));
    STRNCPY(ll.ll_host, host, sizeof(ll.ll_host));
#  ifdef LASTLOG_IS_DIR
    sprintf(lastlogfile, "%.*s/%.*s",
            sizeof(lastlogfile) - sizeof(pwent->pw_name) - 2, fname,
            sizeof(pwent->pw_name),
            (!pwent->pw_name || pwent->pw_name[0] == '\0') ? "unknown"
                                                           : pwent->pw_name);
    if ((fd = open(lastlogfile, O_WRONLY | O_CREAT, 0644)) >= 0) {
        write(fd, &ll, sizeof(ll));
        close(fd);
    }
#  else
    if ((fd = open(fname, O_RDWR)) != -1) {
        if (lseek(fd, (off_t) ((long)pwent->pw_uid * sizeof(ll)),
                  SEEK_SET) != -1)
            write(fd, &ll, sizeof(ll));
        close(fd);
    }
#  endif                        /* LASTLOG_IS_DIR */
# endif                         /* HAVE_STRUCT_LASTLOG */
}
#endif                          /* LASTLOG_SUPPORT */
/* ------------------------------------------------------------------------- */

#endif                          /* UTMP_SUPPORT */
Revision:	1.4
Committed:	Sat Jan 31 00:20:21 2004 UTC (20 years, 3 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
Changes since 1.3:	+23 -25 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	pcg	1.1	/---------------------------------C----------------------------------
2			* File: logging.c
3			----------------------------------------------------------------------
4	pcg	1.4	* $Id: logging.C,v 1.3 2003/11/25 11:52:42 pcg Exp $
5	pcg	1.1	*
6			* All portions of code are copyright by their respective author/s.
7			* Copyright (c) 1992 John Bovey <jdb@ukc.ac.uk>
8			* - original version
9			* Copyright (c) 1993 lipka
10			* Copyright (c) 1993 Brian Stempien <stempien@cs.wmich.edu>
11			* Copyright (c) 1995 Raul Garcia Garcia <rgg@tid.es>
12			* Copyright (c) 1995 Piet W. Plomp <piet@idefix.icce.rug.nl>
13			* Copyright (c) 1997 Raul Garcia Garcia <rgg@tid.es>
14			* Copyright (c) 1998-2001 Geoff Wing <gcw@pobox.com>
15			* - extensive modifications
16			* Copyright (c) 1999 D J Hawkey Jr <hawkeyd@visi.com>
17			* - lastlog support
18			*
19			* This program is free software; you can redistribute it and/or modify
20			* it under the terms of the GNU General Public License as published by
21			* the Free Software Foundation; either version 2 of the License, or
22			* (at your option) any later version.
23			*
24			* This program is distributed in the hope that it will be useful,
25			* but WITHOUT ANY WARRANTY; without even the implied warranty of
26			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27			* GNU General Public License for more details.
28			*
29			* You should have received a copy of the GNU General Public License
30			* along with this program; if not, write to the Free Software
31			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
32			----------------------------------------------------------------------/
33			/----------------------------------------------------------------------
34			* Public:
35			* extern void cleanutent (void);
36			* extern void makeutent (const char * pty, const char * hostname);
37			*
38			* Private:
39			* rxvt_update_wtmp ();
40			----------------------------------------------------------------------/
41
42			#include "../config.h" /* NECESSARY */
43			#include "rxvt.h" /* NECESSARY */
44			#include "logging.h"
45			#ifdef UTMP_SUPPORT
46
47			/*
48			* BSD style utmp entry
49			* ut_line, ut_name, ut_host, ut_time
50			* SYSV style utmp (and utmpx) entry
51			* ut_user, ut_id, ut_line, ut_pid, ut_type, ut_exit, ut_time
52			*/
53
54			/* ------------------------------------------------------------------------- */
55
56			/*
57			* make and write utmp and wtmp entries
58			*/
59			void
60	pcg	1.4	rxvt_term::makeutent (const char pty, const char hostname)
61	pcg	1.1	{
62			#ifdef HAVE_STRUCT_UTMP
63	pcg	1.4	struct utmp *ut = &(this->ut);
64	pcg	1.1	#endif
65			#ifdef HAVE_STRUCT_UTMPX
66	pcg	1.4	struct utmpx *utx = &(this->utx);
67	pcg	1.1	#endif
68			#ifdef HAVE_UTMP_PID
69			int i;
70			#endif
71			char ut_id[5];
72			struct passwd *pwent = getpwuid(getuid());
73
74			if (!STRNCMP(pty, "/dev/", 5))
75			pty += 5; /* skip /dev/ prefix */
76
77			if (!STRNCMP(pty, "pty", 3) \|\| !STRNCMP(pty, "tty", 3)) {
78			STRNCPY(ut_id, (pty + 3), sizeof(ut_id));
79			}
80			#ifdef HAVE_UTMP_PID
81			else if (sscanf(pty, "pts/%d", &i) == 1)
82			sprintf(ut_id, "vt%02x", (i & 0xff)); /* sysv naming */
83			#endif
84			else if (STRNCMP(pty, "pty", 3) && STRNCMP(pty, "tty", 3)) {
85			rxvt_print_error("can't parse tty name \"%s\"", pty);
86			return;
87			}
88
89			#ifdef HAVE_STRUCT_UTMP
90			MEMSET(ut, 0, sizeof(struct utmp));
91			# ifdef HAVE_UTMP_PID
92			setutent();
93			STRNCPY(ut->ut_id, ut_id, sizeof(ut->ut_id));
94			ut->ut_type = DEAD_PROCESS;
95			getutid(ut); /* position to entry in utmp file */
96	pcg	1.4	STRNCPY(ut_id, ut_id, sizeof(ut_id));
97	pcg	1.1	# endif
98			#endif
99
100			#ifdef HAVE_STRUCT_UTMPX
101			MEMSET(utx, 0, sizeof(struct utmpx));
102			setutxent();
103			STRNCPY(utx->ut_id, ut_id, sizeof(utx->ut_id));
104			utx->ut_type = DEAD_PROCESS;
105			getutxid(utx); /* position to entry in utmp file */
106	pcg	1.4	STRNCPY(ut_id, ut_id, sizeof(ut_id));
107	pcg	1.1	#endif
108
109			#ifdef HAVE_STRUCT_UTMP
110			STRNCPY(ut->ut_line, pty, sizeof(ut->ut_line));
111			ut->ut_time = time(NULL);
112			# ifdef HAVE_UTMP_PID
113			STRNCPY(ut->ut_user, (pwent && pwent->pw_name) ? pwent->pw_name : "?",
114			sizeof(ut->ut_user));
115			STRNCPY(ut->ut_id, ut_id, sizeof(ut->ut_id));
116			ut->ut_time = time(NULL);
117	pcg	1.4	ut->ut_pid = cmd_pid;
118	pcg	1.1	# ifdef HAVE_UTMP_HOST
119			STRNCPY(ut->ut_host, hostname, sizeof(ut->ut_host));
120			# endif
121			ut->ut_type = USER_PROCESS;
122			pututline(ut);
123			endutent(); /* close the file */
124	pcg	1.4	utmp_pos = 0;
125	pcg	1.1	# else
126			STRNCPY(ut->ut_name, (pwent && pwent->pw_name) ? pwent->pw_name : "?",
127			sizeof(ut->ut_name));
128			# ifdef HAVE_UTMP_HOST
129			STRNCPY(ut->ut_host, hostname, sizeof(ut->ut_host));
130			# endif
131			# endif
132			#endif
133
134			#ifdef HAVE_STRUCT_UTMPX
135			STRNCPY(utx->ut_line, pty, sizeof(utx->ut_line));
136			STRNCPY(utx->ut_user, (pwent && pwent->pw_name) ? pwent->pw_name : "?",
137			sizeof(utx->ut_user));
138			STRNCPY(utx->ut_id, ut_id, sizeof(utx->ut_id));
139			utx->ut_session = getsid(0);
140			utx->ut_tv.tv_sec = time(NULL);
141			utx->ut_tv.tv_usec = 0;
142	pcg	1.4	utx->ut_pid = cmd_pid;
143	pcg	1.1	# ifdef HAVE_UTMPX_HOST
144			STRNCPY(utx->ut_host, hostname, sizeof(utx->ut_host));
145			# if 0
146			{
147			char *colon;
148
149			if ((colon = STRRCHR(ut->ut_host, ':')) != NULL)
150			*colon = '\0';
151			}
152			# endif
153			# endif
154			utx->ut_type = USER_PROCESS;
155			pututxline(utx);
156			endutxent(); /* close the file */
157	pcg	1.4	utmp_pos = 0;
158	pcg	1.1	#endif
159
160			#if defined(HAVE_STRUCT_UTMP) && !defined(HAVE_UTMP_PID)
161			{
162			int i;
163			# ifdef HAVE_TTYSLOT
164			i = ttyslot();
165			if (rxvt_write_bsd_utmp(i, ut))
166	pcg	1.4	utmp_pos = i;
167	pcg	1.1	# else
168			FILE *fd0;
169
170			if ((fd0 = fopen(TTYTAB_FILENAME, "r")) != NULL) {
171			char buf[256], name[256];
172
173			buf[sizeof(buf) - 1] = '\0';
174			for (i = 1; (fgets(buf, sizeof(buf) - 1, fd0) != NULL);) {
175			if (*buf == '#' \|\| sscanf(buf, "%s", name) != 1)
176			continue;
177			if (!STRCMP(ut->ut_line, name)) {
178			if (!rxvt_write_bsd_utmp(i, ut))
179			i = 0;
180	pcg	1.4	utmp_pos = i;
181	pcg	1.1	fclose(fd0);
182			break;
183			}
184			i++;
185			}
186			fclose(fd0);
187			}
188			# endif
189			}
190			#endif
191
192			#ifdef WTMP_SUPPORT
193			# ifdef WTMP_ONLY_ON_LOGIN
194	pcg	1.4	if (Options & Opt_loginShell)
195	pcg	1.1	# endif
196			{
197			# ifdef HAVE_STRUCT_UTMP
198			# ifdef HAVE_UPDWTMP
199			updwtmp(RXVT_WTMP_FILE, ut);
200			# else
201			rxvt_update_wtmp(RXVT_WTMP_FILE, ut);
202			# endif
203			# endif
204			# ifdef HAVE_STRUCT_UTMPX
205			updwtmpx(RXVT_WTMPX_FILE, utx);
206			# endif
207			}
208			#endif
209			#if defined(LASTLOG_SUPPORT) && defined(RXVT_LASTLOG_FILE)
210	pcg	1.4	if (Options & Opt_loginShell)
211	pcg	1.1	rxvt_update_lastlog(RXVT_LASTLOG_FILE, pty, hostname);
212			#endif
213			}
214
215			/* ------------------------------------------------------------------------- */
216			/*
217			* remove utmp and wtmp entries
218			*/
219			void
220	pcg	1.4	rxvt_term::cleanutent ()
221	pcg	1.1	{
222			#ifdef HAVE_STRUCT_UTMP
223	pcg	1.4	struct utmp *ut = &(this->ut);
224	pcg	1.1	#endif
225			#ifdef HAVE_STRUCT_UTMPX
226	pcg	1.4	struct utmpx tmputx, utx = &(this->utx);
227	pcg	1.1	#endif
228
229			#ifdef HAVE_STRUCT_UTMP
230			# ifdef HAVE_UTMP_PID
231			MEMSET(ut, 0, sizeof(struct utmp));
232			setutent();
233	pcg	1.4	STRNCPY(ut->ut_id, ut_id, sizeof(ut->ut_id));
234	pcg	1.1	ut->ut_type = USER_PROCESS;
235			{
236			struct utmp *tmput = getutid(ut);
237
238			if (tmput) /* position to entry in utmp file */
239			ut = tmput;
240			}
241			ut->ut_type = DEAD_PROCESS;
242			# else
243			MEMSET(ut->ut_name, 0, sizeof(ut->ut_name));
244			# ifdef HAVE_UTMP_HOST
245			MEMSET(ut->ut_host, 0, sizeof(ut->ut_host));
246			# endif
247			# endif
248			ut->ut_time = time(NULL);
249			#endif
250
251			#ifdef HAVE_STRUCT_UTMPX
252			MEMSET(utx, 0, sizeof(struct utmpx));
253			setutxent();
254	pcg	1.4	STRNCPY(utx->ut_id, ut_id, sizeof(utx->ut_id));
255	pcg	1.1	utx->ut_type = USER_PROCESS;
256			if ((tmputx = getutxid(utx))) /* position to entry in utmp file */
257			utx = tmputx;
258			utx->ut_type = DEAD_PROCESS;
259			utx->ut_session = getsid(0);
260			utx->ut_tv.tv_sec = time(NULL);
261			utx->ut_tv.tv_usec = 0;
262			#endif
263
264			/*
265			* Write ending wtmp entry
266			*/
267			#ifdef WTMP_SUPPORT
268			# ifdef WTMP_ONLY_ON_LOGIN
269	pcg	1.4	if (Options & Opt_loginShell)
270	pcg	1.1	# endif
271			{
272			# ifdef HAVE_STRUCT_UTMP
273			# ifdef HAVE_UPDWTMP
274			updwtmp(RXVT_WTMP_FILE, ut);
275			# else
276			rxvt_update_wtmp(RXVT_WTMP_FILE, ut);
277			# endif
278			# endif
279			# ifdef HAVE_STRUCT_UTMPX
280			updwtmpx(RXVT_WTMPX_FILE, utx);
281			# endif
282			}
283			#endif
284
285			/*
286			* Write utmp entry
287			*/
288			#ifdef HAVE_STRUCT_UTMP
289			# ifdef HAVE_UTMP_PID
290	pcg	1.4	if (ut->ut_pid == cmd_pid)
291	pcg	1.1	pututline(ut);
292			endutent();
293			# else
294			MEMSET(ut, 0, sizeof(struct utmp));
295	pcg	1.4	rxvt_write_bsd_utmp(utmp_pos, ut);
296	pcg	1.1	# endif
297			#endif
298			#ifdef HAVE_STRUCT_UTMPX
299	pcg	1.4	if (utx->ut_pid == cmd_pid)
300	pcg	1.1	pututxline(utx);
301			endutxent();
302			#endif
303			}
304
305			/* ------------------------------------------------------------------------- */
306			/*
307			* Write a BSD style utmp entry
308			*/
309			#ifdef HAVE_UTMP_H
310			/* INTPROTO */
311			int
312			rxvt_write_bsd_utmp(int utmp_pos, struct utmp *wu)
313			{
314			int fd;
315
316			if (utmp_pos <= 0 \|\| (fd = open(RXVT_UTMP_FILE, O_WRONLY)) == -1)
317			return 0;
318
319			if (lseek(fd, (off_t) (utmp_pos * sizeof(struct utmp)), SEEK_SET) != -1)
320			write(fd, wu, sizeof(struct utmp));
321			close(fd);
322			return 1;
323			}
324			#endif
325
326			/* ------------------------------------------------------------------------- */
327			/*
328			* Update a BSD style wtmp entry
329			*/
330			#if defined(WTMP_SUPPORT) && !defined(HAVE_UPDWTMP)
331			/* INTPROTO */
332			void
333			rxvt_update_wtmp(const char fname, const struct utmp putmp)
334			{
335			int fd, gotlock, retry;
336			struct flock lck; /* fcntl locking scheme */
337			struct stat sbuf;
338
339			if ((fd = open(fname, O_WRONLY \| O_APPEND, 0)) < 0)
340			return;
341
342			lck.l_whence = SEEK_END; /* start lock at current eof */
343			lck.l_len = 0; /* end at ``largest possible eof'' */
344			lck.l_start = 0;
345			lck.l_type = F_WRLCK; /* we want a write lock */
346
347			/* attempt lock with F_SETLK; F_SETLKW would cause a deadlock! */
348			for (retry = 10, gotlock = 0; retry--;)
349			if (fcntl(fd, F_SETLK, &lck) != -1) {
350			gotlock = 1;
351			break;
352			} else if (errno != EAGAIN && errno != EACCES)
353			break;
354			if (!gotlock) { /* give it up */
355			close(fd);
356			return;
357			}
358			if (fstat(fd, &sbuf) == 0)
359			if (write(fd, putmp, sizeof(struct utmp)) != sizeof(struct utmp))
360			ftruncate(fd, sbuf.st_size); /* remove bad writes */
361
362			lck.l_type = F_UNLCK; /* unlocking the file */
363			fcntl(fd, F_SETLK, &lck);
364			close(fd);
365			}
366			#endif
367
368			/* ------------------------------------------------------------------------- */
369			#ifdef LASTLOG_SUPPORT
370			/* INTPROTO */
371			void
372			rxvt_update_lastlog(const char fname, const char pty, const char *host)
373			{
374			# ifdef HAVE_STRUCT_LASTLOGX
375			struct lastlogx llx;
376			# endif
377			# ifdef HAVE_STRUCT_LASTLOG
378			int fd;
379			struct lastlog ll;
380			# ifdef LASTLOG_IS_DIR
381			char lastlogfile[256];
382			# endif
383			struct passwd *pwent;
384			# endif
385
386			# ifdef HAVE_STRUCT_LASTLOGX
387			MEMSET(&llx, 0, sizeof(llx));
388			llx.ll_tv.tv_sec = time(NULL);
389			llx.ll_tv.tv_usec = 0;
390			STRNCPY(llx.ll_line, pty, sizeof(llx.ll_line));
391			STRNCPY(llx.ll_host, host, sizeof(llx.ll_host));
392			updlastlogx(RXVT_LASTLOGX_FILE, getuid(), &llx);
393			# endif
394
395			# ifdef HAVE_STRUCT_LASTLOG
396			pwent = getpwuid(getuid());
397			if (!pwent) {
398			rxvt_print_error("no entry in password file");
399			return;
400			}
401			MEMSET(&ll, 0, sizeof(ll));
402			ll.ll_time = time(NULL);
403			STRNCPY(ll.ll_line, pty, sizeof(ll.ll_line));
404			STRNCPY(ll.ll_host, host, sizeof(ll.ll_host));
405			# ifdef LASTLOG_IS_DIR
406			sprintf(lastlogfile, "%.s/%.s",
407			sizeof(lastlogfile) - sizeof(pwent->pw_name) - 2, fname,
408			sizeof(pwent->pw_name),
409			(!pwent->pw_name \|\| pwent->pw_name[0] == '\0') ? "unknown"
410			: pwent->pw_name);
411			if ((fd = open(lastlogfile, O_WRONLY \| O_CREAT, 0644)) >= 0) {
412			write(fd, &ll, sizeof(ll));
413			close(fd);
414			}
415			# else
416			if ((fd = open(fname, O_RDWR)) != -1) {
417			if (lseek(fd, (off_t) ((long)pwent->pw_uid * sizeof(ll)),
418			SEEK_SET) != -1)
419			write(fd, &ll, sizeof(ll));
420			close(fd);
421			}
422			# endif /* LASTLOG_IS_DIR */
423			# endif /* HAVE_STRUCT_LASTLOG */
424			}
425			#endif /* LASTLOG_SUPPORT */
426			/* ------------------------------------------------------------------------- */
427
428			#endif /* UTMP_SUPPORT */