开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
ppp_vxworks.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：18k
源码类别：

VxWorks

开发平台：

C/C++

ppp_vxworks.c：源码内容
  1. /* ppp_vxworks.c - System-dependent procedures for setting up PPP interfaces */
  3. /* Copyright 1995 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1989 Carnegie Mellon University.
  8.  * All rights reserved.
  9.  *
  10.  * Redistribution and use in source and binary forms are permitted
  11.  * provided that the above copyright notice and this paragraph are
  12.  * duplicated in all such forms and that any documentation,
  13.  * advertising materials, and other materials related to such
  14.  * distribution and use acknowledge that the software was developed
  15.  * by Carnegie Mellon University.  The name of the
  16.  * University may not be used to endorse or promote products derived
  17.  * from this software without specific prior written permission.
  18.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  19.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  20.  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  21.  */
  23. /*
  24. modification history
  25. --------------------
  26. 01i,30jan01,ijm  Fixed spr 34274, OPT_PROXYARP is not setting ARP entry
  27.  correctly.  It times out.
  28. 01h,17feb99,sgv  Fixed spr 22486, Proxy Arp fix.
  29. 01g,05aug96,vin  upgraded to BSD4.4., replaced rtentry with ortentry,
  30.  reworked get_ether_addr since ifreq struct changed.
  31.  switched the order of initialization in sifaddr(). 
  32. 01f,16jun95,dzb  header file consolidation.
  33. 01e,15may95,dzb  changed LOG_ERR for route delete to LOG_WARNING.
  34. 01d,06mar95,dzb  proxyArp fix (SPR #4074).
  35. 01c,07feb95,dzb  changed to look for OK from pppwrite().
  36. 01b,16jan95,dzb  renamed to ppp_vxworks.c. warnings cleanup.
  37. 01a,21dec94,dab  VxWorks port - first WRS version.
  38.    +dzb  added: path for ppp header files, WRS copyright.
  39. */
  41. #include "vxWorks.h"
  42. #include "string.h"
  43. #include "stdlib.h"
  44. #include "stdio.h"
  45. #include "ioctl.h"
  46. #include "ioLib.h"
  47. #include "sys/ioctl.h"
  48. #include "sys/types.h"
  49. #include "sys/socket.h"
  50. #include "sys/times.h"
  51. #include "net/if.h"
  52. #include "net/if_arp.h"
  53. #include "netinet/if_ether.h"
  54. #include "net/if_dl.h"
  55. #include "errno.h"
  56. #include "net/if.h"
  57. #include "net/route.h"
  58. #include "netinet/in.h"
  59. #include "pppLib.h"
  60. #include "logLib.h"
  62. IMPORT struct ifnet     *ifnet;         /* list of all network interfaces */
  63. IMPORT void arptfree (struct llinfo_arp *);
  64.  
  65. int pppArpCmd (int cmd, struct arpreq * ar);
  69. /*
  70.  * establish_ppp - Turn the serial port into a ppp interface.
  71.  */
  72. void
  73. establish_ppp()
  74. {
  75.     int x;
  77.     /* get ppp fd */
  78.     if (ppptioctl(ppp_unit, PPPIOCGFD, (caddr_t) &(ppp_if[ppp_unit]->fd)) < 0) {
  79.         syslog(LOG_ERR, "ppptioctl(PPPIOCGFD) error");
  80.         die(ppp_unit, 1);
  81.     }
  83.     /*
  84.      * Enable debug in the driver if requested.
  85.      */
  86.     if (ppp_if[ppp_unit]->kdebugflag) {
  87.         if (ppptioctl(ppp_unit, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
  88.             syslog(LOG_WARNING, "ioctl (PPPIOCGFLAGS): error");
  89.         } else {
  90.             x |= (ppp_if[ppp_unit]->kdebugflag & 0xFF) * SC_DEBUG;
  91.             if (ppptioctl(ppp_unit, PPPIOCSFLAGS, (caddr_t) &x) < 0)
  92.                 syslog(LOG_WARNING, "ioctl(PPPIOCSFLAGS): error");
  93.         }
  94.     }
  95. }
  98. /*
  99.  * disestablish_ppp - Restore the serial port to normal operation.
  100.  * This shouldn't call die() because it's called from die().
  101.  */
  102. void
  103. disestablish_ppp()
  104. {
  105. }
  108. /*
  109.  * output - Output PPP packet.
  110.  */
  111. void
  112. output(unit, p, len)
  113.     int unit;
  114.     u_char *p;
  115.     int len;
  116. {
  117.     if (ppp_if[unit]->debug)
  118.         log_packet(p, len, "sent ");
  120.     if (pppwrite(unit, (char *) p, len) != OK) {
  121. syslog(LOG_ERR, "write error");
  122. die(unit, 1);
  123.     }
  124. }
  127. /*
  128.  * read_packet - get a PPP packet from the serial device.
  129.  */
  130. int
  131. read_packet(buf)
  132.     u_char *buf;
  133. {
  134.     int len;
  136.     len = pppread(ppp_unit, (char *) buf, MTU + DLLHEADERLEN);
  138.     if (len == 0) {
  139.         MAINDEBUG((LOG_DEBUG, "read(fd): EWOULDBLOCK"));
  140. return -1;
  141.     }
  142.     return len;
  143. }
  146. /*
  147.  * ppp_send_config - configure the transmit characteristics of
  148.  * the ppp interface.
  149.  */
  150. void
  151. ppp_send_config(unit, mtu, asyncmap, pcomp, accomp)
  152.     int unit, mtu;
  153.     u_long asyncmap;
  154.     int pcomp, accomp;
  155. {
  156.     u_int x;
  158.     if (ppptioctl(unit, SIOCSIFMTU, (caddr_t) &mtu) < 0) {
  159. syslog(LOG_ERR, "ioctl(SIOCSIFMTU) error");
  160. die(unit, 1);
  161.     }
  163.     if (ppptioctl(unit, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
  164. syslog(LOG_ERR, "ioctl(PPPIOCSASYNCMAP) error");
  165. die(unit, 1);
  166.     }
  168.     if (ppptioctl(unit, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
  169. syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS) error");
  170. die(unit, 1);
  171.     }
  172.     x = pcomp? x | SC_COMP_PROT: x &~ SC_COMP_PROT;
  173.     x = accomp? x | SC_COMP_AC: x &~ SC_COMP_AC;
  174.     if (ppptioctl(unit, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
  175. syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS) error");
  176. die(unit, 1);
  177.     }
  178. }
  181. /*
  182.  * ppp_set_xaccm - set the extended transmit ACCM for the interface.
  183.  */
  184. void
  185. ppp_set_xaccm(unit, accm)
  186.     int unit;
  187.     ext_accm accm;
  188. {
  189.     if (ppptioctl(unit, PPPIOCSXASYNCMAP, (caddr_t) accm) < 0)
  190.         syslog(LOG_WARNING, "ioctl(set extended ACCM): error");
  191. }
  194. /*
  195.  * ppp_recv_config - configure the receive-side characteristics of
  196.  * the ppp interface.
  197.  */
  198. void
  199. ppp_recv_config(unit, mru, asyncmap, pcomp, accomp)
  200.     int unit, mru;
  201.     u_long asyncmap;
  202.     int pcomp, accomp;
  203. {
  204.     int x;
  206.     if (ppptioctl(unit, PPPIOCSMRU, (caddr_t) &mru) < 0) {
  207.         syslog(LOG_ERR, "ioctl(PPPIOCSMRU): error");
  208. die(unit, 1);
  209.     }
  210.     if (ppptioctl(unit, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
  211.         syslog(LOG_ERR, "ioctl(PPPIOCSRASYNCMAP): error");
  212. die(unit, 1);
  213.     }
  214.     if (ppptioctl(unit, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
  215.         syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): error");
  216. die(unit, 1);
  217.     }
  218.     x = !accomp? x | SC_REJ_COMP_AC: x &~ SC_REJ_COMP_AC;
  219.     if (ppptioctl(unit, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
  220.         syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): error");
  221. die(unit, 1);
  222.     }
  223. }
  225. /*
  226.  * sifvjcomp - config tcp header compression
  227.  */
  228. int
  229. sifvjcomp(u, vjcomp, cidcomp, maxcid)
  230.     int u, vjcomp, cidcomp, maxcid;
  231. {
  232.     u_int x;
  234.     if (ppptioctl(u, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
  235. syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS) error");
  236. return 0;
  237.     }
  238.     x = vjcomp ? x | SC_COMP_TCP: x &~ SC_COMP_TCP;
  239.     x = cidcomp? x & ~SC_NO_TCP_CCID: x | SC_NO_TCP_CCID;
  240.     if (ppptioctl(u, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
  241. syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS) error");
  242. return 0;
  243.     }
  244.     if (ppptioctl(u, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
  245.         syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): error");
  246.         return 0;
  247.     }
  248.     return 1;
  249. }
  251. /*
  252.  * sifup - Config the interface up and enable IP packets to pass.
  253.  */
  254. int
  255. sifup(u)
  256.     int u;
  257. {
  258.     struct ifreq ifr;
  259.     u_int x;
  261.     strncpy(ifr.ifr_name, ppp_if[u]->ifname, sizeof (ifr.ifr_name));
  262.     if (ioctl(ppp_if[u]->s, SIOCGIFFLAGS, (int) &ifr) < 0) {
  263. syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS) error");
  264. return 0;
  265.     }
  266.     ifr.ifr_flags |= IFF_UP;
  267.     if (ioctl(ppp_if[u]->s, SIOCSIFFLAGS, (int) &ifr) < 0) {
  268. syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS) error");
  269. return 0;
  270.     }
  271.     if (ppptioctl(u, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
  272.         syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): error");
  273.         return 0;
  274.     }
  275.     x |= SC_ENABLE_IP;
  276.     if (ppptioctl(u, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
  277.         syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): error");
  278.         return 0;
  279.     }
  280.     return 1;
  281. }
  283. /*
  284.  * sifdown - Config the interface down and disable IP.
  285.  */
  286. int
  287. sifdown(u)
  288.     int u;
  289. {
  290.     struct ifreq ifr;
  291.     u_int x;
  292.     int rv;
  294.     rv = 1;
  295.     if (ppptioctl(u, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
  296.         syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): error");
  297.         rv = 0;
  298.     } else {
  299.         x &= ~SC_ENABLE_IP;
  300.         if (ppptioctl(u, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
  301.             syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): error");
  302.             rv = 0;
  303.         }
  304.     }
  305.     strncpy(ifr.ifr_name, ppp_if[u]->ifname, sizeof (ifr.ifr_name));
  306.     if (ioctl(ppp_if[u]->s, SIOCGIFFLAGS, (int) &ifr) < 0) {
  307. syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS) error");
  308. rv = 0;
  309.     } else {
  310.         ifr.ifr_flags &= ~IFF_UP;
  311.         if (ioctl(ppp_if[u]->s, SIOCSIFFLAGS, (int) &ifr) < 0) {
  312.     syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): error");
  313.     rv = 0;
  314.         }
  315.     }
  316.     return rv;
  317. }
  319. /*
  320.  * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
  321.  * if it exists.
  322.  */
  323. #define SET_SA_FAMILY(addr, family)
  324.     BZERO((char *) &(addr), sizeof(addr));
  325.     addr.sa_family = (family);
  328. /*
  329.  * sifaddr - Config the interface IP addresses and netmask.
  330.  */
  331. int
  332. sifaddr(u, o, h, m)
  333.     int u, o, h, m;
  334. {
  335.     struct ifreq ifr;
  337.     strncpy(ifr.ifr_name, ppp_if[u]->ifname, sizeof(ifr.ifr_name));
  338.     SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
  339.     ifr.ifr_addr.sa_len = sizeof (struct sockaddr_in);
  340.     if (m != 0) {
  341.         ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = m;
  342.         syslog(LOG_NOTICE, "Setting interface mask to %s", ip_ntoa(m));
  343.         if (ioctl(ppp_if[u]->s, SIOCSIFNETMASK, (int) &ifr) < 0) {
  344.     syslog(LOG_ERR, "ioctl(SIOCSIFNETMASK): error");
  345.     return (0); 
  346. }
  347.     }
  348.     SET_SA_FAMILY(ifr.ifr_dstaddr, AF_INET);
  349.     ifr.ifr_dstaddr.sa_len = sizeof (struct sockaddr_in);
  350.     ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = h;
  351.     if (ioctl(ppp_if[u]->s, SIOCSIFDSTADDR, (int) &ifr) < 0) {
  352.         syslog(LOG_ERR, "ioctl(SIOCSIFDSTADDR): error");
  353. return (0); 
  354.     }
  355.     SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
  356.     ifr.ifr_addr.sa_len = sizeof (struct sockaddr_in);
  357.     ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = o;
  358.     if (ioctl(ppp_if[u]->s, SIOCSIFADDR, (int) &ifr) < 0) {
  359.         syslog(LOG_ERR, "ioctl(SIOCSIFADDR): error");
  360. return (0); 
  361.     }
  362.     return 1;
  363. }
  365. /*
  366.  * cifaddr - Clear the interface IP addresses, and delete routes
  367.  * through the interface if possible.
  368.  */
  369. int
  370. cifaddr(u, o, h)
  371.     int u, o, h;
  372. {
  373.     struct ortentry rt;
  374.     
  375.     SET_SA_FAMILY(rt.rt_dst, AF_INET);
  376.     rt.rt_dst.sa_len = sizeof (struct sockaddr_in);
  377.     ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = h;
  378.     SET_SA_FAMILY(rt.rt_gateway, AF_INET);
  379.     rt.rt_gateway.sa_len = sizeof (struct sockaddr_in);
  380.     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = o;
  381.     rt.rt_flags = RTF_HOST;
  382.     if (ioctl(ppp_if[u]->s, SIOCDELRT, (int) &rt) < 0) {
  383.         syslog(LOG_WARNING, "ioctl(SIOCDELRT) error");
  384.         return 0;
  385.     }
  386.     return 1;
  387. }
  389. /*
  390.  * sifdefaultroute - assign a default route through the address given.
  391.  */
  392. int
  393. sifdefaultroute(u, g)
  394.     int u, g;
  395. {
  396.     struct ortentry rt;
  398.     SET_SA_FAMILY(rt.rt_dst, AF_INET);
  399.     rt.rt_dst.sa_len = sizeof (struct sockaddr_in);
  400.     SET_SA_FAMILY(rt.rt_gateway, AF_INET);
  401.     rt.rt_gateway.sa_len = sizeof (struct sockaddr_in);
  402.     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = g;
  403.     rt.rt_flags = RTF_GATEWAY;
  404.     if (ioctl(ppp_if[u]->s, SIOCADDRT, (int) &rt) < 0) {
  405.         syslog(LOG_ERR, "default route ioctl(SIOCADDRT): error");
  406.         return 0;
  407.     }
  408.     return 1;
  409. }
  411. /*
  412.  * cifdefaultroute - delete a default route through the address given.
  413.  */
  414. int
  415. cifdefaultroute(u, g)
  416.     int u, g;
  417. {
  418.     struct ortentry rt;
  420.     SET_SA_FAMILY(rt.rt_dst, AF_INET);
  421.     rt.rt_dst.sa_len = sizeof (struct sockaddr_in);
  422.     SET_SA_FAMILY(rt.rt_gateway, AF_INET);
  423.     rt.rt_gateway.sa_len = sizeof (struct sockaddr_in);
  424.     ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = g;
  425.     rt.rt_flags = RTF_GATEWAY;
  426.     if (ioctl(ppp_if[u]->s, SIOCDELRT, (int) &rt) < 0)
  427.         syslog(LOG_WARNING, "default route ioctl(SIOCDELRT): error");
  429.     return 1;
  430. }
  432. /*
  433.  * sifproxyarp - Make a proxy ARP entry for the peer.
  434.  */
  435. int
  436. sifproxyarp(unit, hisaddr)
  437.     int unit;
  438.     u_long hisaddr;
  439. {
  440.     struct arpreq arpreq;
  442.     BZERO((char *)&arpreq, sizeof(arpreq));
  444.     /*
  445.      * Get the hardware address of an interface on the same subnet
  446.      * as our local address.
  447.      */
  448.     if (!get_ether_addr(hisaddr, &arpreq.arp_ha)) {
  449. syslog(LOG_ERR, "Cannot determine ethernet address for proxy ARP");
  450. return 0;
  451.     }
  453.     SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
  454.     arpreq.arp_pa.sa_len = sizeof (struct sockaddr_in);
  455.    ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = hisaddr;
  456.     arpreq.arp_flags = ATF_PERM | ATF_PUBL;
  457.     pppArpCmd (SIOCSARP, &arpreq);
  459.     return 1;
  460. }
  462. int pppArpCmd
  463.    (
  464.    int cmd, 
  465.    struct arpreq * ar
  466.    )
  467.    {
  468.    struct sockaddr_in *       soInAddr;
  469.    struct llinfo_arp *        la = NULL;
  470.    struct rtentry *           rt = NULL;
  471.    struct sockaddr_dl *       sdl= NULL;
  474.    if (ar->arp_pa.sa_family != AF_INET ||
  475.        ar->arp_ha.sa_family != AF_UNSPEC)
  476.        return (EAFNOSUPPORT);
  478.    soInAddr = (struct sockaddr_in *)&ar->arp_pa;
  480.    switch (cmd)
  481.         {
  482.         case SIOCSARP:
  483.             {
  484.     register struct rtentry *rt;
  485.             static struct sockaddr_inarp sin = {sizeof(sin), AF_INET };
  486.     int proxy = 1;
  487.     int create = 1;
  489. #define rt_expire rt_rmx.rmx_expire
  490. #define SDL(s) ((struct sockaddr_dl *)s)
  492.             sin.sin_addr.s_addr = soInAddr->sin_addr.s_addr;
  493.             sin.sin_other = proxy ? SIN_PROXY : 0;
  494.             rt = rtalloc1((struct sockaddr *)&sin, create);
  495.             if (rt == 0)
  496.                 return (0);
  497.             rt->rt_refcnt--;
  498.     rt->rt_expire = 0;
  499.             if ((rt->rt_flags & RTF_GATEWAY) || 
  500.                 (rt->rt_flags & RTF_LLINFO) == 0 ||
  501.                  rt->rt_gateway->sa_family != AF_LINK) {
  502.                  if (create)
  503.                         logMsg("arptnew failed on %xn", 
  504. (int)ntohl(soInAddr->sin_addr.s_addr),
  505.                         0,0,0,0,0);
  506.                  return (0);
  507.             }
  508.             la = (struct llinfo_arp *)rt->rt_llinfo;
  510.             }
  512.             rt = la->la_rt;
  513.             sdl = SDL(rt->rt_gateway);
  514.             bcopy((caddr_t)ar->arp_ha.sa_data, LLADDR(sdl),
  515.                   sdl->sdl_alen = sizeof(struct ether_addr));
  517.             rt->rt_flags &= ~RTF_REJECT;
  518.             rt->rt_flags |= RTF_STATIC; /* manually added route. */
  519.             la->la_asked = 0;
  520.             break;
  522.         case SIOCDARP:          /* delete entry */
  523.             {
  524.     register struct rtentry *rt;
  525.             static struct sockaddr_inarp sin = {sizeof(sin), AF_INET };
  526.     int proxy = 1;
  527.     int create = 0;
  528.             sin.sin_addr.s_addr = soInAddr->sin_addr.s_addr;
  529.             sin.sin_other = proxy ? SIN_PROXY : 0;
  530.             rt = rtalloc1((struct sockaddr *)&sin, create);
  531.             if (rt == 0)
  532.                 return (0);
  533.             rt->rt_refcnt--;
  534.             if ((rt->rt_flags & RTF_GATEWAY) || 
  535.                 (rt->rt_flags & RTF_LLINFO) == 0 ||
  536.                  rt->rt_gateway->sa_family != AF_LINK) {
  537.                  if (create)
  538.                         logMsg("arptnew failed on %xn", 
  539. (int)ntohl(soInAddr->sin_addr.s_addr),
  540.                         0,0,0,0,0);
  541.                  return (0);
  542.             }
  543.             la = (struct llinfo_arp *)rt->rt_llinfo;
  544.             arptfree(la);
  545.     }
  546.             break;
  547.         }
  548. return (0);
  549.    }
  551. /*
  552.  * cifproxyarp - Delete the proxy ARP entry for the peer.
  553.  */
  554. int
  555. cifproxyarp(unit, hisaddr)
  556.     int unit;
  557.     u_long hisaddr;
  558. {
  559.     struct arpreq arpreq;
  561.     BZERO((char *)&arpreq, sizeof(arpreq));
  562.     SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
  563.     arpreq.arp_pa.sa_len = sizeof (struct sockaddr_in);
  564.     ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = hisaddr;
  565.     pppArpCmd (SIOCDARP, &arpreq);
  567.     return 1;
  568. }
  570. /*
  571.  * get_ether_addr - get the hardware address of an interface on the
  572.  * the same subnet as ipaddr.
  573.  */
  574. #define MAX_IFS 32
  576. int
  577. get_ether_addr(ipaddr, hwaddr)
  578.     u_long ipaddr;
  579.     struct sockaddr *hwaddr;
  580. {
  581.     struct ifnet *ifp;
  582.     struct ifreq *ifr, *ifend;
  583.     u_long ina, mask;
  584.     struct ifreq ifreq;
  585.     struct ifconf ifc;
  586.     struct ifreq ifs[MAX_IFS];
  588.     ifc.ifc_len = sizeof(ifs);
  589.     ifc.ifc_req = ifs;
  590.     if (ioctl(ppp_if[ppp_unit]->s, SIOCGIFCONF, (int) &ifc) < 0) {
  591. syslog(LOG_ERR, "ioctl(SIOCGIFCONF) error");
  592. return 0;
  593.     }
  595.     /*
  596.      * Scan through looking for an interface with an Internet
  597.      * address on the same subnet as `ipaddr'.
  598.      */
  599.     ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
  600.     for (ifr = ifc.ifc_req; ifr < ifend; ifr = (struct ifreq *)((char *)ifr +
  601. sizeof(ifr->ifr_name) + 
  602. ifr->ifr_addr.sa_len)) 
  603. {
  604. if (ifr->ifr_addr.sa_family == AF_INET) {
  605.     ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
  606.     strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
  607.     /*
  608.      * Check that the interface is up, and not point-to-point
  609.      * or loopback.
  610.      */
  611.     if (ioctl(ppp_if[ppp_unit]->s, SIOCGIFFLAGS, (int) &ifreq) < 0)
  612. continue;
  613.     if ((ifreq.ifr_flags &
  614.  (IFF_UP|IFF_BROADCAST|IFF_POINTOPOINT|IFF_LOOPBACK|IFF_NOARP))
  615.  != (IFF_UP|IFF_BROADCAST))
  616. continue;
  617.     /*
  618.      * Get its netmask and check that it's on the right subnet.
  619.      */
  620.     if (ioctl(ppp_if[ppp_unit]->s, SIOCGIFNETMASK, (int) &ifreq) < 0)
  621. continue;
  622.             mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
  623.     if ((ipaddr & mask) != (ina & mask))
  624. continue;
  626.     break;
  627. }
  628.     }
  630.     if (ifr >= ifend)
  631. return 0;
  633.     if ((ifp = ifunit (ifr->ifr_name)) == NULL)
  634. return 0;
  636.     syslog(LOG_INFO, "found interface %s for proxy arp", ifr->ifr_name);
  638.     /* stuff the ethernet hw address for the arp add call */
  640.     bcopy ((caddr_t) ((struct arpcom *)ifp)->ac_enaddr,
  641. (caddr_t) hwaddr->sa_data, sizeof(((struct arpcom *)ifp)->ac_enaddr));
  642.     hwaddr->sa_family = AF_UNSPEC;
  643.     return 1;
  644. }
  646. /*
  647.  * ppp_available - check whether the system has any ppp interfaces
  648.  * (in fact we check whether we can do an ioctl on ppp0).
  649.  */
  650. int
  651. ppp_available()
  652. {
  653. #ifdef notyet
  654.     int s, ok;
  655.     struct ifreq ifr;
  657.     if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
  658.         return 1;               /* can't tell - maybe we're not root */
  660.     strncpy(ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
  661.     ok = ioctl(s, SIOCGIFFLAGS, (int) &ifr) >= 0;
  662.     close(s);
  664.     return ok;
  665. #else /* notyet */
  666.     return 1;
  667. #endif /* notyet */
  668. }
  670. #ifdef __STDC__
  671. #include <stdarg.h>
  673. void
  674. syslog(int level, char *fmt, ...)
  675. {
  676.     va_list pvar;
  677.     char buf[256];
  679.     va_start(pvar, fmt);
  680.     vsprintf(buf, fmt, pvar);
  681.     va_end(pvar);
  683.     printf("ppp%d: %srn", ppp_unit, buf);
  684. }
  686. #else /* __STDC__ */
  687. #include <varargs.h>
  689. void
  690. syslog(level, fmt, va_alist)
  691. int level;
  692. char *fmt;
  693. va_dcl
  694. {
  695.     va_list pvar;
  696.     char buf[256];
  698.     va_start(pvar);
  699.     vprintf(fmt, pvar);
  700.     va_end(pvar);
  702.     printf("ppp%d: %srn", ppp_unit, buf);
  703. }
  704. #endif /* __STDC__ */
  706. char *stringdup(in)
  707. char *in;
  708. {
  709.     char* dup;
  711.     if ((dup = (char *)malloc(strlen(in) + 1)) == NULL)
  712. return NULL;
  713.     (void) strcpy(dup, in);
  714.     return (dup);
  715. }