Commit 77edab64 authored by Ondrej Zajicek's avatar Ondrej Zajicek
Browse files

OSPF: Redesign LSA checksumming 

New LSA checksumming code separates generic Fletcher-16 and OSPF-specific
code and avoids back and forth endianity conversions, making it much more
readable and also several times faster.
parent 30d09eb9

lib/fletcher16.h

0 → 100644
+196 −0
Original line number Diff line number Diff line 
/*

 *	BIRD Library -- Fletcher-16 checksum

 *

 *	(c) 2015 Ondrej Zajicek <santiago@crfreenet.org>

 *	(c) 2015 CZ.NIC z.s.p.o.

 *

 *	Can be freely distributed and used under the terms of the GNU GPL.

 */



/**

 * DOC: Fletcher-16 checksum

 *

 * Fletcher-16 checksum is a position-dependent checksum algorithm used for

 * error-detection e.g. in OSPF LSAs.

 *

 * To generate Fletcher-16 checksum, zero the checksum field in data, initialize

 * the context by fletcher16_init(), process the data by fletcher16_update(),

 * compute the checksum value by fletcher16_final() and store it to the checksum

 * field in data by put_u16() (or other means involving htons() conversion).

 *

 * To verify Fletcher-16 checksum, initialize the context by fletcher16_init(),

 * process the data by fletcher16_update(), compute a passing checksum by

 * fletcher16_compute() and check if it is zero.

 */



#ifndef _BIRD_FLETCHER16_H_

#define _BIRD_FLETCHER16_H_



#include "nest/bird.h"





struct fletcher16_context

{

  int c0, c1;

};





/**

 * fletcher16_init - initialize Fletcher-16 context

 * @ctx: the context

 */

static inline void

fletcher16_init(struct fletcher16_context *ctx)

{

  ctx->c0 = ctx->c1 = 0;

}



/**

 * fletcher16_update - process data to Fletcher-16 context

 * @ctx: the context

 * @buf: data buffer

 * @len: data length

 *

 * fletcher16_update() reads data from the buffer @buf and updates passing sums

 * in the context @ctx. It may be used multiple times for multiple blocks of

 * checksummed data.

 */

static inline void

fletcher16_update(struct fletcher16_context *ctx, const u8* buf, int len)

{

  /*

   * The Fletcher-16 sum is essentially a sequence of

   * ctx->c1 += ctx->c0 += *buf++, modulo 255.

   *

   * In the inner loop, we eliminate modulo operation and we do some loop

   * unrolling. MODX is the maximal number of steps that can be done without

   * modulo before overflow, see RFC 1008 for details. We use a bit smaller

   * value to cover for initial steps due to loop unrolling.

   */



#define MODX 4096



  int blen, i;



  blen = len % 4;

  len -= blen;



  for (i = 0; i < blen; i++)

    ctx->c1 += ctx->c0 += *buf++;



  do {

    blen = MIN(len, MODX);

    len -= blen;



    for (i = 0; i < blen; i += 4)

    {

      ctx->c1 += ctx->c0 += *buf++;

      ctx->c1 += ctx->c0 += *buf++;

      ctx->c1 += ctx->c0 += *buf++;

      ctx->c1 += ctx->c0 += *buf++;

    }



    ctx->c0 %= 255;

    ctx->c1 %= 255;



  } while (len);

}





/**

 * fletcher16_update_n32 - process data to Fletcher-16 context, with endianity adjustment

 * @ctx: the context

 * @buf: data buffer

 * @len: data length

 *

 * fletcher16_update_n32() works like fletcher16_update(), except it applies

 * 32-bit host/network endianity swap to the data before they are processed.

 * I.e., it assumes that the data is a sequence of u32 that must be converted by

 * ntohl() or htonl() before processing. The @buf need not to be aligned, but

 * its length (@len) must be multiple of 4. Note that on big endian systems the

 * host endianity is the same as the network endianity, therefore there is no

 * endianity swap.

 */

static inline void

fletcher16_update_n32(struct fletcher16_context *ctx, const u8* buf, int len)

{

  /* See fletcher16_update() for details */



  int blen, i;



  do {

    blen = MIN(len, MODX);

    len -= blen;



    for (i = 0; i < blen; i += 4)

    {

#ifdef CPU_BIG_ENDIAN

      ctx->c1 += ctx->c0 += *buf++;

      ctx->c1 += ctx->c0 += *buf++;

      ctx->c1 += ctx->c0 += *buf++;

      ctx->c1 += ctx->c0 += *buf++;

#else

      ctx->c1 += ctx->c0 += buf[3];

      ctx->c1 += ctx->c0 += buf[2];

      ctx->c1 += ctx->c0 += buf[1];

      ctx->c1 += ctx->c0 += buf[0];

      buf += 4;

#endif

    }



    ctx->c0 %= 255;

    ctx->c1 %= 255;



  } while (len);

}



/**

 * fletcher16_final - compute final Fletcher-16 checksum value

 * @ctx: the context

 * @len: total data length

 * @pos: offset in data where the checksum will be stored

 *

 * fletcher16_final() computes the final checksum value and returns it.

 * The caller is responsible for storing it in the appropriate position.

 * The checksum value depends on @len and @pos, but only their difference

 * (i.e. the offset from the end) is significant.

 *

 * The checksum value is represented as u16, although it is defined as two

 * consecutive bytes. We treat them as one u16 in big endian / network order.

 * I.e., the returned value is in the form that would be returned by get_u16()

 * from the checksum field in the data buffer, therefore the caller should use

 * put_u16() or an explicit host-to-network conversion when storing it to the

 * checksum field in the data buffer.

 *

 * Note that the returned checksum value is always nonzero.

 */

static inline u16

fletcher16_final(struct fletcher16_context *ctx, int len, int pos)

{

  int x = ((len - pos - 1) * ctx->c0 - ctx->c1) % 255;

  if (x <= 0)

    x += 255;



  int y = 510 - ctx->c0 - x;

  if (y > 255)

    y -= 255;



  return (x << 8) | y;

}





/**

 * fletcher16_compute - compute Fletcher-16 sum for verification

 * @ctx: the context

 *

 * fletcher16_compute() returns a passing Fletcher-16 sum for processed data.

 * If the data contains the proper Fletcher-16 checksum value, the returned

 * value is zero.

 */

static inline u16

fletcher16_compute(struct fletcher16_context *ctx)

{

  return (ctx->c0 << 8) | ctx->c1;

}



#endif

proto/ospf/lsalib.c

+23 −126
Original line number Diff line number Diff line
@@ -2,14 +2,15 @@ 
 *	BIRD -- OSPF

 *

 *	(c) 1999--2004 Ondrej Filip <feela@network.cz>

 *	(c) 2009--2014 Ondrej Zajicek <santiago@crfreenet.org>

 *	(c) 2009--2014 CZ.NIC z.s.p.o.

 *	(c) 2009--2015 Ondrej Zajicek <santiago@crfreenet.org>

 *	(c) 2009--2015 CZ.NIC z.s.p.o.

 *

 *	Can be freely distributed and used under the terms of the GNU GPL.

 */



#include "ospf.h"



#include "lib/fletcher16.h"



#ifndef CPU_BIG_ENDIAN

void
@@ -150,145 +151,41 @@ lsa_get_type_domain_(u32 itype, struct ospf_iface *ifa, u32 *otype, u32 *domain) 
}







/*

void

buf_dump(const char *hdr, const byte *buf, int blen)

{

  char b2[1024];

  char *bp;

  int first = 1;

  int i;



  const char *lhdr = hdr;



  bp = b2;

  for(i = 0; i < blen; i++)

    {

      if ((i > 0) && ((i % 16) == 0))

	{

	      *bp = 0;

	      log(L_WARN "%s\t%s", lhdr, b2);

	      lhdr = "";

	      bp = b2;

	}



      bp += snprintf(bp, 1022, "%02x ", buf[i]);



    }



  *bp = 0;

  log(L_WARN "%s\t%s", lhdr, b2);

}

*/



#define MODX 4102		/* larges signed value without overflow */



/* Fletcher Checksum -- Refer to RFC1008. */

#define MODX                 4102

#define LSA_CHECKSUM_OFFSET    15



/* FIXME This is VERY uneficient, I have huge endianity problems */

void

lsasum_calculate(struct ospf_lsa_header *h, void *body)

lsa_generate_checksum(struct ospf_lsa_header *lsa, const u8 *body)

{

  u16 length = h->length;



  //  log(L_WARN "Checksum %R %R %d start (len %d)", h->id, h->rt, h->type, length);

  lsa_hton_hdr(h, h);

  lsa_hton_body1(body, length - sizeof(struct ospf_lsa_header));

  struct fletcher16_context ctx;

  struct ospf_lsa_header hdr;

  u16 len = lsa->length;



  /*

  char buf[1024];

  memcpy(buf, h, sizeof(struct ospf_lsa_header));

  memcpy(buf + sizeof(struct ospf_lsa_header), body, length - sizeof(struct ospf_lsa_header));

  buf_dump("CALC", buf, length);

   * lsa and body are in the host order, we need to compute Fletcher-16 checksum

   * for data in the network order. We also skip the initial age field.

   */



  (void) lsasum_check(h, body, 1);



  //  log(L_WARN "Checksum result %4x", h->checksum);

  lsa_hton_hdr(lsa, &hdr);

  hdr.checksum = 0;



  lsa_ntoh_hdr(h, h);

  lsa_ntoh_body1(body, length - sizeof(struct ospf_lsa_header));

  fletcher16_init(&ctx);

  fletcher16_update(&ctx, (u8 *) &hdr + 2, sizeof(struct ospf_lsa_header) - 2);

  fletcher16_update_n32(&ctx, body, len - sizeof(struct ospf_lsa_header));

  lsa->checksum = fletcher16_final(&ctx, len, OFFSETOF(struct ospf_lsa_header, checksum));

}



/*

 * Calculates the Fletcher checksum of an OSPF LSA.

 *

 * If 'update' is non-zero, the checkbytes (X and Y in RFC905) are calculated

 * and the checksum field in the header is updated. The return value is the

 * checksum as placed in the header (in network byte order).

 *

 * If 'update' is zero, only C0 and C1 are calculated and the header is kept

 * intact. The return value is a combination of C0 and C1; if the return value

 * is exactly zero the checksum is considered valid, any non-zero value is

 * invalid.

 *

 * Note that this function expects the input LSA to be in network byte order.

 */

u16

lsasum_check(struct ospf_lsa_header *h, void *body, int update)

{

  u8 *sp, *ep, *p, *q, *b;

  int c0 = 0, c1 = 0;

  int x, y;

  u16 length;



  b = body;

  sp = (char *) h;

  sp += 2; /* Skip Age field */

  length = ntohs(h->length) - 2;

  if (update) h->checksum = 0;



  for (ep = sp + length; sp < ep; sp = q)

  {				/* Actually MODX is very large, do we need the for-cyclus? */

    q = sp + MODX;

    if (q > ep)

      q = ep;

    for (p = sp; p < q; p++)

lsa_verify_checksum(const void *lsa_n, int lsa_len)

{

      /*

       * I count with bytes from header and than from body

       * but if there is no body, it's appended to header

       * (probably checksum in update receiving) and I go on

       * after header

       */

      if ((b == NULL) || (p < (u8 *) (h + 1)))

      {

	c0 += *p;

      }

      else

      {

	c0 += *(b + (p - (u8 *) (h + 1)));

      }

  struct fletcher16_context ctx;



      c1 += c0;

    }

    c0 %= 255;

    c1 %= 255;

  }

  /* The whole LSA is at lsa_n in net order, we just skip initial age field */



  if (!update) {

    /*

     * When testing the checksum, we don't need to calculate x and y. The

     * checksum passes if c0 and c1 are both 0.

     */

    return (c0 << 8) | (c1 & 0xff);

  }

  fletcher16_init(&ctx);

  fletcher16_update(&ctx, (u8 *) lsa_n + 2, lsa_len - 2);



  x = (int)((length - LSA_CHECKSUM_OFFSET) * c0 - c1) % 255;

  if (x <= 0)

    x += 255;

  y = 510 - c0 - x;

  if (y > 255)

    y -= 255;



  ((u8 *) & h->checksum)[0] = x;

  ((u8 *) & h->checksum)[1] = y;

  return h->checksum;

  return fletcher16_compute(&ctx) == 0;

}





int

lsa_comp(struct ospf_lsa_header *l1, struct ospf_lsa_header *l2)

			/* Return codes from point of view of l1 */

proto/ospf/lsalib.h

+2 −2
Original line number Diff line number Diff line
@@ -46,9 +46,9 @@ static inline u32 lsa_get_etype(struct ospf_lsa_header *h, struct ospf_proto *p) 




int lsa_flooding_allowed(u32 type, u32 domain, struct ospf_iface *ifa);

void lsa_generate_checksum(struct ospf_lsa_header *lsa, const u8 *body);

u16 lsa_verify_checksum(const void *lsa_n, int lsa_len);



void lsasum_calculate(struct ospf_lsa_header *header, void *body);

u16 lsasum_check(struct ospf_lsa_header *h, void *body, int update);

#define CMP_NEWER 1

#define CMP_SAME 0

#define CMP_OLDER -1

proto/ospf/lsupd.c

+2 −2
Original line number Diff line number Diff line
@@ -530,8 +530,8 @@ ospf_receive_lsupd(struct ospf_packet *pkt, struct ospf_iface *ifa, 
    DBG("Update Type: %04x, Id: %R, Rt: %R, Sn: 0x%08x, Age: %u, Sum: %u\n",

	lsa_type, lsa.id, lsa.rt, lsa.sn, lsa.age, lsa.checksum);



    /* RFC 2328 13. (1) - validate LSA checksum */

    if ((lsa_n->checksum == 0) || (lsasum_check(lsa_n, NULL, 0) != 0))

    /* RFC 2328 13. (1) - verify LSA checksum */

    if ((lsa_n->checksum == 0) || !lsa_verify_checksum(lsa_n, lsa_len))

      SKIP("invalid checksum");



    /* RFC 2328 13. (2) */

proto/ospf/topology.c

+3 −3
Original line number Diff line number Diff line
@@ -129,7 +129,7 @@ ospf_advance_lsa(struct ospf_proto *p, struct top_hash_entry *en, struct ospf_ls 
      en->lsa.age = 0;

      en->init_age = 0;

      en->inst_time = now;

      lsasum_calculate(&en->lsa, en->lsa_body);

      lsa_generate_checksum(&en->lsa, en->lsa_body);



      OSPF_TRACE(D_EVENTS, "Advancing LSA: Type: %04x, Id: %R, Rt: %R, Seq: %08x",

		 en->lsa_type, en->lsa.id, en->lsa.rt, en->lsa.sn);
@@ -238,7 +238,7 @@ ospf_do_originate_lsa(struct ospf_proto *p, struct top_hash_entry *en, void *lsa 
  en->lsa.age = 0;

  en->init_age = 0;

  en->inst_time = now;

  lsasum_calculate(&en->lsa, en->lsa_body);

  lsa_generate_checksum(&en->lsa, en->lsa_body);



  OSPF_TRACE(D_EVENTS, "Originating LSA: Type: %04x, Id: %R, Rt: %R, Seq: %08x",

	     en->lsa_type, en->lsa.id, en->lsa.rt, en->lsa.sn);
@@ -382,7 +382,7 @@ ospf_refresh_lsa(struct ospf_proto *p, struct top_hash_entry *en) 
  en->lsa.age = 0;

  en->init_age = 0;

  en->inst_time = now;

  lsasum_calculate(&en->lsa, en->lsa_body);

  lsa_generate_checksum(&en->lsa, en->lsa_body);

  ospf_flood_lsa(p, en, NULL);

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE