FreeBSD/Linux Kernel Cross Reference
sys/netisdn/i4b_isppp.c

     /*
      *   Copyright (c) 1997 Joerg Wunsch. All rights reserved.
      *
      *   Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
      *
      *   Redistribution and use in source and binary forms, with or without
      *   modification, are permitted provided that the following conditions
      *   are met:
      *
     *   1. Redistributions of source code must retain the above copyright
     *      notice, this list of conditions and the following disclaimer.
     *   2. Redistributions in binary form must reproduce the above copyright
     *      notice, this list of conditions and the following disclaimer in the
     *      documentation and/or other materials provided with the distribution.
     *   
     *   THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
     *   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     *   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     *   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     *   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     *   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     *   OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     *   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     *   LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     *   OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     *   SUCH DAMAGE.
     *
     *---------------------------------------------------------------------------
     *
     *      i4b_isppp.c - isdn4bsd kernel SyncPPP driver
     *      --------------------------------------------
     *
     *      Uses Serge Vakulenko's sppp backend (originally contributed with
     *      the "cx" driver for Cronyx's HDLC-in-hardware device).  This driver
     *      is only the glue between sppp and i4b.
     *
     *      $Id: i4b_isppp.c,v 1.16 2003/08/12 19:49:27 martin Exp $
     *
     * $FreeBSD$
     *
     *      last edit-date: [Fri Jan  5 11:33:47 2001]
     *
     *---------------------------------------------------------------------------*/
    
    #include <sys/cdefs.h>
    __KERNEL_RCSID(0, "$NetBSD: i4b_isppp.c,v 1.16 2003/08/12 19:49:27 martin Exp $");
    
    #ifndef __NetBSD__
    #define USE_ISPPP
    #endif
    #include "ippp.h"
    
    #ifndef USE_ISPPP
    
    #ifdef __FreeBSD__
    #include "sppp.h"
    #endif
    
    #ifndef __NetBSD__
    #if NI4BISPPP == 0
    # error "You need to define `pseudo-device sppp <N>' with options ISPPP"
    #endif
    #endif
    
    #endif
    
    #include <sys/param.h>
    /*
     * XXX - sys/param.h on alpha (indirectly) includes sys/signal.h, which
     *       defines sc_sp - interfering with our use of this identifier.
     *       Just undef it for now.
     */
    #undef sc_sp    
    
    #include <sys/systm.h>
    #include <sys/mbuf.h>
    #include <sys/socket.h>
    #include <sys/errno.h>
    #include <sys/ioccom.h>
    #include <sys/sockio.h>
    #include <sys/kernel.h>
    #include <sys/protosw.h>
    #include <sys/callout.h>
    
    #include <net/if.h>
    #include <net/if_types.h>
    #include <net/netisr.h>
    #include <net/route.h>
    
    #include <netinet/in.h>
    #include <netinet/in_systm.h>
    #include <netinet/in_var.h>
    #include <netinet/ip.h>
    
    #include <net/slcompress.h>
    
    #include <net/if_spppvar.h>
    
    #if defined(__FreeBSD_version) &&  __FreeBSD_version >= 400008                
   #include "bpf.h"     
   #else
   #include "bpfilter.h"
   #endif
   #if NBPFILTER > 0 || NBPF > 0
   #include <sys/time.h>
   #include <net/bpf.h>
   #endif
   
   #ifdef __FreeBSD__
   #include <machine/i4b_ioctl.h>
   #include <machine/i4b_cause.h>
   #include <machine/i4b_debug.h>
   #else
   #include <netisdn/i4b_ioctl.h>
   #include <netisdn/i4b_cause.h>
   #include <netisdn/i4b_debug.h>
   #endif
   
   #include <netisdn/i4b_global.h>
   #include <netisdn/i4b_mbuf.h>
   #include <netisdn/i4b_l3l4.h>
   
   #include <netisdn/i4b_l4.h>
   
   #ifdef __FreeBSD__
   #define ISPPP_FMT       "ippp%d: "
   #define ISPPP_ARG(sc)   ((sc)->sc_if.if_unit)
   #define PDEVSTATIC      static
                   
   # if __FreeBSD_version >= 300001
   #  define CALLOUT_INIT(chan)            callout_handle_init(chan)
   #  define TIMEOUT(fun, arg, chan, tick) chan = timeout(fun, arg, tick)
   #  define UNTIMEOUT(fun, arg, chan)     untimeout(fun, arg, chan)
   #  define IOCTL_CMD_T u_long
   # else
   #  define CALLOUT_INIT(chan)            do {} while(0)
   #  define TIMEOUT(fun, arg, chan, tick) timeout(fun, arg, tick)
   #  define UNTIMEOUT(fun, arg, chan)     untimeout(fun, arg)
   #  define IOCTL_CMD_T int
   # endif
   
   #elif defined __NetBSD__ || defined __OpenBSD__
   #define ISPPP_FMT       "%s: "
   #define ISPPP_ARG(sc)   ((sc)->sc_sp.pp_if.if_xname)
   #define PDEVSTATIC      /* not static */
   #define IOCTL_CMD_T     u_long
   #else
   # error "What system are you using?"
   #endif
   
   #ifdef __FreeBSD__
   PDEVSTATIC void ipppattach(void *);
   PSEUDO_SET(ipppattach, i4b_isppp);
   #else
   PDEVSTATIC void ipppattach(void);
   #endif
   
   #define I4BISPPPACCT            1       /* enable accounting messages */
   #define I4BISPPPACCTINTVL       2       /* accounting msg interval in secs */
   #define I4BISPPPDISCDEBUG       1       
   
   #define PPP_HDRLEN              4       /* 4 octetts PPP header length  */
   
   struct i4bisppp_softc {
           struct sppp sc_sp;      /* we are derived from struct sppp */
   
           int     sc_state;       /* state of the interface       */
   
   #ifndef __FreeBSD__
           int     sc_unit;        /* unit number for Net/OpenBSD  */
   #endif
   
           call_desc_t *sc_cdp;    /* ptr to call descriptor       */
           isdn_link_t *sc_ilt;    /* B channel driver and state   */
   
   #ifdef I4BISPPPACCT
           int sc_iinb;            /* isdn driver # of inbytes     */
           int sc_ioutb;           /* isdn driver # of outbytes    */
           int sc_inb;             /* # of bytes rx'd              */
           int sc_outb;            /* # of bytes tx'd              */
           int sc_linb;            /* last # of bytes rx'd         */
           int sc_loutb;           /* last # of bytes tx'd         */
           int sc_fn;              /* flag, first null acct        */
   #endif
   
   #if defined(__FreeBSD_version) && __FreeBSD_version >= 300001
           struct callout_handle sc_ch;
   #endif
   
   } i4bisppp_softc[NIPPP];
   
   static int      i4bisppp_ioctl(struct ifnet *ifp, IOCTL_CMD_T cmd, caddr_t data);
   
   #if 0
   static void     i4bisppp_send(struct ifnet *ifp);
   #endif
   
   static void     i4bisppp_start(struct ifnet *ifp);
   
   #if 0 /* never used ??? */
   static void     i4bisppp_timeout(void *cookie);
   #endif
   
   static void     i4bisppp_tls(struct sppp *sp);
   static void     i4bisppp_tlf(struct sppp *sp);
   static void     i4bisppp_state_changed(struct sppp *sp, int new_state);
   static void     i4bisppp_negotiation_complete(struct sppp *sp);
   static void     i4bisppp_watchdog(struct ifnet *ifp);
   time_t          i4bisppp_idletime(void *softc);
   static void     i4bisppp_rx_data_rdy(void *softc);
   static void     i4bisppp_tx_queue_empty(void *softc);
   static void     i4bisppp_activity(void *softc, int rxtx);
   static void     i4bisppp_connect(void *softc, void *cdp);
   static void     i4bisppp_disconnect(void *softc, void *cdp);
   static void     i4bisppp_dialresponse(void *softc, int status, cause_t cause);
   static void     i4bisppp_updown(void *softc, int updown);
   static void*    i4bisppp_ret_softc(int unit);
   static void     i4bisppp_set_linktab(void *softc, isdn_link_t *ilt);
   
   static const struct isdn_l4_driver_functions
   ippp_l4_functions = {
           /* L4<->B-channel functions */
           i4bisppp_rx_data_rdy,
           i4bisppp_tx_queue_empty,
           i4bisppp_activity,
           i4bisppp_connect,
           i4bisppp_disconnect,
           i4bisppp_dialresponse,
           i4bisppp_updown,
           /* Management functions */
           i4bisppp_ret_softc,
           i4bisppp_set_linktab,
           i4bisppp_idletime
   };
   
   static int ippp_drvr_id = -1;
   
   enum i4bisppp_states {
           ST_IDLE,                        /* initialized, ready, idle     */
           ST_DIALING,                     /* dialling out to remote       */
           ST_CONNECTED,                   /* connected to remote          */
   };
   
   /*===========================================================================*
    *                      DEVICE DRIVER ROUTINES
    *===========================================================================*/
   
   /*---------------------------------------------------------------------------*
    *      interface attach routine at kernel boot time
    *---------------------------------------------------------------------------*/
   PDEVSTATIC void
   #ifdef __FreeBSD__
   ipppattach(void *dummy)
   #else
   ipppattach()
   #endif
   {
           struct i4bisppp_softc *sc = i4bisppp_softc;
           int i;
   
           ippp_drvr_id = isdn_l4_driver_attach("ippp", NIPPP, &ippp_l4_functions);
   
           for(i = 0; i < NIPPP; sc++, i++) {              
                   sc->sc_sp.pp_if.if_softc = sc;
                   sc->sc_ilt = NULL;
   
   #ifdef __FreeBSD__              
                   sc->sc_sp.pp_if.if_name = "ippp";
   #if defined(__FreeBSD_version) && __FreeBSD_version < 300001
                   sc->sc_sp.pp_if.if_next = NULL;
   #endif
                   sc->sc_sp.pp_if.if_unit = i;
   #else
                   sprintf(sc->sc_sp.pp_if.if_xname, "ippp%d", i);
                   sc->sc_unit = i;
   #endif
   
                   sc->sc_sp.pp_if.if_mtu = PP_MTU;
   
   #ifdef __NetBSD__
                   sc->sc_sp.pp_if.if_flags = IFF_SIMPLEX | IFF_POINTOPOINT |
                                           IFF_MULTICAST;
   #else
                   sc->sc_sp.pp_if.if_flags = IFF_SIMPLEX | IFF_POINTOPOINT;
   #endif
   
                   sc->sc_sp.pp_if.if_type = IFT_ISDNBASIC;
                   sc->sc_state = ST_IDLE;
   
                   sc->sc_sp.pp_if.if_ioctl = i4bisppp_ioctl;
   
                   /* actually initialized by sppp_attach() */
                   /* sc->sc_sp.pp_if.if_output = sppp_output; */
   
                   sc->sc_sp.pp_if.if_start = i4bisppp_start;
   
                   sc->sc_sp.pp_if.if_hdrlen = 0;
                   sc->sc_sp.pp_if.if_addrlen = 0;
                   IFQ_SET_MAXLEN(&sc->sc_sp.pp_if.if_snd, IFQ_MAXLEN);
                   IFQ_SET_READY(&sc->sc_sp.pp_if.if_snd);
   
                   sc->sc_sp.pp_if.if_ipackets = 0;
                   sc->sc_sp.pp_if.if_ierrors = 0;
                   sc->sc_sp.pp_if.if_opackets = 0;
                   sc->sc_sp.pp_if.if_oerrors = 0;
                   sc->sc_sp.pp_if.if_collisions = 0;
                   sc->sc_sp.pp_if.if_ibytes = 0;
                   sc->sc_sp.pp_if.if_obytes = 0;
                   sc->sc_sp.pp_if.if_imcasts = 0;
                   sc->sc_sp.pp_if.if_omcasts = 0;
                   sc->sc_sp.pp_if.if_iqdrops = 0;
                   sc->sc_sp.pp_if.if_noproto = 0;
   
   #if I4BISPPPACCT
                   sc->sc_sp.pp_if.if_timer = 0;   
                   sc->sc_sp.pp_if.if_watchdog = i4bisppp_watchdog;        
                   sc->sc_iinb = 0;
                   sc->sc_ioutb = 0;
                   sc->sc_inb = 0;
                   sc->sc_outb = 0;
                   sc->sc_linb = 0;
                   sc->sc_loutb = 0;
                   sc->sc_fn = 1;
   #endif
   
                   sc->sc_sp.pp_tls = i4bisppp_tls;
                   sc->sc_sp.pp_tlf = i4bisppp_tlf;
                   sc->sc_sp.pp_con = i4bisppp_negotiation_complete;
                   sc->sc_sp.pp_chg = i4bisppp_state_changed;
                   sc->sc_sp.pp_framebytes = 0;    /* no framing added by hardware */
   
   #if defined(__FreeBSD_version) && ((__FreeBSD_version >= 500009) || (410000 <= __FreeBSD_version && __FreeBSD_version < 500000))
                   /* do not call bpfattach in ether_ifattach */
                   ether_ifattach(&sc->sc_sp.pp_if, 0);
   #else
                   if_attach(&sc->sc_sp.pp_if);
   #endif
   #ifndef USE_ISPPP
                   sppp_attach(&sc->sc_sp.pp_if);
   #else
                   isppp_attach(&sc->sc_sp.pp_if);
   #endif
   
   #if NBPFILTER > 0 || NBPF > 0
   #ifdef __FreeBSD__
                   bpfattach(&sc->sc_sp.pp_if, DLT_PPP, PPP_HDRLEN);
                   CALLOUT_INIT(&sc->sc_ch);
   #endif /* __FreeBSD__ */
   #ifdef __NetBSD__
                   bpfattach(&sc->sc_sp.pp_if, DLT_PPP, sizeof(u_int));
   #endif
   #endif          
           }
   }
   
   /*---------------------------------------------------------------------------*
    *      process ioctl
    *---------------------------------------------------------------------------*/
   static int
   i4bisppp_ioctl(struct ifnet *ifp, IOCTL_CMD_T cmd, caddr_t data)
   {
           struct i4bisppp_softc *sc = ifp->if_softc;
           int error;
   
   #ifndef USE_ISPPP               
           error = sppp_ioctl(&sc->sc_sp.pp_if, cmd, data);
   #else
           error = isppp_ioctl(&sc->sc_sp.pp_if, cmd, data);
   #endif
           if (error)
                   return error;
   
           switch(cmd) {
           case SIOCSIFFLAGS:
   #if 0 /* never used ??? */
                   x = splnet();
                   if ((ifp->if_flags & IFF_UP) == 0)
                           UNTIMEOUT(i4bisppp_timeout, (void *)sp, sc->sc_ch);
                   splx(x);
   #endif
                   break;
           }
   
           return 0;
   }
   
   /*---------------------------------------------------------------------------*
    *      start output to ISDN B-channel
    *---------------------------------------------------------------------------*/
   static void
   i4bisppp_start(struct ifnet *ifp)
   {
           struct i4bisppp_softc *sc = ifp->if_softc;
           struct mbuf *m;
   
   #ifndef USE_ISPPP
           if (sppp_isempty(ifp))
   #else
           if (isppp_isempty(ifp))
   #endif
                   return;
   
           if(sc->sc_state != ST_CONNECTED)
                   return;
   
           /*
            * s = splnet();
            * ifp->if_flags |= IFF_OACTIVE; // - need to clear this somewhere
            * splx(s);
            */
   
   #ifndef USE_ISPPP
           while ((m = sppp_dequeue(&sc->sc_sp.pp_if)) != NULL)
   #else
           while ((m = isppp_dequeue(&sc->sc_sp.pp_if)) != NULL)
   #endif
           {
   
   #if NBPFILTER > 0 || NBPF > 0
   #ifdef __FreeBSD__
                   if (ifp->if_bpf)
                           bpf_mtap(ifp, m);
   #endif /* __FreeBSD__ */
   
   #ifdef __NetBSD__
                   if (ifp->if_bpf)
                           bpf_mtap(ifp->if_bpf, m);
   #endif
   #endif /* NBPFILTER > 0 || NBPF > 0 */
   
                   if(IF_QFULL(sc->sc_ilt->tx_queue))
                   {
                           NDBGL4(L4_ISPDBG, "%s, tx queue full!", sc->sc_sp.pp_if.if_xname);
                           m_freem(m);
                   }
                   else
                   {
                           IF_ENQUEUE(sc->sc_ilt->tx_queue, m);
   #if 0
                           sc->sc_sp.pp_if.if_obytes += m->m_pkthdr.len;
   #endif
                           sc->sc_outb += m->m_pkthdr.len;
                           sc->sc_sp.pp_if.if_opackets++;
                   }
           }
           sc->sc_ilt->bchannel_driver->bch_tx_start(sc->sc_ilt->l1token, 
               sc->sc_ilt->channel);
   }
   
   #ifdef I4BISPPPACCT
   /*---------------------------------------------------------------------------*
    *      watchdog routine
    *---------------------------------------------------------------------------*/
   static void
   i4bisppp_watchdog(struct ifnet *ifp)
   {
           struct i4bisppp_softc *sc = ifp->if_softc;
           bchan_statistics_t bs;
           
           (*sc->sc_ilt->bchannel_driver->bch_stat)
                   (sc->sc_ilt->l1token, sc->sc_ilt->channel, &bs);
   
           sc->sc_ioutb += bs.outbytes;
           sc->sc_iinb += bs.inbytes;
           
           if((sc->sc_iinb != sc->sc_linb) || (sc->sc_ioutb != sc->sc_loutb) || sc->sc_fn)
           {
                   int ri = (sc->sc_iinb - sc->sc_linb)/I4BISPPPACCTINTVL;
                   int ro = (sc->sc_ioutb - sc->sc_loutb)/I4BISPPPACCTINTVL;
   
                   if((sc->sc_iinb == sc->sc_linb) && (sc->sc_ioutb == sc->sc_loutb))
                           sc->sc_fn = 0;
                   else
                           sc->sc_fn = 1;
                           
                   sc->sc_linb = sc->sc_iinb;
                   sc->sc_loutb = sc->sc_ioutb;
   
                   if (sc->sc_cdp)
                           i4b_l4_accounting(sc->sc_cdp->cdid, ACCT_DURING,
                               sc->sc_ioutb, sc->sc_iinb, ro, ri, sc->sc_outb, sc->sc_inb);
           }
           sc->sc_sp.pp_if.if_timer = I4BISPPPACCTINTVL;   
   
   #if 0 /* old stuff, keep it around */
           printf(ISPPP_FMT "transmit timeout\n", ISPPP_ARG(sc));
           i4bisppp_start(ifp);
   #endif
   }
   #endif /* I4BISPPPACCT */
   
   /*
    *===========================================================================*
    *                      SyncPPP layer interface routines
    *===========================================================================*
    */
   
   /*---------------------------------------------------------------------------*
    *      PPP this-layer-started action
    *---------------------------------------------------------------------------*
    */
   static void
   i4bisppp_tls(struct sppp *sp)
   {
           struct i4bisppp_softc *sc = sp->pp_if.if_softc;
   
           if(sc->sc_state == ST_CONNECTED)
                   return;
   
           i4b_l4_dialout(ippp_drvr_id, sc->sc_unit);
   }
   
   /*---------------------------------------------------------------------------*
    *      PPP this-layer-finished action
    *---------------------------------------------------------------------------*
    */
   static void
   i4bisppp_tlf(struct sppp *sp)
   {
           struct i4bisppp_softc *sc = sp->pp_if.if_softc;
   
           if(sc->sc_state != ST_CONNECTED)
                   return;
   
           i4b_l4_drvrdisc(sc->sc_cdp->cdid);
   }
   /*---------------------------------------------------------------------------*
    *      PPP interface phase change
    *---------------------------------------------------------------------------*
    */
   static void
   i4bisppp_state_changed(struct sppp *sp, int new_state)
   {
           struct i4bisppp_softc *sc = sp->pp_if.if_softc;
           
           i4b_l4_ifstate_changed(sc->sc_cdp, new_state);
   }
   
   /*---------------------------------------------------------------------------*
    *      PPP control protocol negotiation complete (run ip-up script now)
    *---------------------------------------------------------------------------*
    */
   static void
   i4bisppp_negotiation_complete(struct sppp *sp)
   {
           struct i4bisppp_softc *sc = sp->pp_if.if_softc;
           
           i4b_l4_negcomplete(sc->sc_cdp);
   }
   
   /*===========================================================================*
    *                      ISDN INTERFACE ROUTINES
    *===========================================================================*/
   
   /*---------------------------------------------------------------------------*
    *      this routine is called from L4 handler at connect time
    *---------------------------------------------------------------------------*/
   static void
   i4bisppp_connect(void *softc, void *cdp)
   {
           struct i4bisppp_softc *sc = softc;
           struct sppp *sp = &sc->sc_sp;
           int s = splnet();
   
           sc->sc_cdp = (call_desc_t *)cdp;
           sc->sc_state = ST_CONNECTED;
   
   #if I4BISPPPACCT
           sc->sc_iinb = 0;
           sc->sc_ioutb = 0;
           sc->sc_inb = 0;
           sc->sc_outb = 0;
           sc->sc_linb = 0;
           sc->sc_loutb = 0;
           sc->sc_sp.pp_if.if_timer = I4BISPPPACCTINTVL;
   #endif
           
   #if 0 /* never used ??? */
           UNTIMEOUT(i4bisppp_timeout, (void *)sp, sc->sc_ch);
   #endif
   
           sp->pp_up(sp);          /* tell PPP we are ready */
   #ifndef __NetBSD__
           sp->pp_last_sent = sp->pp_last_recv = SECOND;
   #endif
           splx(s);
   }
   
   /*---------------------------------------------------------------------------*
    *      this routine is called from L4 handler at disconnect time
    *---------------------------------------------------------------------------*/
   static void
   i4bisppp_disconnect(void *softc, void *cdp)
   {
           call_desc_t *cd = (call_desc_t *)cdp;
           struct i4bisppp_softc *sc = softc;
           struct sppp *sp = &sc->sc_sp;
   
           int s = splnet();
   
           /* new stuff to check that the active channel is being closed */
           if (cd != sc->sc_cdp)
           {
                   NDBGL4(L4_ISPDBG, "%s: channel%d not active!", sp->pp_if.if_xname,
                       cd->channelid);
                   splx(s);
                   return;
           }
   
   #if I4BISPPPACCT
           sc->sc_sp.pp_if.if_timer = 0;
   #endif
   
           i4b_l4_accounting(cd->cdid, ACCT_FINAL,
                    sc->sc_ioutb, sc->sc_iinb, 0, 0, sc->sc_outb, sc->sc_inb);
           
           if (sc->sc_state == ST_CONNECTED)
           {
   #if 0 /* never used ??? */
                   UNTIMEOUT(i4bisppp_timeout, (void *)sp, sc->sc_ch);
   #endif
                   sc->sc_cdp = (call_desc_t *)0;  
                   /* do thhis here because pp_down calls i4bisppp_tlf */
                   sc->sc_state = ST_IDLE;
                   sp->pp_down(sp);        /* tell PPP we have hung up */
           }
   
           splx(s);
   }
   
   /*---------------------------------------------------------------------------*
    *      this routine is used to give a feedback from userland demon
    *      in case of dial problems
    *---------------------------------------------------------------------------*/
   static void
   i4bisppp_dialresponse(void *softc, int status, cause_t cause)
   {
           struct i4bisppp_softc *sc = softc;
   
           NDBGL4(L4_ISPDBG, "%s: status=%d, cause=%d", sc->sc_sp.pp_if.if_xname, status, cause);
   
           if(status != DSTAT_NONE)
           {
                   struct mbuf *m;
                   
                   NDBGL4(L4_ISPDBG, "%s: clearing queues", sc->sc_sp.pp_if.if_xname);
   
   #ifndef USE_ISPPP
                   if(!(sppp_isempty(&sc->sc_sp.pp_if)))
   #else
                   if(!(isppp_isempty(&sc->sc_sp.pp_if)))
   #endif          
                   {
   #ifndef USE_ISPPP
                           while((m = sppp_dequeue(&sc->sc_sp.pp_if)) != NULL)
   #else
                           while((m = isppp_dequeue(&sc->sc_sp.pp_if)) != NULL)
   #endif
                                   m_freem(m);
                   }
           }
   }
           
   /*---------------------------------------------------------------------------*
    *      interface up/down
    *---------------------------------------------------------------------------*/
   static void
   i4bisppp_updown(void *softc, int updown)
   {
           /* could probably do something useful here */
   }
           
   /*---------------------------------------------------------------------------*
    *      this routine is called from the HSCX interrupt handler
    *      when a new frame (mbuf) has been received and was put on
    *      the rx queue.
    *---------------------------------------------------------------------------*/
   static void
   i4bisppp_rx_data_rdy(void *softc)
   {
           struct i4bisppp_softc *sc = softc;
           struct mbuf *m;
           int s;
           
           if((m = *sc->sc_ilt->rx_mbuf) == NULL)
                   return;
   
           m->m_pkthdr.rcvif = &sc->sc_sp.pp_if;
           m->m_pkthdr.len = m->m_len;
   
           sc->sc_sp.pp_if.if_ipackets++;
   
   #if I4BISPPPACCT
           sc->sc_inb += m->m_pkthdr.len;
   #endif
           
   #ifdef I4BISPPPDEBUG
           printf("i4bisppp_rx_data_ready: received packet!\n");
   #endif
   
   #if NBPFILTER > 0 || NBPF > 0
   
   #ifdef __FreeBSD__      
           if(sc->sc_sp.pp_if.if_bpf)
                   bpf_mtap(&sc->sc_sp.pp_if, m);
   #endif /* __FreeBSD__ */
   
   #ifdef __NetBSD__
           if(sc->sc_sp.pp_if.if_bpf)
                   bpf_mtap(sc->sc_sp.pp_if.if_bpf, m);
   #endif
   
   #endif /* NBPFILTER > 0  || NBPF > 0 */
   
           s = splnet();
   
   #ifndef USE_ISPPP
           sppp_input(&sc->sc_sp.pp_if, m);
   #else
           isppp_input(&sc->sc_sp.pp_if, m);
   #endif
   
           splx(s);
   }
   
   /*---------------------------------------------------------------------------*
    *      this routine is called from the HSCX interrupt handler
    *      when the last frame has been sent out and there is no
    *      further frame (mbuf) in the tx queue.
    *---------------------------------------------------------------------------*/
   static void
   i4bisppp_tx_queue_empty(void *softc)
   {
           struct sppp *sp = &((struct i4bisppp_softc *)softc)->sc_sp;
           i4bisppp_start(&sp->pp_if);
   }
   
   /*---------------------------------------------------------------------------*
    *      THIS should be used instead of last_active_time to implement
    *      an activity timeout mechanism.
    *
    *      Sending back the time difference unneccessarily complicates the
    *      idletime checks in i4b_l4.c. Return the largest time instead.
    *      That way the code in i4b_l4.c needs only minimal changes.
    *---------------------------------------------------------------------------*/
   time_t
   i4bisppp_idletime(void *softc)
   {
           struct sppp *sp = &((struct i4bisppp_softc *)softc)->sc_sp;
   
           return sp->pp_last_activity;
   }
   
   /*---------------------------------------------------------------------------*
    *      this routine is called from the HSCX interrupt handler
    *      each time a packet is received or transmitted. It should
    *      be used to implement an activity timeout mechanism.
    *---------------------------------------------------------------------------*/
   static void
   i4bisppp_activity(void *softc, int rxtx)
   {
           struct i4bisppp_softc *sc = softc;
           sc->sc_cdp->last_active_time = SECOND;
   }
   
   /*---------------------------------------------------------------------------*
    *      return this drivers linktab address
    *---------------------------------------------------------------------------*/
   static void *
   i4bisppp_ret_softc(int unit)
   {
           return &i4bisppp_softc[unit];
   }
   
   /*---------------------------------------------------------------------------*
    *      setup the isdn_linktab for this driver
    *---------------------------------------------------------------------------*/
   static void
   i4bisppp_set_linktab(void *softc, isdn_link_t *ilt)
   {
           struct i4bisppp_softc *sc = softc;
           sc->sc_ilt = ilt;
   }
   
   /*===========================================================================*/

Cache object: c555b8546327402d73de78d48fbe38df