add ccp_test
[ppp.git] / pppd / sys-bsd.c
index cb105f5ac0b3e873c17e65304a659a29da0e3fd8..f07a3b7351b7fa8462f8d2700d3c77ff4018b56d 100644 (file)
@@ -19,7 +19,7 @@
  */
 
 #ifndef lint
-static char rcsid[] = "$Id: sys-bsd.c,v 1.2 1993/12/14 05:41:11 paulus Exp $";
+static char rcsid[] = "$Id: sys-bsd.c,v 1.9 1994/08/22 00:41:00 paulus Exp $";
 #endif
 
 /*
@@ -39,11 +39,16 @@ static char rcsid[] = "$Id: sys-bsd.c,v 1.2 1993/12/14 05:41:11 paulus Exp $";
 #include <net/if_dl.h>
 #include <netinet/in.h>
 
+#if RTM_VERSION >= 3
+#include <netinet/if_ether.h>
+#endif
+
 #include "pppd.h"
 #include "ppp.h"
 
-static int initdisc;           /* Initial TTY discipline */
-
+static int initdisc = -1;              /* Initial TTY discipline */
+extern int kdebugflag;
+static int rtm_seq;
 
 /*
  * establish_ppp - Turn the serial port into a ppp interface.
@@ -52,6 +57,7 @@ void
 establish_ppp()
 {
     int pppdisc = PPPDISC;
+    int x;
 
     if (ioctl(fd, TIOCGETD, &initdisc) < 0) {
        syslog(LOG_ERR, "ioctl(TIOCGETD): %m");
@@ -69,6 +75,19 @@ establish_ppp()
        syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m");
        die(1);
     }
+
+    /*
+     * Enable debug in the driver if requested.
+     */
+    if (kdebugflag) {
+       if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
+           syslog(LOG_WARNING, "ioctl (PPPIOCGFLAGS): %m");
+       } else {
+           x |= (kdebugflag & 0xFF) * SC_DEBUG;
+           if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0)
+               syslog(LOG_WARNING, "ioctl(PPPIOCSFLAGS): %m");
+       }
+    }
 }
 
 
@@ -79,8 +98,37 @@ establish_ppp()
 void
 disestablish_ppp()
 {
-    if (ioctl(fd, TIOCSETD, &initdisc) < 0)
-       syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
+    int x;
+    char *s;
+
+    if (initdisc >= 0) {
+       /*
+        * Check whether the link seems not to be 8-bit clean.
+        */
+       if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
+           s = NULL;
+           switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
+           case SC_RCV_B7_0:
+               s = "bit 7 set to 1";
+               break;
+           case SC_RCV_B7_1:
+               s = "bit 7 set to 0";
+               break;
+           case SC_RCV_EVNP:
+               s = "odd parity";
+               break;
+           case SC_RCV_ODDP:
+               s = "even parity";
+               break;
+           }
+           if (s != NULL) {
+               syslog(LOG_WARNING, "Serial link is not 8-bit clean:");
+               syslog(LOG_WARNING, "All received characters had %s", s);
+           }
+       }
+       if (ioctl(fd, TIOCSETD, &initdisc) < 0)
+           syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
+    }
 }
 
 
@@ -95,6 +143,8 @@ output(unit, p, len)
 {
     if (unit != 0)
        MAINDEBUG((LOG_WARNING, "output: unit != 0!"));
+    if (debug)
+       log_packet(p, len, "sent ");
 
     if (write(fd, p, len) < 0) {
        syslog(LOG_ERR, "write: %m");
@@ -103,6 +153,27 @@ output(unit, p, len)
 }
 
 
+/*
+ * wait_input - wait until there is data available on fd,
+ * for the length of time specified by *timo (indefinite
+ * if timo is NULL).
+ */
+wait_input(timo)
+    struct timeval *timo;
+{
+    fd_set ready;
+    int n;
+
+    FD_ZERO(&ready);
+    FD_SET(fd, &ready);
+    n = select(fd+1, &ready, NULL, &ready, timo);
+    if (n < 0 && errno != EINTR) {
+       syslog(LOG_ERR, "select: %m");
+       die(1);
+    }
+}
+
+
 /*
  * read_packet - get a PPP packet from the serial device.
  */
@@ -161,9 +232,23 @@ ppp_send_config(unit, mtu, asyncmap, pcomp, accomp)
     }
 }
 
+
+/*
+ * ppp_set_xaccm - set the extended transmit ACCM for the interface.
+ */
+void
+ppp_set_xaccm(unit, accm)
+    int unit;
+    ext_accm accm;
+{
+    if (ioctl(fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY)
+       syslog(LOG_WARNING, "ioctl(set extended ACCM): %m");
+}
+
+
 /*
  * ppp_recv_config - configure the receive-side characteristics of
- * the ppp interface.  At present this does nothing.
+ * the ppp interface.
  */
 void
 ppp_recv_config(unit, mru, asyncmap, pcomp, accomp)
@@ -171,12 +256,16 @@ ppp_recv_config(unit, mru, asyncmap, pcomp, accomp)
     u_long asyncmap;
     int pcomp, accomp;
 {
-#ifdef notyet
+    int x;
+
+    if (ioctl(fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
+       syslog(LOG_ERR, "ioctl(PPPIOCSMRU): %m");
+       quit();
+    }
     if (ioctl(fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
        syslog(LOG_ERR, "ioctl(PPPIOCSRASYNCMAP): %m");
        quit();
     }
-
     if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
        syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
        quit();
@@ -186,14 +275,49 @@ ppp_recv_config(unit, mru, asyncmap, pcomp, accomp)
        syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
        quit();
     }
-#endif /* notyet */
+}
+
+/*
+ * ccp_test - ask kernel whether a given compression method
+ * is acceptable for use.
+ */
+ccp_test(unit, opt_ptr, opt_len, for_transmit)
+    int unit, opt_len, for_transmit;
+    u_char *opt_ptr;
+{
+    struct ppp_comp_data data;
+
+    data.ptr = opt_ptr;
+    data.length = opt_len;
+    data.transmit = for_transmit;
+    return ioctl(fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0;
+}
+
+/*
+ * ccp_flags_set - inform kernel about the current state of CCP.
+ */
+void
+ccp_flags_set(unit, isopen, isup)
+    int unit, isopen, isup;
+{
+    int x;
+
+    if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
+       syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
+       return;
+    }
+    x = isopen? x | SC_CCP_OPEN: x &~ SC_CCP_OPEN;
+    x = isup? x | SC_CCP_UP: x &~ SC_CCP_UP;
+    if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0)
+       syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
 }
 
 /*
  * sifvjcomp - config tcp header compression
  */
 int
-sifvjcomp(u, vjcomp, cidcomp)
+sifvjcomp(u, vjcomp, cidcomp, maxcid)
+    int u, vjcomp, cidcomp, maxcid;
 {
     u_int x;
 
@@ -203,7 +327,11 @@ sifvjcomp(u, vjcomp, cidcomp)
     }
     x = vjcomp ? x | SC_COMP_TCP: x &~ SC_COMP_TCP;
     x = cidcomp? x & ~SC_NO_TCP_CCID: x | SC_NO_TCP_CCID;
-    if(ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
+    if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
+       syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
+       return 0;
+    }
+    if (ioctl(fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
        syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
        return 0;
     }
@@ -211,12 +339,15 @@ sifvjcomp(u, vjcomp, cidcomp)
 }
 
 /*
- * sifup - Config the interface up.
+ * sifup - Config the interface up and enable IP packets to pass.
  */
 int
 sifup(u)
+    int u;
 {
     struct ifreq ifr;
+    u_int x;
+
     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
     if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
        syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
@@ -227,27 +358,52 @@ sifup(u)
        syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
        return 0;
     }
+    if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
+       syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
+       return 0;
+    }
+    x |= SC_ENABLE_IP;
+    if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
+       syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
+       return 0;
+    }
     return 1;
 }
 
 /*
- * sifdown - Config the interface down.
+ * sifdown - Config the interface down and disable IP.
  */
 int
 sifdown(u)
+    int u;
 {
     struct ifreq ifr;
+    u_int x;
+    int rv;
+
+    rv = 1;
+    if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
+       syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
+       rv = 0;
+    } else {
+       x &= ~SC_ENABLE_IP;
+       if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
+           syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
+           rv = 0;
+       }
+    }
     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
     if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
        syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
-       return 0;
-    }
-    ifr.ifr_flags &= ~IFF_UP;
-    if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
-       syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
-       return 0;
+       rv = 0;
+    } else {
+       ifr.ifr_flags &= ~IFF_UP;
+       if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
+           syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
+           rv = 0;
+       }
     }
-    return 1;
+    return rv;
 }
 
 /*
@@ -264,6 +420,8 @@ sifdown(u)
  */
 int
 sifaddr(u, o, h, m)
+    int u;
+    u_long o, h, m;
 {
     struct ifaliasreq ifra;
 
@@ -293,6 +451,8 @@ sifaddr(u, o, h, m)
  */
 int
 cifaddr(u, o, h)
+    int u;
+    u_long o, h;
 {
     struct ifaliasreq ifra;
 
@@ -314,36 +474,164 @@ cifaddr(u, o, h)
  */
 int
 sifdefaultroute(u, g)
+    int u;
+    u_long g;
+{
+    return dodefaultroute(g, 's');
+}
+
+/*
+ * cifdefaultroute - delete a default route through the address given.
+ */
+int
+cifdefaultroute(u, g)
+    int u;
+    u_long g;
+{
+    return dodefaultroute(g, 'c');
+}
+
+/*
+ * dodefaultroute - talk to a routing socket to add/delete a default route.
+ */
+int
+dodefaultroute(g, cmd)
+    u_long g;
+    int cmd;
 {
-    struct ortentry rt;
-
-    SET_SA_FAMILY(rt.rt_dst, AF_INET);
-    SET_SA_FAMILY(rt.rt_gateway, AF_INET);
-    ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = g;
-    rt.rt_flags = RTF_GATEWAY;
-    if (ioctl(s, SIOCADDRT, &rt) < 0) {
-       syslog(LOG_ERR, "default route ioctl(SIOCADDRT): %m");
+    int routes;
+    struct {
+       struct rt_msghdr        hdr;
+       struct sockaddr_in      dst;
+       struct sockaddr_in      gway;
+       struct sockaddr_in      mask;
+    } rtmsg;
+
+    if ((routes = socket(PF_ROUTE, SOCK_RAW, AF_INET)) < 0) {
+       syslog(LOG_ERR, "%cifdefaultroute: opening routing socket: %m", cmd);
        return 0;
     }
+
+    memset(&rtmsg, 0, sizeof(rtmsg));
+    rtmsg.hdr.rtm_type = cmd == 's'? RTM_ADD: RTM_DELETE;
+    rtmsg.hdr.rtm_flags = RTF_UP | RTF_GATEWAY;
+    rtmsg.hdr.rtm_version = RTM_VERSION;
+    rtmsg.hdr.rtm_seq = ++rtm_seq;
+    rtmsg.hdr.rtm_addrs = RTA_DST | RTA_GATEWAY | RTA_NETMASK;
+    rtmsg.dst.sin_len = sizeof(rtmsg.dst);
+    rtmsg.dst.sin_family = AF_INET;
+    rtmsg.gway.sin_len = sizeof(rtmsg.gway);
+    rtmsg.gway.sin_family = AF_INET;
+    rtmsg.gway.sin_addr.s_addr = g;
+    rtmsg.mask.sin_len = sizeof(rtmsg.dst);
+    rtmsg.mask.sin_family = AF_INET;
+
+    rtmsg.hdr.rtm_msglen = sizeof(rtmsg);
+    if (write(routes, &rtmsg, sizeof(rtmsg)) < 0) {
+       syslog(LOG_ERR, "%s default route: %m", cmd=='s'? "add": "delete");
+       close(routes);
+       return 0;
+    }
+
+    close(routes);
     return 1;
 }
 
+#if RTM_VERSION >= 3
+
 /*
- * cifdefaultroute - delete a default route through the address given.
+ * sifproxyarp - Make a proxy ARP entry for the peer.
  */
+static struct {
+    struct rt_msghdr           hdr;
+    struct sockaddr_inarp      dst;
+    struct sockaddr_dl         hwa;
+    char                       extra[128];
+} arpmsg;
+
+static int arpmsg_valid;
+
 int
-cifdefaultroute(u, g)
+sifproxyarp(unit, hisaddr)
+    int unit;
+    u_long hisaddr;
+{
+    int routes;
+    int l;
+
+    /*
+     * Get the hardware address of an interface on the same subnet
+     * as our local address.
+     */
+    memset(&arpmsg, 0, sizeof(arpmsg));
+    if (!get_ether_addr(hisaddr, &arpmsg.hwa)) {
+       syslog(LOG_ERR, "Cannot determine ethernet address for proxy ARP");
+       return 0;
+    }
+
+    if ((routes = socket(PF_ROUTE, SOCK_RAW, AF_INET)) < 0) {
+       syslog(LOG_ERR, "sifproxyarp: opening routing socket: %m");
+       return 0;
+    }
+
+    arpmsg.hdr.rtm_type = RTM_ADD;
+    arpmsg.hdr.rtm_flags = RTF_ANNOUNCE | RTF_HOST | RTF_STATIC;
+    arpmsg.hdr.rtm_version = RTM_VERSION;
+    arpmsg.hdr.rtm_seq = ++rtm_seq;
+    arpmsg.hdr.rtm_addrs = RTA_DST | RTA_GATEWAY;
+    arpmsg.hdr.rtm_inits = RTV_EXPIRE;
+    arpmsg.dst.sin_len = sizeof(struct sockaddr_inarp);
+    arpmsg.dst.sin_family = AF_INET;
+    arpmsg.dst.sin_addr.s_addr = hisaddr;
+    arpmsg.dst.sin_other = SIN_PROXY;
+
+    arpmsg.hdr.rtm_msglen = (char *) &arpmsg.hwa - (char *) &arpmsg
+       + arpmsg.hwa.sdl_len;
+    if (write(routes, &arpmsg, arpmsg.hdr.rtm_msglen) < 0) {
+       syslog(LOG_ERR, "add proxy arp entry: %m");
+       close(routes);
+       return 0;
+    }
+
+    close(routes);
+    arpmsg_valid = 1;
+    return 1;
+}
+
+/*
+ * cifproxyarp - Delete the proxy ARP entry for the peer.
+ */
+int
+cifproxyarp(unit, hisaddr)
+    int unit;
+    u_long hisaddr;
 {
-    struct ortentry rt;
-
-    SET_SA_FAMILY(rt.rt_dst, AF_INET);
-    SET_SA_FAMILY(rt.rt_gateway, AF_INET);
-    ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = g;
-    rt.rt_flags = RTF_GATEWAY;
-    if (ioctl(s, SIOCDELRT, &rt) < 0)
-       syslog(LOG_WARNING, "default route ioctl(SIOCDELRT): %m");
+    int routes;
+
+    if (!arpmsg_valid)
+       return 0;
+    arpmsg_valid = 0;
+
+    arpmsg.hdr.rtm_type = RTM_DELETE;
+    arpmsg.hdr.rtm_seq = ++rtm_seq;
+
+    if ((routes = socket(PF_ROUTE, SOCK_RAW, AF_INET)) < 0) {
+       syslog(LOG_ERR, "sifproxyarp: opening routing socket: %m");
+       return 0;
+    }
+
+    if (write(routes, &arpmsg, arpmsg.hdr.rtm_msglen) < 0) {
+       syslog(LOG_ERR, "delete proxy arp entry: %m");
+       close(routes);
+       return 0;
+    }
+
+    close(routes);
+    return 1;
 }
 
+#else  /* RTM_VERSION */
+
 /*
  * sifproxyarp - Make a proxy ARP entry for the peer.
  */
@@ -353,6 +641,10 @@ sifproxyarp(unit, hisaddr)
     u_long hisaddr;
 {
     struct arpreq arpreq;
+    struct {
+       struct sockaddr_dl      sdl;
+       char                    space[128];
+    } dls;
 
     BZERO(&arpreq, sizeof(arpreq));
 
@@ -360,11 +652,14 @@ sifproxyarp(unit, hisaddr)
      * Get the hardware address of an interface on the same subnet
      * as our local address.
      */
-    if (!get_ether_addr(hisaddr, &arpreq.arp_ha)) {
+    if (!get_ether_addr(hisaddr, &dls.sdl)) {
        syslog(LOG_ERR, "Cannot determine ethernet address for proxy ARP");
        return 0;
     }
 
+    arpreq.arp_ha.sa_len = sizeof(struct sockaddr);
+    arpreq.arp_ha.sa_family = AF_UNSPEC;
+    BCOPY(LLADDR(&dls.sdl), arpreq.arp_ha.sa_data, dls.sdl.sdl_alen);
     SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
     ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = hisaddr;
     arpreq.arp_flags = ATF_PERM | ATF_PUBL;
@@ -395,6 +690,8 @@ cifproxyarp(unit, hisaddr)
     }
     return 1;
 }
+#endif /* RTM_VERSION */
+
 
 /*
  * get_ether_addr - get the hardware address of an interface on the
@@ -405,7 +702,7 @@ cifproxyarp(unit, hisaddr)
 int
 get_ether_addr(ipaddr, hwaddr)
     u_long ipaddr;
-    struct sockaddr *hwaddr;
+    struct sockaddr_dl *hwaddr;
 {
     struct ifreq *ifr, *ifend, *ifp;
     u_long ina, mask;
@@ -469,10 +766,8 @@ get_ether_addr(ipaddr, hwaddr)
            /*
             * Found the link-level address - copy it out
             */
-           dla = (struct sockaddr_dl *)&ifr->ifr_addr;
-           hwaddr->sa_len = sizeof(struct sockaddr);
-           hwaddr->sa_family = AF_UNSPEC;
-           BCOPY(LLADDR(dla), hwaddr->sa_data, dla->sdl_alen);
+           dla = (struct sockaddr_dl *) &ifr->ifr_addr;
+           BCOPY(dla, hwaddr, dla->sdl_len);
            return 1;
        }
        ifr = (struct ifreq *) ((char *)&ifr->ifr_addr + ifr->ifr_addr.sa_len);
@@ -481,11 +776,11 @@ get_ether_addr(ipaddr, hwaddr)
     return 0;
 }
 
+
 /*
  * ppp_available - check whether the system has any ppp interfaces
  * (in fact we check whether we can do an ioctl on ppp0).
  */
-
 int
 ppp_available()
 {