OpenSolaris_b135/cmd/write/write.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (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 (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/* All Rights Reserved */
/*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include <ctype.h>
#include <string.h>
#include <stdio.h>
#include <signal.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/utsname.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <utmpx.h>
#include <pwd.h>
#include <fcntl.h>
#include <stdarg.h>
#include <locale.h>
#include <stdlib.h>
#include <limits.h>
#include <wctype.h>
#include <errno.h>
#include <syslog.h>
#define TRUE 1
#define FALSE 0
#define FAILURE -1
#define DATE_FMT "%a %b %e %H:%M:%S"
#define UTMP_HACK /* work around until utmpx is world writable */
/*
* DATE-TIME format
* %a abbreviated weekday name
* %b abbreviated month name
* %e day of month
* %H hour - 24 hour clock
* %M minute
* %S second
*
*/
static int permit1(int);
static int permit(char *);
static int readcsi(int, char *, int);
static void setsignals();
static void shellcmd(char *);
static void openfail();
static void eof();
static struct utsname utsn;
static FILE *fp; /* File pointer for receipient's terminal */
static char *rterm, *receipient; /* Pointer to receipient's terminal & name */
static char *thissys;
int
main(int argc, char **argv)
{
int i;
struct utmpx *ubuf;
static struct utmpx self;
char ownname[sizeof (self.ut_user) + 1];
static char rterminal[sizeof ("/dev/") + sizeof (self.ut_line)] =
"/dev/";
extern char *rterm, *receipient;
char *terminal, *ownterminal, *oterminal;
short count;
extern FILE *fp;
char input[134+MB_LEN_MAX];
char *ptr;
time_t tod;
char time_buf[40];
struct passwd *passptr;
char badterm[20][20];
int bad = 0;
uid_t myuid;
char *bp;
int n;
wchar_t wc;
int c;
int newline;
(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
(void) textdomain(TEXT_DOMAIN);
while ((c = getopt(argc, argv, "")) != EOF)
switch (c) {
case '?':
(void) fprintf(stderr, "Usage: write %s\n",
gettext("user_name [terminal]"));
exit(2);
}
myuid = geteuid();
uname(&utsn);
thissys = utsn.nodename;
/* Set "rterm" to location where receipient's terminal will go. */
rterm = &rterminal[sizeof ("/dev/") - 1];
terminal = NULL;
if (--argc <= 0) {
(void) fprintf(stderr, "Usage: write %s\n",
gettext("user_name [terminal]"));
exit(1);
}
else
{
receipient = *++argv;
}
/* Was a terminal name supplied? If so, save it. */
if (--argc > 1) {
(void) fprintf(stderr, "Usage: write %s\n",
gettext("user_name [terminal]"));
exit(1);
} else {
terminal = *++argv;
}
/* One of the standard file descriptors must be attached to a */
/* terminal in "/dev". */
if ((ownterminal = ttyname(fileno(stdin))) == NULL &&
(ownterminal = ttyname(fileno(stdout))) == NULL &&
(ownterminal = ttyname(fileno(stderr))) == NULL) {
(void) fprintf(stderr,
gettext("I cannot determine your terminal name."
" No reply possible.\n"));
ownterminal = "/dev/???";
}
/*
* Set "ownterminal" past the "/dev/" at the beginning of
* the device name.
*/
oterminal = ownterminal + sizeof ("/dev/")-1;
/*
* Scan through the "utmpx" file for your own entry and the
* entry for the person we want to send to.
*/
for (self.ut_pid = 0, count = 0; (ubuf = getutxent()) != NULL; ) {
/* Is this a USER_PROCESS entry? */
if (ubuf->ut_type == USER_PROCESS) {
/* Is it our entry? (ie. The line matches ours?) */
if (strncmp(&ubuf->ut_line[0], oterminal,
sizeof (ubuf->ut_line)) == 0) self = *ubuf;
/* Is this the person we want to send to? */
if (strncmp(receipient, &ubuf->ut_user[0],
sizeof (ubuf->ut_user)) == 0) {
/* If a terminal name was supplied, is this login at the correct */
/* terminal? If not, ignore. If it is right place, copy over the */
/* name. */
if (terminal != NULL) {
if (strncmp(terminal, &ubuf->ut_line[0],
sizeof (ubuf->ut_line)) == 0) {
strlcpy(rterm, &ubuf->ut_line[0],
sizeof (rterminal) - (rterm - rterminal));
if (myuid && !permit(rterminal)) {
bad++;
rterm[0] = '\0';
}
}
}
/* If no terminal was supplied, then take this terminal if no */
/* other terminal has been encountered already. */
else
{
/* If this is the first encounter, copy the string into */
/* "rterminal". */
if (*rterm == '\0') {
strlcpy(rterm, &ubuf->ut_line[0],
sizeof (rterminal) - (rterm - rterminal));
if (myuid && !permit(rterminal)) {
if (bad < 20) {
strlcpy(badterm[bad++], rterm,
sizeof (badterm[bad++]));
}
rterm[0] = '\0';
} else if (bad > 0) {
(void) fprintf(stderr,
gettext(
"%s is logged on more than one place.\n"
"You are connected to \"%s\".\nOther locations are:\n"),
receipient, rterm);
for (i = 0; i < bad; i++)
(void) fprintf(stderr, "%s\n", badterm[i]);
}
}
/* If this is the second terminal, print out the first. In all */
/* cases of multiple terminals, list out all the other terminals */
/* so the user can restart knowing what her/his choices are. */
else if (terminal == NULL) {
if (count == 1 && bad == 0) {
(void) fprintf(stderr,
gettext(
"%s is logged on more than one place.\n"
"You are connected to \"%s\".\nOther locations are:\n"),
receipient, rterm);
}
fwrite(&ubuf->ut_line[0], sizeof (ubuf->ut_line),
1, stderr);
(void) fprintf(stderr, "\n");
}
count++;
} /* End of "else" */
} /* End of "else if (strncmp" */
} /* End of "if (USER_PROCESS" */
} /* End of "for(count=0" */
/* Did we find a place to talk to? If we were looking for a */
/* specific spot and didn't find it, complain and quit. */
if (terminal != NULL && *rterm == '\0') {
if (bad > 0) {
(void) fprintf(stderr, gettext("Permission denied.\n"));
exit(1);
} else {
#ifdef UTMP_HACK
if (strlcat(rterminal, terminal, sizeof (rterminal)) >=
sizeof (rterminal)) {
(void) fprintf(stderr,
gettext("Terminal name too long.\n"));
exit(1);
}
if (self.ut_pid == 0) {
if ((passptr = getpwuid(getuid())) == NULL) {
(void) fprintf(stderr,
gettext("Cannot determine who you are.\n"));
exit(1);
}
(void) strlcpy(&ownname[0], &passptr->pw_name[0],
sizeof (ownname));
} else {
(void) strlcpy(&ownname[0], self.ut_user,
sizeof (self.ut_user));
}
if (!permit(rterminal)) {
(void) fprintf(stderr,
gettext("%s permission denied\n"), terminal);
exit(1);
}
#else
(void) fprintf(stderr, gettext("%s is not at \"%s\".\n"),
receipient, terminal);
exit(1);
#endif /* UTMP_HACK */
}
}
/* If we were just looking for anyplace to talk and didn't find */
/* one, complain and quit. */
/* If permissions prevent us from sending to this person - exit */
else if (*rterm == '\0') {
if (bad > 0)
(void) fprintf(stderr, gettext("Permission denied.\n"));
else
(void) fprintf(stderr,
gettext("%s is not logged on.\n"), receipient);
exit(1);
}
/* Did we find our own entry? */
else if (self.ut_pid == 0) {
/* Use the user id instead of utmp name if the entry in the */
/* utmp file couldn't be found. */
if ((passptr = getpwuid(getuid())) == (struct passwd *)NULL) {
(void) fprintf(stderr,
gettext("Cannot determine who you are.\n"));
exit(1);
}
strncpy(&ownname[0], &passptr->pw_name[0], sizeof (ownname));
}
else
{
strncpy(&ownname[0], self.ut_user, sizeof (self.ut_user));
}
ownname[sizeof (ownname)-1] = '\0';
if (!permit1(1))
(void) fprintf(stderr,
gettext("Warning: You have your terminal set to \"mesg -n\"."
" No reply possible.\n"));
/* Close the utmpx files. */
endutxent();
/* Try to open up the line to the receipient's terminal. */
signal(SIGALRM, openfail);
alarm(5);
fp = fopen(&rterminal[0], "w");
alarm(0);
/* Make sure executed subshell doesn't inherit this fd - close-on-exec */
if (fcntl(fileno(fp), F_SETFD, FD_CLOEXEC) < 0) {
perror("fcntl(F_SETFD)");
exit(1);
}
/* Catch signals SIGHUP, SIGINT, SIGQUIT, and SIGTERM, and send */
/* <EOT> message to receipient before dying away. */
setsignals(eof);
/* Get the time of day, convert it to a string and throw away the */
/* year information at the end of the string. */
time(&tod);
(void) strftime(time_buf, sizeof (time_buf),
dcgettext(NULL, DATE_FMT, LC_TIME), localtime(&tod));
(void) fprintf(fp,
gettext("\n\007\007\007\tMessage from %s on %s (%s) [ %s ] ...\n"),
&ownname[0], thissys, oterminal, time_buf);
fflush(fp);
(void) fprintf(stderr, "\007\007");
/* Get input from user and send to receipient unless it begins */
/* with a !, when it is to be a shell command. */
newline = 1;
while ((i = readcsi(0, &input[0], sizeof (input))) > 0) {
ptr = &input[0];
/* Is this a shell command? */
if ((newline) && (*ptr == '!'))
shellcmd(++ptr);
/* Send line to the receipient. */
else {
if (myuid && !permit1(fileno(fp))) {
(void) fprintf(stderr,
gettext("Can no longer write to %s\n"), rterminal);
break;
}
/*
* All non-printable characters are displayed using a special notation:
* Control characters shall be displayed using the two character
* sequence of ^ (carat) and the ASCII character - decimal 64 greater
* that the character being encoded - eg., a \003 is displayed ^C.
* Characters with the eighth bit set shall be displayed using
* the three or four character meta notation - e.g., \372 is
* displayed M-z and \203 is displayed M-^C.
*/
newline = 0;
for (bp = &input[0]; --i >= 0; bp++) {
if (*bp == '\n') {
newline = 1;
putc('\r', fp);
}
if (*bp == ' ' ||
*bp == '\t' || *bp == '\n' ||
*bp == '\r' || *bp == '\013' ||
*bp == '\007') {
putc(*bp, fp);
} else if (((n = mbtowc(&wc, bp, MB_CUR_MAX)) > 0) &&
iswprint(wc)) {
for (; n > 0; --n, --i, ++bp)
putc(*bp, fp);
bp--, ++i;
} else {
if (!isascii(*bp)) {
fputs("M-", fp);
*bp = toascii(*bp);
}
if (iscntrl(*bp)) {
putc('^', fp);
/* add decimal 64 to the control character */
putc(*bp + 0100, fp);
}
else
putc(*bp, fp);
}
if (*bp == '\n')
fflush(fp);
if (ferror(fp) || feof(fp)) {
printf(gettext(
"\n\007Write failed (%s logged out?)\n"),
receipient);
exit(1);
}
} /* for */
fflush(fp);
} /* else */
} /* while */
/* Since "end of file" received, send <EOT> message to receipient. */
eof();
return (0);
}
static void
setsignals(catch)
void (*catch)();
{
signal(SIGHUP, catch);
signal(SIGINT, catch);
signal(SIGQUIT, catch);
signal(SIGTERM, catch);
}
static void
shellcmd(command)
char *command;
{
register pid_t child;
extern void eof();
if ((child = fork()) == (pid_t)FAILURE)
{
(void) fprintf(stderr,
gettext("Unable to fork. Try again later.\n"));
return;
} else if (child == (pid_t)0) {
/* Reset the signals to the default actions and exec a shell. */
if (setgid(getgid()) < 0)
exit(1);
execl("/usr/bin/sh", "sh", "-c", command, 0);
exit(0);
}
else
{
/* Allow user to type <del> and <quit> without dying during */
/* commands. */
signal(SIGINT, SIG_IGN);
signal(SIGQUIT, SIG_IGN);
/* As parent wait around for user to finish spunoff command. */
while (wait(NULL) != child);
/* Reset the signals to their normal state. */
setsignals(eof);
}
(void) fprintf(stdout, "!\n");
}
static void
openfail()
{
extern char *rterm, *receipient;
(void) fprintf(stderr,
gettext("Timeout trying to open %s's line(%s).\n"),
receipient, rterm);
exit(1);
}
static void
eof()
{
extern FILE *fp;
(void) fprintf(fp, "%s\n", gettext("<EOT>"));
exit(0);
}
/*
* permit: check mode of terminal - if not writable by all disallow writing to
* (even the user him/herself cannot therefore write to their own tty)
*/
static int
permit(term)
char *term;
{
struct stat buf;
int fildes;
if ((fildes = open(term, O_WRONLY|O_NOCTTY)) < 0)
return (0);
/* check if the device really is a tty */
if (!isatty(fildes)) {
(void) fprintf(stderr,
gettext("%s in utmpx is not a tty\n"), term);
openlog("write", 0, LOG_AUTH);
syslog(LOG_CRIT, "%s in utmpx is not a tty\n", term);
closelog();
close(fildes);
return (0);
}
fstat(fildes, &buf);
close(fildes);
return (buf.st_mode & (S_IWGRP|S_IWOTH));
}
/*
* permit1: check mode of terminal - if not writable by all disallow writing
* to (even the user him/herself cannot therefore write to their own tty)
*/
/* this is used with fstat (which is faster than stat) where possible */
static int
permit1(fildes)
int fildes;
{
struct stat buf;
fstat(fildes, &buf);
return (buf.st_mode & (S_IWGRP|S_IWOTH));
}
/*
* Read a string of multi-byte characters from specified file.
* The requested # of bytes are attempted to read.
* readcsi() tries to complete the last multibyte character
* by calling mbtowc(), if the leftovers form mbtowc(),
* left the last char imcomplete, moves into delta_spool to use later,
* next called. The caller must reserve
* nbytereq+MB_LEN_MAX bytes for the buffer. When the attempt
* is failed, it truncate the last char.
* Returns the number of bytes that constitutes the valid multi-byte characters.
*/
static int readcsi(d, buf, nbytereq)
int d;
char *buf;
int nbytereq;
{
static char delta_pool[MB_LEN_MAX * 2];
static char delta_size;
char *cp, *nextp, *lastp;
int n;
int r_size;
if (delta_size) {
memcpy(buf, delta_pool, delta_size);
cp = buf + delta_size;
r_size = nbytereq - delta_size;
} else {
cp = buf;
r_size = nbytereq;
}
if ((r_size = read(d, cp, r_size)) < 0)
r_size = 0;
if ((n = delta_size + r_size) <= 0)
return (n);
/* Scan the result to test the completeness of each EUC characters. */
nextp = buf;
lastp = buf + n; /* Lastp points to the first junk byte. */
while (nextp < lastp) {
if ((n = (lastp - nextp)) > (unsigned int)MB_CUR_MAX)
n = (unsigned int)MB_CUR_MAX;
if ((n = mbtowc((wchar_t *)0, nextp, n)) <= 0) {
if ((lastp - nextp) < (unsigned int)MB_CUR_MAX)
break;
n = 1;
}
nextp += n;
}
/* How many bytes needed to complete the last char? */
delta_size = lastp - nextp;
if (delta_size > 0) {
if (nextp[delta_size - 1] != '\n') {
/* the remnants store into delta_pool */
memcpy(delta_pool, nextp, delta_size);
} else
nextp = lastp;
}
*nextp = '\0';
return (nextp-buf); /* Return # of bytes. */
}