if_ppp.c

VXWORKS源代码

	 * abort sequence "}~".
	 */
	if (sc->sc_flags & (SC_FLUSH | SC_ESCAPED)
	    || (ilen > 0 && sc->sc_fcs != PPP_GOODFCS)) {
#ifdef VJC
	    /*
	     * If we've missed a packet, we must toss subsequent compressed
	     * packets which don't have an explicit connection ID.
	     */
	    sl_uncompress_tcp(NULL, 0, TYPE_ERROR, &sc->sc_comp);
#endif
	    if ((sc->sc_flags & (SC_FLUSH | SC_ESCAPED)) == 0){
		if (sc->sc_flags & SC_DEBUG)
		    printf("ppp%d: bad fcs %x\n", sc->sc_if.if_unit,
			   sc->sc_fcs);
		sc->sc_if.if_ierrors++;
	    } else
		sc->sc_flags &= ~(SC_FLUSH | SC_ESCAPED);
	    return;
	}

	if (ilen < PPP_HDRLEN + PPP_FCSLEN) {
	    if (ilen) {
		if (sc->sc_flags & SC_DEBUG)
		    printf("ppp%d: too short (%d)\n", sc->sc_if.if_unit, ilen);
		sc->sc_if.if_ierrors++;
	    }
	    return;
	}

	/*
	 * Remove FCS trailer.  Somewhat painful...
	 */
	ilen -= 2;
	if (--sc->sc_mc->m_len == 0) {
	    for (m = sc->sc_m; m->m_next != sc->sc_mc; m = m->m_next)
		;
	    sc->sc_mc = m;
	}
	sc->sc_mc->m_len--;

	/* excise this mbuf chain */
	m = sc->sc_m;
	sc->sc_m = sc->sc_mc->m_next;
	sc->sc_mc->m_next = NULL;

	if (sc->sc_flags & SC_LOG_INPKT) {
	    printf("ppp%d: got %d bytes\n", sc->sc_if.if_unit, ilen);
	    pppdumpm(m, ilen);
	}
	
	ppppktin(sc, m); 		/* handover packet to upper layer */
	pppgetm(sc);			
	return;
    }

    if (sc->sc_flags & SC_FLUSH) {
	if (sc->sc_flags & SC_LOG_FLUSH)
	    ppplogchar(sc, c);
	return;
    }

    if (c < 0x20 && (sc->sc_rasyncmap & (1 << c)))
	return;

    if (sc->sc_flags & SC_ESCAPED) {
	sc->sc_flags &= ~SC_ESCAPED;
	c ^= PPP_TRANS;
    } else if (c == PPP_ESCAPE) {
	sc->sc_flags |= SC_ESCAPED;
	return;
    }

    /*
     * Initialize buffer on first octet received.
     * First octet could be address or protocol (when compressing
     * address/control).
     * Second octet is control.
     * Third octet is first or second (when compressing protocol)
     * octet of protocol.
     * Fourth octet is second octet of protocol.
     */
    if (sc->sc_ilen == 0) {
	/* reset the first input mbuf */
	if (sc->sc_m == NULL) {
	    pppgetm(sc);
	    if (sc->sc_m == NULL) {
		if (sc->sc_flags & SC_DEBUG)
		    printf("ppp%d: no input mbufs!\n", sc->sc_if.if_unit);
		goto flush;
	    }
	}
	m = sc->sc_m;
	m->m_len = 0;
	m->m_data = M_DATASTART(sc->sc_m);
	if (M_DATASIZE(sc->sc_m) >= HDROFF + PPP_HDRLEN)
	    m->m_data += HDROFF;	/* allow room for VJ decompression */
	sc->sc_mc = m;
	sc->sc_mp = mtod(m, char *);
	sc->sc_fcs = PPP_INITFCS;
	if (c != PPP_ALLSTATIONS) {
	    if (sc->sc_flags & SC_REJ_COMP_AC) {
		if (sc->sc_flags & SC_DEBUG)
		    printf("ppp%d: garbage received: 0x%x (need 0xFF)\n",
			   sc->sc_if.if_unit, c);
		goto flush;
	    }
	    *sc->sc_mp++ = PPP_ALLSTATIONS;
	    *sc->sc_mp++ = PPP_UI;
	    sc->sc_ilen += 2;
	    m->m_len += 2;
	}
    }
    if (sc->sc_ilen == 1 && c != PPP_UI) {
	if (sc->sc_flags & SC_DEBUG)
	    printf("ppp%d: missing UI (0x3), got 0x%x\n",
		   sc->sc_if.if_unit, c);
	goto flush;
    }
    if (sc->sc_ilen == 2 && (c & 1) == 1) {
	/* a compressed protocol */
	*sc->sc_mp++ = 0;
	sc->sc_ilen++;
	sc->sc_mc->m_len++;
    }
    if (sc->sc_ilen == 3 && (c & 1) == 0) {
	if (sc->sc_flags & SC_DEBUG)
	    printf("ppp%d: bad protocol %x\n", sc->sc_if.if_unit,
		   (sc->sc_mp[-1] << 8) + c);
	goto flush;
    }

    /* packet beyond configured mru? */
    if (++sc->sc_ilen > sc->sc_mru + PPP_HDRLEN + PPP_FCSLEN) {
	if (sc->sc_flags & SC_DEBUG)
	    printf("ppp%d: packet too big\n", sc->sc_if.if_unit);
	goto flush;
    }

    /* is this mbuf full? */
    m = sc->sc_mc;
    if (M_TRAILINGSPACE(m) <= 0) {
	if (m->m_next == NULL) {
	    pppgetm(sc);
	    if (m->m_next == NULL) {
		if (sc->sc_flags & SC_DEBUG)
		    printf("ppp%d: too few input mbufs!\n", sc->sc_if.if_unit);
		goto flush;
	    }
	}
	sc->sc_mc = m = m->m_next;
	m->m_len = 0;
	m->m_data = M_DATASTART(m);
	sc->sc_mp = mtod(m, char *);
    }

    ++m->m_len;
    *sc->sc_mp++ = c;
    sc->sc_fcs = PPP_FCS(sc->sc_fcs, c);
    return;

 flush:
    if (!(sc->sc_flags & SC_FLUSH)) {
	sc->sc_if.if_ierrors++;
	sc->sc_flags |= SC_FLUSH;
	if (sc->sc_flags & SC_LOG_FLUSH)
	    ppplogchar(sc, c);
    }
}

/*
 * Process an ioctl request to interface.
 */
static int
pppioctl(ifp, cmd, data)
    register struct ifnet *ifp;
    int cmd;
    caddr_t data;
{
    register struct ppp_softc *sc = ppp_softc[ifp->if_unit];
    register struct ifaddr *ifa = (struct ifaddr *)data;
    register struct ifreq *ifr = (struct ifreq *)data;
    register M2_NETDRVCNFG *pm2DrvCnfg = (M2_NETDRVCNFG *)data;
    register M2_NETDRVCNTRS *pm2DrvCntr = (M2_NETDRVCNTRS *)data;
    int s = splimp(), error = 0;

    switch (cmd) {
    case SIOCGIFFLAGS:
        *(short *)data = ifp->if_flags;
         break;

    case SIOCSIFFLAGS:
	if ((ifp->if_flags & IFF_RUNNING) == 0)
	    ifp->if_flags &= ~IFF_UP;
	break;

    case SIOCSIFADDR:
	if (ifa->ifa_addr->sa_family != AF_INET)
	    error = EAFNOSUPPORT;
	break;

    case SIOCSIFDSTADDR:
	if (ifa->ifa_dstaddr->sa_family != AF_INET)
	    error = EAFNOSUPPORT;
	break;

    case SIOCSIFMTU:
	sc->sc_if.if_mtu = ifr->ifr_mtu;
	break;

    case SIOCGIFMTU:
	ifr->ifr_mtu = sc->sc_if.if_mtu;
	break;

    case SIOCADDMULTI:
    case SIOCDELMULTI:
        if (ifr == 0) {
            error = EAFNOSUPPORT;
            break;
        }
        switch(ifr->ifr_addr.sa_family) {
#ifdef INET
        case AF_INET:
            break;
#endif
        default:
            error = EAFNOSUPPORT;
            break;
        }
        break;

    case SIOCGMIB2CNFG:
        pm2DrvCnfg->ifType = M2_ifType_ppp;		/* ppp type */
        pm2DrvCnfg->ifSpecific.idLength = 0;		/* use default */
	break;

    case SIOCGMIB2CNTRS:				/* fill in counters */
	pm2DrvCntr->ifInOctets = sc->sc_bytesrcvd;
        pm2DrvCntr->ifInNUcastPkts = 0;
        pm2DrvCntr->ifInDiscards = 0;
        pm2DrvCntr->ifInUnknownProtos = ppp_if[ppp_unit]->unknownProto;
	pm2DrvCntr->ifOutOctets = sc->sc_bytessent;
        pm2DrvCntr->ifOutNUcastPkts = 0;
        pm2DrvCntr->ifOutDiscards = 0;

	if ((pm2DrvCntr->ifSpeed = ppp_if[ppp_unit]->baud_rate) == 0)
	    pm2DrvCntr->ifSpeed = 9600;			/* nominal default */

	break;

    default:
	error = EINVAL;
    }
    splx(s);
    return (error);
}

#define	MAX_DUMP_BYTES	128

static void
pppdumpm(m0, pktlen)
    struct mbuf *m0;
    int pktlen;
{
    char buf [3*MAX_DUMP_BYTES+4];
    char *bp = buf;
    struct mbuf *m;
    static char digits [] = "0123456789abcdef";

    for (m = m0; m && pktlen; m = m->m_next) {
	int l = m->m_len;
	u_char *rptr = mtod(m, u_char *);

        if (pktlen > 0) {
            if (l > pktlen)
                l = pktlen;
	    pktlen -= l;
	}
        while (l--) {
            if (bp > buf + sizeof(buf) - 4)
                goto done;
            *bp++ = digits[*rptr >> 4]; /* convert byte to ascii hex */
            *bp++ = digits[*rptr++ & 0xf];
        }

        if (m->m_next) {
            if (bp > buf + sizeof(buf) - 3)
                goto done;
            *bp++ = '|';
        } else
            *bp++ = ' ';
    }
done:
    if (m && pktlen)
        *bp++ = '>';
    *bp = 0;
    printf("%s\n", buf);
}

static void
ppplogchar(sc, c)
    struct ppp_softc *sc;
    int c;
{
    if (c >= 0)
        sc->sc_rawin[sc->sc_rawin_count++] = c;
    if (sc->sc_rawin_count >= sizeof(sc->sc_rawin)
        || (c < 0 && sc->sc_rawin_count > 0)) {
        printf("ppp%d input: ", sc->sc_if.if_unit);
        pppdumpb(sc->sc_rawin, sc->sc_rawin_count);
        sc->sc_rawin_count = 0;
    }
}

static void
pppdumpb(b, l)
    u_char *b;
    int l;
{
    char buf [3*MAX_DUMP_BYTES+4];
    char *bp = buf;
    static char digits[] = "0123456789abcdef";

    while (l--) {
	if (bp >= buf + sizeof (buf) - 3) {
	    *bp++ = '>';
	    break;
	}
	*bp++ = digits [*b >> 4]; /* convert byte to ascii hex */
	*bp++ = digits [*b++ & 0xf];
        *bp++ = ' ';
    }

    *bp = 0;
    printf("%s\n", buf);
}

/* 
 * Flush write output on the interface. 
 */
static void
ppp_wrt_flush(sc)
    register struct ppp_softc *sc;
{
    register struct mbuf *m;
    register int len;
    register u_char *start, *stop, *cp;
    int n, ndone, done;
    struct mbuf *m2;
    int count, fd;
    char ch;

    fd = sc->sc_fd;

    for (;;) {
        /*
         * See if we have an existing packet partly sent.
         * If not, get a new packet and start sending it.
         * We take packets on the priority queue ahead of those
         * on the normal queue.
         */
        m = sc->sc_outm;
        if (m == NULL) {
	    /*
	     * Get another packet to be sent
	     */
	    m = ppp_dequeue(sc);
	    if (m == NULL)
	        break;

	    /*
	     * The extra PPP_FLAG will start up a new packet, and thus
	     * will flush any accumulated garbage.  We do this whenever
	     * the line may have been idle for some time.
	     */
	    ioctl(fd, FIONWRITE, (int) &count);
	    if (count == 0) {
	        ++sc->sc_bytessent;
	        ch = PPP_FLAG;
	        (void) write(fd, &ch, 1);
	    }

	    /* Calculate the FCS for the first mbuf's worth. */
	    sc->sc_outfcs = pppfcs(PPP_INITFCS, mtod(m, u_char *), m->m_len);
        }

        for (;;) {
	    start = mtod(m, u_char *);
	    len = m->m_len;
	    stop = start + len;
	    while (len > 0) {
	        /*
	         * Find out how many bytes in the string we can
	         * handle without doing something special.
	         */
	        for (cp = start; cp < stop; cp++)
		    if (ESCAPE_P(*cp))
		        break;
	        n = cp - start;
	        if (n) {
		    int cc, nleft;
		    for (nleft = n; nleft > 0; nleft -= cc) {
		        if ((cc =  write(fd, (char *)start, n)) <= 0)
			    break;
		        if (cc > nleft)
			    cc = nleft;
		    }
		    ndone = n - nleft;
		    len -= ndone;
		    start += ndone;
		    sc->sc_bytessent += ndone;

		    if (ndone < n)
		        break;  /* packet doesn't fit */
	        }
	        /*
	         * If there are characters left in the mbuf,
	         * the first one must be special..
	         * Put it out in a different form.
	         */
	        if (len) {
		    ch = PPP_ESCAPE;
		    if (write(fd, &ch, 1) != 1)
		        break;

		    ch = *start ^ PPP_TRANS;
		    if (write(fd, &ch, 1) != 1)
		        break;

		    sc->sc_bytessent += 2;
		    start++;
		    len--;
	        }
	    }
	    /*
	     * If we didn't empty this mbuf, remember where we're up to.
	     * If we emptied the last mbuf, try to add the FCS and closing
	     * flag, and if we can't, leave sc_outm pointing to m, but with
	     * m->m_len == 0, to remind us to output the FCS and flag later.
	     */
	    done = len == 0;
	    if (done && m->m_next == NULL) {
	        u_char *p;
	        int c;
	        u_char endseq[8];
    
	        /*
	         * We may have to escape the bytes in the FCS.
	         */
	        p = endseq;
	        c = ~sc->sc_outfcs & 0xFF;
	        if (ESCAPE_P(c)) {
		    *p++ = PPP_ESCAPE;
		    *p++ = c ^ PPP_TRANS;
	        } else
		    *p++ = c;
	        c = (~sc->sc_outfcs >> 8) & 0xFF;
	        if (ESCAPE_P(c)) {
		    *p++ = PPP_ESCAPE;
		    *p++ = c ^ PPP_TRANS;
	        } else
		    *p++ = c;
	        *p++ = PPP_FLAG;

	        /*
	         * Try to output the FCS and flag.  If the bytes
	         * don't all fit, back out.
	         */
	        write(fd, (char *)endseq, (int)p-(int)endseq);
	    }

	    if (!done) {
	        m->m_data = (caddr_t)start; 
	        m->m_len = len;
	        sc->sc_outm = m;
	        break;         /* can't do any more at the moment */
	    }

	    /* Finished with this mbuf; free it and move on. */
	    m2 = m_free (m);

	    if (m2 == NULL)
	        break;

	    m = m2;
	    sc->sc_outfcs = pppfcs(sc->sc_outfcs, mtod(m, u_char *), m->m_len);
        }

        /* Finished a packet */
        sc->sc_outm = NULL;
        sc->sc_bytessent++;     /* account for closing flag */
        sc->sc_if.if_opackets++;
    }
}
#endif  /* NPPP > 0 */