Annotation of sys/net/if_strip.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: if_strip.c,v 1.32 2006/03/25 22:41:47 djm Exp $ */
! 2: /* $NetBSD: if_strip.c,v 1.2.4.3 1996/08/03 00:58:32 jtc Exp $ */
! 3: /* from: NetBSD: if_sl.c,v 1.38 1996/02/13 22:00:23 christos Exp $ */
! 4:
! 5: /*
! 6: * Copyright 1996 The Board of Trustees of The Leland Stanford
! 7: * Junior University. All Rights Reserved.
! 8: *
! 9: * Permission to use, copy, modify, and distribute this
! 10: * software and its documentation for any purpose and without
! 11: * fee is hereby granted, provided that the above copyright
! 12: * notice appear in all copies. Stanford University
! 13: * makes no representations about the suitability of this
! 14: * software for any purpose. It is provided "as is" without
! 15: * express or implied warranty.
! 16: *
! 17: *
! 18: * This driver was contributed by Jonathan Stone.
! 19: *
! 20: * Starmode Radio IP interface (STRIP) for Metricom wireless radio.
! 21: * This STRIP driver assumes address resolution of IP addresses to
! 22: * Metricom MAC addresses is done via local link-level routes.
! 23: * The link-level addresses are entered as an 8-digit packed BCD number.
! 24: * To add a route for a radio at IP address 10.1.2.3, with radio
! 25: * address '1234-5678', reachable via interface st0, use the command
! 26: *
! 27: * route add -host 10.1.2.3 -link st0:12:34:56:78
! 28: */
! 29:
! 30:
! 31: /*
! 32: * Copyright (c) 1987, 1989, 1992, 1993
! 33: * The Regents of the University of California. All rights reserved.
! 34: *
! 35: * Redistribution and use in source and binary forms, with or without
! 36: * modification, are permitted provided that the following conditions
! 37: * are met:
! 38: * 1. Redistributions of source code must retain the above copyright
! 39: * notice, this list of conditions and the following disclaimer.
! 40: * 2. Redistributions in binary form must reproduce the above copyright
! 41: * notice, this list of conditions and the following disclaimer in the
! 42: * documentation and/or other materials provided with the distribution.
! 43: * 3. Neither the name of the University nor the names of its contributors
! 44: * may be used to endorse or promote products derived from this software
! 45: * without specific prior written permission.
! 46: *
! 47: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 48: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 49: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 50: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 51: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 52: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 53: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 54: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 55: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 56: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 57: * SUCH DAMAGE.
! 58: *
! 59: * @(#)if_sl.c 8.6 (Berkeley) 2/1/94
! 60: */
! 61:
! 62: /*
! 63: * Derived from: Serial Line interface written by Rick Adams (rick@seismo.gov)
! 64: *
! 65: * Rick Adams
! 66: * Center for Seismic Studies
! 67: * 1300 N 17th Street, Suite 1450
! 68: * Arlington, Virginia 22209
! 69: * (703)276-7900
! 70: * rick@seismo.ARPA
! 71: * seismo!rick
! 72: *
! 73: * Pounded on heavily by Chris Torek (chris@mimsy.umd.edu, umcp-cs!chris).
! 74: * N.B.: this belongs in netinet, not net, the way it stands now.
! 75: * Should have a link-layer type designation, but wouldn't be
! 76: * backwards-compatible.
! 77: *
! 78: * Converted to 4.3BSD Beta by Chris Torek.
! 79: * Other changes made at Berkeley, based in part on code by Kirk Smith.
! 80: * W. Jolitz added slip abort.
! 81: *
! 82: * Hacked almost beyond recognition by Van Jacobson (van@helios.ee.lbl.gov).
! 83: * Added priority queuing for "interactive" traffic; hooks for TCP
! 84: * header compression; ICMP filtering (at 2400 baud, some cretin
! 85: * pinging you can use up all your bandwidth). Made low clist behavior
! 86: * more robust and slightly less likely to hang serial line.
! 87: * Sped up a bunch of things.
! 88: */
! 89:
! 90: #include "strip.h"
! 91: #if NSTRIP > 0
! 92:
! 93: #include "bpfilter.h"
! 94:
! 95: #include <sys/param.h>
! 96: #include <sys/proc.h>
! 97: #include <sys/mbuf.h>
! 98: #include <sys/dkstat.h>
! 99: #include <sys/socket.h>
! 100: #include <sys/ioctl.h>
! 101: #include <sys/file.h>
! 102: #include <sys/tty.h>
! 103: #include <sys/kernel.h>
! 104: #include <sys/conf.h>
! 105: #if defined(__NetBSD__) || defined(__OpenBSD__)
! 106: #include <sys/systm.h>
! 107: #endif
! 108: #include <sys/syslog.h>
! 109:
! 110: #include <machine/cpu.h>
! 111:
! 112: #include <net/if.h>
! 113: #include <net/if_dl.h>
! 114: #include <net/if_types.h>
! 115: #include <net/netisr.h>
! 116: #include <net/route.h>
! 117:
! 118: #if INET
! 119: #include <netinet/in.h>
! 120: #include <netinet/in_systm.h>
! 121: #include <netinet/in_var.h>
! 122: #include <netinet/ip.h>
! 123: #else
! 124: #error Starmode Radio IP configured without configuring inet?
! 125: #endif
! 126:
! 127: #include <net/slcompress.h>
! 128: #include <net/if_stripvar.h>
! 129: #include <net/slip.h>
! 130:
! 131: #if defined(__NetBSD__) || defined(__OpenBSD__) /* XXX -- jrs */
! 132: typedef u_char ttychar_t;
! 133: #else
! 134: typedef char ttychar_t;
! 135: #endif
! 136:
! 137: #if NBPFILTER > 0
! 138: #include <sys/time.h>
! 139: #include <net/bpf.h>
! 140: #endif
! 141:
! 142: /*
! 143: * SLMAX is a hard limit on input packet size. To simplify the code
! 144: * and improve performance, we require that packets fit in an mbuf
! 145: * cluster, and if we get a compressed packet, there's enough extra
! 146: * room to expand the header into a max length tcp/ip header (128
! 147: * bytes). So, SLMAX can be at most
! 148: * MCLBYTES - 128
! 149: *
! 150: * SLMTU is a hard limit on output packet size. To insure good
! 151: * interactive response, SLMTU wants to be the smallest size that
! 152: * amortizes the header cost. Remember that even with
! 153: * type-of-service queuing, we have to wait for any in-progress
! 154: * packet to finish. I.e., we wait, on the average, 1/2 * mtu /
! 155: * cps, where cps is the line speed in characters per second.
! 156: * E.g., 533ms wait for a 1024 byte MTU on a 9600 baud line. The
! 157: * average compressed header size is 6-8 bytes so any MTU > 90
! 158: * bytes will give us 90% of the line bandwidth. A 100ms wait is
! 159: * tolerable (500ms is not), so want an MTU around 296. (Since TCP
! 160: * will send 256 byte segments (to allow for 40 byte headers), the
! 161: * typical packet size on the wire will be around 260 bytes). In
! 162: * 4.3tahoe+ systems, we can set an MTU in a route so we do that &
! 163: * leave the interface MTU relatively high (so we don't IP fragment
! 164: * when acting as a gateway to someone using a stupid MTU).
! 165: *
! 166: * Similar considerations apply to SLIP_HIWAT: It's the amount of
! 167: * data that will be queued 'downstream' of us (i.e., in clists
! 168: * waiting to be picked up by the tty output interrupt). If we
! 169: * queue a lot of data downstream, it's immune to our t.o.s. queuing.
! 170: * E.g., if SLIP_HIWAT is 1024, the interactive traffic in mixed
! 171: * telnet/ftp will see a 1 sec wait, independent of the mtu (the
! 172: * wait is dependent on the ftp window size but that's typically
! 173: * 1k - 4k). So, we want SLIP_HIWAT just big enough to amortize
! 174: * the cost (in idle time on the wire) of the tty driver running
! 175: * off the end of its clists & having to call back slstart for a
! 176: * new packet. For a tty interface with any buffering at all, this
! 177: * cost will be zero. Even with a totally brain dead interface (like
! 178: * the one on a typical workstation), the cost will be <= 1 character
! 179: * time. So, setting SLIP_HIWAT to ~100 guarantees that we'll lose
! 180: * at most 1% while maintaining good interactive response.
! 181: */
! 182: #if NBPFILTER > 0
! 183: #define BUFOFFSET (128+sizeof(struct ifnet **)+SLIP_HDRLEN)
! 184: #else
! 185: #define BUFOFFSET (128+sizeof(struct ifnet **))
! 186: #endif
! 187: #define SLMAX (MCLBYTES - BUFOFFSET)
! 188: #define SLBUFSIZE (SLMAX + BUFOFFSET)
! 189: #ifdef SLMTU
! 190: #undef SLMTU
! 191: #endif
! 192: #define SLMTU 1100 /* XXX -- appromaximated. 1024 may be safer. */
! 193:
! 194: #define STRIP_MTU_ONWIRE (SLMTU + 20 + STRIP_HDRLEN) /* (2*SLMTU+2 in sl.c */
! 195:
! 196:
! 197:
! 198: #define SLIP_HIWAT roundup(50,CBSIZE)
! 199:
! 200: /* This is a NetBSD-1.0 or later kernel. */
! 201: #define CCOUNT(q) ((q)->c_cc)
! 202:
! 203:
! 204: #if !(defined(__NetBSD__) || defined(__OpenBSD__)) /* XXX - cgd */
! 205: #define CLISTRESERVE 1024 /* Can't let clists get too low */
! 206: #endif /* !__NetBSD__ */
! 207:
! 208: /*
! 209: * SLIP ABORT ESCAPE MECHANISM:
! 210: * (inspired by HAYES modem escape arrangement)
! 211: * 1sec escape 1sec escape 1sec escape { 1sec escape 1sec escape }
! 212: * within window time signals a "soft" exit from slip mode by remote end
! 213: * if the IFF_DEBUG flag is on.
! 214: */
! 215: #define ABT_ESC '\033' /* can't be t_intr - distant host must know it*/
! 216: #define ABT_IDLE 1 /* in seconds - idle before an escape */
! 217: #define ABT_COUNT 3 /* count of escapes for abort */
! 218: #define ABT_WINDOW (ABT_COUNT*2+2) /* in seconds - time to count */
! 219:
! 220: struct st_softc st_softc[NSTRIP];
! 221:
! 222: #define STRIP_FRAME_END 0x0D /* carriage return */
! 223:
! 224:
! 225: static int stripinit(struct st_softc *);
! 226: static struct mbuf *strip_btom(struct st_softc *, int);
! 227:
! 228: /*
! 229: * STRIP header: '*' + modem address (dddd-dddd) + '*' + mactype ('SIP0')
! 230: * A Metricom packet looks like this: *<address>*<key><payload><CR>
! 231: * eg. *0000-1164*SIP0<payload><CR>
! 232: *
! 233: */
! 234:
! 235: #define STRIP_ENCAP_SIZE(X) ((36) + (X)*65/64 + 2)
! 236: #define STRIP_HDRLEN 15
! 237: #define STRIP_MAC_ADDR_LEN 9
! 238:
! 239: /*
! 240: * Star mode packet header.
! 241: * (may be used for encapsulations other than STRIP.)
! 242: */
! 243: #define STARMODE_ADDR_LEN 11
! 244: struct st_header {
! 245: u_char starmode_addr[STARMODE_ADDR_LEN];
! 246: u_char starmode_type[4];
! 247: };
! 248:
! 249: /*
! 250: * Forward declarations for Metricom-specific functions.
! 251: * Ideally, these would be in a library and shared across
! 252: * different STRIP implementations: *BSD, Linux, etc.
! 253: *
! 254: */
! 255: static u_char *UnStuffData(u_char *src, u_char *end, u_char
! 256: *dest, u_long dest_length);
! 257:
! 258: static u_char *StuffData(u_char *src, u_long length, u_char *dest,
! 259: u_char **code_ptr_ptr);
! 260:
! 261: static void RecvErr(char *msg, struct st_softc *sc);
! 262: static void RecvErr_Message(struct st_softc *strip_info,
! 263: u_char *sendername, u_char *msg);
! 264: void strip_resetradio(struct st_softc *sc, struct tty *tp);
! 265: void strip_proberadio(struct st_softc *sc, struct tty *tp);
! 266: void strip_watchdog(struct ifnet *ifp);
! 267: void strip_sendbody(struct st_softc *sc, struct mbuf *m);
! 268: int strip_newpacket(struct st_softc *sc, u_char *ptr, u_char *end);
! 269: struct mbuf * strip_send(struct st_softc *sc, struct mbuf *m0);
! 270:
! 271: void strip_timeout(void *x);
! 272:
! 273:
! 274:
! 275: #ifdef DEBUG
! 276: #define DPRINTF(x) printf x
! 277: #else
! 278: #define DPRINTF(x)
! 279: #endif
! 280:
! 281:
! 282:
! 283: /*
! 284: * Radio reset macros.
! 285: * The Metricom radios are not particularly well-designed for
! 286: * use in packet mode (starmode). There's no easy way to tell
! 287: * when the radio is in starmode. Worse, when the radios are reset
! 288: * or power-cycled, they come back up in Hayes AT-emulation mode,
! 289: * and there's no good way for this driver to tell.
! 290: * We deal with this by peridically tickling the radio
! 291: * with an invalid starmode command. If the radio doesn't
! 292: * respond with an error, the driver knows to reset the radio.
! 293: */
! 294:
! 295: /* Radio-reset finite state machine (if_watchdog) callback rate, in seconds */
! 296: #define STRIP_WATCHDOG_INTERVAL 5
! 297:
! 298: /* Period between intrusive radio probes, in seconds */
! 299: #define ST_PROBE_INTERVAL 10
! 300:
! 301: /* Grace period for radio to answer probe, in seconds */
! 302: #define ST_PROBERESPONSE_INTERVAL 2
! 303:
! 304: /* Be less agressive about repeated resetting. */
! 305: #define STRIP_RESET_INTERVAL 5
! 306:
! 307: /*
! 308: * We received a response from the radio that indicates it's in
! 309: * star mode. Clear any pending probe or reset timer.
! 310: * Don't probe radio again for standard polling interval.
! 311: */
! 312: #define CLEAR_RESET_TIMER(sc) \
! 313: do {\
! 314: (sc)->sc_state = ST_ALIVE; \
! 315: (sc)->sc_statetimo = time_second + ST_PROBE_INTERVAL; \
! 316: } while (0)
! 317:
! 318: /*
! 319: * we received a response from the radio that indicates it's crashed
! 320: * out of starmode into Hayse mode. Reset it ASAP.
! 321: */
! 322: #define FORCE_RESET(sc) \
! 323: do {\
! 324: (sc)->sc_statetimo = time_second - 1; \
! 325: (sc)->sc_state = ST_DEAD; \
! 326: /*(sc)->sc_if.if_timer = 0;*/ \
! 327: } while (0)
! 328:
! 329: #define RADIO_PROBE_TIMEOUT(sc) \
! 330: ((sc)-> sc_statetimo > time_second)
! 331:
! 332:
! 333:
! 334: /*
! 335: * Called from boot code to establish sl interfaces.
! 336: */
! 337: void
! 338: stripattach(n)
! 339: int n;
! 340: {
! 341: struct st_softc *sc;
! 342: int i = 0;
! 343:
! 344: for (sc = st_softc; i < NSTRIP; sc++) {
! 345: timeout_set(&sc->sc_timo, strip_timeout, sc);
! 346: sc->sc_unit = i; /* XXX */
! 347: snprintf(sc->sc_if.if_xname, sizeof sc->sc_if.if_xname,
! 348: "strip%d", i++);
! 349: sc->sc_if.if_softc = sc;
! 350: sc->sc_if.if_mtu = SLMTU;
! 351: sc->sc_if.if_flags = 0;
! 352: sc->sc_if.if_type = IFT_OTHER;
! 353: #if 0
! 354: sc->sc_if.if_flags |= SC_AUTOCOMP /* | IFF_POINTOPOINT | IFF_MULTICAST*/;
! 355: #endif
! 356: sc->sc_if.if_type = IFT_SLIP;
! 357: sc->sc_if.if_ioctl = stripioctl;
! 358: sc->sc_if.if_output = stripoutput;
! 359: IFQ_SET_MAXLEN(&sc->sc_if.if_snd, 50);
! 360: sc->sc_fastq.ifq_maxlen = 32;
! 361:
! 362: sc->sc_if.if_watchdog = strip_watchdog;
! 363: sc->sc_if.if_timer = STRIP_WATCHDOG_INTERVAL;
! 364: IFQ_SET_READY(&sc->sc_if.if_snd);
! 365: if_attach(&sc->sc_if);
! 366: if_alloc_sadl(&sc->sc_if);
! 367: #if NBPFILTER > 0
! 368: bpfattach(&sc->sc_bpf, &sc->sc_if, DLT_SLIP, SLIP_HDRLEN);
! 369: #endif
! 370: }
! 371: }
! 372:
! 373: static int
! 374: stripinit(sc)
! 375: struct st_softc *sc;
! 376: {
! 377: caddr_t p;
! 378:
! 379: if (sc->sc_ep == (u_char *) 0) {
! 380: MCLALLOC(p, M_WAIT);
! 381: if (p)
! 382: sc->sc_ep = (u_char *)p + SLBUFSIZE;
! 383: else {
! 384: addlog("%s: can't allocate buffer\n",
! 385: sc->sc_if.if_xname);
! 386: sc->sc_if.if_flags &= ~IFF_UP;
! 387: return (0);
! 388: }
! 389: }
! 390:
! 391: /* Get contiguous buffer in which to de-bytestuff/rll-decode input */
! 392: if (sc->sc_rxbuf == (u_char *) 0) {
! 393: MCLALLOC(p, M_WAIT);
! 394: if (p)
! 395: sc->sc_rxbuf = (u_char *)p + SLBUFSIZE - SLMAX;
! 396: else {
! 397: addlog("%s: can't allocate input buffer\n",
! 398: sc->sc_if.if_xname);
! 399: sc->sc_if.if_flags &= ~IFF_UP;
! 400: return (0);
! 401: }
! 402: }
! 403:
! 404: /* Get contiguous buffer in which to bytestuff/rll-encode output */
! 405: if (sc->sc_txbuf == (u_char *) 0) {
! 406: MCLALLOC(p, M_WAIT);
! 407: if (p)
! 408: sc->sc_txbuf = (u_char *)p + SLBUFSIZE - SLMAX;
! 409: else {
! 410: addlog("%s: can't allocate buffer\n",
! 411: sc->sc_if.if_xname);
! 412:
! 413: sc->sc_if.if_flags &= ~IFF_UP;
! 414: return (0);
! 415: }
! 416: }
! 417:
! 418: sc->sc_buf = sc->sc_ep - SLMAX;
! 419: sc->sc_mp = sc->sc_buf;
! 420: sl_compress_init(&sc->sc_comp);
! 421:
! 422: /* Initialize radio probe/reset state machine */
! 423: sc->sc_state = ST_DEAD; /* assumet the worst. */
! 424: sc->sc_statetimo = time_second; /* do reset immediately */
! 425:
! 426: return (1);
! 427: }
! 428:
! 429: /*
! 430: * Line specific open routine.
! 431: * Attach the given tty to the first available sl unit.
! 432: */
! 433: /* ARGSUSED */
! 434: int
! 435: stripopen(dev, tp)
! 436: dev_t dev;
! 437: struct tty *tp;
! 438: {
! 439: struct proc *p = curproc; /* XXX */
! 440: struct st_softc *sc;
! 441: int nstrip;
! 442: int error;
! 443: #if defined(__NetBSD__) || defined(__OpenBSD__)
! 444: int s;
! 445: #endif
! 446:
! 447: if ((error = suser(p, 0)) != 0)
! 448: return (error);
! 449:
! 450: if (tp->t_line == STRIPDISC)
! 451: return (0);
! 452:
! 453: for (nstrip = NSTRIP, sc = st_softc; --nstrip >= 0; sc++)
! 454: if (sc->sc_ttyp == NULL) {
! 455: if (stripinit(sc) == 0)
! 456: return (ENOBUFS);
! 457: tp->t_sc = (caddr_t)sc;
! 458: sc->sc_ttyp = tp;
! 459: sc->sc_if.if_baudrate = tp->t_ospeed;
! 460: ttyflush(tp, FREAD | FWRITE);
! 461: #if defined(__NetBSD__) || defined(__OpenBSD__)
! 462: /*
! 463: * Make sure tty output queue is large enough
! 464: * to hold a full-sized packet (including frame
! 465: * end, and a possible extra frame end).
! 466: * A full-sized of 65/64) *SLMTU bytes (because
! 467: * of escapes and clever RLL bytestuffing),
! 468: * plus frame header, and add two on for frame ends.
! 469: */
! 470: s = spltty();
! 471: if (tp->t_outq.c_cn < STRIP_MTU_ONWIRE) {
! 472: sc->sc_oldbufsize = tp->t_outq.c_cn;
! 473: sc->sc_oldbufquot = tp->t_outq.c_cq != 0;
! 474:
! 475: clfree(&tp->t_outq);
! 476: error = clalloc(&tp->t_outq, 3*SLMTU, 0);
! 477: if (error) {
! 478: splx(s);
! 479: return (error);
! 480: }
! 481: } else
! 482: sc->sc_oldbufsize = sc->sc_oldbufquot = 0;
! 483: splx(s);
! 484: #endif /* __NetBSD__ */
! 485: s = spltty();
! 486: strip_resetradio(sc, tp);
! 487: splx(s);
! 488:
! 489: return (0);
! 490: }
! 491: return (ENXIO);
! 492: }
! 493:
! 494: /*
! 495: * Line specific close routine.
! 496: * Detach the tty from the strip unit.
! 497: */
! 498: void
! 499: stripclose(tp)
! 500: struct tty *tp;
! 501: {
! 502: struct st_softc *sc;
! 503: int s;
! 504:
! 505: ttywflush(tp);
! 506:
! 507: s = spltty();
! 508: tp->t_line = 0;
! 509: sc = (struct st_softc *)tp->t_sc;
! 510: if (sc != NULL) {
! 511: if_down(&sc->sc_if);
! 512: sc->sc_ttyp = NULL;
! 513: tp->t_sc = NULL;
! 514: MCLFREE((caddr_t)(sc->sc_ep - SLBUFSIZE));
! 515: MCLFREE((caddr_t)(sc->sc_rxbuf - SLBUFSIZE + SLMAX)); /* XXX */
! 516: MCLFREE((caddr_t)(sc->sc_txbuf - SLBUFSIZE + SLMAX)); /* XXX */
! 517: sc->sc_ep = 0;
! 518: sc->sc_mp = 0;
! 519: sc->sc_buf = 0;
! 520: sc->sc_rxbuf = 0;
! 521: sc->sc_txbuf = 0;
! 522:
! 523: if (sc->sc_flags & SC_TIMEOUT) {
! 524: timeout_del(&sc->sc_timo);
! 525: sc->sc_flags &= ~SC_TIMEOUT;
! 526: }
! 527: }
! 528: #if defined(__NetBSD__) || defined(__OpenBSD__)
! 529: /* if necessary, install a new outq buffer of the appropriate size */
! 530: if (sc->sc_oldbufsize != 0) {
! 531: clfree(&tp->t_outq);
! 532: clalloc(&tp->t_outq, sc->sc_oldbufsize, sc->sc_oldbufquot);
! 533: }
! 534: #endif
! 535: splx(s);
! 536: }
! 537:
! 538: /*
! 539: * Line specific (tty) ioctl routine.
! 540: * Provide a way to get the sl unit number.
! 541: */
! 542: /* ARGSUSED */
! 543: int
! 544: striptioctl(tp, cmd, data, flag)
! 545: struct tty *tp;
! 546: u_long cmd;
! 547: caddr_t data;
! 548: int flag;
! 549: {
! 550: struct st_softc *sc = (struct st_softc *)tp->t_sc;
! 551:
! 552: switch (cmd) {
! 553: case SLIOCGUNIT:
! 554: *(int *)data = sc->sc_unit;
! 555: break;
! 556:
! 557: default:
! 558: return (-1);
! 559: }
! 560: return (0);
! 561: }
! 562:
! 563: /*
! 564: * Take an mbuf chain containing a STRIP packet (no link-level header),
! 565: * byte-stuff (escape) it, and enqueue it on the tty send queue.
! 566: */
! 567: void
! 568: strip_sendbody(sc, m)
! 569: struct st_softc *sc;
! 570: struct mbuf *m;
! 571: {
! 572: struct tty *tp = sc->sc_ttyp;
! 573: u_char *dp = sc->sc_txbuf;
! 574: struct mbuf *m2;
! 575: int len;
! 576: u_char *rllstate_ptr = NULL;
! 577:
! 578: while (m) {
! 579: /*
! 580: * Byte-stuff/run-length encode this mbuf's data into the
! 581: * output buffer.
! 582: * XXX
! 583: * Note that chained calls to stuffdata()
! 584: * require that the stuffed data be left in the
! 585: * output buffer until the entire packet is encoded.
! 586: */
! 587: dp = StuffData(mtod(m, u_char *), m->m_len, dp, &rllstate_ptr);
! 588:
! 589: MFREE(m, m2);
! 590: m = m2;
! 591: }
! 592:
! 593: /*
! 594: * Put the entire stuffed packet into the tty output queue.
! 595: */
! 596: len = dp - sc->sc_txbuf;
! 597: if (b_to_q((ttychar_t *)sc->sc_txbuf,
! 598: len, &tp->t_outq)) {
! 599: if (sc->sc_if.if_flags & IFF_DEBUG)
! 600: addlog("%s: tty output overflow\n",
! 601: sc->sc_if.if_xname);
! 602: goto bad;
! 603: }
! 604: sc->sc_if.if_obytes += len;
! 605:
! 606: return;
! 607:
! 608: bad:
! 609: m_freem(m);
! 610: return;
! 611: }
! 612:
! 613:
! 614: /*
! 615: * Prepend a STRIP header to the packet.
! 616: * (based on 4.4bsd if_ppp)
! 617: *
! 618: * XXX manipulates tty queues with putc.
! 619: * must be called at spl >= spltty.
! 620: */
! 621: struct mbuf *
! 622: strip_send(sc, m0)
! 623: struct st_softc *sc;
! 624: struct mbuf *m0;
! 625: {
! 626: struct tty *tp = sc->sc_ttyp;
! 627: struct st_header *hdr;
! 628:
! 629: /*
! 630: * Send starmode header (unstuffed).
! 631: */
! 632: hdr = mtod(m0, struct st_header *);
! 633: if (b_to_q((ttychar_t *)hdr, STRIP_HDRLEN, &tp->t_outq)) {
! 634: if (sc->sc_if.if_flags & IFF_DEBUG)
! 635: addlog("%s: outq overflow writing header\n",
! 636: sc->sc_if.if_xname);
! 637: m_freem(m0);
! 638: return 0;
! 639: }
! 640:
! 641: /* The header has been enqueued in clear; undo the M_PREPEND() of the header. */
! 642: m0->m_data += sizeof(struct st_header);
! 643: m0->m_len -= sizeof(struct st_header);
! 644: if (m0->m_flags & M_PKTHDR) {
! 645: m0->m_pkthdr.len -= sizeof(struct st_header);
! 646: }
! 647: #ifdef DIAGNOSTIC
! 648: else
! 649: addlog("%s: strip_send: missing pkthdr, %d remains\n",
! 650: sc->sc_if.if_xname, m0->m_len); /*XXX*/
! 651: #endif
! 652:
! 653: /*
! 654: * If M_PREPEND() had to prepend a new mbuf, it is now empty.
! 655: * Discard it.
! 656: */
! 657: if (m0->m_len == 0) {
! 658: struct mbuf *m;
! 659: MFREE(m0, m);
! 660: m0 = m;
! 661: }
! 662:
! 663: /* Byte-stuff and run-length encode the remainder of the packet. */
! 664: strip_sendbody(sc, m0);
! 665:
! 666: if (putc(STRIP_FRAME_END, &tp->t_outq)) {
! 667: /*
! 668: * Not enough room. Remove a char to make room
! 669: * and end the packet normally.
! 670: * If you get many collisions (more than one or two
! 671: * a day) you probably do not have enough clists
! 672: * and you should increase "nclist" in param.c.
! 673: */
! 674: (void) unputc(&tp->t_outq);
! 675: (void) putc(STRIP_FRAME_END, &tp->t_outq);
! 676: sc->sc_if.if_collisions++;
! 677: } else {
! 678: ++sc->sc_if.if_obytes;
! 679: sc->sc_if.if_opackets++;
! 680: }
! 681:
! 682: /*
! 683: * If a radio probe is due now, append it to this packet rather
! 684: * than waiting until the watchdog routine next runs.
! 685: */
! 686: if (time_second >= sc->sc_statetimo && sc->sc_state == ST_ALIVE)
! 687: strip_proberadio(sc, tp);
! 688:
! 689: return (m0);
! 690: }
! 691:
! 692:
! 693:
! 694: /*
! 695: * Queue a packet. Start transmission if not active.
! 696: * Compression happens in slstart; if we do it here, IP TOS
! 697: * will cause us to not compress "background" packets, because
! 698: * ordering gets trashed. It can be done for all packets in slstart.
! 699: */
! 700: int
! 701: stripoutput(ifp, m, dst, rt)
! 702: struct ifnet *ifp;
! 703: struct mbuf *m;
! 704: struct sockaddr *dst;
! 705: struct rtentry *rt;
! 706: {
! 707: struct st_softc *sc = ifp->if_softc;
! 708: struct ip *ip;
! 709: struct ifqueue *ifq;
! 710: struct st_header *shp;
! 711: u_char *dldst; /* link-level next-hop */
! 712: int s;
! 713: u_char dl_addrbuf[STARMODE_ADDR_LEN+1];
! 714:
! 715: /*
! 716: * Verify tty line is up and alive.
! 717: */
! 718: if (sc->sc_ttyp == NULL) {
! 719: m_freem(m);
! 720: return (ENETDOWN); /* sort of */
! 721: }
! 722: if ((sc->sc_ttyp->t_state & TS_CARR_ON) == 0 &&
! 723: (sc->sc_ttyp->t_cflag & CLOCAL) == 0) {
! 724: m_freem(m);
! 725: return (EHOSTUNREACH);
! 726: }
! 727:
! 728: #define SDL(a) ((struct sockaddr_dl *) (a))
! 729:
! 730: #ifdef DEBUG
! 731: if (rt) {
! 732: printf("stripout, rt: dst af%d gw af%d",
! 733: rt_key(rt)->sa_family,
! 734: rt->rt_gateway->sa_family);
! 735: if (rt_key(rt)->sa_family == AF_INET)
! 736: printf(" dst %x",
! 737: ((struct sockaddr_in *)rt_key(rt))->sin_addr.s_addr);
! 738: printf("\n");
! 739: }
! 740: #endif
! 741:
! 742: switch (dst->sa_family) {
! 743: case AF_INET:
! 744: if (rt != NULL && rt->rt_gwroute != NULL)
! 745: rt = rt->rt_gwroute;
! 746:
! 747: /* assume rt is never NULL */
! 748: if (rt == NULL || rt->rt_gateway->sa_family != AF_LINK
! 749: || SDL(rt->rt_gateway)->sdl_alen != ifp->if_addrlen) {
! 750: DPRINTF(("strip: could not arp starmode addr %x\n",
! 751: ((struct sockaddr_in *)dst)->sin_addr.s_addr));
! 752: m_freem(m);
! 753: return (EHOSTUNREACH);
! 754: }
! 755: /*bcopy(LLADDR(SDL(rt->rt_gateway)), dldst, ifp->if_addrlen);*/
! 756: dldst = LLADDR(SDL(rt->rt_gateway));
! 757: break;
! 758:
! 759: case AF_LINK:
! 760: /*bcopy(LLADDR(SDL(rt->rt_gateway)), dldst, ifp->if_addrlen);*/
! 761: dldst = LLADDR(SDL(dst));
! 762: break;
! 763:
! 764: default:
! 765: /*
! 766: * `Cannot happen' (see stripioctl). Someday we will extend
! 767: * the line protocol to support other address families.
! 768: */
! 769: addlog("%s: af %d not supported\n", sc->sc_if.if_xname,
! 770: dst->sa_family);
! 771: m_freem(m);
! 772: sc->sc_if.if_noproto++;
! 773: return (EAFNOSUPPORT);
! 774: }
! 775:
! 776: ifq = NULL;
! 777: ip = mtod(m, struct ip *);
! 778: if (sc->sc_if.if_flags & SC_NOICMP && ip->ip_p == IPPROTO_ICMP) {
! 779: m_freem(m);
! 780: return (ENETRESET); /* XXX ? */
! 781: }
! 782: if ((ip->ip_tos & IPTOS_LOWDELAY)
! 783: #ifdef ALTQ
! 784: && ALTQ_IS_ENABLED(&sc->sc_if.if_snd) == 0
! 785: #endif
! 786: )
! 787: ifq = &sc->sc_fastq;
! 788:
! 789: /*
! 790: * Add local net header. If no space in first mbuf,
! 791: * add another.
! 792: */
! 793: M_PREPEND(m, sizeof(struct st_header), M_DONTWAIT);
! 794: if (m == 0) {
! 795: DPRINTF(("strip: could not prepend starmode header\n"));
! 796: return (ENOBUFS);
! 797: }
! 798:
! 799:
! 800: /*
! 801: * Unpack BCD route entry into an ASCII starmode address.
! 802: */
! 803:
! 804: dl_addrbuf[0] = '*';
! 805:
! 806: dl_addrbuf[1] = ((dldst[0] >> 4) & 0x0f) + '0';
! 807: dl_addrbuf[2] = ((dldst[0] ) & 0x0f) + '0';
! 808:
! 809: dl_addrbuf[3] = ((dldst[1] >> 4) & 0x0f) + '0';
! 810: dl_addrbuf[4] = ((dldst[1] ) & 0x0f) + '0';
! 811:
! 812: dl_addrbuf[5] = '-';
! 813:
! 814: dl_addrbuf[6] = ((dldst[2] >> 4) & 0x0f) + '0';
! 815: dl_addrbuf[7] = ((dldst[2] ) & 0x0f) + '0';
! 816:
! 817: dl_addrbuf[8] = ((dldst[3] >> 4) & 0x0f) + '0';
! 818: dl_addrbuf[9] = ((dldst[3] ) & 0x0f) + '0';
! 819:
! 820: dl_addrbuf[10] = '*';
! 821: dl_addrbuf[11] = 0;
! 822: dldst = dl_addrbuf;
! 823:
! 824: shp = mtod(m, struct st_header *);
! 825: bcopy((caddr_t)"SIP0", (caddr_t)shp->starmode_type,
! 826: sizeof(shp->starmode_type));
! 827:
! 828: bcopy((caddr_t)dldst, (caddr_t)shp->starmode_addr,
! 829: sizeof (shp->starmode_addr));
! 830:
! 831: s = spltty();
! 832: if (sc->sc_oqlen && sc->sc_ttyp->t_outq.c_cc == sc->sc_oqlen) {
! 833: struct timeval tv, tm;
! 834:
! 835: /* if output's been stalled for too long, and restart */
! 836: getmicrotime(&tm);
! 837: timersub(&tm, &sc->sc_lastpacket, &tv);
! 838: if (tv.tv_sec > 0) {
! 839: DPRINTF(("stripoutput: stalled, resetting\n"));
! 840: sc->sc_otimeout++;
! 841: stripstart(sc->sc_ttyp);
! 842: }
! 843: }
! 844:
! 845: (void) splnet();
! 846: if (ifq != NULL) {
! 847: if (IF_QFULL(ifq)) {
! 848: IF_DROP(ifq);
! 849: m_freem(m);
! 850: error = ENOBUFS;
! 851: } else {
! 852: IF_ENQUEUE(ifq, m);
! 853: error = 0;
! 854: }
! 855: } else
! 856: IFQ_ENQUEUE(&sc->sc_if.if_snd, m, NULL, error);
! 857: if (error) {
! 858: splx(s);
! 859: sc->sc_if.if_oerrors++;
! 860: return (error);
! 861: }
! 862:
! 863: (void) spltty();
! 864: getmicrotime(&sc->sc_lastpacket);
! 865: if ((sc->sc_oqlen = sc->sc_ttyp->t_outq.c_cc) == 0) {
! 866: stripstart(sc->sc_ttyp);
! 867: }
! 868:
! 869: /*
! 870: * slip doesn't call its start routine unconditionally (again)
! 871: * here, but doing so apepars to reduce latency.
! 872: */
! 873: stripstart(sc->sc_ttyp);
! 874:
! 875: splx(s);
! 876: return (0);
! 877: }
! 878:
! 879:
! 880: /*
! 881: * Start output on interface. Get another datagram
! 882: * to send from the interface queue and map it to
! 883: * the interface before starting output.
! 884: *
! 885: */
! 886: void
! 887: stripstart(tp)
! 888: struct tty *tp;
! 889: {
! 890: struct st_softc *sc = (struct st_softc *)tp->t_sc;
! 891: struct mbuf *m;
! 892: struct ip *ip;
! 893: int s;
! 894: #if NBPFILTER > 0
! 895: u_char bpfbuf[SLMTU + SLIP_HDRLEN];
! 896: int len = 0;
! 897: #endif
! 898: #if !(defined(__NetBSD__) || defined(__OpenBSD__)) /* XXX - cgd */
! 899: extern int cfreecount;
! 900: #endif
! 901:
! 902:
! 903: /*
! 904: * Ppp checks that strip is still the line discipline,
! 905: * and if not, calls t_oproc here. sl.c does not.
! 906: * PPP is newer...
! 907: */
! 908:
! 909: if (((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0)
! 910: || sc == NULL || tp != (struct tty *) sc->sc_ttyp) {
! 911: if (tp->t_oproc != NULL)
! 912: (*tp->t_oproc)(tp);
! 913: if (sc && (sc->sc_if.if_flags & IFF_DEBUG))
! 914: addlog("%s: late call to stripstart\n ",
! 915: sc->sc_if.if_xname);
! 916: }
! 917:
! 918: /* Start any pending output asap */
! 919: if (CCOUNT(&tp->t_outq) != 0) {
! 920: (*tp->t_oproc)(tp);
! 921: }
! 922:
! 923: while (CCOUNT(&tp->t_outq) < SLIP_HIWAT) {
! 924:
! 925: /*
! 926: * This happens briefly when the line shuts down.
! 927: */
! 928: if (sc == NULL) {
! 929: return;
! 930: }
! 931:
! 932: #if defined(__NetBSD__) || defined(__OpenBSD__) /* XXX - cgd */
! 933: /*
! 934: * Do not remove the packet from the IP queue if it
! 935: * doesn't look like the packet will fit into the
! 936: * current serial output queue, with a packet full of
! 937: * escapes this could be as bad as STRIP_MTU_ONWIRE
! 938: * (for slip, SLMTU*2+2, for STRIP, header + 20 bytes).
! 939: * Also allow 4 bytes in case we need to send a probe
! 940: * to the radio.
! 941: */
! 942: if (tp->t_outq.c_cn - tp->t_outq.c_cc < STRIP_MTU_ONWIRE + 4)
! 943: return;
! 944: #endif /* __NetBSD__ */
! 945: /*
! 946: * Get a packet and send it to the interface.
! 947: */
! 948: s = splnet();
! 949: IF_DEQUEUE(&sc->sc_fastq, m);
! 950: if (m)
! 951: sc->sc_if.if_omcasts++; /* XXX */
! 952: else
! 953: IFQ_DEQUEUE(&sc->sc_if.if_snd, m);
! 954: splx(s);
! 955: if (m == NULL) {
! 956: return;
! 957: }
! 958: /*
! 959: * We do the header compression here rather than in stripoutput
! 960: * because the packets will be out of order if we are using TOS
! 961: * queueing, and the connection id compression will get
! 962: * munged when this happens.
! 963: */
! 964: #if NBPFILTER > 0
! 965: if (sc->sc_bpf) {
! 966: /*
! 967: * We need to save the TCP/IP header before it's
! 968: * compressed. To avoid complicated code, we just
! 969: * copy the entire packet into a stack buffer (since
! 970: * this is a serial line, packets should be short
! 971: * and/or the copy should be negligible cost compared
! 972: * to the packet transmission time).
! 973: */
! 974: struct mbuf *m1 = m;
! 975: u_char *cp = bpfbuf + SLIP_HDRLEN;
! 976:
! 977: len = 0;
! 978: do {
! 979: int mlen = m1->m_len;
! 980:
! 981: bcopy(mtod(m1, caddr_t), cp, mlen);
! 982: cp += mlen;
! 983: len += mlen;
! 984: } while ((m1 = m1->m_next) != NULL);
! 985: }
! 986: #endif
! 987: if ((ip = mtod(m, struct ip *))->ip_p == IPPROTO_TCP) {
! 988: if (sc->sc_if.if_flags & SC_COMPRESS)
! 989: *mtod(m, u_char *) |= sl_compress_tcp(m, ip,
! 990: &sc->sc_comp, 1);
! 991: }
! 992: #if NBPFILTER > 0
! 993: if (sc->sc_bpf) {
! 994: u_char *cp = bpfbuf + STRIP_HDRLEN;
! 995: /*
! 996: * Put the SLIP pseudo-"link header" in place. The
! 997: * compressed header is now at the beginning of the
! 998: * mbuf.
! 999: */
! 1000: cp[SLX_DIR] = SLIPDIR_OUT;
! 1001:
! 1002: bcopy(mtod(m, caddr_t)+STRIP_HDRLEN, &cp[SLX_CHDR], CHDR_LEN);
! 1003: bpf_tap(sc->sc_bpf, cp, len + SLIP_HDRLEN,
! 1004: BPF_DIRECTION_OUT);
! 1005: }
! 1006: #endif
! 1007: getmicrotime(&sc->sc_lastpacket);
! 1008:
! 1009: #if !(defined(__NetBSD__) || defined(__OpenBSD__)) /* XXX - cgd */
! 1010: /*
! 1011: * If system is getting low on clists, just flush our
! 1012: * output queue (if the stuff was important, it'll get
! 1013: * retransmitted).
! 1014: */
! 1015: if (cfreecount < CLISTRESERVE + SLMTU) {
! 1016: m_freem(m);
! 1017: sc->sc_if.if_collisions++;
! 1018: continue;
! 1019: }
! 1020: #endif /* !__NetBSD__ */
! 1021:
! 1022: if (strip_send(sc, m) == NULL) {
! 1023: DPRINTF(("stripsend: failed to send pkt\n")); /*XXX*/
! 1024: }
! 1025: }
! 1026:
! 1027:
! 1028: #if 0
! 1029: /* schedule timeout to start output */
! 1030: if ((sc->sc_flags & SC_TIMEOUT) == 0) {
! 1031: timeout_add(&sc->sc_timo, hz);
! 1032: sc->sc_flags |= SC_TIMEOUT;
! 1033: }
! 1034: #endif
! 1035:
! 1036: #if 0
! 1037: /*
! 1038: * This timeout is needed for operation on a pseudo-tty,
! 1039: * because the pty code doesn't call our start routine
! 1040: * after it has drained the t_outq.
! 1041: */
! 1042: if ((sc->sc_flags & SC_TIMEOUT) == 0) {
! 1043: timeout_add(&sc->sc_timo, hz);
! 1044: sc->sc_flags |= SC_TIMEOUT;
! 1045: }
! 1046: #endif
! 1047:
! 1048: /*
! 1049: * XXX ppp calls oproc at the end of its loop, but slip
! 1050: * does it at the beginning. We do both.
! 1051: */
! 1052:
! 1053: /*
! 1054: * If there is stuff in the output queue, send it now.
! 1055: * We are being called in lieu of ttstart and must do what it would.
! 1056: */
! 1057: if (tp->t_oproc != NULL)
! 1058: (*tp->t_oproc)(tp);
! 1059: }
! 1060:
! 1061:
! 1062:
! 1063: /*
! 1064: * Copy data buffer to mbuf chain; add ifnet pointer.
! 1065: */
! 1066: static struct mbuf *
! 1067: strip_btom(sc, len)
! 1068: struct st_softc *sc;
! 1069: int len;
! 1070: {
! 1071: struct mbuf *m;
! 1072:
! 1073: MGETHDR(m, M_DONTWAIT, MT_DATA);
! 1074: if (m == NULL)
! 1075: return (NULL);
! 1076:
! 1077: /*
! 1078: * If we have more than MHLEN bytes, it's cheaper to
! 1079: * queue the cluster we just filled & allocate a new one
! 1080: * for the input buffer. Otherwise, fill the mbuf we
! 1081: * allocated above. Note that code in the input routine
! 1082: * guarantees that packet will fit in a cluster.
! 1083: */
! 1084: if (len >= MHLEN) {
! 1085: MCLGET(m, M_DONTWAIT);
! 1086: if ((m->m_flags & M_EXT) == 0) {
! 1087: /*
! 1088: * we couldn't get a cluster - if memory's this
! 1089: * low, it's time to start dropping packets.
! 1090: */
! 1091: (void) m_free(m);
! 1092: return (NULL);
! 1093: }
! 1094: sc->sc_ep = mtod(m, u_char *) + SLBUFSIZE;
! 1095: m->m_data = (caddr_t)sc->sc_buf;
! 1096: m->m_ext.ext_buf = (caddr_t)((long)sc->sc_buf &~ MCLOFSET);
! 1097: } else
! 1098: bcopy((caddr_t)sc->sc_buf, mtod(m, caddr_t), len);
! 1099:
! 1100: m->m_len = len;
! 1101: m->m_pkthdr.len = len;
! 1102: m->m_pkthdr.rcvif = &sc->sc_if;
! 1103: return (m);
! 1104: }
! 1105:
! 1106: /*
! 1107: * tty interface receiver interrupt.
! 1108: *
! 1109: * Called with a single char from the tty receiver interrupt; put
! 1110: * the char into the buffer containing a partial packet. If the
! 1111: * char is a packet delimiter, decapsulate the packet, wrap it in
! 1112: * an mbuf, and put it on the protocol input queue.
! 1113: */
! 1114: void
! 1115: stripinput(c, tp)
! 1116: int c;
! 1117: struct tty *tp;
! 1118: {
! 1119: struct st_softc *sc;
! 1120: struct mbuf *m;
! 1121: int len;
! 1122: int s;
! 1123: #if NBPFILTER > 0
! 1124: u_char chdr[CHDR_LEN];
! 1125: #endif
! 1126:
! 1127: tk_nin++;
! 1128: sc = (struct st_softc *)tp->t_sc;
! 1129: if (sc == NULL)
! 1130: return;
! 1131: if (c & TTY_ERRORMASK || ((tp->t_state & TS_CARR_ON) == 0 &&
! 1132: (tp->t_cflag & CLOCAL) == 0)) {
! 1133: sc->sc_flags |= SC_ERROR;
! 1134: DPRINTF(("strip: input, error %x\n", c)); /* XXX */
! 1135: return;
! 1136: }
! 1137: c &= TTY_CHARMASK;
! 1138:
! 1139: ++sc->sc_if.if_ibytes;
! 1140:
! 1141: /*
! 1142: * Accumulate characters until we see a frame terminator (\r).
! 1143: */
! 1144: switch (c) {
! 1145:
! 1146: case '\n':
! 1147: /*
! 1148: * Error message strings from the modem are terminated with
! 1149: * \r\n. This driver interprets the \r as a packet terminator.
! 1150: * If the first character in a packet is a \n, drop it.
! 1151: * (it can never be the first char of a vaild frame).
! 1152: */
! 1153: if (sc->sc_mp - sc->sc_buf == 0)
! 1154: break;
! 1155:
! 1156: /* Fall through to */
! 1157:
! 1158: default:
! 1159: if (sc->sc_mp < sc->sc_ep) {
! 1160: *sc->sc_mp++ = c;
! 1161: } else {
! 1162: sc->sc_flags |= SC_ERROR;
! 1163: goto error;
! 1164: }
! 1165: return;
! 1166:
! 1167: case STRIP_FRAME_END:
! 1168: break;
! 1169: }
! 1170:
! 1171:
! 1172: /*
! 1173: * We only reach here if we see a CR delimiting a packet.
! 1174: */
! 1175:
! 1176:
! 1177: len = sc->sc_mp - sc->sc_buf;
! 1178:
! 1179: #ifdef XDEBUG
! 1180: if (len < 15 || sc->sc_flags & SC_ERROR)
! 1181: addlog("stripinput: end of pkt, len %d, err %d\n",
! 1182: len, sc->sc_flags & SC_ERROR); /*XXX*/
! 1183: #endif
! 1184: if(sc->sc_flags & SC_ERROR) {
! 1185: sc->sc_flags &= ~SC_ERROR;
! 1186: addlog("%s: sc error flag set. terminating packet\n",
! 1187: sc->sc_if.if_xname);
! 1188: goto newpack;
! 1189: }
! 1190:
! 1191: /*
! 1192: * We have a frame.
! 1193: * Process an IP packet, ARP packet, AppleTalk packet,
! 1194: * AT command resposne, or Starmode error.
! 1195: */
! 1196: len = strip_newpacket(sc, sc->sc_buf, sc->sc_mp);
! 1197: if (len <= 1)
! 1198: /* less than min length packet - ignore */
! 1199: goto newpack;
! 1200:
! 1201:
! 1202: #if NBPFILTER > 0
! 1203: if (sc->sc_bpf) {
! 1204: /*
! 1205: * Save the compressed header, so we
! 1206: * can tack it on later. Note that we
! 1207: * will end up copying garbage in some
! 1208: * cases but this is okay. We remember
! 1209: * where the buffer started so we can
! 1210: * compute the new header length.
! 1211: */
! 1212: bcopy(sc->sc_buf, chdr, CHDR_LEN);
! 1213: }
! 1214: #endif
! 1215:
! 1216: if ((c = (*sc->sc_buf & 0xf0)) != (IPVERSION << 4)) {
! 1217: if (c & 0x80)
! 1218: c = TYPE_COMPRESSED_TCP;
! 1219: else if (c == TYPE_UNCOMPRESSED_TCP)
! 1220: *sc->sc_buf &= 0x4f; /* XXX */
! 1221: /*
! 1222: * We've got something that's not an IP packet.
! 1223: * If compression is enabled, try to decompress it.
! 1224: * Otherwise, if `auto-enable' compression is on and
! 1225: * it's a reasonable packet, decompress it and then
! 1226: * enable compression. Otherwise, drop it.
! 1227: */
! 1228: if (sc->sc_if.if_flags & SC_COMPRESS) {
! 1229: len = sl_uncompress_tcp(&sc->sc_buf, len,
! 1230: (u_int)c, &sc->sc_comp);
! 1231: if (len <= 0)
! 1232: goto error;
! 1233: } else if ((sc->sc_if.if_flags & SC_AUTOCOMP) &&
! 1234: c == TYPE_UNCOMPRESSED_TCP && len >= 40) {
! 1235: len = sl_uncompress_tcp(&sc->sc_buf, len,
! 1236: (u_int)c, &sc->sc_comp);
! 1237: if (len <= 0)
! 1238: goto error;
! 1239: sc->sc_if.if_flags |= SC_COMPRESS;
! 1240: } else
! 1241: goto error;
! 1242: }
! 1243:
! 1244: #if NBPFILTER > 0
! 1245: if (sc->sc_bpf) {
! 1246: /*
! 1247: * Put the SLIP pseudo-"link header" in place.
! 1248: * We couldn't do this any earlier since
! 1249: * decompression probably moved the buffer
! 1250: * pointer. Then, invoke BPF.
! 1251: */
! 1252: u_char *hp = sc->sc_buf - SLIP_HDRLEN;
! 1253:
! 1254: hp[SLX_DIR] = SLIPDIR_IN;
! 1255: bcopy(chdr, &hp[SLX_CHDR], CHDR_LEN);
! 1256: bpf_tap(sc->sc_bpf, hp, len + SLIP_HDRLEN, BPF_DIRECTION_IN);
! 1257: }
! 1258: #endif
! 1259: m = strip_btom(sc, len);
! 1260: if (m == NULL) {
! 1261: goto error;
! 1262: }
! 1263:
! 1264: sc->sc_if.if_ipackets++;
! 1265: getmicrotime(&sc->sc_lastpacket);
! 1266: s = splnet();
! 1267: if (IF_QFULL(&ipintrq)) {
! 1268: IF_DROP(&ipintrq);
! 1269: sc->sc_if.if_ierrors++;
! 1270: sc->sc_if.if_iqdrops++;
! 1271: if (!ipintrq.ifq_congestion)
! 1272: if_congestion(&ipintrq);
! 1273: m_freem(m);
! 1274: } else {
! 1275: IF_ENQUEUE(&ipintrq, m);
! 1276: schednetisr(NETISR_IP);
! 1277: }
! 1278: splx(s);
! 1279: goto newpack;
! 1280:
! 1281: error:
! 1282: sc->sc_if.if_ierrors++;
! 1283:
! 1284: newpack:
! 1285:
! 1286: sc->sc_mp = sc->sc_buf = sc->sc_ep - SLMAX;
! 1287: }
! 1288:
! 1289: /*
! 1290: * Process an ioctl request.
! 1291: */
! 1292: int
! 1293: stripioctl(ifp, cmd, data)
! 1294: struct ifnet *ifp;
! 1295: u_long cmd;
! 1296: caddr_t data;
! 1297: {
! 1298: struct ifaddr *ifa = (struct ifaddr *)data;
! 1299: struct ifreq *ifr;
! 1300: int s = splnet(), error = 0;
! 1301:
! 1302: switch (cmd) {
! 1303:
! 1304: case SIOCSIFADDR:
! 1305: if (ifa->ifa_addr->sa_family == AF_INET)
! 1306: ifp->if_flags |= IFF_UP;
! 1307: else
! 1308: error = EAFNOSUPPORT;
! 1309: break;
! 1310:
! 1311: case SIOCSIFDSTADDR:
! 1312: if (ifa->ifa_addr->sa_family != AF_INET)
! 1313: error = EAFNOSUPPORT;
! 1314: break;
! 1315:
! 1316: case SIOCADDMULTI:
! 1317: case SIOCDELMULTI:
! 1318: ifr = (struct ifreq *)data;
! 1319: if (ifr == 0) {
! 1320: error = EAFNOSUPPORT; /* XXX */
! 1321: break;
! 1322: }
! 1323: switch (ifr->ifr_addr.sa_family) {
! 1324:
! 1325: #ifdef INET
! 1326: case AF_INET:
! 1327: break;
! 1328: #endif
! 1329:
! 1330: default:
! 1331: error = EAFNOSUPPORT;
! 1332: break;
! 1333: }
! 1334: break;
! 1335:
! 1336: default:
! 1337:
! 1338: #ifdef DEBUG
! 1339: addlog("stripioctl: unknown request 0x%lx\n", cmd);
! 1340: #endif
! 1341: error = EINVAL;
! 1342: }
! 1343: splx(s);
! 1344: return (error);
! 1345: }
! 1346:
! 1347:
! 1348: /*
! 1349: * Strip subroutines
! 1350: */
! 1351:
! 1352: /*
! 1353: * Set a radio into starmode.
! 1354: * XXX must be called at spltty() or higher (e.g., splvm()
! 1355: */
! 1356: void
! 1357: strip_resetradio(sc, tp)
! 1358: struct st_softc *sc;
! 1359: struct tty *tp;
! 1360: {
! 1361: #if 0
! 1362: static ttychar_t InitString[] =
! 1363: "\r\n\r\n\r\nat\r\n\r\n\r\nate0dt**starmode\r\n**\r\n";
! 1364: #else
! 1365: static ttychar_t InitString[] =
! 1366: "\r\rat\r\r\rate0q1dt**starmode\r**\r";
! 1367: #endif
! 1368: int i;
! 1369:
! 1370: /*
! 1371: * XXX Perhaps flush tty output queue?
! 1372: */
! 1373:
! 1374: if (tp == NULL)
! 1375: return;
! 1376:
! 1377: if ((i = b_to_q(InitString, sizeof(InitString) - 1, &tp->t_outq))) {
! 1378: addlog("resetradio: %d chars didn't fit in tty queue\n", i);
! 1379: return;
! 1380: }
! 1381: sc->sc_if.if_obytes += sizeof(InitString) - 1;
! 1382:
! 1383: /*
! 1384: * Assume the radio is still dead, so we can detect repeated
! 1385: * resets (perhaps the radio is disconnected, powered off, or
! 1386: * is so badlyhung it needs powercycling.
! 1387: */
! 1388: sc->sc_state = ST_DEAD;
! 1389: getmicrotime(&sc->sc_lastpacket);
! 1390: sc->sc_statetimo = time_second + STRIP_RESET_INTERVAL;
! 1391:
! 1392: /*
! 1393: * XXX Does calling the tty output routine now help resets?
! 1394: */
! 1395: (*sc->sc_ttyp->t_oproc)(tp);
! 1396: }
! 1397:
! 1398:
! 1399: /*
! 1400: * Send an invalid starmode packet to the radio, to induce an error message
! 1401: * indicating the radio is in starmode.
! 1402: * Update the state machine to indicate a response is expected.
! 1403: * Either the radio answers, which will be caught by the parser,
! 1404: * or the watchdog will start resetting.
! 1405: *
! 1406: * NOTE: drops chars directly on the tty output queue.
! 1407: * should be caled at spl >= spltty.
! 1408: */
! 1409: void
! 1410: strip_proberadio(sc, tp)
! 1411: struct st_softc *sc;
! 1412: struct tty *tp;
! 1413: {
! 1414:
! 1415: int overflow;
! 1416: char *strip_probestr = "**";
! 1417:
! 1418: if (sc->sc_if.if_flags & IFF_DEBUG)
! 1419: addlog("%s: attempting to probe radio\n", sc->sc_if.if_xname);
! 1420:
! 1421: if (tp == NULL) {
! 1422: addlog("%s: no tty attached\n", sc->sc_if.if_xname);
! 1423: return;
! 1424: }
! 1425:
! 1426: overflow = b_to_q((ttychar_t *)strip_probestr, 2, &tp->t_outq);
! 1427: if (overflow == 0) {
! 1428: if (sc->sc_if.if_flags & IFF_DEBUG)
! 1429: addlog("%s:: sent probe to radio\n",
! 1430: sc->sc_if.if_xname);
! 1431: /* Go to probe-sent state, set timeout accordingly. */
! 1432: sc->sc_state = ST_PROBE_SENT;
! 1433: sc->sc_statetimo = time_second + ST_PROBERESPONSE_INTERVAL;
! 1434: } else {
! 1435: addlog("%s: incomplete probe, tty queue %d bytes overfull\n",
! 1436: sc->sc_if.if_xname, overflow);
! 1437: }
! 1438: }
! 1439:
! 1440:
! 1441: #ifdef DEBUG
! 1442: static char *strip_statenames[] = {
! 1443: "Alive",
! 1444: "Probe sent, awaiting answer",
! 1445: "Probe not answered, resetting"
! 1446: };
! 1447: #endif
! 1448:
! 1449:
! 1450: /*
! 1451: * Timeout routine -- try to start more output.
! 1452: * Will be needed to make strip work on ptys.
! 1453: */
! 1454: void
! 1455: strip_timeout(x)
! 1456: void *x;
! 1457: {
! 1458: struct st_softc *sc = (struct st_softc *) x;
! 1459: struct tty *tp = sc->sc_ttyp;
! 1460: int s;
! 1461:
! 1462: s = spltty();
! 1463: sc->sc_flags &= ~SC_TIMEOUT;
! 1464: stripstart(tp);
! 1465: splx(s);
! 1466: }
! 1467:
! 1468:
! 1469: /*
! 1470: * Strip watchdog routine.
! 1471: * The radio hardware is balky. When sent long packets or bursts of small
! 1472: * packets, the radios crash and reboots into Hayes-emulation mode.
! 1473: * The transmit-side machinery, the error parser, and strip_watchdog()
! 1474: * implement a simple finite state machine.
! 1475: *
! 1476: * We attempt to send a probe to the radio every ST_PROBE seconds. There
! 1477: * is no direct way to tell if the radio is in starmode, so we send it a
! 1478: * malformed starmode packet -- a frame with no destination address --
! 1479: * and expect to an "name missing" error response from the radio within
! 1480: * 1 second. If we hear such a response, we assume the radio is alive
! 1481: * for the next ST_PROBE seconds.
! 1482: * If we don't hear a starmode-error response from the radio, we reset it.
! 1483: *
! 1484: * Probes, and parsing of error responses, are normally done inside the send
! 1485: * and receive side respectively. This watchdog routine examines the
! 1486: * state-machine variables. If there are no packets to send to the radio
! 1487: * during an entire probe interval, strip_output will not be called,
! 1488: * so we send a probe on its behalf.
! 1489: */
! 1490: void
! 1491: strip_watchdog(ifp)
! 1492: struct ifnet *ifp;
! 1493: {
! 1494: struct st_softc *sc = ifp->if_softc;
! 1495: struct tty *tp = sc->sc_ttyp;
! 1496:
! 1497: #ifdef DEBUG
! 1498: if (ifp->if_flags & IFF_DEBUG)
! 1499: addlog("\n%s: in watchdog, state %s timeout %ld\n",
! 1500: ifp->if_xname,
! 1501: ((unsigned) sc->sc_state < 3) ?
! 1502: strip_statenames[sc->sc_state] : "<<illegal state>>",
! 1503: sc->sc_statetimo - time_second);
! 1504: #endif
! 1505:
! 1506: /*
! 1507: * If time in this state hasn't yet expired, return.
! 1508: */
! 1509: if ((ifp->if_flags & IFF_UP) == 0 || sc->sc_statetimo > time_second) {
! 1510: goto done;
! 1511: }
! 1512:
! 1513: /*
! 1514: * The time in the current state has expired.
! 1515: * Take appropriate action and advance FSA to the next state.
! 1516: */
! 1517: switch (sc->sc_state) {
! 1518: case ST_ALIVE:
! 1519: /*
! 1520: * A probe is due but we haven't piggybacked one on a packet.
! 1521: * Send a probe now.
! 1522: */
! 1523: if (tp == NULL)
! 1524: break;
! 1525: strip_proberadio(sc, sc->sc_ttyp);
! 1526: (*tp->t_oproc)(tp);
! 1527: break;
! 1528:
! 1529: case ST_PROBE_SENT:
! 1530: /*
! 1531: * Probe sent but no response within timeout. Reset.
! 1532: */
! 1533: addlog("%s: no answer to probe, resetting radio\n",
! 1534: ifp->if_xname);
! 1535: strip_resetradio(sc, sc->sc_ttyp);
! 1536: ifp->if_oerrors++;
! 1537: break;
! 1538:
! 1539: case ST_DEAD:
! 1540: /*
! 1541: * The radio has been sent a reset but didn't respond.
! 1542: * XXX warn user to remove AC adaptor and battery,
! 1543: * wait 5 secs, and replace.
! 1544: */
! 1545: addlog("%s: radio reset but not responding, Trying again\n",
! 1546: ifp->if_xname);
! 1547: strip_resetradio(sc, sc->sc_ttyp);
! 1548: ifp->if_oerrors++;
! 1549: break;
! 1550:
! 1551: default:
! 1552: /* Cannot happen. To be safe, do a reset. */
! 1553: addlog("%s: %s %d, resetting\n",
! 1554: sc->sc_if.if_xname,
! 1555: "radio-reset finite-state machine in invalid state",
! 1556: sc->sc_state);
! 1557: strip_resetradio(sc, sc->sc_ttyp);
! 1558: sc->sc_state = ST_DEAD;
! 1559: break;
! 1560: }
! 1561:
! 1562: done:
! 1563: ifp->if_timer = STRIP_WATCHDOG_INTERVAL;
! 1564: return;
! 1565: }
! 1566:
! 1567:
! 1568: /*
! 1569: * The following bytestuffing and run-length encoding/decoding
! 1570: * fucntions are taken, with permission from Stuart Cheshire,
! 1571: * from the MosquitonNet strip driver for Linux.
! 1572: * XXX Linux style left intact, to ease folding in updates from
! 1573: * the Mosquitonet group.
! 1574: */
! 1575:
! 1576:
! 1577: /*
! 1578: * Process a received packet.
! 1579: */
! 1580: int
! 1581: strip_newpacket(sc, ptr, end)
! 1582: struct st_softc *sc;
! 1583: u_char *ptr, *end;
! 1584: {
! 1585: int len = ptr - end;
! 1586: u_char *name, *name_end;
! 1587: u_int packetlen;
! 1588:
! 1589: /* Ignore empty lines */
! 1590: if (len == 0) return 0;
! 1591:
! 1592: /* Catch 'OK' responses which show radio has fallen out of starmode */
! 1593: if (len >= 2 && ptr[0] == 'O' && ptr[1] == 'K') {
! 1594: addlog("%s: Radio is back in AT command mode: will reset\n",
! 1595: sc->sc_if.if_xname);
! 1596: FORCE_RESET(sc); /* Do reset ASAP */
! 1597: return 0;
! 1598: }
! 1599:
! 1600: /* Check for start of address marker, and then skip over it */
! 1601: if (*ptr != '*') {
! 1602: /* Catch other error messages */
! 1603: if (ptr[0] == 'E' && ptr[1] == 'R' && ptr[2] == 'R' && ptr[3] == '_')
! 1604: RecvErr_Message(sc, NULL, ptr+4);
! 1605: /* XXX what should the message above be? */
! 1606: else {
! 1607: RecvErr("No initial *", sc);
! 1608: addlog("(len = %d)\n", len);
! 1609: }
! 1610: return 0;
! 1611: }
! 1612:
! 1613: /* skip the '*' */
! 1614: ptr++;
! 1615:
! 1616: /* Skip the return address */
! 1617: name = ptr;
! 1618: while (ptr < end && *ptr != '*')
! 1619: ptr++;
! 1620:
! 1621: /* Check for end of address marker, and skip over it */
! 1622: if (ptr == end) {
! 1623: RecvErr("No second *", sc);
! 1624: return 0;
! 1625: }
! 1626: name_end = ptr++;
! 1627:
! 1628: /* Check for SRIP key, and skip over it */
! 1629: if (ptr[0] != 'S' || ptr[1] != 'I' || ptr[2] != 'P' || ptr[3] != '0') {
! 1630: if (ptr[0] == 'E' && ptr[1] == 'R' && ptr[2] == 'R' &&
! 1631: ptr[3] == '_') {
! 1632: *name_end = 0;
! 1633: RecvErr_Message(sc, name, ptr+4);
! 1634: }
! 1635: else RecvErr("No SRIP key", sc);
! 1636: return 0;
! 1637: }
! 1638: ptr += 4;
! 1639:
! 1640: /* Decode start of the IP packet header */
! 1641: ptr = UnStuffData(ptr, end, sc->sc_rxbuf, 4);
! 1642: if (ptr == 0) {
! 1643: RecvErr("Runt packet (hdr)", sc);
! 1644: return 0;
! 1645: }
! 1646:
! 1647: /*
! 1648: * The STRIP bytestuff/RLL encoding has no explicit length
! 1649: * of the decoded packet. Decode start of IP header, get the
! 1650: * IP header length and decode that many bytes in total.
! 1651: */
! 1652: packetlen = ((u_short)sc->sc_rxbuf[2] << 8) | sc->sc_rxbuf[3];
! 1653:
! 1654: #ifdef DIAGNOSTIC
! 1655: /* addlog("Packet %02x.%02x.%02x.%02x\n",
! 1656: sc->sc_rxbuf[0], sc->sc_rxbuf[1],
! 1657: sc->sc_rxbuf[2], sc->sc_rxbuf[3]);
! 1658: addlog("Got %d byte packet\n", packetlen); */
! 1659: #endif
! 1660:
! 1661: /* Decode remainder of the IP packer */
! 1662: ptr = UnStuffData(ptr, end, sc->sc_rxbuf+4, packetlen-4);
! 1663: if (ptr == 0) {
! 1664: RecvErr("Short packet", sc);
! 1665: return 0;
! 1666: }
! 1667:
! 1668: /* XXX redundant copy */
! 1669: bcopy(sc->sc_rxbuf, sc->sc_buf, packetlen );
! 1670: return (packetlen);
! 1671: }
! 1672:
! 1673:
! 1674: /*
! 1675: * Stuffing scheme:
! 1676: * 00 Unused (reserved character)
! 1677: * 01-3F Run of 2-64 different characters
! 1678: * 40-7F Run of 1-64 different characters plus a single zero at the end
! 1679: * 80-BF Run of 1-64 of the same character
! 1680: * C0-FF Run of 1-64 zeroes (ASCII 0)
! 1681: */
! 1682: typedef enum
! 1683: {
! 1684: Stuff_Diff = 0x00,
! 1685: Stuff_DiffZero = 0x40,
! 1686: Stuff_Same = 0x80,
! 1687: Stuff_Zero = 0xC0,
! 1688: Stuff_NoCode = 0xFF, /* Special code, meaning no code selected */
! 1689:
! 1690: Stuff_CodeMask = 0xC0,
! 1691: Stuff_CountMask = 0x3F,
! 1692: Stuff_MaxCount = 0x3F,
! 1693: Stuff_Magic = 0x0D /* The value we are eliminating */
! 1694: } StuffingCode;
! 1695:
! 1696: /*
! 1697: * StuffData encodes the data starting at "src" for "length" bytes.
! 1698: * It writes it to the buffer pointed to by "dest" (which must be at least
! 1699: * as long as 1 + 65/64 of the input length). The output may be up to 1.6%
! 1700: * larger than the input for pathological input, but will usually be smaller.
! 1701: * StuffData returns the new value of the dest pointer as its result.
! 1702: *
! 1703: * "code_ptr_ptr" points to a "u_char *" which is used to hold
! 1704: * encoding state between calls, allowing an encoded packet to be
! 1705: * incrementally built up from small parts.
! 1706: * On the first call, the "u_char *" pointed to should be initialized
! 1707: * to NULL; between subsequent calls the calling routine should leave
! 1708: * the value alone and simply pass it back unchanged so that the
! 1709: * encoder can recover its current state.
! 1710: */
! 1711:
! 1712: #define StuffData_FinishBlock(X) \
! 1713: (*code_ptr = (X) ^ Stuff_Magic, code = Stuff_NoCode)
! 1714:
! 1715: static u_char *
! 1716: StuffData(u_char *src, u_long length, u_char *dest, u_char **code_ptr_ptr)
! 1717: {
! 1718: u_char *end = src + length;
! 1719: u_char *code_ptr = *code_ptr_ptr;
! 1720: u_char code = Stuff_NoCode, count = 0;
! 1721:
! 1722: if (!length) return (dest);
! 1723:
! 1724: if (code_ptr) { /* Recover state from last call, if applicable */
! 1725: code = (*code_ptr ^ Stuff_Magic) & Stuff_CodeMask;
! 1726: count = (*code_ptr ^ Stuff_Magic) & Stuff_CountMask;
! 1727: }
! 1728:
! 1729: while (src < end) {
! 1730: switch (code) {
! 1731: /*
! 1732: * Stuff_NoCode: If no current code, select one
! 1733: */
! 1734: case Stuff_NoCode:
! 1735: code_ptr = dest++; /* Record where we're going to put this code */
! 1736: count = 0; /* Reset the count (zero means one instance) */
! 1737: /* Tentatively start a new block */
! 1738: if (*src == 0) {
! 1739: code = Stuff_Zero;
! 1740: src++;
! 1741: } else {
! 1742: code = Stuff_Same;
! 1743: *dest++ = *src++ ^ Stuff_Magic;
! 1744: }
! 1745: /* Note: We optimistically assume run of same -- which will be */
! 1746: /* fixed later in Stuff_Same if it turns out not to be true. */
! 1747: break;
! 1748:
! 1749: /*
! 1750: * Stuff_Zero: We already have at least one zero encoded
! 1751: */
! 1752: case Stuff_Zero:
! 1753:
! 1754: /* If another zero, count it, else finish this code block */
! 1755: if (*src == 0) {
! 1756: count++;
! 1757: src++;
! 1758: } else
! 1759: StuffData_FinishBlock(Stuff_Zero + count);
! 1760: break;
! 1761:
! 1762: /*
! 1763: * Stuff_Same: We already have at least one byte encoded
! 1764: */
! 1765: case Stuff_Same:
! 1766: /* If another one the same, count it */
! 1767: if ((*src ^ Stuff_Magic) == code_ptr[1]) {
! 1768: count++;
! 1769: src++;
! 1770: break;
! 1771: }
! 1772: /* else, this byte does not match this block. */
! 1773: /* If we already have two or more bytes encoded, finish this code block */
! 1774: if (count) {
! 1775: StuffData_FinishBlock(Stuff_Same + count);
! 1776: break;
! 1777: }
! 1778: /* else, we only have one so far, so switch to Stuff_Diff code */
! 1779: code = Stuff_Diff; /* and fall through to Stuff_Diff case below */
! 1780:
! 1781: case Stuff_Diff: /* Stuff_Diff: We have at least two *different* bytes encoded */
! 1782: /* If this is a zero, must encode a Stuff_DiffZero, and begin a new block */
! 1783: if (*src == 0)
! 1784: StuffData_FinishBlock(Stuff_DiffZero + count);
! 1785: /* else, if we have three in a row, it is worth starting a Stuff_Same block */
! 1786: else if ((*src ^ Stuff_Magic) == dest[-1] && dest[-1] == dest[-2])
! 1787: {
! 1788: code += count-2;
! 1789: if (code == Stuff_Diff)
! 1790: code = Stuff_Same;
! 1791: StuffData_FinishBlock(code);
! 1792: code_ptr = dest-2;
! 1793: /* dest[-1] already holds the correct value */
! 1794: count = 2; /* 2 means three bytes encoded */
! 1795: code = Stuff_Same;
! 1796: }
! 1797: /* else, another different byte, so add it to the block */
! 1798: else {
! 1799: *dest++ = *src ^ Stuff_Magic;
! 1800: count++;
! 1801: }
! 1802: src++; /* Consume the byte */
! 1803: break;
! 1804: }
! 1805:
! 1806: if (count == Stuff_MaxCount)
! 1807: StuffData_FinishBlock(code + count);
! 1808: }
! 1809: if (code == Stuff_NoCode)
! 1810: *code_ptr_ptr = NULL;
! 1811: else {
! 1812: *code_ptr_ptr = code_ptr;
! 1813: StuffData_FinishBlock(code + count);
! 1814: }
! 1815:
! 1816: return (dest);
! 1817: }
! 1818:
! 1819:
! 1820:
! 1821: /*
! 1822: * UnStuffData decodes the data at "src", up to (but not including)
! 1823: * "end". It writes the decoded data into the buffer pointed to by
! 1824: * "dst", up to a maximum of "dst_length", and returns the new
! 1825: * value of "src" so that a follow-on call can read more data,
! 1826: * continuing from where the first left off.
! 1827: *
! 1828: * There are three types of results:
! 1829: * 1. The source data runs out before extracting "dst_length" bytes:
! 1830: * UnStuffData returns NULL to indicate failure.
! 1831: * 2. The source data produces exactly "dst_length" bytes:
! 1832: * UnStuffData returns new_src = end to indicate that all bytes
! 1833: * were consumed.
! 1834: * 3. "dst_length" bytes are extracted, with more
! 1835: * remaining. UnStuffData returns new_src < end to indicate that
! 1836: * there are more bytes to be read.
! 1837: *
! 1838: * Note: The decoding may be dstructive, in that it may alter the
! 1839: * source data in the process of decoding it (this is necessary to
! 1840: * allow a follow-on call to resume correctly).
! 1841: */
! 1842:
! 1843: static u_char *
! 1844: UnStuffData(u_char *src, u_char *end, u_char *dst, u_long dst_length)
! 1845: {
! 1846: u_char *dst_end = dst + dst_length;
! 1847:
! 1848: /* Sanity check */
! 1849: if (!src || !end || !dst || !dst_length)
! 1850: return (NULL);
! 1851:
! 1852: while (src < end && dst < dst_end)
! 1853: {
! 1854: int count = (*src ^ Stuff_Magic) & Stuff_CountMask;
! 1855: switch ((*src ^ Stuff_Magic) & Stuff_CodeMask)
! 1856: {
! 1857: case Stuff_Diff:
! 1858: if (src+1+count >= end)
! 1859: return (NULL);
! 1860: do
! 1861: {
! 1862: *dst++ = *++src ^ Stuff_Magic;
! 1863: }
! 1864: while(--count >= 0 && dst < dst_end);
! 1865: if (count < 0)
! 1866: src += 1;
! 1867: else
! 1868: if (count == 0)
! 1869: *src = Stuff_Same ^ Stuff_Magic;
! 1870: else
! 1871: *src = (Stuff_Diff + count) ^ Stuff_Magic;
! 1872: break;
! 1873: case Stuff_DiffZero:
! 1874: if (src+1+count >= end)
! 1875: return (NULL);
! 1876: do
! 1877: {
! 1878: *dst++ = *++src ^ Stuff_Magic;
! 1879: }
! 1880: while(--count >= 0 && dst < dst_end);
! 1881: if (count < 0)
! 1882: *src = Stuff_Zero ^ Stuff_Magic;
! 1883: else
! 1884: *src = (Stuff_DiffZero + count) ^ Stuff_Magic;
! 1885: break;
! 1886: case Stuff_Same:
! 1887: if (src+1 >= end)
! 1888: return (NULL);
! 1889: do
! 1890: {
! 1891: *dst++ = src[1] ^ Stuff_Magic;
! 1892: }
! 1893: while(--count >= 0 && dst < dst_end);
! 1894: if (count < 0)
! 1895: src += 2;
! 1896: else
! 1897: *src = (Stuff_Same + count) ^ Stuff_Magic;
! 1898: break;
! 1899: case Stuff_Zero:
! 1900: do
! 1901: {
! 1902: *dst++ = 0;
! 1903: }
! 1904: while(--count >= 0 && dst < dst_end);
! 1905: if (count < 0)
! 1906: src += 1;
! 1907: else
! 1908: *src = (Stuff_Zero + count) ^ Stuff_Magic;
! 1909: break;
! 1910: }
! 1911: }
! 1912:
! 1913: if (dst < dst_end)
! 1914: return (NULL);
! 1915: else
! 1916: return (src);
! 1917: }
! 1918:
! 1919:
! 1920:
! 1921: /*
! 1922: * Log an error mesesage (for a packet received with errors?)
! 1923: * from the STRIP driver.
! 1924: */
! 1925: static void
! 1926: RecvErr(msg, sc)
! 1927: char *msg;
! 1928: struct st_softc *sc;
! 1929: {
! 1930: static const int MAX_RecErr = 80;
! 1931: u_char *ptr = sc->sc_buf;
! 1932: u_char *end = sc->sc_mp;
! 1933: u_char pkt_text[MAX_RecErr], *p = pkt_text;
! 1934: *p++ = '\"';
! 1935: while (ptr < end && p < &pkt_text[MAX_RecErr-4]) {
! 1936: if (*ptr == '\\') {
! 1937: *p++ = '\\';
! 1938: *p++ = '\\';
! 1939: } else if (*ptr >= 32 && *ptr <= 126)
! 1940: *p++ = *ptr;
! 1941: else {
! 1942: sprintf(p, "\\%02x", *ptr);
! 1943: p+= 3;
! 1944: }
! 1945: ptr++;
! 1946: }
! 1947:
! 1948: if (ptr == end) *p++ = '\"';
! 1949: *p++ = 0;
! 1950: addlog("%s: %13s : %s\n", sc->sc_if.if_xname, msg, pkt_text);
! 1951:
! 1952: sc->sc_if.if_ierrors++;
! 1953: }
! 1954:
! 1955:
! 1956: /*
! 1957: * Parse an error message from the radio.
! 1958: */
! 1959: static void
! 1960: RecvErr_Message(strip_info, sendername, msg)
! 1961: struct st_softc *strip_info;
! 1962: u_char *sendername;
! 1963: /*const*/ u_char *msg;
! 1964: {
! 1965: static const char ERR_001[] = "001"; /* Not in StarMode! */
! 1966: static const char ERR_002[] = "002"; /* Remap handle */
! 1967: static const char ERR_003[] = "003"; /* Can't resolve name */
! 1968: static const char ERR_004[] = "004"; /* Name too small or missing */
! 1969: static const char ERR_005[] = "005"; /* Bad count specification */
! 1970: static const char ERR_006[] = "006"; /* Header too big */
! 1971: static const char ERR_007[] = "007"; /* Body too big */
! 1972: static const char ERR_008[] = "008"; /* Bad character in name */
! 1973: static const char ERR_009[] = "009"; /* No count or line terminator */
! 1974:
! 1975: char * if_name;
! 1976:
! 1977: if_name = strip_info->sc_if.if_xname;
! 1978:
! 1979: if (!strncmp(msg, ERR_001, sizeof(ERR_001)-1))
! 1980: {
! 1981: RecvErr("radio error message:", strip_info);
! 1982: addlog("%s: Radio %s is not in StarMode\n",
! 1983: if_name, sendername);
! 1984: }
! 1985: else if (!strncmp(msg, ERR_002, sizeof(ERR_002)-1))
! 1986: {
! 1987: RecvErr("radio error message:", strip_info);
! 1988: #ifdef notyet /*Kernel doesn't have scanf!*/
! 1989: int handle;
! 1990: u_char newname[64];
! 1991: sscanf(msg, "ERR_002 Remap handle &%d to name %s", &handle, newname);
! 1992: addlog("%s: Radio name %s is handle %d\n",
! 1993: if_name, newname, handle);
! 1994: #endif
! 1995: }
! 1996: else if (!strncmp(msg, ERR_003, sizeof(ERR_003)-1))
! 1997: {
! 1998: RecvErr("radio error message:", strip_info);
! 1999: addlog("%s: Destination radio name is unknown\n", if_name);
! 2000: }
! 2001: else if (!strncmp(msg, ERR_004, sizeof(ERR_004)-1)) {
! 2002: /*
! 2003: * The radio reports it got a badly-framed starmode packet
! 2004: * from us; so it must me in starmode.
! 2005: */
! 2006: if (strip_info->sc_if.if_flags & IFF_DEBUG)
! 2007: addlog("%s: radio responded to probe\n", if_name);
! 2008: if (strip_info->sc_state == ST_DEAD) {
! 2009: /* A successful reset... */
! 2010: addlog("%s: Radio back in starmode\n", if_name);
! 2011: }
! 2012: CLEAR_RESET_TIMER(strip_info);
! 2013: }
! 2014: else if (!strncmp(msg, ERR_005, sizeof(ERR_005)-1))
! 2015: RecvErr("radio error message:", strip_info);
! 2016: else if (!strncmp(msg, ERR_006, sizeof(ERR_006)-1))
! 2017: RecvErr("radio error message:", strip_info);
! 2018: else if (!strncmp(msg, ERR_007, sizeof(ERR_007)-1))
! 2019: {
! 2020: /*
! 2021: * Note: This error knocks the radio back into
! 2022: * command mode.
! 2023: */
! 2024: RecvErr("radio error message:", strip_info);
! 2025: addlog("%s: Error! Packet size too big for radio.",
! 2026: if_name);
! 2027: FORCE_RESET(strip_info);
! 2028: }
! 2029: else if (!strncmp(msg, ERR_008, sizeof(ERR_008)-1))
! 2030: {
! 2031: RecvErr("radio error message:", strip_info);
! 2032: addlog("%s: Radio name contains illegal character\n",
! 2033: if_name);
! 2034: }
! 2035: else if (!strncmp(msg, ERR_009, sizeof(ERR_009)-1))
! 2036: RecvErr("radio error message:", strip_info);
! 2037: else {
! 2038: addlog("failed to parse ]%3s[\n", msg);
! 2039: RecvErr("unparsed radio error message:", strip_info);
! 2040: }
! 2041: }
! 2042:
! 2043: #endif /* NSTRIP > 0 */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to if_strip.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / net