term-utils/write.c

   1 /*
   2  * Copyright (c) 1989, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Jef Poskanzer and Craig Leres of the Lawrence Berkeley Laboratory.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by the University of
  19  *      California, Berkeley and its contributors.
  20  * 4. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  *
  36  * Modified for Linux, Mon Mar  8 18:16:24 1993, faith@cs.unc.edu
  37  * Wed Jun 22 21:41:56 1994, faith@cs.unc.edu:
  38  *      Added fix from Mike Grupenhoff (kashmir@umiacs.umd.edu)
  39  * Mon Jul  1 17:01:39 MET DST 1996, janl@math.uio.no:
  40  *      - Added fix from David.Chapell@mail.trincoll.edu enabling daemons
  41  *        to use write.
  42  *      - ANSIed it since I was working on it anyway.
  43  * 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
  44  * - added Native Language Support
  45  *
  46  */
  47
  48 #include <errno.h>
  49 #include <getopt.h>
  50 #include <paths.h>
  51 #include <pwd.h>
  52 #include <signal.h>
  53 #include <stdio.h>
  54 #include <stdlib.h>
  55 #include <string.h>
  56 #include <sys/param.h>
  57 #include <sys/stat.h>
  58 #include <time.h>
  59 #include <unistd.h>
  60 #include <utmpx.h>
  61
  62 #include "c.h"
  63 #include "carefulputc.h"
  64 #include "closestream.h"
  65 #include "nls.h"
  66 #include "strutils.h"
  67 #include "ttyutils.h"
  68 #include "xalloc.h"
  69
  70 static sig_atomic_t signal_received = 0;
  71
  72 struct write_control {
  73         uid_t src_uid;
  74         const char *src_login;
  75         const char *src_tty_path;
  76         const char *src_tty_name;
  77         const char *dst_login;
  78         char *dst_tty_path;
  79         const char *dst_tty_name;
  80 };
  81
  82 static void __attribute__((__noreturn__)) usage(void)
  83 {
  84         FILE *out = stdout;
  85         fputs(USAGE_HEADER, out);
  86         fprintf(out,
  87               _(" %s [options] <user> [<ttyname>]\n"),
  88               program_invocation_short_name);
  89
  90         fputs(USAGE_SEPARATOR, out);
  91         fputs(_("Send a message to another user.\n"), out);
  92
  93         fputs(USAGE_OPTIONS, out);
  94         printf(USAGE_HELP_OPTIONS(16));
  95         printf(USAGE_MAN_TAIL("write(1)"));
  96         exit(EXIT_SUCCESS);
  97 }
  98
  99 /*
 100  * check_tty - check that a terminal exists, and get the message bit
 101  *     and the access time
 102  */
 103 static int check_tty(const char *tty, int *tty_writeable, time_t *tty_atime, int showerror)
 104 {
 105         struct stat s;
 106
 107         if (stat(tty, &s) < 0) {
 108                 if (showerror)
 109                         warn("%s", tty);
 110                 return 1;
 111         }
 112         if (getuid() == 0)      /* root can always write */
 113                 *tty_writeable = 1;
 114         else {
 115                 if (getegid() != s.st_gid) {
 116                         warnx(_("effective gid does not match group of %s"), tty);
 117                         return 1;
 118                 }
 119                 *tty_writeable = s.st_mode & S_IWGRP;
 120         }
 121         if (tty_atime)
 122                 *tty_atime = s.st_atime;
 123         return 0;
 124 }
 125
 126 /*
 127  * check_utmp - checks that the given user is actually logged in on
 128  *     the given tty
 129  */
 130 static int check_utmp(const struct write_control *ctl)
 131 {
 132         struct utmpx *u;
 133         int res = 1;
 134
 135         utmpxname(_PATH_UTMP);
 136         setutxent();
 137
 138         while ((u = getutxent())) {
 139                 if (strncmp(ctl->dst_login, u->ut_user, sizeof(u->ut_user)) == 0 &&
 140                     strncmp(ctl->dst_tty_name, u->ut_line, sizeof(u->ut_line)) == 0) {
 141                         res = 0;
 142                         break;
 143                 }
 144         }
 145
 146         endutxent();
 147         return res;
 148 }
 149
 150 /*
 151  * search_utmp - search utmp for the "best" terminal to write to
 152  *
 153  * Ignores terminals with messages disabled, and of the rest, returns
 154  * the one with the most recent access time.  Returns as value the number
 155  * of the user's terminals with messages enabled, or -1 if the user is
 156  * not logged in at all.
 157  *
 158  * Special case for writing to yourself - ignore the terminal you're
 159  * writing from, unless that's the only terminal with messages enabled.
 160  */
 161 static void search_utmp(struct write_control *ctl)
 162 {
 163         struct utmpx *u;
 164         time_t best_atime = 0, tty_atime;
 165         int num_ttys = 0, valid_ttys = 0, tty_writeable = 0, user_is_me = 0;
 166         char path[sizeof(u->ut_line) + 6];
 167
 168         utmpxname(_PATH_UTMP);
 169         setutxent();
 170
 171         while ((u = getutxent())) {
 172                 if (strncmp(ctl->dst_login, u->ut_user, sizeof(u->ut_user)) != 0)
 173                         continue;
 174                 num_ttys++;
 175                 sprintf(path, "/dev/%s", u->ut_line);
 176                 if (check_tty(path, &tty_writeable, &tty_atime, 0))
 177                         /* bad term? skip */
 178                         continue;
 179                 if (ctl->src_uid && !tty_writeable)
 180                         /* skip ttys with msgs off */
 181                         continue;
 182                 if (strcmp(u->ut_line, ctl->src_tty_name) == 0) {
 183                         user_is_me = 1;
 184                         /* don't write to yourself */
 185                         continue;
 186                 }
 187                 if (u->ut_type != USER_PROCESS)
 188                         /* it's not a valid entry */
 189                         continue;
 190                 valid_ttys++;
 191                 if (best_atime < tty_atime) {
 192                         best_atime = tty_atime;
 193                         free(ctl->dst_tty_path);
 194                         ctl->dst_tty_path = xstrdup(path);
 195                         ctl->dst_tty_name = ctl->dst_tty_path + 5;
 196                 }
 197         }
 198
 199         endutxent();
 200         if (num_ttys == 0)
 201                 errx(EXIT_FAILURE, _("%s is not logged in"), ctl->dst_login);
 202         if (valid_ttys == 0) {
 203                 if (user_is_me) {
 204                         /* ok, so write to yourself! */
 205                         if (!ctl->src_tty_path)
 206                                 errx(EXIT_FAILURE, _("can't find your tty's name"));
 207                         ctl->dst_tty_path = xstrdup(ctl->src_tty_path);
 208                         ctl->dst_tty_name = ctl->dst_tty_path + 5;
 209                         return;
 210                 }
 211                 errx(EXIT_FAILURE, _("%s has messages disabled"), ctl->dst_login);
 212         }
 213         if (1 < valid_ttys)
 214                 warnx(_("%s is logged in more than once; writing to %s"),
 215                       ctl->dst_login, ctl->dst_tty_name);
 216 }
 217
 218 /*
 219  * signal_handler - cause write loop to exit
 220  */
 221 static void signal_handler(int signo)
 222 {
 223         signal_received = signo;
 224 }
 225
 226 /*
 227  * write_line - like fputs(), but makes control characters visible and
 228  *     turns \n into \r\n.
 229  */
 230 static void write_line(char *s)
 231 {
 232         while (*s) {
 233                 const int c = *s++;
 234
 235                 if ((c == '\n' && fputc_careful('\r', stdout, '^') == EOF)
 236                     || fputc_careful(c, stdout, '^') == EOF)
 237                         err(EXIT_FAILURE, _("carefulputc failed"));
 238         }
 239 }
 240
 241 /*
 242  * do_write - actually make the connection
 243  */
 244 static void do_write(const struct write_control *ctl)
 245 {
 246         char *login, *pwuid;
 247         struct passwd *pwd;
 248         time_t now;
 249         struct tm *tm;
 250         char *host, line[512];
 251         struct sigaction sigact;
 252
 253         /* Determine our login name(s) before the we reopen() stdout */
 254         if ((pwd = getpwuid(ctl->src_uid)) != NULL)
 255                 pwuid = pwd->pw_name;
 256         else
 257                 pwuid = "???";
 258         if ((login = getlogin()) == NULL)
 259                 login = pwuid;
 260
 261         if ((freopen(ctl->dst_tty_path, "w", stdout)) == NULL)
 262                 err(EXIT_FAILURE, "%s", ctl->dst_tty_path);
 263
 264         sigact.sa_handler = signal_handler;
 265         sigemptyset(&sigact.sa_mask);
 266         sigact.sa_flags = 0;
 267         sigaction(SIGINT, &sigact, NULL);
 268         sigaction(SIGHUP, &sigact, NULL);
 269
 270         host = xgethostname();
 271         if (!host)
 272                 host = xstrdup("???");
 273
 274         now = time((time_t *)NULL);
 275         tm = localtime(&now);
 276         /* print greeting */
 277         printf("\r\n\a\a\a");
 278         if (strcmp(login, pwuid))
 279                 printf(_("Message from %s@%s (as %s) on %s at %02d:%02d ..."),
 280                        login, host, pwuid, ctl->src_tty_name,
 281                        tm->tm_hour, tm->tm_min);
 282         else
 283                 printf(_("Message from %s@%s on %s at %02d:%02d ..."),
 284                        login, host, ctl->src_tty_name,
 285                        tm->tm_hour, tm->tm_min);
 286         free(host);
 287         printf("\r\n");
 288
 289         while (fgets(line, sizeof(line), stdin) != NULL) {
 290                 if (signal_received)
 291                         break;
 292                 write_line(line);
 293         }
 294         printf("EOF\r\n");
 295 }
 296
 297 int main(int argc, char **argv)
 298 {
 299         int tty_writeable = 0, c;
 300         struct write_control ctl = { 0 };
 301
 302         static const struct option longopts[] = {
 303                 {"version", no_argument, NULL, 'V'},
 304                 {"help", no_argument, NULL, 'h'},
 305                 {NULL, 0, NULL, 0}
 306         };
 307
 308         setlocale(LC_ALL, "");
 309         bindtextdomain(PACKAGE, LOCALEDIR);
 310         textdomain(PACKAGE);
 311         atexit(close_stdout);
 312
 313         while ((c = getopt_long(argc, argv, "Vh", longopts, NULL)) != -1)
 314                 switch (c) {
 315                 case 'V':
 316                         printf(UTIL_LINUX_VERSION);
 317                         return EXIT_SUCCESS;
 318                 case 'h':
 319                         usage();
 320                 default:
 321                         errtryhelp(EXIT_FAILURE);
 322                 }
 323
 324         if (get_terminal_name(&ctl.src_tty_path, &ctl.src_tty_name, NULL) == 0) {
 325                 /* check that sender has write enabled */
 326                 if (check_tty(ctl.src_tty_path, &tty_writeable, NULL, 1))
 327                         exit(EXIT_FAILURE);
 328                 if (!tty_writeable)
 329                         errx(EXIT_FAILURE,
 330                              _("you have write permission turned off"));
 331                 tty_writeable = 0;
 332         } else
 333                 ctl.src_tty_name = "<no tty>";
 334
 335         ctl.src_uid = getuid();
 336
 337         /* check args */
 338         switch (argc) {
 339         case 2:
 340                 ctl.dst_login = argv[1];
 341                 search_utmp(&ctl);
 342                 do_write(&ctl);
 343                 break;
 344         case 3:
 345                 ctl.dst_login = argv[1];
 346                 if (!strncmp(argv[2], "/dev/", 5))
 347                         ctl.dst_tty_path = xstrdup(argv[2]);
 348                 else
 349                         xasprintf(&ctl.dst_tty_path, "/dev/%s", argv[2]);
 350                 ctl.dst_tty_name = ctl.dst_tty_path + 5;
 351                 if (check_utmp(&ctl))
 352                         errx(EXIT_FAILURE,
 353                              _("%s is not logged in on %s"),
 354                              ctl.dst_login, ctl.dst_tty_name);
 355                 if (check_tty(ctl.dst_tty_path, &tty_writeable, NULL, 1))
 356                         exit(EXIT_FAILURE);
 357                 if (ctl.src_uid && !tty_writeable)
 358                         errx(EXIT_FAILURE,
 359                              _("%s has messages disabled on %s"),
 360                              ctl.dst_login, ctl.dst_tty_name);
 361                 do_write(&ctl);
 362                 break;
 363         default:
 364                 errtryhelp(EXIT_FAILURE);
 365         }
 366         free(ctl.dst_tty_path);
 367         return EXIT_SUCCESS;
 368 }