Auth2Nam(PROTO_CHAP, cp[4]),
Auth2Nam(PROTO_CHAP, chap_type),
LcpDecodeConfig(struct fsm *fp, u_char *cp, int plen, int mode_type,                struct fsm_decode *dec){  /* Deal with incoming PROTO_LCP */  struct lcp *lcp = fsm2lcp(fp);  int type, length, sz, pos, op, callback_req;  u_int32_t magic, accmap;  u_short mru, phmtu, maxmtu, maxmru, wantmtu, wantmru, proto;  struct lqrreq *req;  char request[20], desc[22];  struct mp *mp;  struct physical *p = link2physical(fp->link);  sz = op = callback_req = 0;  while (plen >= sizeof(struct fsmconfig)) {    type = *cp;    length = cp[1];    snprintf(request, sizeof request, " %s[%d]", protoname(type), length);    if (length < 2) {      log_Printf(LogLCP, "%s:%s: Bad LCP length\n", fp->link->name, request);      break;    }    switch (type) {    case TY_MRRU:      mp = &lcp->fsm.bundle->ncp.mp;      ua_ntohs(cp + 2, &mru);      log_Printf(LogLCP, "%s %u\n", request, mru);      switch (mode_type) {      case MODE_REQ:        if (mp->cfg.mrru) {          if (REJECTED(lcp, TY_MRRU))            /* Ignore his previous reject so that we REQ next time */	    lcp->his_reject &= ~(1 << type);          if (mru > MAX_MRU) {            /* Push him down to MAX_MRU */            lcp->his_mrru = MAX_MRU;	    memcpy(dec->nakend, cp, 2);            ua_htons(&lcp->his_mrru, dec->nakend + 2);	    dec->nakend += 4;          } else if (mru < MIN_MRU) {            /* Push him up to MIN_MRU */            lcp->his_mrru = MIN_MRU;	    memcpy(dec->nakend, cp, 2);            ua_htons(&lcp->his_mrru, dec->nakend + 2);	    dec->nakend += 4;	  } else {            lcp->his_mrru = mru;	    memcpy(dec->ackend, cp, 4);	    dec->ackend += 4;	  }	  break;        } else	  goto reqreject;        break;      case MODE_NAK:        if (mp->cfg.mrru) {          if (REJECTED(lcp, TY_MRRU))            /* Must have changed his mind ! */	    lcp->his_reject &= ~(1 << type);          if (mru > MAX_MRU)            lcp->want_mrru = MAX_MRU;          else if (mru < MIN_MRU)            lcp->want_mrru = MIN_MRU;          else            lcp->want_mrru = mru;        }        /* else we honour our config and don't send the suggested REQ */        break;      case MODE_REJ:	lcp->his_reject |= (1 << type);        lcp->want_mrru = 0;		/* Ah well, no multilink :-( */	break;      }      break;    case TY_MRU:      lcp->mru_req = 1;      ua_ntohs(cp + 2, &mru);      log_Printf(LogLCP, "%s %d\n", request, mru);      switch (mode_type) {      case MODE_REQ:        maxmtu = p ? physical_DeviceMTU(p) : 0;        if (lcp->cfg.max_mtu && (!maxmtu || maxmtu > lcp->cfg.max_mtu))          maxmtu = lcp->cfg.max_mtu;        wantmtu = lcp->cfg.mtu;        if (maxmtu && wantmtu > maxmtu) {          log_Printf(LogWARN, "%s: Reducing configured MTU from %u to %u\n",                     fp->link->name, wantmtu, maxmtu);          wantmtu = maxmtu;        }        if (maxmtu && mru > maxmtu) {          lcp->his_mru = maxmtu;          memcpy(dec->nakend, cp, 2);          ua_htons(&lcp->his_mru, dec->nakend + 2);          dec->nakend += 4;        } else if (wantmtu && mru < wantmtu) {          /* Push him up to MTU or MIN_MRU */          lcp->his_mru = wantmtu;          memcpy(dec->nakend, cp, 2);          ua_htons(&lcp->his_mru, dec->nakend + 2);          dec->nakend += 4;        } else {          lcp->his_mru = mru;          memcpy(dec->ackend, cp, 4);          dec->ackend += 4;        }	break;      case MODE_NAK:        maxmru = p ? physical_DeviceMTU(p) : 0;        if (lcp->cfg.max_mru && (!maxmru || maxmru > lcp->cfg.max_mru))          maxmru = lcp->cfg.max_mru;        wantmru = lcp->cfg.mru > maxmru ? maxmru : lcp->cfg.mru;        if (wantmru && mru > wantmru)          lcp->want_mru = wantmru;        else if (mru > maxmru)          lcp->want_mru = maxmru;        else if (mru < MIN_MRU)          lcp->want_mru = MIN_MRU;        else          lcp->want_mru = mru;	break;      case MODE_REJ:	lcp->his_reject |= (1 << type);	break;      }      break;    case TY_ACCMAP:      ua_ntohl(cp + 2, &accmap);      log_Printf(LogLCP, "%s 0x%08lx\n", request, (u_long)accmap);      switch (mode_type) {      case MODE_REQ:	lcp->his_accmap = accmap;	memcpy(dec->ackend, cp, 6);	dec->ackend += 6;	break;      case MODE_NAK:	lcp->want_accmap = accmap;	break;      case MODE_REJ:	lcp->his_reject |= (1 << type);	break;      }      break;    case TY_AUTHPROTO:      ua_ntohs(cp + 2, &proto);      log_Printf(LogLCP, "%s 0x%04x (%s)\n", request, proto,                 Auth2Nam(proto, length > 4 ? cp[4] : 0));      switch (mode_type) {      case MODE_REQ:	switch (proto) {	case PROTO_PAP:	  if (length != 4) {	    log_Printf(LogLCP, " Bad length!\n");	    goto reqreject;	  }	  if (IsAccepted(lcp->cfg.pap)) {	    lcp->his_auth = proto;	    lcp->his_authtype = 0;	    memcpy(dec->ackend, cp, length);	    dec->ackend += length;	  } else if (IsAccepted(lcp->cfg.chap05)) {	    *dec->nakend++ = *cp;	    *dec->nakend++ = 5;	    *dec->nakend++ = (unsigned char) (PROTO_CHAP >> 8);	    *dec->nakend++ = (unsigned char) PROTO_CHAP;	    *dec->nakend++ = 0x05;#ifndef NODES	  } else if (IsAccepted(lcp->cfg.chap80nt) ||	             IsAccepted(lcp->cfg.chap80lm)) {	    *dec->nakend++ = *cp;	    *dec->nakend++ = 5;	    *dec->nakend++ = (unsigned char) (PROTO_CHAP >> 8);	    *dec->nakend++ = (unsigned char) PROTO_CHAP;	    *dec->nakend++ = 0x80;	  } else if (IsAccepted(lcp->cfg.chap81)) {	    *dec->nakend++ = *cp;	    *dec->nakend++ = 5;	    *dec->nakend++ = (unsigned char) (PROTO_CHAP >> 8);	    *dec->nakend++ = (unsigned char) PROTO_CHAP;	    *dec->nakend++ = 0x81;#endif	  } else	    goto reqreject;	  break;	case PROTO_CHAP:	  if (length != 5) {	    log_Printf(LogLCP, " Bad length!\n");	    goto reqreject;	  }          if ((cp[4] == 0x05 && IsAccepted(lcp->cfg.chap05))#ifndef NODES              || (cp[4] == 0x80 && (IsAccepted(lcp->cfg.chap80nt) ||                                   (IsAccepted(lcp->cfg.chap80lm))))              || (cp[4] == 0x81 && IsAccepted(lcp->cfg.chap81))#endif             ) {	    lcp->his_auth = proto;	    lcp->his_authtype = cp[4];	    memcpy(dec->ackend, cp, length);	    dec->ackend += length;	  } else {#ifndef HAVE_DES            if (cp[4] == 0x80) {              log_Printf(LogWARN, "CHAP 0x80 not available without DES\n");            } else if (cp[4] == 0x81) {              log_Printf(LogWARN, "CHAP 0x81 not available without DES\n");            } else#endif            if (cp[4] != 0x05)              log_Printf(LogWARN, "%s not supported\n",                         Auth2Nam(PROTO_CHAP, cp[4]));            if (IsAccepted(lcp->cfg.chap05)) {	      *dec->nakend++ = *cp;	      *dec->nakend++ = 5;	      *dec->nakend++ = (unsigned char) (PROTO_CHAP >> 8);	      *dec->nakend++ = (unsigned char) PROTO_CHAP;	      *dec->nakend++ = 0x05;#ifndef NODES            } else if (IsAccepted(lcp->cfg.chap80nt) ||                       IsAccepted(lcp->cfg.chap80lm)) {	      *dec->nakend++ = *cp;	      *dec->nakend++ = 5;	      *dec->nakend++ = (unsigned char) (PROTO_CHAP >> 8);	      *dec->nakend++ = (unsigned char) PROTO_CHAP;	      *dec->nakend++ = 0x80;            } else if (IsAccepted(lcp->cfg.chap81)) {	      *dec->nakend++ = *cp;	      *dec->nakend++ = 5;	      *dec->nakend++ = (unsigned char) (PROTO_CHAP >> 8);	      *dec->nakend++ = (unsigned char) PROTO_CHAP;	      *dec->nakend++ = 0x81;#endif            } else if (IsAccepted(lcp->cfg.pap)) {	      *dec->nakend++ = *cp;	      *dec->nakend++ = 4;	      *dec->nakend++ = (unsigned char) (PROTO_PAP >> 8);	      *dec->nakend++ = (unsigned char) PROTO_PAP;	    } else	      goto reqreject;          }	  break;	default:          log_Printf(LogLCP, "%s 0x%04x - not recognised, NAK\n",                    request, proto);	  memcpy(dec->nakend, cp, length);	  dec->nakend += length;	  break;	}	break;      case MODE_NAK:	switch (proto) {	case PROTO_PAP:          if (IsEnabled(lcp->cfg.pap)) {            lcp->want_auth = PROTO_PAP;            lcp->want_authtype = 0;          } else {            log_Printf(LogLCP, "Peer will only send PAP (not enabled)\n");	    lcp->his_reject |= (1 << type);          }          break;	case PROTO_CHAP:          if (cp[4] == 0x05 && IsEnabled(lcp->cfg.chap05)) {            lcp->want_auth = PROTO_CHAP;            lcp->want_authtype = 0x05;#ifndef NODES          } else if (cp[4] == 0x80 && (IsEnabled(lcp->cfg.chap80nt) ||                                       IsEnabled(lcp->cfg.chap80lm))) {            lcp->want_auth = PROTO_CHAP;            lcp->want_authtype = 0x80;          } else if (cp[4] == 0x81 && IsEnabled(lcp->cfg.chap81)) {            lcp->want_auth = PROTO_CHAP;            lcp->want_authtype = 0x81;#endif          } else {#ifndef HAVE_DES            if (cp[4] == 0x80) {              log_Printf(LogLCP, "Peer will only send MSCHAP (not available"                         " without DES)\n");            } else if (cp[4] == 0x81) {              log_Printf(LogLCP, "Peer will only send MSCHAPV2 (not available"                         " without DES)\n");            } else#endif            log_Printf(LogLCP, "Peer will only send %s (not %s)\n",                       Auth2Nam(PROTO_CHAP, cp[4]),#ifndef NODES                       (cp[4] == 0x80 || cp[4] == 0x81) ? "configured" :#endif                       "supported");	    lcp->his_reject |= (1 << type);          }          break;        default:          /* We've been NAK'd with something we don't understand :-( */	  lcp->his_reject |= (1 << type);          break;        }	break;      case MODE_REJ:	lcp->his_reject |= (1 << type);	break;      }      break;    case TY_QUALPROTO:      req = (struct lqrreq *)cp;      log_Printf(LogLCP, "%s proto %x, interval %lums\n",                request, ntohs(req->proto), (u_long)ntohl(req->period) * 10);      switch (mode_type) {      case MODE_REQ:	if (ntohs(req->proto) != PROTO_LQR || !IsAccepted(lcp->cfg.lqr))	  goto reqreject;	else {	  lcp->his_lqrperiod = ntohl(req->period);	  if (lcp->his_lqrperiod < MIN_LQRPERIOD * 100)	    lcp->his_lqrperiod = MIN_LQRPERIOD * 100;	  req->period = htonl(lcp->his_lqrperiod);	  memcpy(dec->ackend, cp, length);	  dec->ackend += length;	}	break;      case MODE_NAK:	break;      case MODE_REJ:	lcp->his_reject |= (1 << type);	break;      }      break;    case TY_MAGICNUM:      ua_ntohl(cp + 2, &magic);      log_Printf(LogLCP, "%s 0x%08lx\n", request, (u_long)magic);      switch (mode_type) {      case MODE_REQ:	if (lcp->want_magic) {	  /* Validate magic number */	  if (magic == lcp->want_magic) {	    sigset_t emptyset;	    log_Printf(LogLCP, "Magic is same (%08lx) - %d times\n",                      (u_long)magic, ++lcp->LcpFailedMagic);	    lcp->want_magic = GenerateMagic();	    memcpy(dec->nakend, cp, 6);	    dec->nakend += 6;            ualarm(TICKUNIT * (4 + 4 * lcp->LcpFailedMagic), 0);	    sigemptyset(&emptyset);	    sigsuspend(&emptyset);	  } else {	    lcp->his_magic = magic;	    memcpy(dec->ackend, cp, length);	    dec->ackend += length;            lcp->LcpFailedMagic = 0;	  }	} else {	  goto reqreject;	}	break;      case MODE_NAK:	log_Printf(LogLCP, " Magic 0x%08lx is NAKed!\n", (u_long)magic);	lcp->want_magic = GenerateMagic();	break;      case MODE_REJ:	log_Printf(LogLCP, " Magic 0x%08x is REJected!\n", magic);	lcp->want_magic = 0;	lcp->his_reject |= (1 << type);	break;      }      break;    case TY_PROTOCOMP:      log_Printf(LogLCP, "%s\n", request);      switch (mode_type) {      case MODE_REQ:	if (IsAccepted(lcp->cfg.protocomp)) {	  lcp->his_protocomp = 1;	  memcpy(dec->ackend, cp, 2);	  dec->ackend += 2;	} else {#ifdef OLDMST	  /* MorningStar before v1.3 needs NAK */	  memcpy(dec->nakend, cp, 2);	  dec->nakend += 2;#else	  goto reqreject;#endif	}	break;      case MODE_NAK:      case MODE_REJ:	lcp->want_protocomp = 0;	lcp->his_reject |= (1 << type);	break;      }      break;    case TY_ACFCOMP:      log_Printf(LogLCP, "%s\n", request);      switch (mode_type) {      case MODE_REQ:	if (IsAccepted(lcp->cfg.acfcomp)) {	  lcp->his_acfcomp = 1;	  memcpy(dec->ackend, cp, 2);	  dec->ackend += 2;	} else {#ifdef OLDMST	  /* MorningStar before v1.3 needs NAK */	  memcpy(dec->nakend, cp, 2);	  dec->nakend += 2;#else	  goto reqreject;#endif	}	break;      case MODE_NAK:      case MODE_REJ:	lcp->want_acfcomp = 0;	lcp->his_reject |= (1 << type);	break;      }      break;    case TY_SDP:      log_Printf(LogLCP, "%s\n", request);      switch (mode_type) {      case MODE_REQ:      case MODE_NAK:      case MODE_REJ:	break;      }      break;    case TY_CALLBACK:      if (length == 2)        op = CALLBACK_NONE;      else        op = (int)cp[2];      sz = length - 3;      switch (op) {        case CALLBACK_AUTH:          log_Printf(LogLCP, "%s Auth\n", request);          break;        case CALLBACK_DIALSTRING:          log_Printf(LogLCP, "%s Dialstring %.*s\n", request, sz, cp + 3);          break;        case CALLBACK_LOCATION:          log_Printf(LogLCP, "%s Location %.*s\n", request, sz, cp + 3);          break;        case CALLBACK_E164:          log_Printf(LogLCP, "%s E.164 (%.*s)\n", request, sz, cp + 3);          break;        case CALLBACK_NAME:          log_Printf(LogLCP, "%s Name %.*s\n", request, sz, cp + 3);          break;        case CALLBACK_CBCP:          log_Printf(LogLCP, "%s CBCP\n", request);          break;        default:          log_Printf(LogLCP, "%s ???\n", request);          break;      }      switch (mode_type) {      case MODE_REQ:        callback_req = 1;        if (p->type != PHYS_DIRECT)	  goto reqreject;        if ((p->dl->cfg.callback.opmask & CALLBACK_BIT(op)) &&            (op != CALLBACK_AUTH || p->link.lcp.want_auth) &&            (op != CALLBACK_E164 ||             E164ok(&p->dl->cfg.callback, cp + 3, sz))) {	  lcp->his_callback.opmask = CALLBACK_BIT(op);          if (sz > sizeof lcp->his_callback.msg - 1) {            sz = sizeof lcp->his_callback.msg - 1;            log_Printf(LogWARN, "Truncating option arg to %d octets\n", sz);          }	  memcpy(lcp->his_callback.msg, cp + 3, sz);	  lcp->his_callback.msg[sz] = '\0';	  memcpy(dec->ackend, cp, sz + 3);	  dec->ackend += sz + 3;        } else if ((p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_AUTH)) &&                    p->link.lcp.auth_ineed) {          *dec->nakend++ = *cp;          *dec->nakend++ = 3;          *dec->nakend++ = CALLBACK_AUTH;        } else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_CBCP)) {          *dec->nakend++ = *cp;          *dec->nakend++ = 3;          *dec->nakend++ = CALLBACK_CBCP;        } else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_E164)) {          *dec->nakend++ = *cp;          *dec->nakend++ = 3;          *dec->nakend++ = CALLBACK_E164;        } else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_AUTH)) {          log_Printf(LogWARN, "Cannot insist on auth callback without"                     " PAP or CHAP enabled !\n");          *dec->nakend++ = *cp;          *dec->nakend++ = 2;        } else	  goto reqreject;        break;      case MODE_NAK:        /* We don't do what he NAKs with, we do things in our preferred order */        if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_AUTH))          lcp->want_callback.opmask &= ~CALLBACK_BIT(CALLBACK_AUTH);        else if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_CBCP))          lcp->want_callback.opmask &= ~CALLBACK_BIT(CALLBACK_CBCP);        else if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_E164))          lcp->want_callback.opmask &= ~CALLBACK_BIT(CALLBACK_E164);        if (lcp->want_callback.opmask == CALLBACK_BIT(CALLBACK_NONE)) {          log_Printf(LogPHASE, "Peer NAKd all callbacks, trying none\n");          lcp->want_callback.opmask = 0;        } else if (!lcp->want_callback.opmask) {          log_Printf(LogPHASE, "Peer NAKd last configured callback\n");          fsm_Close(&lcp->fsm);        }        break;      case MODE_REJ:        if (lcp->want_callback.opmask & CALLBACK_BIT(CALLBACK_NONE)) {	  lcp->his_reject |= (1 << type);          lcp->want_callback.opmask = 0;        } else {          log_Printf(LogPHASE, "Peer rejected *required* callback\n");          fsm_Close(&lcp->fsm);        }	break;      }      break;    case TY_SHORTSEQ:      mp = &lcp->fsm.bundle->ncp.mp;      log_Printf(LogLCP, "%s\n", request);      switch (mode_type) {      case MODE_REQ:        if (lcp->want_mrru && IsAccepted(mp->cfg.shortseq)) {          lcp->his_shortseq = 1;	  memcpy(dec->ackend, cp, length);	  dec->ackend += length;        } else	  goto reqreject;        break;      case MODE_NAK:        /*         * He's trying to get us to ask for short sequence numbers.         * We ignore the NAK and honour our configuration file instead.         */        break;      case MODE_REJ:	lcp->his_reject |= (1 << type);        lcp->want_shortseq = 0;		/* For when we hit MP */	break;      }      break;    case TY_ENDDISC:      mp = &lcp->fsm.bundle->ncp.mp;      log_Printf(LogLCP, "%s %s\n", request,                mp_Enddisc(cp[2], cp + 3, length - 3));      switch (mode_type) {      case MODE_REQ:        if (!p) {          log_Printf(LogLCP, " ENDDISC rejected - not a physical link\n");	  goto reqreject;        } else if (!IsAccepted(mp->cfg.negenddisc))	  goto reqreject;        else if (length-3 < sizeof p->dl->peer.enddisc.address &&                   cp[2] <= MAX_ENDDISC_CLASS) {          p->dl->peer.enddisc.class = cp[2];          p->dl->peer.enddisc.len = length-3;          memcpy(p->dl->peer.enddisc.address, cp + 3, length - 3);          p->dl->peer.enddisc.address[length - 3] = '\0';          /* XXX: If mp->active, compare and NAK with mp->peer ? */	  memcpy(dec->ackend, cp, length);	  dec->ackend += length;        } else {          if (cp[2] > MAX_ENDDISC_CLASS)            log_Printf(LogLCP, " ENDDISC rejected - unrecognised class %d\n",                      cp[2]);          else            log_Printf(LogLCP, " ENDDISC rejected - local max length is %ld\n",                      (long)(sizeof p->dl->peer.enddisc.address - 1));	  goto reqreject;        }	break;      case MODE_NAK:	/* Treat this as a REJ, we don't vary our disc (yet) */      case MODE_REJ:	lcp->his_reject |= (1 << type);	break;      }      break;          default:      sz = (sizeof desc - 2) / 2;      if (sz > length - 2)        sz = length - 2;      pos = 0;      desc[0] = sz ? ' ' : '\0';      for (pos = 0; sz--; pos++)        sprintf(desc+(pos<<1)+1, "%02x", cp[pos+2]);      log_Printf(LogLCP, "%s%s\n", request, desc);      if (mode_type == MODE_REQ) {reqreject:        if (length > sizeof dec->rej - (dec->rejend - dec->rej)) {          length = sizeof dec->rej - (dec->rejend - dec->rej);          log_Printf(LogLCP, "Can't REJ length %d - trunating to %d\n",		    cp[1], length);        }	memcpy(dec->rejend, cp, length);	dec->rejend += length;	lcp->my_reject |= (1 << type);        if (length != cp[1])          length = 0;		/* force our way out of the loop */      }      break;    }    plen -= length;    cp += length;  }  if (mode_type != MODE_NOP) {    if (mode_type == MODE_REQ && p && p->type == PHYS_DIRECT &&        p->dl->cfg.callback.opmask && !callback_req &&        !(p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_NONE))) {      /* We *REQUIRE* that the peer requests callback */      *dec->nakend++ = TY_CALLBACK;      *dec->nakend++ = 3;      if ((p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_AUTH)) &&          p->link.lcp.want_auth)        *dec->nakend++ = CALLBACK_AUTH;      else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_CBCP))        *dec->nakend++ = CALLBACK_CBCP;      else if (p->dl->cfg.callback.opmask & CALLBACK_BIT(CALLBACK_E164))        *dec->nakend++ = CALLBACK_E164;      else {        log_Printf(LogWARN, "Cannot insist on auth callback without"                   " PAP or CHAP enabled !\n");        dec->nakend[-1] = 2;	/* XXX: Silly ! */      }    }    if (mode_type == MODE_REQ && !lcp->mru_req) {      mru = DEF_MRU;      phmtu = p ? physical_DeviceMTU(p) : 0;      if (phmtu && mru > phmtu)        mru = phmtu;      if (mru > lcp->cfg.max_mtu)        mru = lcp->cfg.max_mtu;      if (mru < DEF_MRU) {        /* Don't let the peer use the default MRU */        lcp->his_mru = lcp->cfg.mtu && lcp->cfg.mtu < mru ? lcp->cfg.mtu : mru;        *dec->nakend++ = TY_MRU;        *dec->nakend++ = 4;        ua_htons(&lcp->his_mru, dec->nakend);        dec->nakend += 2;        lcp->mru_req = 1;	/* Don't keep NAK'ing this */      }    }    if (dec->rejend != dec->rej) {      /* rejects are preferred */      dec->ackend = dec->ack;      dec->nakend = dec->nak;    } else if (dec->nakend != dec->nak)      /* then NAKs */      dec->ackend = dec->ack;  }}