pppfsm.c

用于嵌入式系统的TCP/IP协议栈

#if PPP_TRACE
          pppFsmLog(fsm, "peer error likely");
#endif
          fsm->state = fsmReqSent;
          fsmSendReq(fsm);
          break;
      }
      break;

    case TERM_REQ:
#if PPP_TRACE
      pppFsmLog(fsm, "Peer requested termination");
#endif
      switch (fsm->state)
      {
        case fsmAckRcvd:
        case fsmAckSent:
          fsm->state = fsmReqSent;
          /*lint -fallthrough */

        case fsmCLOSED:
        case fsmSTOPPED:
        case fsmCLOSING:
        case fsmSTOPPING:
        case fsmReqSent:
          send_term_ack(fsm, hdr.id);
          break;

        case fsmOPENED:
          fsm->pdc->down(fsm);
          set_retry_count(fsm, 0);
          fsm_timer(fsm);
          fsm->state = fsmSTOPPING;
          send_term_ack(fsm, hdr.id);
          break;
      }
      break;

    case TERM_ACK:
      switch (fsm->state)
      {
        case fsmCLOSED:
        case fsmSTOPPED:
        case fsmReqSent:
        case fsmAckSent:
          /* Nothing to do */
          break;

        case fsmAckRcvd:
          fsm->state = fsmReqSent;
          break;

        case fsmCLOSING:
        case fsmSTOPPING:
          /*-----------------------------------------------------------*/
          /* Change Closing -> Closed and Stopping -> Stopped.         */
          /*-----------------------------------------------------------*/
          NetTimerStop(&fsm->timer);
#if PPP_TRACE
          pppFsmLog(fsm, "Terminated");
#endif
          fsm->state -= 2;
          fsm->pdc->finished(fsm);
          break;

        case fsmOPENED:
          /* peer has abruptly closed connection */
#if PPP_TRACE
          pppFsmLog(fsm, "Terminated unexpectly");
#endif
          fsm->pdc->down(fsm);
          fsm->state = fsmReqSent;
          fsmSendReq(fsm);
          break;
      }
      break;

    case CODE_REJ:
    case PROT_REJ:
      if (hdr.code == CODE_REJ)
      {
#if PPP_TRACE
        pppLogn("PPP/%s Code Reject; indicates implementation error",
                fsm->pdc->name);
#endif
      }
      else
      {
#if PPP_TRACE
        pppLogn("PPP/%s Protocol Reject; do not use this protocol",
                fsm->pdc->name);
#endif

        /*-------------------------------------------------------------*/
        /* Silently drop protocol rejects unless LCP state is Opened.  */
        /*-------------------------------------------------------------*/
        if (fsm->state != fsmOPENED)
          return;
      }

      switch (fsm->state)
      {
        case fsmCLOSING:
          fsm->state = fsmCLOSED;
          NetTimerStop(&fsm->timer);
          /*lint -fallthrough */

        case fsmCLOSED:
          fsm->pdc->finished(fsm);
          break;

        case fsmSTOPPING:
        case fsmReqSent:
        case fsmAckRcvd:
        case fsmAckSent:
          fsm->state = fsmSTOPPED;
          NetTimerStop(&fsm->timer);
          /*lint -fallthrough */

        case fsmSTOPPED:
          fsm->pdc->finished(fsm);
          break;

        case fsmOPENED:
          fsm->pdc->down(fsm);
          set_retry_count(fsm, fsm->pdc->terminate_limit);
          fsm->state = fsmSTOPPING;
          send_term_req(fsm);
          break;
      }
      break;

    case ECHO_REQ:
      /*---------------------------------------------------------------*/
      /* Silently drop echo requests unless LCP state is opened.       */
      /*---------------------------------------------------------------*/
      if (fsm->state == fsmOPENED)
      {
        NetRstBuf(pppRcvBuf);
        pppFsmSend(fsm, ECHO_REPLY, hdr.id, pppRcvBuf);
        pppRcvBuf = NULL;
      }
      break;

    case ECHO_REPLY:
    case DISCARD_REQ:
      break;

    case UNRECOGNIZED:
    default:
      /*---------------------------------------------------------------*/
      /* Received a packet of unknown type.                            */
      /*---------------------------------------------------------------*/
#if PPP_TRACE
      pppLogn("PPP/%s Unknown packet type: %d; Sending Code Reject",
              fsm->pdc->name, hdr.code);
#endif
      hdr.len += CONFIG_HDR_LEN;  /* restore original length */
      wr_conf(&hdr, pppRcvBuf);   /* put header back on */
      pppFsmSend(fsm, CODE_REJ, 0, pppRcvBuf);
      pppRcvBuf = NULL;
      break;
  }
}

/***********************************************************************/
/*  pppFsmOpen: Process administrative Open event                      */
/*                                                                     */
/***********************************************************************/
void pppFsmOpen(FSM *fsm)
{
  switch (fsm->state)
  {
    case fsmINITIAL:
      fsm->state = fsmSTARTING;
      break;

    case fsmCLOSED:
      fsm->pdc->starting(fsm);
      fsm->rcn_cnt = 0;
      set_retry_count(fsm, fsm->pdc->req_limit);
      fsm->state = fsmReqSent;
      fsmSendReq(fsm);
      break;

    case fsmCLOSING:
      fsm->state = fsmSTOPPING;
      break;

    case fsmSTARTING:
    case fsmSTOPPED:
    case fsmSTOPPING:
    case fsmReqSent:
    case fsmAckRcvd:
    case fsmAckSent:
    case fsmOPENED:
      /* Nothing to do */
      break;
  }
}

/***********************************************************************/
/*    pppFsmUp: Process Up event from lower layer or interface         */
/*                                                                     */
/***********************************************************************/
void pppFsmUp(FSM *fsm)
{
  switch (fsm->state)
  {
    case fsmINITIAL:
      fsm->state = fsmCLOSED;
      break;

    case fsmSTARTING:
      fsm->pdc->starting(fsm);
      set_retry_count(fsm, fsm->pdc->req_limit);
      fsm->rcn_cnt = 0;
      fsm->state = fsmReqSent;
      fsmSendReq(fsm);
      break;

    case fsmCLOSED:
    case fsmSTOPPED:
    case fsmCLOSING:
    case fsmSTOPPING:
    case fsmReqSent:
    case fsmAckRcvd:
    case fsmAckSent:
    case fsmOPENED:
#if PPP_TRACE
      pppFsmLog(fsm, "Illegal transition");
#endif
      break;
  }
}

/***********************************************************************/
/*  pppFsmDown: Process Down event from physical interface or lower    */
/*              protocol                                               */
/*                                                                     */
/***********************************************************************/
void pppFsmDown(FSM *fsm)
{
#if PPP_TRACE
  pppFsmLog(fsm, "Down");
#endif

  switch (fsm->state)
  {
    case fsmINITIAL:
    case fsmSTARTING:
#if PPP_TRACE
      pppFsmLog(fsm, "Illegal transition");
#endif
      break;

    case fsmCLOSED:
    case fsmCLOSING:
      fsm->state = fsmINITIAL;
      NetTimerStop(&fsm->timer);
      break;

    case fsmOPENED:
      fsm->pdc->down(fsm);
      /*lint -fallthrough */

    case fsmSTOPPING:
    case fsmReqSent:
    case fsmAckRcvd:
    case fsmAckSent:
      fsm->state = fsmSTARTING;
      NetTimerStop(&fsm->timer);
      break;

    case fsmSTOPPED:
      fsm->state = fsmSTARTING;
      break;
  }
}

/***********************************************************************/
/* fsmLcpClose: Close the connection                                   */
/*                                                                     */
/***********************************************************************/
void fsmLcpClose(void)
{
  FSM *fsm = &Ppp->fsm[kLCP];

#if PPP_TRACE
  pppFsmLog(fsm, "Close");
#endif

  switch (fsm->state)
  {
    case fsmINITIAL:
    case fsmCLOSED:
    case fsmCLOSING:
      break;

    case fsmSTARTING:
      fsm->pdc->finished(fsm);
      break;

    case fsmSTOPPED:
    case fsmSTOPPING:
      --fsm->state;
      break;

    case fsmOPENED:
      fsm->pdc->down(fsm);
      /*lint -fallthrough */

    case fsmReqSent:
    case fsmAckRcvd:
    case fsmAckSent:
      set_retry_count(fsm, fsm->pdc->terminate_limit);
      fsm->state = fsmCLOSING;
      send_term_req(fsm);
      break;
  }
}

/***********************************************************************/
/*  pppFsmInit: Initialize FSM for particular protocol                 */
/*                                                                     */
/***********************************************************************/
void pppFsmInit(FSM *fsm)
{
  /*-------------------------------------------------------------------*/
  /* Initialize timer.                                                 */
  /*-------------------------------------------------------------------*/
  fsm->timer.action = fsm_timeout;
  fsm->timer.object = fsm;
  INIT_TMR(fsm->timer);
}

#endif /* MAX_PPP_INTF */