inet_chksum.c File Reference

#include "lwip/opt.h"
#include "lwip/inet_chksum.h"
#include "lwip/def.h"
#include <stddef.h>
#include <string.h>

Include dependency graph for inet_chksum.c:

Go to the source code of this file.

Macros
#define	LWIP_CHKSUM   lwip_standard_chksum
#define	LWIP_CHKSUM_ALGORITHM   2

Functions
static u16_t ICACHE_FLASH_ATTR	lwip_standard_chksum (void *dataptr, int len)
u16_t	inet_chksum_pseudo (struct pbuf *p, ip_addr_t *src, ip_addr_t *dest, u8_t proto, u16_t proto_len)
u16_t	inet_chksum_pseudo_partial (struct pbuf *p, ip_addr_t *src, ip_addr_t *dest, u8_t proto, u16_t proto_len, u16_t chksum_len)
u16_t	inet_chksum (void *dataptr, u16_t len)
u16_t	inet_chksum_pbuf (struct pbuf *p)

Detailed Description

Incluse internet checksum functions.

Definition in file inet_chksum.c.

Macro Definition Documentation

LWIP_CHKSUM

#define LWIP_CHKSUM   lwip_standard_chksum

Definition at line 59 of file inet_chksum.c.

Referenced by inet_chksum(), inet_chksum_pbuf(), inet_chksum_pseudo(), and inet_chksum_pseudo_partial().

LWIP_CHKSUM_ALGORITHM

#define LWIP_CHKSUM_ALGORITHM   2

Definition at line 61 of file inet_chksum.c.

Function Documentation

inet_chksum()

u16_t inet_chksum	(	void *	dataptr,
		u16_t	len
	)

Definition at line 396 of file inet_chksum.c.

References LWIP_CHKSUM.

Referenced by ip_input(), and ip_output_if().

{
  return ~LWIP_CHKSUM(dataptr, len);
}

Here is the caller graph for this function:

inet_chksum_pbuf()

u16_t inet_chksum_pbuf

(

struct pbuf *

p

)

Calculate a checksum over a chain of pbufs (without pseudo-header, much like inet_chksum only pbufs are used).

Parameters

p	pbuf chain over that the checksum should be calculated

Returns

checksum (as u16_t) to be saved directly in the protocol header

Definition at line 409 of file inet_chksum.c.

References FOLD_U32T, pbuf::len, LWIP_CHKSUM, MEMCPY, pbuf::next, NULL, pbuf::payload, and SWAP_BYTES_IN_WORD.

{
  u32_t acc;
  struct pbuf *q;
  u8_t swapped;

  acc = 0;
  swapped = 0;
  for(q = p; q != NULL; q = q->next) {
    acc += LWIP_CHKSUM(q->payload, q->len);
    acc = FOLD_U32T(acc);
    if (q->len % 2 != 0) {
      swapped = 1 - swapped;
      acc = SWAP_BYTES_IN_WORD(acc);
    }
  }

  if (swapped) {
    acc = SWAP_BYTES_IN_WORD(acc);
  }
  return (u16_t)~(acc & 0xffffUL);
}

inet_chksum_pseudo()

u16_t inet_chksum_pseudo	(	struct pbuf *	p,
		ip_addr_t *	src,
		ip_addr_t *	dest,
		u8_t	proto,
		u16_t	proto_len
	)

Definition at line 272 of file inet_chksum.c.

References FOLD_U32T, htons, INET_DEBUG, ip4_addr_get_u32, LWIP_CHKSUM, LWIP_DEBUGF, pbuf::next, NULL, SWAP_BYTES_IN_WORD, and X32_F.

{
  u32_t acc;
  u32_t addr;
  struct pbuf *q;
  u8_t swapped;

  acc = 0;
  swapped = 0;
  /* iterate through all pbuf in chain */
  for(q = p; q != NULL; q = q->next) {
    LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): checksumming pbuf %p (has next %p) \n",
      (void *)q, (void *)q->next));
    acc += LWIP_CHKSUM(q->payload, q->len);
    /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): unwrapped lwip_chksum()=%"X32_F" \n", acc));*/
    /* just executing this next line is probably faster that the if statement needed
       to check whether we really need to execute it, and does no harm */
    acc = FOLD_U32T(acc);
    if (q->len % 2 != 0) {
      swapped = 1 - swapped;
      acc = SWAP_BYTES_IN_WORD(acc);
    }
    /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): wrapped lwip_chksum()=%"X32_F" \n", acc));*/
  }

  if (swapped) {
    acc = SWAP_BYTES_IN_WORD(acc);
  }
  addr = ip4_addr_get_u32(src);
  acc += (addr & 0xffffUL);
  acc += ((addr >> 16) & 0xffffUL);
  addr = ip4_addr_get_u32(dest);
  acc += (addr & 0xffffUL);
  acc += ((addr >> 16) & 0xffffUL);
  acc += (u32_t)htons((u16_t)proto);
  acc += (u32_t)htons(proto_len);

  /* Fold 32-bit sum to 16 bits
     calling this twice is propably faster than if statements... */
  acc = FOLD_U32T(acc);
  acc = FOLD_U32T(acc);
  LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): pbuf chain lwip_chksum()=%"X32_F"\n", acc));
  return (u16_t)~(acc & 0xffffUL);
}

inet_chksum_pseudo_partial()

u16_t inet_chksum_pseudo_partial	(	struct pbuf *	p,
		ip_addr_t *	src,
		ip_addr_t *	dest,
		u8_t	proto,
		u16_t	proto_len,
		u16_t	chksum_len
	)

Definition at line 332 of file inet_chksum.c.

References FOLD_U32T, htons, INET_DEBUG, ip4_addr_get_u32, LWIP_ASSERT, LWIP_CHKSUM, LWIP_DEBUGF, pbuf::next, NULL, SWAP_BYTES_IN_WORD, and X32_F.

{
  u32_t acc;
  u32_t addr;
  struct pbuf *q;
  u8_t swapped;
  u16_t chklen;

  acc = 0;
  swapped = 0;
  /* iterate through all pbuf in chain */
  for(q = p; (q != NULL) && (chksum_len > 0); q = q->next) {
    LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): checksumming pbuf %p (has next %p) \n",
      (void *)q, (void *)q->next));
    chklen = q->len;
    if (chklen > chksum_len) {
      chklen = chksum_len;
    }
    acc += LWIP_CHKSUM(q->payload, chklen);
    chksum_len -= chklen;
    LWIP_ASSERT("delete me", chksum_len < 0x7fff);
    /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): unwrapped lwip_chksum()=%"X32_F" \n", acc));*/
    /* fold the upper bit down */
    acc = FOLD_U32T(acc);
    if (q->len % 2 != 0) {
      swapped = 1 - swapped;
      acc = SWAP_BYTES_IN_WORD(acc);
    }
    /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): wrapped lwip_chksum()=%"X32_F" \n", acc));*/
  }

  if (swapped) {
    acc = SWAP_BYTES_IN_WORD(acc);
  }
  addr = ip4_addr_get_u32(src);
  acc += (addr & 0xffffUL);
  acc += ((addr >> 16) & 0xffffUL);
  addr = ip4_addr_get_u32(dest);
  acc += (addr & 0xffffUL);
  acc += ((addr >> 16) & 0xffffUL);
  acc += (u32_t)htons((u16_t)proto);
  acc += (u32_t)htons(proto_len);

  /* Fold 32-bit sum to 16 bits
     calling this twice is propably faster than if statements... */
  acc = FOLD_U32T(acc);
  acc = FOLD_U32T(acc);
  LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): pbuf chain lwip_chksum()=%"X32_F"\n", acc));
  return (u16_t)~(acc & 0xffffUL);
}

lwip_standard_chksum()

static u16_t ICACHE_FLASH_ATTR lwip_standard_chksum ( void *  dataptr, int  len  )

static

Definition at line 135 of file inet_chksum.c.

References FOLD_U32T, ICACHE_FLASH_ATTR, and SWAP_BYTES_IN_WORD.

{
  u8_t *pb = (u8_t *)dataptr;
  u16_t *ps, t = 0;
  u32_t sum = 0;
  int odd = ((mem_ptr_t)pb & 1);

  /* Get aligned to u16_t */
  if (odd && len > 0) {
    ((u8_t *)&t)[1] = *pb++;
    len--;
  }

  /* Add the bulk of the data */
  ps = (u16_t *)(void *)pb;
  while (len > 1) {
    sum += *ps++;
    len -= 2;
  }

  /* Consume left-over byte, if any */
  if (len > 0) {
    ((u8_t *)&t)[0] = *(u8_t *)ps;
  }

  /* Add end bytes */
  sum += t;

  /* Fold 32-bit sum to 16 bits
     calling this twice is propably faster than if statements... */
  sum = FOLD_U32T(sum);
  sum = FOLD_U32T(sum);

  /* Swap if alignment was odd */
  if (odd) {
    sum = SWAP_BYTES_IN_WORD(sum);
  }

  return (u16_t)sum;
}