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 /* 28 * Copyright 1988-2003 Sun Microsystems, Inc. All rights reserved. 29 * Use is subject to license terms. 30 */ 31 32 /* 33 * Copyright 2012 Joyent, Inc. All rights reserved. 34 * 35 * Copyright (c) 2013 Gary Mills 36 */ 37 38 #include <signal.h> 39 #include <stdio.h> 40 #include <stdlib.h> 41 #include <grp.h> 42 #include <sys/types.h> 43 #include <unistd.h> 44 #include <string.h> 45 #include <ctype.h> 46 #include <sys/stat.h> 47 #include <utmpx.h> 48 #include <sys/utsname.h> 49 #include <dirent.h> 50 #include <pwd.h> 51 #include <fcntl.h> 52 #include <time.h> 53 #include <errno.h> 54 #include <locale.h> 55 #include <syslog.h> 56 #include <sys/wait.h> 57 #include <limits.h> 58 #include <libzonecfg.h> 59 #include <zone.h> 60 #include <sys/contract/process.h> 61 #include <libcontract.h> 62 #include <sys/ctfs.h> 63 64 /* 65 * Use the full lengths from utmpx for user and line. 66 */ 67 #define NMAX (sizeof (((struct utmpx *)0)->ut_user)) 68 #define LMAX (sizeof (((struct utmpx *)0)->ut_line)) 69 70 static char mesg[3000]; 71 static char *infile; 72 static int gflag; 73 static struct group *pgrp; 74 static char *grpname; 75 static char line[MAXNAMLEN+1] = "???"; 76 static char systm[MAXNAMLEN+1]; 77 static time_t tloc; 78 static struct utsname utsn; 79 static char who[NMAX+1] = "???"; 80 static char time_buf[50]; 81 #define DATE_FMT "%a %b %e %H:%M:%S" 82 83 static void sendmes(struct utmpx *, zoneid_t); 84 static void sendmes_tozone(zoneid_t, int); 85 static int chkgrp(char *); 86 static char *copy_str_till(char *, char *, char, int); 87 88 static int init_template(void); 89 int contract_abandon_id(ctid_t); 90 91 int 92 main(int argc, char *argv[]) 93 { 94 FILE *f; 95 char *ptr, *start; 96 struct passwd *pwd; 97 char *term_name; 98 int c; 99 int aflag = 0; 100 int errflg = 0; 101 int zflg = 0; 102 int Zflg = 0; 103 104 char *zonename = NULL; 105 zoneid_t *zoneidlist = NULL; 106 uint_t nzids_saved, nzids = 0; 107 108 (void) setlocale(LC_ALL, ""); 109 110 while ((c = getopt(argc, argv, "g:az:Z")) != EOF) 111 switch (c) { 112 case 'a': 113 aflag++; 114 break; 115 case 'g': 116 if (gflag) { 117 (void) fprintf(stderr, 118 "Only one group allowed\n"); 119 return (1); 120 } 121 if ((pgrp = getgrnam(grpname = optarg)) == NULL) { 122 (void) fprintf(stderr, "Unknown group %s\n", 123 grpname); 124 return (1); 125 } 126 gflag++; 127 break; 128 case 'z': 129 zflg++; 130 zonename = optarg; 131 if (getzoneidbyname(zonename) == -1) { 132 (void) fprintf(stderr, "Specified zone %s " 133 "is invalid", zonename); 134 return (1); 135 } 136 break; 137 case 'Z': 138 Zflg++; 139 break; 140 case '?': 141 errflg++; 142 break; 143 } 144 145 if (errflg) { 146 (void) fprintf(stderr, 147 "Usage: wall [-a] [-g group] [-z zone] [-Z] [files...]\n"); 148 return (1); 149 } 150 151 if (zflg && Zflg) { 152 (void) fprintf(stderr, "Cannot use -z with -Z\n"); 153 return (1); 154 } 155 156 if (optind < argc) 157 infile = argv[optind]; 158 159 if (uname(&utsn) == -1) { 160 (void) fprintf(stderr, "wall: uname() failed, %s\n", 161 strerror(errno)); 162 return (2); 163 } 164 (void) strcpy(systm, utsn.nodename); 165 166 /* 167 * Get the name of the terminal wall is running from. 168 */ 169 170 if ((term_name = ttyname(fileno(stderr))) != NULL) { 171 /* 172 * skip the leading "/dev/" in term_name 173 */ 174 (void) strncpy(line, &term_name[5], sizeof (line) - 1); 175 } 176 177 if (who[0] == '?') { 178 if (pwd = getpwuid(getuid())) 179 (void) strncpy(&who[0], pwd->pw_name, sizeof (who)); 180 } 181 182 f = stdin; 183 if (infile) { 184 f = fopen(infile, "r"); 185 if (f == NULL) { 186 (void) fprintf(stderr, "Cannot open %s\n", infile); 187 return (1); 188 } 189 } 190 191 start = &mesg[0]; 192 ptr = start; 193 while ((ptr - start) < 3000) { 194 size_t n; 195 196 if (fgets(ptr, &mesg[sizeof (mesg)] - ptr, f) == NULL) 197 break; 198 if ((n = strlen(ptr)) == 0) 199 break; 200 ptr += n; 201 } 202 (void) fclose(f); 203 204 /* 205 * If the request is from the rwall daemon then use the caller's 206 * name and host. We determine this if all of the following is true: 207 * 1) First 5 characters are "From " 208 * 2) Next non-white characters are of the form "name@host:" 209 */ 210 if (strcmp(line, "???") == 0) { 211 char rwho[MAXNAMLEN+1]; 212 char rsystm[MAXNAMLEN+1]; 213 char *cp; 214 215 if (strncmp(mesg, "From ", 5) == 0) { 216 cp = &mesg[5]; 217 cp = copy_str_till(rwho, cp, '@', MAXNAMLEN + 1); 218 if (rwho[0] != '\0') { 219 cp = copy_str_till(rsystm, ++cp, ':', 220 MAXNAMLEN + 1); 221 if (rsystm[0] != '\0') { 222 (void) strcpy(systm, rsystm); 223 (void) strncpy(rwho, who, 224 sizeof (who)); 225 (void) strcpy(line, "rpc.rwalld"); 226 } 227 } 228 } 229 } 230 (void) time(&tloc); 231 (void) strftime(time_buf, sizeof (time_buf), 232 DATE_FMT, localtime(&tloc)); 233 234 if (zflg != 0) { 235 if ((zoneidlist = 236 malloc(sizeof (zoneid_t))) == NULL || 237 (*zoneidlist = getzoneidbyname(zonename)) == -1) 238 return (errno); 239 nzids = 1; 240 } else if (Zflg != 0) { 241 if (zone_list(NULL, &nzids) != 0) 242 return (errno); 243 again: 244 nzids *= 2; 245 if ((zoneidlist = malloc(nzids * sizeof (zoneid_t))) == NULL) 246 exit(errno); 247 nzids_saved = nzids; 248 if (zone_list(zoneidlist, &nzids) != 0) { 249 (void) free(zoneidlist); 250 return (errno); 251 } 252 if (nzids > nzids_saved) { 253 free(zoneidlist); 254 goto again; 255 } 256 } 257 if (zflg || Zflg) { 258 for (; nzids > 0; --nzids) 259 sendmes_tozone(zoneidlist[nzids-1], aflag); 260 free(zoneidlist); 261 } else 262 sendmes_tozone(getzoneid(), aflag); 263 264 return (0); 265 } 266 267 /* 268 * Copy src to destination upto but not including the delim. 269 * Leave dst empty if delim not found or whitespace encountered. 270 * Return pointer to next character (delim, whitespace, or '\0') 271 */ 272 static char * 273 copy_str_till(char *dst, char *src, char delim, int len) 274 { 275 int i = 0; 276 277 while (*src != '\0' && i < len) { 278 if (isspace(*src)) { 279 dst[0] = '\0'; 280 return (src); 281 } 282 if (*src == delim) { 283 dst[i] = '\0'; 284 return (src); 285 } 286 dst[i++] = *src++; 287 } 288 dst[0] = '\0'; 289 return (src); 290 } 291 292 static void 293 sendmes_tozone(zoneid_t zid, int aflag) { 294 int i = 0; 295 char zonename[ZONENAME_MAX], root[MAXPATHLEN]; 296 struct utmpx *p; 297 298 if (zid != getzoneid()) { 299 root[0] = '\0'; 300 (void) getzonenamebyid(zid, zonename, ZONENAME_MAX); 301 (void) zone_get_rootpath(zonename, root, sizeof (root)); 302 (void) strlcat(root, UTMPX_FILE, sizeof (root)); 303 if (!utmpxname(root)) { 304 (void) fprintf(stderr, "Cannot open %s\n", root); 305 return; 306 } 307 } else { 308 (void) utmpxname(UTMPX_FILE); 309 } 310 setutxent(); 311 while ((p = getutxent()) != NULL) { 312 if (p->ut_type != USER_PROCESS) 313 continue; 314 /* 315 * if (-a option OR NOT pty window login), send the message 316 */ 317 if (aflag || !nonuser(*p)) 318 sendmes(p, zid); 319 } 320 endutxent(); 321 322 (void) alarm(60); 323 do { 324 i = (int)wait((int *)0); 325 } while (i != -1 || errno != ECHILD); 326 327 } 328 329 /* 330 * Note to future maintainers: with the change of wall to use the 331 * getutxent() API, the forked children (created by this function) 332 * must call _exit as opposed to exit. This is necessary to avoid 333 * unwanted fflushing of getutxent's stdio stream (caused by atexit 334 * processing). 335 */ 336 static void 337 sendmes(struct utmpx *p, zoneid_t zid) 338 { 339 int i; 340 char *s; 341 static char device[LMAX + 6]; 342 char *bp; 343 int ibp; 344 FILE *f; 345 int fd, tmpl_fd; 346 boolean_t zoneenter = B_FALSE; 347 348 if (zid != getzoneid()) { 349 zoneenter = B_TRUE; 350 tmpl_fd = init_template(); 351 if (tmpl_fd == -1) { 352 (void) fprintf(stderr, "Could not initialize " 353 "process contract"); 354 return; 355 } 356 } 357 358 while ((i = (int)fork()) == -1) { 359 (void) alarm(60); 360 (void) wait((int *)0); 361 (void) alarm(0); 362 } 363 364 if (i) 365 return; 366 367 if (zoneenter && zone_enter(zid) == -1) { 368 char zonename[ZONENAME_MAX]; 369 (void) getzonenamebyid(zid, zonename, ZONENAME_MAX); 370 (void) fprintf(stderr, "Could not enter zone " 371 "%s\n", zonename); 372 } 373 if (zoneenter) 374 (void) ct_tmpl_clear(tmpl_fd); 375 376 if (gflag) 377 if (!chkgrp(p->ut_user)) 378 _exit(0); 379 380 (void) signal(SIGHUP, SIG_IGN); 381 (void) alarm(60); 382 s = &device[0]; 383 (void) snprintf(s, sizeof (device), "/dev/%.*s", LMAX, p->ut_line); 384 385 /* check if the device is really a tty */ 386 if ((fd = open(s, O_WRONLY|O_NOCTTY|O_NONBLOCK)) == -1) { 387 (void) fprintf(stderr, "Cannot send to %.*s on %s\n", 388 NMAX, p->ut_user, s); 389 perror("open"); 390 (void) fflush(stderr); 391 _exit(1); 392 } else { 393 if (!isatty(fd)) { 394 (void) fprintf(stderr, 395 "Cannot send to device %.*s %s\n", 396 LMAX, p->ut_line, 397 "because it's not a tty"); 398 openlog("wall", 0, LOG_AUTH); 399 syslog(LOG_CRIT, "%.*s in utmpx is not a tty\n", 400 LMAX, p->ut_line); 401 closelog(); 402 (void) fflush(stderr); 403 _exit(1); 404 } 405 } 406 #ifdef DEBUG 407 (void) close(fd); 408 f = fopen("wall.debug", "a"); 409 #else 410 f = fdopen(fd, "w"); 411 #endif 412 if (f == NULL) { 413 (void) fprintf(stderr, "Cannot send to %-.*s on %s\n", 414 NMAX, &p->ut_user[0], s); 415 perror("open"); 416 (void) fflush(stderr); 417 _exit(1); 418 } 419 (void) fprintf(f, 420 "\07\07\07Broadcast Message from %s (%s) on %s %19.19s", 421 who, line, systm, time_buf); 422 if (gflag) 423 (void) fprintf(f, " to group %s", grpname); 424 (void) fprintf(f, "...\n"); 425 #ifdef DEBUG 426 (void) fprintf(f, "DEBUG: To %.*s on %s\n", NMAX, p->ut_user, s); 427 #endif 428 i = strlen(mesg); 429 for (bp = mesg; --i >= 0; bp++) { 430 ibp = (unsigned int)((unsigned char) *bp); 431 if (*bp == '\n') 432 (void) putc('\r', f); 433 if (isprint(ibp) || *bp == '\r' || *bp == '\013' || 434 *bp == ' ' || *bp == '\t' || *bp == '\n' || *bp == '\007') { 435 (void) putc(*bp, f); 436 } else { 437 if (!isascii(*bp)) { 438 (void) fputs("M-", f); 439 *bp = toascii(*bp); 440 } 441 if (iscntrl(*bp)) { 442 (void) putc('^', f); 443 (void) putc(*bp + 0100, f); 444 } 445 else 446 (void) putc(*bp, f); 447 } 448 449 if (*bp == '\n') 450 (void) fflush(f); 451 452 if (ferror(f) || feof(f)) { 453 (void) printf("\n\007Write failed\n"); 454 (void) fflush(stdout); 455 _exit(1); 456 } 457 } 458 (void) fclose(f); 459 (void) close(fd); 460 _exit(0); 461 } 462 463 464 static int 465 chkgrp(char *name) 466 { 467 int i; 468 char user[NMAX + 1]; 469 470 (void) strlcpy(user, name, sizeof (user)); 471 for (i = 0; pgrp->gr_mem[i] && pgrp->gr_mem[i][0]; i++) { 472 if (strcmp(user, pgrp->gr_mem[i]) == 0) 473 return (1); 474 } 475 476 return (0); 477 } 478 479 static int 480 init_template(void) { 481 int fd = 0; 482 int err = 0; 483 484 fd = open64(CTFS_ROOT "/process/template", O_RDWR); 485 if (fd == -1) 486 return (-1); 487 488 err |= ct_tmpl_set_critical(fd, 0); 489 err |= ct_tmpl_set_informative(fd, 0); 490 err |= ct_pr_tmpl_set_fatal(fd, CT_PR_EV_HWERR); 491 err |= ct_pr_tmpl_set_param(fd, CT_PR_PGRPONLY | CT_PR_REGENT); 492 if (err || ct_tmpl_activate(fd)) { 493 (void) close(fd); 494 return (-1); 495 } 496 497 return (fd); 498 } 499