OpenSolaris_b135/cmd/ttymon/tmutmp.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
/*	  All Rights Reserved  	*/

/*
 * University Copyright- Copyright (c) 1982, 1986, 1988
 * The Regents of the University of California
 * All Rights Reserved
 *
 * University Acknowledgment- Portions of this document are derived from
 * software developed by the University of California, Berkeley, and its
 * contributors.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include	<unistd.h>
#include	<stdlib.h>
#include	<stdio.h>
#include	<fcntl.h>
#include	<sys/types.h>
#include	<sys/wait.h>
#include	<string.h>
#include	<memory.h>
#include	<utmpx.h>
#include	<security/pam_appl.h>

#include	"sac.h"
#include	"tmextern.h"

extern	char	*lastname();

/*
 * account - create a utmpx record for service
 *
 */

int
account(line)
char	*line;
{
	struct utmpx utmpx;			/* prototype utmpx entry */
	struct utmpx *up = &utmpx;		/* and a pointer to it */

	(void) memset(up, '\0', sizeof (utmpx));
	up->ut_user[0] = '.';
	(void) strncpy(&up->ut_user[1], Tag, sizeof (up->ut_user)-1);
	(void) strncpy(up->ut_line, lastname(line), sizeof (up->ut_line));
	up->ut_pid = getpid();
	up->ut_type = USER_PROCESS;
	up->ut_id[0] = 't';
	up->ut_id[1] = 'm';
	up->ut_id[2] = SC_WILDC;
	up->ut_id[3] = SC_WILDC;
	up->ut_exit.e_termination = 0;
	up->ut_exit.e_exit = 0;
	(void) time(&up->ut_tv.tv_sec);
	if (makeutx(up) == NULL) {
		log("makeutx for pid %d failed", up->ut_pid);
		return (-1);
	}
	return (0);
}

/*
 * checkut_line	- check if a login is active on the requested device
 */
int
checkut_line(char *line)
{
	struct utmpx *u;
	char buf[33], ttyn[33];
	int rvalue = 0;
	pid_t ownpid = getpid();

	(void) strncpy(buf, lastname(line), sizeof (u->ut_line));
	buf[sizeof (u->ut_line)] = '\0';

	setutxent();
	while ((u = getutxent()) != NULL) {
		if (u->ut_pid == ownpid) {
			if (u->ut_type == USER_PROCESS) {
				strncpy(ttyn, u->ut_line, sizeof (u->ut_line));
				ttyn[sizeof (u->ut_line)] = '\0';
				if (strcmp(buf, ttyn) == 0) {
					rvalue = 1;
					break;
				}
			}
		}
	}
	endutxent();

	return (rvalue);
}


void
cleanut(pid, status)
	pid_t	pid;
	int	status;
{
	pam_handle_t *pamh;
	struct utmpx *up;
	struct utmpx ut;
	char user[33], ttyn[33], rhost[258];

	setutxent();
	while (up = getutxent()) {
		if (up->ut_pid == pid) {
			if (up->ut_type == DEAD_PROCESS) {
				/* Cleaned up elsewhere. */
				break;
			}

			strncpy(user, up->ut_user, sizeof (up->ut_user));
			user[sizeof (up->ut_user)] = '\0';
			strncpy(ttyn, up->ut_line, sizeof (up->ut_line));
			ttyn[sizeof (up->ut_line)] = '\0';
			strncpy(rhost, up->ut_host, sizeof (up->ut_host));
			rhost[sizeof (up->ut_host)] = '\0';

			if (pam_start("ttymon", user, NULL, &pamh)
							== PAM_SUCCESS) {
				(void) pam_set_item(pamh, PAM_TTY, ttyn);
				(void) pam_set_item(pamh, PAM_RHOST, rhost);
				(void) pam_close_session(pamh, 0);
				(void) pam_end(pamh, PAM_SUCCESS);
			}


			up->ut_type = DEAD_PROCESS;
			up->ut_exit.e_termination = WTERMSIG(status);
			up->ut_exit.e_exit = WEXITSTATUS(status);
			(void) time(&up->ut_tv.tv_sec);

			if (modutx(up) == NULL) {
				/*
				 * Since modutx failed we'll
				 * write out the new entry
				 * ourselves.
				 */
				(void) pututxline(up);
				updwtmpx("wtmpx", up);
			}
			break;
		}
	}
	endutxent();
}

/*
 * getty_account	- This is a copy of old getty account routine.
 *			- This is only called if ttymon is invoked as getty.
 *			- It tries to find its own INIT_PROCESS entry in utmpx
 *			- and change it to LOGIN_PROCESS
 */
void
getty_account(line)
char *line;
{
	pid_t ownpid;
	struct utmpx *u;

	ownpid = getpid();

	setutxent();
	while ((u = getutxent()) != NULL) {

		if (u->ut_type == INIT_PROCESS && u->ut_pid == ownpid) {
			(void) strncpy(u->ut_line, lastname(line),
				sizeof (u->ut_line));
			(void) strncpy(u->ut_user, "LOGIN",
					sizeof (u->ut_user));
			u->ut_type = LOGIN_PROCESS;

			/* Write out the updated entry. */
			(void) pututxline(u);
			break;
		}
	}

	/* create wtmpx entry also */
	if (u != NULL)
		updwtmpx("/etc/wtmpx", u);

	endutxent();
}