usr.sbin/ppp/lqr.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 1996 - 2001 Brian Somers <brian@Awfulhak.org>
   5  *          based on work by Toshiharu OHNO <tony-o@iij.ad.jp>
   6  *                           Internet Initiative Japan, Inc (IIJ)
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  *
  30  * $FreeBSD$
  31  */
  32
  33 #include <sys/param.h>
  34
  35 #ifdef __FreeBSD__
  36 #include <netinet/in.h>
  37 #endif
  38 #include <sys/un.h>
  39
  40 #include <string.h>
  41 #include <termios.h>
  42
  43 #include "layer.h"
  44 #include "mbuf.h"
  45 #include "log.h"
  46 #include "defs.h"
  47 #include "timer.h"
  48 #include "fsm.h"
  49 #include "acf.h"
  50 #include "proto.h"
  51 #include "lqr.h"
  52 #include "hdlc.h"
  53 #include "lcp.h"
  54 #include "async.h"
  55 #include "throughput.h"
  56 #include "ccp.h"
  57 #include "link.h"
  58 #include "descriptor.h"
  59 #include "physical.h"
  60 #include "mp.h"
  61 #include "chat.h"
  62 #include "auth.h"
  63 #include "chap.h"
  64 #include "command.h"
  65 #include "cbcp.h"
  66 #include "datalink.h"
  67
  68 struct echolqr {
  69   u_int32_t magic;
  70   u_int32_t signature;
  71   u_int32_t sequence;
  72 };
  73
  74 #define SIGNATURE  0x594e4f54
  75
  76 static void
  77 SendEchoReq(struct lcp *lcp)
  78 {
  79   struct hdlc *hdlc = &link2physical(lcp->fsm.link)->hdlc;
  80   struct echolqr echo;
  81
  82   echo.magic = htonl(lcp->want_magic);
  83   echo.signature = htonl(SIGNATURE);
  84   echo.sequence = htonl(hdlc->lqm.echo.seq_sent);
  85   fsm_Output(&lcp->fsm, CODE_ECHOREQ, hdlc->lqm.echo.seq_sent++,
  86             (u_char *)&echo, sizeof echo, MB_ECHOOUT);
  87 }
  88
  89 struct mbuf *
  90 lqr_RecvEcho(struct fsm *fp, struct mbuf *bp)
  91 {
  92   struct hdlc *hdlc = &link2physical(fp->link)->hdlc;
  93   struct lcp *lcp = fsm2lcp(fp);
  94   struct echolqr lqr;
  95
  96   if (m_length(bp) >= sizeof lqr) {
  97     m_freem(mbuf_Read(bp, &lqr, sizeof lqr));
  98     bp = NULL;
  99     lqr.magic = ntohl(lqr.magic);
 100     lqr.signature = ntohl(lqr.signature);
 101     lqr.sequence = ntohl(lqr.sequence);
 102
 103     /* Tolerate echo replies with either magic number */
 104     if (lqr.magic != 0 && lqr.magic != lcp->his_magic &&
 105         lqr.magic != lcp->want_magic) {
 106       log_Printf(LogWARN, "%s: lqr_RecvEcho: Bad magic: expected 0x%08x,"
 107                  " got 0x%08x\n", fp->link->name, lcp->his_magic, lqr.magic);
 108       /*
 109        * XXX: We should send a terminate request. But poor implementations may
 110        *      die as a result.
 111        */
 112     }
 113     if (lqr.signature == SIGNATURE
 114         || lqr.signature == lcp->want_magic) {                  /* some implementations return the wrong magic */
 115       /* careful not to update lqm.echo.seq_recv with older values */
 116       if ((hdlc->lqm.echo.seq_recv > (u_int32_t)0 - 5 && lqr.sequence < 5) ||
 117           (hdlc->lqm.echo.seq_recv <= (u_int32_t)0 - 5 &&
 118            lqr.sequence > hdlc->lqm.echo.seq_recv))
 119         hdlc->lqm.echo.seq_recv = lqr.sequence;
 120     } else
 121       log_Printf(LogWARN, "lqr_RecvEcho: Got sig 0x%08lx, not 0x%08lx !\n",
 122                 (u_long)lqr.signature, (u_long)SIGNATURE);
 123   } else
 124     log_Printf(LogWARN, "lqr_RecvEcho: Got packet size %zd, expecting %ld !\n",
 125               m_length(bp), (long)sizeof(struct echolqr));
 126   return bp;
 127 }
 128
 129 void
 130 lqr_ChangeOrder(struct lqrdata *src, struct lqrdata *dst)
 131 {
 132   u_int32_t *sp, *dp;
 133   unsigned n;
 134
 135   sp = (u_int32_t *) src;
 136   dp = (u_int32_t *) dst;
 137   for (n = 0; n < sizeof(struct lqrdata) / sizeof(u_int32_t); n++, sp++, dp++)
 138     *dp = ntohl(*sp);
 139 }
 140
 141 static void
 142 SendLqrData(struct lcp *lcp)
 143 {
 144   struct mbuf *bp;
 145   int extra;
 146
 147   extra = proto_WrapperOctets(lcp, PROTO_LQR) +
 148           acf_WrapperOctets(lcp, PROTO_LQR);
 149   bp = m_get(sizeof(struct lqrdata) + extra, MB_LQROUT);
 150   bp->m_len -= extra;
 151   bp->m_offset += extra;
 152
 153   /*
 154    * Send on the highest priority queue.  We send garbage - the real data
 155    * is written by lqr_LayerPush() where we know how to fill in all the
 156    * fields.  Note, lqr_LayerPush() ``knows'' that we're pushing onto the
 157    * highest priority queue, and factors out packet & octet values from
 158    * other queues!
 159    */
 160   link_PushPacket(lcp->fsm.link, bp, lcp->fsm.bundle,
 161                   LINK_QUEUES(lcp->fsm.link) - 1, PROTO_LQR);
 162 }
 163
 164 static void
 165 SendLqrReport(void *v)
 166 {
 167   struct lcp *lcp = (struct lcp *)v;
 168   struct physical *p = link2physical(lcp->fsm.link);
 169
 170   timer_Stop(&p->hdlc.lqm.timer);
 171
 172   if (p->hdlc.lqm.method & LQM_LQR) {
 173     if (p->hdlc.lqm.lqr.resent > 5) {
 174       /* XXX: Should implement LQM strategy */
 175       log_Printf(LogPHASE, "%s: ** Too many LQR packets lost **\n",
 176                 lcp->fsm.link->name);
 177       log_Printf(LogLQM, "%s: Too many LQR packets lost\n",
 178                 lcp->fsm.link->name);
 179       p->hdlc.lqm.method = 0;
 180       datalink_Down(p->dl, CLOSE_NORMAL);
 181     } else {
 182       SendLqrData(lcp);
 183       p->hdlc.lqm.lqr.resent++;
 184     }
 185   } else if (p->hdlc.lqm.method & LQM_ECHO) {
 186     if ((p->hdlc.lqm.echo.seq_sent > 5 &&
 187          p->hdlc.lqm.echo.seq_sent - 5 > p->hdlc.lqm.echo.seq_recv) ||
 188         (p->hdlc.lqm.echo.seq_sent <= 5 &&
 189          p->hdlc.lqm.echo.seq_sent > p->hdlc.lqm.echo.seq_recv + 5)) {
 190       log_Printf(LogPHASE, "%s: ** Too many LCP ECHO packets lost **\n",
 191                 lcp->fsm.link->name);
 192       log_Printf(LogLQM, "%s: Too many LCP ECHO packets lost\n",
 193                 lcp->fsm.link->name);
 194       p->hdlc.lqm.method = 0;
 195       datalink_Down(p->dl, CLOSE_NORMAL);
 196     } else
 197       SendEchoReq(lcp);
 198   }
 199   if (p->hdlc.lqm.method && p->hdlc.lqm.timer.load)
 200     timer_Start(&p->hdlc.lqm.timer);
 201 }
 202
 203 struct mbuf *
 204 lqr_Input(struct bundle *bundle __unused, struct link *l, struct mbuf *bp)
 205 {
 206   struct physical *p = link2physical(l);
 207   struct lcp *lcp = p->hdlc.lqm.owner;
 208   int len;
 209
 210   if (p == NULL) {
 211     log_Printf(LogERROR, "lqr_Input: Not a physical link - dropped\n");
 212     m_freem(bp);
 213     return NULL;
 214   }
 215
 216   len = m_length(bp);
 217   if (len != sizeof(struct lqrdata))
 218     log_Printf(LogWARN, "lqr_Input: Got packet size %d, expecting %ld !\n",
 219               len, (long)sizeof(struct lqrdata));
 220   else if (!IsAccepted(l->lcp.cfg.lqr) && !(p->hdlc.lqm.method & LQM_LQR)) {
 221     bp = m_pullup(proto_Prepend(bp, PROTO_LQR, 0, 0));
 222     lcp_SendProtoRej(lcp, MBUF_CTOP(bp), bp->m_len);
 223   } else {
 224     struct lqrdata *lqr;
 225
 226     bp = m_pullup(bp);
 227     lqr = (struct lqrdata *)MBUF_CTOP(bp);
 228     if (ntohl(lqr->MagicNumber) != lcp->his_magic)
 229       log_Printf(LogWARN, "lqr_Input: magic 0x%08lx is wrong,"
 230                  " expecting 0x%08lx\n",
 231                  (u_long)ntohl(lqr->MagicNumber), (u_long)lcp->his_magic);
 232     else {
 233       struct lqrdata lastlqr;
 234
 235       memcpy(&lastlqr, &p->hdlc.lqm.lqr.peer, sizeof lastlqr);
 236       lqr_ChangeOrder(lqr, &p->hdlc.lqm.lqr.peer);
 237       lqr_Dump(l->name, "Input", &p->hdlc.lqm.lqr.peer);
 238       /* we have received an LQR from our peer */
 239       p->hdlc.lqm.lqr.resent = 0;
 240
 241       /* Snapshot our state when the LQR packet was received */
 242       memcpy(&p->hdlc.lqm.lqr.prevSave, &p->hdlc.lqm.lqr.Save,
 243              sizeof p->hdlc.lqm.lqr.prevSave);
 244       p->hdlc.lqm.lqr.Save.InLQRs = ++p->hdlc.lqm.lqr.InLQRs;
 245       p->hdlc.lqm.lqr.Save.InPackets = p->hdlc.lqm.ifInUniPackets;
 246       p->hdlc.lqm.lqr.Save.InDiscards = p->hdlc.lqm.ifInDiscards;
 247       p->hdlc.lqm.lqr.Save.InErrors = p->hdlc.lqm.ifInErrors;
 248       p->hdlc.lqm.lqr.Save.InOctets = p->hdlc.lqm.lqr.InGoodOctets;
 249
 250       lqr_Analyse(&p->hdlc, &lastlqr, &p->hdlc.lqm.lqr.peer);
 251
 252       /*
 253        * Generate an LQR response if we're not running an LQR timer OR
 254        * two successive LQR's PeerInLQRs are the same.
 255        */
 256       if (p->hdlc.lqm.timer.load == 0 || !(p->hdlc.lqm.method & LQM_LQR) ||
 257           (lastlqr.PeerInLQRs &&
 258            lastlqr.PeerInLQRs == p->hdlc.lqm.lqr.peer.PeerInLQRs))
 259         SendLqrData(lcp);
 260     }
 261   }
 262   m_freem(bp);
 263   return NULL;
 264 }
 265
 266 /*
 267  *  When LCP is reached to opened state, We'll start LQM activity.
 268  */
 269 static void
 270 lqr_Setup(struct lcp *lcp)
 271 {
 272   struct physical *physical = link2physical(lcp->fsm.link);
 273   int period;
 274
 275   physical->hdlc.lqm.lqr.resent = 0;
 276   physical->hdlc.lqm.echo.seq_sent = 0;
 277   physical->hdlc.lqm.echo.seq_recv = 0;
 278   memset(&physical->hdlc.lqm.lqr.peer, '\0',
 279          sizeof physical->hdlc.lqm.lqr.peer);
 280
 281   physical->hdlc.lqm.method = lcp->cfg.echo ? LQM_ECHO : 0;
 282   if (IsEnabled(lcp->cfg.lqr) && !REJECTED(lcp, TY_QUALPROTO))
 283     physical->hdlc.lqm.method |= LQM_LQR;
 284   timer_Stop(&physical->hdlc.lqm.timer);
 285
 286   physical->hdlc.lqm.lqr.peer_timeout = lcp->his_lqrperiod;
 287   if (lcp->his_lqrperiod)
 288     log_Printf(LogLQM, "%s: Expecting LQR every %d.%02d secs\n",
 289               physical->link.name, lcp->his_lqrperiod / 100,
 290               lcp->his_lqrperiod % 100);
 291
 292   period = lcp->want_lqrperiod ?
 293     lcp->want_lqrperiod : lcp->cfg.lqrperiod * 100;
 294   physical->hdlc.lqm.timer.func = SendLqrReport;
 295   physical->hdlc.lqm.timer.name = "lqm";
 296   physical->hdlc.lqm.timer.arg = lcp;
 297
 298   if (lcp->want_lqrperiod || physical->hdlc.lqm.method & LQM_ECHO) {
 299     log_Printf(LogLQM, "%s: Will send %s every %d.%02d secs\n",
 300               physical->link.name, lcp->want_lqrperiod ? "LQR" : "LCP ECHO",
 301               period / 100, period % 100);
 302     physical->hdlc.lqm.timer.load = period * SECTICKS / 100;
 303   } else {
 304     physical->hdlc.lqm.timer.load = 0;
 305     if (!lcp->his_lqrperiod)
 306       log_Printf(LogLQM, "%s: LQR/LCP ECHO not negotiated\n",
 307                  physical->link.name);
 308   }
 309 }
 310
 311 void
 312 lqr_Start(struct lcp *lcp)
 313 {
 314   struct physical *p = link2physical(lcp->fsm.link);
 315
 316   lqr_Setup(lcp);
 317   if (p->hdlc.lqm.timer.load)
 318     SendLqrReport(lcp);
 319 }
 320
 321 void
 322 lqr_reStart(struct lcp *lcp)
 323 {
 324   struct physical *p = link2physical(lcp->fsm.link);
 325
 326   lqr_Setup(lcp);
 327   if (p->hdlc.lqm.timer.load)
 328     timer_Start(&p->hdlc.lqm.timer);
 329 }
 330
 331 void
 332 lqr_StopTimer(struct physical *physical)
 333 {
 334   timer_Stop(&physical->hdlc.lqm.timer);
 335 }
 336
 337 void
 338 lqr_Stop(struct physical *physical, int method)
 339 {
 340   if (method == LQM_LQR)
 341     log_Printf(LogLQM, "%s: Stop sending LQR, Use LCP ECHO instead.\n",
 342                physical->link.name);
 343   if (method == LQM_ECHO)
 344     log_Printf(LogLQM, "%s: Stop sending LCP ECHO.\n",
 345                physical->link.name);
 346   physical->hdlc.lqm.method &= ~method;
 347   if (physical->hdlc.lqm.method)
 348     SendLqrReport(physical->hdlc.lqm.owner);
 349   else
 350     timer_Stop(&physical->hdlc.lqm.timer);
 351 }
 352
 353 void
 354 lqr_Dump(const char *link, const char *message, const struct lqrdata *lqr)
 355 {
 356   if (log_IsKept(LogLQM)) {
 357     log_Printf(LogLQM, "%s: %s:\n", link, message);
 358     log_Printf(LogLQM, "  Magic:          %08x   LastOutLQRs:    %08x\n",
 359               lqr->MagicNumber, lqr->LastOutLQRs);
 360     log_Printf(LogLQM, "  LastOutPackets: %08x   LastOutOctets:  %08x\n",
 361               lqr->LastOutPackets, lqr->LastOutOctets);
 362     log_Printf(LogLQM, "  PeerInLQRs:     %08x   PeerInPackets:  %08x\n",
 363               lqr->PeerInLQRs, lqr->PeerInPackets);
 364     log_Printf(LogLQM, "  PeerInDiscards: %08x   PeerInErrors:   %08x\n",
 365               lqr->PeerInDiscards, lqr->PeerInErrors);
 366     log_Printf(LogLQM, "  PeerInOctets:   %08x   PeerOutLQRs:    %08x\n",
 367               lqr->PeerInOctets, lqr->PeerOutLQRs);
 368     log_Printf(LogLQM, "  PeerOutPackets: %08x   PeerOutOctets:  %08x\n",
 369               lqr->PeerOutPackets, lqr->PeerOutOctets);
 370   }
 371 }
 372
 373 void
 374 lqr_Analyse(const struct hdlc *hdlc, const struct lqrdata *oldlqr,
 375             const struct lqrdata *newlqr)
 376 {
 377   u_int32_t LQRs, transitLQRs, pkts, octets, disc, err;
 378
 379   if (!newlqr->PeerInLQRs)      /* No analysis possible yet! */
 380     return;
 381
 382   log_Printf(LogLQM, "Analysis:\n");
 383
 384   LQRs = (newlqr->LastOutLQRs - oldlqr->LastOutLQRs) -
 385          (newlqr->PeerInLQRs - oldlqr->PeerInLQRs);
 386   transitLQRs = hdlc->lqm.lqr.OutLQRs - newlqr->LastOutLQRs;
 387   pkts = (newlqr->LastOutPackets - oldlqr->LastOutPackets) -
 388          (newlqr->PeerInPackets - oldlqr->PeerInPackets);
 389   octets = (newlqr->LastOutOctets - oldlqr->LastOutOctets) -
 390            (newlqr->PeerInOctets - oldlqr->PeerInOctets);
 391   log_Printf(LogLQM, "  Outbound lossage: %d LQR%s (%d en route), %d packet%s,"
 392              " %d octet%s\n", (int)LQRs, LQRs == 1 ? "" : "s", (int)transitLQRs,
 393              (int)pkts, pkts == 1 ? "" : "s",
 394              (int)octets, octets == 1 ? "" : "s");
 395
 396   pkts = (newlqr->PeerOutPackets - oldlqr->PeerOutPackets) -
 397     (hdlc->lqm.lqr.Save.InPackets - hdlc->lqm.lqr.prevSave.InPackets);
 398   octets = (newlqr->PeerOutOctets - oldlqr->PeerOutOctets) -
 399     (hdlc->lqm.lqr.Save.InOctets - hdlc->lqm.lqr.prevSave.InOctets);
 400   log_Printf(LogLQM, "  Inbound lossage: %d packet%s, %d octet%s\n",
 401              (int)pkts, pkts == 1 ? "" : "s",
 402              (int)octets, octets == 1 ? "" : "s");
 403
 404   disc = newlqr->PeerInDiscards - oldlqr->PeerInDiscards;
 405   err = newlqr->PeerInErrors - oldlqr->PeerInErrors;
 406   if (disc && err)
 407     log_Printf(LogLQM, "                   Likely due to both peer congestion"
 408                " and physical errors\n");
 409   else if (disc)
 410     log_Printf(LogLQM, "                   Likely due to peer congestion\n");
 411   else if (err)
 412     log_Printf(LogLQM, "                   Likely due to physical errors\n");
 413   else if (pkts)
 414     log_Printf(LogLQM, "                   Likely due to transport "
 415                "congestion\n");
 416 }
 417
 418 static struct mbuf *
 419 lqr_LayerPush(struct bundle *b __unused, struct link *l, struct mbuf *bp,
 420               int pri __unused, u_short *proto)
 421 {
 422   struct physical *p = link2physical(l);
 423   int len, layer;
 424
 425   if (!p) {
 426     /* Oops - can't happen :-] */
 427     m_freem(bp);
 428     return NULL;
 429   }
 430
 431   bp = m_pullup(bp);
 432   len = m_length(bp);
 433
 434   /*-
 435    * From rfc1989:
 436    *
 437    *  All octets which are included in the FCS calculation MUST be counted,
 438    *  including the packet header, the information field, and any padding.
 439    *  The FCS octets MUST also be counted, and one flag octet per frame
 440    *  MUST be counted.  All other octets (such as additional flag
 441    *  sequences, and escape bits or octets) MUST NOT be counted.
 442    *
 443    * As we're stacked higher than the HDLC layer (otherwise HDLC wouldn't be
 444    * able to calculate the FCS), we must not forget about these additional
 445    * bytes when we're asynchronous.
 446    *
 447    * We're also expecting to be stacked *before* the likes of the proto and
 448    * acf layers (to avoid alignment issues), so deal with this too.
 449    */
 450
 451   p->hdlc.lqm.ifOutUniPackets++;
 452   p->hdlc.lqm.ifOutOctets += len + 1;           /* plus 1 flag octet! */
 453   for (layer = 0; layer < l->nlayers; layer++)
 454     switch (l->layer[layer]->type) {
 455       case LAYER_ACF:
 456         p->hdlc.lqm.ifOutOctets += acf_WrapperOctets(&l->lcp, *proto);
 457         break;
 458       case LAYER_ASYNC:
 459         /* Not included - see rfc1989 */
 460         break;
 461       case LAYER_HDLC:
 462         p->hdlc.lqm.ifOutOctets += hdlc_WrapperOctets();
 463         break;
 464       case LAYER_LQR:
 465         layer = l->nlayers;
 466         break;
 467       case LAYER_PROTO:
 468         p->hdlc.lqm.ifOutOctets += proto_WrapperOctets(&l->lcp, *proto);
 469         break;
 470       case LAYER_SYNC:
 471         /* Nothing to add on */
 472         break;
 473       default:
 474         log_Printf(LogWARN, "Oops, don't know how to do octets for %s layer\n",
 475                    l->layer[layer]->name);
 476         break;
 477     }
 478
 479   if (*proto == PROTO_LQR) {
 480     /* Overwrite the entire packet (created in SendLqrData()) */
 481     struct lqrdata lqr;
 482     size_t pending_pkts, pending_octets;
 483
 484     p->hdlc.lqm.lqr.OutLQRs++;
 485
 486     /*
 487      * We need to compensate for the fact that we're pushing our data
 488      * onto the highest priority queue by factoring out packet & octet
 489      * values from other queues!
 490      */
 491     link_PendingLowPriorityData(l, &pending_pkts, &pending_octets);
 492
 493     memset(&lqr, '\0', sizeof lqr);
 494     lqr.MagicNumber = p->link.lcp.want_magic;
 495     lqr.LastOutLQRs = p->hdlc.lqm.lqr.peer.PeerOutLQRs;
 496     lqr.LastOutPackets = p->hdlc.lqm.lqr.peer.PeerOutPackets;
 497     lqr.LastOutOctets = p->hdlc.lqm.lqr.peer.PeerOutOctets;
 498     lqr.PeerInLQRs = p->hdlc.lqm.lqr.Save.InLQRs;
 499     lqr.PeerInPackets = p->hdlc.lqm.lqr.Save.InPackets;
 500     lqr.PeerInDiscards = p->hdlc.lqm.lqr.Save.InDiscards;
 501     lqr.PeerInErrors = p->hdlc.lqm.lqr.Save.InErrors;
 502     lqr.PeerInOctets = p->hdlc.lqm.lqr.Save.InOctets;
 503     lqr.PeerOutLQRs = p->hdlc.lqm.lqr.OutLQRs;
 504     lqr.PeerOutPackets = p->hdlc.lqm.ifOutUniPackets - pending_pkts;
 505     /* Don't forget our ``flag'' octets.... */
 506     lqr.PeerOutOctets = p->hdlc.lqm.ifOutOctets - pending_octets - pending_pkts;
 507     lqr_Dump(l->name, "Output", &lqr);
 508     lqr_ChangeOrder(&lqr, (struct lqrdata *)MBUF_CTOP(bp));
 509   }
 510
 511   return bp;
 512 }
 513
 514 static struct mbuf *
 515 lqr_LayerPull(struct bundle *b __unused, struct link *l __unused,
 516               struct mbuf *bp, u_short *proto)
 517 {
 518   /*
 519    * This is the ``Rx'' process from rfc1989, although a part of it is
 520    * actually performed by sync_LayerPull() & hdlc_LayerPull() so that
 521    * our octet counts are correct.
 522    */
 523
 524   if (*proto == PROTO_LQR)
 525     m_settype(bp, MB_LQRIN);
 526   return bp;
 527 }
 528
 529 /*
 530  * Statistics for pulled packets are recorded either in hdlc_PullPacket()
 531  * or sync_PullPacket()
 532  */
 533
 534 struct layer lqrlayer = { LAYER_LQR, "lqr", lqr_LayerPush, lqr_LayerPull };