rxvtlib_logging.c

具有IDE功能的编辑器

#include "rxvtlib.h"

/*--------------------------------*-C-*---------------------------------*
 * File:	logging.c
 *----------------------------------------------------------------------*
 * $Id: logging.c,v 1.7.2.1 1999/07/10 04:20:01 mason Exp $
 *
 * All portions of code are copyright by their respective author/s.
 * Copyright (C) 1992      John Bovey <[e-mail]>
 *				- original version
 * Copyright (C) 1993      lipka
 * Copyright (C) 1993      Brian Stempien <[e-mail]>
 * Copyright (C) 1995      Raul Garcia Garcia <[e-mail]>
 * Copyright (C) 1995      Piet W. Plomp <[e-mail]>
 * Copyright (C) 1997      Raul Garcia Garcia <[e-mail]>
 * Copyright (C) 1997,1998 Geoff Wing <[e-mail]>
 *
 * 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:
 *	write_utmp ();
 *	update_wtmp ();
 *----------------------------------------------------------------------*/

/*
 * HAVE_SETUTENT corresponds to SYSV-style utmp support.
 * Without it corresponds to using BSD utmp support.
 * SYSV-style utmp support is further divided in normal utmp support
 * and utmpx support (Solaris 2.x) by RXVT_UTMP_AS_UTMPX
 */

/*
 * update wtmp entries - only for SYSV style UTMP systems
 */
#ifdef UTMP_SUPPORT
	/* remember if entry to utmp made */

# ifndef USE_SYSV_UTMP
	/* BSD position of utmp-stamp */

# endif
#endif

/* ------------------------------------------------------------------------- */
#ifndef RXVT_UTMP_AS_UTMPX	/* supposedly we have updwtmpx ? */
#ifdef WTMP_SUPPORT
/* INTPROTO */
void            rxvt_update_wtmp (const char *fname, const struct utmp *putmp)
{
    int             fd, retry = 10;	/* 10 attempts at locking */
    struct flock    lck;	/* fcntl locking scheme */

    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 */

    while (retry--)
	/* attempt lock with F_SETLK - F_SETLKW would cause a deadlock! */
	if ((fcntl (fd, F_SETLK, &lck) < 0) && errno != EACCESS) {
	    close (fd);
	    return;		/* failed for unknown reason: give up */
	}
    write (fd, putmp, sizeof (struct utmp));

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

    close (fd);
}

#endif				/* WTMP_SUPPORT */
#endif				/* !HAVE_UTMPX_H */
/* ------------------------------------------------------------------------- */
#ifdef UTMP_SUPPORT
/*
 * make a utmp entry
 */
/* EXTPROTO */
void            rxvtlib_makeutent (rxvtlib *o, const char *pty, const char *hostname)
{
    struct passwd  *pwent = getpwuid (getuid ());
    UTMP            ut;

#ifndef USE_SYSV_UTMP
/*
 * BSD style utmp entry
 *      ut_line, ut_name, ut_host, ut_time
 */
    int             i;
    FILE           *fd0, *fd1;
    char            buf[256], name[256];

#else
/*
 * SYSV style utmp entry
 *      ut_user, ut_id, ut_line, ut_pid, ut_type, ut_exit, ut_time
 */
    char           *colon;

#endif				/* !USE_SYSV_UTMP */

/* BSD naming is of the form /dev/tty?? or /dev/pty?? */

    MEMSET (&ut, 0, sizeof (UTMP));
    if (!strncmp (pty, "/dev/", 5))
	pty += 5;		/* skip /dev/ prefix */
    if (!strncmp (pty, "pty", 3) || !strncmp (pty, "tty", 3))
	STRNCPY (o->ut_id, (pty + 3), sizeof (o->ut_id));
    else
#ifndef USE_SYSV_UTMP
    {
	print_error ("can't parse tty name \"%s\"", pty);
	o->ut_id[0] = '\0';	/* entry not made */
	return;
    }

    STRNCPY (ut.ut_line, pty, sizeof (ut.ut_line));
    STRNCPY (ut.ut_name, (pwent && pwent->pw_name) ? pwent->pw_name : "?",
	     sizeof (ut.ut_name));
    STRNCPY (ut.ut_host, hostname, sizeof (ut.ut_host));
    ut.ut_time = time (NULL);

    if ((fd0 = fopen (RXVT_REAL_UTMP_FILE, "r+")) == NULL)
	o->ut_id[0] = '\0';	/* entry not made */
    else {
	o->utmp_pos = -1;
	if ((fd1 = fopen (TTYTAB_FILENAME, "r")) != NULL) {
	    for (i = 1; (fgets (buf, sizeof (buf), fd1) != NULL);) {
		if (*buf == '#' || sscanf (buf, "%s", name) != 1)
		    continue;
		if (!strcmp (ut.ut_line, name)) {
		    fclose (fd1);
		    o->utmp_pos = i * sizeof (struct utmp);

		    break;
		}
		i++;
	    }
	    fclose (fd1);
	}
	if (o->utmp_pos < 0)
	    o->ut_id[0] = '\0';	/* entry not made */
	else {
	    fseek (fd0, o->utmp_pos, 0);
	    fwrite (&ut, sizeof (UTMP), 1, fd0);
	}
	fclose (fd0);
    }

#else				/* USE_SYSV_UTMP */
    {
	int             n;

	if (sscanf (pty, "pts/%d", &n) == 1)
	    sprintf (o->ut_id, "vt%02x", (n % 256));	/* sysv naming */
	else {
	    print_error ("can't parse tty name \"%s\"", pty);
	    o->ut_id[0] = '\0';	/* entry not made */
	    return;
	}
    }

#if 0
    /* XXX: most likely unnecessary.  could be harmful */
    utmpname (RXVT_REAL_UTMP_FILE);
#endif

    setutent ();		/* XXX: should be unnecessaray */

    STRNCPY (ut.o->ut_id, o->ut_id, sizeof (ut.o->ut_id));
    ut.ut_type = DEAD_PROCESS;
    (void)getutid (&ut);	/* position to entry in utmp file */

/* set up the new entry */
    ut.ut_type = USER_PROCESS;
#ifndef linux
    ut.ut_exit.e_exit = 2;
#endif
    STRNCPY (ut.ut_user, (pwent && pwent->pw_name) ? pwent->pw_name : "?",
	     sizeof (ut.ut_user));
    STRNCPY (ut.o->ut_id, o->ut_id, sizeof (ut.o->ut_id));
    STRNCPY (ut.ut_line, pty, sizeof (ut.ut_line));

#if (defined(HAVE_UTMP_HOST) && ! defined(RXVT_UTMP_AS_UTMPX)) || (defined(HAVE_UTMPX_HOST) && defined(RXVT_UTMP_AS_UTMPX))
    STRNCPY (ut.ut_host, hostname, sizeof (ut.ut_host));
# ifndef linux
    if ((colon = strrchr (ut.ut_host, ':')) != NULL)
	*colon = '\0';
# endif
#endif

/* ut_name is normally the same as ut_user, but .... */
    STRNCPY (ut.ut_name, (pwent && pwent->pw_name) ? pwent->pw_name : "?",
	     sizeof (ut.ut_name));

    ut.ut_pid = getpid ();

#ifdef RXVT_UTMP_AS_UTMPX
    ut.ut_session = getsid (0);
    ut.ut_tv.tv_sec = time (NULL);
    ut.ut_tv.tv_usec = 0;
#else
    ut.ut_time = time (NULL);
#endif				/* HAVE_UTMPX_H */

    pututline (&ut);

#ifdef WTMP_SUPPORT
    update_wtmp (RXVT_WTMP_FILE, &ut);
#endif

    endutent ();		/* close the file */
#endif				/* !USE_SYSV_UTMP */
}
#endif				/* UTMP_SUPPORT */

/* ------------------------------------------------------------------------- */
#ifdef UTMP_SUPPORT
/*
 * remove a utmp entry
 */
/* EXTPROTO */
void            rxvtlib_cleanutent (rxvtlib *o)
{
    UTMP            ut;

#ifndef USE_SYSV_UTMP
    FILE           *fd;

    if (o->ut_id[0] && ((fd = fopen (RXVT_REAL_UTMP_FILE, "r+")) != NULL)) {
	MEMSET (&ut, 0, sizeof (struct utmp));

	fseek (fd, o->utmp_pos, 0);
	fwrite (&ut, sizeof (struct utmp), 1, fd);

	fclose (fd);
    }
#else				/* USE_SYSV_UTMP */
    UTMP           *putmp;

    if (!o->ut_id[0])
	return;			/* entry not made */

#if 0
    /* XXX: most likely unnecessary.  could be harmful */
    utmpname (RXVT_REAL_UTMP_FILE);
#endif
    MEMSET (&ut, 0, sizeof (UTMP));
    STRNCPY (ut.o->ut_id, o->ut_id, sizeof (ut.o->ut_id));
    ut.ut_type = USER_PROCESS;

    setutent ();		/* XXX: should be unnecessaray */

    putmp = getutid (&ut);
    if (!putmp || putmp->ut_pid != getpid ())
	return;

    putmp->ut_type = DEAD_PROCESS;

#ifdef RXVT_UTMP_AS_UTMPX
    putmp->ut_session = getsid (0);
    putmp->ut_tv.tv_sec = time (NULL);
    putmp->ut_tv.tv_usec = 0;
#else				/* HAVE_UTMPX_H */
    putmp->ut_time = time (NULL);
#endif				/* HAVE_UTMPX_H */
    pututline (putmp);

#ifdef WTMP_SUPPORT
    update_wtmp (RXVT_WTMP_FILE, putmp);
#endif

    endutent ();
#endif				/* !USE_SYSV_UTMP */
}
#endif