pandory500/SDL-mirror
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Fixing the previous commit.

Browse source
This commit is contained in:
Markus Kauppila 2011-07-24 18:58:36 +03:00
parent afbf90dc78
commit fc76a5fa6a
9 changed files with 1056 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

119
test/test-automation/fuzzer/fuzzer.c Normal file
View file

@ -0,0 +1,119 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "../SDL_test.h"
#include "fuzzer.h"
//! context for test-specific random number generator
RND_CTX rndContext3;
int
GenerateExecKey(CRC32_CTX crcContext, char *runSeed, char *suiteName,
char *testName, int iterationNumber)
{
if(runSeed == NULL || suiteName == NULL ||
testName == NULL || iterationNumber < 0) {
fprintf(stderr, "Incorrect parameter given to GenerateExecKey function\n");
return -1;
}
char iterationString[256];
memset(iterationString, 0, sizeof(iterationString));
snprintf(iterationString, sizeof(iterationString), "%d", iterationNumber);
// combine the parameters
const int runSeedLength = strlen(runSeed);
const int suiteNameLength = strlen(suiteName);
const int testNameLength = strlen(testName);
const int iterationStringLength = strlen(iterationString);
// size of the entire + 3 for slashes and + 1 for '\0'
const int entireString = runSeedLength + suiteNameLength +
testNameLength + iterationString + 3 + 1;
int result = 0;
/* Let's take a hash from the strings separately because
* it's really slow to calculate md5 or crc32 for a really long string
* like 'runSeed/testSuiteName/testName/iteration'
*/
MD5_CTX md5Context;
utl_md5Init(&md5Context);
utl_md5Update(&md5Context, runSeed, runSeedLength);
utl_md5Update(&md5Context, suiteName, suiteNameLength);
utl_md5Update(&md5Context, testName, testNameLength);
utl_md5Update(&md5Context, iterationString, iterationStringLength);
utl_md5Final(&md5Context);
utl_crc32Calc(&crcContext, md5Context.digest, sizeof(md5Context.digest), &result);
return result;
}
void
InitFuzzer(const int execKey)
{
utl_randomInit(&rndContext3, globalExecKey, globalExecKey / 0xfafafafa);
}
void
DeinitFuzzer()
{
}
int
RandomInteger()
{
return utl_randomInt(&rndContext3);
}
int
RandomPositiveIntegerInRange(int min, int max)
{
int number = utl_randomInt(&rndContext3);
number = abs(number);
return (number % (max - min)) + min;
}
int
RandomBoundaryValue(const int max)
{
// Note: somehow integrate with RandomInteger?
// try to make more sensible & add new values
int boundaryValues[] = {0, 1, 15, 16, 17, 31, 32, 33, 63, 64, 65};
int retValue = -1;
do {
int index = RandomPositiveIntegerInRange(0, 10);
retValue = boundaryValues[index];
} while( !(retValue <= max) );
return retValue;
}
char *
RandomAsciiString()
{
const int size = abs(RandomInteger);
char *string = SDL_malloc(size * sizeof(size));
int counter = 0;
for( ; counter < size; ++counter) {
char character = (char) RandomPositiveIntegerInRange(0, 127);
string[counter] = character;
}
return string;
}

80
test/test-automation/fuzzer/fuzzer.h Normal file
View file

@ -0,0 +1,80 @@
/*
Copyright (C) 2011 Markus Kauppila <markus.kauppila@gmail.com>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#ifndef _FUZZER_H
#define _FUZZER_H
#include "utl_crc32.h"
#include "utl_md5.h"
#include "utl_random.h"
/*!
* Inits the fuzzer for a test
*/
void InitFuzzer(const int execKey);
/*!
* Deinits the fuzzer (for a test)
*/
void DeinitFuzzer();
/*!
* Returns random integer
*
* \returns Generated integer
*/
int RandomInteger();
/*!
* Returns positive integer in range [min, max]
*
* \returns Generated integer
*/
int RandomPositiveIntegerInRange(int min, int max);
/*!
* Generates random ASCII string
*
* \returns newly allocated random string
*/
char *RandomAsciiString();
/*!
* Generates a random boundary value. Max is the biggest
* value the function can return.
*
* \returns a boundary value
*/
int RandomBoundaryValue(const int max);
/*!
* Generates execution key (used for random seed) for a test
*
* \param runSeed Seed of the harness
* \param suiteName Test suite name
* \param testName Test name
* \param iteration Number of test iteration
*
* \return Generated execution key
*/
int GenerateExecKey(CRC32_CTX crcContext, char *runSeed, char *suiteName, char *testName, int interationNumber);
#endif

125
test/test-automation/fuzzer/utl_crc32.c Executable file
View file

@ -0,0 +1,125 @@
#include "utl_crc32.h"
int utl_crc32Init(CRC32_CTX *crcContext)
{
int i,j;
CrcUint32 c;
/* Sanity check context pointer */
if (crcContext==NULL) {
return(-1);
}
/*
* Build auxiliary table for parallel byte-at-a-time CRC-32
*/
#ifdef ORIGINAL_METHOD
for (i = 0; i < 256; ++i) {
for (c = i << 24, j = 8; j > 0; --j) {
c = c & 0x80000000 ? (c << 1) ^ CRC32_POLY : (c << 1);
}
crcContext->crc32_table[i] = c;
}
#else
for (i=0; i<256; i++) {
c = i;
for (j=8; j>0; j--) {
if (c & 1) {
c = (c >> 1) ^ CRC32_POLY;
} else {
c >>= 1;
}
}
crcContext->crc32_table[i] = c;
}
#endif
return(0);
}
/* Complete CRC32 calculation on a memory block */
int utl_crc32Calc(CRC32_CTX * crcContext, CrcUint8 *inBuf, CrcUint32 inLen, CrcUint32 *crc32)
{
if (utl_crc32CalcStart(crcContext,crc32)) {
return(-1);
}
if (utl_crc32CalcBuffer(crcContext, inBuf, inLen, crc32)) {
return(-1);
}
if (utl_crc32CalcEnd(crcContext, crc32)) {
return(-1);
}
return(0);
}
/* Start crc calculation */
int utl_crc32CalcStart(CRC32_CTX * crcContext, CrcUint32 *crc32)
{
/* Sanity check pointers */
if (crcContext==NULL) {
*crc32=0;
return(-1);
}
/*
* Preload shift register, per CRC-32 spec
*/
*crc32 = 0xffffffff;
return(0);
}
/* Finish crc calculation */
int utl_crc32CalcEnd(CRC32_CTX * crcContext, CrcUint32 *crc32)
{
/*
* Return complement, per CRC-32 spec
*/
*crc32 = (~(*crc32));
return(0);
}
/* Include memory block in crc */
int utl_crc32CalcBuffer(CRC32_CTX * crcContext, CrcUint8 *inBuf, CrcUint32 inLen, CrcUint32 *crc32)
{
CrcUint8 *p;
register CrcUint32 crc;
/* Sanity check pointers */
if (crcContext==NULL) {
*crc32=0;
return(-1);
}
/*
* Calculate CRC from data
*/
crc = *crc32;
for (p = inBuf; inLen > 0; ++p, --inLen) {
#ifdef ORIGINAL_METHOD
crc = (crc << 8) ^ crcContext->crc32_table[(crc >> 24) ^ *p];
#else
crc = ((crc >> 8) & 0x00FFFFFF) ^ crcContext->crc32_table[ (crc ^ *p) & 0xFF ];
#endif
}
*crc32 = crc;
return(0);
}
int utl_crc32Done(CRC32_CTX * crcContext)
{
/* Sanity check context pointer */
if (crcContext==NULL) {
return(-1);
}
return(0);
}

113
test/test-automation/fuzzer/utl_crc32.h Executable file
View file

@ -0,0 +1,113 @@
#ifndef _utl_crc32_h
#define _utl_crc32_h
/* Set up for C function definitions, even when using C++ */
#ifdef __cplusplus
extern "C" {
#endif
/* ----------- Includes -------------- */
#include <stdlib.h>
/* ------------ Definitions --------- */
/* Definition shared by all CRC routines */
#ifndef CrcUint32
#define CrcUint32 unsigned int
#endif
#ifndef CrcUint8
#define CrcUint8 unsigned char
#endif
#ifdef ORIGINAL_METHOD
#define CRC32_POLY 0x04c11db7 /* AUTODIN II, Ethernet, & FDDI */
#else
#define CRC32_POLY 0xEDB88320 /* Perl String::CRC32 compatible */
#endif
/* Data structure for CRC32 (checksum) computation */
typedef struct {
CrcUint32 crc32_table[256]; /* CRC table */
} CRC32_CTX;
/* ---------- Function Prototypes ------------- */
#ifdef WIN32
#ifdef BUILD_DLL
#define DLLINTERFACE __declspec(dllexport)
#else
#define DLLINTERFACE __declspec(dllimport)
#endif
#else
#define DLLINTERFACE
#endif
/*
* utl_crc32Init: initialize the CRC context
*
* Parameters:
*
* crcContext pointer to context variable
*
* Return value:
*
* 0 OK
* -1 error
*
* Note: The function initializes the crc table required for crc calcs.
*/
DLLINTERFACE int utl_crc32Init(CRC32_CTX * crcContext);
/*
* utl_crc32Calc: calculate a crc32 from a data block
*
* Parameters:
*
* crcContext pointer to context variable
* inBuf input buffer to checksum
* inLen length of input buffer
* crc32 pointer to Uint32 to store the final CRC into
*
* Return value:
*
* 0 OK
* -1 error
*
*/
DLLINTERFACE int utl_crc32Calc(CRC32_CTX * crcContext, CrcUint8 *inBuf, CrcUint32 inLen, CrcUint32 *crc32);
/* Same routine broken down into three steps */
DLLINTERFACE int utl_crc32CalcStart(CRC32_CTX * crcContext, CrcUint32 *crc32);
DLLINTERFACE int utl_crc32CalcEnd(CRC32_CTX * crcContext, CrcUint32 *crc32);
DLLINTERFACE int utl_crc32CalcBuffer(CRC32_CTX * crcContext, CrcUint8 *inBuf, CrcUint32 inLen, CrcUint32 *crc32);
/*
* utl_crc32Done: clean up CRC context
*
* Parameters:
*
* crcContext pointer to context variable
*
* Return value:
*
* 0 OK
* -1 error
*
*/
DLLINTERFACE int utl_crc32Done(CRC32_CTX * crcContext);
/* Ends C function definitions when using C++ */
#ifdef __cplusplus
};
#endif
#endif /* _utl_crc32_h */

314
test/test-automation/fuzzer/utl_md5.c Executable file
View file

@ -0,0 +1,314 @@
/*
***********************************************************************
** utl_md5.c -- the source code for MD5 routines **
** RSA Data Security, Inc. MD5 Message-Digest Algorithm **
** Created: 2/17/90 RLR **
** Revised: 1/91 SRD,AJ,BSK,JT Reference C ver., 7/10 constant corr. **
***********************************************************************
*/
/*
***********************************************************************
** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. **
** **
** License to copy and use this software is granted provided that **
** it is identified as the "RSA Data Security, Inc. MD5 Message- **
** Digest Algorithm" in all material mentioning or referencing this **
** software or this function. **
** **
** License is also granted to make and use derivative works **
** provided that such works are identified as "derived from the RSA **
** Data Security, Inc. MD5 Message-Digest Algorithm" in all **
** material mentioning or referencing the derived work. **
** **
** RSA Data Security, Inc. makes no representations concerning **
** either the merchantability of this software or the suitability **
** of this software for any particular purpose. It is provided "as **
** is" without express or implied warranty of any kind. **
** **
** These notices must be retained in any copies of any part of this **
** documentation and/or software. **
***********************************************************************
*/
#include "utl_md5.h"
/* forward declaration */
static void Transform(MD5UINT4 * buf, MD5UINT4 * in);
static unsigned char MD5PADDING[64] = {
0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
/* F, G, H and I are basic MD5 functions */
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))
/* ROTATE_LEFT rotates x left n bits */
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4 */
/* Rotation is separate from addition to prevent recomputation */
#define FF(a, b, c, d, x, s, ac) \
{(a) += F ((b), (c), (d)) + (x) + (MD5UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define GG(a, b, c, d, x, s, ac) \
{(a) += G ((b), (c), (d)) + (x) + (MD5UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define HH(a, b, c, d, x, s, ac) \
{(a) += H ((b), (c), (d)) + (x) + (MD5UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define II(a, b, c, d, x, s, ac) \
{(a) += I ((b), (c), (d)) + (x) + (MD5UINT4)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
/*
The routine MD5Init initializes the message-digest context
mdContext. All fields are set to zero.
*/
void utl_md5Init(MD5_CTX * mdContext)
{
mdContext->i[0] = mdContext->i[1] = (MD5UINT4) 0;
/*
* Load magic initialization constants.
*/
mdContext->buf[0] = (MD5UINT4) 0x67452301;
mdContext->buf[1] = (MD5UINT4) 0xefcdab89;
mdContext->buf[2] = (MD5UINT4) 0x98badcfe;
mdContext->buf[3] = (MD5UINT4) 0x10325476;
}
/*
The routine MD5Update updates the message-digest context to
account for the presence of each of the characters inBuf[0..inLen-1]
in the message whose digest is being computed.
*/
void utl_md5Update(MD5_CTX * mdContext, unsigned char *inBuf,
unsigned int inLen)
{
MD5UINT4 in[16];
int mdi;
unsigned int i, ii;
/*
* compute number of bytes mod 64
*/
mdi = (int) ((mdContext->i[0] >> 3) & 0x3F);
/*
* update number of bits
*/
if ((mdContext->i[0] + ((MD5UINT4) inLen << 3)) < mdContext->i[0])
mdContext->i[1]++;
mdContext->i[0] += ((MD5UINT4) inLen << 3);
mdContext->i[1] += ((MD5UINT4) inLen >> 29);
while (inLen--) {
/*
* add new character to buffer, increment mdi
*/
mdContext->in[mdi++] = *inBuf++;
/*
* transform if necessary
*/
if (mdi == 0x40) {
for (i = 0, ii = 0; i < 16; i++, ii += 4)
in[i] = (((MD5UINT4) mdContext->in[ii + 3]) << 24) |
(((MD5UINT4) mdContext->in[ii + 2]) << 16) |
(((MD5UINT4) mdContext->in[ii + 1]) << 8) |
((MD5UINT4) mdContext->in[ii]);
Transform(mdContext->buf, in);
mdi = 0;
}
}
}
/*
The routine MD5Final terminates the message-digest computation and
ends with the desired message digest in mdContext->digest[0...15].
*/
void utl_md5Final(MD5_CTX * mdContext)
{
MD5UINT4 in[16];
int mdi;
unsigned int i, ii;
unsigned int padLen;
/*
* save number of bits
*/
in[14] = mdContext->i[0];
in[15] = mdContext->i[1];
/*
* compute number of bytes mod 64
*/
mdi = (int) ((mdContext->i[0] >> 3) & 0x3F);
/*
* pad out to 56 mod 64
*/
padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);
utl_md5Update(mdContext, MD5PADDING, padLen);
/*
* append length in bits and transform
*/
for (i = 0, ii = 0; i < 14; i++, ii += 4)
in[i] = (((MD5UINT4) mdContext->in[ii + 3]) << 24) |
(((MD5UINT4) mdContext->in[ii + 2]) << 16) |
(((MD5UINT4) mdContext->in[ii + 1]) << 8) |
((MD5UINT4) mdContext->in[ii]);
Transform(mdContext->buf, in);
/*
* store buffer in digest
*/
for (i = 0, ii = 0; i < 4; i++, ii += 4) {
mdContext->digest[ii] = (unsigned char) (mdContext->buf[i] & 0xFF);
mdContext->digest[ii + 1] =
(unsigned char) ((mdContext->buf[i] >> 8) & 0xFF);
mdContext->digest[ii + 2] =
(unsigned char) ((mdContext->buf[i] >> 16) & 0xFF);
mdContext->digest[ii + 3] =
(unsigned char) ((mdContext->buf[i] >> 24) & 0xFF);
}
}
/* Basic MD5 step. Transforms buf based on in.
*/
static void Transform(MD5UINT4 * buf, MD5UINT4 * in)
{
MD5UINT4 a = buf[0], b = buf[1], c = buf[2], d = buf[3];
/*
* Round 1
*/
#define S11 7
#define S12 12
#define S13 17
#define S14 22
FF(a, b, c, d, in[0], S11, 3614090360u); /* 1 */
FF(d, a, b, c, in[1], S12, 3905402710u); /* 2 */
FF(c, d, a, b, in[2], S13, 606105819u); /* 3 */
FF(b, c, d, a, in[3], S14, 3250441966u); /* 4 */
FF(a, b, c, d, in[4], S11, 4118548399u); /* 5 */
FF(d, a, b, c, in[5], S12, 1200080426u); /* 6 */
FF(c, d, a, b, in[6], S13, 2821735955u); /* 7 */
FF(b, c, d, a, in[7], S14, 4249261313u); /* 8 */
FF(a, b, c, d, in[8], S11, 1770035416u); /* 9 */
FF(d, a, b, c, in[9], S12, 2336552879u); /* 10 */
FF(c, d, a, b, in[10], S13, 4294925233u); /* 11 */
FF(b, c, d, a, in[11], S14, 2304563134u); /* 12 */
FF(a, b, c, d, in[12], S11, 1804603682u); /* 13 */
FF(d, a, b, c, in[13], S12, 4254626195u); /* 14 */
FF(c, d, a, b, in[14], S13, 2792965006u); /* 15 */
FF(b, c, d, a, in[15], S14, 1236535329u); /* 16 */
/*
* Round 2
*/
#define S21 5
#define S22 9
#define S23 14
#define S24 20
GG(a, b, c, d, in[1], S21, 4129170786u); /* 17 */
GG(d, a, b, c, in[6], S22, 3225465664u); /* 18 */
GG(c, d, a, b, in[11], S23, 643717713u); /* 19 */
GG(b, c, d, a, in[0], S24, 3921069994u); /* 20 */
GG(a, b, c, d, in[5], S21, 3593408605u); /* 21 */
GG(d, a, b, c, in[10], S22, 38016083u); /* 22 */
GG(c, d, a, b, in[15], S23, 3634488961u); /* 23 */
GG(b, c, d, a, in[4], S24, 3889429448u); /* 24 */
GG(a, b, c, d, in[9], S21, 568446438u); /* 25 */
GG(d, a, b, c, in[14], S22, 3275163606u); /* 26 */
GG(c, d, a, b, in[3], S23, 4107603335u); /* 27 */
GG(b, c, d, a, in[8], S24, 1163531501u); /* 28 */
GG(a, b, c, d, in[13], S21, 2850285829u); /* 29 */
GG(d, a, b, c, in[2], S22, 4243563512u); /* 30 */
GG(c, d, a, b, in[7], S23, 1735328473u); /* 31 */
GG(b, c, d, a, in[12], S24, 2368359562u); /* 32 */
/*
* Round 3
*/
#define S31 4
#define S32 11
#define S33 16
#define S34 23
HH(a, b, c, d, in[5], S31, 4294588738u); /* 33 */
HH(d, a, b, c, in[8], S32, 2272392833u); /* 34 */
HH(c, d, a, b, in[11], S33, 1839030562u); /* 35 */
HH(b, c, d, a, in[14], S34, 4259657740u); /* 36 */
HH(a, b, c, d, in[1], S31, 2763975236u); /* 37 */
HH(d, a, b, c, in[4], S32, 1272893353u); /* 38 */
HH(c, d, a, b, in[7], S33, 4139469664u); /* 39 */
HH(b, c, d, a, in[10], S34, 3200236656u); /* 40 */
HH(a, b, c, d, in[13], S31, 681279174u); /* 41 */
HH(d, a, b, c, in[0], S32, 3936430074u); /* 42 */
HH(c, d, a, b, in[3], S33, 3572445317u); /* 43 */
HH(b, c, d, a, in[6], S34, 76029189u); /* 44 */
HH(a, b, c, d, in[9], S31, 3654602809u); /* 45 */
HH(d, a, b, c, in[12], S32, 3873151461u); /* 46 */
HH(c, d, a, b, in[15], S33, 530742520u); /* 47 */
HH(b, c, d, a, in[2], S34, 3299628645u); /* 48 */
/*
* Round 4
*/
#define S41 6
#define S42 10
#define S43 15
#define S44 21
II(a, b, c, d, in[0], S41, 4096336452u); /* 49 */
II(d, a, b, c, in[7], S42, 1126891415u); /* 50 */
II(c, d, a, b, in[14], S43, 2878612391u); /* 51 */
II(b, c, d, a, in[5], S44, 4237533241u); /* 52 */
II(a, b, c, d, in[12], S41, 1700485571u); /* 53 */
II(d, a, b, c, in[3], S42, 2399980690u); /* 54 */
II(c, d, a, b, in[10], S43, 4293915773u); /* 55 */
II(b, c, d, a, in[1], S44, 2240044497u); /* 56 */
II(a, b, c, d, in[8], S41, 1873313359u); /* 57 */
II(d, a, b, c, in[15], S42, 4264355552u); /* 58 */
II(c, d, a, b, in[6], S43, 2734768916u); /* 59 */
II(b, c, d, a, in[13], S44, 1309151649u); /* 60 */
II(a, b, c, d, in[4], S41, 4149444226u); /* 61 */
II(d, a, b, c, in[11], S42, 3174756917u); /* 62 */
II(c, d, a, b, in[2], S43, 718787259u); /* 63 */
II(b, c, d, a, in[9], S44, 3951481745u); /* 64 */
buf[0] += a;
buf[1] += b;
buf[2] += c;
buf[3] += d;
}
/*
***********************************************************************
** End of utl_md5.c **
******************************** (cut) ********************************
*/

125
test/test-automation/fuzzer/utl_md5.h Executable file
View file

@ -0,0 +1,125 @@
/*
***********************************************************************
** utl_md5.h -- header file for implementation of MD5 **
** RSA Data Security, Inc. MD5 Message-Digest Algorithm **
** Created: 2/17/90 RLR **
** Revised: 12/27/90 SRD,AJ,BSK,JT Reference C version **
** Revised (for MD5): RLR 4/27/91 **
** -- G modified to have y&~z instead of y&z **
** -- FF, GG, HH modified to add in last register done **
** -- Access pattern: round 2 works mod 5, round 3 works mod 3 **
** -- distinct additive constant for each step **
** -- round 4 added, working mod 7 **
***********************************************************************
*/
/*
***********************************************************************
** Message-digest routines: **
** To form the message digest for a message M **
** (1) Initialize a context buffer mdContext using MD5Init **
** (2) Call MD5Update on mdContext and M **
** (3) Call MD5Final on mdContext **
** The message digest is now in mdContext->digest[0...15] **
***********************************************************************
*/
#ifndef _utl_md5_h
#define _utl_md5_h
/* Set up for C function definitions, even when using C++ */
#ifdef __cplusplus
extern "C" {
#endif
/* ------------ Definitions --------- */
/* typedef a 32-bit type */
typedef unsigned long int MD5UINT4;
/* Data structure for MD5 (Message-Digest) computation */
typedef struct {
MD5UINT4 i[2]; /* number of _bits_ handled mod 2^64 */
MD5UINT4 buf[4]; /* scratch buffer */
unsigned char in[64]; /* input buffer */
unsigned char digest[16]; /* actual digest after MD5Final call */
} MD5_CTX;
/* ---------- Function Prototypes ------------- */
#ifdef WIN32
#ifdef BUILD_DLL
#define DLLINTERFACE __declspec(dllexport)
#else
#define DLLINTERFACE __declspec(dllimport)
#endif
#else
#define DLLINTERFACE
#endif
/*
* utl_md5Init: initialize the context
*
* Parameters:
*
* mdContext pointer to context variable
*
* Return value:
*
* none
*
* Note: The function initializes the message-digest context
* mdContext. Call before each new use of the context -
* all fields are set to zero.
*/
DLLINTERFACE void utl_md5Init(MD5_CTX * mdContext);
/*
* utl_md5update: update digest from variable length data
*
* Parameters:
*
* mdContext pointer to context variable
* inBuf pointer to data array/string
* inLen length of data array/string
*
* Return value:
*
* none
*
* Note: The function updates the message-digest context to account
* for the presence of each of the characters inBuf[0..inLen-1]
* in the message whose digest is being computed.
*/
DLLINTERFACE void utl_md5Update(MD5_CTX * mdContext, unsigned char *inBuf,
unsigned int inLen);
/*
* utl_md5Final: complete digest computation
*
* Parameters:
*
* mdContext pointer to context variable
*
* Return value:
*
* none
*
* Note: The function terminates the message-digest computation and
* ends with the desired message digest in mdContext.digest[0..15].
* Always call before using the digest[] variable.
*/
DLLINTERFACE void utl_md5Final(MD5_CTX * mdContext);
/* Ends C function definitions when using C++ */
#ifdef __cplusplus
};
#endif
#endif /* _utl_md5_h */

63
test/test-automation/fuzzer/utl_random.c Executable file
View file

@ -0,0 +1,63 @@
/*
utl_random
A "32-bit Multiply with carry" random number generator.
*/
#include "utl_random.h"
/* Initialize random number generator with two integer variables */
void utl_randomInit(RND_CTX * rndContext, unsigned int xi, unsigned int ci)
{
/*
* Choose a value for 'a' from this list
* 1791398085 1929682203 1683268614 1965537969 1675393560
* 1967773755 1517746329 1447497129 1655692410 1606218150
* 2051013963 1075433238 1557985959 1781943330 1893513180
* 1631296680 2131995753 2083801278 1873196400 1554115554
*/
rndContext->a = 1655692410;
rndContext->x = 30903;
rndContext->c = 0;
if (xi != 0)
rndContext->x = xi;
rndContext->c = ci;
rndContext->ah = rndContext->a >> 16;
rndContext->al = rndContext->a & 65535;
}
/* Initialize random number generator from time */
void utl_randomInitTime(RND_CTX * rndContext)
{
int a,b;
srand(time(NULL));
a=rand();
srand(clock());
b=rand();
utl_randomInit(rndContext, a, b);
}
/* Returns random numbers */
unsigned int utl_random(RND_CTX * rndContext)
{
unsigned int xh, xl;
xh = rndContext->x >> 16, xl = rndContext->x & 65535;
rndContext->x = rndContext->x * rndContext->a + rndContext->c;
rndContext->c =
xh * rndContext->ah + ((xh * rndContext->al) >> 16) +
((xl * rndContext->ah) >> 16);
if (xl * rndContext->al >= (~rndContext->c + 1))
rndContext->c++;
return (rndContext->x);
}

112
test/test-automation/fuzzer/utl_random.h Executable file
View file

@ -0,0 +1,112 @@
/*
A "32-bit Multiply with carry: random number generator.
Has a list of recommended multipliers. Very fast and good.
multiply-with-carry generator" x(n) = a*x(n-1) + carry mod 2^32.
period" (a*2^31)-1
*/
#ifndef _utl_random_h
#define _utl_random_h
/* Set up for C function definitions, even when using C++ */
#ifdef __cplusplus
extern "C" {
#endif
/* ------- Includes ---------- */
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
/* ------- Definitions ------- */
/*
* Macros that return random number in a specific format. See utl_random()
* below for details. Float values are in the range [0.0-1.0].
*/
#define utl_randomInt(c) ((int)utl_random(c))
#define utl_randomFloat(c) ((double)utl_random(c)/(unsigned long)0xffffffff)
typedef struct {
unsigned int a;
unsigned int x;
unsigned int c;
unsigned int ah;
unsigned int al;
} RND_CTX;
/* ---- Function Prototypes -------- */
#ifdef WIN32
#ifdef BUILD_DLL
#define DLLINTERFACE __declspec(dllexport)
#else
#define DLLINTERFACE __declspec(dllimport)
#endif
#else
#define DLLINTERFACE
#endif
/*
* utl_randomInit: Initialize random number generator with two integers.
*
* Paramaters:
*
* rndContext pointer to context structure
* xi, ci integers that define the random sequence
*
* Return value:
*
* none
*
* Note: The random sequence of numbers returned by utl_random() is the
* same for the same two integers and has a period of 2^31.
*
*/
DLLINTERFACE void utl_randomInit(RND_CTX * rndContext, unsigned int xi,
unsigned int ci);
/*
* utl_randomInitTime: Initialize random number generator with the time
*
* Parameters:
*
* rndContext pointer to context structure
*
* Return value:
*
* none
*
*/
DLLINTERFACE void utl_randomInitTime(RND_CTX * rndContext);
/*
* utl_random: Returns random numbers
*
* Parameters:
*
* rndContext pointer to context structure
*
* Return value:
*
* random number (32bit unsigned integer)
*
* Note: utl_randomInit() or utl_randomInitTime() must have been called
* before using this function.
*
*/
DLLINTERFACE unsigned int utl_random(RND_CTX * rndContext);
/* Ends C function definitions when using C++ */
#ifdef __cplusplus
};
#endif
#endif /* _utl_random_h */

6
test/test-automation/runner.c
View file

@ -865,7 +865,8 @@ PrintUsage() {
printf("Usage: ./runner [--in-proc] [--suite SUITE] [--test TEST]\n");
printf(" [--name-contains SUBSTR] [--show-tests]\n");
printf(" [--xml] [--xsl [STYLESHEET]] [--timeout VALUE]\n");
printf(" [--version] [--help]\n");
printf(" [--exec-key KEY] [--iterations VALUE]\n");
printf(" [--seed VALUE] [--version] [--help]\n");
printf("Options:\n");
printf(" --in-proc Executes tests in-process\n");
printf(" --show-tests Prints out all the executable tests\n");
@ -873,6 +874,9 @@ PrintUsage() {
printf(" --xsl [STYLESHEET] Adds XSL stylesheet to the XML test reports for\n");
printf(" browser viewing. Optionally uses the specified XSL\n");
printf(" file or URL instead of the default one\n");
printf(" --seed VALUE Specify fuzzing seed for the harness\n");
printf(" --iterations VALUE Specify how many times a test will be executed\n");
printf(" --exec-key KEY Run test(s) with specific execution key\n");
printf(" -tm --timeout VALUE Specify common timeout value for all tests\n");
printf(" Timeout is given in seconds and it'll override\n");
printf(" test specific timeout value only if the given\n");