checkFrame.c File Reference

#include "util.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <assert.h>
#include "lz4frame.h"
#include "lz4.h"
#include "xxhash.h"

Go to the source code of this file.

Classes
struct	cRess_t

Macros
#define	LZ4F_STATIC_LINKING_ONLY
#define	XXH_STATIC_LINKING_ONLY
#define	KB   *(1U<<10)
#define	MB   *(1U<<20)
#define	GB   *(1U<<30)
#define	DISPLAY(...)   fprintf(stderr, __VA_ARGS__)
#define	DISPLAYLEVEL(l, ...)   if (displayLevel>=l) { DISPLAY(__VA_ARGS__); }
#define	DEBUG   0
#define	DEBUGOUTPUT(...)   if (DEBUG) DISPLAY(__VA_ARGS__);
#define	EXM_THROW(error, ...)
#define	MIN(a, b)   ( (a) < (b) ? (a) : (b) )
#define	MAX(a, b)   ( (a) > (b) ? (a) : (b) )

Functions
static int	createCResources (cRess_t *ress)
static void	freeCResources (cRess_t ress)
int	frameCheck (cRess_t ress, FILE *const srcFile, unsigned bsid, size_t blockSize)
int	FUZ_usage (const char *programName)
int	main (int argc, const char **argv)

Variables
static U32	no_prompt = 0
static U32	displayLevel = 2
static U32	use_pause = 0

Macro Definition Documentation

DEBUG

#define DEBUG   0

Definition at line 63 of file checkFrame.c.

DEBUGOUTPUT

#define DEBUGOUTPUT

(

...

)

if (DEBUG) DISPLAY(__VA_ARGS__);

Definition at line 65 of file checkFrame.c.

DISPLAY

#define DISPLAY

(

...

)

fprintf(stderr, __VA_ARGS__)

Definition at line 56 of file checkFrame.c.

DISPLAYLEVEL

#define DISPLAYLEVEL	(		l,
			...
	)		if (displayLevel>=l) { DISPLAY(__VA_ARGS__); }

Definition at line 57 of file checkFrame.c.

EXM_THROW

#define EXM_THROW	(		error,
			...
	)

Value:

{                                                                         \
    DEBUGOUTPUT("Error defined at %s, line %i : \n", __FILE__, __LINE__); \
    DISPLAYLEVEL(1, "Error %i : ", error);                                \
    DISPLAYLEVEL(1, __VA_ARGS__);                                         \
    DISPLAYLEVEL(1, " \n");                                               \
    return(error);                                                          \
}

Definition at line 66 of file checkFrame.c.

GB

#define GB   *(1U<<30)

Definition at line 50 of file checkFrame.c.

KB

#define KB   *(1U<<10)

Definition at line 48 of file checkFrame.c.

LZ4F_STATIC_LINKING_ONLY

#define LZ4F_STATIC_LINKING_ONLY

Definition at line 37 of file checkFrame.c.

MAX

#define MAX	(		a,
			b
	)		( (a) > (b) ? (a) : (b) )

Definition at line 89 of file checkFrame.c.

MB

#define MB   *(1U<<20)

Definition at line 49 of file checkFrame.c.

MIN

#define MIN	(		a,
			b
	)		( (a) < (b) ? (a) : (b) )

Definition at line 88 of file checkFrame.c.

XXH_STATIC_LINKING_ONLY

#define XXH_STATIC_LINKING_ONLY

Definition at line 41 of file checkFrame.c.

Function Documentation

createCResources()

static int createCResources ( cRess_t *  ress )

static

Definition at line 99 of file checkFrame.c.

{
    ress->srcBufferSize = 4 MB;
    ress->srcBuffer = malloc(ress->srcBufferSize);
    ress->dstBufferSize = 4 MB;
    ress->dstBuffer = malloc(ress->dstBufferSize);
 
    if (!ress->srcBuffer || !ress->dstBuffer) {
        free(ress->srcBuffer);
        free(ress->dstBuffer);
        EXM_THROW(20, "Allocation error : not enough memory");
    }
 
    if (LZ4F_isError( LZ4F_createDecompressionContext(&(ress->ctx), LZ4F_VERSION) )) {
        free(ress->srcBuffer);
        free(ress->dstBuffer);
        EXM_THROW(21, "Unable to create decompression context");
    }
    return 0;
}

References cRess_t::ctx, cRess_t::dstBuffer, cRess_t::dstBufferSize, EXM_THROW, free(), LZ4F_createDecompressionContext(), LZ4F_isError(), LZ4F_VERSION, malloc(), MB, cRess_t::srcBuffer, and cRess_t::srcBufferSize.

Referenced by main().

frameCheck()

int frameCheck	(	cRess_t	ress,
		FILE *const	srcFile,
		unsigned	bsid,
		size_t	blockSize
	)

Definition at line 128 of file checkFrame.c.

{
    LZ4F_errorCode_t nextToLoad = 0;
    size_t curblocksize = 0;
    int partialBlock = 0;
 
    /* Main Loop */
    for (;;) {
        size_t readSize;
        size_t pos = 0;
        size_t decodedBytes = ress.dstBufferSize;
        size_t remaining;
        LZ4F_frameInfo_t frameInfo;
 
        /* Read input */
        readSize = fread(ress.srcBuffer, 1, ress.srcBufferSize, srcFile);
        if (!readSize) break;   /* reached end of file or stream */
 
        while (pos < readSize) {  /* still to read */
            /* Decode Input (at least partially) */
            if (!nextToLoad) {
                /* LZ4F_decompress returned 0 : starting new frame */
                curblocksize = 0;
                remaining = readSize - pos;
                nextToLoad = LZ4F_getFrameInfo(ress.ctx, &frameInfo, (char*)(ress.srcBuffer)+pos, &remaining);
                if (LZ4F_isError(nextToLoad))
                    EXM_THROW(22, "Error getting frame info: %s",
                                LZ4F_getErrorName(nextToLoad));
                if (frameInfo.blockSizeID != bsid)
                    EXM_THROW(23, "Block size ID %u != expected %u",
                                frameInfo.blockSizeID, bsid);
                pos += remaining;
                /* nextToLoad should be block header size */
                remaining = nextToLoad;
                decodedBytes = ress.dstBufferSize;
                nextToLoad = LZ4F_decompress(ress.ctx, ress.dstBuffer, &decodedBytes, (char*)(ress.srcBuffer)+pos, &remaining, NULL);
                if (LZ4F_isError(nextToLoad)) EXM_THROW(24, "Decompression error : %s", LZ4F_getErrorName(nextToLoad));
                pos += remaining;
            }
            decodedBytes = ress.dstBufferSize;
            /* nextToLoad should be just enough to cover the next block */
            if (nextToLoad > (readSize - pos)) {
                /* block is not fully contained in current buffer */
                partialBlock = 1;
                remaining = readSize - pos;
            } else {
                if (partialBlock) {
                    partialBlock = 0;
                }
                remaining = nextToLoad;
            }
            nextToLoad = LZ4F_decompress(ress.ctx, ress.dstBuffer, &decodedBytes, (char*)(ress.srcBuffer)+pos, &remaining, NULL);
            if (LZ4F_isError(nextToLoad)) EXM_THROW(24, "Decompression error : %s", LZ4F_getErrorName(nextToLoad));
            curblocksize += decodedBytes;
            pos += remaining;
            if (!partialBlock) {
                /* detect small block due to end of frame; the final 4-byte frame checksum could be left in the buffer */
                if ((curblocksize != 0) && (nextToLoad > 4)) {
                    if (curblocksize != blockSize)
                        EXM_THROW(25, "Block size %u != expected %u, pos %u\n",
                                    (unsigned)curblocksize, (unsigned)blockSize, (unsigned)pos);
                }
                curblocksize = 0;
            }
        }
    }
    /* can be out because readSize == 0, which could be an fread() error */
    if (ferror(srcFile)) EXM_THROW(26, "Read error");
 
    if (nextToLoad!=0) EXM_THROW(27, "Unfinished stream");
 
    return 0;
}

References LZ4F_frameInfo_t::blockSizeID, cRess_t::ctx, cRess_t::dstBuffer, cRess_t::dstBufferSize, EXM_THROW, LZ4F_decompress(), LZ4F_getErrorName(), LZ4F_getFrameInfo(), LZ4F_isError(), NULL, pos, cRess_t::srcBuffer, and cRess_t::srcBufferSize.

Referenced by main().

freeCResources()

static void freeCResources ( cRess_t  ress )

static

Definition at line 120 of file checkFrame.c.

{
    free(ress.srcBuffer);
    free(ress.dstBuffer);
 
    (void) LZ4F_freeDecompressionContext(ress.ctx);
}

References cRess_t::ctx, cRess_t::dstBuffer, free(), LZ4F_freeDecompressionContext(), and cRess_t::srcBuffer.

Referenced by main().

FUZ_usage()

int FUZ_usage

(

const char *

programName

)

Definition at line 202 of file checkFrame.c.

{
    DISPLAY( "Usage :\n");
    DISPLAY( "      %s [args] filename\n", programName);
    DISPLAY( "\n");
    DISPLAY( "Arguments :\n");
    DISPLAY( " -b#    : expected blocksizeID [4-7] (required)\n");
    DISPLAY( " -B#    : expected blocksize [32-4194304] (required)\n");
    DISPLAY( " -v     : verbose\n");
    DISPLAY( " -h     : display help and exit\n");
    return 0;
}

References DISPLAY.

Referenced by main().

main()

int main	(	int	argc,
		const char **	argv
	)

Definition at line 216 of file checkFrame.c.

{
    int argNb;
    unsigned bsid=0;
    size_t blockSize=0;
    const char* const programName = argv[0];
 
    /* Check command line */
    for (argNb=1; argNb<argc; argNb++) {
        const char* argument = argv[argNb];
 
        if(!argument) continue;   /* Protection if argument empty */
 
        /* Decode command (note : aggregated short commands are allowed) */
        if (argument[0]=='-') {
            if (!strcmp(argument, "--no-prompt")) {
                no_prompt=1;
                displayLevel=1;
                continue;
            }
            argument++;
 
            while (*argument!=0) {
                switch(*argument)
                {
                case 'h':
                    return FUZ_usage(programName);
                case 'v':
                    argument++;
                    displayLevel++;
                    break;
                case 'q':
                    argument++;
                    displayLevel--;
                    break;
                case 'p': /* pause at the end */
                    argument++;
                    use_pause = 1;
                    break;
 
                case 'b':
                    argument++;
                    bsid=0;
                    while ((*argument>='0') && (*argument<='9')) {
                        bsid *= 10;
                        bsid += (unsigned)(*argument - '0');
                        argument++;
                    }
                    break;
 
                case 'B':
                    argument++;
                    blockSize=0;
                    while ((*argument>='0') && (*argument<='9')) {
                        blockSize *= 10;
                        blockSize += (size_t)(*argument - '0');
                        argument++;
                    }
                    break;
 
                default:
                    ;
                    return FUZ_usage(programName);
                }
            }
        } else {
            int err;
            FILE *srcFile;
            cRess_t ress;
            if (bsid == 0 || blockSize == 0)
              return FUZ_usage(programName);
            DISPLAY("Starting frame checker (%i-bits, %s)\n", (int)(sizeof(size_t)*8), LZ4_VERSION_STRING);
            err = createCResources(&ress);
            if (err) return (err);
            srcFile = fopen(argument, "rb");
            if ( srcFile==NULL ) {
                freeCResources(ress);
                EXM_THROW(1, "%s: %s \n", argument, strerror(errno));
            }
            assert (srcFile != NULL);
            err = frameCheck(ress, srcFile, bsid, blockSize);
            freeCResources(ress);
            fclose(srcFile);
            return (err);
        }
    }
    return 0;
}

References argv, assert(), createCResources(), DISPLAY, displayLevel, err, EXM_THROW, benchmark::FILE, frameCheck(), freeCResources(), FUZ_usage(), LZ4_VERSION_STRING, no_prompt, NULL, unsigned, and use_pause.

Variable Documentation

displayLevel

U32 displayLevel = 2

static

Definition at line 81 of file checkFrame.c.

Referenced by main().

no_prompt

U32 no_prompt = 0

static

Definition at line 80 of file checkFrame.c.

Referenced by main().

use_pause

U32 use_pause = 0

static

Definition at line 82 of file checkFrame.c.

Referenced by main().