?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libuutil: move under bmake
[unleashed.git] / usr / src / cmd / ttymon / ttymon.c
blob6593f1338c1c3788467ce93e8efed8a9e579ac96
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 (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
27 /* All Rights Reserved */
28
29 #include <stdio_ext.h>
30 #include <stdlib.h>
31 #include <fcntl.h>
32 #include <errno.h>
33 #include <poll.h>
34 #include <string.h>
35 #include <signal.h>
36 #include <sys/types.h>
37 #include <sys/stat.h>
38 #include <sys/stropts.h>
39 #include <sys/resource.h>
40 #include <sys/termios.h>
41 #include <pwd.h>
42 #include <grp.h>
43 #include <unistd.h>
44 #include <ulimit.h>
45
46 #include "sac.h"
47 #include "ttymon.h"
48 #include "tmstruct.h"
49 #include "tmextern.h"
50
51 static int Initialized;
52
53 extern int Retry;
54 extern struct pollfd *Pollp;
55 static void initialize();
56 static void open_all();
57 static int set_poll();
58 static int check_spawnlimit();
59 static int mod_ttydefs();
60
61 void open_device();
62 void set_softcar();
63
64 extern int check_session();
65 extern void sigalarm();
66 extern void revokedevaccess(char *, uid_t, gid_t, mode_t);
67 /* can't include libdevinfo.h */
68 extern int di_devperm_logout(const char *);
69
70 /*
71 * ttymon - a port monitor under SAC
72 * - monitor ports, set terminal modes, baud rate
73 * and line discipline for the port
74 * - invoke service on port if connection request received
75 * - Usage: ttymon
76 * ttymon -g [options]
77 * Valid options are
78 * -h
79 * -d device
80 * -l ttylabel
81 * -t timeout
82 * -m modules
83 * -p prompt
84 *
85 * - ttymon without args is invoked by SAC
86 * - ttymon -g is invoked by process that needs to
87 * have login service on the fly
88 */
89
90 int
91 main(int argc, char *argv[])
92 {
93 int nfds;
94 extern char *lastname();
95
96 /*
97 * Only the superuser should execute this command.
98 */
99 if (getuid() != 0)
100 return (1);
101
102 /* remember original signal mask and dispositions */
103 (void) sigprocmask(SIG_SETMASK, NULL, &Origmask);
104 (void) sigaction(SIGINT, NULL, &Sigint);
105 (void) sigaction(SIGALRM, NULL, &Sigalrm);
106 (void) sigaction(SIGPOLL, NULL, &Sigpoll);
107 (void) sigaction(SIGQUIT, NULL, &Sigquit);
108 (void) sigaction(SIGCLD, NULL, &Sigcld);
109 (void) sigaction(SIGTERM, NULL, &Sigterm);
110 #ifdef DEBUG
111 (void) sigaction(SIGUSR1, NULL, &Sigusr1);
112 (void) sigaction(SIGUSR2, NULL, &Sigusr2);
113 #endif
114
115 /*
116 * SIGQUIT needs to be ignored. Otherwise, hitting ^\ from
117 * console kills ttymon.
118 */
119 (void) signal(SIGQUIT, SIG_IGN);
120
121 if ((argc > 1) || (strcmp(lastname(argv[0]), "getty") == 0)) {
122 ttymon_express(argc, argv);
123 return (1); /*NOTREACHED*/
124 }
125
126 initialize();
127
128 for (;;) {
129 nfds = set_poll(Pollp);
130 if (!Reread_flag) {
131 if (nfds > 0)
132 do_poll(Pollp, nfds);
133 else
134 (void) pause();
135 }
136 /*
137 * READDB messages may arrive during poll or pause.
138 * So the flag needs to be checked again.
139 */
140 if (Reread_flag) {
141 Reread_flag = FALSE;
142 re_read();
143 }
144 while (Retry) {
145 Retry = FALSE;
146 open_all();
147 }
148 }
149 }
150
151 static void
152 initialize()
153 {
154 struct pmtab *tp;
155 register struct passwd *pwdp;
156 register struct group *gp;
157 struct rlimit rlimit;
158 extern struct rlimit Rlimit;
159 extern uid_t Uucp_uid;
160 extern gid_t Tty_gid;
161
162 #ifdef DEBUG
163 extern opendebug();
164 #endif
165 Initialized = FALSE;
166 /*
167 * get_environ() must be called first,
168 * otherwise we don't know where the log file is
169 */
170 get_environ();
171 openttymonlog();
172 openpid();
173 openpipes();
174 setup_PCpipe();
175
176 log("PMTAG: %s", Tag);
177 log("Starting state: %s",
178 (State == PM_ENABLED) ? "enabled" : "disabled");
179
180 #ifdef DEBUG
181 opendebug(FALSE);
182 debug("***** ttymon in initialize *****");
183 log("debug mode is \t on");
184 #endif
185
186 catch_signals();
187
188 /* register to receive SIGPOLL when data comes to pmpipe */
189 if (ioctl(Pfd, I_SETSIG, S_INPUT) < 0)
190 fatal("I_SETSIG on pmpipe failed: %s", strerror(errno));
191
192 sacpoll(); /* this is needed because there may be data already */
193
194 Maxfiles = (int)ulimit(4, 0L); /* get max number of open files */
195 if (Maxfiles < 0)
196 fatal("ulimit(4,0L) failed: %s", strerror(errno));
197
198 if (getrlimit(RLIMIT_NOFILE, &Rlimit) == -1)
199 fatal("getrlimit failed: %s", strerror(errno));
200
201 rlimit.rlim_cur = rlimit.rlim_max = Rlimit.rlim_max;
202 if (setrlimit(RLIMIT_NOFILE, &rlimit) == -1)
203 fatal("setrlimit failed: %s", strerror(errno));
204
205 (void) enable_extended_FILE_stdio(-1, -1);
206
207 Maxfiles = rlimit.rlim_cur;
208 Maxfds = Maxfiles - FILE_RESERVED;
209
210 log("max open files = %d", Maxfiles);
211 log("max ports ttymon can monitor = %d", Maxfds);
212
213 read_pmtab();
214
215 /*
216 * setup poll array
217 * - we allocate 10 extra pollfd so that
218 * we do not have to re-malloc when there is
219 * minor fluctuation in Nentries
220 */
221 Npollfd = Nentries + 10;
222 if (Npollfd > Maxfds)
223 Npollfd = Maxfds;
224 if ((Pollp = (struct pollfd *)
225 malloc((unsigned)(Npollfd * sizeof (struct pollfd))))
226 == NULL)
227 fatal("malloc for Pollp failed");
228
229 (void) mod_ttydefs(); /* just to initialize Mtime */
230 if (check_version(TTYDEFS_VERS, TTYDEFS) != 0)
231 fatal("check /etc/ttydefs version failed");
232
233 read_ttydefs(NULL, FALSE);
234
235 /* initialize global variables, Uucp_uid & Tty_gid */
236 if ((pwdp = getpwnam(UUCP)) != NULL)
237 Uucp_uid = pwdp->pw_uid;
238 if ((gp = getgrnam(TTY)) == NULL)
239 log("no group entry for <tty>, default is used");
240 else
241 Tty_gid = gp->gr_gid;
242 endgrent();
243 endpwent();
244 #ifdef DEBUG
245 debug("Uucp_uid = %u, Tty_gid = %u", Uucp_uid, Tty_gid);
246 #endif
247
248 log("Initialization Completed");
249
250 /* open the devices ttymon monitors */
251 Retry = TRUE;
252 while (Retry) {
253 Retry = FALSE;
254 for (tp = PMtab; tp; tp = tp->p_next) {
255 if ((tp->p_status > 0) && (tp->p_fd == 0) &&
256 (tp->p_pid == 0) && !(tp->p_ttyflags & I_FLAG) &&
257 (!((State == PM_DISABLED) &&
258 ((tp->p_dmsg == NULL)||(*(tp->p_dmsg) == '\0'))))) {
259 open_device(tp);
260 if (tp->p_fd > 0)
261 got_carrier(tp);
262 }
263 }
264 }
265 Initialized = TRUE;
266 }
267
268 static void free_defs();
269
270 /*
271 * open_all - open devices in pmtab if the entry is
272 * - valid, fd = 0, and pid = 0
273 */
274 static void
275 open_all()
276 {
277 struct pmtab *tp;
278 int check_modtime;
279 sigset_t cset;
280 sigset_t tset;
281
282 #ifdef DEBUG
283 debug("in open_all");
284 #endif
285 check_modtime = TRUE;
286
287 for (tp = PMtab; tp; tp = tp->p_next) {
288 if ((tp->p_status > 0) && (tp->p_fd == 0) &&
289 (tp->p_pid == 0) &&
290 !(tp->p_ttyflags & I_FLAG) && (!((State == PM_DISABLED) &&
291 ((tp->p_dmsg == NULL)||(*(tp->p_dmsg) == '\0'))))) {
292 /*
293 * if we have not check modification time and
294 * /etc/ttydefs was modified, need to re-read it
295 */
296 if (check_modtime && mod_ttydefs()) {
297 check_modtime = FALSE;
298 (void) sigprocmask(SIG_SETMASK, NULL, &cset);
299 tset = cset;
300 (void) sigaddset(&tset, SIGCLD);
301 (void) sigprocmask(SIG_SETMASK, &tset, NULL);
302 free_defs();
303 #ifdef DEBUG
304 debug("/etc/ttydefs is modified, re-read it");
305 #endif
306 read_ttydefs(NULL, FALSE);
307 (void) sigprocmask(SIG_SETMASK, &cset, NULL);
308 }
309 open_device(tp);
310 if (tp->p_fd > 0)
311 got_carrier(tp);
312 } else if (((tp->p_status == LOCKED) ||
313 (tp->p_status == SESSION) ||
314 (tp->p_status == UNACCESS)) &&
315 (tp->p_fd > 0) &&
316 (!((State == PM_DISABLED) &&
317 ((tp->p_dmsg == NULL)||(*(tp->p_dmsg) == '\0'))))) {
318 if (check_modtime && mod_ttydefs()) {
319 check_modtime = FALSE;
320 (void) sigprocmask(SIG_SETMASK, NULL, &cset);
321 tset = cset;
322 (void) sigaddset(&tset, SIGCLD);
323 (void) sigprocmask(SIG_SETMASK, &tset, NULL);
324 free_defs();
325 #ifdef DEBUG
326 debug("/etc/ttydefs is modified, re-read it");
327 #endif
328 read_ttydefs(NULL, FALSE);
329 (void) sigprocmask(SIG_SETMASK, &cset, NULL);
330 }
331 tp->p_status = VALID;
332 open_device(tp);
333 if (tp->p_fd > 0)
334 got_carrier(tp);
335 }
336 }
337 }
338
339 void
340 set_softcar(pmptr)
341 struct pmtab *pmptr;
342 {
343
344 int fd, val = 0;
345
346 #ifdef DEBUG
347 debug("in set_softcar");
348 #endif
349 /*
350 * If soft carrier is not set one way or
351 * the other, leave it alone.
352 */
353 if (*pmptr->p_softcar == '\0')
354 return;
355
356 if (*pmptr->p_softcar == 'y')
357 val = 1;
358
359 if ((fd = open(pmptr->p_device, O_RDONLY|O_NONBLOCK|O_NOCTTY)) < 0) {
360 log("open (%s) failed: %s", pmptr->p_device, strerror(errno));
361 return;
362 }
363
364 if (ioctl(fd, TIOCSSOFTCAR, &val) < 0)
365 log("set soft-carrier (%s) failed: %s", pmptr->p_device,
366 strerror(errno));
367
368 close(fd);
369 }
370
371
372 /*
373 * open_device(pmptr) - open the device
374 * - check device lock
375 * - change owner of device
376 * - push line disciplines
377 * - set termio
378 */
379
380 void
381 open_device(pmptr)
382 struct pmtab *pmptr;
383 {
384 int fd, tmpfd;
385 struct sigaction sigact;
386
387 #ifdef DEBUG
388 debug("in open_device");
389 #endif
390
391 if (pmptr->p_status == GETTY) {
392 revokedevaccess(pmptr->p_device, 0, 0, 0);
393
394 if ((fd = open(pmptr->p_device, O_RDWR)) == -1)
395 fatal("open (%s) failed: %s", pmptr->p_device,
396 strerror(errno));
397
398 } else {
399 if (check_spawnlimit(pmptr) == -1) {
400 pmptr->p_status = NOTVALID;
401 log("service <%s> is respawning too rapidly",
402 pmptr->p_tag);
403 return;
404 }
405 if (pmptr->p_fd > 0) { /* file already open */
406 fd = pmptr->p_fd;
407 pmptr->p_fd = 0;
408 } else if ((fd = open(pmptr->p_device, O_RDWR|O_NONBLOCK))
409 == -1) {
410 log("open (%s) failed: %s", pmptr->p_device,
411 strerror(errno));
412 if ((errno == ENODEV) || (errno == EBUSY)) {
413 pmptr->p_status = UNACCESS;
414 Nlocked++;
415 if (Nlocked == 1) {
416 sigact.sa_flags = 0;
417 sigact.sa_handler = sigalarm;
418 (void) sigemptyset(&sigact.sa_mask);
419 (void) sigaction(SIGALRM, &sigact, NULL);
420 (void) alarm(ALARMTIME);
421 }
422 } else
423 Retry = TRUE;
424 return;
425 }
426 /* set close-on-exec flag */
427 if (fcntl(fd, F_SETFD, 1) == -1)
428 fatal("F_SETFD fcntl failed: %s", strerror(errno));
429
430 if (tm_checklock(fd) != 0) {
431 pmptr->p_status = LOCKED;
432 (void) close(fd);
433 Nlocked++;
434 if (Nlocked == 1) {
435 sigact.sa_flags = 0;
436 sigact.sa_handler = sigalarm;
437 (void) sigemptyset(&sigact.sa_mask);
438 (void) sigaction(SIGALRM, &sigact, NULL);
439 (void) alarm(ALARMTIME);
440 }
441 return;
442 }
443 if (check_session(fd) != 0) {
444 if ((Initialized) && (pmptr->p_inservice != SESSION)) {
445 log("Warning -- active session exists on <%s>",
446 pmptr->p_device);
447 } else {
448 /*
449 * this may happen if a service is running
450 * and ttymon dies and is restarted,
451 * or another process is running on the
452 * port.
453 */
454 pmptr->p_status = SESSION;
455 pmptr->p_inservice = 0;
456 (void) close(fd);
457 Nlocked++;
458 if (Nlocked == 1) {
459 sigact.sa_flags = 0;
460 sigact.sa_handler = sigalarm;
461 (void) sigemptyset(&sigact.sa_mask);
462 (void) sigaction(SIGALRM, &sigact,
463 NULL);
464 (void) alarm(ALARMTIME);
465 }
466 return;
467 }
468 }
469 pmptr->p_inservice = 0;
470 }
471
472 if (pmptr->p_ttyflags & H_FLAG) {
473 /* drop DTR */
474 (void) hang_up_line(fd);
475 /*
476 * After hang_up_line, the stream is in STRHUP state.
477 * We need to do another open to reinitialize streams
478 * then we can close one fd
479 */
480 if ((tmpfd = open(pmptr->p_device, O_RDWR|O_NONBLOCK)) == -1) {
481 log("open (%s) failed: %s", pmptr->p_device,
482 strerror(errno));
483 Retry = TRUE;
484 (void) close(fd);
485 return;
486 }
487 (void) close(tmpfd);
488 }
489
490 #ifdef DEBUG
491 debug("open_device (%s), fd = %d", pmptr->p_device, fd);
492 #endif
493
494 /* Change ownership of the tty line to root/uucp and */
495 /* set protections to only allow root/uucp to read the line. */
496
497 if (pmptr->p_ttyflags & (B_FLAG|C_FLAG))
498 (void) fchown(fd, Uucp_uid, Tty_gid);
499 else
500 (void) fchown(fd, ROOTUID, Tty_gid);
501 (void) fchmod(fd, 0620);
502
503 if ((pmptr->p_modules != NULL)&&(*(pmptr->p_modules) != '\0')) {
504 if (push_linedisc(fd, pmptr->p_modules, pmptr->p_device)
505 == -1) {
506 Retry = TRUE;
507 (void) close(fd);
508 return;
509 }
510 }
511
512 if (initial_termio(fd, pmptr) == -1) {
513 Retry = TRUE;
514 (void) close(fd);
515 return;
516 }
517
518 di_devperm_logout((const char *)pmptr->p_device);
519 pmptr->p_fd = fd;
520 }
521
522 /*
523 * set_poll(fdp) - put all fd's in a pollfd array
524 * - set poll event to POLLIN and POLLMSG
525 * - return number of fd to be polled
526 */
527
528 static int
529 set_poll(fdp)
530 struct pollfd *fdp;
531 {
532 struct pmtab *tp;
533 int nfd = 0;
534
535 for (tp = PMtab; tp; tp = tp->p_next) {
536 if (tp->p_fd > 0) {
537 fdp->fd = tp->p_fd;
538 fdp->events = POLLIN;
539 fdp++;
540 nfd++;
541 }
542 }
543 return (nfd);
544 }
545
546 /*
547 * check_spawnlimit - return 0 if spawnlimit is not reached
548 * - otherwise return -1
549 */
550 static int
551 check_spawnlimit(pmptr)
552 struct pmtab *pmptr;
553 {
554 time_t now;
555
556 (void) time(&now);
557 if (pmptr->p_time == 0L)
558 pmptr->p_time = now;
559 if (pmptr->p_respawn >= SPAWN_LIMIT) {
560 if ((now - pmptr->p_time) < SPAWN_INTERVAL) {
561 pmptr->p_time = now;
562 pmptr->p_respawn = 0;
563 return (-1);
564 }
565 pmptr->p_time = now;
566 pmptr->p_respawn = 0;
567 }
568 pmptr->p_respawn++;
569 return (0);
570 }
571
572 /*
573 * mod_ttydefs - to check if /etc/ttydefs has been modified
574 * - return TRUE if file modified
575 * - otherwise, return FALSE
576 */
577 static int
578 mod_ttydefs()
579 {
580 struct stat statbuf;
581 extern long Mtime;
582 if (stat(TTYDEFS, &statbuf) == -1) {
583 /* if stat failed, don't bother reread ttydefs */
584 return (FALSE);
585 }
586 if ((long)statbuf.st_mtime != Mtime) {
587 Mtime = (long)statbuf.st_mtime;
588 return (TRUE);
589 }
590 return (FALSE);
591 }
592
593 /*
594 * free_defs - free the Gdef table
595 */
596 static void
597 free_defs()
598 {
599 int i;
600 struct Gdef *tp;
601 tp = &Gdef[0];
602 for (i = 0; i < Ndefs; i++, tp++) {
603 free(tp->g_id);
604 free(tp->g_iflags);
605 free(tp->g_fflags);
606 free(tp->g_nextid);
607 tp->g_id = NULL;
608 tp->g_iflags = NULL;
609 tp->g_fflags = NULL;
610 tp->g_nextid = NULL;
611 }
612 Ndefs = 0;
613 }
614
615 /*
616 * struct Gdef *get_speed(ttylabel)
617 * - search "/etc/ttydefs" for speed and term. specification
618 * using "ttylabel". If "ttylabel" is NULL, default
619 * to DEFAULT
620 * arg: ttylabel - label/id of speed settings.
621 */
622
623 struct Gdef *
624 get_speed(char *ttylabel)
625 {
626 register struct Gdef *sp;
627 extern struct Gdef DEFAULT;
628
629 if ((ttylabel != NULL) && (*ttylabel != '\0')) {
630 if ((sp = find_def(ttylabel)) == NULL) {
631 log("unable to find <%s> in \"%s\"", ttylabel, TTYDEFS);
632 sp = &DEFAULT; /* use default */
633 }
634 } else sp = &DEFAULT; /* use default */
635 return (sp);
636 }
637
638 /*
639 * setup_PCpipe() - setup the pipe between Parent and Children
640 * - the pipe is used for a tmchild to send its
641 * pid to inform ttymon that it is about to
642 * invoke service
643 * - the pipe also serves as a mean for tmchild
644 * to detect failure of ttymon
645 */
646 void
647 setup_PCpipe()
648 {
649 int flag = 0;
650
651 if (pipe(PCpipe) == -1)
652 fatal("pipe() failed: %s", strerror(errno));
653
654 /* set close-on-exec flag */
655 if (fcntl(PCpipe[0], F_SETFD, 1) == -1)
656 fatal("F_SETFD fcntl failed: %s", strerror(errno));
657
658 if (fcntl(PCpipe[1], F_SETFD, 1) == -1)
659 fatal("F_SETFD fcntl failed: %s", strerror(errno));
660
661 /* set O_NONBLOCK flag */
662 if (fcntl(PCpipe[0], F_GETFL, flag) == -1)
663 fatal("F_GETFL failed: %s", strerror(errno));
664
665 flag |= O_NONBLOCK;
666 if (fcntl(PCpipe[0], F_SETFL, flag) == -1)
667 fatal("F_SETFL failed: %s", strerror(errno));
668
669 /* set message discard mode */
670 if (ioctl(PCpipe[0], I_SRDOPT, RMSGD) == -1)
671 fatal("I_SRDOPT RMSGD failed: %s", strerror(errno));
672
673 /* register to receive SIGPOLL when data come */
674 if (ioctl(PCpipe[0], I_SETSIG, S_INPUT) == -1)
675 fatal("I_SETSIG S_INPUT failed: %s", strerror(errno));
676
677 #ifdef DEBUG
678 log("PCpipe[0]\t = %d", PCpipe[0]);
679 log("PCpipe[1]\t = %d", PCpipe[1]);
680 #endif
681 }
Unleashed OS