usr.sbin/sliplogin/sliplogin.c

   1 /*-
   2  * Copyright (c) 1990, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  * @(#) Copyright (c) 1990, 1993 The Regents of the University of California.  All rights reserved.
  34  * @(#)sliplogin.c        8.2 (Berkeley) 2/1/94
  35  * $FreeBSD: src/usr.sbin/sliplogin/sliplogin.c,v 1.9.6.2 2001/07/19 05:21:28 kris Exp $
  36  * $DragonFly: src/usr.sbin/sliplogin/sliplogin.c,v 1.4 2005/12/05 02:40:28 swildner Exp $
  37  */
  38
  39 /*
  40  * sliplogin.c
  41  * [MUST BE RUN SUID, SLOPEN DOES A SUSER()!]
  42  *
  43  * This program initializes its own tty port to be an async TCP/IP interface.
  44  * It sets the line discipline to slip, invokes a shell script to initialize
  45  * the network interface, then pauses forever waiting for hangup.
  46  *
  47  * It is a remote descendant of several similar programs with incestuous ties:
  48  * - Kirk Smith's slipconf, modified by Richard Johnsson @ DEC WRL.
  49  * - slattach, probably by Rick Adams but touched by countless hordes.
  50  * - the original sliplogin for 4.2bsd, Doug Kingston the mover behind it.
  51  *
  52  * There are two forms of usage:
  53  *
  54  * "sliplogin"
  55  * Invoked simply as "sliplogin", the program looks up the username
  56  * in the file /etc/slip.hosts.
  57  * If an entry is found, the line on fd0 is configured for SLIP operation
  58  * as specified in the file.
  59  *
  60  * "sliplogin IPhostlogin </dev/ttyb"
  61  * Invoked by root with a username, the name is looked up in the
  62  * /etc/slip.hosts file and if found fd0 is configured as in case 1.
  63  */
  64
  65 #include <sys/param.h>
  66 #include <sys/socket.h>
  67 #include <sys/file.h>
  68 #include <sys/stat.h>
  69 #include <syslog.h>
  70 #include <netdb.h>
  71
  72 #include <termios.h>
  73 #include <sys/ioctl.h>
  74 #include <net/slip.h>
  75 #include <net/if.h>
  76
  77 #include <stdio.h>
  78 #include <errno.h>
  79 #include <ctype.h>
  80 #include <paths.h>
  81 #include <string.h>
  82 #include <unistd.h>
  83 #include <stdlib.h>
  84 #include <signal.h>
  85 #include "pathnames.h"
  86
  87 extern char **environ;
  88
  89 static char *restricted_environ[] = {
  90         "PATH=" _PATH_STDPATH,
  91         NULL
  92 };
  93
  94 int     unit;
  95 int     slip_mode;
  96 speed_t speed;
  97 int     uid;
  98 int     keepal;
  99 int     outfill;
 100 int     slunit;
 101 char    loginargs[BUFSIZ];
 102 char    loginfile[MAXPATHLEN];
 103 char    loginname[BUFSIZ];
 104 static char raddr[32];                  /* remote address */
 105 char ifname[IFNAMSIZ];                  /* interface name */
 106 static  char pidfilename[MAXPATHLEN];   /* name of pid file */
 107 static  char iffilename[MAXPATHLEN];    /* name of if file */
 108 static  pid_t   pid;                    /* our pid */
 109
 110 char *
 111 make_ipaddr(void)
 112 {
 113 static char address[20] ="";
 114 struct hostent *he;
 115 unsigned long ipaddr;
 116
 117 address[0] = '\0';
 118 if ((he = gethostbyname(raddr)) != NULL) {
 119         ipaddr = ntohl(*(long *)he->h_addr_list[0]);
 120         sprintf(address, "%lu.%lu.%lu.%lu",
 121                 ipaddr >> 24,
 122                 (ipaddr & 0x00ff0000) >> 16,
 123                 (ipaddr & 0x0000ff00) >> 8,
 124                 (ipaddr & 0x000000ff));
 125         }
 126
 127 return address;
 128 }
 129
 130 struct slip_modes {
 131         char    *sm_name;
 132         int     sm_or_flag;
 133         int     sm_and_flag;
 134 }        modes[] = {
 135         "normal",       0        , 0        ,
 136         "compress",     IFF_LINK0, IFF_LINK2,
 137         "noicmp",       IFF_LINK1, 0        ,
 138         "autocomp",     IFF_LINK2, IFF_LINK0,
 139 };
 140
 141 void
 142 findid(char *name)
 143 {
 144         FILE *fp;
 145         static char slopt[5][16];
 146         static char laddr[16];
 147         static char mask[16];
 148         char   slparmsfile[MAXPATHLEN];
 149         char user[16];
 150         char buf[128];
 151         int i, j, n;
 152
 153         environ = restricted_environ; /* minimal protection for system() */
 154
 155         strncpy(loginname, name, sizeof(loginname)-1);
 156         loginname[sizeof(loginname)-1] = '\0';
 157
 158         if ((fp = fopen(_PATH_ACCESS, "r")) == NULL) {
 159         accfile_err:
 160                 syslog(LOG_ERR, "%s: %m\n", _PATH_ACCESS);
 161                 exit(1);
 162         }
 163         while (fgets(loginargs, sizeof(loginargs) - 1, fp)) {
 164                 if (ferror(fp))
 165                         goto accfile_err;
 166                 if (loginargs[0] == '#' || isspace(loginargs[0]))
 167                         continue;
 168                 n = sscanf(loginargs, "%15s%*[ \t]%15s%*[ \t]%15s%*[ \t]%15s%*[ \t]%15s%*[ \t]%15s%*[ \t]%15s%*[ \t]%15s%*[ \t]%15s\n",
 169                         user, laddr, raddr, mask, slopt[0], slopt[1],
 170                         slopt[2], slopt[3], slopt[4]);
 171                 if (n < 4) {
 172                         syslog(LOG_ERR, "%s: wrong format\n", _PATH_ACCESS);
 173                         exit(1);
 174                 }
 175                 if (strcmp(user, name) != 0)
 176                         continue;
 177
 178                 fclose(fp);
 179
 180                 slip_mode = 0;
 181                 for (i = 0; i < n - 4; i++) {
 182                         for (j = 0; j < sizeof(modes)/sizeof(struct slip_modes);
 183                                 j++) {
 184                                 if (strcmp(modes[j].sm_name, slopt[i]) == 0) {
 185                                         slip_mode |= (modes[j].sm_or_flag);
 186                                         slip_mode &= ~(modes[j].sm_and_flag);
 187                                         break;
 188                                 }
 189                         }
 190                 }
 191
 192                 /*
 193                  * we've found the guy we're looking for -- see if
 194                  * there's a login file we can use.  First check for
 195                  * one specific to this host.  If none found, try for
 196                  * a generic one.
 197                  */
 198                 snprintf(loginfile, sizeof(loginfile), "%s.%s", _PATH_LOGIN, name);
 199                 if (access(loginfile, R_OK|X_OK) != 0) {
 200                         strncpy(loginfile, _PATH_LOGIN, sizeof(loginfile)-1);
 201                         loginfile[sizeof(loginfile)-1] = '\0';
 202                         if (access(loginfile, R_OK|X_OK)) {
 203                                 syslog(LOG_ERR,
 204                                        "access denied for %s - no %s\n",
 205                                        name, _PATH_LOGIN);
 206                                 exit(5);
 207                         }
 208                 }
 209                 snprintf(slparmsfile, sizeof(slparmsfile), "%s.%s", _PATH_SLPARMS, name);
 210                 if (access(slparmsfile, R_OK|X_OK) != 0) {
 211                         strncpy(slparmsfile, _PATH_SLPARMS, sizeof(slparmsfile)-1);
 212                         slparmsfile[sizeof(slparmsfile)-1] = '\0';
 213                         if (access(slparmsfile, R_OK|X_OK))
 214                                 *slparmsfile = '\0';
 215                 }
 216                 keepal = outfill = 0;
 217                 slunit = -1;
 218                 if (*slparmsfile) {
 219                         if ((fp = fopen(slparmsfile, "r")) == NULL) {
 220                         slfile_err:
 221                                 syslog(LOG_ERR, "%s: %m\n", slparmsfile);
 222                                 exit(1);
 223                         }
 224                         n = 0;
 225                         while (fgets(buf, sizeof(buf) - 1, fp) != NULL) {
 226                                 if (ferror(fp))
 227                                         goto slfile_err;
 228                                 if (buf[0] == '#' || isspace(buf[0]))
 229                                         continue;
 230                                 n = sscanf(buf, "%d %d %d", &keepal, &outfill, &slunit);
 231                                 if (n < 1) {
 232                                 slwrong_fmt:
 233                                         syslog(LOG_ERR, "%s: wrong format\n", slparmsfile);
 234                                         exit(1);
 235                                 }
 236                                 fclose(fp);
 237                                 break;
 238                         }
 239                         if (n == 0)
 240                                 goto slwrong_fmt;
 241                 }
 242
 243                 return;
 244         }
 245         syslog(LOG_ERR, "SLIP access denied for %s\n", name);
 246         exit(4);
 247         /* NOTREACHED */
 248 }
 249
 250 char *
 251 sigstr(int s)
 252 {
 253         static char buf[32];
 254
 255         switch (s) {
 256         case SIGHUP:    return("HUP");
 257         case SIGINT:    return("INT");
 258         case SIGQUIT:   return("QUIT");
 259         case SIGILL:    return("ILL");
 260         case SIGTRAP:   return("TRAP");
 261         case SIGIOT:    return("IOT");
 262         case SIGEMT:    return("EMT");
 263         case SIGFPE:    return("FPE");
 264         case SIGKILL:   return("KILL");
 265         case SIGBUS:    return("BUS");
 266         case SIGSEGV:   return("SEGV");
 267         case SIGSYS:    return("SYS");
 268         case SIGPIPE:   return("PIPE");
 269         case SIGALRM:   return("ALRM");
 270         case SIGTERM:   return("TERM");
 271         case SIGURG:    return("URG");
 272         case SIGSTOP:   return("STOP");
 273         case SIGTSTP:   return("TSTP");
 274         case SIGCONT:   return("CONT");
 275         case SIGCHLD:   return("CHLD");
 276         case SIGTTIN:   return("TTIN");
 277         case SIGTTOU:   return("TTOU");
 278         case SIGIO:     return("IO");
 279         case SIGXCPU:   return("XCPU");
 280         case SIGXFSZ:   return("XFSZ");
 281         case SIGVTALRM: return("VTALRM");
 282         case SIGPROF:   return("PROF");
 283         case SIGWINCH:  return("WINCH");
 284 #ifdef SIGLOST
 285         case SIGLOST:   return("LOST");
 286 #endif
 287         case SIGUSR1:   return("USR1");
 288         case SIGUSR2:   return("USR2");
 289         }
 290         snprintf(buf, sizeof(buf), "sig %d", s);
 291         return(buf);
 292 }
 293
 294 void
 295 hup_handler(int s)
 296 {
 297         char logoutfile[MAXPATHLEN];
 298
 299         close(0);
 300         seteuid(0);
 301         snprintf(logoutfile, sizeof(logoutfile), "%s.%s", _PATH_LOGOUT, loginname);
 302         if (access(logoutfile, R_OK|X_OK) != 0) {
 303                 strncpy(logoutfile, _PATH_LOGOUT, sizeof(logoutfile)-1);
 304                 logoutfile[sizeof(logoutfile)-1] = '\0';
 305         }
 306         if (access(logoutfile, R_OK|X_OK) == 0) {
 307                 char logincmd[2*MAXPATHLEN+32];
 308
 309                 snprintf(logincmd, sizeof(logincmd), "%s %d %ld %s", logoutfile, unit, speed, loginargs);
 310                 system(logincmd);
 311         }
 312         syslog(LOG_INFO, "closed %s slip unit %d (%s)\n", loginname, unit,
 313                sigstr(s));
 314         if (unlink(pidfilename) < 0 && errno != ENOENT)
 315                 syslog(LOG_WARNING, "unable to delete pid file: %m");
 316         if (unlink(iffilename) < 0 && errno != ENOENT)
 317                 syslog(LOG_WARNING, "unable to delete if file: %m");
 318         exit(1);
 319         /* NOTREACHED */
 320 }
 321
 322
 323 /* Modify the slip line mode and add any compression or no-icmp flags. */
 324 void
 325 line_flags(int unit)
 326 {
 327         struct ifreq ifr;
 328         int s;
 329
 330         /* open a socket as the handle to the interface */
 331         s = socket(AF_INET, SOCK_DGRAM, 0);
 332         if (s < 0) {
 333                 syslog(LOG_ERR, "socket: %m");
 334                 exit(1);
 335         }
 336         sprintf(ifr.ifr_name, "sl%d", unit);
 337
 338         /* get the flags for the interface */
 339         if (ioctl(s, SIOCGIFFLAGS, (caddr_t)&ifr) < 0) {
 340                 syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
 341                 exit(1);
 342         }
 343
 344         /* Assert any compression or no-icmp flags. */
 345 #define SLMASK (~(IFF_LINK0 | IFF_LINK1 | IFF_LINK2))
 346         ifr.ifr_flags &= SLMASK;
 347         ifr.ifr_flags |= slip_mode;
 348         if (ioctl(s, SIOCSIFFLAGS, (caddr_t)&ifr) < 0) {
 349                 syslog(LOG_ERR, "ioctl (SIOCSIFFLAGS): %m");
 350                 exit(1);
 351         }
 352         close(s);
 353 }
 354
 355 int
 356 main(int argc, char *argv[])
 357 {
 358         int fd, s, ldisc;
 359         char *name;
 360         struct termios tios, otios;
 361         char logincmd[2*BUFSIZ+32];
 362         extern uid_t getuid();
 363
 364         FILE *pidfile;                          /* pid file */
 365         FILE *iffile;                           /* interfaces file */
 366         char *p;
 367         int n;
 368         char devnam[MAXPATHLEN] = _PATH_TTY;   /* Device name */
 369
 370         if ((name = strrchr(argv[0], '/')) == NULL)
 371                 name = argv[0];
 372         s = getdtablesize();
 373         for (fd = 3 ; fd < s ; fd++)
 374                 close(fd);
 375         openlog(name, LOG_PID|LOG_PERROR, LOG_DAEMON);
 376         uid = getuid();
 377         if (argc > 1) {
 378                 findid(argv[1]);
 379
 380                 /*
 381                  * Disassociate from current controlling terminal, if any,
 382                  * and ensure that the slip line is our controlling terminal.
 383                  */
 384                 if (daemon(1, 1)) {
 385                         syslog(LOG_ERR, "daemon(1, 1): %m");
 386                         exit(1);
 387                 }
 388                 if (argc > 2) {
 389                         if ((fd = open(argv[2], O_RDWR)) == -1) {
 390                                 syslog(LOG_ERR, "open %s: %m", argv[2]);
 391                                 exit(2);
 392                         }
 393                         dup2(fd, 0);
 394                         if (fd > 2)
 395                                 close(fd);
 396                 }
 397                 if (ioctl(0, TIOCSCTTY, 0) == -1) {
 398                         syslog(LOG_ERR, "ioctl (TIOCSCTTY): %m");
 399                         exit(1);
 400                 }
 401                 if (tcsetpgrp(0, getpid()) < 0) {
 402                         syslog(LOG_ERR, "tcsetpgrp failed: %m");
 403                         exit(1);
 404                 }
 405         } else {
 406                 if ((name = getlogin()) == NULL) {
 407                         syslog(LOG_ERR, "access denied - login name not found\n");
 408                         exit(1);
 409                 }
 410                 findid(name);
 411         }
 412         fchmod(0, 0600);
 413         fprintf(stderr, "starting slip login for %s\n", loginname);
 414         fprintf(stderr, "your address is %s\n\n", make_ipaddr());
 415
 416         fflush(stderr);
 417         sleep(1);
 418
 419         /* set up the line parameters */
 420         if (tcgetattr(0, &tios) < 0) {
 421                 syslog(LOG_ERR, "tcgetattr: %m");
 422                 exit(1);
 423         }
 424         otios = tios;
 425         cfmakeraw(&tios);
 426         if (tcsetattr(0, TCSAFLUSH, &tios) < 0) {
 427                 syslog(LOG_ERR, "tcsetattr: %m");
 428                 exit(1);
 429         }
 430         speed = cfgetispeed(&tios);
 431
 432         ldisc = SLIPDISC;
 433         if (ioctl(0, TIOCSETD, &ldisc) < 0) {
 434                 syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
 435                 exit(1);
 436         }
 437         if (slunit >= 0 && ioctl(0, SLIOCSUNIT, &slunit) < 0) {
 438                 syslog(LOG_ERR, "ioctl (SLIOCSUNIT): %m");
 439                 exit(1);
 440         }
 441         /* find out what unit number we were assigned */
 442         if (ioctl(0, SLIOCGUNIT, &unit) < 0) {
 443                 syslog(LOG_ERR, "ioctl (SLIOCGUNIT): %m");
 444                 exit(1);
 445         }
 446         signal(SIGHUP, hup_handler);
 447         signal(SIGTERM, hup_handler);
 448
 449         if (keepal > 0) {
 450                 signal(SIGURG, hup_handler);
 451                 if (ioctl(0, SLIOCSKEEPAL, &keepal) < 0) {
 452                         syslog(LOG_ERR, "ioctl(SLIOCSKEEPAL): %m");
 453                         exit(1);
 454                 }
 455         }
 456         if (outfill > 0 && ioctl(0, SLIOCSOUTFILL, &outfill) < 0) {
 457                 syslog(LOG_ERR, "ioctl(SLIOCSOUTFILL): %m");
 458                 exit(1);
 459         }
 460
 461         /* write pid to file */
 462         pid = getpid();
 463         sprintf(ifname, "sl%d", unit);
 464         sprintf(pidfilename, "%s%s.pid", _PATH_VARRUN, ifname);
 465         if ((pidfile = fopen(pidfilename, "w")) != NULL) {
 466                 fprintf(pidfile, "%d\n", pid);
 467                 fclose(pidfile);
 468         } else {
 469                 syslog(LOG_ERR, "Failed to create pid file %s: %m",
 470                                 pidfilename);
 471                 pidfilename[0] = 0;
 472         }
 473
 474         /* write interface unit number to file */
 475         p = ttyname(0);
 476         if (p)
 477                 strcpy(devnam, p);
 478         for (n = strlen(devnam); n > 0; n--)
 479                 if (devnam[n] == '/') {
 480                         n++;
 481                         break;
 482                 }
 483         sprintf(iffilename, "%s%s.if", _PATH_VARRUN, &devnam[n]);
 484         if ((iffile = fopen(iffilename, "w")) != NULL) {
 485                 fprintf(iffile, "sl%d\n", unit);
 486                 fclose(iffile);
 487         } else {
 488                 syslog(LOG_ERR, "Failed to create if file %s: %m", iffilename);
 489                 iffilename[0] = 0;
 490         }
 491
 492
 493         syslog(LOG_INFO, "attaching slip unit %d for %s\n", unit, loginname);
 494         snprintf(logincmd, sizeof(logincmd), "%s %d %ld %s", loginfile, unit, speed,
 495                  loginargs);
 496         /*
 497          * aim stdout and errout at /dev/null so logincmd output won't
 498          * babble into the slip tty line.
 499          */
 500         close(1);
 501         if ((fd = open(_PATH_DEVNULL, O_WRONLY)) != 1) {
 502                 if (fd < 0) {
 503                         syslog(LOG_ERR, "open %s: %m", _PATH_DEVNULL);
 504                         exit(1);
 505                 }
 506                 dup2(fd, 1);
 507                 close(fd);
 508         }
 509         dup2(1, 2);
 510
 511         /*
 512          * Run login and logout scripts as root (real and effective);
 513          * current route(8) is setuid root, and checks the real uid
 514          * to see whether changes are allowed (or just "route get").
 515          */
 516         setuid(0);
 517         if (s = system(logincmd)) {
 518                 syslog(LOG_ERR, "%s login failed: exit status %d from %s",
 519                        loginname, s, loginfile);
 520                 exit(6);
 521         }
 522
 523         /* Handle any compression or no-icmp flags. */
 524         line_flags(unit);
 525
 526         /* reset uid to users' to allow the user to give a signal. */
 527         seteuid(uid);
 528         /* twiddle thumbs until we get a signal */
 529         while (1)
 530                 sigpause(0);
 531
 532         /* NOTREACHED */
 533 }