rxvt-unicode/src/logging.C

/*--------------------------------*-C-*---------------------------------*
 * File:        logging.c
 *----------------------------------------------------------------------*
 * $Id: logging.C,v 1.2 2003/11/24 17:31:27 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
 */
/* EXTPROTO */
void
rxvt_makeutent(pR_ const char *pty, const char *hostname)
{
#ifdef HAVE_STRUCT_UTMP
    struct utmp    *ut = &(R->ut);
#endif
#ifdef HAVE_STRUCT_UTMPX
    struct utmpx   *utx = &(R->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(R->ut_id, ut_id, sizeof(R->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(R->ut_id, ut_id, sizeof(R->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 = R->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 */
    R->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 = R->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 */
    R->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))
            R->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;
                    R->utmp_pos = i;
                    fclose(fd0);
                    break;
                }
                i++;
            }
            fclose(fd0);
        }
# endif
    }
#endif

#ifdef WTMP_SUPPORT
# ifdef WTMP_ONLY_ON_LOGIN
    if (R->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 (R->Options & Opt_loginShell)
        rxvt_update_lastlog(RXVT_LASTLOG_FILE, pty, hostname);
#endif
}

/* ------------------------------------------------------------------------- */
/*
 * remove utmp and wtmp entries
 */
/* EXTPROTO */
void
rxvt_cleanutent(pR)
{
#ifdef HAVE_STRUCT_UTMP
    struct utmp    *ut = &(R->ut);
#endif
#ifdef HAVE_STRUCT_UTMPX
    struct utmpx   *tmputx, *utx = &(R->utx);
#endif

#ifdef HAVE_STRUCT_UTMP
# ifdef HAVE_UTMP_PID
    MEMSET(ut, 0, sizeof(struct utmp));
    setutent();
    STRNCPY(ut->ut_id, R->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, R->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 (R->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 == R->cmd_pid)
        pututline(ut);
    endutent();
# else
    MEMSET(ut, 0, sizeof(struct utmp));
    rxvt_write_bsd_utmp(R->utmp_pos, ut);
# endif
#endif
#ifdef HAVE_STRUCT_UTMPX
    if (utx->ut_pid == R->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.3
Committed:	Tue Nov 25 11:52:42 2003 UTC (20 years, 6 months ago) by pcg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-1-2, rel-1-3
Changes since 1.2:	+18 -18 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	pcg	1.1	/---------------------------------C----------------------------------
2			* File: logging.c
3			----------------------------------------------------------------------
4	pcg	1.3	* $Id: logging.C,v 1.2 2003/11/24 17:31:27 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			/* EXTPROTO */
60			void
61			rxvt_makeutent(pR_ const char pty, const char hostname)
62			{
63			#ifdef HAVE_STRUCT_UTMP
64	pcg	1.3	struct utmp *ut = &(R->ut);
65	pcg	1.1	#endif
66			#ifdef HAVE_STRUCT_UTMPX
67	pcg	1.3	struct utmpx *utx = &(R->utx);
68	pcg	1.1	#endif
69			#ifdef HAVE_UTMP_PID
70			int i;
71			#endif
72			char ut_id[5];
73			struct passwd *pwent = getpwuid(getuid());
74
75			if (!STRNCMP(pty, "/dev/", 5))
76			pty += 5; /* skip /dev/ prefix */
77
78			if (!STRNCMP(pty, "pty", 3) \|\| !STRNCMP(pty, "tty", 3)) {
79			STRNCPY(ut_id, (pty + 3), sizeof(ut_id));
80			}
81			#ifdef HAVE_UTMP_PID
82			else if (sscanf(pty, "pts/%d", &i) == 1)
83			sprintf(ut_id, "vt%02x", (i & 0xff)); /* sysv naming */
84			#endif
85			else if (STRNCMP(pty, "pty", 3) && STRNCMP(pty, "tty", 3)) {
86			rxvt_print_error("can't parse tty name \"%s\"", pty);
87			return;
88			}
89
90			#ifdef HAVE_STRUCT_UTMP
91			MEMSET(ut, 0, sizeof(struct utmp));
92			# ifdef HAVE_UTMP_PID
93			setutent();
94			STRNCPY(ut->ut_id, ut_id, sizeof(ut->ut_id));
95			ut->ut_type = DEAD_PROCESS;
96			getutid(ut); /* position to entry in utmp file */
97	pcg	1.3	STRNCPY(R->ut_id, ut_id, sizeof(R->ut_id));
98	pcg	1.1	# endif
99			#endif
100
101			#ifdef HAVE_STRUCT_UTMPX
102			MEMSET(utx, 0, sizeof(struct utmpx));
103			setutxent();
104			STRNCPY(utx->ut_id, ut_id, sizeof(utx->ut_id));
105			utx->ut_type = DEAD_PROCESS;
106			getutxid(utx); /* position to entry in utmp file */
107	pcg	1.3	STRNCPY(R->ut_id, ut_id, sizeof(R->ut_id));
108	pcg	1.1	#endif
109
110			#ifdef HAVE_STRUCT_UTMP
111			STRNCPY(ut->ut_line, pty, sizeof(ut->ut_line));
112			ut->ut_time = time(NULL);
113			# ifdef HAVE_UTMP_PID
114			STRNCPY(ut->ut_user, (pwent && pwent->pw_name) ? pwent->pw_name : "?",
115			sizeof(ut->ut_user));
116			STRNCPY(ut->ut_id, ut_id, sizeof(ut->ut_id));
117			ut->ut_time = time(NULL);
118	pcg	1.3	ut->ut_pid = R->cmd_pid;
119	pcg	1.1	# ifdef HAVE_UTMP_HOST
120			STRNCPY(ut->ut_host, hostname, sizeof(ut->ut_host));
121			# endif
122			ut->ut_type = USER_PROCESS;
123			pututline(ut);
124			endutent(); /* close the file */
125	pcg	1.3	R->utmp_pos = 0;
126	pcg	1.1	# else
127			STRNCPY(ut->ut_name, (pwent && pwent->pw_name) ? pwent->pw_name : "?",
128			sizeof(ut->ut_name));
129			# ifdef HAVE_UTMP_HOST
130			STRNCPY(ut->ut_host, hostname, sizeof(ut->ut_host));
131			# endif
132			# endif
133			#endif
134
135			#ifdef HAVE_STRUCT_UTMPX
136			STRNCPY(utx->ut_line, pty, sizeof(utx->ut_line));
137			STRNCPY(utx->ut_user, (pwent && pwent->pw_name) ? pwent->pw_name : "?",
138			sizeof(utx->ut_user));
139			STRNCPY(utx->ut_id, ut_id, sizeof(utx->ut_id));
140			utx->ut_session = getsid(0);
141			utx->ut_tv.tv_sec = time(NULL);
142			utx->ut_tv.tv_usec = 0;
143	pcg	1.3	utx->ut_pid = R->cmd_pid;
144	pcg	1.1	# ifdef HAVE_UTMPX_HOST
145			STRNCPY(utx->ut_host, hostname, sizeof(utx->ut_host));
146			# if 0
147			{
148			char *colon;
149
150			if ((colon = STRRCHR(ut->ut_host, ':')) != NULL)
151			*colon = '\0';
152			}
153			# endif
154			# endif
155			utx->ut_type = USER_PROCESS;
156			pututxline(utx);
157			endutxent(); /* close the file */
158	pcg	1.3	R->utmp_pos = 0;
159	pcg	1.1	#endif
160
161			#if defined(HAVE_STRUCT_UTMP) && !defined(HAVE_UTMP_PID)
162			{
163			int i;
164			# ifdef HAVE_TTYSLOT
165			i = ttyslot();
166			if (rxvt_write_bsd_utmp(i, ut))
167	pcg	1.3	R->utmp_pos = i;
168	pcg	1.1	# else
169			FILE *fd0;
170
171			if ((fd0 = fopen(TTYTAB_FILENAME, "r")) != NULL) {
172			char buf[256], name[256];
173
174			buf[sizeof(buf) - 1] = '\0';
175			for (i = 1; (fgets(buf, sizeof(buf) - 1, fd0) != NULL);) {
176			if (*buf == '#' \|\| sscanf(buf, "%s", name) != 1)
177			continue;
178			if (!STRCMP(ut->ut_line, name)) {
179			if (!rxvt_write_bsd_utmp(i, ut))
180			i = 0;
181	pcg	1.3	R->utmp_pos = i;
182	pcg	1.1	fclose(fd0);
183			break;
184			}
185			i++;
186			}
187			fclose(fd0);
188			}
189			# endif
190			}
191			#endif
192
193			#ifdef WTMP_SUPPORT
194			# ifdef WTMP_ONLY_ON_LOGIN
195			if (R->Options & Opt_loginShell)
196			# endif
197			{
198			# ifdef HAVE_STRUCT_UTMP
199			# ifdef HAVE_UPDWTMP
200			updwtmp(RXVT_WTMP_FILE, ut);
201			# else
202			rxvt_update_wtmp(RXVT_WTMP_FILE, ut);
203			# endif
204			# endif
205			# ifdef HAVE_STRUCT_UTMPX
206			updwtmpx(RXVT_WTMPX_FILE, utx);
207			# endif
208			}
209			#endif
210			#if defined(LASTLOG_SUPPORT) && defined(RXVT_LASTLOG_FILE)
211			if (R->Options & Opt_loginShell)
212			rxvt_update_lastlog(RXVT_LASTLOG_FILE, pty, hostname);
213			#endif
214			}
215
216			/* ------------------------------------------------------------------------- */
217			/*
218			* remove utmp and wtmp entries
219			*/
220			/* EXTPROTO */
221			void
222			rxvt_cleanutent(pR)
223			{
224			#ifdef HAVE_STRUCT_UTMP
225	pcg	1.3	struct utmp *ut = &(R->ut);
226	pcg	1.1	#endif
227			#ifdef HAVE_STRUCT_UTMPX
228	pcg	1.3	struct utmpx tmputx, utx = &(R->utx);
229	pcg	1.1	#endif
230
231			#ifdef HAVE_STRUCT_UTMP
232			# ifdef HAVE_UTMP_PID
233			MEMSET(ut, 0, sizeof(struct utmp));
234			setutent();
235	pcg	1.3	STRNCPY(ut->ut_id, R->ut_id, sizeof(ut->ut_id));
236	pcg	1.1	ut->ut_type = USER_PROCESS;
237			{
238			struct utmp *tmput = getutid(ut);
239
240			if (tmput) /* position to entry in utmp file */
241			ut = tmput;
242			}
243			ut->ut_type = DEAD_PROCESS;
244			# else
245			MEMSET(ut->ut_name, 0, sizeof(ut->ut_name));
246			# ifdef HAVE_UTMP_HOST
247			MEMSET(ut->ut_host, 0, sizeof(ut->ut_host));
248			# endif
249			# endif
250			ut->ut_time = time(NULL);
251			#endif
252
253			#ifdef HAVE_STRUCT_UTMPX
254			MEMSET(utx, 0, sizeof(struct utmpx));
255			setutxent();
256	pcg	1.3	STRNCPY(utx->ut_id, R->ut_id, sizeof(utx->ut_id));
257	pcg	1.1	utx->ut_type = USER_PROCESS;
258			if ((tmputx = getutxid(utx))) /* position to entry in utmp file */
259			utx = tmputx;
260			utx->ut_type = DEAD_PROCESS;
261			utx->ut_session = getsid(0);
262			utx->ut_tv.tv_sec = time(NULL);
263			utx->ut_tv.tv_usec = 0;
264			#endif
265
266			/*
267			* Write ending wtmp entry
268			*/
269			#ifdef WTMP_SUPPORT
270			# ifdef WTMP_ONLY_ON_LOGIN
271			if (R->Options & Opt_loginShell)
272			# endif
273			{
274			# ifdef HAVE_STRUCT_UTMP
275			# ifdef HAVE_UPDWTMP
276			updwtmp(RXVT_WTMP_FILE, ut);
277			# else
278			rxvt_update_wtmp(RXVT_WTMP_FILE, ut);
279			# endif
280			# endif
281			# ifdef HAVE_STRUCT_UTMPX
282			updwtmpx(RXVT_WTMPX_FILE, utx);
283			# endif
284			}
285			#endif
286
287			/*
288			* Write utmp entry
289			*/
290			#ifdef HAVE_STRUCT_UTMP
291			# ifdef HAVE_UTMP_PID
292	pcg	1.3	if (ut->ut_pid == R->cmd_pid)
293	pcg	1.1	pututline(ut);
294			endutent();
295			# else
296			MEMSET(ut, 0, sizeof(struct utmp));
297	pcg	1.3	rxvt_write_bsd_utmp(R->utmp_pos, ut);
298	pcg	1.1	# endif
299			#endif
300			#ifdef HAVE_STRUCT_UTMPX
301	pcg	1.3	if (utx->ut_pid == R->cmd_pid)
302	pcg	1.1	pututxline(utx);
303			endutxent();
304			#endif
305			}
306
307			/* ------------------------------------------------------------------------- */
308			/*
309			* Write a BSD style utmp entry
310			*/
311			#ifdef HAVE_UTMP_H
312			/* INTPROTO */
313			int
314			rxvt_write_bsd_utmp(int utmp_pos, struct utmp *wu)
315			{
316			int fd;
317
318			if (utmp_pos <= 0 \|\| (fd = open(RXVT_UTMP_FILE, O_WRONLY)) == -1)
319			return 0;
320
321			if (lseek(fd, (off_t) (utmp_pos * sizeof(struct utmp)), SEEK_SET) != -1)
322			write(fd, wu, sizeof(struct utmp));
323			close(fd);
324			return 1;
325			}
326			#endif
327
328			/* ------------------------------------------------------------------------- */
329			/*
330			* Update a BSD style wtmp entry
331			*/
332			#if defined(WTMP_SUPPORT) && !defined(HAVE_UPDWTMP)
333			/* INTPROTO */
334			void
335			rxvt_update_wtmp(const char fname, const struct utmp putmp)
336			{
337			int fd, gotlock, retry;
338			struct flock lck; /* fcntl locking scheme */
339			struct stat sbuf;
340
341			if ((fd = open(fname, O_WRONLY \| O_APPEND, 0)) < 0)
342			return;
343
344			lck.l_whence = SEEK_END; /* start lock at current eof */
345			lck.l_len = 0; /* end at ``largest possible eof'' */
346			lck.l_start = 0;
347			lck.l_type = F_WRLCK; /* we want a write lock */
348
349			/* attempt lock with F_SETLK; F_SETLKW would cause a deadlock! */
350			for (retry = 10, gotlock = 0; retry--;)
351			if (fcntl(fd, F_SETLK, &lck) != -1) {
352			gotlock = 1;
353			break;
354			} else if (errno != EAGAIN && errno != EACCES)
355			break;
356			if (!gotlock) { /* give it up */
357			close(fd);
358			return;
359			}
360			if (fstat(fd, &sbuf) == 0)
361			if (write(fd, putmp, sizeof(struct utmp)) != sizeof(struct utmp))
362			ftruncate(fd, sbuf.st_size); /* remove bad writes */
363
364			lck.l_type = F_UNLCK; /* unlocking the file */
365			fcntl(fd, F_SETLK, &lck);
366			close(fd);
367			}
368			#endif
369
370			/* ------------------------------------------------------------------------- */
371			#ifdef LASTLOG_SUPPORT
372			/* INTPROTO */
373			void
374			rxvt_update_lastlog(const char fname, const char pty, const char *host)
375			{
376			# ifdef HAVE_STRUCT_LASTLOGX
377			struct lastlogx llx;
378			# endif
379			# ifdef HAVE_STRUCT_LASTLOG
380			int fd;
381			struct lastlog ll;
382			# ifdef LASTLOG_IS_DIR
383			char lastlogfile[256];
384			# endif
385			struct passwd *pwent;
386			# endif
387
388			# ifdef HAVE_STRUCT_LASTLOGX
389			MEMSET(&llx, 0, sizeof(llx));
390			llx.ll_tv.tv_sec = time(NULL);
391			llx.ll_tv.tv_usec = 0;
392			STRNCPY(llx.ll_line, pty, sizeof(llx.ll_line));
393			STRNCPY(llx.ll_host, host, sizeof(llx.ll_host));
394			updlastlogx(RXVT_LASTLOGX_FILE, getuid(), &llx);
395			# endif
396
397			# ifdef HAVE_STRUCT_LASTLOG
398			pwent = getpwuid(getuid());
399			if (!pwent) {
400			rxvt_print_error("no entry in password file");
401			return;
402			}
403			MEMSET(&ll, 0, sizeof(ll));
404			ll.ll_time = time(NULL);
405			STRNCPY(ll.ll_line, pty, sizeof(ll.ll_line));
406			STRNCPY(ll.ll_host, host, sizeof(ll.ll_host));
407			# ifdef LASTLOG_IS_DIR
408			sprintf(lastlogfile, "%.s/%.s",
409			sizeof(lastlogfile) - sizeof(pwent->pw_name) - 2, fname,
410			sizeof(pwent->pw_name),
411			(!pwent->pw_name \|\| pwent->pw_name[0] == '\0') ? "unknown"
412			: pwent->pw_name);
413			if ((fd = open(lastlogfile, O_WRONLY \| O_CREAT, 0644)) >= 0) {
414			write(fd, &ll, sizeof(ll));
415			close(fd);
416			}
417			# else
418			if ((fd = open(fname, O_RDWR)) != -1) {
419			if (lseek(fd, (off_t) ((long)pwent->pw_uid * sizeof(ll)),
420			SEEK_SET) != -1)
421			write(fd, &ll, sizeof(ll));
422			close(fd);
423			}
424			# endif /* LASTLOG_IS_DIR */
425			# endif /* HAVE_STRUCT_LASTLOG */
426			}
427			#endif /* LASTLOG_SUPPORT */
428			/* ------------------------------------------------------------------------- */
429
430			#endif /* UTMP_SUPPORT */