pppasync.c

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

    }
  }

  /*-------------------------------------------------------------------*/
  /* Initialize control block (rbuf_size marks block in use).          */
  /*-------------------------------------------------------------------*/
  ppp = &Ppps[PppIndex++];
  ppp->rbuf_size = 1;
  ppp->public.transmit = NULL;
  ppp->public.flags = PPPF_DEAD;
  ppp->phase = pppDEAD;

  /*-------------------------------------------------------------------*/
  /* Release exclusive access and return control block handle.         */
  /*-------------------------------------------------------------------*/
  semPost(Net.IntSem);
  return ppp;
}

/***********************************************************************/
/*     pppOpen: Connect a PPP interface to TargetTCP                   */
/*                                                                     */
/*       Input: pppi = pointer to PPP interface structure              */
/*                                                                     */
/*     Returns: 0 if no errors, else -1                                */
/*                                                                     */
/***********************************************************************/
int pppOpen(pppPublic *pppi)
{
  char *ep;
  PPP ppp = (PPP)pppi;

#if OS_FATAL_CHECK
  /*-------------------------------------------------------------------*/
  /* Verify protocol has been initialized.                             */
  /*-------------------------------------------------------------------*/
  if (!Net.Initialized)
    SysFatalError(ENETDOWN);
#endif

  /*-------------------------------------------------------------------*/
  /* Verify the required callbacks have been provided.                 */
  /*-------------------------------------------------------------------*/
  if ((pppi->connect == NULL) || (pppi->disconnect == NULL) ||
      (pppi->start_tx == NULL))
    goto ppp_add_err;

  /*-------------------------------------------------------------------*/
  /* Ensure flag values are legal.                                     */
  /*-------------------------------------------------------------------*/
  if (pppi->flags & ~(PPPF_DEF_GW | PPPF_TRACE | PPPF_PASSIVE))
    goto ppp_add_err;

  /*-------------------------------------------------------------------*/
  /* Translate flags for accepted options.                             */
  /*-------------------------------------------------------------------*/
  ppp->lcp_accept_opts = 0;
  if (pppi->accept_opts & OPT_MRU)
    ppp->lcp_accept_opts |= LCP_N_MRU;
  if (pppi->accept_opts & OPT_ACCM)
    ppp->lcp_accept_opts |= LCP_N_ACCM;
  if (pppi->accept_opts & OPT_MAGIC)
    ppp->lcp_accept_opts |= LCP_N_MAGIC;
  if (pppi->accept_opts & OPT_PFC)
    ppp->lcp_accept_opts |= LCP_N_PFC;
  if (pppi->accept_opts & OPT_ACFC)
    ppp->lcp_accept_opts |= LCP_N_ACFC;
  if (pppi->accept_opts & (OPT_PAP | OPT_CHAP))
    ppp->lcp_accept_opts |= LCP_N_AUTHENT;

  if (pppi->accept_opts & OPT_ADDR)
    ppp->ipcp_accept_opts |= IPCP_N_ADDRESS;
  if (pppi->accept_opts & OPT_VJHC)
    ppp->ipcp_accept_opts |= IPCP_N_COMPRESS;

  /*-------------------------------------------------------------------*/
  /* Translate flags for requested options.                            */
  /*-------------------------------------------------------------------*/
  ppp->lcp_request_opts = 0;
  if (pppi->request_opts & OPT_MRU)
    ppp->lcp_request_opts |= LCP_N_MRU;
  if (pppi->request_opts & OPT_ACCM)
    ppp->lcp_request_opts |= LCP_N_ACCM;

  if (pppi->request_opts & OPT_MAGIC)
  {
    /*-----------------------------------------------------------------*/
    /* If we request a magic number, required to allow peer to also.   */
    /*-----------------------------------------------------------------*/
    ppp->lcp_request_opts |= LCP_N_MAGIC;
    ppp->lcp_accept_opts  |= LCP_N_MAGIC;
  }

  if (pppi->request_opts & OPT_PFC)
    ppp->lcp_request_opts |= LCP_N_PFC;
  if (pppi->request_opts & OPT_ACFC)
    ppp->lcp_request_opts |= LCP_N_ACFC;
  if (pppi->request_opts & (OPT_PAP | OPT_CHAP))
    ppp->lcp_request_opts |= LCP_N_AUTHENT;
  if (pppi->request_opts & OPT_ADDR)
    ppp->ipcp_request_opts |= IPCP_N_ADDRESS;
  if (pppi->request_opts & OPT_VJHC)
    ppp->ipcp_request_opts |= IPCP_N_COMPRESS;

  /*-------------------------------------------------------------------*/
  /* Ensure MRU request is legal.                                      */
  /*-------------------------------------------------------------------*/
  if ((pppi->mru < LCP_MRU_LO) || (pppi->mru > LCP_MRU_HI))
    goto ppp_add_err;

  /*-------------------------------------------------------------------*/
  /* Ensure MTU request is legal.                                      */
  /*-------------------------------------------------------------------*/
  if (pppi->mtu < LCP_MRU_LO)
    goto ppp_add_err;

  /*-------------------------------------------------------------------*/
  /* Initialize transmitter ACCM with zero and asyncmap assignment.    */
  /*-------------------------------------------------------------------*/
  ppp->tx_accm[1] = ppp->tx_accm[2] = ppp->tx_accm[3] = 0;
  ppp->tx_accm[0] = pppi->asyncmap;

  /*-------------------------------------------------------------------*/
  /* Add PPP_FLAG and PPP_ESCAPE, always transformed in user data.     */
  /*-------------------------------------------------------------------*/
  ppp->tx_accm[PPP_FLAG   >> 5] |= (1 << (PPP_FLAG & 0x1F));
  ppp->tx_accm[PPP_ESCAPE >> 5] |= (1 << (PPP_ESCAPE & 0x1F));

  /*-------------------------------------------------------------------*/
  /* Process the "addtl_esc" characters one at a time.                 */
  /*-------------------------------------------------------------------*/
  for (ep = pppi->addtl_esc; *ep; ++ep)
  {
    uint ch = *ep;
    uint esc_ch = ch ^ PPP_ESCAPE_BIT;
    uint bit = 1 << (ch & 0x1F);

    /*-----------------------------------------------------------------*/
    /* Error if transformed value is also set to be escaped.           */
    /*-----------------------------------------------------------------*/
    if (ppp->tx_accm[esc_ch >> 5] & bit)
      goto ppp_add_err;

    /*-----------------------------------------------------------------*/
    /* Add bit to transmitter's asynchronous control character map.    */
    /*-----------------------------------------------------------------*/
    ppp->tx_accm[ch >> 5] |= bit;
  }

  /*-------------------------------------------------------------------*/
  /* Characters falling below 0x20 are included in the negotiation.    */
  /*-------------------------------------------------------------------*/
  pppi->asyncmap = ppp->tx_accm[0];

  /*-------------------------------------------------------------------*/
  /* Initialize PPP control block values.                              */
  /*-------------------------------------------------------------------*/
  ppp->uart.rbuf = NULL;
  ppp->rx_accm = ACCM_DEFAULT;
  ppp->uart.idle = TRUE;
  ppp->uart.next_char = PPP_FLAG;
  ppp->uart.tx_crc = CRC16_START;
  ppp->uart.escaped = FALSE;
  ppp->uart.hunt = TRUE;
  ppp->dcd_persist = pppi->DCD_timeout;
  ppp->dsr_persist = pppi->DSR_timeout;
  ppp->public.flags &= ~PPPF_DEAD;
  ppp->public.ni.report = ppp_report;
  ppp->public.data_ind = uartDataInd;
  ppp->public.data_req = uartDataReq;
  ppp->rbuf_size = NIMHLEN + PPP_MTU + CRC16_LEN;

  /*-------------------------------------------------------------------*/
  /* Initialize the various layers.                                    */
  /*-------------------------------------------------------------------*/
  lcpInit(ppp);
  chatInit(ppp);
  chapInit(ppp);
  papInit(ppp);
  ipcpInit(ppp);

  /*-------------------------------------------------------------------*/
  /* Schedule PPP initialization and bringup.                          */
  /*-------------------------------------------------------------------*/
  pppAttnReq(pppStart, ppp);

  /*-------------------------------------------------------------------*/
  /* If handler provided, schedule modem signal check.                 */
  /*-------------------------------------------------------------------*/
  if (pppi->sig_check)
  {
    Ppp->timer2.action = pppSigCheck;
    ppp->timer2.object = ppp;
    INIT_TMR(ppp->timer2);
    NetTimerStart(&Ppp->timer2, TICKS_PER_SEC);
  }

  /*-------------------------------------------------------------------*/
  /* Return PPP interface handle.                                      */
  /*-------------------------------------------------------------------*/
  return 0;

  /*-------------------------------------------------------------------*/
  /* Exit point for resource or configuration errors.                  */
  /*-------------------------------------------------------------------*/
ppp_add_err:
  if (ppp->public.report)
    ppp->public.report(ppp, NIE_DOWN);
  NetError(NULL, EFAULT);
  return -1;
}

/***********************************************************************/
/*    pppClose: Close PPP connection                                   */
/*                                                                     */
/*       Input: pppi = PPP interface handle                            */
/*                                                                     */
/***********************************************************************/
void pppClose(pppPublic *pppi)
{
  PPP ppp = (PPP)pppi;

#if OS_FATAL_CHECK
  /*-------------------------------------------------------------------*/
  /* Verify PPP identifier.                                            */
  /*-------------------------------------------------------------------*/
  if (ppp < &Ppps[0] || ppp > &Ppps[MAX_PPP_INTF - 1] || !ppp->rbuf_size)
    SysFatalError(EFAULT);
#endif

  /*-------------------------------------------------------------------*/
  /* Acquire exclusive access to TargetTCP internals.                  */
  /*-------------------------------------------------------------------*/
  semPend(Net.IntSem, WAIT_FOREVER);

  /*-------------------------------------------------------------------*/
  /* Set global PPP channel identifier and shutdown LCP layer.         */
  /*-------------------------------------------------------------------*/
  Ppp = ppp;
  fsmLcpClose();

  /*-------------------------------------------------------------------*/
  /* Release exclusive access to TargetTCP internals.                  */
  /*-------------------------------------------------------------------*/
  semPost(Net.IntSem);
}

/***********************************************************************/
/*     pppFree: Free PPP control block and bring interface down        */
/*                                                                     */
/*       Input: pppi = PPP interface handle                            */
/*                                                                     */
/***********************************************************************/
void pppFree(pppPublic *pppi)
{
  PPP ppp = (PPP)pppi;

#if OS_FATAL_CHECK
  /*-------------------------------------------------------------------*/
  /* Verify PPP identifier.                                            */
  /*-------------------------------------------------------------------*/
  if (ppp < &Ppps[0] || ppp > &Ppps[MAX_PPP_INTF - 1] || !ppp->rbuf_size)
    SysFatalError(EFAULT);
#endif

  /*-------------------------------------------------------------------*/
  /* Acquire exclusive access to TargetTCP internals.                  */
  /*-------------------------------------------------------------------*/
  semPend(Net.IntSem, WAIT_FOREVER);

  /*-------------------------------------------------------------------*/
  /* Ensure PPP network interface is removed from TargetTCP.           */
  /*-------------------------------------------------------------------*/
  pppFinish();

  /*-------------------------------------------------------------------*/
  /* Release exclusive access to TargetTCP internals.                  */
  /*-------------------------------------------------------------------*/
  semPost(Net.IntSem);

  /*-------------------------------------------------------------------*/
  /* Deallocate PPP control block.                                     */
  /*-------------------------------------------------------------------*/
  ppp->rbuf_size = 0;
}

#endif  /* MAX_PPP_INTF */