Index: stable/2.2/usr.sbin/ppp/ccp.c =================================================================== --- stable/2.2/usr.sbin/ppp/ccp.c (revision 29308) +++ stable/2.2/usr.sbin/ppp/ccp.c (revision 29309) @@ -1,264 +1,264 @@ /* * PPP Compression Control Protocol (CCP) Module * * Written by Toshiharu OHNO (tony-o@iij.ad.jp) * * Copyright (C) 1994, Internet Initiative Japan, Inc. All rights reserverd. * * Redistribution and use in source and binary forms are permitted * provided that the above copyright notice and this paragraph are * duplicated in all such forms and that any documentation, * advertising materials, and other materials related to such * distribution and use acknowledge that the software was developed * by the Internet Initiative Japan, Inc. The name of the * IIJ may not be used to endorse or promote products derived * from this software without specific prior written permission. * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. * - * $Id: ccp.c,v 1.14 1997/08/20 23:47:40 brian Exp $ + * $Id: ccp.c,v 1.7.2.6 1997/08/25 00:34:21 brian Exp $ * * TODO: * o Support other compression protocols */ #include "fsm.h" #include "lcpproto.h" #include "lcp.h" #include "ccp.h" #include "phase.h" #include "loadalias.h" #include "vars.h" #include "pred.h" struct ccpstate CcpInfo; static void CcpSendConfigReq(struct fsm *); static void CcpSendTerminateReq(struct fsm * fp); static void CcpSendTerminateAck(struct fsm * fp); static void CcpDecodeConfig(u_char * cp, int flen, int mode); static void CcpLayerStart(struct fsm *); static void CcpLayerFinish(struct fsm *); static void CcpLayerUp(struct fsm *); static void CcpLayerDown(struct fsm *); static void CcpInitRestartCounter(struct fsm *); #define REJECTED(p, x) (p->his_reject & (1<name, StateNames[fp->state]); fprintf(VarTerm, "myproto = %s, hisproto = %s\n", cftypes[icp->want_proto], cftypes[icp->his_proto]); fprintf(VarTerm, "Input: %ld --> %ld, Output: %ld --> %ld\n", icp->orgin, icp->compin, icp->orgout, icp->compout); } return 0; } void CcpInit() { struct ccpstate *icp = &CcpInfo; FsmInit(&CcpFsm); bzero(icp, sizeof(struct ccpstate)); if (Enabled(ConfPred1)) icp->want_proto = TY_PRED1; CcpFsm.maxconfig = 10; } static void CcpInitRestartCounter(struct fsm * fp) { fp->FsmTimer.load = VarRetryTimeout * SECTICKS; fp->restart = 5; } static void CcpSendConfigReq(struct fsm * fp) { u_char *cp; struct ccpstate *icp = &CcpInfo; cp = ReqBuff; LogPrintf(LogCCP, "CcpSendConfigReq\n"); if (icp->want_proto && !REJECTED(icp, TY_PRED1)) { *cp++ = TY_PRED1; *cp++ = 2; } FsmOutput(fp, CODE_CONFIGREQ, fp->reqid++, ReqBuff, cp - ReqBuff); } void CcpSendResetReq(struct fsm * fp) { - Pred1Init(1); /* Initialize Input part */ LogPrintf(LogCCP, "CcpSendResetReq\n"); FsmOutput(fp, CODE_RESETREQ, fp->reqid, NULL, 0); } static void CcpSendTerminateReq(struct fsm * fp) { /* XXX: No code yet */ } static void CcpSendTerminateAck(struct fsm * fp) { LogPrintf(LogCCP, "CcpSendTerminateAck\n"); FsmOutput(fp, CODE_TERMACK, fp->reqid++, NULL, 0); } void CcpRecvResetReq(struct fsm * fp) { Pred1Init(2); /* Initialize Output part */ } static void CcpLayerStart(struct fsm * fp) { LogPrintf(LogCCP, "CcpLayerStart.\n"); } static void CcpLayerFinish(struct fsm * fp) { LogPrintf(LogCCP, "CcpLayerFinish.\n"); } static void CcpLayerDown(struct fsm * fp) { LogPrintf(LogCCP, "CcpLayerDown.\n"); } /* * Called when CCP has reached to OPEN state */ static void CcpLayerUp(struct fsm * fp) { LogPrintf(LogCCP, "CcpLayerUp(%d).\n", fp->state); LogPrintf(LogCCP, "myproto = %d, hisproto = %d\n", CcpInfo.want_proto, CcpInfo.his_proto); Pred1Init(3); /* Initialize Input and Output */ } void CcpUp() { FsmUp(&CcpFsm); LogPrintf(LogCCP, "CCP Up event!!\n"); } void CcpOpen() { if (Enabled(ConfPred1)) FsmOpen(&CcpFsm); } static void CcpDecodeConfig(u_char * cp, int plen, int mode) { int type, length; char tbuff[100]; ackp = AckBuff; nakp = NakBuff; rejp = RejBuff; while (plen >= sizeof(struct fsmconfig)) { if (plen < 0) break; type = *cp; length = cp[1]; if (type <= TY_BSD) snprintf(tbuff, sizeof(tbuff), " %s[%d] ", cftypes[type], length); else snprintf(tbuff, sizeof(tbuff), " "); LogPrintf(LogCCP, "%s\n", tbuff); switch (type) { case TY_PRED1: switch (mode) { case MODE_REQ: if (Acceptable(ConfPred1)) { bcopy(cp, ackp, length); ackp += length; CcpInfo.his_proto = type; } else { bcopy(cp, rejp, length); rejp += length; } break; case MODE_NAK: case MODE_REJ: CcpInfo.his_reject |= (1 << type); CcpInfo.want_proto = 0; break; } break; case TY_BSD: default: CcpInfo.my_reject |= (1 << type); bcopy(cp, rejp, length); rejp += length; break; } plen -= length; cp += length; } } void CcpInput(struct mbuf * bp) { if (phase == PHASE_NETWORK) FsmInput(&CcpFsm, bp); else { - LogPrintf(LogERROR, "Unexpected CCP in phase %d\n", phase); + if (phase > PHASE_NETWORK) + LogPrintf(LogERROR, "Unexpected CCP in phase %d\n", phase); pfree(bp); } } Index: stable/2.2/usr.sbin/ppp/fsm.c =================================================================== --- stable/2.2/usr.sbin/ppp/fsm.c (revision 29308) +++ stable/2.2/usr.sbin/ppp/fsm.c (revision 29309) @@ -1,764 +1,766 @@ /* * PPP Finite State Machine for LCP/IPCP * * Written by Toshiharu OHNO (tony-o@iij.ad.jp) * * Copyright (C) 1993, Internet Initiative Japan, Inc. All rights reserverd. * * Redistribution and use in source and binary forms are permitted * provided that the above copyright notice and this paragraph are * duplicated in all such forms and that any documentation, * advertising materials, and other materials related to such * distribution and use acknowledge that the software was developed * by the Internet Initiative Japan, Inc. The name of the * IIJ may not be used to endorse or promote products derived * from this software without specific prior written permission. * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. * - * $Id: fsm.c,v 1.7.2.6 1997/08/25 00:34:26 brian Exp $ + * $Id: fsm.c,v 1.7.2.7 1997/08/31 23:02:15 brian Exp $ * * TODO: * o Refer loglevel for log output * o Better option log display */ #include "fsm.h" #include "hdlc.h" #include "lqr.h" #include "lcpproto.h" #include "lcp.h" #include "ccp.h" #include "modem.h" #include "loadalias.h" #include "vars.h" +#include "pred.h" void FsmSendConfigReq(struct fsm * fp); void FsmSendTerminateReq(struct fsm * fp); void FsmInitRestartCounter(struct fsm * fp); void FsmTimeout(struct fsm * fp); char const *StateNames[] = { "Initial", "Starting", "Closed", "Stopped", "Closing", "Stopping", "Req-Sent", "Ack-Rcvd", "Ack-Sent", "Opened", }; static void StoppedTimeout(struct fsm * fp) { LogPrintf(fp->LogLevel, "Stopped timer expired\n"); if (modem != -1) DownConnection(); else FsmDown(fp); } void FsmInit(struct fsm * fp) { LogPrintf(LogDEBUG, "FsmInit\n"); fp->state = ST_INITIAL; fp->reqid = 1; fp->restart = 1; fp->maxconfig = 3; } void NewState(struct fsm * fp, int new) { LogPrintf(fp->LogLevel, "State change %s --> %s\n", StateNames[fp->state], StateNames[new]); if (fp->state == ST_STOPPED && fp->StoppedTimer.state == TIMER_RUNNING) StopTimer(&fp->StoppedTimer); fp->state = new; if ((new >= ST_INITIAL && new <= ST_STOPPED) || (new == ST_OPENED)) { StopTimer(&fp->FsmTimer); if (new == ST_STOPPED && fp->StoppedTimer.load) { fp->StoppedTimer.state = TIMER_STOPPED; fp->StoppedTimer.func = StoppedTimeout; fp->StoppedTimer.arg = (void *) fp; StartTimer(&fp->StoppedTimer); } } } void FsmOutput(struct fsm * fp, u_int code, u_int id, u_char * ptr, int count) { int plen; struct fsmheader lh; struct mbuf *bp; plen = sizeof(struct fsmheader) + count; lh.code = code; lh.id = id; lh.length = htons(plen); bp = mballoc(plen, MB_FSM); bcopy(&lh, MBUF_CTOP(bp), sizeof(struct fsmheader)); if (count) bcopy(ptr, MBUF_CTOP(bp) + sizeof(struct fsmheader), count); LogDumpBp(LogDEBUG, "FsmOutput", bp); HdlcOutput(PRI_LINK, fp->proto, bp); } void FsmOpen(struct fsm * fp) { switch (fp->state) { case ST_INITIAL: (fp->LayerStart) (fp); NewState(fp, ST_STARTING); break; case ST_STARTING: break; case ST_CLOSED: if (fp->open_mode == OPEN_PASSIVE) { NewState(fp, ST_STOPPED); } else { FsmInitRestartCounter(fp); FsmSendConfigReq(fp); NewState(fp, ST_REQSENT); } break; case ST_STOPPED: /* XXX: restart option */ case ST_REQSENT: case ST_ACKRCVD: case ST_ACKSENT: case ST_OPENED: /* XXX: restart option */ break; case ST_CLOSING: /* XXX: restart option */ case ST_STOPPING: /* XXX: restart option */ NewState(fp, ST_STOPPING); break; } } void FsmUp(struct fsm * fp) { switch (fp->state) { case ST_INITIAL: NewState(fp, ST_CLOSED); break; case ST_STARTING: FsmInitRestartCounter(fp); FsmSendConfigReq(fp); NewState(fp, ST_REQSENT); break; default: LogPrintf(fp->LogLevel, "Oops, Up at %s\n", StateNames[fp->state]); break; } } void FsmDown(struct fsm * fp) { switch (fp->state) { case ST_CLOSED: case ST_CLOSING: NewState(fp, ST_INITIAL); break; case ST_STOPPED: (fp->LayerStart) (fp); /* Fall into.. */ case ST_STOPPING: case ST_REQSENT: case ST_ACKRCVD: case ST_ACKSENT: NewState(fp, ST_STARTING); break; case ST_OPENED: (fp->LayerDown) (fp); NewState(fp, ST_STARTING); break; } } void FsmClose(struct fsm * fp) { switch (fp->state) { case ST_STARTING: NewState(fp, ST_INITIAL); break; case ST_STOPPED: NewState(fp, ST_CLOSED); break; case ST_STOPPING: NewState(fp, ST_CLOSING); break; case ST_OPENED: (fp->LayerDown) (fp); /* Fall down */ case ST_REQSENT: case ST_ACKRCVD: case ST_ACKSENT: FsmInitRestartCounter(fp); FsmSendTerminateReq(fp); NewState(fp, ST_CLOSING); break; } } /* * Send functions */ void FsmSendConfigReq(struct fsm * fp) { if (--fp->maxconfig > 0) { (fp->SendConfigReq) (fp); StartTimer(&fp->FsmTimer); /* Start restart timer */ fp->restart--; /* Decrement restart counter */ } else { FsmClose(fp); } } void FsmSendTerminateReq(struct fsm * fp) { LogPrintf(fp->LogLevel, "SendTerminateReq.\n"); FsmOutput(fp, CODE_TERMREQ, fp->reqid++, NULL, 0); (fp->SendTerminateReq) (fp); StartTimer(&fp->FsmTimer); /* Start restart timer */ fp->restart--; /* Decrement restart counter */ } static void FsmSendConfigAck(struct fsm * fp, struct fsmheader * lhp, u_char * option, int count) { LogPrintf(fp->LogLevel, "SendConfigAck(%s)\n", StateNames[fp->state]); (fp->DecodeConfig) (option, count, MODE_NOP); FsmOutput(fp, CODE_CONFIGACK, lhp->id, option, count); } static void FsmSendConfigRej(struct fsm * fp, struct fsmheader * lhp, u_char * option, int count) { LogPrintf(fp->LogLevel, "SendConfigRej(%s)\n", StateNames[fp->state]); (fp->DecodeConfig) (option, count, MODE_NOP); FsmOutput(fp, CODE_CONFIGREJ, lhp->id, option, count); } static void FsmSendConfigNak(struct fsm * fp, struct fsmheader * lhp, u_char * option, int count) { LogPrintf(fp->LogLevel, "SendConfigNak(%s)\n", StateNames[fp->state]); (fp->DecodeConfig) (option, count, MODE_NOP); FsmOutput(fp, CODE_CONFIGNAK, lhp->id, option, count); } /* * Timeout actions */ void FsmTimeout(struct fsm * fp) { if (fp->restart) { switch (fp->state) { case ST_CLOSING: case ST_STOPPING: FsmSendTerminateReq(fp); break; case ST_REQSENT: case ST_ACKSENT: FsmSendConfigReq(fp); break; case ST_ACKRCVD: FsmSendConfigReq(fp); NewState(fp, ST_REQSENT); break; } StartTimer(&fp->FsmTimer); } else { switch (fp->state) { case ST_CLOSING: NewState(fp, ST_CLOSED); (fp->LayerFinish) (fp); break; case ST_STOPPING: NewState(fp, ST_STOPPED); (fp->LayerFinish) (fp); break; case ST_REQSENT: /* XXX: 3p */ case ST_ACKSENT: case ST_ACKRCVD: NewState(fp, ST_STOPPED); (fp->LayerFinish) (fp); break; } } } void FsmInitRestartCounter(struct fsm * fp) { StopTimer(&fp->FsmTimer); fp->FsmTimer.state = TIMER_STOPPED; fp->FsmTimer.func = FsmTimeout; fp->FsmTimer.arg = (void *) fp; (fp->InitRestartCounter) (fp); } /* * Actions when receive packets */ void FsmRecvConfigReq(struct fsm * fp, struct fsmheader * lhp, struct mbuf * bp) /* RCR */ { int plen, flen; int ackaction = 0; plen = plength(bp); flen = ntohs(lhp->length) - sizeof(*lhp); if (plen < flen) { LogPrintf(LogERROR, "FsmRecvConfigReq: plen (%d) < flen (%d)\n", plen, flen); pfree(bp); return; } /* * Check and process easy case */ switch (fp->state) { case ST_INITIAL: case ST_STARTING: LogPrintf(fp->LogLevel, "Oops, RCR in %s.\n", StateNames[fp->state]); pfree(bp); return; case ST_CLOSED: (fp->SendTerminateAck) (fp); pfree(bp); return; case ST_CLOSING: case ST_STOPPING: LogPrintf(LogERROR, "Got ConfigReq while state = %d\n", fp->state); pfree(bp); return; } (fp->DecodeConfig) (MBUF_CTOP(bp), flen, MODE_REQ); if (nakp == NakBuff && rejp == RejBuff) ackaction = 1; switch (fp->state) { case ST_OPENED: (fp->LayerDown) (fp); FsmSendConfigReq(fp); break; case ST_STOPPED: FsmInitRestartCounter(fp); FsmSendConfigReq(fp); break; } if (rejp != RejBuff) FsmSendConfigRej(fp, lhp, RejBuff, rejp - RejBuff); if (nakp != NakBuff) FsmSendConfigNak(fp, lhp, NakBuff, nakp - NakBuff); if (ackaction) FsmSendConfigAck(fp, lhp, AckBuff, ackp - AckBuff); switch (fp->state) { case ST_STOPPED: case ST_OPENED: if (ackaction) NewState(fp, ST_ACKSENT); else NewState(fp, ST_REQSENT); break; case ST_REQSENT: if (ackaction) NewState(fp, ST_ACKSENT); break; case ST_ACKRCVD: if (ackaction) { NewState(fp, ST_OPENED); (fp->LayerUp) (fp); } break; case ST_ACKSENT: if (!ackaction) NewState(fp, ST_REQSENT); break; } pfree(bp); } void FsmRecvConfigAck(struct fsm * fp, struct fsmheader * lhp, struct mbuf * bp) /* RCA */ { switch (fp->state) { case ST_CLOSED: case ST_STOPPED: (fp->SendTerminateAck) (fp); break; case ST_CLOSING: case ST_STOPPING: break; case ST_REQSENT: FsmInitRestartCounter(fp); NewState(fp, ST_ACKRCVD); break; case ST_ACKRCVD: FsmSendConfigReq(fp); NewState(fp, ST_REQSENT); break; case ST_ACKSENT: FsmInitRestartCounter(fp); NewState(fp, ST_OPENED); (fp->LayerUp) (fp); break; case ST_OPENED: (fp->LayerDown) (fp); FsmSendConfigReq(fp); NewState(fp, ST_REQSENT); break; } pfree(bp); } void FsmRecvConfigNak(struct fsm * fp, struct fsmheader * lhp, struct mbuf * bp) /* RCN */ { int plen, flen; plen = plength(bp); flen = ntohs(lhp->length) - sizeof(*lhp); if (plen < flen) { pfree(bp); return; } /* * Check and process easy case */ switch (fp->state) { case ST_INITIAL: case ST_STARTING: LogPrintf(fp->LogLevel, "Oops, RCN in %s.\n", StateNames[fp->state]); pfree(bp); return; case ST_CLOSED: case ST_STOPPED: (fp->SendTerminateAck) (fp); pfree(bp); return; case ST_CLOSING: case ST_STOPPING: pfree(bp); return; } (fp->DecodeConfig) (MBUF_CTOP(bp), flen, MODE_NAK); switch (fp->state) { case ST_REQSENT: case ST_ACKSENT: FsmInitRestartCounter(fp); FsmSendConfigReq(fp); break; case ST_OPENED: (fp->LayerDown) (fp); /* Fall down */ case ST_ACKRCVD: FsmSendConfigReq(fp); NewState(fp, ST_REQSENT); break; } pfree(bp); } void FsmRecvTermReq(struct fsm * fp, struct fsmheader * lhp, struct mbuf * bp) /* RTR */ { switch (fp->state) { case ST_INITIAL: case ST_STARTING: LogPrintf(fp->LogLevel, "Oops, RTR in %s\n", StateNames[fp->state]); break; case ST_CLOSED: case ST_STOPPED: case ST_CLOSING: case ST_STOPPING: case ST_REQSENT: (fp->SendTerminateAck) (fp); break; case ST_ACKRCVD: case ST_ACKSENT: (fp->SendTerminateAck) (fp); NewState(fp, ST_REQSENT); break; case ST_OPENED: (fp->LayerDown) (fp); (fp->SendTerminateAck) (fp); StartTimer(&fp->FsmTimer); /* Start restart timer */ fp->restart = 0; NewState(fp, ST_STOPPING); break; } pfree(bp); } void FsmRecvTermAck(struct fsm * fp, struct fsmheader * lhp, struct mbuf * bp) /* RTA */ { switch (fp->state) { case ST_CLOSING: NewState(fp, ST_CLOSED); (fp->LayerFinish) (fp); break; case ST_STOPPING: NewState(fp, ST_STOPPED); (fp->LayerFinish) (fp); break; case ST_ACKRCVD: NewState(fp, ST_REQSENT); break; case ST_OPENED: (fp->LayerDown) (fp); FsmSendConfigReq(fp); NewState(fp, ST_REQSENT); break; } pfree(bp); } void FsmRecvConfigRej(struct fsm * fp, struct fsmheader * lhp, struct mbuf * bp) /* RCJ */ { int plen, flen; plen = plength(bp); flen = ntohs(lhp->length) - sizeof(*lhp); if (plen < flen) { pfree(bp); return; } LogPrintf(fp->LogLevel, "RecvConfigRej.\n"); /* * Check and process easy case */ switch (fp->state) { case ST_INITIAL: case ST_STARTING: LogPrintf(fp->LogLevel, "Oops, RCJ in %s.\n", StateNames[fp->state]); pfree(bp); return; case ST_CLOSED: case ST_STOPPED: (fp->SendTerminateAck) (fp); pfree(bp); return; case ST_CLOSING: case ST_STOPPING: pfree(bp); return; } (fp->DecodeConfig) (MBUF_CTOP(bp), flen, MODE_REJ); switch (fp->state) { case ST_REQSENT: case ST_ACKSENT: FsmInitRestartCounter(fp); FsmSendConfigReq(fp); break; case ST_OPENED: (fp->LayerDown) (fp); /* Fall down */ case ST_ACKRCVD: FsmSendConfigReq(fp); NewState(fp, ST_REQSENT); break; } pfree(bp); } void FsmRecvCodeRej(struct fsm * fp, struct fsmheader * lhp, struct mbuf * bp) { LogPrintf(fp->LogLevel, "RecvCodeRej\n"); pfree(bp); } void FsmRecvProtoRej(struct fsm * fp, struct fsmheader * lhp, struct mbuf * bp) { u_short *sp, proto; sp = (u_short *) MBUF_CTOP(bp); proto = ntohs(*sp); LogPrintf(fp->LogLevel, "-- Protocol (%04x) was rejected.\n", proto); switch (proto) { case PROTO_LQR: StopLqr(LQM_LQR); break; case PROTO_CCP: fp = &CcpFsm; (fp->LayerFinish) (fp); switch (fp->state) { case ST_CLOSED: case ST_CLOSING: NewState(fp, ST_CLOSED); default: NewState(fp, ST_STOPPED); break; } break; } pfree(bp); } void FsmRecvEchoReq(struct fsm * fp, struct fsmheader * lhp, struct mbuf * bp) { u_char *cp; u_long *lp, magic; cp = MBUF_CTOP(bp); lp = (u_long *) cp; magic = ntohl(*lp); if (magic != LcpInfo.his_magic) { LogPrintf(LogERROR, "RecvEchoReq: his magic is bad!!\n"); /* XXX: We should send terminate request */ } if (fp->state == ST_OPENED) { *lp = htonl(LcpInfo.want_magic); /* Insert local magic number */ LogPrintf(fp->LogLevel, "SendEchoRep(%s)\n", StateNames[fp->state]); FsmOutput(fp, CODE_ECHOREP, lhp->id, cp, plength(bp)); } pfree(bp); } void FsmRecvEchoRep(struct fsm * fp, struct fsmheader * lhp, struct mbuf * bp) { u_long *lp, magic; lp = (u_long *) MBUF_CTOP(bp); magic = ntohl(*lp); /* * Tolerate echo replies with either magic number */ if (magic != 0 && magic != LcpInfo.his_magic && magic != LcpInfo.want_magic) { LogPrintf(LogERROR, "RecvEchoRep: his magic is wrong! expect: %x got: %x\n", LcpInfo.his_magic, magic); /* * XXX: We should send terminate request. But poor implementation may die * as a result. */ } RecvEchoLqr(bp); pfree(bp); } void FsmRecvDiscReq(struct fsm * fp, struct fsmheader * lhp, struct mbuf * bp) { LogPrintf(fp->LogLevel, "RecvDiscReq\n"); pfree(bp); } void FsmRecvIdent(struct fsm * fp, struct fsmheader * lhp, struct mbuf * bp) { LogPrintf(fp->LogLevel, "RecvIdent\n"); pfree(bp); } void FsmRecvTimeRemain(struct fsm * fp, struct fsmheader * lhp, struct mbuf * bp) { LogPrintf(fp->LogLevel, "RecvTimeRemain\n"); pfree(bp); } void FsmRecvResetReq(struct fsm * fp, struct fsmheader * lhp, struct mbuf * bp) { LogPrintf(fp->LogLevel, "RecvResetReq\n"); CcpRecvResetReq(fp); LogPrintf(fp->LogLevel, "SendResetAck\n"); FsmOutput(fp, CODE_RESETACK, fp->reqid, NULL, 0); pfree(bp); } void FsmRecvResetAck(struct fsm * fp, struct fsmheader * lhp, struct mbuf * bp) { LogPrintf(fp->LogLevel, "RecvResetAck\n"); + Pred1Init(1); /* Initialize Input part */ fp->reqid++; pfree(bp); } struct fsmcodedesc FsmCodes[] = { {FsmRecvConfigReq, "Configure Request",}, {FsmRecvConfigAck, "Configure Ack",}, {FsmRecvConfigNak, "Configure Nak",}, {FsmRecvConfigRej, "Configure Reject",}, {FsmRecvTermReq, "Terminate Request",}, {FsmRecvTermAck, "Terminate Ack",}, {FsmRecvCodeRej, "Code Reject",}, {FsmRecvProtoRej, "Protocol Reject",}, {FsmRecvEchoReq, "Echo Request",}, {FsmRecvEchoRep, "Echo Reply",}, {FsmRecvDiscReq, "Discard Request",}, {FsmRecvIdent, "Ident",}, {FsmRecvTimeRemain, "Time Remain",}, {FsmRecvResetReq, "Reset Request",}, {FsmRecvResetAck, "Reset Ack",}, }; void FsmInput(struct fsm * fp, struct mbuf * bp) { int len; struct fsmheader *lhp; struct fsmcodedesc *codep; len = plength(bp); if (len < sizeof(struct fsmheader)) { pfree(bp); return; } lhp = (struct fsmheader *) MBUF_CTOP(bp); if (lhp->code == 0 || lhp->code > fp->max_code) { pfree(bp); /* XXX: Should send code reject */ return; } bp->offset += sizeof(struct fsmheader); bp->cnt -= sizeof(struct fsmheader); codep = FsmCodes + lhp->code - 1; LogPrintf(fp->LogLevel, "Received %s (%d) state = %s (%d)\n", codep->name, lhp->id, StateNames[fp->state], fp->state); if (LogIsKept(LogDEBUG)) LogMemory(); (codep->action) (fp, lhp, bp); if (LogIsKept(LogDEBUG)) LogMemory(); } Index: stable/2.2/usr.sbin/ppp/hdlc.c =================================================================== --- stable/2.2/usr.sbin/ppp/hdlc.c (revision 29308) +++ stable/2.2/usr.sbin/ppp/hdlc.c (revision 29309) @@ -1,422 +1,424 @@ /* * PPP High Level Link Control (HDLC) Module * * Written by Toshiharu OHNO (tony-o@iij.ad.jp) * * Copyright (C) 1993, Internet Initiative Japan, Inc. All rights reserverd. * * Redistribution and use in source and binary forms are permitted * provided that the above copyright notice and this paragraph are * duplicated in all such forms and that any documentation, * advertising materials, and other materials related to such * distribution and use acknowledge that the software was developed * by the Internet Initiative Japan, Inc. The name of the * IIJ may not be used to endorse or promote products derived * from this software without specific prior written permission. * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. * - * $Id: hdlc.c,v 1.16 1997/06/09 03:27:22 brian Exp $ + * $Id: hdlc.c,v 1.9.2.5 1997/08/25 00:34:27 brian Exp $ * * TODO: */ #include "fsm.h" #include "hdlc.h" #include "lcpproto.h" #include "lcp.h" #include "lqr.h" #include "loadalias.h" #include "vars.h" #include "pred.h" #include "modem.h" #include "ccp.h" struct hdlcstat { int badfcs; int badaddr; int badcommand; int unknownproto; } HdlcStat; static int ifOutPackets, ifOutOctets, ifOutLQRs; static int ifInPackets, ifInOctets; struct protostat { u_short number; char *name; u_long in_count; u_long out_count; } ProtocolStat[] = { { PROTO_IP, "IP" }, { PROTO_VJUNCOMP, "VJ_UNCOMP" }, { PROTO_VJCOMP, "VJ_COMP" }, { PROTO_COMPD, "COMPD" }, { PROTO_LCP, "LCP" }, { PROTO_IPCP, "IPCP" }, { PROTO_CCP, "CCP" }, { PROTO_PAP, "PAP" }, { PROTO_LQR, "LQR" }, { PROTO_CHAP, "CHAP" }, { 0, "Others" }, }; static u_short const fcstab[256] = { /* 00 */ 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, /* 08 */ 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7, /* 10 */ 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e, /* 18 */ 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876, /* 20 */ 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd, /* 28 */ 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5, /* 30 */ 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, /* 38 */ 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974, /* 40 */ 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb, /* 48 */ 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, /* 50 */ 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a, /* 58 */ 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72, /* 60 */ 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, /* 68 */ 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1, /* 70 */ 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, /* 78 */ 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, /* 80 */ 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, /* 88 */ 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff, /* 90 */ 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, /* 98 */ 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, /* a0 */ 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5, /* a8 */ 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, /* b0 */ 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134, /* b8 */ 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c, /* c0 */ 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, /* c8 */ 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb, /* d0 */ 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, /* d8 */ 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, /* e0 */ 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1, /* e8 */ 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9, /* f0 */ 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, /* f8 */ 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78 }; u_char EscMap[33]; void HdlcInit() { ifInOctets = ifOutOctets = 0; ifInPackets = ifOutPackets = 0; ifOutLQRs = 0; } /* * HDLC FCS computation. Read RFC 1171 Appendix B and CCITT X.25 section * 2.27 for further details. */ inline u_short HdlcFcs(u_short fcs, u_char * cp, int len) { while (len--) fcs = (fcs >> 8) ^ fcstab[(fcs ^ *cp++) & 0xff]; return (fcs); } void HdlcOutput(int pri, u_short proto, struct mbuf * bp) { struct mbuf *mhp, *mfcs; struct protostat *statp; struct lqrdata *lqr; u_char *cp; u_short fcs; if ((proto & 0xfff1) == 0x21) { /* Network Layer protocol */ if (CcpFsm.state == ST_OPENED) { - Pred1Output(pri, proto, bp); - return; + if (CcpInfo.want_proto == TY_PRED1) { + Pred1Output(pri, proto, bp); + return; + } } } if (DEV_IS_SYNC) mfcs = NULLBUFF; else mfcs = mballoc(2, MB_HDLCOUT); mhp = mballoc(4, MB_HDLCOUT); mhp->cnt = 0; cp = MBUF_CTOP(mhp); if (proto == PROTO_LCP || LcpInfo.his_acfcomp == 0) { *cp++ = HDLC_ADDR; *cp++ = HDLC_UI; mhp->cnt += 2; } /* * If possible, compress protocol field. */ if (LcpInfo.his_protocomp && (proto & 0xff00) == 0) { *cp++ = proto; mhp->cnt++; } else { *cp++ = proto >> 8; *cp = proto & 0377; mhp->cnt += 2; } mhp->next = bp; bp->next = mfcs; lqr = &MyLqrData; lqr->PeerOutPackets = ifOutPackets++; ifOutOctets += plength(mhp) + 1; lqr->PeerOutOctets = ifOutOctets; if (proto == PROTO_LQR) { lqr->MagicNumber = LcpInfo.want_magic; lqr->LastOutLQRs = HisLqrData.PeerOutLQRs; lqr->LastOutPackets = HisLqrData.PeerOutPackets; lqr->LastOutOctets = HisLqrData.PeerOutOctets; lqr->PeerInLQRs = HisLqrSave.SaveInLQRs; lqr->PeerInPackets = HisLqrSave.SaveInPackets; lqr->PeerInDiscards = HisLqrSave.SaveInDiscards; lqr->PeerInErrors = HisLqrSave.SaveInErrors; lqr->PeerInOctets = HisLqrSave.SaveInOctets; lqr->PeerOutLQRs = ++ifOutLQRs; LqrDump("LqrOutput", lqr); LqrChangeOrder(lqr, (struct lqrdata *) (MBUF_CTOP(bp))); } if (!DEV_IS_SYNC) { fcs = HdlcFcs(INITFCS, MBUF_CTOP(mhp), mhp->cnt); fcs = HdlcFcs(fcs, MBUF_CTOP(bp), bp->cnt); fcs = ~fcs; cp = MBUF_CTOP(mfcs); *cp++ = fcs & 0377; /* Low byte first!! */ *cp++ = fcs >> 8; } LogDumpBp(LogHDLC, "HdlcOutput", mhp); for (statp = ProtocolStat; statp->number; statp++) if (statp->number == proto) break; statp->out_count++; if (DEV_IS_SYNC) ModemOutput(pri, mhp); else AsyncOutput(pri, mhp, proto); } void DecodePacket(u_short proto, struct mbuf * bp) { u_char *cp; LogPrintf(LogDEBUG, "DecodePacket: proto = %04x\n", proto); switch (proto) { case PROTO_LCP: LcpInput(bp); break; case PROTO_PAP: PapInput(bp); break; case PROTO_LQR: HisLqrSave.SaveInLQRs++; LqrInput(bp); break; case PROTO_CHAP: ChapInput(bp); break; case PROTO_VJUNCOMP: case PROTO_VJCOMP: bp = VjCompInput(bp, proto); if (bp == NULLBUFF) { break; } /* fall down */ case PROTO_IP: IpInput(bp); break; case PROTO_IPCP: IpcpInput(bp); break; case PROTO_CCP: CcpInput(bp); break; case PROTO_COMPD: Pred1Input(bp); break; default: LogPrintf(LogPHASE, "Unknown protocol 0x%04x\n", proto); bp->offset -= 2; bp->cnt += 2; cp = MBUF_CTOP(bp); LcpSendProtoRej(cp, bp->cnt); HisLqrSave.SaveInDiscards++; HdlcStat.unknownproto++; pfree(bp); break; } } int ReportProtStatus() { struct protostat *statp; int cnt; statp = ProtocolStat; statp--; cnt = 0; fprintf(VarTerm, " Protocol in out Protocol in out\n"); do { statp++; fprintf(VarTerm, " %-9s: %8lu, %8lu", statp->name, statp->in_count, statp->out_count); if (++cnt == 2) { fprintf(VarTerm, "\n"); cnt = 0; } } while (statp->number); if (cnt) fprintf(VarTerm, "\n"); return (1); } int ReportHdlcStatus() { struct hdlcstat *hp = &HdlcStat; if (VarTerm) { fprintf(VarTerm, "HDLC level errors\n\n"); fprintf(VarTerm, "FCS: %u ADDR: %u COMMAND: %u PROTO: %u\n", hp->badfcs, hp->badaddr, hp->badcommand, hp->unknownproto); } return 0; } static struct hdlcstat laststat; void HdlcErrorCheck() { struct hdlcstat *hp = &HdlcStat; struct hdlcstat *op = &laststat; if (bcmp(hp, op, sizeof(laststat))) { LogPrintf(LogPHASE, "HDLC errors -> FCS: %u ADDR: %u COMD: %u PROTO: %u\n", hp->badfcs - op->badfcs, hp->badaddr - op->badaddr, hp->badcommand - op->badcommand, hp->unknownproto - op->unknownproto); } laststat = HdlcStat; } void HdlcInput(struct mbuf * bp) { u_short fcs, proto; u_char *cp, addr, ctrl; struct protostat *statp; LogDumpBp(LogHDLC, "HdlcInput:", bp); if (DEV_IS_SYNC) fcs = GOODFCS; else fcs = HdlcFcs(INITFCS, MBUF_CTOP(bp), bp->cnt); HisLqrSave.SaveInOctets += bp->cnt + 1; LogPrintf(LogDEBUG, "HdlcInput: fcs = %04x (%s)\n", fcs, (fcs == GOODFCS) ? "good" : "bad"); if (fcs != GOODFCS) { HisLqrSave.SaveInErrors++; LogPrintf(LogDEBUG, "HdlcInput: Bad FCS\n"); HdlcStat.badfcs++; pfree(bp); return; } if (!DEV_IS_SYNC) bp->cnt -= 2; /* discard FCS part */ if (bp->cnt < 2) { /* XXX: raise this bar ? */ pfree(bp); return; } cp = MBUF_CTOP(bp); ifInPackets++; ifInOctets += bp->cnt; if (!LcpInfo.want_acfcomp) { /* * We expect that packet is not compressed. */ addr = *cp++; if (addr != HDLC_ADDR) { HisLqrSave.SaveInErrors++; HdlcStat.badaddr++; LogPrintf(LogDEBUG, "HdlcInput: addr %02x\n", *cp); pfree(bp); return; } ctrl = *cp++; if (ctrl != HDLC_UI) { HisLqrSave.SaveInErrors++; HdlcStat.badcommand++; LogPrintf(LogDEBUG, "HdlcInput: %02x\n", *cp); pfree(bp); return; } bp->offset += 2; bp->cnt -= 2; } else if (cp[0] == HDLC_ADDR && cp[1] == HDLC_UI) { /* * We can receive compressed packet, but peer still send uncompressed * packet to me. */ cp += 2; bp->offset += 2; bp->cnt -= 2; } if (LcpInfo.want_protocomp) { proto = 0; cp--; do { cp++; bp->offset++; bp->cnt--; proto = proto << 8; proto += *cp; } while (!(proto & 1)); } else { proto = *cp++ << 8; proto |= *cp++; bp->offset += 2; bp->cnt -= 2; } for (statp = ProtocolStat; statp->number; statp++) if (statp->number == proto) break; statp->in_count++; HisLqrSave.SaveInPackets++; DecodePacket(proto, bp); }