pppasync.c

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

/***********************************************************************/
/*                                                                     */
/*   Module:  tcp_ip/ppp/pppasync.c                                    */
/*   Release: 2001.3                                                   */
/*   Version: 2001.0                                                   */
/*   Purpose: Asynchronous PPP framer                                  */
/*                                                                     */
/*---------------------------------------------------------------------*/
/*                                                                     */
/*               Copyright 2001, Blunk Microsystems                    */
/*                      ALL RIGHTS RESERVED                            */
/*                                                                     */
/*   Licensees have the non-exclusive right to use, modify, or extract */
/*   this computer program for software development at a single site.  */
/*   This program may be resold or disseminated in executable format   */
/*   only. The source code may not be redistributed or resold.         */
/*                                                                     */
/***********************************************************************/
#include "pppp.h"

#if MAX_PPP_INTF
/***********************************************************************/
/* Symbol Definitions                                                  */
/***********************************************************************/
#define DEBUG           0
#define ACCM_DEFAULT    0xFFFFFFFF
#define CRC16_START     0xFFFF  /* starting FCS bit string */
#define CRC16_FINAL     0xF0B8  /* summed over frame and sender CRC */
#define SP_CHAR         0x20
#define PPP_MAX_HDR     4

/*
** PPP special character codes
*/
#define PPP_ESCAPE      0x7D    /* escapes special chars (0x7D, 0x7E) */
#define PPP_ESCAPE_BIT  0x20    /* XORed with special chars in data */

/***********************************************************************/
/* Macro Definitions                                                   */
/***********************************************************************/
#define pppfcs(fcs, c)  ((fcs >> 8) ^ FcsTab[(ui8)(fcs ^ c)])

/***********************************************************************/
/* Type Definitions                                                    */
/***********************************************************************/

/***********************************************************************/
/* Global Variable Definitions                                         */
/***********************************************************************/
static struct PppCB Ppps[MAX_PPP_INTF];
static int PppIndex;

/***********************************************************************/
/* Constant Data Definitions                                           */
/***********************************************************************/
/*
** FCS Lookup Table
*/
static const ui16 FcsTab[256] =
{
  0x0000, 0x1189, 0x2312, 0x329B, 0x4624, 0x57AD, 0x6536, 0x74BF,
  0x8C48, 0x9DC1, 0xAF5A, 0xBED3, 0xCA6C, 0xDBE5, 0xE97E, 0xF8F7,
  0x1081, 0x0108, 0x3393, 0x221A, 0x56A5, 0x472C, 0x75B7, 0x643E,
  0x9CC9, 0x8D40, 0xBFDB, 0xAE52, 0xDAED, 0xCB64, 0xF9FF, 0xE876,
  0x2102, 0x308B, 0x0210, 0x1399, 0x6726, 0x76AF, 0x4434, 0x55BD,
  0xAD4A, 0xBCC3, 0x8E58, 0x9FD1, 0xEB6E, 0xFAE7, 0xC87C, 0xD9F5,
  0x3183, 0x200A, 0x1291, 0x0318, 0x77A7, 0x662E, 0x54B5, 0x453C,
  0xBDCB, 0xAC42, 0x9ED9, 0x8F50, 0xFBEF, 0xEA66, 0xD8FD, 0xC974,
  0x4204, 0x538D, 0x6116, 0x709F, 0x0420, 0x15A9, 0x2732, 0x36BB,
  0xCE4C, 0xDFC5, 0xED5E, 0xFCD7, 0x8868, 0x99E1, 0xAB7A, 0xBAF3,
  0x5285, 0x430C, 0x7197, 0x601E, 0x14A1, 0x0528, 0x37B3, 0x263A,
  0xDECD, 0xCF44, 0xFDDF, 0xEC56, 0x98E9, 0x8960, 0xBBFB, 0xAA72,
  0x6306, 0x728F, 0x4014, 0x519D, 0x2522, 0x34AB, 0x0630, 0x17B9,
  0xEF4E, 0xFEC7, 0xCC5C, 0xDDD5, 0xA96A, 0xB8E3, 0x8A78, 0x9BF1,
  0x7387, 0x620E, 0x5095, 0x411C, 0x35A3, 0x242A, 0x16B1, 0x0738,
  0xFFCF, 0xEE46, 0xDCDD, 0xCD54, 0xB9EB, 0xA862, 0x9AF9, 0x8B70,
  0x8408, 0x9581, 0xA71A, 0xB693, 0xC22C, 0xD3A5, 0xE13E, 0xF0B7,
  0x0840, 0x19C9, 0x2B52, 0x3ADB, 0x4E64, 0x5FED, 0x6D76, 0x7CFF,
  0x9489, 0x8500, 0xB79B, 0xA612, 0xD2AD, 0xC324, 0xF1BF, 0xE036,
  0x18C1, 0x0948, 0x3BD3, 0x2A5A, 0x5EE5, 0x4F6C, 0x7DF7, 0x6C7E,
  0xA50A, 0xB483, 0x8618, 0x9791, 0xE32E, 0xF2A7, 0xC03C, 0xD1B5,
  0x2942, 0x38CB, 0x0A50, 0x1BD9, 0x6F66, 0x7EEF, 0x4C74, 0x5DFD,
  0xB58B, 0xA402, 0x9699, 0x8710, 0xF3AF, 0xE226, 0xD0BD, 0xC134,
  0x39C3, 0x284A, 0x1AD1, 0x0B58, 0x7FE7, 0x6E6E, 0x5CF5, 0x4D7C,
  0xC60C, 0xD785, 0xE51E, 0xF497, 0x8028, 0x91A1, 0xA33A, 0xB2B3,
  0x4A44, 0x5BCD, 0x6956, 0x78DF, 0x0C60, 0x1DE9, 0x2F72, 0x3EFB,
  0xD68D, 0xC704, 0xF59F, 0xE416, 0x90A9, 0x8120, 0xB3BB, 0xA232,
  0x5AC5, 0x4B4C, 0x79D7, 0x685E, 0x1CE1, 0x0D68, 0x3FF3, 0x2E7A,
  0xE70E, 0xF687, 0xC41C, 0xD595, 0xA12A, 0xB0A3, 0x8238, 0x93B1,
  0x6B46, 0x7ACF, 0x4854, 0x59DD, 0x2D62, 0x3CEB, 0x0E70, 0x1FF9,
  0xF78F, 0xE606, 0xD49D, 0xC514, 0xB1AB, 0xA022, 0x92B9, 0x8330,
  0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78
};

/***********************************************************************/
/* Local Function Definitions                                          */
/***********************************************************************/

/***********************************************************************/
/*  ppp_report: Translates event callback from upper layer             */
/*                                                                     */
/***********************************************************************/
static void ppp_report(Ni *ni, int event)
{
  /*-------------------------------------------------------------------*/
  /* Set global PPP channel identifier before calling other routines.  */
  /*-------------------------------------------------------------------*/
  Ppp = (PPP)((ui8 *)ni - offsetof(pppPublic, ni));

  /*-------------------------------------------------------------------*/
  /* Intercept down event, pass others on if handler is present.       */
  /*-------------------------------------------------------------------*/
  if (event == NIE_DOWN)
    pppFinish();
  else if (Ppp->public.report)
    Ppp->public.report(Ppp, event);
}

/***********************************************************************/
/* Global Function Definitions                                         */
/***********************************************************************/

/***********************************************************************/
/* uartDataInd: Called by UART driver to report incoming data          */
/*                                                                     */
/*      Inputs: handle = pointer to PPP control block                  */
/*              src = pointer to driver data                           */
/*              length = amount of driver data                         */
/*              increment = amount to add to src after each char       */
/*                                                                     */
/***********************************************************************/
void uartDataInd(void *handle, ui8 *src, int length, int increment)
{
  ui8 ch;
  PPP ppp = handle;

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

  /*-------------------------------------------------------------------*/
  /* If needed, allocate and reset receive buffer.                     */
  /*-------------------------------------------------------------------*/
  if (ppp->uart.rbuf == NULL)
  {
    ppp->uart.rbuf = tcpGetBuf(ppp->rbuf_size);
    if (ppp->uart.rbuf == NULL)
    {
      ppp->uart.hunt = TRUE;
      return;
    }
    goto reset_buffer;
  }

  /*-------------------------------------------------------------------*/
  /* Loop until out of packet data.                                    */
  /*-------------------------------------------------------------------*/
  while (length--)
  {
    /*-----------------------------------------------------------------*/
    /* Read received character and update source pointer.              */
    /*-----------------------------------------------------------------*/
    ch = *src;
    src += increment;

    /*-----------------------------------------------------------------*/
    /* Process non-flag characters.                                    */
    /*-----------------------------------------------------------------*/
    if (ch != PPP_FLAG)
    {
      /*---------------------------------------------------------------*/
      /* In hunt mode, skip characters until flag starts next packet.  */
      /*---------------------------------------------------------------*/
      if (ppp->uart.hunt)
        continue;

      /*---------------------------------------------------------------*/
      /* Drop unexpected control characters.                           */
      /*---------------------------------------------------------------*/
      if (ch < SP_CHAR && (ppp->rx_accm & (1 << ch)))
        continue;

      /*---------------------------------------------------------------*/
      /* Flip bit 5 if escape mode is set.                             */
      /*---------------------------------------------------------------*/
      if (ppp->uart.escaped)
      {
        ch ^= PPP_ESCAPE_BIT;
        ppp->uart.escaped = FALSE;
      }

      /*---------------------------------------------------------------*/
      /* Else set flag if escape character is found.                   */
      /*---------------------------------------------------------------*/
      else if (ch == PPP_ESCAPE)
      {
        ppp->uart.escaped = TRUE;
        continue;
      }

      /*---------------------------------------------------------------*/
      /* If frame too large, enter hunt mode and reset buffer.         */
      /*---------------------------------------------------------------*/
      if (++ppp->uart.received > PPP_MAX_HDR + PPP_MTU + CRC16_LEN)
      {
        ++ppp->public.ni.ierrs;
        vjhc_toss(&ppp->comp);
#if DEBUG
        printf("FRAME TOO LARGE (>%u bytes)\n", PPP_MAX_HDR + PPP_MTU +
               CRC16_LEN);
#endif
        ppp->uart.hunt = TRUE;
        goto reset_buffer;
      }

      /*---------------------------------------------------------------*/
      /* Store character and update FCS.                               */
      /*---------------------------------------------------------------*/
      *ppp->uart.rx_dst++ = ch;
      ppp->uart.rx_crc = pppfcs(ppp->uart.rx_crc, ch);
      continue;
    }

    /*-----------------------------------------------------------------*/
    /* Else character is a flag.                                       */
    /*-----------------------------------------------------------------*/
    else
    {
      /*---------------------------------------------------------------*/
      /* <ESC><FLAG> is frame abort. Enter hunt mode and reset buffer. */
      /*---------------------------------------------------------------*/
      if (ppp->uart.escaped)
      {
        ++ppp->public.ni.ierrs;
        vjhc_toss(&ppp->comp);
#if DEBUG
        printf("AHDLC ABORT, ierrs = %u\n", ppp->public.ni.ierrs);
#endif
        ppp->uart.hunt = TRUE;
        goto reset_buffer;
      }

      /*---------------------------------------------------------------*/
      /* If flag found in hunt mode, clear mode and start new frame.   */
      /*---------------------------------------------------------------*/
      if (ppp->uart.hunt)
      {
        ppp->uart.hunt = FALSE;
        continue;
      }

      /*---------------------------------------------------------------*/
      /* If extra flags are found, ignore them.                        */
      /*---------------------------------------------------------------*/
      if (ppp->uart.received == 0)
        continue;

      /*---------------------------------------------------------------*/
      /* If CRC error, reset buffer and start on next frame.           */
      /*---------------------------------------------------------------*/
      if (ppp->uart.rx_crc != CRC16_FINAL)
      {
        ++ppp->public.ni.ierrs;
        vjhc_toss(&ppp->comp);
        ++ppp->rxChecksum;
#if DEBUG
        printf("AHDLC CRC ERROR, rxChecksum = %u\n", ppp->rxChecksum);
#endif
        goto reset_buffer;
      }

      /*---------------------------------------------------------------*/
      /* If runt frame, reset buffer and continue with next character. */
      /*---------------------------------------------------------------*/
      if (ppp->uart.received <= 2)
      {
        ++ppp->public.ni.ierrs;
        vjhc_toss(&ppp->comp);
#if DEBUG
        printf("AHDLC RUNT (%u bytes)\n", ppp->public.ni.ierrs);
#endif
        goto reset_buffer;
      }

      /*---------------------------------------------------------------*/
      /* Normal end-of-frame. Pass frame to PPP state machine.         */
      /*---------------------------------------------------------------*/