usr.sbin/ppp/async.c

   1 /*
   2  *                   PPP Async HDLC Module
   3  *
   4  *          Written by Toshiharu OHNO (tony-o@iij.ad.jp)
   5  *
   6  *   Copyright (C) 1993, Internet Initiative Japan, Inc. All rights reserverd.
   7  *
   8  * Redistribution and use in source and binary forms are permitted
   9  * provided that the above copyright notice and this paragraph are
  10  * duplicated in all such forms and that any documentation,
  11  * advertising materials, and other materials related to such
  12  * distribution and use acknowledge that the software was developed
  13  * by the Internet Initiative Japan, Inc.  The name of the
  14  * IIJ may not be used to endorse or promote products derived
  15  * from this software without specific prior written permission.
  16  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  18  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  19  *
  20  * $FreeBSD$
  21  *
  22  */
  23 #include <sys/types.h>
  24
  25 #include <string.h>
  26 #include <termios.h>
  27
  28 #include "layer.h"
  29 #include "mbuf.h"
  30 #include "log.h"
  31 #include "defs.h"
  32 #include "timer.h"
  33 #include "fsm.h"
  34 #include "lqr.h"
  35 #include "hdlc.h"
  36 #include "lcp.h"
  37 #include "proto.h"
  38 #include "async.h"
  39 #include "throughput.h"
  40 #include "ccp.h"
  41 #include "link.h"
  42 #include "descriptor.h"
  43 #include "physical.h"
  44
  45 #define MODE_HUNT 0x01
  46 #define MODE_ESC  0x02
  47
  48 void
  49 async_Init(struct async *async)
  50 {
  51   async->mode = MODE_HUNT;
  52   async->length = 0;
  53   async->my_accmap = async->his_accmap = 0xffffffff;
  54   memset(async->cfg.EscMap, '\0', sizeof async->cfg.EscMap);
  55 }
  56
  57 void
  58 async_SetLinkParams(struct async *async, struct lcp *lcp)
  59 {
  60   async->my_accmap = lcp->want_accmap;
  61   async->his_accmap = lcp->his_accmap | lcp->want_accmap;
  62 }
  63
  64 /*
  65  * Encode into async HDLC byte code
  66  */
  67 static void
  68 async_Encode(struct async *async, u_char **cp, u_char c, int proto)
  69 {
  70   u_char *wp;
  71
  72   wp = *cp;
  73   if ((c < 0x20 && (proto == PROTO_LCP || (async->his_accmap & (1 << c))))
  74       || (c == HDLC_ESC) || (c == HDLC_SYN)) {
  75     *wp++ = HDLC_ESC;
  76     c ^= HDLC_XOR;
  77   }
  78   if (async->cfg.EscMap[32] && async->cfg.EscMap[c >> 3] & (1 << (c & 7))) {
  79     *wp++ = HDLC_ESC;
  80     c ^= HDLC_XOR;
  81   }
  82   *wp++ = c;
  83   *cp = wp;
  84 }
  85
  86 static struct mbuf *
  87 async_LayerPush(struct bundle *bundle, struct link *l, struct mbuf *bp,
  88                 int pri, u_short *proto)
  89 {
  90   struct physical *p = link2physical(l);
  91   u_char *cp, *sp, *ep;
  92   struct mbuf *wp;
  93   int cnt;
  94
  95   if (!p || m_length(bp) > HDLCSIZE) {
  96     m_freem(bp);
  97     return NULL;
  98   }
  99
 100   cp = p->async.xbuff;
 101   ep = cp + HDLCSIZE - 10;
 102   wp = bp;
 103   *cp++ = HDLC_SYN;
 104   while (wp) {
 105     sp = MBUF_CTOP(wp);
 106     for (cnt = wp->m_len; cnt > 0; cnt--) {
 107       async_Encode(&p->async, &cp, *sp++, *proto);
 108       if (cp >= ep) {
 109         m_freem(bp);
 110         return NULL;
 111       }
 112     }
 113     wp = wp->m_next;
 114   }
 115   *cp++ = HDLC_SYN;
 116
 117   cnt = cp - p->async.xbuff;
 118   m_freem(bp);
 119   bp = m_get(cnt, MB_ASYNCOUT);
 120   memcpy(MBUF_CTOP(bp), p->async.xbuff, cnt);
 121   log_DumpBp(LogASYNC, "Write", bp);
 122
 123   return bp;
 124 }
 125
 126 static struct mbuf *
 127 async_Decode(struct async *async, u_char c)
 128 {
 129   struct mbuf *bp;
 130
 131   if ((async->mode & MODE_HUNT) && c != HDLC_SYN)
 132     return NULL;
 133
 134   switch (c) {
 135   case HDLC_SYN:
 136     async->mode &= ~MODE_HUNT;
 137     if (async->length) {                /* packet is ready. */
 138       bp = m_get(async->length, MB_ASYNCIN);
 139       mbuf_Write(bp, async->hbuff, async->length);
 140       async->length = 0;
 141       return bp;
 142     }
 143     break;
 144   case HDLC_ESC:
 145     if (!(async->mode & MODE_ESC)) {
 146       async->mode |= MODE_ESC;
 147       break;
 148     }
 149     /* Fall into ... */
 150   default:
 151     if (async->length >= HDLCSIZE) {
 152       /* packet is too large, discard it */
 153       log_Printf(LogWARN, "Packet too large (%d), discarding.\n",
 154                  async->length);
 155       async->length = 0;
 156       async->mode = MODE_HUNT;
 157       break;
 158     }
 159     if (async->mode & MODE_ESC) {
 160       c ^= HDLC_XOR;
 161       async->mode &= ~MODE_ESC;
 162     }
 163     async->hbuff[async->length++] = c;
 164     break;
 165   }
 166   return NULL;
 167 }
 168
 169 static struct mbuf *
 170 async_LayerPull(struct bundle *b, struct link *l, struct mbuf *bp,
 171                 u_short *proto)
 172 {
 173   struct mbuf *nbp, **last;
 174   struct physical *p = link2physical(l);
 175   u_char *ch;
 176   size_t cnt;
 177
 178   if (!p) {
 179     log_Printf(LogERROR, "Can't Pull an async packet from a logical link\n");
 180     return bp;
 181   }
 182
 183   last = &nbp;
 184
 185   log_DumpBp(LogASYNC, "Read", bp);
 186   while (bp) {
 187     ch = MBUF_CTOP(bp);
 188     for (cnt = bp->m_len; cnt; cnt--) {
 189       *last = async_Decode(&p->async, *ch++);
 190       if (*last != NULL)
 191         last = &(*last)->m_nextpkt;
 192     }
 193     bp = m_free(bp);
 194   }
 195
 196   return nbp;
 197 }
 198
 199 struct layer asynclayer =
 200   { LAYER_ASYNC, "async", async_LayerPush, async_LayerPull };