slipif.c File Reference

#include "netif/slipif.h"
#include "lwip/opt.h"
#include "lwip/def.h"
#include "lwip/pbuf.h"
#include "lwip/stats.h"
#include "lwip/snmp.h"
#include "lwip/sys.h"
#include "lwip/sio.h"

Include dependency graph for slipif.c:

Go to the source code of this file.

Classes
struct	slipif_priv

Macros
#define	SLIP_END   0xC0 /* 0300: start and end of every packet */
#define	SLIP_ESC   0xDB /* 0333: escape start (one byte escaped data follows) */
#define	SLIP_ESC_END   0xDC /* 0334: following escape: original byte is 0xC0 (END) */
#define	SLIP_ESC_ESC   0xDD /* 0335: following escape: original byte is 0xDB (ESC) */
#define	SLIP_MAX_SIZE   1500
#define	SLIP_SIO_SPEED(sio_fd)   0

Enumerations
enum	slipif_recv_state { SLIP_RECV_NORMAL , SLIP_RECV_ESCAPE }

Functions
static err_t	slipif_output (struct netif *netif, struct pbuf *p)
static struct pbuf *	slipif_rxbyte (struct netif *netif, u8_t c)
static void	slipif_rxbyte_input (struct netif *netif, u8_t c)
err_t	slipif_init (struct netif *netif)
void	slipif_poll (struct netif *netif)

Detailed Description

SLIP Interface

Definition in file slipif.c.

Macro Definition Documentation

SLIP_END

#define SLIP_END   0xC0 /* 0300: start and end of every packet */

Definition at line 72 of file slipif.c.

SLIP_ESC

#define SLIP_ESC   0xDB /* 0333: escape start (one byte escaped data follows) */

Definition at line 73 of file slipif.c.

SLIP_ESC_END

#define SLIP_ESC_END   0xDC /* 0334: following escape: original byte is 0xC0 (END) */

Definition at line 74 of file slipif.c.

SLIP_ESC_ESC

#define SLIP_ESC_ESC   0xDD /* 0335: following escape: original byte is 0xDB (ESC) */

Definition at line 75 of file slipif.c.

SLIP_MAX_SIZE

#define SLIP_MAX_SIZE   1500

Maximum packet size that is received by this netif

Definition at line 79 of file slipif.c.

SLIP_SIO_SPEED

#define SLIP_SIO_SPEED

(

sio_fd

)

0

Define this to the interface speed for SNMP (sio_fd is the sio_fd_t returned by sio_open). The default value of zero means 'unknown'.

Definition at line 87 of file slipif.c.

Enumeration Type Documentation

slipif_recv_state

enum slipif_recv_state

Enumerator
SLIP_RECV_NORMAL
SLIP_RECV_ESCAPE

Definition at line 90 of file slipif.c.

                       {
  SLIP_RECV_NORMAL,
  SLIP_RECV_ESCAPE
};

Function Documentation

slipif_output()

static err_t slipif_output ( struct netif *  netif, struct pbuf *  p  )

static

Send a pbuf doing the necessary SLIP encapsulation

Uses the serial layer's sio_send()

Parameters

netif	the lwip network interface structure for this slipif
p	the pbuf chain packet to send

Returns

always returns ERR_OK since the serial layer does not provide return values

Definition at line 116 of file slipif.c.

{
  struct slipif_priv *priv;
  struct pbuf *q;
  u16_t i;
  u8_t c;
 
  LWIP_ASSERT("netif != NULL", (netif != NULL));
  LWIP_ASSERT("netif->state != NULL", (netif->state != NULL));
  LWIP_ASSERT("p != NULL", (p != NULL));
 
  LWIP_DEBUGF(SLIP_DEBUG, ("slipif_output: sending %"U16_F" bytes\n", p->tot_len));
  priv = (struct slipif_priv *)netif->state;
 
  /* Send pbuf out on the serial I/O device. */
  /* Start with packet delimiter. */
  sio_send(SLIP_END, priv->sd);
 
  for (q = p; q != NULL; q = q->next) {
    for (i = 0; i < q->len; i++) {
      c = ((u8_t *)q->payload)[i];
      switch (c) {
        case SLIP_END:
          /* need to escape this byte (0xC0 -> 0xDB, 0xDC) */
          sio_send(SLIP_ESC, priv->sd);
          sio_send(SLIP_ESC_END, priv->sd);
          break;
        case SLIP_ESC:
          /* need to escape this byte (0xDB -> 0xDB, 0xDD) */
          sio_send(SLIP_ESC, priv->sd);
          sio_send(SLIP_ESC_ESC, priv->sd);
          break;
        default:
          /* normal byte - no need for escaping */
          sio_send(c, priv->sd);
          break;
      }
    }
  }
  /* End with packet delimiter. */
  sio_send(SLIP_END, priv->sd);
  return ERR_OK;
}

slipif_rxbyte()

static struct pbuf * slipif_rxbyte ( struct netif *  netif, u8_t  c  )

static

Handle the incoming SLIP stream character by character

Parameters

netif	the lwip network interface structure for this slipif
c	received character (multiple calls to this function will return a complete packet, NULL is returned before - used for polling)

Returns

The IP packet when SLIP_END is received

Definition at line 207 of file slipif.c.

{
  struct slipif_priv *priv;
  struct pbuf *t;
 
  LWIP_ASSERT("netif != NULL", (netif != NULL));
  LWIP_ASSERT("netif->state != NULL", (netif->state != NULL));
 
  priv = (struct slipif_priv *)netif->state;
 
  switch (priv->state) {
    case SLIP_RECV_NORMAL:
      switch (c) {
        case SLIP_END:
          if (priv->recved > 0) {
            /* Received whole packet. */
            /* Trim the pbuf to the size of the received packet. */
            pbuf_realloc(priv->q, priv->recved);
 
            LINK_STATS_INC(link.recv);
 
            LWIP_DEBUGF(SLIP_DEBUG, ("slipif: Got packet (%"U16_F" bytes)\n", priv->recved));
            t = priv->q;
            priv->p = priv->q = NULL;
            priv->i = priv->recved = 0;
            return t;
          }
          return NULL;
        case SLIP_ESC:
          priv->state = SLIP_RECV_ESCAPE;
          return NULL;
        default:
          break;
      } /* end switch (c) */
      break;
    case SLIP_RECV_ESCAPE:
      /* un-escape END or ESC bytes, leave other bytes
         (although that would be a protocol error) */
      switch (c) {
        case SLIP_ESC_END:
          c = SLIP_END;
          break;
        case SLIP_ESC_ESC:
          c = SLIP_ESC;
          break;
        default:
          break;
      }
      priv->state = SLIP_RECV_NORMAL;
      break;
    default:
      break;
  } /* end switch (priv->state) */
 
  /* byte received, packet not yet completely received */
  if (priv->p == NULL) {
    /* allocate a new pbuf */
    LWIP_DEBUGF(SLIP_DEBUG, ("slipif_input: alloc\n"));
    priv->p = pbuf_alloc(PBUF_LINK, (PBUF_POOL_BUFSIZE - PBUF_LINK_HLEN - PBUF_LINK_ENCAPSULATION_HLEN), PBUF_POOL);
 
    if (priv->p == NULL) {
      LINK_STATS_INC(link.drop);
      LWIP_DEBUGF(SLIP_DEBUG, ("slipif_input: no new pbuf! (DROP)\n"));
      /* don't process any further since we got no pbuf to receive to */
      return NULL;
    }
 
    if (priv->q != NULL) {
      /* 'chain' the pbuf to the existing chain */
      pbuf_cat(priv->q, priv->p);
    } else {
      /* p is the first pbuf in the chain */
      priv->q = priv->p;
    }
  }
 
  /* this automatically drops bytes if > SLIP_MAX_SIZE */
  if ((priv->p != NULL) && (priv->recved <= SLIP_MAX_SIZE)) {
    ((u8_t *)priv->p->payload)[priv->i] = c;
    priv->recved++;
    priv->i++;
    if (priv->i >= priv->p->len) {
      /* on to the next pbuf */
      priv->i = 0;
      if (priv->p->next != NULL && priv->p->next->len > 0) {
        /* p is a chain, on to the next in the chain */
        priv->p = priv->p->next;
      } else {
        /* p is a single pbuf, set it to NULL so next time a new
         * pbuf is allocated */
        priv->p = NULL;
      }
    }
  }
  return NULL;
}

Referenced by slipif_rxbyte_input().

slipif_rxbyte_input()

static void slipif_rxbyte_input ( struct netif *  netif, u8_t  c  )

static

Like slipif_rxbyte, but passes completed packets to netif->input

Parameters

netif	The lwip network interface structure for this slipif
c	received character

Definition at line 310 of file slipif.c.

{
  struct pbuf *p;
  p = slipif_rxbyte(netif, c);
  if (p != NULL) {
    if (netif->input(p, netif) != ERR_OK) {
      pbuf_free(p);
    }
  }
}

Referenced by slipif_poll().