rdChecksum.c

Go to the documentation of this file.

/*
 * rdChecksum.h  - definition of MINOS Rotorooter command functions
 *
 * Author:  rhatcher@fnal.gov    2001-06
 *
 * CVS Tag: "$Id: rdChecksum.c,v 1.1 2003/01/17 21:41:58 rhatcher Exp $"
 *
 */
#include <sys/types.h>

#include "rdChecksum.h"
/*
 *=========================================================================
 * rdxsum_calc(const long* ptr, char version)
 * 
 * Purpose:
 *    Calculate the checksum value
 *
 * Arguments:
 *    ptr:     pointer to the buffer of 32bit words
 *    version: checksum algorithm version (only low 4 bits significant)
 *
 * Return Value:
 *    the calculated checksum
 *=========================================================================
 */
unsigned long rdxsum_calc(const long* ptr, char version)
{
   unsigned long  sum   = 0;
   const long    *begin = ptr + 2;      /* contiguous data starts here */
   const long    *end   = ptr + (*ptr); /* this is one word too far    */
   int            v2    = version & 0x3;

   /* protect against null pointers */
   if (!ptr) return 0;

   /* 
    * By reserving 2 bits at the top we can support 4 possible
    * checksum algorithms, in case we wish to switch at a later
    * time, while still retaining the ability to know which
    * algorithm was used.  Until all are implemented, cascade
    * downward until an existing one is found.
    */
   switch (v2) {
   case 0x3:
      v2 = 0x3;     /* tag with what we used, not requested     */
      /* break; */  /* this version not supported: fall through */
   case 0x2:
      v2 = 0x2;     /* tag with what we used, not requested     */
      /* break; */  /* this version not supported: fall through */
   case 0x1:
      v2 = 0x1 ;    /* tag with what we used, not requested     */
      /* --- add next algorithm here, make break "active"       */
      /* break; */  /* this version not supported: fall through */
   case 0x0:
   default:
      /* the "0" and default algorithm is very simple ...       */
      /* simply add up everything ignoring overflows            */
         
      v2 = 0x0;     /* tag with what we used, not requested     */
      sum = *ptr;   /* prime the pump with the word count       */
      while (begin<end) sum += *begin++;
   }
   /* remove top two bits and replace them with the version */
   return (sum & 0x3fffffff) | ( version << 30 );
}

/*
 *=========================================================================
 * rdxsum_fill(long* ptr, char version)
 * 
 * Purpose:
 *    Fill in the checksum value
 *
 * Arguments:
 *    ptr:     pointer to the buffer of 32bit words
 *    version: checksum algorithm version (only low 4 bits significant)
 *
 * Return Value:
 *    (nothing)
 *=========================================================================
 */
void rdxsum_fill(long* ptr, char version)
{
   /* protect against null pointers */
   if (!ptr) return;

   *(ptr+1) = rdxsum_calc(ptr,version);
}

/*
 *=========================================================================
 * rdxsum_test(const long* ptr)
 * 
 * Purpose:
 *    Test the checksum value
 *
 * Arguments:
 *    ptr:     pointer to the buffer of 32bit words
 *
 * Return Value:
 *    non-zero if there was an mismatch
 *=========================================================================
 */
int rdxsum_test(const long* ptr)
{
   unsigned long stored;
   int version; 

   /* protect against null pointers */
   if (!ptr) return 1;

   stored  = *(ptr+1);
   version = ( 0x3 & ( stored >> 30 ) );
   return stored != rdxsum_calc(ptr,version);
}

---