usr/src/cmd/write/write.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
  23 /*        All Rights Reserved   */
  24
  25
  26 /*
  27  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
  28  * Use is subject to license terms.
  29  */
  30
  31 #pragma ident   "%Z%%M% %I%     %E% SMI"
  32
  33 #include        <ctype.h>
  34 #include        <string.h>
  35 #include        <stdio.h>
  36 #include        <signal.h>
  37 #include        <sys/wait.h>
  38 #include        <sys/types.h>
  39 #include        <sys/stat.h>
  40 #include        <sys/utsname.h>
  41 #include        <stdlib.h>
  42 #include        <unistd.h>
  43 #include        <time.h>
  44 #include        <utmpx.h>
  45 #include        <pwd.h>
  46 #include        <fcntl.h>
  47 #include        <stdarg.h>
  48 #include        <locale.h>
  49 #include        <stdlib.h>
  50 #include        <limits.h>
  51 #include        <wctype.h>
  52 #include        <errno.h>
  53 #include        <syslog.h>
  54
  55 #define         TRUE    1
  56 #define         FALSE   0
  57 #define         FAILURE -1
  58 #define         DATE_FMT        "%a %b %e %H:%M:%S"
  59 #define         UTMP_HACK  /* work around until utmpx is world writable */
  60 /*
  61  *      DATE-TIME format
  62  *  %a  abbreviated weekday name
  63  *  %b  abbreviated month name
  64  *  %e  day of month
  65  *  %H  hour - 24 hour clock
  66  *  %M  minute
  67  *  %S  second
  68  *
  69  */
  70
  71 static int permit1(int);
  72 static int permit(char *);
  73 static int readcsi(int, char *, int);
  74 static void setsignals();
  75 static void shellcmd(char *);
  76 static void openfail();
  77 static void eof();
  78
  79 static struct   utsname utsn;
  80
  81 static FILE     *fp;    /* File pointer for receipient's terminal */
  82 static char *rterm, *receipient; /* Pointer to receipient's terminal & name */
  83 static char *thissys;
  84
  85 int
  86 main(int argc, char **argv)
  87 {
  88         int i;
  89         struct utmpx *ubuf;
  90         static struct utmpx self;
  91         char ownname[sizeof (self.ut_user) + 1];
  92         static char rterminal[sizeof ("/dev/") + sizeof (self.ut_line)] =
  93             "/dev/";
  94         extern char *rterm, *receipient;
  95         char *terminal, *ownterminal, *oterminal;
  96         short count;
  97         extern FILE *fp;
  98         char input[134+MB_LEN_MAX];
  99         char *ptr;
 100         time_t tod;
 101         char time_buf[40];
 102         struct passwd *passptr;
 103         char badterm[20][20];
 104         int bad = 0;
 105         uid_t   myuid;
 106         char *bp;
 107         int n;
 108         wchar_t wc;
 109         int c;
 110         int newline;
 111
 112         (void) setlocale(LC_ALL, "");
 113 #if !defined(TEXT_DOMAIN)
 114 #define TEXT_DOMAIN "SYS_TEST"
 115 #endif
 116         (void) textdomain(TEXT_DOMAIN);
 117
 118         while ((c = getopt(argc, argv, "")) != EOF)
 119                 switch (c) {
 120                         case '?':
 121                                 (void) fprintf(stderr, "Usage: write %s\n",
 122                                 gettext("user_name [terminal]"));
 123                                 exit(2);
 124                 }
 125         myuid = geteuid();
 126         uname(&utsn);
 127         thissys = utsn.nodename;
 128
 129 /*      Set "rterm" to location where receipient's terminal will go.    */
 130
 131         rterm = &rterminal[sizeof ("/dev/") - 1];
 132         terminal = NULL;
 133
 134         if (--argc <= 0) {
 135             (void) fprintf(stderr, "Usage: write %s\n",
 136                 gettext("user_name [terminal]"));
 137             exit(1);
 138             }
 139         else
 140             {
 141             receipient = *++argv;
 142             }
 143
 144 /*      Was a terminal name supplied?  If so, save it.                  */
 145
 146         if (--argc > 1) {
 147             (void) fprintf(stderr, "Usage: write %s\n",
 148                 gettext("user_name [terminal]"));
 149             exit(1);
 150         } else {
 151             terminal = *++argv;
 152         }
 153
 154 /*      One of the standard file descriptors must be attached to a      */
 155 /*      terminal in "/dev".                                             */
 156
 157         if ((ownterminal = ttyname(fileno(stdin))) == NULL &&
 158             (ownterminal = ttyname(fileno(stdout))) == NULL &&
 159             (ownterminal = ttyname(fileno(stderr))) == NULL) {
 160                 (void) fprintf(stderr,
 161                         gettext("I cannot determine your terminal name."
 162                                         " No reply possible.\n"));
 163                 ownterminal = "/dev/???";
 164         }
 165
 166         /*
 167          * Set "ownterminal" past the "/dev/" at the beginning of
 168          * the device name.
 169          */
 170         oterminal = ownterminal + sizeof ("/dev/")-1;
 171
 172         /*
 173          * Scan through the "utmpx" file for your own entry and the
 174          * entry for the person we want to send to.
 175          */
 176         for (self.ut_pid = 0, count = 0; (ubuf = getutxent()) != NULL; ) {
 177         /* Is this a USER_PROCESS entry? */
 178
 179             if (ubuf->ut_type == USER_PROCESS) {
 180 /*      Is it our entry?  (ie.  The line matches ours?)                 */
 181
 182                 if (strncmp(&ubuf->ut_line[0], oterminal,
 183                     sizeof (ubuf->ut_line)) == 0) self = *ubuf;
 184
 185 /*      Is this the person we want to send to?                          */
 186
 187                 if (strncmp(receipient, &ubuf->ut_user[0],
 188                     sizeof (ubuf->ut_user)) == 0) {
 189 /*      If a terminal name was supplied, is this login at the correct   */
 190 /*      terminal?  If not, ignore.  If it is right place, copy over the */
 191 /*      name.                                                           */
 192
 193                     if (terminal != NULL) {
 194                         if (strncmp(terminal, &ubuf->ut_line[0],
 195                             sizeof (ubuf->ut_line)) == 0) {
 196                             strlcpy(rterm, &ubuf->ut_line[0],
 197                                 sizeof (rterminal) - (rterm - rterminal));
 198                             if (myuid && !permit(rterminal)) {
 199                                 bad++;
 200                                 rterm[0] = '\0';
 201                             }
 202                             }
 203                     }
 204
 205 /*      If no terminal was supplied, then take this terminal if no      */
 206 /*      other terminal has been encountered already.                    */
 207
 208                     else
 209                     {
 210 /*      If this is the first encounter, copy the string into            */
 211 /*      "rterminal".                                                    */
 212
 213                         if (*rterm == '\0') {
 214                             strlcpy(rterm, &ubuf->ut_line[0],
 215                                 sizeof (rterminal) - (rterm - rterminal));
 216                             if (myuid && !permit(rterminal)) {
 217                                 if (bad < 20) {
 218                                         strlcpy(badterm[bad++], rterm,
 219                                             sizeof (badterm[bad++]));
 220                                 }
 221                                 rterm[0] = '\0';
 222                             } else if (bad > 0) {
 223                                 (void) fprintf(stderr,
 224                                 gettext(
 225                                 "%s is logged on more than one place.\n"
 226         "You are connected to \"%s\".\nOther locations are:\n"),
 227                                     receipient, rterm);
 228                                 for (i = 0; i < bad; i++)
 229                                     (void) fprintf(stderr, "%s\n", badterm[i]);
 230                             }
 231                         }
 232
 233 /*      If this is the second terminal, print out the first.  In all    */
 234 /*      cases of multiple terminals, list out all the other terminals   */
 235 /*      so the user can restart knowing what her/his choices are.       */
 236
 237                         else if (terminal == NULL) {
 238                             if (count == 1 && bad == 0) {
 239                                 (void) fprintf(stderr,
 240                                 gettext(
 241                                 "%s is logged on more than one place.\n"
 242         "You are connected to \"%s\".\nOther locations are:\n"),
 243                                     receipient, rterm);
 244                             }
 245                             fwrite(&ubuf->ut_line[0], sizeof (ubuf->ut_line),
 246                                 1, stderr);
 247                             (void) fprintf(stderr, "\n");
 248                             }
 249
 250                         count++;
 251                     }                   /* End of "else" */
 252                     }                   /* End of "else if (strncmp" */
 253             }                   /* End of "if (USER_PROCESS" */
 254             }           /* End of "for(count=0" */
 255
 256 /*      Did we find a place to talk to?  If we were looking for a       */
 257 /*      specific spot and didn't find it, complain and quit.            */
 258
 259         if (terminal != NULL && *rterm == '\0') {
 260             if (bad > 0) {
 261                 (void) fprintf(stderr, gettext("Permission denied.\n"));
 262                 exit(1);
 263                 } else {
 264 #ifdef UTMP_HACK
 265                 if (strlcat(rterminal, terminal, sizeof (rterminal)) >=
 266                     sizeof (rterminal)) {
 267                         (void) fprintf(stderr,
 268                             gettext("Terminal name too long.\n"));
 269                         exit(1);
 270                 }
 271                 if (self.ut_pid == 0) {
 272                         if ((passptr = getpwuid(getuid())) == NULL) {
 273                             (void) fprintf(stderr,
 274                                 gettext("Cannot determine who you are.\n"));
 275                             exit(1);
 276                     }
 277                     (void) strlcpy(&ownname[0], &passptr->pw_name[0],
 278                         sizeof (ownname));
 279                 } else {
 280                         (void) strlcpy(&ownname[0], self.ut_user,
 281                             sizeof (self.ut_user));
 282                 }
 283                 if (!permit(rterminal)) {
 284                         (void) fprintf(stderr,
 285                                 gettext("%s permission denied\n"), terminal);
 286                         exit(1);
 287                 }
 288 #else
 289                 (void) fprintf(stderr, gettext("%s is not at \"%s\".\n"),
 290                         receipient, terminal);
 291                 exit(1);
 292 #endif  /* UTMP_HACK */
 293             }
 294             }
 295
 296 /*      If we were just looking for anyplace to talk and didn't find    */
 297 /*      one, complain and quit.                                         */
 298 /*      If permissions prevent us from sending to this person - exit    */
 299
 300         else if (*rterm == '\0') {
 301             if (bad > 0)
 302                 (void) fprintf(stderr, gettext("Permission denied.\n"));
 303             else
 304                 (void) fprintf(stderr,
 305                         gettext("%s is not logged on.\n"), receipient);
 306             exit(1);
 307             }
 308
 309 /*      Did we find our own entry?                                      */
 310
 311         else if (self.ut_pid == 0) {
 312 /*      Use the user id instead of utmp name if the entry in the        */
 313 /*      utmp file couldn't be found.                                    */
 314
 315             if ((passptr = getpwuid(getuid())) == (struct passwd *)NULL) {
 316                 (void) fprintf(stderr,
 317                         gettext("Cannot determine who you are.\n"));
 318                 exit(1);
 319             }
 320             strncpy(&ownname[0], &passptr->pw_name[0], sizeof (ownname));
 321             }
 322         else
 323             {
 324             strncpy(&ownname[0], self.ut_user, sizeof (self.ut_user));
 325             }
 326         ownname[sizeof (ownname)-1] = '\0';
 327
 328         if (!permit1(1))
 329                 (void) fprintf(stderr,
 330                 gettext("Warning: You have your terminal set to \"mesg -n\"."
 331                     " No reply possible.\n"));
 332 /*      Close the utmpx files.                                          */
 333
 334         endutxent();
 335
 336 /*      Try to open up the line to the receipient's terminal.           */
 337
 338         signal(SIGALRM, openfail);
 339         alarm(5);
 340         fp = fopen(&rterminal[0], "w");
 341         alarm(0);
 342
 343 /*      Make sure executed subshell doesn't inherit this fd - close-on-exec */
 344
 345         if (fcntl(fileno(fp), F_SETFD, FD_CLOEXEC) < 0)  {
 346                 perror("fcntl(F_SETFD)");
 347                 exit(1);
 348         }
 349
 350 /*      Catch signals SIGHUP, SIGINT, SIGQUIT, and SIGTERM, and send    */
 351 /*      <EOT> message to receipient before dying away.                  */
 352
 353         setsignals(eof);
 354
 355 /*      Get the time of day, convert it to a string and throw away the  */
 356 /*      year information at the end of the string.                      */
 357
 358         time(&tod);
 359         (void) strftime(time_buf, sizeof (time_buf),
 360             dcgettext(NULL, DATE_FMT, LC_TIME), localtime(&tod));
 361
 362         (void) fprintf(fp,
 363         gettext("\n\007\007\007\tMessage from %s on %s (%s) [ %s ] ...\n"),
 364             &ownname[0], thissys, oterminal, time_buf);
 365         fflush(fp);
 366         (void) fprintf(stderr, "\007\007");
 367
 368 /*      Get input from user and send to receipient unless it begins     */
 369 /*      with a !, when it is to be a shell command.                     */
 370         newline = 1;
 371         while ((i = readcsi(0, &input[0], sizeof (input))) > 0) {
 372                 ptr = &input[0];
 373 /*      Is this a shell command?                                        */
 374
 375                 if ((newline) && (*ptr == '!'))
 376                         shellcmd(++ptr);
 377
 378 /*      Send line to the receipient.                                    */
 379
 380                 else {
 381                         if (myuid && !permit1(fileno(fp))) {
 382                                 (void) fprintf(stderr,
 383                         gettext("Can no longer write to %s\n"), rterminal);
 384                                 break;
 385                         }
 386
 387 /*
 388  * All non-printable characters are displayed using a special notation:
 389  * Control characters  shall be displayed using the two character
 390  * sequence of ^ (carat) and the ASCII character - decimal 64 greater
 391  * that the character being encoded - eg., a \003 is displayed ^C.
 392  * Characters with the eighth bit set shall be displayed using
 393  * the three or four character meta notation - e.g., \372 is
 394  * displayed M-z and \203 is displayed M-^C.
 395  */
 396
 397                         newline = 0;
 398                         for (bp = &input[0]; --i >= 0; bp++) {
 399                         if (*bp == '\n') {
 400                                 newline = 1;
 401                                 putc('\r', fp);
 402                         }
 403                         if (*bp == ' ' ||
 404                                  *bp == '\t' || *bp == '\n' ||
 405                                  *bp == '\r' || *bp == '\013' ||
 406                                  *bp == '\007') {
 407                                         putc(*bp, fp);
 408                         } else if (((n = mbtowc(&wc, bp, MB_CUR_MAX)) > 0) &&
 409                                 iswprint(wc)) {
 410                                 for (; n > 0; --n, --i, ++bp)
 411                                         putc(*bp, fp);
 412                                 bp--, ++i;
 413                         } else {
 414                                 if (!isascii(*bp)) {
 415                                         fputs("M-", fp);
 416                                         *bp = toascii(*bp);
 417                                 }
 418                                 if (iscntrl(*bp)) {
 419                                         putc('^', fp);
 420 /*      add decimal 64 to the control character                 */
 421                                         putc(*bp + 0100, fp);
 422                                 }
 423                                 else
 424                                         putc(*bp, fp);
 425                         }
 426                         if (*bp == '\n')
 427                                 fflush(fp);
 428                         if (ferror(fp) || feof(fp)) {
 429                                 printf(gettext(
 430                                 "\n\007Write failed (%s logged out?)\n"),
 431                                 receipient);
 432                                 exit(1);
 433                         }
 434                         } /* for */
 435                         fflush(fp);
 436         } /* else */
 437         } /* while */
 438
 439 /*      Since "end of file" received, send <EOT> message to receipient. */
 440
 441         eof();
 442         return (0);
 443 }
 444
 445
 446 static void
 447 setsignals(catch)
 448 void (*catch)();
 449 {
 450         signal(SIGHUP, catch);
 451         signal(SIGINT, catch);
 452         signal(SIGQUIT, catch);
 453         signal(SIGTERM, catch);
 454 }
 455
 456
 457 static void
 458 shellcmd(command)
 459 char *command;
 460 {
 461         register pid_t child;
 462         extern void eof();
 463
 464         if ((child = fork()) == (pid_t)FAILURE)
 465             {
 466             (void) fprintf(stderr,
 467             gettext("Unable to fork.  Try again later.\n"));
 468             return;
 469             } else if (child == (pid_t)0) {
 470 /*      Reset the signals to the default actions and exec a shell.      */
 471
 472             if (setgid(getgid()) < 0)
 473                 exit(1);
 474             execl("/usr/bin/sh", "sh", "-c", command, 0);
 475             exit(0);
 476             }
 477         else
 478             {
 479 /*      Allow user to type <del> and <quit> without dying during        */
 480 /*      commands.                                                       */
 481
 482             signal(SIGINT, SIG_IGN);
 483             signal(SIGQUIT, SIG_IGN);
 484
 485 /*      As parent wait around for user to finish spunoff command.       */
 486
 487             while (wait(NULL) != child);
 488
 489 /*      Reset the signals to their normal state.                        */
 490
 491             setsignals(eof);
 492             }
 493         (void) fprintf(stdout, "!\n");
 494 }
 495
 496 static void
 497 openfail()
 498 {
 499         extern char *rterm, *receipient;
 500
 501         (void) fprintf(stderr,
 502                 gettext("Timeout trying to open %s's line(%s).\n"),
 503             receipient, rterm);
 504         exit(1);
 505 }
 506
 507 static void
 508 eof()
 509 {
 510         extern FILE *fp;
 511
 512         (void) fprintf(fp, "%s\n", gettext("<EOT>"));
 513         exit(0);
 514 }
 515
 516 /*
 517  * permit: check mode of terminal - if not writable by all disallow writing to
 518  * (even the user him/herself cannot therefore write to their own tty)
 519  */
 520
 521 static int
 522 permit(term)
 523 char *term;
 524 {
 525         struct stat buf;
 526         int fildes;
 527
 528         if ((fildes = open(term, O_WRONLY|O_NOCTTY)) < 0)
 529                 return (0);
 530         /* check if the device really is a tty */
 531         if (!isatty(fildes)) {
 532                 (void) fprintf(stderr,
 533                     gettext("%s in utmpx is not a tty\n"), term);
 534                 openlog("write", 0, LOG_AUTH);
 535                 syslog(LOG_CRIT, "%s in utmpx is not a tty\n", term);
 536                 closelog();
 537                 close(fildes);
 538                 return (0);
 539         }
 540         fstat(fildes, &buf);
 541         close(fildes);
 542         return (buf.st_mode & (S_IWGRP|S_IWOTH));
 543 }
 544
 545
 546
 547 /*
 548  * permit1: check mode of terminal - if not writable by all disallow writing
 549  * to (even the user him/herself cannot therefore write to their own tty)
 550  */
 551
 552 /* this is used with fstat (which is faster than stat) where possible */
 553
 554 static int
 555 permit1(fildes)
 556 int fildes;
 557 {
 558         struct stat buf;
 559
 560         fstat(fildes, &buf);
 561         return (buf.st_mode & (S_IWGRP|S_IWOTH));
 562 }
 563
 564
 565 /*
 566  * Read a string of multi-byte characters from specified file.
 567  * The requested # of bytes are attempted to read.
 568  * readcsi() tries to complete the last multibyte character
 569  * by calling mbtowc(), if the leftovers form mbtowc(),
 570  * left the last char imcomplete, moves into delta_spool to use later,
 571  * next called. The caller must reserve
 572  * nbytereq+MB_LEN_MAX bytes for the buffer.  When the attempt
 573  * is failed, it truncate the last char.
 574  * Returns the number of bytes that constitutes the valid multi-byte characters.
 575  */
 576
 577
 578 static int readcsi(d, buf, nbytereq)
 579 int     d;
 580 char    *buf;
 581 int     nbytereq;
 582 {
 583         static char     delta_pool[MB_LEN_MAX * 2];
 584         static char     delta_size;
 585         char    *cp, *nextp, *lastp;
 586         int     n;
 587         int     r_size;
 588
 589         if (delta_size) {
 590                 memcpy(buf, delta_pool, delta_size);
 591                 cp = buf + delta_size;
 592                 r_size = nbytereq - delta_size;
 593         } else {
 594                 cp = buf;
 595                 r_size = nbytereq;
 596         }
 597
 598         if ((r_size = read(d, cp, r_size)) < 0)
 599                 r_size = 0;
 600         if ((n = delta_size + r_size) <= 0)
 601                 return (n);
 602
 603         /* Scan the result to test the completeness of each EUC characters. */
 604         nextp = buf;
 605         lastp = buf + n; /* Lastp points to the first junk byte. */
 606         while (nextp < lastp) {
 607                 if ((n = (lastp - nextp)) > (unsigned int)MB_CUR_MAX)
 608                         n = (unsigned int)MB_CUR_MAX;
 609                 if ((n = mbtowc((wchar_t *)0, nextp, n)) <= 0) {
 610                         if ((lastp - nextp) < (unsigned int)MB_CUR_MAX)
 611                                 break;
 612                         n = 1;
 613                 }
 614                 nextp += n;
 615         }
 616         /* How many bytes needed to complete the last char? */
 617         delta_size = lastp - nextp;
 618         if (delta_size > 0) {
 619                 if (nextp[delta_size - 1] != '\n') {
 620                         /* the remnants store into delta_pool */
 621                         memcpy(delta_pool, nextp, delta_size);
 622                 } else
 623                         nextp = lastp;
 624         }
 625         *nextp = '\0';
 626         return (nextp-buf); /* Return # of bytes. */
 627 }