< draft-eastlake-fnv-11.txt   draft-eastlake-fnv-12.txt >
skipping to change at page 1, line 13 skipping to change at page 1, line 13
Network Working Group Glenn Fowler Network Working Group Glenn Fowler
INTERNET-DRAFT Google INTERNET-DRAFT Google
Intended Status: Informational Landon Curt Noll Intended Status: Informational Landon Curt Noll
Cisco Systems Cisco Systems
Kiem-Phong Vo Kiem-Phong Vo
Google Google
Donald Eastlake Donald Eastlake
Huawei Technologies Huawei Technologies
Tony Hansen Tony Hansen
AT&T Laboratories AT&T Laboratories
Expires: December 15, 2016 June 16, 2016 Expires: June 11, 2016 December 12, 2016
The FNV Non-Cryptographic Hash Algorithm The FNV Non-Cryptographic Hash Algorithm
<draft-eastlake-fnv-11.txt> <draft-eastlake-fnv-12.txt>
Abstract Abstract
FNV (Fowler/Noll/Vo) is a fast, non-cryptographic hash algorithm with FNV (Fowler/Noll/Vo) is a fast, non-cryptographic hash algorithm with
good dispersion. The purpose of this document is to make information good dispersion. The purpose of this document is to make information
on FNV and open source code performing FNV conveniently available to on FNV and open source code performing FNV conveniently available to
the Internet community. the Internet community.
Status of This Memo Status of This Memo
skipping to change at page 2, line 25 skipping to change at page 2, line 25
3. Other Hash Sizes and XOR Folding........................7 3. Other Hash Sizes and XOR Folding........................7
4. Hashing Multiple Values Together........................8 4. Hashing Multiple Values Together........................8
5. FNV Constants...........................................9 5. FNV Constants...........................................9
6. The Source Code........................................11 6. The Source Code........................................11
6.1 FNV-1a C Code.........................................11 6.1 FNV-1a C Code.........................................11
6.1.1 FNV32 Code..........................................15 6.1.1 FNV32 Code..........................................15
6.1.2 FNV64 C Code........................................21 6.1.2 FNV64 C Code........................................21
6.1.3 FNV128 C Code.......................................32 6.1.3 FNV128 C Code.......................................32
6.1.4 FNV256 C Code.......................................44 6.1.4 FNV256 C Code.......................................43
6.1.5 FNV512 C Code.......................................55 6.1.5 FNV512 C Code.......................................55
6.1.6 FNV1024 C Code......................................67 6.1.6 FNV1024 C Code......................................67
6.2 FNV Test Code.........................................79 6.2 FNV Test Code.........................................79
7. Security Considerations................................93 7. Security Considerations................................93
7.1 Why is FNV Non-Cryptographic?.........................93 7.1 Why is FNV Non-Cryptographic?.........................93
7.2 Inducing Collisions...................................94 7.2 Inducing Collisions...................................94
8. IANA Considerations....................................95 8. IANA Considerations....................................95
Normative References......................................95 Normative References......................................95
Informative References....................................95 Informative References....................................95
Acknowledgements..........................................96 Acknowledgements..........................................96
Appendix A: Work Comparison with SHA-1....................97 Appendix A: Work Comparison with SHA-1....................97
Appendix B: Previous IETF Reference to FNV................98 Appendix B: Previous IETF Reference to FNV................98
Appendix C: A Few Test Vectors............................99 Appendix C: A Few Test Vectors............................99
Appendix Z: Change Summary...............................100 Appendix Z: Change Summary...............................100
From -00 to -01..........................................100 From -00 to -01..........................................100
From -01 to -02..........................................100 From -01 to -02..........................................100
From -02 to -03..........................................100 From -02 to -03..........................................100
From -03 to -04..........................................100 From -03 to -04..........................................100
From -04 to -05..........................................101 From -04 to -05..........................................101
From -05 to -06..........................................101 From -05 to -06..........................................101
From -06 to -07 to -08...................................101 From -06 to -07 to -08...................................101
From -08 to -09..........................................101 From -08 to -09..........................................101
From -09 to -10..........................................101 From -09 to -10..........................................101
From -10 to -11..........................................102 From -10 to -11..........................................102
From -11 to -12..........................................102
Author's Address.........................................103 Author's Address.........................................103
INTERNET-DRAFT FNV INTERNET-DRAFT FNV
1. Introduction 1. Introduction
The FNV hash algorithm is based on an idea sent as reviewer comments The FNV hash algorithm is based on an idea sent as reviewer comments
to the [IEEE] POSIX P1003.2 committee by Glenn Fowler and Phong Vo in to the [IEEE] POSIX P1003.2 committee by Glenn Fowler and Phong Vo in
1991. In a subsequent ballot round Landon Curt Noll suggested an 1991. In a subsequent ballot round Landon Curt Noll suggested an
skipping to change at page 17, line 48 skipping to change at page 17, line 48
#ifndef _FNV32_C_ #ifndef _FNV32_C_
#define _FNV32_C_ #define _FNV32_C_
#include "fnv-private.h" #include "fnv-private.h"
#include "FNV32.h" #include "FNV32.h"
/* 32 bit FNV_prime = 2^24 + 2^8 + 0x93 */ /* 32 bit FNV_prime = 2^24 + 2^8 + 0x93 */
#define FNV32prime 0x01000193 #define FNV32prime 0x01000193
#define FNV32basis 0x811C9DC5 #define FNV32basis 0x811C9DC5
#ifdef FNV_BigEndian
/* Local prototype */
static void FNV32reverse ( uint32_t *out, uint32_t hash );
#endif
/* FNV32 hash a zero terminated string not including the zero /* FNV32 hash a zero terminated string not including the zero
*********************************************************************/ *********************************************************************/
int FNV32string ( const char *in, uint32_t * const out ) int FNV32string ( const char *in, uint32_t * const out )
{ {
INTERNET-DRAFT FNV
uint32_t temp; uint32_t temp;
uint8_t ch; uint8_t ch;
if ( in && out ) if ( in && out )
{ {
INTERNET-DRAFT FNV
temp = FNV32basis; temp = FNV32basis;
while ( (ch = *in++) ) while ( (ch = *in++) )
temp = FNV32prime * ( temp ^ ch ); temp = FNV32prime * ( temp ^ ch );
#ifdef FNV_BigEndian #ifdef FNV_BigEndian
FNV32reverse ( out, temp ); FNV32reverse ( out, temp );
#else #else
*out = temp; *out = temp;
#endif #endif
return fnvSuccess; return fnvSuccess;
} }
skipping to change at page 19, line 4 skipping to change at page 18, line 52
return fnvNull; /* Null input pointer */ return fnvNull; /* Null input pointer */
} /* end FNV32block */ } /* end FNV32block */
#ifdef FNV_BigEndian #ifdef FNV_BigEndian
/* Store a Big Endian result back as Little Endian /* Store a Big Endian result back as Little Endian
***************************************************************/ ***************************************************************/
static void FNV32reverse ( uint32_t *out, uint32_t hash ) static void FNV32reverse ( uint32_t *out, uint32_t hash )
{ {
uint32_t temp; uint32_t temp;
INTERNET-DRAFT FNV
temp = hash & 0xFF; temp = hash & 0xFF;
hash >>= 8; hash >>= 8;
temp = ( temp << 8 ) + ( hash & 0xFF ); temp = ( temp << 8 ) + ( hash & 0xFF );
hash >>= 8; hash >>= 8;
INTERNET-DRAFT FNV
temp = ( temp << 8 ) + ( hash & 0xFF ); temp = ( temp << 8 ) + ( hash & 0xFF );
hash >>= 8; hash >>= 8;
*out = ( temp << 8 ) + ( hash & 0xFF ); *out = ( temp << 8 ) + ( hash & 0xFF );
} /* end FNV32reverse */ } /* end FNV32reverse */
#endif /* FNV_BigEndian */ #endif /* FNV_BigEndian */
/*************************************************************** /***************************************************************
* Set of init, input, and output functions below * * Set of init, input, and output functions below *
* to incrementally compute FNV32 * * to incrementally compute FNV32 *
skipping to change at page 20, line 4 skipping to change at page 19, line 51
const void *vin, const void *vin,
long int length ) long int length )
{ {
const uint8_t *in = (const uint8_t*)vin; const uint8_t *in = (const uint8_t*)vin;
uint32_t temp; uint32_t temp;
if ( ctx && in ) if ( ctx && in )
{ {
if ( length < 0 ) if ( length < 0 )
return fnvBadParam; return fnvBadParam;
INTERNET-DRAFT FNV
switch ( ctx->Computed ) switch ( ctx->Computed )
{ {
case FNVinited+FNV32state: case FNVinited+FNV32state:
ctx->Computed = FNVcomputed+FNV32state; ctx->Computed = FNVcomputed+FNV32state;
INTERNET-DRAFT FNV
case FNVcomputed+FNV32state: case FNVcomputed+FNV32state:
break; break;
default: default:
return fnvStateError; return fnvStateError;
} }
for ( temp = ctx->Hash; length > 0; length-- ) for ( temp = ctx->Hash; length > 0; length-- )
temp = FNV32prime * ( temp ^ *in++ ); temp = FNV32prime * ( temp ^ *in++ );
ctx->Hash = temp; ctx->Hash = temp;
return fnvSuccess; return fnvSuccess;
} }
skipping to change at page 21, line 4 skipping to change at page 20, line 53
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
} /* end FNV32stringin */ } /* end FNV32stringin */
/* return hash /* return hash
***************************************************************/ ***************************************************************/
int FNV32result ( FNV32context * const ctx, int FNV32result ( FNV32context * const ctx,
uint32_t * const out ) uint32_t * const out )
{ {
INTERNET-DRAFT FNV
if ( ctx && out ) if ( ctx && out )
{ {
if ( ctx->Computed != FNVcomputed+FNV32state ) if ( ctx->Computed != FNVcomputed+FNV32state )
return fnvStateError; return fnvStateError;
INTERNET-DRAFT FNV
ctx->Computed = FNVemptied+FNV32state; ctx->Computed = FNVemptied+FNV32state;
#ifdef FNV_BigEndian #ifdef FNV_BigEndian
FNV32reverse ( out, ctx->Hash ); FNV32reverse ( out, ctx->Hash );
#else #else
*out = ctx->Hash; *out = ctx->Hash;
#endif #endif
ctx->Hash = 0; ctx->Hash = 0;
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
skipping to change at page 22, line 4 skipping to change at page 21, line 51
* non-cryptographic hash algorithm. * non-cryptographic hash algorithm.
*/ */
#include "FNVconfig.h" #include "FNVconfig.h"
#include <stdint.h> #include <stdint.h>
#define FNV64size (64/8) #define FNV64size (64/8)
/* If you do not have the ISO standard stdint.h header file, then you /* If you do not have the ISO standard stdint.h header file, then you
* must typedef the following types: * must typedef the following types:
INTERNET-DRAFT FNV
* *
* type meaning * type meaning
* uint64_t unsigned 64 bit integer (ifdef FNV_64bitIntegers) * uint64_t unsigned 64 bit integer (ifdef FNV_64bitIntegers)
* uint32_t unsigned 32 bit integer * uint32_t unsigned 32 bit integer
INTERNET-DRAFT FNV
* uint16_t unsigned 16 bit integer * uint16_t unsigned 16 bit integer
* uint8_t unsigned 8 bit integer (i.e., unsigned char) * uint8_t unsigned 8 bit integer (i.e., unsigned char)
*/ */
#ifndef _FNV_ErrCodes_ #ifndef _FNV_ErrCodes_
#define _FNV_ErrCodes_ #define _FNV_ErrCodes_
/********************************************************************* /*********************************************************************
* All FNV functions provided return as integer as follows: * All FNV functions provided return as integer as follows:
* 0 -> success * 0 -> success
* >0 -> error as listed below * >0 -> error as listed below
skipping to change at page 23, line 4 skipping to change at page 22, line 53
} FNV64context; } FNV64context;
#endif /* FNV_64bitIntegers */ #endif /* FNV_64bitIntegers */
/* /*
* Function Prototypes * Function Prototypes
* FNV64string: hash a zero terminated string not including * FNV64string: hash a zero terminated string not including
* the terminating zero * the terminating zero
* FNV64block: FNV64 hash a specified length byte vector * FNV64block: FNV64 hash a specified length byte vector
* FNV64init: initializes an FNV64 context * FNV64init: initializes an FNV64 context
INTERNET-DRAFT FNV
* FNV64initBasis: initializes an FNV64 context with a * FNV64initBasis: initializes an FNV64 context with a
* provided basis * provided basis
* FNV64blockin: hash in a specified length byte vector * FNV64blockin: hash in a specified length byte vector
* FNV64stringin: hash in a zero terminated string not * FNV64stringin: hash in a zero terminated string not
INTERNET-DRAFT FNV
* incluing the zero * incluing the zero
* FNV64result: returns the hash value * FNV64result: returns the hash value
* *
* Hash is returned as a 64-bit integer if supported, otherwise * Hash is returned as a 64-bit integer if supported, otherwise
* as a vector of 8-bit integers * as a vector of 8-bit integers
*/ */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
skipping to change at page 24, line 4 skipping to change at page 23, line 53
const uint8_t basis[FNV64size] ); const uint8_t basis[FNV64size] );
extern int FNV64result ( FNV64context * const, extern int FNV64result ( FNV64context * const,
uint8_t out[FNV64size] ); uint8_t out[FNV64size] );
#endif /* FNV_64bitIntegers */ #endif /* FNV_64bitIntegers */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _FNV64_H_ */ #endif /* _FNV64_H_ */
INTERNET-DRAFT FNV
<CODE ENDS> <CODE ENDS>
<CODE BEGINS> <CODE BEGINS>
/***************************** FNV64.c ******************************/ /***************************** FNV64.c ******************************/
INTERNET-DRAFT FNV
/******************** See RFC NNNN for details **********************/ /******************** See RFC NNNN for details **********************/
/* Copyright (c) 2016 IETF Trust and the persons identified as /* Copyright (c) 2016 IETF Trust and the persons identified as
* authors of the code. All rights reserved. * authors of the code. All rights reserved.
* See fnv-private.h for terms of use and redistribution. * See fnv-private.h for terms of use and redistribution.
*/ */
/* This file implements the FNV (Fowler, Noll, Vo) non-cryptographic /* This file implements the FNV (Fowler, Noll, Vo) non-cryptographic
* hash function FNV-1a for 64-bit hashes. * hash function FNV-1a for 64-bit hashes.
*/ */
skipping to change at page 24, line 31 skipping to change at page 24, line 27
#define _FNV64_C_ #define _FNV64_C_
#include "fnv-private.h" #include "fnv-private.h"
#include "FNV64.h" #include "FNV64.h"
/******************************************************************** /********************************************************************
* START VERSION FOR WHEN YOU HAVE 64 BIT ARITHMETIC * * START VERSION FOR WHEN YOU HAVE 64 BIT ARITHMETIC *
********************************************************************/ ********************************************************************/
#ifdef FNV_64bitIntegers #ifdef FNV_64bitIntegers
#ifdef FNV_BigEndian
/* Local prototype */
static void FNV64reverse ( uint64_t * out, uint64_t hash );
#endif /* FNV_BigEndian */
/* 64 bit FNV_prime = 2^40 + 2^8 + 0xb3 */ /* 64 bit FNV_prime = 2^40 + 2^8 + 0xb3 */
#define FNV64prime 0x00000100000001B3 #define FNV64prime 0x00000100000001B3
#define FNV64basis 0xCBF29CE484222325 #define FNV64basis 0xCBF29CE484222325
/* FNV64 hash a null terminated string (64 bit) /* FNV64 hash a null terminated string (64 bit)
********************************************************************/ ********************************************************************/
int FNV64string ( const char *in, uint64_t * const out ) int FNV64string ( const char *in, uint64_t * const out )
{ {
uint64_t temp; uint64_t temp;
uint8_t ch; uint8_t ch;
if ( in && out ) if ( in && out )
{ {
temp = FNV64basis; temp = FNV64basis;
while ( (ch = *in++) ) while ( (ch = *in++) )
temp = FNV64prime * ( temp ^ ch ); temp = FNV64prime * ( temp ^ ch );
#ifdef FNV_BigEndian #ifdef FNV_BigEndian
FNV64reverse ( out, temp ); FNV64reverse ( out, temp );
#else #else
*out = temp; *out = temp;
INTERNET-DRAFT FNV
#endif #endif
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; /* Null input pointer */ return fnvNull; /* Null input pointer */
} /* end FNV64string */ } /* end FNV64string */
/* FNV64 hash a counted block (64 bit) /* FNV64 hash a counted block (64 bit)
********************************************************************/ ********************************************************************/
int FNV64block ( const void *vin, int FNV64block ( const void *vin,
INTERNET-DRAFT FNV
long int length, long int length,
uint64_t * const out ) uint64_t * const out )
{ {
const uint8_t *in = (const uint8_t*)vin; const uint8_t *in = (const uint8_t*)vin;
uint64_t temp; uint64_t temp;
if ( in && out ) if ( in && out )
{ {
if ( length < 0 ) if ( length < 0 )
return fnvBadParam; return fnvBadParam;
skipping to change at page 26, line 4 skipping to change at page 25, line 47
temp = hash & 0xFF; temp = hash & 0xFF;
for ( i = FNV64size - 1; i > 0; i-- ) for ( i = FNV64size - 1; i > 0; i-- )
{ {
hash >>= 8; hash >>= 8;
temp = ( temp << 8 ) + ( hash & 0xFF ); temp = ( temp << 8 ) + ( hash & 0xFF );
} }
*out = temp; *out = temp;
} /* end FNV64reverse */ } /* end FNV64reverse */
#endif /* FNV_BigEndian */ #endif /* FNV_BigEndian */
INTERNET-DRAFT FNV
/******************************************************************** /********************************************************************
* Set of init, input, and output functions below * * Set of init, input, and output functions below *
* to incrementally compute FNV64 * * to incrementally compute FNV64 *
********************************************************************/ ********************************************************************/
/* initialize context (64 bit) /* initialize context (64 bit)
********************************************************************/ ********************************************************************/
INTERNET-DRAFT FNV
int FNV64init ( FNV64context * const ctx ) int FNV64init ( FNV64context * const ctx )
{ {
return FNV64initBasis ( ctx, FNV64basis ); return FNV64initBasis ( ctx, FNV64basis );
} /* end FNV64init */ } /* end FNV64init */
/* initialize context with a provided basis (64 bit) /* initialize context with a provided basis (64 bit)
********************************************************************/ ********************************************************************/
int FNV64initBasis ( FNV64context * const ctx, uint64_t basis ) int FNV64initBasis ( FNV64context * const ctx, uint64_t basis )
{ {
if ( ctx ) if ( ctx )
skipping to change at page 27, line 4 skipping to change at page 26, line 50
case FNVinited+FNV64state: case FNVinited+FNV64state:
ctx->Computed = FNVcomputed+FNV64state; ctx->Computed = FNVcomputed+FNV64state;
case FNVcomputed+FNV64state: case FNVcomputed+FNV64state:
break; break;
default: default:
return fnvStateError; return fnvStateError;
} }
for ( temp = ctx->Hash; length > 0; length-- ) for ( temp = ctx->Hash; length > 0; length-- )
temp = FNV64prime * ( temp ^ *in++ ); temp = FNV64prime * ( temp ^ *in++ );
ctx->Hash = temp; ctx->Hash = temp;
INTERNET-DRAFT FNV
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
} /* end FNV64input */ } /* end FNV64input */
/* hash in a zero terminated string not including the zero (64 bit) /* hash in a zero terminated string not including the zero (64 bit)
********************************************************************/ ********************************************************************/
INTERNET-DRAFT FNV
int FNV64stringin ( FNV64context * const ctx, int FNV64stringin ( FNV64context * const ctx,
const char *in ) const char *in )
{ {
uint64_t temp; uint64_t temp;
uint8_t ch; uint8_t ch;
if ( ctx && in ) if ( ctx && in )
{ {
switch ( ctx->Computed ) switch ( ctx->Computed )
{ {
skipping to change at page 28, line 4 skipping to change at page 27, line 50
if ( ctx->Computed != FNVcomputed+FNV64state ) if ( ctx->Computed != FNVcomputed+FNV64state )
return fnvStateError; return fnvStateError;
ctx->Computed = FNVemptied+FNV64state; ctx->Computed = FNVemptied+FNV64state;
#ifdef FNV_BigEndian #ifdef FNV_BigEndian
FNV64reverse ( out, ctx->Hash ); FNV64reverse ( out, ctx->Hash );
#else #else
*out = ctx->Hash; *out = ctx->Hash;
#endif #endif
ctx->Hash = 0; ctx->Hash = 0;
return fnvSuccess; return fnvSuccess;
INTERNET-DRAFT FNV
} }
return fnvNull; return fnvNull;
} /* end FNV64result */ } /* end FNV64result */
/****************************************************************** /******************************************************************
* END VERSION FOR WHEN YOU HAVE 64 BIT ARITHMETIC * * END VERSION FOR WHEN YOU HAVE 64 BIT ARITHMETIC *
******************************************************************/ ******************************************************************/
INTERNET-DRAFT FNV
#else /* FNV_64bitIntegers */ #else /* FNV_64bitIntegers */
/****************************************************************** /******************************************************************
* START VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC * * START VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC *
******************************************************************/ ******************************************************************/
/* 64 bit FNV_prime = 2^40 + 2^8 + 0xb3 */ /* 64 bit FNV_prime = 2^40 + 2^8 + 0xb3 */
/* #define FNV64prime 0x00000100000001B3 */ /* #define FNV64prime 0x00000100000001B3 */
#define FNV64primeX 0x01B3 #define FNV64primeX 0x01B3
#define FNV64shift 8 #define FNV64shift 8
skipping to change at page 29, line 4 skipping to change at page 28, line 50
long int length, long int length,
uint8_t out[FNV64size] ) uint8_t out[FNV64size] )
{ {
FNV64context ctx; FNV64context ctx;
int err; int err;
if ( ( err = FNV64init (&ctx) ) != fnvSuccess ) if ( ( err = FNV64init (&ctx) ) != fnvSuccess )
return err; return err;
if ( ( err = FNV64blockin (&ctx, in, length) ) != fnvSuccess ) if ( ( err = FNV64blockin (&ctx, in, length) ) != fnvSuccess )
return err; return err;
INTERNET-DRAFT FNV
return FNV64result (&ctx, out); return FNV64result (&ctx, out);
} /* end FNV64block */ } /* end FNV64block */
/******************************************************************** /********************************************************************
* Set of init, input, and output functions below * * Set of init, input, and output functions below *
* to incrementally compute FNV64 * * to incrementally compute FNV64 *
INTERNET-DRAFT FNV
********************************************************************/ ********************************************************************/
/* initialize context (32 bit) /* initialize context (32 bit)
********************************************************************/ ********************************************************************/
int FNV64init ( FNV64context * const ctx ) int FNV64init ( FNV64context * const ctx )
{ {
if ( ctx ) if ( ctx )
{ {
ctx->Hash[0] = FNV64basis0; ctx->Hash[0] = FNV64basis0;
ctx->Hash[1] = FNV64basis1; ctx->Hash[1] = FNV64basis1;
skipping to change at page 30, line 4 skipping to change at page 29, line 50
ctx->Hash[2] = basis[4] + ( basis[5]<<8 ); ctx->Hash[2] = basis[4] + ( basis[5]<<8 );
ctx->Hash[3] = basis[6] + ( basis[7]<<8 ); ctx->Hash[3] = basis[6] + ( basis[7]<<8 );
#endif #endif
ctx->Computed = FNVinited+FNV64state; ctx->Computed = FNVinited+FNV64state;
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
} /* end FNV64initBasis */ } /* end FNV64initBasis */
/* hash in a counted block (32 bit) /* hash in a counted block (32 bit)
INTERNET-DRAFT FNV
********************************************************************/ ********************************************************************/
int FNV64blockin ( FNV64context * const ctx, int FNV64blockin ( FNV64context * const ctx,
const void *vin, const void *vin,
long int length ) long int length )
{ {
const uint8_t *in = (const uint8_t*)vin; const uint8_t *in = (const uint8_t*)vin;
uint32_t temp[FNV64size/2]; uint32_t temp[FNV64size/2];
INTERNET-DRAFT FNV
uint32_t temp2[2]; uint32_t temp2[2];
int i; int i;
if ( ctx && in ) if ( ctx && in )
{ {
if ( length < 0 ) if ( length < 0 )
return fnvBadParam; return fnvBadParam;
switch ( ctx->Computed ) switch ( ctx->Computed )
{ {
case FNVinited+FNV64state: case FNVinited+FNV64state:
skipping to change at page 31, line 4 skipping to change at page 30, line 49
} }
for ( i=0; i<FNV64size/2; ++i ) for ( i=0; i<FNV64size/2; ++i )
ctx->Hash[i] = temp[i]; ctx->Hash[i] = temp[i];
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
} /* end FNV64blockin */ } /* end FNV64blockin */
/* hash in a string (32 bit) /* hash in a string (32 bit)
********************************************************************/ ********************************************************************/
INTERNET-DRAFT FNV
int FNV64stringin ( FNV64context * const ctx, int FNV64stringin ( FNV64context * const ctx,
const char *in ) const char *in )
{ {
uint32_t temp[FNV64size/2]; uint32_t temp[FNV64size/2];
uint32_t temp2[2]; uint32_t temp2[2];
int i; int i;
uint8_t ch; uint8_t ch;
INTERNET-DRAFT FNV
if ( ctx && in ) if ( ctx && in )
{ {
switch ( ctx->Computed ) switch ( ctx->Computed )
{ {
case FNVinited+FNV64state: case FNVinited+FNV64state:
ctx->Computed = FNVcomputed+FNV64state; ctx->Computed = FNVcomputed+FNV64state;
case FNVcomputed+FNV64state: case FNVcomputed+FNV64state:
break; break;
default: default:
skipping to change at page 32, line 4 skipping to change at page 31, line 48
} }
return fnvNull; return fnvNull;
} /* end FNV64stringin */ } /* end FNV64stringin */
/* return hash (32 bit) /* return hash (32 bit)
********************************************************************/ ********************************************************************/
int FNV64result ( FNV64context * const ctx, int FNV64result ( FNV64context * const ctx,
uint8_t out[FNV64size] ) uint8_t out[FNV64size] )
{ {
int i; int i;
INTERNET-DRAFT FNV
if ( ctx && out ) if ( ctx && out )
{ {
if ( ctx->Computed != FNVcomputed+FNV64state ) if ( ctx->Computed != FNVcomputed+FNV64state )
return fnvStateError; return fnvStateError;
for ( i=0; i<FNV64size/2; ++i ) for ( i=0; i<FNV64size/2; ++i )
{ {
#ifdef FNV_BigEndian #ifdef FNV_BigEndian
INTERNET-DRAFT FNV
out[7-2*i] = ctx->Hash[i]; out[7-2*i] = ctx->Hash[i];
out[6-2*i] = ctx->Hash[i] >> 8; out[6-2*i] = ctx->Hash[i] >> 8;
#else #else
out[2*i] = ctx->Hash[i]; out[2*i] = ctx->Hash[i];
out[2*i+1] = ctx->Hash[i] >> 8; out[2*i+1] = ctx->Hash[i] >> 8;
#endif #endif
ctx -> Hash[i] = 0; ctx -> Hash[i] = 0;
} }
ctx->Computed = FNVemptied+FNV64state; ctx->Computed = FNVemptied+FNV64state;
return fnvSuccess; return fnvSuccess;
skipping to change at page 33, line 4 skipping to change at page 32, line 47
* authors of the code. All rights reserved. * authors of the code. All rights reserved.
* See fnv-private.h for terms of use and redistribution. * See fnv-private.h for terms of use and redistribution.
*/ */
#ifndef _FNV128_H_ #ifndef _FNV128_H_
#define _FNV128_H_ #define _FNV128_H_
/* /*
* Description: * Description:
* This file provides headers for the 128-bit version of the * This file provides headers for the 128-bit version of the
INTERNET-DRAFT FNV
* FNV-1a non-cryptographic hash algorithm. * FNV-1a non-cryptographic hash algorithm.
*/ */
#include "FNVconfig.h" #include "FNVconfig.h"
#include <stdint.h> #include <stdint.h>
#define FNV128size (128/8) #define FNV128size (128/8)
INTERNET-DRAFT FNV
/* If you do not have the ISO standard stdint.h header file, then you /* If you do not have the ISO standard stdint.h header file, then you
* must typedef the following types: * must typedef the following types:
* *
* type meaning * type meaning
* uint64_t unsigned 64 bit integer (ifdef FNV_64bitIntegers) * uint64_t unsigned 64 bit integer (ifdef FNV_64bitIntegers)
* uint32_t unsigned 32 bit integer * uint32_t unsigned 32 bit integer
* uint16_t unsigned 16 bit integer * uint16_t unsigned 16 bit integer
* uint8_t unsigned 8 bit integer (i.e., unsigned char) * uint8_t unsigned 8 bit integer (i.e., unsigned char)
*/ */
skipping to change at page 34, line 4 skipping to change at page 33, line 48
uint32_t Hash[FNV128size/4]; uint32_t Hash[FNV128size/4];
} FNV128context; } FNV128context;
#else #else
/* version if 64 bit integers NOT supported */ /* version if 64 bit integers NOT supported */
typedef struct FNV128context_s { typedef struct FNV128context_s {
int Computed; /* state */ int Computed; /* state */
uint16_t Hash[FNV128size/2]; uint16_t Hash[FNV128size/2];
} FNV128context; } FNV128context;
INTERNET-DRAFT FNV
#endif /* FNV_64bitIntegers */ #endif /* FNV_64bitIntegers */
/* /*
* Function Prototypes * Function Prototypes
* FNV128string: hash a zero terminated string not including * FNV128string: hash a zero terminated string not including
* the terminating zero * the terminating zero
* FNV128block: FNV128 hash a specified length byte vector * FNV128block: FNV128 hash a specified length byte vector
INTERNET-DRAFT FNV
* FNV128init: initializes an FNV128 context * FNV128init: initializes an FNV128 context
* FNV128initBasis: initializes an FNV128 context with a * FNV128initBasis: initializes an FNV128 context with a
* provided basis * provided basis
* FNV128blockin: hash in a specified length byte vector * FNV128blockin: hash in a specified length byte vector
* FNV128stringin: hash in a zero terminated string not * FNV128stringin: hash in a zero terminated string not
* including the zero * including the zero
* FNV128result: returns the hash value * FNV128result: returns the hash value
* *
* Hash is returned as an array of 8-bit integers * Hash is returned as an array of 8-bit integers
*/ */
skipping to change at page 35, line 4 skipping to change at page 34, line 50
} }
#endif #endif
#endif /* _FNV128_H_ */ #endif /* _FNV128_H_ */
<CODE ENDS> <CODE ENDS>
<CODE BEGINS> <CODE BEGINS>
/***************************** FNV128.c ****************************/ /***************************** FNV128.c ****************************/
/******************** See RFC NNNN for details *********************/ /******************** See RFC NNNN for details *********************/
/* Copyright (c) 2016 IETF Trust and the persons identified as /* Copyright (c) 2016 IETF Trust and the persons identified as
INTERNET-DRAFT FNV
* authors of the code. All rights * authors of the code. All rights
* See fnv-private.h for terms of use and redistribution. * See fnv-private.h for terms of use and redistribution.
*/ */
/* This file implements the FNV (Fowler, Noll, Vo) non-cryptographic /* This file implements the FNV (Fowler, Noll, Vo) non-cryptographic
* hash function FNV-1a for 128-bit hashes. * hash function FNV-1a for 128-bit hashes.
*/ */
INTERNET-DRAFT FNV
#ifndef _FNV128_C_ #ifndef _FNV128_C_
#define _FNV128_C_ #define _FNV128_C_
#include "fnv-private.h" #include "fnv-private.h"
#include "FNV128.h" #include "FNV128.h"
/* common code for 64 and 32 bit modes */ /* common code for 64 and 32 bit modes */
/* FNV128 hash a null terminated string (64/32 bit) /* FNV128 hash a null terminated string (64/32 bit)
********************************************************************/ ********************************************************************/
skipping to change at page 36, line 4 skipping to change at page 35, line 48
err = FNV128init ( &ctx ); err = FNV128init ( &ctx );
if ( err != fnvSuccess ) return err; if ( err != fnvSuccess ) return err;
err = FNV128blockin ( &ctx, in, length ); err = FNV128blockin ( &ctx, in, length );
if ( err != fnvSuccess ) return err; if ( err != fnvSuccess ) return err;
return FNV128result ( &ctx, out ); return FNV128result ( &ctx, out );
} /* end FNV128block */ } /* end FNV128block */
/******************************************************************** /********************************************************************
* START VERSION FOR WHEN YOU HAVE 64 BIT ARITHMETIC * * START VERSION FOR WHEN YOU HAVE 64 BIT ARITHMETIC *
********************************************************************/ ********************************************************************/
INTERNET-DRAFT FNV
#ifdef FNV_64bitIntegers #ifdef FNV_64bitIntegers
/* 128 bit FNV_prime = 2^88 + 2^8 + 0x3b */ /* 128 bit FNV_prime = 2^88 + 2^8 + 0x3b */
/* 0x00000000 01000000 00000000 0000013B */ /* 0x00000000 01000000 00000000 0000013B */
#define FNV128primeX 0x013B #define FNV128primeX 0x013B
#define FNV128shift 24 #define FNV128shift 24
/* 0x6C62272E 07BB0142 62B82175 6295C58D */ /* 0x6C62272E 07BB0142 62B82175 6295C58D */
INTERNET-DRAFT FNV
#define FNV128basis0 0x6C62272E #define FNV128basis0 0x6C62272E
#define FNV128basis1 0x07BB0142 #define FNV128basis1 0x07BB0142
#define FNV128basis2 0x62B82175 #define FNV128basis2 0x62B82175
#define FNV128basis3 0x6295C58D #define FNV128basis3 0x6295C58D
/******************************************************************** /********************************************************************
* Set of init, input, and output functions below * * Set of init, input, and output functions below *
* to incrementally compute FNV128 * * to incrementally compute FNV128 *
********************************************************************/ ********************************************************************/
skipping to change at page 37, line 4 skipping to change at page 36, line 48
const uint8_t *ui8p; const uint8_t *ui8p;
uint32_t temp; uint32_t temp;
if ( ctx ) if ( ctx )
{ {
#ifdef FNV_BigEndian #ifdef FNV_BigEndian
ui8p = basis; ui8p = basis;
for ( i=0; i < FNV128size/4; ++i ) for ( i=0; i < FNV128size/4; ++i )
{ {
temp = (*ui8p++)<<8; temp = (*ui8p++)<<8;
INTERNET-DRAFT FNV
temp = (temp + *ui8p++)<<8; temp = (temp + *ui8p++)<<8;
temp = (temp + *ui8p++)<<8; temp = (temp + *ui8p++)<<8;
ctx->Hash[i] = temp + *ui8p; ctx->Hash[i] = temp + *ui8p;
} }
#else #else
ui8p = basis + ( FNV128size/4 - 1 ); ui8p = basis + ( FNV128size/4 - 1 );
for ( i=0; i < FNV128size/4; ++i ) for ( i=0; i < FNV128size/4; ++i )
{ {
INTERNET-DRAFT FNV
temp = (*ui8p--)<<8; temp = (*ui8p--)<<8;
temp = (temp + *ui8p--)<<8; temp = (temp + *ui8p--)<<8;
temp = (temp + *ui8p--)<<8; temp = (temp + *ui8p--)<<8;
ctx->Hash[i] = temp + *ui8p; ctx->Hash[i] = temp + *ui8p;
} }
#endif #endif
ctx->Computed = FNVinited+FNV128state; ctx->Computed = FNVinited+FNV128state;
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
skipping to change at page 38, line 4 skipping to change at page 37, line 49
break; break;
default: default:
return fnvStateError; return fnvStateError;
} }
for ( i=0; i<FNV128size/4; ++i ) for ( i=0; i<FNV128size/4; ++i )
temp[i] = ctx->Hash[i]; temp[i] = ctx->Hash[i];
for ( ; length > 0; length-- ) for ( ; length > 0; length-- )
{ {
/* temp = FNV128prime * ( temp ^ *in++ ); */ /* temp = FNV128prime * ( temp ^ *in++ ); */
temp2[1] = temp[3] << FNV128shift; temp2[1] = temp[3] << FNV128shift;
INTERNET-DRAFT FNV
temp2[0] = temp[2] << FNV128shift; temp2[0] = temp[2] << FNV128shift;
temp[3] = FNV128primeX * ( temp[3] ^ *in++ ); temp[3] = FNV128primeX * ( temp[3] ^ *in++ );
temp[2] *= FNV128primeX; temp[2] *= FNV128primeX;
temp[1] = temp[1] * FNV128primeX + temp2[1]; temp[1] = temp[1] * FNV128primeX + temp2[1];
temp[0] = temp[0] * FNV128primeX + temp2[0]; temp[0] = temp[0] * FNV128primeX + temp2[0];
temp[2] += temp[3] >> 32; temp[2] += temp[3] >> 32;
temp[3] &= 0xFFFFFFFF; temp[3] &= 0xFFFFFFFF;
temp[1] += temp[2] >> 32; temp[1] += temp[2] >> 32;
INTERNET-DRAFT FNV
temp[2] &= 0xFFFFFFFF; temp[2] &= 0xFFFFFFFF;
temp[0] += temp[1] >> 32; temp[0] += temp[1] >> 32;
temp[1] &= 0xFFFFFFFF; temp[1] &= 0xFFFFFFFF;
} }
for ( i=0; i<FNV128size/4; ++i ) for ( i=0; i<FNV128size/4; ++i )
ctx->Hash[i] = temp[i]; ctx->Hash[i] = temp[i];
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
} /* end FNV128input */ } /* end FNV128input */
skipping to change at page 39, line 4 skipping to change at page 38, line 49
temp[i] = ctx->Hash[i]; temp[i] = ctx->Hash[i];
while ( (ch = (uint8_t)*in++) ) while ( (ch = (uint8_t)*in++) )
{ {
/* temp = FNV128prime * ( temp ^ ch ); */ /* temp = FNV128prime * ( temp ^ ch ); */
temp2[1] = temp[3] << FNV128shift; temp2[1] = temp[3] << FNV128shift;
temp2[0] = temp[2] << FNV128shift; temp2[0] = temp[2] << FNV128shift;
temp[3] = FNV128primeX * ( temp[3] ^ *in++ ); temp[3] = FNV128primeX * ( temp[3] ^ *in++ );
temp[2] *= FNV128primeX; temp[2] *= FNV128primeX;
temp[1] = temp[1] * FNV128primeX + temp2[1]; temp[1] = temp[1] * FNV128primeX + temp2[1];
temp[0] = temp[0] * FNV128primeX + temp2[0]; temp[0] = temp[0] * FNV128primeX + temp2[0];
INTERNET-DRAFT FNV
temp[2] += temp[3] >> 32; temp[2] += temp[3] >> 32;
temp[3] &= 0xFFFFFFFF; temp[3] &= 0xFFFFFFFF;
temp[1] += temp[2] >> 32; temp[1] += temp[2] >> 32;
temp[2] &= 0xFFFFFFFF; temp[2] &= 0xFFFFFFFF;
temp[0] += temp[1] >> 32; temp[0] += temp[1] >> 32;
temp[1] &= 0xFFFFFFFF; temp[1] &= 0xFFFFFFFF;
} }
for ( i=0; i<FNV128size/4; ++i ) for ( i=0; i<FNV128size/4; ++i )
INTERNET-DRAFT FNV
ctx->Hash[i] = temp[i]; ctx->Hash[i] = temp[i];
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
} /* end FNV128stringin */ } /* end FNV128stringin */
/* return hash (64 bit) /* return hash (64 bit)
********************************************************************/ ********************************************************************/
int FNV128result ( FNV128context * const ctx, uint8_t out[FNV128size] ) int FNV128result ( FNV128context * const ctx, uint8_t out[FNV128size] )
{ {
skipping to change at page 40, line 4 skipping to change at page 39, line 49
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
} /* end FNV128result */ } /* end FNV128result */
/****************************************************************** /******************************************************************
* END VERSION FOR WHEN YOU HAVE 64 BIT ARITHMETIC * * END VERSION FOR WHEN YOU HAVE 64 BIT ARITHMETIC *
******************************************************************/ ******************************************************************/
#else /* FNV_64bitIntegers */ #else /* FNV_64bitIntegers */
/****************************************************************** /******************************************************************
INTERNET-DRAFT FNV
* START VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC * * START VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC *
******************************************************************/ ******************************************************************/
/* 128 bit FNV_prime = 2^88 + 2^8 + 0x3b */ /* 128 bit FNV_prime = 2^88 + 2^8 + 0x3b */
/* 0x00000000 01000000 00000000 0000013B */ /* 0x00000000 01000000 00000000 0000013B */
#define FNV128primeX 0x013B #define FNV128primeX 0x013B
#define FNV128shift 8 #define FNV128shift 8
INTERNET-DRAFT FNV
/* 0x6C62272E 07BB0142 62B82175 6295C58D */ /* 0x6C62272E 07BB0142 62B82175 6295C58D */
uint16_t FNV128basis[FNV128size/2] = uint16_t FNV128basis[FNV128size/2] =
{ 0x6C62, 0x272E, 0x07BB, 0x0142, { 0x6C62, 0x272E, 0x07BB, 0x0142,
0x62B8, 0x2175, 0x6295, 0xC58D }; 0x62B8, 0x2175, 0x6295, 0xC58D };
/******************************************************************** /********************************************************************
* Set of init, input, and output functions below * * Set of init, input, and output functions below *
* to incrementally compute FNV128 * * to incrementally compute FNV128 *
********************************************************************/ ********************************************************************/
skipping to change at page 41, line 4 skipping to change at page 40, line 48
const uint8_t *ui8p; const uint8_t *ui8p;
uint32_t temp; uint32_t temp;
if ( ctx ) if ( ctx )
{ {
#ifdef FNV_BigEndian #ifdef FNV_BigEndian
ui8p = basis; ui8p = basis;
for ( i=0; i < FNV128size/2; ++i ) for ( i=0; i < FNV128size/2; ++i )
{ {
temp = *ui8p++; temp = *ui8p++;
INTERNET-DRAFT FNV
ctx->Hash[i] = ( temp<<8 ) + (*ui8p++); ctx->Hash[i] = ( temp<<8 ) + (*ui8p++);
} }
#else #else
ui8p = basis + (FNV128size/2 - 1); ui8p = basis + (FNV128size/2 - 1);
for ( i=0; i < FNV128size/2; ++i ) for ( i=0; i < FNV128size/2; ++i )
{ {
temp = *ui8p--; temp = *ui8p--;
ctx->Hash[i] = ( temp<<8 ) + (*ui8p--); ctx->Hash[i] = ( temp<<8 ) + (*ui8p--);
INTERNET-DRAFT FNV
} }
#endif #endif
ctx->Computed = FNVinited+FNV128state; ctx->Computed = FNVinited+FNV128state;
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
} /* end FNV128initBasis */ } /* end FNV128initBasis */
/* hash in a counted block (32 bit) /* hash in a counted block (32 bit)
*******************************************************************/ *******************************************************************/
skipping to change at page 42, line 4 skipping to change at page 41, line 49
for ( i=0; i<FNV128size/2; ++i ) for ( i=0; i<FNV128size/2; ++i )
temp[i] = ctx->Hash[i]; temp[i] = ctx->Hash[i];
for ( ; length > 0; length-- ) for ( ; length > 0; length-- )
{ {
/* temp = FNV128prime * ( temp ^ *in++ ); */ /* temp = FNV128prime * ( temp ^ *in++ ); */
temp[7] ^= *in++; temp[7] ^= *in++;
temp2[2] = temp[7] << FNV128shift; temp2[2] = temp[7] << FNV128shift;
temp2[1] = temp[6] << FNV128shift; temp2[1] = temp[6] << FNV128shift;
temp2[0] = temp[5] << FNV128shift; temp2[0] = temp[5] << FNV128shift;
for ( i=0; i<8; ++i ) for ( i=0; i<8; ++i )
INTERNET-DRAFT FNV
temp[i] *= FNV128primeX; temp[i] *= FNV128primeX;
temp[2] += temp2[2]; temp[2] += temp2[2];
temp[1] += temp2[1]; temp[1] += temp2[1];
temp[0] += temp2[0]; temp[0] += temp2[0];
for ( i=7; i>0; --i ) for ( i=7; i>0; --i )
{ {
temp[i-1] += temp[i] >> 16; temp[i-1] += temp[i] >> 16;
temp[i] &= 0xFFFF; temp[i] &= 0xFFFF;
INTERNET-DRAFT FNV
} }
} }
for ( i=0; i<FNV128size/2; ++i ) for ( i=0; i<FNV128size/2; ++i )
ctx->Hash[i] = temp[i]; ctx->Hash[i] = temp[i];
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
} /* end FNV128blockin */ } /* end FNV128blockin */
/* hash in a string (32 bit) /* hash in a string (32 bit)
skipping to change at page 43, line 4 skipping to change at page 42, line 49
while ( (ch = (uint8_t)*in++) ) while ( (ch = (uint8_t)*in++) )
{ {
/* temp = FNV128prime * ( temp ^ *in++ ); */ /* temp = FNV128prime * ( temp ^ *in++ ); */
temp[7] ^= ch; temp[7] ^= ch;
temp2[2] = temp[7] << FNV128shift; temp2[2] = temp[7] << FNV128shift;
temp2[1] = temp[6] << FNV128shift; temp2[1] = temp[6] << FNV128shift;
temp2[0] = temp[5] << FNV128shift; temp2[0] = temp[5] << FNV128shift;
for ( i=0; i<8; ++i ) for ( i=0; i<8; ++i )
temp[i] *= FNV128primeX; temp[i] *= FNV128primeX;
temp[2] += temp2[2]; temp[2] += temp2[2];
INTERNET-DRAFT FNV
temp[1] += temp2[1]; temp[1] += temp2[1];
temp[0] += temp2[0]; temp[0] += temp2[0];
for ( i=7; i>0; --i ) for ( i=7; i>0; --i )
{ {
temp[i-1] += temp[i] >> 16; temp[i-1] += temp[i] >> 16;
temp[i] &= 0xFFFF; temp[i] &= 0xFFFF;
} }
} }
INTERNET-DRAFT FNV
for ( i=0; i<FNV128size/2; ++i ) for ( i=0; i<FNV128size/2; ++i )
ctx->Hash[i] = temp[i]; ctx->Hash[i] = temp[i];
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
} /* end FNV128stringin */ } /* end FNV128stringin */
/* return hash (32 bit) /* return hash (32 bit)
********************************************************************/ ********************************************************************/
int FNV128result ( FNV128context *ctx, int FNV128result ( FNV128context *ctx,
skipping to change at page 44, line 5 skipping to change at page 43, line 50
} /* end FNV128result */ } /* end FNV128result */
#endif /* Have64bitIntegers */ #endif /* Have64bitIntegers */
/******************************************************************** /********************************************************************
* END VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC * * END VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC *
********************************************************************/ ********************************************************************/
#endif /* _FNV128_C_ */ #endif /* _FNV128_C_ */
<CODE ENDS> <CODE ENDS>
INTERNET-DRAFT FNV
6.1.4 FNV256 C Code 6.1.4 FNV256 C Code
The header and C source for 256-bit FNV-1a. The header and C source for 256-bit FNV-1a.
<CODE BEGINS> <CODE BEGINS>
INTERNET-DRAFT FNV
/**************************** FNV256.h **************************/ /**************************** FNV256.h **************************/
/***************** See RFC NNNN for details. ********************/ /***************** See RFC NNNN for details. ********************/
/* /*
* Copyright (c) 2016 IETF Trust and the persons identified as * Copyright (c) 2016 IETF Trust and the persons identified as
* authors of the code. All rights reserved. * authors of the code. All rights reserved.
* See fnv-private.h for terms of use and redistribution. * See fnv-private.h for terms of use and redistribution.
*/ */
#ifndef _FNV256_H_ #ifndef _FNV256_H_
#define _FNV256_H_ #define _FNV256_H_
skipping to change at page 45, line 4 skipping to change at page 44, line 52
* All FNV functions provided return as integer as follows: * All FNV functions provided return as integer as follows:
* 0 -> success * 0 -> success
* >0 -> error as listed below * >0 -> error as listed below
*/ */
enum { /* success and errors */ enum { /* success and errors */
fnvSuccess = 0, fnvSuccess = 0,
fnvNull, /* Null pointer parameter */ fnvNull, /* Null pointer parameter */
fnvStateError, /* called Input after Result or before Init */ fnvStateError, /* called Input after Result or before Init */
fnvBadParam /* passed a bad parameter */ fnvBadParam /* passed a bad parameter */
}; };
INTERNET-DRAFT FNV
#endif /* _FNV_ErrCodes_ */ #endif /* _FNV_ErrCodes_ */
/* /*
* This structure holds context information for an FNV256 hash * This structure holds context information for an FNV256 hash
*/ */
INTERNET-DRAFT FNV
#ifdef FNV_64bitIntegers #ifdef FNV_64bitIntegers
/* version if 64 bit integers supported */ /* version if 64 bit integers supported */
typedef struct FNV256context_s { typedef struct FNV256context_s {
int Computed; /* state */ int Computed; /* state */
uint32_t Hash[FNV256size/4]; uint32_t Hash[FNV256size/4];
} FNV256context; } FNV256context;
#else #else
/* version if 64 bit integers NOT supported */ /* version if 64 bit integers NOT supported */
skipping to change at page 46, line 4 skipping to change at page 45, line 52
#endif #endif
/* FNV256 */ /* FNV256 */
extern int FNV256string ( const char *in, extern int FNV256string ( const char *in,
uint8_t out[FNV256size] ); uint8_t out[FNV256size] );
extern int FNV256block ( const void *in, extern int FNV256block ( const void *in,
long int length, long int length,
uint8_t out[FNV256size] ); uint8_t out[FNV256size] );
extern int FNV256init ( FNV256context *); extern int FNV256init ( FNV256context *);
extern int FNV256initBasis ( FNV256context * const, extern int FNV256initBasis ( FNV256context * const,
INTERNET-DRAFT FNV
const uint8_t basis[FNV256size] ); const uint8_t basis[FNV256size] );
extern int FNV256blockin ( FNV256context * const, extern int FNV256blockin ( FNV256context * const,
const void *in, const void *in,
long int length ); long int length );
extern int FNV256stringin ( FNV256context * const, extern int FNV256stringin ( FNV256context * const,
INTERNET-DRAFT FNV
const char *in ); const char *in );
extern int FNV256result ( FNV256context * const, extern int FNV256result ( FNV256context * const,
uint8_t out[FNV256size] ); uint8_t out[FNV256size] );
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* _FNV256_H_ */ #endif /* _FNV256_H_ */
<CODE ENDS> <CODE ENDS>
skipping to change at page 47, line 4 skipping to change at page 46, line 50
{ {
FNV256context ctx; FNV256context ctx;
int err; int err;
if ( (err = FNV256init ( &ctx )) != fnvSuccess ) if ( (err = FNV256init ( &ctx )) != fnvSuccess )
return err; return err;
if ( (err = FNV256stringin ( &ctx, in )) != fnvSuccess ) if ( (err = FNV256stringin ( &ctx, in )) != fnvSuccess )
return err; return err;
return FNV256result ( &ctx, out ); return FNV256result ( &ctx, out );
} /* end FNV256string */ } /* end FNV256string */
INTERNET-DRAFT FNV
/* FNV256 hash a counted block (64/32 bit) /* FNV256 hash a counted block (64/32 bit)
********************************************************************/ ********************************************************************/
int FNV256block ( const void *in, int FNV256block ( const void *in,
long int length, long int length,
uint8_t out[FNV256size] ) uint8_t out[FNV256size] )
INTERNET-DRAFT FNV
{ {
FNV256context ctx; FNV256context ctx;
int err; int err;
if ( (err = FNV256init ( &ctx )) != fnvSuccess ) if ( (err = FNV256init ( &ctx )) != fnvSuccess )
return err; return err;
if ( (err = FNV256blockin ( &ctx, in, length)) != fnvSuccess ) if ( (err = FNV256blockin ( &ctx, in, length)) != fnvSuccess )
return err; return err;
return FNV256result ( &ctx, out ); return FNV256result ( &ctx, out );
} /* end FNV256block */ } /* end FNV256block */
skipping to change at page 48, line 4 skipping to change at page 47, line 51
********************************************************************/ ********************************************************************/
int FNV256init ( FNV256context *ctx ) int FNV256init ( FNV256context *ctx )
{ {
int i; int i;
if ( ctx ) if ( ctx )
{ {
for ( i=0; i<FNV256size/4; ++i ) for ( i=0; i<FNV256size/4; ++i )
ctx->Hash[i] = FNV256basis[i]; ctx->Hash[i] = FNV256basis[i];
ctx->Computed = FNVinited+FNV256state; ctx->Computed = FNVinited+FNV256state;
INTERNET-DRAFT FNV
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
} /* end FNV256init */ } /* end FNV256init */
INTERNET-DRAFT FNV
/* initialize context with a provided basis (64 bit) /* initialize context with a provided basis (64 bit)
********************************************************************/ ********************************************************************/
int FNV256initBasis ( FNV256context* const ctx, int FNV256initBasis ( FNV256context* const ctx,
const uint8_t basis[FNV256size] ) const uint8_t basis[FNV256size] )
{ {
int i; int i;
const uint8_t *ui8p; const uint8_t *ui8p;
uint32_t temp; uint32_t temp;
skipping to change at page 49, line 4 skipping to change at page 48, line 51
/* hash in a counted block (64 bit) /* hash in a counted block (64 bit)
********************************************************************/ ********************************************************************/
int FNV256blockin ( FNV256context *ctx, int FNV256blockin ( FNV256context *ctx,
const void *vin, const void *vin,
long int length ) long int length )
{ {
const uint8_t *in = (const uint8_t*)vin; const uint8_t *in = (const uint8_t*)vin;
uint64_t temp[FNV256size/4]; uint64_t temp[FNV256size/4];
uint64_t temp2[3]; uint64_t temp2[3];
INTERNET-DRAFT FNV
int i; int i;
if ( ctx && in ) if ( ctx && in )
{ {
if ( length < 0 ) if ( length < 0 )
INTERNET-DRAFT FNV
return fnvBadParam; return fnvBadParam;
switch ( ctx->Computed ) switch ( ctx->Computed )
{ {
case FNVinited+FNV256state: case FNVinited+FNV256state:
ctx->Computed = FNVcomputed+FNV256state; ctx->Computed = FNVcomputed+FNV256state;
case FNVcomputed+FNV256state: case FNVcomputed+FNV256state:
break; break;
default: default:
return fnvStateError; return fnvStateError;
} }
skipping to change at page 50, line 4 skipping to change at page 49, line 52
} /* end FNV256input */ } /* end FNV256input */
/* hash in a string (64 bit) /* hash in a string (64 bit)
********************************************************************/ ********************************************************************/
int FNV256stringin ( FNV256context *ctx, const char *in ) int FNV256stringin ( FNV256context *ctx, const char *in )
{ {
uint64_t temp[FNV256size/4]; uint64_t temp[FNV256size/4];
uint64_t temp2[3]; uint64_t temp2[3];
int i; int i;
uint8_t ch; uint8_t ch;
INTERNET-DRAFT FNV
if ( ctx && in ) if ( ctx && in )
{ {
switch ( ctx->Computed ) switch ( ctx->Computed )
{ {
INTERNET-DRAFT FNV
case FNVinited+FNV256state: case FNVinited+FNV256state:
ctx->Computed = FNVcomputed+FNV256state; ctx->Computed = FNVcomputed+FNV256state;
case FNVcomputed+FNV256state: case FNVcomputed+FNV256state:
break; break;
default: default:
return fnvStateError; return fnvStateError;
} }
for ( i=0; i<FNV256size/4; ++i ) for ( i=0; i<FNV256size/4; ++i )
temp[i] = ctx->Hash[i]; temp[i] = ctx->Hash[i];
while ( (ch = (uint8_t)*in++) ) while ( (ch = (uint8_t)*in++) )
skipping to change at page 51, line 4 skipping to change at page 50, line 53
int FNV256result ( FNV256context *ctx, uint8_t out[FNV256size] ) int FNV256result ( FNV256context *ctx, uint8_t out[FNV256size] )
{ {
int i; int i;
if ( ctx && out ) if ( ctx && out )
{ {
if ( ctx->Computed != FNVcomputed+FNV256state ) if ( ctx->Computed != FNVcomputed+FNV256state )
return fnvStateError; return fnvStateError;
for ( i=0; i<FNV256size/4; ++i ) for ( i=0; i<FNV256size/4; ++i )
{ {
INTERNET-DRAFT FNV
#ifdef FNV_BigEndian #ifdef FNV_BigEndian
out[31-4*i] = ctx->Hash[i]; out[31-4*i] = ctx->Hash[i];
out[31-4*i] = ctx->Hash[i] >> 8; out[31-4*i] = ctx->Hash[i] >> 8;
out[31-4*i] = ctx->Hash[i] >> 16; out[31-4*i] = ctx->Hash[i] >> 16;
INTERNET-DRAFT FNV
out[31-4*i] = ctx->Hash[i] >> 24; out[31-4*i] = ctx->Hash[i] >> 24;
#else #else
out[4*i] = ctx->Hash[i]; out[4*i] = ctx->Hash[i];
out[4*i+1] = ctx->Hash[i] >> 8; out[4*i+1] = ctx->Hash[i] >> 8;
out[4*i+2] = ctx->Hash[i] >> 16; out[4*i+2] = ctx->Hash[i] >> 16;
out[4*i+3] = ctx->Hash[i] >> 24; out[4*i+3] = ctx->Hash[i] >> 24;
#endif #endif
ctx -> Hash[i] = 0; ctx -> Hash[i] = 0;
} }
ctx->Computed = FNVemptied+FNV256state; ctx->Computed = FNVemptied+FNV256state;
skipping to change at page 52, line 4 skipping to change at page 51, line 53
0x2D98, 0xC384, 0xC4E5, 0x76CC, 0x2D98, 0xC384, 0xC4E5, 0x76CC,
0xC8B1, 0x5368, 0x47B6, 0xBBB3, 0xC8B1, 0x5368, 0x47B6, 0xBBB3,
0x1023, 0xB4C8, 0xCAEE, 0x0535 }; 0x1023, 0xB4C8, 0xCAEE, 0x0535 };
/******************************************************************** /********************************************************************
* Set of init, input, and output functions below * * Set of init, input, and output functions below *
* to incrementally compute FNV256 * * to incrementally compute FNV256 *
********************************************************************/ ********************************************************************/
/* initialize context (32 bit) /* initialize context (32 bit)
INTERNET-DRAFT FNV
********************************************************************/ ********************************************************************/
int FNV256init ( FNV256context *ctx ) int FNV256init ( FNV256context *ctx )
{ {
int i; int i;
INTERNET-DRAFT FNV
if ( ctx ) if ( ctx )
{ {
for ( i=0; i<FNV256size/2; ++i ) for ( i=0; i<FNV256size/2; ++i )
ctx->Hash[i] = FNV256basis[i]; ctx->Hash[i] = FNV256basis[i];
ctx->Computed = FNVinited+FNV256state; ctx->Computed = FNVinited+FNV256state;
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
} /* end FNV256init */ } /* end FNV256init */
skipping to change at page 53, line 4 skipping to change at page 52, line 51
#endif #endif
ctx->Computed = FNVinited+FNV256state; ctx->Computed = FNVinited+FNV256state;
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
} /* end FNV256initBasis */ } /* end FNV256initBasis */
/* hash in a counted block (32 bit) /* hash in a counted block (32 bit)
*******************************************************************/ *******************************************************************/
int FNV256blockin ( FNV256context *ctx, int FNV256blockin ( FNV256context *ctx,
INTERNET-DRAFT FNV
const void *vin, const void *vin,
long int length ) long int length )
{ {
const uint8_t *in = (const uint8_t*)vin; const uint8_t *in = (const uint8_t*)vin;
uint32_t temp[FNV256size/2]; uint32_t temp[FNV256size/2];
INTERNET-DRAFT FNV
uint32_t temp2[6]; uint32_t temp2[6];
int i; int i;
if ( ctx && in ) if ( ctx && in )
{ {
if ( length < 0 ) if ( length < 0 )
return fnvBadParam; return fnvBadParam;
switch ( ctx->Computed ) switch ( ctx->Computed )
{ {
case FNVinited+FNV256state: case FNVinited+FNV256state:
skipping to change at page 54, line 4 skipping to change at page 53, line 51
ctx->Hash[i] = temp[i]; ctx->Hash[i] = temp[i];
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
} /* end FNV256blockin */ } /* end FNV256blockin */
/* hash in a string (32 bit) /* hash in a string (32 bit)
*******************************************************************/ *******************************************************************/
int FNV256stringin ( FNV256context *ctx, const char *in ) int FNV256stringin ( FNV256context *ctx, const char *in )
{ {
INTERNET-DRAFT FNV
uint32_t temp[FNV256size/2]; uint32_t temp[FNV256size/2];
uint32_t temp2[6]; uint32_t temp2[6];
int i; int i;
uint8_t ch; uint8_t ch;
INTERNET-DRAFT FNV
if ( ctx && in ) if ( ctx && in )
{ {
switch ( ctx->Computed ) switch ( ctx->Computed )
{ {
case FNVinited+FNV256state: case FNVinited+FNV256state:
ctx->Computed = FNVcomputed+FNV256state; ctx->Computed = FNVcomputed+FNV256state;
case FNVcomputed+FNV256state: case FNVcomputed+FNV256state:
break; break;
default: default:
skipping to change at page 55, line 4 skipping to change at page 54, line 51
/* return hash (32 bit) /* return hash (32 bit)
********************************************************************/ ********************************************************************/
int FNV256result ( FNV256context *ctx, uint8_t out[FNV256size] ) int FNV256result ( FNV256context *ctx, uint8_t out[FNV256size] )
{ {
int i; int i;
if ( ctx && out ) if ( ctx && out )
{ {
if ( ctx->Computed != FNVcomputed+FNV256state ) if ( ctx->Computed != FNVcomputed+FNV256state )
INTERNET-DRAFT FNV
return fnvStateError; return fnvStateError;
for ( i=0; i<FNV256size/2; ++i ) for ( i=0; i<FNV256size/2; ++i )
{ {
#ifdef FNV_BigEndian #ifdef FNV_BigEndian
out[31-2*i] = ctx->Hash[i]; out[31-2*i] = ctx->Hash[i];
INTERNET-DRAFT FNV
out[30-2*i] = ctx->Hash[i] >> 8; out[30-2*i] = ctx->Hash[i] >> 8;
#else #else
out[2*i] = ctx->Hash[i]; out[2*i] = ctx->Hash[i];
out[2*i+1] = ctx->Hash[i] >> 8; out[2*i+1] = ctx->Hash[i] >> 8;
#endif #endif
ctx->Hash[i] = 0; ctx->Hash[i] = 0;
} }
ctx->Computed = FNVemptied+FNV256state; ctx->Computed = FNVemptied+FNV256state;
return fnvSuccess; return fnvSuccess;
} }
skipping to change at page 56, line 5 skipping to change at page 55, line 50
#ifndef _FNV512_H_ #ifndef _FNV512_H_
#define _FNV512_H_ #define _FNV512_H_
/* /*
* Description: * Description:
* This file provides headers for the 512-bit version of the * This file provides headers for the 512-bit version of the
* FNV-1a non-cryptographic hash algorithm. * FNV-1a non-cryptographic hash algorithm.
*/ */
INTERNET-DRAFT FNV
#include "FNVconfig.h" #include "FNVconfig.h"
#include <stdint.h> #include <stdint.h>
#define FNV512size (512/8) #define FNV512size (512/8)
INTERNET-DRAFT FNV
/* If you do not have the ISO standard stdint.h header file, then you /* If you do not have the ISO standard stdint.h header file, then you
* must typedef the following types: * must typedef the following types:
* *
* type meaning * type meaning
* uint64_t unsigned 64 bit integer (ifdef FNV_64bitIntegers) * uint64_t unsigned 64 bit integer (ifdef FNV_64bitIntegers)
* uint32_t unsigned 32 bit integer * uint32_t unsigned 32 bit integer
* uint16_t unsigned 16 bit integer * uint16_t unsigned 16 bit integer
* uint8_t unsigned 8 bit integer (i.e., unsigned char) * uint8_t unsigned 8 bit integer (i.e., unsigned char)
*/ */
skipping to change at page 57, line 4 skipping to change at page 56, line 50
#else #else
/* version if 64 bit integers NOT supported */ /* version if 64 bit integers NOT supported */
typedef struct FNV512context_s { typedef struct FNV512context_s {
int Computed; /* state */ int Computed; /* state */
uint16_t Hash[FNV512size/2]; uint16_t Hash[FNV512size/2];
} FNV512context; } FNV512context;
#endif /* FNV_64bitIntegers */ #endif /* FNV_64bitIntegers */
INTERNET-DRAFT FNV
/* /*
* Function Prototypes * Function Prototypes
* FNV512string: hash a zero terminated string not including * FNV512string: hash a zero terminated string not including
* the terminating zero * the terminating zero
* FNV512block: FNV512 hash a specified length byte vector * FNV512block: FNV512 hash a specified length byte vector
INTERNET-DRAFT FNV
* FNV512init: initializes an FNV512 context * FNV512init: initializes an FNV512 context
* FNV512initBasis: initializes an FNV512 context with a * FNV512initBasis: initializes an FNV512 context with a
* provided basis * provided basis
* FNV512blockin: hash in a specified length byte vector * FNV512blockin: hash in a specified length byte vector
* FNV512stringin: hash in a zero terminated string not * FNV512stringin: hash in a zero terminated string not
* including the zero * including the zero
* FNV512result: returns the hash value * FNV512result: returns the hash value
* *
* Hash is returned as an array of 8-bit integers * Hash is returned as an array of 8-bit integers
*/ */
skipping to change at page 58, line 4 skipping to change at page 57, line 52
#endif /* _FNV512_H_ */ #endif /* _FNV512_H_ */
<CODE ENDS> <CODE ENDS>
<CODE BEGINS> <CODE BEGINS>
/***************************** FNV512.c ****************************/ /***************************** FNV512.c ****************************/
/******************** See RFC NNNN for details *********************/ /******************** See RFC NNNN for details *********************/
/* Copyright (c) 2016 IETF Trust and the persons identified as /* Copyright (c) 2016 IETF Trust and the persons identified as
* authors of the code. All rights * authors of the code. All rights
* See fnv-private.h for terms of use and redistribution. * See fnv-private.h for terms of use and redistribution.
INTERNET-DRAFT FNV
*/ */
/* This file implements the FNV (Fowler, Noll, Vo) non-cryptographic /* This file implements the FNV (Fowler, Noll, Vo) non-cryptographic
* hash function FNV-1a for 512-bit hashes. * hash function FNV-1a for 512-bit hashes.
*/ */
INTERNET-DRAFT FNV
#ifndef _FNV512_C_ #ifndef _FNV512_C_
#define _FNV512_C_ #define _FNV512_C_
#include "fnv-private.h" #include "fnv-private.h"
#include "FNV512.h" #include "FNV512.h"
/* common code for 64 and 32 bit modes */ /* common code for 64 and 32 bit modes */
/* FNV512 hash a null terminated string (64/32 bit) /* FNV512 hash a null terminated string (64/32 bit)
********************************************************************/ ********************************************************************/
skipping to change at page 59, line 4 skipping to change at page 58, line 49
return err; return err;
if ( (err = FNV512blockin ( &ctx, in, length)) != fnvSuccess ) if ( (err = FNV512blockin ( &ctx, in, length)) != fnvSuccess )
return err; return err;
return FNV512result ( &ctx, out ); return FNV512result ( &ctx, out );
} /* end FNV512block */ } /* end FNV512block */
/******************************************************************** /********************************************************************
* START VERSION FOR WHEN YOU HAVE 64 BIT ARITHMETIC * * START VERSION FOR WHEN YOU HAVE 64 BIT ARITHMETIC *
********************************************************************/ ********************************************************************/
#ifdef Have64bitIntegers #ifdef Have64bitIntegers
INTERNET-DRAFT FNV
/* /*
512 bit FNV_prime = 2^344 + 2^8 + 0x57 = 512 bit FNV_prime = 2^344 + 2^8 + 0x57 =
0x0000000000000000 0000000000000000 0x0000000000000000 0000000000000000
0000000001000000 0000000000000000 0000000001000000 0000000000000000
0000000000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000157 */ 0000000000000000 0000000000000157 */
INTERNET-DRAFT FNV
#define FNV512primeX 0x0157 #define FNV512primeX 0x0157
#define FNV512shift 24 #define FNV512shift 24
/* 0xB86DB0B1171F4416 DCA1E50F309990AC /* 0xB86DB0B1171F4416 DCA1E50F309990AC
AC87D059C9000000 0000000000000D21 AC87D059C9000000 0000000000000D21
E948F68A34C192F6 2EA79BC942DBE7CE E948F68A34C192F6 2EA79BC942DBE7CE
182036415F56E34B AC982AAC4AFE9FD9 */ 182036415F56E34B AC982AAC4AFE9FD9 */
uint32_t FNV512basis[FNV512size/4] = { uint32_t FNV512basis[FNV512size/4] = {
0xB86DB0B1, 0x171F4416, 0xDCA1E50F, 0x209990AC, 0xB86DB0B1, 0x171F4416, 0xDCA1E50F, 0x209990AC,
skipping to change at page 60, line 4 skipping to change at page 59, line 51
********************************************************************/ ********************************************************************/
int FNV512initBasis ( FNV512context* const ctx, int FNV512initBasis ( FNV512context* const ctx,
const uint8_t basis[FNV512size] ) const uint8_t basis[FNV512size] )
{ {
int i; int i;
const uint8_t *ui8p; const uint8_t *ui8p;
uint32_t temp; uint32_t temp;
if ( ctx ) if ( ctx )
{ {
INTERNET-DRAFT FNV
#ifdef FNV_BigEndian #ifdef FNV_BigEndian
ui8p = basis; ui8p = basis;
for ( i=0; i < FNV512size/4; ++i ) for ( i=0; i < FNV512size/4; ++i )
{ {
temp = (*ui8p++)<<8; temp = (*ui8p++)<<8;
temp = (temp + *ui8p++)<<8; temp = (temp + *ui8p++)<<8;
INTERNET-DRAFT FNV
temp = (temp + *ui8p++)<<8; temp = (temp + *ui8p++)<<8;
ctx->Hash[i] = temp + *ui8p; ctx->Hash[i] = temp + *ui8p;
} }
#else #else
ui8p = basis + (FNV512size/4 - 1); ui8p = basis + (FNV512size/4 - 1);
for ( i=0; i < FNV512size/4; ++i ) for ( i=0; i < FNV512size/4; ++i )
{ {
temp = (*ui8p--)<<8; temp = (*ui8p--)<<8;
temp = (temp + *ui8p--)<<8; temp = (temp + *ui8p--)<<8;
temp = (temp + *ui8p--)<<8; temp = (temp + *ui8p--)<<8;
skipping to change at page 61, line 4 skipping to change at page 60, line 51
ctx->Computed = FNVcomputed+FNV128state; ctx->Computed = FNVcomputed+FNV128state;
case FNVcomputed+FNV512state: case FNVcomputed+FNV512state:
break; break;
default: default:
return fnvStateError; return fnvStateError;
} }
if ( length < 0 ) if ( length < 0 )
return fnvBadParam; return fnvBadParam;
for ( i=0; i<FNV512size/4; ++i ) for ( i=0; i<FNV512size/4; ++i )
temp[i] = ctx->Hash[i]; temp[i] = ctx->Hash[i];
INTERNET-DRAFT FNV
for ( ; length > 0; length-- ) for ( ; length > 0; length-- )
{ {
/* temp = FNV512prime * ( temp ^ *in++ ); */ /* temp = FNV512prime * ( temp ^ *in++ ); */
temp[7] ^= *in++; temp[7] ^= *in++;
temp2[2] = temp[7] << FNV512shift; temp2[2] = temp[7] << FNV512shift;
temp2[1] = temp[6] << FNV512shift; temp2[1] = temp[6] << FNV512shift;
INTERNET-DRAFT FNV
temp2[0] = temp[5] << FNV512shift; temp2[0] = temp[5] << FNV512shift;
for ( i=0; i<FNV512size/4; ++i ) for ( i=0; i<FNV512size/4; ++i )
temp[i] *= FNV512primeX; temp[i] *= FNV512primeX;
temp[2] += temp2[2]; temp[2] += temp2[2];
temp[1] += temp2[1]; temp[1] += temp2[1];
temp[0] += temp2[0]; temp[0] += temp2[0];
for ( i=FNV512size/4-1; i>0; --i ) for ( i=FNV512size/4-1; i>0; --i )
{ {
temp[i-1] += temp[i] >> 16; temp[i-1] += temp[i] >> 16;
temp[i] &= 0xFFFF; temp[i] &= 0xFFFF;
skipping to change at page 62, line 4 skipping to change at page 61, line 51
case FNVcomputed+FNV512state: case FNVcomputed+FNV512state:
break; break;
default: default:
return fnvStateError; return fnvStateError;
} }
for ( i=0; i<FNV512size/4; ++i ) for ( i=0; i<FNV512size/4; ++i )
temp[i] = ctx->Hash[i]; temp[i] = ctx->Hash[i];
while ( ch = (uint8_t)*in++ ) while ( ch = (uint8_t)*in++ )
{ {
/* temp = FNV512prime * ( temp ^ ch ); */ /* temp = FNV512prime * ( temp ^ ch ); */
INTERNET-DRAFT FNV
temp[7] ^= ch; temp[7] ^= ch;
temp2[2] = temp[7] << FNV128shift; temp2[2] = temp[7] << FNV128shift;
temp2[1] = temp[6] << FNV128shift; temp2[1] = temp[6] << FNV128shift;
temp2[0] = temp[5] << FNV128shift; temp2[0] = temp[5] << FNV128shift;
for ( i=0; i<FNV512size/4; ++i ) for ( i=0; i<FNV512size/4; ++i )
temp[i] *= FNV512prime; temp[i] *= FNV512prime;
INTERNET-DRAFT FNV
temp[2] += temp2[2]; temp[2] += temp2[2];
temp[1] += temp2[1]; temp[1] += temp2[1];
temp[0] += temp2[0]; temp[0] += temp2[0];
for ( i=FNVsize512/4-1; i>0; --i ) for ( i=FNVsize512/4-1; i>0; --i )
{ {
temp[i-1] += temp[i] >> 16; temp[i-1] += temp[i] >> 16;
temp[i] &= 0xFFFF; temp[i] &= 0xFFFF;
} }
} }
for ( i=0; i<FNV512size/4; ++i ) for ( i=0; i<FNV512size/4; ++i )
skipping to change at page 63, line 4 skipping to change at page 62, line 51
} }
ctx->Computed = FNVemptied+FNV512state; ctx->Computed = FNVemptied+FNV512state;
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
} /* end FNV512result */ } /* end FNV512result */
/****************************************************************** /******************************************************************
* END VERSION FOR WHEN YOU HAVE 64 BIT ARITHMETIC * * END VERSION FOR WHEN YOU HAVE 64 BIT ARITHMETIC *
******************************************************************/ ******************************************************************/
INTERNET-DRAFT FNV
#else /* FNV_64bitIntegers */ #else /* FNV_64bitIntegers */
/****************************************************************** /******************************************************************
* START VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC * * START VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC *
******************************************************************/ ******************************************************************/
/* version for when you only have 32-bit arithmetic /* version for when you only have 32-bit arithmetic
INTERNET-DRAFT FNV
********************************************************************/ ********************************************************************/
/* /*
512 bit FNV_prime = 2^344 + 2^8 + 0x57 = 512 bit FNV_prime = 2^344 + 2^8 + 0x57 =
0x0000000000000000 0000000000000000 0x0000000000000000 0000000000000000
0000000001000000 0000000000000000 0000000001000000 0000000000000000
0000000000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000157 */ 0000000000000000 0000000000000157 */
#define FNV512primeX 0x0157 #define FNV512primeX 0x0157
#define FNV512shift 8 #define FNV512shift 8
skipping to change at page 64, line 4 skipping to change at page 63, line 48
if ( ctx ) if ( ctx )
{ {
for ( i=0; i<FNV512size/2; ++i ) for ( i=0; i<FNV512size/2; ++i )
ctx->Hash[i] = FNV512basis[i]; ctx->Hash[i] = FNV512basis[i];
ctx->Computed = FNVinited+FNV512state; ctx->Computed = FNVinited+FNV512state;
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
} /* end FNV512init */ } /* end FNV512init */
INTERNET-DRAFT FNV
/* initialize context with a provided basis (32 bit) /* initialize context with a provided basis (32 bit)
********************************************************************/ ********************************************************************/
int FNV512initBasis ( FNV512context *ctx, int FNV512initBasis ( FNV512context *ctx,
const uint8_t basis[FNV512size] ) const uint8_t basis[FNV512size] )
{ {
int i; int i;
INTERNET-DRAFT FNV
const uint8_t *ui8p; const uint8_t *ui8p;
uint32_t temp; uint32_t temp;
if ( ctx ) if ( ctx )
{ {
#ifdef FNV_BigEndian #ifdef FNV_BigEndian
ui8p = basis; ui8p = basis;
for ( i=0; i < FNV512size/2; ++i ) for ( i=0; i < FNV512size/2; ++i )
{ {
temp = *ui8p++; temp = *ui8p++;
skipping to change at page 65, line 4 skipping to change at page 64, line 50
uint32_t temp2[6]; uint32_t temp2[6];
int i; int i;
if ( ctx && in ) if ( ctx && in )
{ {
switch ( ctx->Computed ) switch ( ctx->Computed )
{ {
case FNVinited+FNV512state: case FNVinited+FNV512state:
ctx->Computed = FNVcomputed+FNV512state; ctx->Computed = FNVcomputed+FNV512state;
case FNVcomputed+FNV512state: case FNVcomputed+FNV512state:
INTERNET-DRAFT FNV
break; break;
default: default:
return fnvStateError; return fnvStateError;
} }
if ( length < 0 ) if ( length < 0 )
return fnvBadParam; return fnvBadParam;
INTERNET-DRAFT FNV
for ( i=0; i<FNV512size/2; ++i ) for ( i=0; i<FNV512size/2; ++i )
temp[i] = ctx->Hash[i]; temp[i] = ctx->Hash[i];
for ( ; length > 0; length-- ) for ( ; length > 0; length-- )
{ {
/* temp = FNV512prime * ( temp ^ *in++ ); */ /* temp = FNV512prime * ( temp ^ *in++ ); */
temp[15] ^= *in++; temp[15] ^= *in++;
for ( i=0; i<6; ++i ) for ( i=0; i<6; ++i )
temp2[i] = temp[10+i] << FNV512shift; temp2[i] = temp[10+i] << FNV512shift;
for ( i=0; i<FNV512size/2; ++i ) for ( i=0; i<FNV512size/2; ++i )
temp[i] *= FNV512primeX; temp[i] *= FNV512primeX;
skipping to change at page 66, line 4 skipping to change at page 65, line 51
if ( ctx && in ) if ( ctx && in )
{ {
switch ( ctx->Computed ) switch ( ctx->Computed )
{ {
case FNVinited+FNV512state: case FNVinited+FNV512state:
ctx->Computed = FNVcomputed+FNV512state; ctx->Computed = FNVcomputed+FNV512state;
case FNVcomputed+FNV512state: case FNVcomputed+FNV512state:
break; break;
default: default:
return fnvStateError; return fnvStateError;
INTERNET-DRAFT FNV
} }
for ( i=0; i<FNV512size/2; ++i ) for ( i=0; i<FNV512size/2; ++i )
temp[i] = ctx->Hash[i]; temp[i] = ctx->Hash[i];
while ( (ch = (uint8_t)*in++) ) while ( (ch = (uint8_t)*in++) )
{ {
/* temp = FNV512prime * ( temp ^ *in++ ); */ /* temp = FNV512prime * ( temp ^ *in++ ); */
INTERNET-DRAFT FNV
temp[15] ^= ch; temp[15] ^= ch;
for ( i=0; i<6; ++i ) for ( i=0; i<6; ++i )
temp2[i] = temp[10+i] << FNV512shift; temp2[i] = temp[10+i] << FNV512shift;
for ( i=0; i<FNV512size/2; ++i ) for ( i=0; i<FNV512size/2; ++i )
temp[i] *= FNV512primeX; temp[i] *= FNV512primeX;
for ( i=0; i<6; ++i ) for ( i=0; i<6; ++i )
temp[10+i] += temp2[i]; temp[10+i] += temp2[i];
for ( i=15; i>0; --i ) for ( i=15; i>0; --i )
{ {
temp[i-1] += temp[i] >> 16; temp[i-1] += temp[i] >> 16;
skipping to change at page 67, line 4 skipping to change at page 66, line 51
out[30-2*i] = ctx->Hash[i] >> 8; out[30-2*i] = ctx->Hash[i] >> 8;
#else #else
out[2*i] = ctx->Hash[i]; out[2*i] = ctx->Hash[i];
out[2*i+1] = ctx->Hash[i] >> 8; out[2*i+1] = ctx->Hash[i] >> 8;
#endif #endif
ctx->Hash[i] = 0; ctx->Hash[i] = 0;
} }
ctx->Computed = FNVemptied+FNV512state; ctx->Computed = FNVemptied+FNV512state;
return fnvSuccess; return fnvSuccess;
} }
INTERNET-DRAFT FNV
return fnvNull; return fnvNull;
} /* end FNV512result */ } /* end FNV512result */
#endif /* Have64bitIntegers */ #endif /* Have64bitIntegers */
/******************************************************************** /********************************************************************
* END VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC * * END VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC *
INTERNET-DRAFT FNV
********************************************************************/ ********************************************************************/
#endif /* _FNV512_C_ */ #endif /* _FNV512_C_ */
<CODE ENDS> <CODE ENDS>
6.1.6 FNV1024 C Code 6.1.6 FNV1024 C Code
The header and C source for 1024-bit FNV-1a. The header and C source for 1024-bit FNV-1a.
<CODE BEGINS> <CODE BEGINS>
skipping to change at page 68, line 5 skipping to change at page 67, line 49
/* If you do not have the ISO standard stdint.h header file, then you /* If you do not have the ISO standard stdint.h header file, then you
* must typedef the following types: * must typedef the following types:
* *
* type meaning * type meaning
* uint64_t unsigned 64 bit integer (ifdef FNV_64bitIntegers) * uint64_t unsigned 64 bit integer (ifdef FNV_64bitIntegers)
* uint32_t unsigned 32 bit integer * uint32_t unsigned 32 bit integer
* uint16_t unsigned 16 bit integer * uint16_t unsigned 16 bit integer
* uint8_t unsigned 8 bit integer (i.e., unsigned char) * uint8_t unsigned 8 bit integer (i.e., unsigned char)
*/ */
INTERNET-DRAFT FNV
#ifndef _FNV_ErrCodes_ #ifndef _FNV_ErrCodes_
#define _FNV_ErrCodes_ #define _FNV_ErrCodes_
/********************************************************************* /*********************************************************************
* All FNV functions provided return as integer as follows: * All FNV functions provided return as integer as follows:
* 0 -> success * 0 -> success
* >0 -> error as listed below * >0 -> error as listed below
INTERNET-DRAFT FNV
*/ */
enum { /* success and errors */ enum { /* success and errors */
fnvSuccess = 0, fnvSuccess = 0,
fnvNull, /* Null pointer parameter */ fnvNull, /* Null pointer parameter */
fnvStateError, /* called Input after Result or before Init */ fnvStateError, /* called Input after Result or before Init */
fnvBadParam /* passed a bad parameter */ fnvBadParam /* passed a bad parameter */
}; };
#endif /* _FNV_ErrCodes_ */ #endif /* _FNV_ErrCodes_ */
/* /*
skipping to change at page 69, line 5 skipping to change at page 68, line 52
* FNV1024initBasis: initializes an FNV1024 context with a * FNV1024initBasis: initializes an FNV1024 context with a
* provided basis * provided basis
* FNV1024blockin: hash in a specified length byte vector * FNV1024blockin: hash in a specified length byte vector
* FNV1024stringin: hash in a zero terminated string not * FNV1024stringin: hash in a zero terminated string not
* including the zero * including the zero
* FNV1024result: returns the hash value * FNV1024result: returns the hash value
* *
* Hash is returned as an array of 8-bit integers * Hash is returned as an array of 8-bit integers
*/ */
INTERNET-DRAFT FNV
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* FNV1024 */ /* FNV1024 */
INTERNET-DRAFT FNV
extern int FNV1024string ( const char *in, extern int FNV1024string ( const char *in,
unsigned char out[FNV1024size] ); unsigned char out[FNV1024size] );
extern int FNV1024block ( const void *in, extern int FNV1024block ( const void *in,
long int length, long int length,
unsigned char out[FNV1024size] ); unsigned char out[FNV1024size] );
extern int FNV1024init ( FNV1024context *); extern int FNV1024init ( FNV1024context *);
extern int FNV1024initBasis ( FNV1024context * const, extern int FNV1024initBasis ( FNV1024context * const,
const uint8_t basis[FNV1024size] ); const uint8_t basis[FNV1024size] );
extern int FNV1024blockin ( FNV1024context *, extern int FNV1024blockin ( FNV1024context *,
const void *in, const void *in,
skipping to change at page 70, line 4 skipping to change at page 69, line 51
#ifndef _FNV1024_C_ #ifndef _FNV1024_C_
#define _FNV1024_C_ #define _FNV1024_C_
#include "fnv-private.h" #include "fnv-private.h"
#include "FNV1024.h" #include "FNV1024.h"
/* common code for 64 and 32 bit modes */ /* common code for 64 and 32 bit modes */
/* FNV1024 hash a null terminated string (64/32 bit) /* FNV1024 hash a null terminated string (64/32 bit)
********************************************************************/ ********************************************************************/
INTERNET-DRAFT FNV
int FNV1024string ( const char *in, uint8_t out[FNV1024size] ) int FNV1024string ( const char *in, uint8_t out[FNV1024size] )
{ {
FNV1024context ctx; FNV1024context ctx;
int err; int err;
INTERNET-DRAFT FNV
if ( (err = FNV1024init ( &ctx )) != fnvSuccess) if ( (err = FNV1024init ( &ctx )) != fnvSuccess)
return err; return err;
if ( (err = FNV1024stringin ( &ctx, in )) != fnvSuccess) if ( (err = FNV1024stringin ( &ctx, in )) != fnvSuccess)
return err; return err;
return FNV1024result ( &ctx, out ); return FNV1024result ( &ctx, out );
} /* end FNV1024string */ } /* end FNV1024string */
/* FNV1024 hash a counted block (64/32 bit) /* FNV1024 hash a counted block (64/32 bit)
********************************************************************/ ********************************************************************/
skipping to change at page 71, line 4 skipping to change at page 70, line 50
0000000000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000 000000000000018D 0000000000000000 000000000000018D
#define FNV1024primeX 0x018D #define FNV1024primeX 0x018D
#define FNV1024shift 24 #define FNV1024shift 24
/* 0x0000000000000000 005F7A76758ECC4D /* 0x0000000000000000 005F7A76758ECC4D
32E56D5A591028B7 4B29FC4223FDADA1 32E56D5A591028B7 4B29FC4223FDADA1
6C3BF34EDA3674DA 9A21D90000000000 6C3BF34EDA3674DA 9A21D90000000000
0000000000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000000 0000000000000000 0000000000000000
INTERNET-DRAFT FNV
0000000000000000 000000000004C6D7 0000000000000000 000000000004C6D7
EB6E73802734510A 555F256CC005AE55 EB6E73802734510A 555F256CC005AE55
6BDE8CC9C6A93B21 AFF4B16C71EE90B3 */ 6BDE8CC9C6A93B21 AFF4B16C71EE90B3 */
uint32_t FNV1024basis[FNV1024size/4] = { uint32_t FNV1024basis[FNV1024size/4] = {
INTERNET-DRAFT FNV
0x00000000, 0x00000000, 0x005F7A76, 0x758ECC4D, 0x00000000, 0x00000000, 0x005F7A76, 0x758ECC4D,
0x32E56D5A, 0x591028B7, 0x4B29FC42, 0x23FDADA1, 0x32E56D5A, 0x591028B7, 0x4B29FC42, 0x23FDADA1,
0x6C3BF34E, 0xDA3674DA, 0x9A21D900, 0x00000000, 0x6C3BF34E, 0xDA3674DA, 0x9A21D900, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x0004C6D7, 0x00000000, 0x00000000, 0x00000000, 0x0004C6D7,
0xEB6E7380, 0x2734510A, 0x555F256C, 0xC005AE55, 0xEB6E7380, 0x2734510A, 0x555F256C, 0xC005AE55,
0x6BDE8CC9, 0xC6A93B21, 0xAFF4B16C, 0x71EE90B3 0x6BDE8CC9, 0xC6A93B21, 0xAFF4B16C, 0x71EE90B3
}; };
skipping to change at page 72, line 4 skipping to change at page 71, line 51
uint8_t *ui8p; uint8_t *ui8p;
uint32_t temp; uint32_t temp;
if ( ctx ) if ( ctx )
{ {
#ifdef FNV_BigEndian #ifdef FNV_BigEndian
ui8p = basis; ui8p = basis;
for ( i=0; i < FNV1024size/4; ++i ) for ( i=0; i < FNV1024size/4; ++i )
{ {
temp = (*ui8p++)<<8; temp = (*ui8p++)<<8;
INTERNET-DRAFT FNV
temp = (temp + *ui8p++)<<8; temp = (temp + *ui8p++)<<8;
temp = (temp + *ui8p++)<<8; temp = (temp + *ui8p++)<<8;
ctx->Hash[i] = temp + *ui8p; ctx->Hash[i] = temp + *ui8p;
} }
#else #else
INTERNET-DRAFT FNV
ui8p = basis + (FNV1024size/4 - 1); ui8p = basis + (FNV1024size/4 - 1);
for ( i=0; i < FNV1024size/4; ++i ) for ( i=0; i < FNV1024size/4; ++i )
{ {
temp = (*ui8p--)<<8; temp = (*ui8p--)<<8;
temp = (temp + *ui8p--)<<8; temp = (temp + *ui8p--)<<8;
temp = (temp + *ui8p--)<<8; temp = (temp + *ui8p--)<<8;
ctx->Hash[i] = temp + *ui8p; ctx->Hash[i] = temp + *ui8p;
} }
#endif #endif
ctx->Computed = FNVinited+FNV1024state; ctx->Computed = FNVinited+FNV1024state;
skipping to change at page 73, line 4 skipping to change at page 72, line 51
} }
if ( length < 0 ) if ( length < 0 )
return fnvBadParam; return fnvBadParam;
for ( i=0; i<FNV1024size/4; ++i ) for ( i=0; i<FNV1024size/4; ++i )
temp[i] = ctx->Hash[i]; temp[i] = ctx->Hash[i];
for ( ; length > 0; length-- ) for ( ; length > 0; length-- )
{ {
/* temp = FNV1024prime * ( temp ^ *in++ ); */ /* temp = FNV1024prime * ( temp ^ *in++ ); */
temp[7] ^= *in++; temp[7] ^= *in++;
temp2[2] = temp[7] << FNV1024shift; temp2[2] = temp[7] << FNV1024shift;
INTERNET-DRAFT FNV
temp2[1] = temp[6] << FNV1024shift; temp2[1] = temp[6] << FNV1024shift;
temp2[0] = temp[5] << FNV1024shift; temp2[0] = temp[5] << FNV1024shift;
for ( i=0; i<FNV1024size/4; ++i ) for ( i=0; i<FNV1024size/4; ++i )
temp[i] *= FNV1024primeX; temp[i] *= FNV1024primeX;
temp[2] += temp2[2]; temp[2] += temp2[2];
INTERNET-DRAFT FNV
temp[1] += temp2[1]; temp[1] += temp2[1];
temp[0] += temp2[0]; temp[0] += temp2[0];
for ( i=FNV1024size/4-1; i>0; --i ) for ( i=FNV1024size/4-1; i>0; --i )
{ {
temp[i-1] += temp[i] >> 16; temp[i-1] += temp[i] >> 16;
temp[i] &= 0xFFFF; temp[i] &= 0xFFFF;
} }
} }
for ( i=0; i<FNV1024size/4; ++i ) for ( i=0; i<FNV1024size/4; ++i )
ctx->Hash[i] = temp[i]; ctx->Hash[i] = temp[i];
skipping to change at page 74, line 4 skipping to change at page 73, line 52
for ( i=0; i<FNV1024size/4; ++i ) for ( i=0; i<FNV1024size/4; ++i )
temp[i] = ctx->Hash[i]; temp[i] = ctx->Hash[i];
while ( ch = (uint8_t)*in++ ) while ( ch = (uint8_t)*in++ )
{ {
/* temp = FNV1024prime * ( temp ^ ch ); */ /* temp = FNV1024prime * ( temp ^ ch ); */
temp[7] ^= ch; temp[7] ^= ch;
temp2[2] = temp[7] << FNV128shift; temp2[2] = temp[7] << FNV128shift;
temp2[1] = temp[6] << FNV128shift; temp2[1] = temp[6] << FNV128shift;
temp2[0] = temp[5] << FNV128shift; temp2[0] = temp[5] << FNV128shift;
for ( i=0; i<FNV1024size/4; ++i ) for ( i=0; i<FNV1024size/4; ++i )
INTERNET-DRAFT FNV
temp[i] *= FNV1024prime; temp[i] *= FNV1024prime;
temp[2] += temp2[2]; temp[2] += temp2[2];
temp[1] += temp2[1]; temp[1] += temp2[1];
temp[0] += temp2[0]; temp[0] += temp2[0];
for ( i=FNVsize1024/4-1; i>0; --i ) for ( i=FNVsize1024/4-1; i>0; --i )
INTERNET-DRAFT FNV
{ {
temp[i-1] += temp[i] >> 16; temp[i-1] += temp[i] >> 16;
temp[i] &= 0xFFFF; temp[i] &= 0xFFFF;
} }
} }
for ( i=0; i<FNV1024size/4; ++i ) for ( i=0; i<FNV1024size/4; ++i )
ctx->Hash[i] = temp[i]; ctx->Hash[i] = temp[i];
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
skipping to change at page 75, line 5 skipping to change at page 74, line 52
} /* end FNV1024result */ } /* end FNV1024result */
/****************************************************************** /******************************************************************
* END VERSION FOR WHEN YOU HAVE 64 BIT ARITHMETIC * * END VERSION FOR WHEN YOU HAVE 64 BIT ARITHMETIC *
******************************************************************/ ******************************************************************/
#else /* FNV_64bitIntegers */ #else /* FNV_64bitIntegers */
/****************************************************************** /******************************************************************
* START VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC * * START VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC *
******************************************************************/ ******************************************************************/
INTERNET-DRAFT FNV
/* version for when you only have 32-bit arithmetic /* version for when you only have 32-bit arithmetic
********************************************************************/ ********************************************************************/
/* /*
1024 bit FNV_prime = 2^680 + 2^8 + 0x8d = 1024 bit FNV_prime = 2^680 + 2^8 + 0x8d =
INTERNET-DRAFT FNV
0x0000000000000000 0000010000000000 0x0000000000000000 0000010000000000
0000000000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000 0000000000000000 0000000000000000 0000000000000000
0000000000000000 000000000000018D */ 0000000000000000 000000000000018D */
#define FNV1024primeX 0x018D #define FNV1024primeX 0x018D
#define FNV1024shift 8 #define FNV1024shift 8
/* 0x0000000000000000 005F7A76758ECC4D /* 0x0000000000000000 005F7A76758ECC4D
skipping to change at page 76, line 4 skipping to change at page 75, line 51
/* initialize context (32 bit) /* initialize context (32 bit)
********************************************************************/ ********************************************************************/
int FNV1024init ( FNV1024context *ctx ) int FNV1024init ( FNV1024context *ctx )
{ {
int i; int i;
if ( ctx ) if ( ctx )
{ {
for ( i=0; i<FNV1024size/2; ++i ) for ( i=0; i<FNV1024size/2; ++i )
ctx->Hash[i] = FNV1024basis[i]; ctx->Hash[i] = FNV1024basis[i];
INTERNET-DRAFT FNV
ctx->Computed = FNVinited+FNV1024state; ctx->Computed = FNVinited+FNV1024state;
return fnvSuccess; return fnvSuccess;
} }
return fnvNull; return fnvNull;
} /* end FNV1024init */ } /* end FNV1024init */
INTERNET-DRAFT FNV
/* initialize context with a provided basis (32 bit) /* initialize context with a provided basis (32 bit)
********************************************************************/ ********************************************************************/
int FNV1024initBasis ( FNV1024context *ctx, int FNV1024initBasis ( FNV1024context *ctx,
const uint8_t basis[FNV1024size] ) const uint8_t basis[FNV1024size] )
{ {
int i; int i;
const uint8_t *ui8p; const uint8_t *ui8p;
uint32_t temp; uint32_t temp;
skipping to change at page 77, line 4 skipping to change at page 76, line 50
int FNV1024blockin ( FNV1024context *ctx, int FNV1024blockin ( FNV1024context *ctx,
const void *vin, const void *vin,
long int length ) long int length )
{ {
const uint8_t *in = (const uint8_t*)vin; const uint8_t *in = (const uint8_t*)vin;
uint32_t temp[FNV1024size/2]; uint32_t temp[FNV1024size/2];
uint32_t temp2[6]; uint32_t temp2[6];
int i; int i;
if ( ctx && in ) if ( ctx && in )
INTERNET-DRAFT FNV
{ {
switch ( ctx->Computed ) switch ( ctx->Computed )
{ {
case FNVinited+FNV1024state: case FNVinited+FNV1024state:
ctx->Computed = FNVcomputed+FNV1024state; ctx->Computed = FNVcomputed+FNV1024state;
case FNVcomputed+FNV1024state: case FNVcomputed+FNV1024state:
INTERNET-DRAFT FNV
break; break;
default: default:
return fnvStateError; return fnvStateError;
} }
if ( length < 0 ) if ( length < 0 )
return fnvBadParam; return fnvBadParam;
for ( i=0; i<FNV1024size/2; ++i ) for ( i=0; i<FNV1024size/2; ++i )
temp[i] = ctx->Hash[i]; temp[i] = ctx->Hash[i];
for ( ; length > 0; length-- ) for ( ; length > 0; length-- )
{ {
skipping to change at page 78, line 4 skipping to change at page 77, line 51
{ {
uint32_t temp[FNV1024size/2]; uint32_t temp[FNV1024size/2];
uint32_t temp2[6]; uint32_t temp2[6];
int i; int i;
uint8_t ch; uint8_t ch;
if ( ctx && in ) if ( ctx && in )
{ {
switch ( ctx->Computed ) switch ( ctx->Computed )
{ {
INTERNET-DRAFT FNV
case FNVinited+FNV1024state: case FNVinited+FNV1024state:
ctx->Computed = FNVcomputed+FNV1024state; ctx->Computed = FNVcomputed+FNV1024state;
case FNVcomputed+FNV1024state: case FNVcomputed+FNV1024state:
break; break;
default: default:
return fnvStateError; return fnvStateError;
INTERNET-DRAFT FNV
} }
for ( i=0; i<FNV1024size/2; ++i ) for ( i=0; i<FNV1024size/2; ++i )
temp[i] = ctx->Hash[i]; temp[i] = ctx->Hash[i];
while ( (ch = (uint8_t)*in++) ) while ( (ch = (uint8_t)*in++) )
{ {
/* temp = FNV1024prime * ( temp ^ *in++ ); */ /* temp = FNV1024prime * ( temp ^ *in++ ); */
temp[15] ^= ch; temp[15] ^= ch;
for ( i=0; i<6; ++i ) for ( i=0; i<6; ++i )
temp2[i] = temp[10+i] << FNV1024shift; temp2[i] = temp[10+i] << FNV1024shift;
for ( i=0; i<FNV1024size/2; ++i ) for ( i=0; i<FNV1024size/2; ++i )
skipping to change at page 79, line 4 skipping to change at page 78, line 51
if ( ctx->Computed != FNVcomputed+FNV1024state ) if ( ctx->Computed != FNVcomputed+FNV1024state )
return fnvStateError; return fnvStateError;
for ( i=0; i<FNV1024size/2; ++i ) for ( i=0; i<FNV1024size/2; ++i )
{ {
#ifdef FNV_BigEndian #ifdef FNV_BigEndian
out[31-2*i] = ctx->Hash[i]; out[31-2*i] = ctx->Hash[i];
out[30-2*i] = ctx->Hash[i] >> 8; out[30-2*i] = ctx->Hash[i] >> 8;
#else #else
out[2*i] = ctx->Hash[i]; out[2*i] = ctx->Hash[i];
out[2*i+1] = ctx->Hash[i] >> 8; out[2*i+1] = ctx->Hash[i] >> 8;
INTERNET-DRAFT FNV
#endif #endif
ctx->Hash[i] = 0; ctx->Hash[i] = 0;
} }
ctx->Computed = FNVemptied+FNV1024state; ctx->Computed = FNVemptied+FNV1024state;
return fnvSuccess; return fnvSuccess;
} }
INTERNET-DRAFT FNV
return fnvNull; return fnvNull;
} /* end FNV1024result */ } /* end FNV1024result */
#endif /* Have64bitIntegers */ #endif /* Have64bitIntegers */
/******************************************************************** /********************************************************************
* END VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC * * END VERSION FOR WHEN YOU ONLY HAVE 32-BIT ARITHMETIC *
********************************************************************/ ********************************************************************/
#endif /* _FNV1024_C_ */ #endif /* _FNV1024_C_ */
<CODE ENDS> <CODE ENDS>
skipping to change at page 80, line 5 skipping to change at page 79, line 50
#include "FNV.h" #include "FNV.h"
/* global variables */ /* global variables */
char *funcName; char *funcName;
char *errteststring = "foo"; char *errteststring = "foo";
int Terr; /* Total errors */ int Terr; /* Total errors */
#define NTestBytes 3 #define NTestBytes 3
uint8_t errtestbytes[NTestBytes] = { (uint8_t)1, uint8_t errtestbytes[NTestBytes] = { (uint8_t)1,
(uint8_t)2, (uint8_t)3 }; (uint8_t)2, (uint8_t)3 };
INTERNET-DRAFT FNV
#define NTstrings 3 #define NTstrings 3
char *teststring[NTstrings] = { "", "a", "foobar" }; char *teststring[NTstrings] = { "", "a", "foobar" };
/***************************************************************** /*****************************************************************
* local prototypes * local prototypes
INTERNET-DRAFT FNV
*****************************************************************/ *****************************************************************/
int TestR ( char *, int should, int was ); int TestR ( char *, int should, int was );
void TestNValue ( char *subfunc, void TestNValue ( char *subfunc,
char *string, char *string,
int N, int N,
uint8_t *should, uint8_t *should,
uint8_t *was ); uint8_t *was );
void HexPrint ( int i, unsigned char *p ); void HexPrint ( int i, unsigned char *p );
void Test32 (); void Test32 ();
void Test32Value ( char *subfunc, char *string, void Test32Value ( char *subfunc, char *string,
skipping to change at page 81, line 4 skipping to change at page 80, line 52
printf ("Have 64-bit Integers. "); printf ("Have 64-bit Integers. ");
#else #else
printf ("Do not have 64-bit integers. "); printf ("Do not have 64-bit integers. ");
#endif #endif
#ifdef FNV_BigEndian #ifdef FNV_BigEndian
printf ("Calculating for Big Endian.0); printf ("Calculating for Big Endian.0);
#else #else
printf ("Not calculating for Big Endian.0); printf ("Not calculating for Big Endian.0);
#endif #endif
funcName = "Testing TestR "; funcName = "Testing TestR ";
INTERNET-DRAFT FNV
/* test the Test Return function */ /* test the Test Return function */
TestR ( "should fail", 1, 2 ); TestR ( "should fail", 1, 2 );
TestR ( "should not have failed", 0, 0 ); TestR ( "should not have failed", 0, 0 );
Test32(); Test32();
INTERNET-DRAFT FNV
Test64(); Test64();
Test128(); Test128();
Test256(); Test256();
Test512(); Test512();
Test1024(); Test1024();
printf ("Type return to exit.0); printf ("Type return to exit.0);
(void)getchar(); (void)getchar();
printf ("Goodbye!0); printf ("Goodbye!0);
skipping to change at page 82, line 4 skipping to change at page 81, line 52
/* General byte vector return error test /* General byte vector return error test
*****************************************************************/ *****************************************************************/
void TestNValue ( char *subfunc, void TestNValue ( char *subfunc,
char *string, char *string,
int N, int N,
uint8_t *was, uint8_t *was,
uint8_t *should ) uint8_t *should )
{ {
#ifdef FNV_BigEndian #ifdef FNV_BigEndian
INTERNET-DRAFT FNV
if ( revcmp ( was, should, N) == 0) if ( revcmp ( was, should, N) == 0)
#else #else
if ( memcmp ( was, should, N) != 0) if ( memcmp ( was, should, N) != 0)
#endif #endif
{ {
INTERNET-DRAFT FNV
printf ( "%s %s of '%s' computed ", funcName, subfunc, string ); printf ( "%s %s of '%s' computed ", funcName, subfunc, string );
HexPrint ( N, was ); HexPrint ( N, was );
printf ( ", should have been " ); printf ( ", should have been " );
HexPrint ( N, should ); HexPrint ( N, should );
printf ( ".0 ); printf ( ".0 );
++Terr; ++Terr;
} }
} /* end TestNValue */ } /* end TestNValue */
/* print some hex /* print some hex
skipping to change at page 83, line 4 skipping to change at page 82, line 51
funcName = "Test32Value"; funcName = "Test32Value";
Test32Value ( "should fail", "test", FNV32svalues[1], FNV32svalues[2] ); Test32Value ( "should fail", "test", FNV32svalues[1], FNV32svalues[2] );
funcName = "FNV32"; funcName = "FNV32";
/* test error checks */ /* test error checks */
Terr = 0; Terr = 0;
TestR ( "init", fnvSuccess, FNV32init (&eContext) ); TestR ( "init", fnvSuccess, FNV32init (&eContext) );
TestR ( "string", fnvNull, TestR ( "string", fnvNull,
FNV32string ( (char *)0, &eUint32 ) ); FNV32string ( (char *)0, &eUint32 ) );
INTERNET-DRAFT FNV
TestR ( "string", fnvNull, TestR ( "string", fnvNull,
FNV32string ( errteststring, (uint32_t *)0 ) ); FNV32string ( errteststring, (uint32_t *)0 ) );
TestR ( "block", fnvNull, TestR ( "block", fnvNull,
FNV32block ( (uint8_t *)0, 1, &eUint32 ) ); FNV32block ( (uint8_t *)0, 1, &eUint32 ) );
TestR ( "block", fnvBadParam, TestR ( "block", fnvBadParam,
INTERNET-DRAFT FNV
FNV32block ( errtestbytes, -1, &eUint32 ) ); FNV32block ( errtestbytes, -1, &eUint32 ) );
TestR ( "block", fnvNull, TestR ( "block", fnvNull,
FNV32block ( errtestbytes, 1, (uint32_t *)0 ) ); FNV32block ( errtestbytes, 1, (uint32_t *)0 ) );
TestR ( "init", fnvNull, TestR ( "init", fnvNull,
FNV32init ( (FNV32context *)0 ) ); FNV32init ( (FNV32context *)0 ) );
TestR ( "initBasis", fnvNull, TestR ( "initBasis", fnvNull,
FNV32initBasis ( (FNV32context *)0, 42 ) ); FNV32initBasis ( (FNV32context *)0, 42 ) );
TestR ( "blockin", fnvNull, TestR ( "blockin", fnvNull,
FNV32blockin ( (FNV32context *)0, FNV32blockin ( (FNV32context *)0,
errtestbytes, NTestBytes ) ); errtestbytes, NTestBytes ) );
skipping to change at page 84, line 4 skipping to change at page 83, line 52
printf ( "%s test of error checks passed0, funcName ); printf ( "%s test of error checks passed0, funcName );
/* test actual results */ /* test actual results */
Terr = 0; Terr = 0;
for ( i = 0; i < NTstrings; ++i ) for ( i = 0; i < NTstrings; ++i )
{ {
err = TestR ( "string", fnvSuccess, err = TestR ( "string", fnvSuccess,
FNV32string ( teststring[i], &eUint32 ) ); FNV32string ( teststring[i], &eUint32 ) );
if ( err == fnvSuccess ) if ( err == fnvSuccess )
Test32Value ( "string", teststring[i], eUint32, Test32Value ( "string", teststring[i], eUint32,
INTERNET-DRAFT FNV
FNV32svalues[i] ); FNV32svalues[i] );
err = TestR ( "block", fnvSuccess, err = TestR ( "block", fnvSuccess,
FNV32block ( (uint8_t *)teststring[i], FNV32block ( (uint8_t *)teststring[i],
(unsigned long)(strlen(teststring[i])+1), (unsigned long)(strlen(teststring[i])+1),
&eUint32 ) ); &eUint32 ) );
INTERNET-DRAFT FNV
if ( err == fnvSuccess ) if ( err == fnvSuccess )
Test32Value ( "block", teststring[i], eUint32, Test32Value ( "block", teststring[i], eUint32,
FNV32bvalues[i] ); FNV32bvalues[i] );
/* now try testing the incremental stuff */ /* now try testing the incremental stuff */
err = TestR ( "init", fnvSuccess, FNV32init ( &eContext ) ); err = TestR ( "init", fnvSuccess, FNV32init ( &eContext ) );
if ( err ) break; if ( err ) break;
iLen = strlen ( teststring[i] ); iLen = strlen ( teststring[i] );
err = TestR ( "blockin", fnvSuccess, err = TestR ( "blockin", fnvSuccess,
FNV32blockin ( &eContext, FNV32blockin ( &eContext,
(uint8_t *)teststring[i], (uint8_t *)teststring[i],
skipping to change at page 85, line 5 skipping to change at page 84, line 51
{ {
TestNValue(subfunc, string, sizeof(uint32_t), (uint8_t*)&was, TestNValue(subfunc, string, sizeof(uint32_t), (uint8_t*)&was,
(uint8_t*)&should); (uint8_t*)&should);
} /* end Test32Value */ } /* end Test32Value */
#ifdef FNV_64bitIntegers #ifdef FNV_64bitIntegers
/***************************************************************** /*****************************************************************
* Code for FNV64 using 64-bit integers * Code for FNV64 using 64-bit integers
*****************************************************************/ *****************************************************************/
INTERNET-DRAFT FNV
void Test64 () void Test64 ()
{ {
int i, err; int i, err;
uint64_t eUint64 = 42; uint64_t eUint64 = 42;
FNV64context eContext; FNV64context eContext;
INTERNET-DRAFT FNV
uint64_t FNV64svalues[NTstrings] = { uint64_t FNV64svalues[NTstrings] = {
0xcbf29ce484222325, 0xaf63dc4c8601ec8c, 0x85944171f73967e8 }; 0xcbf29ce484222325, 0xaf63dc4c8601ec8c, 0x85944171f73967e8 };
uint64_t FNV64bvalues[NTstrings] = { uint64_t FNV64bvalues[NTstrings] = {
0xaf63bd4c8601b7df, 0x089be207b544f1e4, 0x34531ca7168b8f38 }; 0xaf63bd4c8601b7df, 0x089be207b544f1e4, 0x34531ca7168b8f38 };
funcName = "FNV64"; funcName = "FNV64";
/* test error checks */ /* test error checks */
Terr = 0; Terr = 0;
TestR ( "init", fnvSuccess, FNV64init (&eContext) ); TestR ( "init", fnvSuccess, FNV64init (&eContext) );
skipping to change at page 86, line 4 skipping to change at page 85, line 51
NTestBytes ) ); NTestBytes ) );
TestR ( "stringin", fnvNull, TestR ( "stringin", fnvNull,
FNV64stringin ( (FNV64context *)0, errteststring ) ); FNV64stringin ( (FNV64context *)0, errteststring ) );
TestR ( "stringin", fnvNull, TestR ( "stringin", fnvNull,
FNV64stringin ( &eContext, (char *)0 ) ); FNV64stringin ( &eContext, (char *)0 ) );
TestR ( "stringin", fnvStateError, TestR ( "stringin", fnvStateError,
FNV64stringin ( &eContext, errteststring ) ); FNV64stringin ( &eContext, errteststring ) );
TestR ( "result", fnvNull, TestR ( "result", fnvNull,
FNV64result ( (FNV64context *)0, &eUint64 ) ); FNV64result ( (FNV64context *)0, &eUint64 ) );
TestR ( "result", fnvNull, TestR ( "result", fnvNull,
INTERNET-DRAFT FNV
FNV64result ( &eContext, (uint64_t *)0 ) ); FNV64result ( &eContext, (uint64_t *)0 ) );
TestR ( "result", fnvStateError, TestR ( "result", fnvStateError,
FNV64result ( &eContext, &eUint64 ) ); FNV64result ( &eContext, &eUint64 ) );
if ( Terr ) if ( Terr )
printf ( "%s test of error checks failed %i times.0, printf ( "%s test of error checks failed %i times.0,
INTERNET-DRAFT FNV
funcName, Terr ); funcName, Terr );
else else
printf ( "%s test of error checks passed0, funcName ); printf ( "%s test of error checks passed0, funcName );
/* test actual results */ /* test actual results */
Terr = 0; Terr = 0;
for ( i = 0; i < NTstrings; ++i ) for ( i = 0; i < NTstrings; ++i )
{ {
err = TestR ( "string", fnvSuccess, err = TestR ( "string", fnvSuccess,
FNV64string ( teststring[i], &eUint64 ) ); FNV64string ( teststring[i], &eUint64 ) );
skipping to change at page 87, line 4 skipping to change at page 86, line 52
uint64_t should, uint64_t should,
uint64_t was ) uint64_t was )
{ {
TestNValue(subfunc, string, sizeof(uint64_t), (uint8_t*)&was, TestNValue(subfunc, string, sizeof(uint64_t), (uint8_t*)&was,
. (uint8_t*)&should); . (uint8_t*)&should);
} /* end Test64Value */ } /* end Test64Value */
#else #else
void Test64 () void Test64 ()
{ {
/* TBD */ /* TBD */
INTERNET-DRAFT FNV
} }
#endif /* FNV_64bitIntegers */ #endif /* FNV_64bitIntegers */
/***************************************************************** /*****************************************************************
INTERNET-DRAFT FNV
* Code for FNV128 using 64-bit integers * Code for FNV128 using 64-bit integers
*****************************************************************/ *****************************************************************/
void Test128 () void Test128 ()
{ {
//int i, err; //int i, err;
uint8_t eUint128[FNV128size]; uint8_t eUint128[FNV128size];
FNV128context eContext; FNV128context eContext;
funcName = "FNV128"; funcName = "FNV128";
skipping to change at page 88, line 4 skipping to change at page 87, line 51
FNV128blockin ( &eContext, errtestbytes, -1 ) ); FNV128blockin ( &eContext, errtestbytes, -1 ) );
eContext.Computed = FNVclobber+FNV128state; eContext.Computed = FNVclobber+FNV128state;
TestR ( "blockin", fnvStateError, TestR ( "blockin", fnvStateError,
FNV128blockin ( &eContext, errtestbytes, FNV128blockin ( &eContext, errtestbytes,
NTestBytes ) ); NTestBytes ) );
TestR ( "stringin", fnvNull, TestR ( "stringin", fnvNull,
FNV128stringin ( (FNV128context *)0, errteststring ) ); FNV128stringin ( (FNV128context *)0, errteststring ) );
TestR ( "stringin", fnvNull, TestR ( "stringin", fnvNull,
FNV128stringin ( &eContext, (char *)0 ) ); FNV128stringin ( &eContext, (char *)0 ) );
TestR ( "stringin", fnvStateError, TestR ( "stringin", fnvStateError,
INTERNET-DRAFT FNV
FNV128stringin ( &eContext, errteststring ) ); FNV128stringin ( &eContext, errteststring ) );
TestR ( "result", fnvNull, TestR ( "result", fnvNull,
FNV128result ( (FNV128context *)0, eUint128 ) ); FNV128result ( (FNV128context *)0, eUint128 ) );
TestR ( "result", fnvNull, TestR ( "result", fnvNull,
FNV128result ( &eContext, (uint8_t *)0 ) ); FNV128result ( &eContext, (uint8_t *)0 ) );
INTERNET-DRAFT FNV
TestR ( "result", fnvStateError, TestR ( "result", fnvStateError,
FNV128result ( &eContext, eUint128 ) ); FNV128result ( &eContext, eUint128 ) );
if ( Terr ) if ( Terr )
printf ( "%s test of error checks failed %i times.0, printf ( "%s test of error checks failed %i times.0,
funcName, Terr ); funcName, Terr );
else else
printf ( "%s test of error checks passed0, funcName ); printf ( "%s test of error checks passed0, funcName );
/* test actual results */ /* test actual results */
Terr = 0; Terr = 0;
skipping to change at page 89, line 4 skipping to change at page 88, line 51
TestR ( "block", fnvBadParam, TestR ( "block", fnvBadParam,
FNV256block ( errtestbytes, -1, eUint256 ) ); FNV256block ( errtestbytes, -1, eUint256 ) );
TestR ( "block", fnvNull, TestR ( "block", fnvNull,
FNV256block ( errtestbytes, 1, (uint8_t *)0 ) ); FNV256block ( errtestbytes, 1, (uint8_t *)0 ) );
TestR ( "init", fnvNull, TestR ( "init", fnvNull,
FNV256init ( (FNV256context *)0 ) ); FNV256init ( (FNV256context *)0 ) );
TestR ( "initBasis", fnvNull, TestR ( "initBasis", fnvNull,
FNV256initBasis ( (FNV256context *)0, eUint256 ) ); FNV256initBasis ( (FNV256context *)0, eUint256 ) );
TestR ( "blockin", fnvNull, TestR ( "blockin", fnvNull,
FNV256blockin ( (FNV256context *)0, FNV256blockin ( (FNV256context *)0,
INTERNET-DRAFT FNV
errtestbytes, NTestBytes ) ); errtestbytes, NTestBytes ) );
TestR ( "blockin", fnvNull, TestR ( "blockin", fnvNull,
FNV256blockin ( &eContext, (uint8_t *)0, FNV256blockin ( &eContext, (uint8_t *)0,
NTestBytes ) ); NTestBytes ) );
TestR ( "blockin", fnvBadParam, TestR ( "blockin", fnvBadParam,
INTERNET-DRAFT FNV
FNV256blockin ( &eContext, errtestbytes, -1 ) ); FNV256blockin ( &eContext, errtestbytes, -1 ) );
eContext.Computed = FNVclobber+FNV256state; eContext.Computed = FNVclobber+FNV256state;
TestR ( "blockin", fnvStateError, TestR ( "blockin", fnvStateError,
FNV256blockin ( &eContext, errtestbytes, FNV256blockin ( &eContext, errtestbytes,
NTestBytes ) ); NTestBytes ) );
TestR ( "stringin", fnvNull, TestR ( "stringin", fnvNull,
FNV256stringin ( (FNV256context *)0, errteststring ) ); FNV256stringin ( (FNV256context *)0, errteststring ) );
TestR ( "stringin", fnvNull, TestR ( "stringin", fnvNull,
FNV256stringin ( &eContext, (char *)0 ) ); FNV256stringin ( &eContext, (char *)0 ) );
TestR ( "stringin", fnvStateError, TestR ( "stringin", fnvStateError,
skipping to change at page 90, line 4 skipping to change at page 89, line 51
//int i, err; //int i, err;
uint8_t eUint512[FNV512size]; uint8_t eUint512[FNV512size];
FNV512context eContext; FNV512context eContext;
funcName = "FNV512"; funcName = "FNV512";
/* test error checks */ /* test error checks */
Terr = 0; Terr = 0;
TestR ( "init", fnvSuccess, FNV512init (&eContext) ); TestR ( "init", fnvSuccess, FNV512init (&eContext) );
TestR ( "string", fnvNull, TestR ( "string", fnvNull,
INTERNET-DRAFT FNV
FNV512string ( (char *)0, eUint512 ) ); FNV512string ( (char *)0, eUint512 ) );
TestR ( "string", fnvNull, TestR ( "string", fnvNull,
FNV512string ( errteststring, (uint8_t *)0 ) ); FNV512string ( errteststring, (uint8_t *)0 ) );
TestR ( "block", fnvNull, TestR ( "block", fnvNull,
FNV512block ( (uint8_t *)0, 1, eUint512 ) ); FNV512block ( (uint8_t *)0, 1, eUint512 ) );
INTERNET-DRAFT FNV
TestR ( "block", fnvBadParam, TestR ( "block", fnvBadParam,
FNV512block ( errtestbytes, -1, eUint512 ) ); FNV512block ( errtestbytes, -1, eUint512 ) );
TestR ( "block", fnvNull, TestR ( "block", fnvNull,
FNV512block ( errtestbytes, 1, (uint8_t *)0 ) ); FNV512block ( errtestbytes, 1, (uint8_t *)0 ) );
TestR ( "init", fnvNull, TestR ( "init", fnvNull,
FNV512init ( (FNV512context *)0 ) ); FNV512init ( (FNV512context *)0 ) );
TestR ( "initBasis", fnvNull, TestR ( "initBasis", fnvNull,
FNV512initBasis ( (FNV512context *)0, eUint512 ) ); FNV512initBasis ( (FNV512context *)0, eUint512 ) );
TestR ( "blockin", fnvNull, TestR ( "blockin", fnvNull,
FNV512blockin ( (FNV512context *)0, FNV512blockin ( (FNV512context *)0,
skipping to change at page 91, line 4 skipping to change at page 90, line 51
funcName, Terr ); funcName, Terr );
else else
printf ( "%s test of error checks passed0, funcName ); printf ( "%s test of error checks passed0, funcName );
/* test actual results */ /* test actual results */
Terr = 0; Terr = 0;
/* tbd */ /* tbd */
} /* end Test512 */ } /* end Test512 */
/***************************************************************** /*****************************************************************
INTERNET-DRAFT FNV
* Code for FNV1024 using 64-bit integers * Code for FNV1024 using 64-bit integers
*****************************************************************/ *****************************************************************/
void Test1024 () void Test1024 ()
{ {
INTERNET-DRAFT FNV
//int i, err; //int i, err;
uint8_t eUint1024[FNV1024size]; uint8_t eUint1024[FNV1024size];
FNV1024context eContext; FNV1024context eContext;
funcName = "FNV1024"; funcName = "FNV1024";
/* test error checks */ /* test error checks */
Terr = 0; Terr = 0;
TestR ( "init", fnvSuccess, FNV1024init (&eContext) ); TestR ( "init", fnvSuccess, FNV1024init (&eContext) );
TestR ( "string", fnvNull, TestR ( "string", fnvNull,
skipping to change at page 92, line 4 skipping to change at page 91, line 51
TestR ( "stringin", fnvNull, TestR ( "stringin", fnvNull,
FNV1024stringin ( (FNV1024context *)0, errteststring ) ); FNV1024stringin ( (FNV1024context *)0, errteststring ) );
TestR ( "stringin", fnvNull, TestR ( "stringin", fnvNull,
FNV1024stringin ( &eContext, (char *)0 ) ); FNV1024stringin ( &eContext, (char *)0 ) );
TestR ( "stringin", fnvStateError, TestR ( "stringin", fnvStateError,
FNV1024stringin ( &eContext, errteststring ) ); FNV1024stringin ( &eContext, errteststring ) );
TestR ( "result", fnvNull, TestR ( "result", fnvNull,
FNV1024result ( (FNV1024context *)0, eUint1024 ) ); FNV1024result ( (FNV1024context *)0, eUint1024 ) );
TestR ( "result", fnvNull, TestR ( "result", fnvNull,
FNV1024result ( &eContext, (uint8_t *)0 ) ); FNV1024result ( &eContext, (uint8_t *)0 ) );
INTERNET-DRAFT FNV
TestR ( "result", fnvStateError, TestR ( "result", fnvStateError,
FNV1024result ( &eContext, eUint1024 ) ); FNV1024result ( &eContext, eUint1024 ) );
if ( Terr ) if ( Terr )
printf ( "%s test of error checks failed %i times.0, printf ( "%s test of error checks failed %i times.0,
funcName, Terr ); funcName, Terr );
INTERNET-DRAFT FNV
else else
printf ( "%s test of error checks passed0, funcName ); printf ( "%s test of error checks passed0, funcName );
/* test actual results */ /* test actual results */
Terr = 0; Terr = 0;
/* tbd */ /* tbd */
} /* end Test1024 */ } /* end Test1024 */
<CODE ENDS> <CODE ENDS>
INTERNET-DRAFT FNV INTERNET-DRAFT FNV
skipping to change at page 103, line 5 skipping to change at page 102, line 13
2. Insertion of new Section 4 on hashing values. 2. Insertion of new Section 4 on hashing values.
INTERNET-DRAFT FNV INTERNET-DRAFT FNV
From -10 to -11 From -10 to -11
Changes based on code improvements primarily from Tony Hansen who has Changes based on code improvements primarily from Tony Hansen who has
been added as an author. Changes based on comments from Mukund been added as an author. Changes based on comments from Mukund
Sivaraman and Roman Donchenko. Sivaraman and Roman Donchenko.
From -11 to -12
Keep alive update.
INTERNET-DRAFT FNV INTERNET-DRAFT FNV
Author's Address Author's Address
Glenn Fowler Glenn Fowler
Google Google
Email: glenn.s.fowler@gmail.com Email: glenn.s.fowler@gmail.com
Landon Curt Noll Landon Curt Noll
 End of changes. 159 change blocks. 
199 lines changed or deleted 198 lines changed or added

This html diff was produced by rfcdiff 1.48. The latest version is available from http://tools.ietf.org/tools/rfcdiff/