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"

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

Macro Definition Documentation

SLIP_END

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

SLIP_ESC

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

SLIP_ESC_END

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

SLIP_ESC_ESC

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

SLIP_MAX_SIZE

#define SLIP_MAX_SIZE   1500

Maximum packet size that is received by this netif

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'.

Enumeration Type Documentation

slipif_recv_state

enum slipif_recv_state

Enumerator
SLIP_RECV_NORMAL
SLIP_RECV_ESCAPE

                       {
    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

{
  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(%"U16_F"): sending %"U16_F" bytes\n", (u16_t)netif->num, 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;
}

Here is the call graph for this function:

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

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

slipif_init()

err_t slipif_init

(

struct netif *

netif

)

SLIP netif initialization

Call the arch specific sio_open and remember the opened device in the state field of the netif.

Parameters

netif

the lwip network interface structure for this slipif

Returns

ERR_OK if serial line could be opened, ERR_MEM if no memory could be allocated, ERR_IF is serial line couldn't be opened

Note

netif->num must contain the number of the serial port to open (0 by default). If netif->state is != NULL, it is interpreted as an u8_t pointer pointing to the serial port number instead of netif->num.

{
  struct slipif_priv *priv;
  u8_t sio_num;
 
  LWIP_DEBUGF(SLIP_DEBUG, ("slipif_init: netif->num=%"U16_F"\n", (u16_t)netif->num));
 
  /* Allocate private data */
  priv = (struct slipif_priv *)mem_malloc(sizeof(struct slipif_priv));
  if (!priv) {
    return ERR_MEM;
  }
 
  netif->name[0] = 's';
  netif->name[1] = 'l';
#if LWIP_IPV4
  netif->output = slipif_output_v4;
#endif /* LWIP_IPV4 */
#if LWIP_IPV6
  netif->output_ip6 = slipif_output_v6;
#endif /* LWIP_IPV6 */
  netif->mtu = SLIP_MAX_SIZE;
 
  /* netif->state or netif->num contain the port number */
  if (netif->state != NULL) {
    sio_num = *(u8_t*)netif->state;
  } else {
    sio_num = netif->num;
  }
  /* Try to open the serial port. */
  priv->sd = sio_open(sio_num);
  if (!priv->sd) {
    /* Opening the serial port failed. */
    mem_free(priv);
    return ERR_IF;
  }
 
  /* Initialize private data */
  priv->p = NULL;
  priv->q = NULL;
  priv->state = SLIP_RECV_NORMAL;
  priv->i = 0;
  priv->recved = 0;
#if SLIP_RX_FROM_ISR
  priv->rxpackets = NULL;
#endif
 
  netif->state = priv;
 
  /* initialize the snmp variables and counters inside the struct netif */
  MIB2_INIT_NETIF(netif, snmp_ifType_slip, SLIP_SIO_SPEED(priv->sd));
 
#if SLIP_USE_RX_THREAD
  /* Create a thread to poll the serial line. */
  sys_thread_new(SLIPIF_THREAD_NAME, slipif_loop_thread, netif,
    SLIPIF_THREAD_STACKSIZE, SLIPIF_THREAD_PRIO);
#endif /* SLIP_USE_RX_THREAD */
  return ERR_OK;
}

Here is the call graph for this function:

slipif_poll()

void slipif_poll

(

struct netif *

netif

)

Polls the serial device and feeds the IP layer with incoming packets.

Parameters

netif

The lwip network interface structure for this slipif

{
  u8_t c;
  struct slipif_priv *priv;
 
  LWIP_ASSERT("netif != NULL", (netif != NULL));
  LWIP_ASSERT("netif->state != NULL", (netif->state != NULL));
 
  priv = (struct slipif_priv *)netif->state;
 
  while (sio_tryread(priv->sd, &c, 1) > 0) {
    slipif_rxbyte_input(netif, c);
  }
}

Here is the call graph for this function: