ffuzzy.h

Go to the documentation of this file.

/*

    libffuzzy : Fast ssdeep comparison library

    ffuzzy.h
    Public API for libffuzzy


    CREDITS OF ORIGINAL VERSION OF SSDEEP

    Copyright (C) 2002 Andrew Tridgell <tridge@samba.org>
    Copyright (C) 2006 ManTech International Corporation
    Copyright (C) 2013 Helmut Grohne <helmut@subdivi.de>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA


    CREDIT OF MODIFIED PORTIONS

    Copyright (C) 2014 Tsukasa OI <li@livegrid.org>

*/
#ifndef FFUZZY_FFUZZY_H
#define FFUZZY_FFUZZY_H

#ifndef __cplusplus
#include <stdbool.h>
#endif
#include <stddef.h>

#define FFUZZY_SPAMSUM_LENGTH 64

#define FFUZZY_MIN_BLOCKSIZE 3ul

#define FFUZZY_NUM_BLOCKHASHES 31

#define FFUZZY_MAX_BLOCKSIZE (FFUZZY_MIN_BLOCKSIZE << (FFUZZY_NUM_BLOCKHASHES-1))

#define FFUZZY_PRETTY_LEN 141

#define FFUZZY_MIN_MATCH 7


#ifdef __cplusplus
extern "C" {
#endif

typedef struct
{
    size_t len1, len2;
    unsigned long block_size;
    char digest[FFUZZY_SPAMSUM_LENGTH * 2];
} ffuzzy_digest;



bool ffuzzy_read_digest(ffuzzy_digest *digest, const char *s);

int ffuzzy_compare_digest(const ffuzzy_digest *d1, const ffuzzy_digest *d2);

int ffuzzy_compare(const char *str1, const char *str2);

int ffuzzy_compare_digest_near(const ffuzzy_digest *d1, const ffuzzy_digest *d2);

int ffuzzy_compare_digest_near_eq(const ffuzzy_digest *d1, const ffuzzy_digest *d2);

int ffuzzy_compare_digest_near_lt(const ffuzzy_digest *d1, const ffuzzy_digest *d2);

bool ffuzzy_blocksize_is_valid(unsigned long block_size);

bool ffuzzy_blocksize_is_natural(unsigned long block_size);

bool ffuzzy_blocksize_is_near(unsigned long block_size1, unsigned long block_size2);

bool ffuzzy_blocksize_is_far_le(unsigned long block_size1, unsigned long block_size2);

bool ffuzzy_digest_is_valid_lengths(const ffuzzy_digest *digest);

bool ffuzzy_digest_is_valid_buffer(const ffuzzy_digest *digest);

bool ffuzzy_digest_is_natural_buffer(const ffuzzy_digest *digest);

bool ffuzzy_digest_is_valid(const ffuzzy_digest *digest);

bool ffuzzy_digest_is_natural(const ffuzzy_digest *digest);

int ffuzzy_digestcmp(const ffuzzy_digest *d1, const ffuzzy_digest *d2);

int ffuzzy_digestcmp_blocksize(const ffuzzy_digest *d1, const ffuzzy_digest *d2);

int ffuzzy_digestcmp_blocksize_n(const ffuzzy_digest *d1, const ffuzzy_digest *d2);

bool ffuzzy_pretty_digest(char *buf, size_t buflen, const ffuzzy_digest *digest);

typedef struct
{
    size_t len1, len2;
    unsigned long block_size;
    char digest[FFUZZY_SPAMSUM_LENGTH * 2];
} ffuzzy_udigest;


bool ffuzzy_read_udigest(ffuzzy_udigest *udigest, const char *s);

bool ffuzzy_udigest_is_valid_lengths(const ffuzzy_udigest *udigest);

bool ffuzzy_udigest_is_natural_buffer(const ffuzzy_udigest *udigest);

bool ffuzzy_udigest_is_valid(const ffuzzy_udigest *udigest);

bool ffuzzy_udigest_is_natural(const ffuzzy_udigest *udigest);

int ffuzzy_udigestcmp(const ffuzzy_udigest *d1, const ffuzzy_udigest *d2);

int ffuzzy_udigestcmp_blocksize(const ffuzzy_udigest *d1, const ffuzzy_udigest *d2);

int ffuzzy_udigestcmp_blocksize_n(const ffuzzy_udigest *d1, const ffuzzy_udigest *d2);

bool ffuzzy_pretty_udigest(char *buf, size_t buflen, const ffuzzy_udigest *udigest);


void ffuzzy_convert_digest_to_udigest(ffuzzy_udigest *udigest, const ffuzzy_digest *digest);

void ffuzzy_convert_udigest_to_digest(ffuzzy_digest *digest, const ffuzzy_udigest *udigest);

int ffuzzy_score_cap(int s1len, int s2len, unsigned long block_size);

int ffuzzy_score_cap_1(int minslen, unsigned long block_size);

int ffuzzy_score_strings(
    const char *s1, size_t s1len,
    const char *s2, size_t s2len,
    unsigned long block_size
);

#ifdef __cplusplus
}
#endif

#endif