pppd/sys-ultrix.c

   1 /*
   2  * sys-ultrix.c - System-dependent procedures for setting up
   3  * PPP interfaces on Ultrix systems.
   4  *
   5  * Copyright (c) 1989 Carnegie Mellon University.
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms are permitted
   9  * provided that the above copyright notice and this paragraph are
  10  * duplicated in all such forms and that any documentation,
  11  * advertising materials, and other materials related to such
  12  * distribution and use acknowledge that the software was developed
  13  * by Carnegie Mellon University.  The name of the
  14  * University may not be used to endorse or promote products derived
  15  * from this software without specific prior written permission.
  16  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  18  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  19  */
  20
  21 #ifndef lint
  22 static char rcsid[] = "$Id: sys-ultrix.c,v 1.6 1994/09/21 06:47:37 paulus Exp $";
  23 #endif
  24
  25 /*
  26  * TODO:
  27  */
  28
  29 #include <stdio.h>
  30 #include <syslog.h>
  31 #include <termios.h>
  32 #include <utmp.h>
  33 #include <sys/types.h>
  34 #include <sys/file.h>
  35 #include <sys/socket.h>
  36 #include <sys/ioctl.h>
  37 #include <sys/time.h>
  38 #include <sys/errno.h>
  39 #include <sys/stat.h>
  40
  41 #include <net/if.h>
  42 #include <net/ppp_defs.h>
  43 #include <net/if_ppp.h>
  44 #include <net/route.h>
  45 #include <netinet/in.h>
  46
  47 #include "pppd.h"
  48
  49 static int initdisc = -1;               /* Initial TTY discipline */
  50
  51 static int restore_term;        /* 1 => we've munged the terminal */
  52 static struct termios inittermios;      /* Initial TTY termios */
  53
  54 /*
  55  * sys_init - System-dependent initialization.
  56  */
  57 void
  58 sys_init()
  59 {
  60     openlog("pppd", LOG_PID);
  61     if (debug)
  62         setlogmask(LOG_UPTO(LOG_DEBUG));
  63 }
  64
  65 /*
  66  * note_debug_level - note a change in the debug level.
  67  */
  68 void
  69 note_debug_level()
  70 {
  71     if (debug) {
  72         syslog(LOG_INFO, "Debug turned ON, Level %d", debug);
  73     }
  74 }
  75
  76 /*
  77  * establish_ppp - Turn the serial port into a ppp interface.
  78  */
  79 void
  80 establish_ppp()
  81 {
  82     int pppdisc = PPPDISC;
  83     int x;
  84
  85     if (ioctl(fd, TIOCGETD, &initdisc) < 0) {
  86         syslog(LOG_ERR, "ioctl(TIOCGETD): %m");
  87         die(1);
  88     }
  89     if (ioctl(fd, TIOCSETD, &pppdisc) < 0) {
  90         syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
  91         die(1);
  92     }
  93
  94     /*
  95      * Find out which interface we were given.
  96      */
  97     if (ioctl(fd, PPPIOCGUNIT, &ifunit) < 0) {
  98         syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m");
  99         die(1);
 100     }
 101
 102     /*
 103      * Enable debug in the driver if requested.
 104      */
 105     if (kdebugflag) {
 106         if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
 107             syslog(LOG_WARNING, "ioctl (PPPIOCGFLAGS): %m");
 108         } else {
 109             x |= (kdebugflag & 0xFF) * SC_DEBUG;
 110             if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0)
 111                 syslog(LOG_WARNING, "ioctl(PPPIOCSFLAGS): %m");
 112         }
 113     }
 114 }
 115
 116
 117 /*
 118  * disestablish_ppp - Restore the serial port to normal operation.
 119  * This shouldn't call die() because it's called from die().
 120  */
 121 void
 122 disestablish_ppp()
 123 {
 124     int x;
 125     char *s;
 126
 127     if (initdisc >= 0) {
 128         /*
 129          * Check whether the link seems not to be 8-bit clean.
 130          */
 131         if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
 132             s = NULL;
 133             switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
 134             case SC_RCV_B7_0:
 135                 s = "bit 7 set to 1";
 136                 break;
 137             case SC_RCV_B7_1:
 138                 s = "bit 7 set to 0";
 139                 break;
 140             case SC_RCV_EVNP:
 141                 s = "odd parity";
 142                 break;
 143             case SC_RCV_ODDP:
 144                 s = "even parity";
 145                 break;
 146             }
 147             if (s != NULL) {
 148                 syslog(LOG_WARNING, "Serial link is not 8-bit clean:");
 149                 syslog(LOG_WARNING, "All received characters had %s", s);
 150             }
 151         }
 152         if (ioctl(fd, TIOCSETD, &initdisc) < 0)
 153             syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
 154     }
 155 }
 156
 157
 158 /*
 159  * List of valid speeds.
 160  */
 161 struct speed {
 162     int speed_int, speed_val;
 163 } speeds[] = {
 164 #ifdef B50
 165     { 50, B50 },
 166 #endif
 167 #ifdef B75
 168     { 75, B75 },
 169 #endif
 170 #ifdef B110
 171     { 110, B110 },
 172 #endif
 173 #ifdef B134
 174     { 134, B134 },
 175 #endif
 176 #ifdef B150
 177     { 150, B150 },
 178 #endif
 179 #ifdef B200
 180     { 200, B200 },
 181 #endif
 182 #ifdef B300
 183     { 300, B300 },
 184 #endif
 185 #ifdef B600
 186     { 600, B600 },
 187 #endif
 188 #ifdef B1200
 189     { 1200, B1200 },
 190 #endif
 191 #ifdef B1800
 192     { 1800, B1800 },
 193 #endif
 194 #ifdef B2000
 195     { 2000, B2000 },
 196 #endif
 197 #ifdef B2400
 198     { 2400, B2400 },
 199 #endif
 200 #ifdef B3600
 201     { 3600, B3600 },
 202 #endif
 203 #ifdef B4800
 204     { 4800, B4800 },
 205 #endif
 206 #ifdef B7200
 207     { 7200, B7200 },
 208 #endif
 209 #ifdef B9600
 210     { 9600, B9600 },
 211 #endif
 212 #ifdef B19200
 213     { 19200, B19200 },
 214 #endif
 215 #ifdef B38400
 216     { 38400, B38400 },
 217 #endif
 218 #ifdef EXTA
 219     { 19200, EXTA },
 220 #endif
 221 #ifdef EXTB
 222     { 38400, EXTB },
 223 #endif
 224 #ifdef B57600
 225     { 57600, B57600 },
 226 #endif
 227 #ifdef B115200
 228     { 115200, B115200 },
 229 #endif
 230     { 0, 0 }
 231 };
 232
 233 /*
 234  * Translate from bits/second to a speed_t.
 235  */
 236 int
 237 translate_speed(bps)
 238     int bps;
 239 {
 240     struct speed *speedp;
 241
 242     if (bps == 0)
 243         return 0;
 244     for (speedp = speeds; speedp->speed_int; speedp++)
 245         if (bps == speedp->speed_int)
 246             return speedp->speed_val;
 247     syslog(LOG_WARNING, "speed %d not supported", bps);
 248     return 0;
 249 }
 250
 251 /*
 252  * Translate from a speed_t to bits/second.
 253  */
 254 int
 255 baud_rate_of(speed)
 256     int speed;
 257 {
 258     struct speed *speedp;
 259
 260     if (speed == 0)
 261         return 0;
 262     for (speedp = speeds; speedp->speed_int; speedp++)
 263         if (speed == speedp->speed_val)
 264             return speedp->speed_int;
 265     return 0;
 266 }
 267
 268 /*
 269  * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
 270  * at the requested speed, etc.  If `local' is true, set CLOCAL
 271  * regardless of whether the modem option was specified.
 272  */
 273 set_up_tty(fd, local)
 274     int fd, local;
 275 {
 276     int speed, x;
 277     struct termios tios;
 278
 279     if (tcgetattr(fd, &tios) < 0) {
 280         syslog(LOG_ERR, "tcgetattr: %m");
 281         die(1);
 282     }
 283
 284     if (!restore_term)
 285         inittermios = tios;
 286
 287 #ifdef CRTSCTS
 288     tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL | CRTSCTS);
 289     if (crtscts == 1)
 290         tios.c_cflag |= CRTSCTS;
 291 #else
 292     tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
 293 #endif  /* CRTSCTS */
 294
 295     tios.c_cflag |= CS8 | CREAD | HUPCL;
 296     if (local || !modem)
 297         tios.c_cflag |= CLOCAL;
 298     tios.c_iflag = IGNBRK | IGNPAR;
 299     tios.c_oflag = 0;
 300     tios.c_lflag = 0;
 301     tios.c_cc[VMIN] = 1;
 302     tios.c_cc[VTIME] = 0;
 303
 304     if (crtscts == 2) {
 305         tios.c_iflag |= IXOFF;
 306         tios.c_cc[VSTOP] = 0x13;        /* DC3 = XOFF = ^S */
 307         tios.c_cc[VSTART] = 0x11;       /* DC1 = XON  = ^Q */
 308     }
 309
 310     speed = translate_speed(inspeed);
 311     if (speed) {
 312         cfsetospeed(&tios, speed);
 313         cfsetispeed(&tios, speed);
 314     } else {
 315         speed = cfgetospeed(&tios);
 316     }
 317
 318     if (tcsetattr(fd, TCSAFLUSH, &tios) < 0) {
 319         syslog(LOG_ERR, "tcsetattr: %m");
 320         die(1);
 321     }
 322
 323     x = 0;
 324     if (ioctl(fd, (crtscts || modem)? TIOCMODEM: TIOCNMODEM, &x) < 0)
 325         syslog(LOG_WARNING, "TIOC(N)MODEM: %m");
 326     if (ioctl(fd, (local || !modem)? TIOCNCAR: TIOCCAR) < 0)
 327         syslog(LOG_WARNING, "TIOC(N)CAR: %m");
 328
 329     baud_rate = inspeed = baud_rate_of(speed);
 330     restore_term = TRUE;
 331 }
 332
 333 /*
 334  * restore_tty - restore the terminal to the saved settings.
 335  */
 336 void
 337 restore_tty()
 338 {
 339     if (restore_term) {
 340         if (tcsetattr(fd, TCSAFLUSH, &inittermios) < 0)
 341             if (errno != ENXIO)
 342                 syslog(LOG_WARNING, "tcsetattr: %m");
 343         restore_term = FALSE;
 344     }
 345 }
 346
 347 /*
 348  * setdtr - control the DTR line on the serial port.
 349  * This is called from die(), so it shouldn't call die().
 350  */
 351 setdtr(fd, on)
 352 int fd, on;
 353 {
 354     int modembits = TIOCM_DTR;
 355
 356     ioctl(fd, (on? TIOCMBIS: TIOCMBIC), &modembits);
 357 }
 358
 359
 360 /*
 361  * output - Output PPP packet.
 362  */
 363 void
 364 output(unit, p, len)
 365     int unit;
 366     u_char *p;
 367     int len;
 368 {
 369     if (unit != 0)
 370         MAINDEBUG((LOG_WARNING, "output: unit != 0!"));
 371     if (debug)
 372         log_packet(p, len, "sent ");
 373
 374     if (write(fd, p, len) < 0) {
 375         syslog(LOG_ERR, "write: %m");
 376         die(1);
 377     }
 378 }
 379
 380
 381 /*
 382  * wait_input - wait until there is data available on fd,
 383  * for the length of time specified by *timo (indefinite
 384  * if timo is NULL).
 385  */
 386 wait_input(timo)
 387     struct timeval *timo;
 388 {
 389     fd_set ready;
 390     int n;
 391
 392     FD_ZERO(&ready);
 393     FD_SET(fd, &ready);
 394     n = select(fd+1, &ready, NULL, &ready, timo);
 395     if (n < 0 && errno != EINTR) {
 396         syslog(LOG_ERR, "select: %m");
 397         die(1);
 398     }
 399 }
 400
 401
 402 /*
 403  * read_packet - get a PPP packet from the serial device.
 404  */
 405 int
 406 read_packet(buf)
 407     u_char *buf;
 408 {
 409     int len;
 410
 411     if ((len = read(fd, buf, PPP_MTU + PPP_HDRLEN)) < 0) {
 412         if (errno == EWOULDBLOCK) {
 413             MAINDEBUG((LOG_DEBUG, "read(fd): EWOULDBLOCK"));
 414             return -1;
 415         }
 416         syslog(LOG_ERR, "read(fd): %m");
 417         die(1);
 418     }
 419     return len;
 420 }
 421
 422
 423 /*
 424  * ppp_send_config - configure the transmit characteristics of
 425  * the ppp interface.
 426  */
 427 void
 428 ppp_send_config(unit, mtu, asyncmap, pcomp, accomp)
 429     int unit, mtu;
 430     u_int32_t asyncmap;
 431     int pcomp, accomp;
 432 {
 433     u_int x;
 434     struct ifreq ifr;
 435
 436     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
 437     ifr.ifr_mtu = mtu;
 438     if (ioctl(s, SIOCSIFMTU, (caddr_t) &ifr) < 0) {
 439         syslog(LOG_ERR, "ioctl(SIOCSIFMTU): %m");
 440         quit();
 441     }
 442
 443     if (ioctl(fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
 444         syslog(LOG_ERR, "ioctl(PPPIOCSASYNCMAP): %m");
 445         quit();
 446     }
 447
 448     if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
 449         syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
 450         quit();
 451     }
 452     x = pcomp? x | SC_COMP_PROT: x &~ SC_COMP_PROT;
 453     x = accomp? x | SC_COMP_AC: x &~ SC_COMP_AC;
 454     if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
 455         syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
 456         quit();
 457     }
 458 }
 459
 460
 461 /*
 462  * ppp_set_xaccm - set the extended transmit ACCM for the interface.
 463  */
 464 void
 465 ppp_set_xaccm(unit, accm)
 466     int unit;
 467     ext_accm accm;
 468 {
 469     if (ioctl(fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY)
 470         syslog(LOG_WARNING, "ioctl(set extended ACCM): %m");
 471 }
 472
 473
 474 /*
 475  * ppp_recv_config - configure the receive-side characteristics of
 476  * the ppp interface.
 477  */
 478 void
 479 ppp_recv_config(unit, mru, asyncmap, pcomp, accomp)
 480     int unit, mru;
 481     u_int32_t asyncmap;
 482     int pcomp, accomp;
 483 {
 484     int x;
 485
 486     if (ioctl(fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
 487         syslog(LOG_ERR, "ioctl(PPPIOCSMRU): %m");
 488         quit();
 489     }
 490     if (ioctl(fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
 491         syslog(LOG_ERR, "ioctl(PPPIOCSRASYNCMAP): %m");
 492         quit();
 493     }
 494     if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
 495         syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
 496         quit();
 497     }
 498     x = !accomp? x | SC_REJ_COMP_AC: x &~ SC_REJ_COMP_AC;
 499     if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
 500         syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
 501         quit();
 502     }
 503 }
 504
 505 /*
 506  * ccp_flags_set - inform kernel about the current state of CCP.
 507  */
 508 void
 509 ccp_flags_set(unit, isopen, isup)
 510     int unit, isopen, isup;
 511 {
 512     int x;
 513
 514     if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
 515         syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
 516         return;
 517     }
 518     x = isopen? x | SC_CCP_OPEN: x &~ SC_CCP_OPEN;
 519     x = isup? x | SC_CCP_UP: x &~ SC_CCP_UP;
 520     if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0)
 521         syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
 522 }
 523
 524 /*
 525  * sifvjcomp - config tcp header compression
 526  */
 527 int
 528 sifvjcomp(u, vjcomp, cidcomp, maxcid)
 529     int u, vjcomp, cidcomp, maxcid;
 530 {
 531     u_int x;
 532
 533     if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
 534         syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
 535         return 0;
 536     }
 537     x = vjcomp ? x | SC_COMP_TCP: x &~ SC_COMP_TCP;
 538     x = cidcomp? x & ~SC_NO_TCP_CCID: x | SC_NO_TCP_CCID;
 539     if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
 540         syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
 541         return 0;
 542     }
 543     if (ioctl(fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
 544         syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
 545         return 0;
 546     }
 547     return 1;
 548 }
 549
 550 /*
 551  * sifup - Config the interface up and enable IP packets to pass.
 552  */
 553 int
 554 sifup(u)
 555 {
 556     struct ifreq ifr;
 557     u_int x;
 558
 559     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
 560     if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
 561         syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
 562         return 0;
 563     }
 564     ifr.ifr_flags |= IFF_UP;
 565     if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
 566         syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
 567         return 0;
 568     }
 569     if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
 570         syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
 571         return 0;
 572     }
 573     x |= SC_ENABLE_IP;
 574     if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
 575         syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
 576         return 0;
 577     }
 578     return 1;
 579 }
 580
 581 /*
 582  * sifdown - Config the interface down and disable IP.
 583  */
 584 int
 585 sifdown(u)
 586 {
 587     struct ifreq ifr;
 588     u_int x;
 589     int rv;
 590
 591     rv = 1;
 592     if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
 593         syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
 594         rv = 0;
 595     } else {
 596         x &= ~SC_ENABLE_IP;
 597         if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
 598             syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
 599             rv = 0;
 600         }
 601     }
 602     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
 603     if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
 604         syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
 605         rv = 0;
 606     } else {
 607         ifr.ifr_flags &= ~IFF_UP;
 608         if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
 609             syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
 610             rv = 0;
 611         }
 612     }
 613     return rv;
 614 }
 615
 616 /*
 617  * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
 618  * if it exists.
 619  */
 620 #define SET_SA_FAMILY(addr, family)             \
 621     BZERO((char *) &(addr), sizeof(addr));      \
 622     addr.sa_family = (family);
 623
 624 /*
 625  * sifaddr - Config the interface IP addresses and netmask.
 626  */
 627 int
 628 sifaddr(u, o, h, m)
 629 {
 630     int ret;
 631     struct ifreq ifr;
 632
 633     ret = 1;
 634     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
 635     SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
 636     ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = o;
 637     if (ioctl(s, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
 638         syslog(LOG_ERR, "ioctl(SIOCSIFADDR): %m");
 639         ret = 0;
 640     }
 641     ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = h;
 642     if (ioctl(s, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
 643         syslog(LOG_ERR, "ioctl(SIOCSIFDSTADDR): %m");
 644         ret = 0;
 645     }
 646     if (m != 0) {
 647         ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = m;
 648         syslog(LOG_INFO, "Setting interface mask to %s\n", ip_ntoa(m));
 649         if (ioctl(s, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
 650             syslog(LOG_ERR, "ioctl(SIOCSIFNETMASK): %m");
 651             ret = 0;
 652         }
 653     }
 654     return ret;
 655 }
 656
 657 /*
 658  * cifaddr - Clear the interface IP addresses, and delete routes
 659  * through the interface if possible.
 660  */
 661 int
 662 cifaddr(u, o, h)
 663 {
 664     struct rtentry rt;
 665
 666     SET_SA_FAMILY(rt.rt_dst, AF_INET);
 667     ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = h;
 668     SET_SA_FAMILY(rt.rt_gateway, AF_INET);
 669     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = o;
 670     rt.rt_flags = RTF_HOST;
 671     if (ioctl(s, SIOCDELRT, (caddr_t) &rt) < 0) {
 672         syslog(LOG_ERR, "ioctl(SIOCDELRT): %m");
 673         return 0;
 674     }
 675     return 1;
 676 }
 677
 678 /*
 679  * sifdefaultroute - assign a default route through the address given.
 680  */
 681 int
 682 sifdefaultroute(u, g)
 683 {
 684     struct rtentry rt;
 685
 686     SET_SA_FAMILY(rt.rt_dst, AF_INET);
 687     SET_SA_FAMILY(rt.rt_gateway, AF_INET);
 688     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = g;
 689     rt.rt_flags = RTF_GATEWAY;
 690     if (ioctl(s, SIOCADDRT, &rt) < 0) {
 691         syslog(LOG_ERR, "default route ioctl(SIOCADDRT): %m");
 692         return 0;
 693     }
 694     return 1;
 695 }
 696
 697 /*
 698  * cifdefaultroute - delete a default route through the address given.
 699  */
 700 int
 701 cifdefaultroute(u, g)
 702 {
 703     struct rtentry rt;
 704
 705     SET_SA_FAMILY(rt.rt_dst, AF_INET);
 706     SET_SA_FAMILY(rt.rt_gateway, AF_INET);
 707     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = g;
 708     rt.rt_flags = RTF_GATEWAY;
 709     if (ioctl(s, SIOCDELRT, &rt) < 0)
 710         syslog(LOG_WARNING, "default route ioctl(SIOCDELRT): %m");
 711 }
 712
 713 /*
 714  * sifproxyarp - Make a proxy ARP entry for the peer.
 715  */
 716 int
 717 sifproxyarp(unit, hisaddr)
 718     int unit;
 719     u_int32_t hisaddr;
 720 {
 721     struct arpreq arpreq;
 722
 723     BZERO(&arpreq, sizeof(arpreq));
 724
 725     /*
 726      * Get the hardware address of an interface on the same subnet
 727      * as our local address.
 728      */
 729     if (!get_ether_addr(hisaddr, &arpreq.arp_ha)) {
 730         syslog(LOG_ERR, "Cannot determine ethernet address for proxy ARP");
 731         return 0;
 732     }
 733
 734     SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
 735     ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = hisaddr;
 736     arpreq.arp_flags = ATF_PERM | ATF_PUBL;
 737     if (ioctl(s, SIOCSARP, (caddr_t)&arpreq) < 0) {
 738         syslog(LOG_ERR, "ioctl(SIOCSARP): %m");
 739         return 0;
 740     }
 741
 742     return 1;
 743 }
 744
 745 /*
 746  * cifproxyarp - Delete the proxy ARP entry for the peer.
 747  */
 748 int
 749 cifproxyarp(unit, hisaddr)
 750     int unit;
 751     u_int32_t hisaddr;
 752 {
 753     struct arpreq arpreq;
 754
 755     BZERO(&arpreq, sizeof(arpreq));
 756     SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
 757     ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = hisaddr;
 758     if (ioctl(s, SIOCDARP, (caddr_t)&arpreq) < 0) {
 759         syslog(LOG_WARNING, "ioctl(SIOCDARP): %m");
 760         return 0;
 761     }
 762     return 1;
 763 }
 764
 765 /*
 766  * get_ether_addr - get the hardware address of an interface on the
 767  * the same subnet as ipaddr.
 768  */
 769 #define MAX_IFS         32
 770
 771 int
 772 get_ether_addr(ipaddr, hwaddr)
 773     u_int32_t ipaddr;
 774     struct sockaddr *hwaddr;
 775 {
 776     struct ifreq *ifr, *ifend, *ifp;
 777     u_int32_t ina, mask;
 778     struct sockaddr_dl *dla;
 779     struct ifreq ifreq;
 780     struct ifconf ifc;
 781     struct ifreq ifs[MAX_IFS];
 782
 783     ifc.ifc_len = sizeof(ifs);
 784     ifc.ifc_req = ifs;
 785     if (ioctl(s, SIOCGIFCONF, &ifc) < 0) {
 786         syslog(LOG_ERR, "ioctl(SIOCGIFCONF): %m");
 787         return 0;
 788     }
 789
 790     /*
 791      * Scan through looking for an interface with an Internet
 792      * address on the same subnet as `ipaddr'.
 793      */
 794     ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
 795     for (ifr = ifc.ifc_req; ifr < ifend; ) {
 796         if (ifr->ifr_addr.sa_family == AF_INET) {
 797             ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
 798             strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
 799             /*
 800              * Check that the interface is up, and not point-to-point
 801              * or loopback.
 802              */
 803             if (ioctl(s, SIOCGIFFLAGS, &ifreq) < 0)
 804                 continue;
 805             if ((ifreq.ifr_flags &
 806                  (IFF_UP|IFF_BROADCAST|IFF_POINTOPOINT|IFF_LOOPBACK|IFF_NOARP))
 807                  != (IFF_UP|IFF_BROADCAST))
 808                 continue;
 809             /*
 810              * Get its netmask and check that it's on the right subnet.
 811              */
 812             if (ioctl(s, SIOCGIFNETMASK, &ifreq) < 0)
 813                 continue;
 814             mask = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
 815             if ((ipaddr & mask) != (ina & mask))
 816                 continue;
 817
 818             break;
 819         }
 820         ifr = (struct ifreq *) ((char *)&ifr->ifr_addr + sizeof(struct sockaddr)
 821 );
 822     }
 823
 824     if (ifr >= ifend)
 825         return 0;
 826     syslog(LOG_DEBUG, "found interface %s for proxy arp", ifr->ifr_name);
 827
 828     /*
 829      * Now scan through again looking for a link-level address
 830      * for this interface.
 831      */
 832     ifp = ifr;
 833     for (ifr = ifc.ifc_req; ifr < ifend; ) {
 834         if (strcmp(ifp->ifr_name, ifr->ifr_name) == 0
 835             && ifr->ifr_addr.sa_family == AF_DLI) {
 836 /*          && ifr->ifr_addr.sa_family == AF_LINK) { Per! Kolla !!! ROHACK */
 837             /*
 838              * Found the link-level address - copy it out
 839              */
 840             dla = (struct sockaddr_dl *)&ifr->ifr_addr;
 841             hwaddr->sa_family = AF_UNSPEC;
 842             BCOPY(dla, hwaddr->sa_data, sizeof(hwaddr->sa_data));
 843             return 1;
 844         }
 845         ifr = (struct ifreq *) ((char *)&ifr->ifr_addr + sizeof(struct sockaddr)
 846 );
 847     }
 848
 849     return 0;
 850 }
 851
 852
 853 /*
 854  * ppp_available - check whether the system has any ppp interfaces
 855  * (in fact we check whether we can do an ioctl on ppp0).
 856  */
 857
 858 int
 859 ppp_available()
 860 {
 861     int s, ok;
 862     struct ifreq ifr;
 863
 864     if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
 865         return 1;               /* can't tell - maybe we're not root */
 866
 867     strncpy(ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
 868     ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
 869     close(s);
 870
 871     return ok;
 872 }
 873
 874
 875 /*
 876   Seems like strdup() is not part of string package in Ultrix.
 877   If I understood the man-page on the sun this should work.
 878
 879   Robert Olsson
 880 */
 881
 882 char *strdup( in ) char *in;
 883 {
 884   char* dup;
 885   if(! (dup = (char *) malloc( strlen( in ) +1 ))) return NULL;
 886   (void) strcpy( dup, in );
 887   return dup;
 888 }
 889
 890 /*
 891  * This logwtmp() implementation is subject to the following copyright:
 892  *
 893  * Copyright (c) 1988 The Regents of the University of California.
 894  * All rights reserved.
 895  *
 896  * Redistribution and use in source and binary forms are permitted
 897  * provided that the above copyright notice and this paragraph are
 898  * duplicated in all such forms and that any documentation,
 899  * advertising materials, and other materials related to such
 900  * distribution and use acknowledge that the software was developed
 901  * by the University of California, Berkeley.  The name of the
 902  * University may not be used to endorse or promote products derived
 903  * from this software without specific prior written permission.
 904  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 905  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 906  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 907  */
 908
 909 #define WTMPFILE        "/usr/adm/wtmp"
 910
 911 int
 912 logwtmp(line, name, host)
 913     char *line, *name, *host;
 914 {
 915     int fd;
 916     struct stat buf;
 917     struct utmp ut;
 918
 919     if ((fd = open(WTMPFILE, O_WRONLY|O_APPEND, 0)) < 0)
 920         return;
 921     if (!fstat(fd, &buf)) {
 922         (void)strncpy(ut.ut_line, line, sizeof(ut.ut_line));
 923         (void)strncpy(ut.ut_name, name, sizeof(ut.ut_name));
 924         (void)strncpy(ut.ut_host, host, sizeof(ut.ut_host));
 925         (void)time(&ut.ut_time);
 926         if (write(fd, (char *)&ut, sizeof(struct utmp)) != sizeof(struct utmp))
 927             (void)ftruncate(fd, buf.st_size);
 928     }
 929     close(fd);
 930 }