/*
   Fuzzing ldb_comparison_fold()
   Copyright (C) Catalyst IT 2020

   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 3 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, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#include "fuzzing/fuzzing.h"
#include "charset.h"


int LLVMFuzzerInitialize(int *argc, char ***argv)
{
	return 0;
}


int LLVMFuzzerTestOneInput(const uint8_t *input, size_t len)
{
	struct ldb_val v[3] = {{},{},{}};
	size_t i, j, k;
	int results[9], ab, ac, bc;

	if (len < 3) {
		return 0;
	}

	j = 0;
	k = 0;
	v[j].data = discard_const(input);

	/*
	 * We split the input into 3 ldb_vals, on the byte '*' (42), chosen
	 * because it is *not* special with regard to termination, utf-8, or
	 * casefolding.
	 *
	 * if there are not 2 '*' bytes, the last value[s] will be empty, with
	 * a NULL pointer and zero length.
	 */

	for (i = 0; i < len; i++) {
		if (input[i] != '*') {
			continue;
		}
		v[j].length = i - k;
		i++;
		j++;
		if (j > 2 || i == len) {
			break;
		}
		k = i;
		v[j].data = discard_const(input + k);
	}

	for (i = 0; i < 3; i++) {
		char *s1 = (char*)v[i].data;
		size_t len1 = v[i].length;
		for (j = 0; j < 3; j++) {
			char *s2 = (char*)v[j].data;
			size_t len2 = v[j].length;
			int r = strncasecmp_ldb(s1, len1, s2, len2);
			if (abs(r) > 1) {
				abort();
			}
			results[i * 3 + j] = r;
		}
	}

	/*
	 * There are nine comparisons we make.
	 *
	 *    A B C
	 *  A = x x
	 *  B - = x
	 *  C - - =
	 *
	 * The diagonal should be all zeros (A == A, etc)
	 * The upper and lower triangles should complement each other
	 * (A > B implies B < A; A == B implies B == A).
	 *
	 * So we check for those identities first.
	 */

	if ((results[0] != 0) ||
	    (results[4] != 0) ||
	    (results[8] != 0)) {
		abort();
	}

	ab = results[3];
	ac = results[6];
	bc = results[7];

	if (ab != -results[1] ||
	    ac != -results[2] ||
	    bc != -results[5]) {
		abort();
	}

	 /*
	 * Then there are 27 states within the three comparisons of one
	 * triangle, because each of AB, AC, and BC can be in 3 states.
	 *
	 *  0    (A < B) (A < C) (B < C)   A < B < C
	 *  1    (A < B) (A < C) (B = C)   A < (B|C)
	 *  2    (A < B) (A < C) (B > C)   A < C < B
	 *  3    (A < B) (A = C) (B < C)    invalid
	 *  4    (A < B) (A = C) (B = C)    invalid
	 *  5    (A < B) (A = C) (B > C)   (A|C) < B
	 *  6    (A < B) (A > C) (B < C)    invalid
	 *  7    (A < B) (A > C) (B = C)    invalid
	 *  8    (A < B) (A > C) (B > C)   C < A < B
	 *  9    (A = B) (A < C) (B < C)   (A|B) < C
	 * 10    (A = B) (A < C) (B = C)    invalid
	 * 11    (A = B) (A < C) (B > C)    invalid
	 * 12    (A = B) (A = C) (B < C)    invalid
	 * 13    (A = B) (A = C) (B = C)   A = B = C
	 * 14    (A = B) (A = C) (B > C)    invalid
	 * 15    (A = B) (A > C) (B < C)    invalid
	 * 16    (A = B) (A > C) (B = C)    invalid
	 * 17    (A = B) (A > C) (B > C)   C < (A|B)
	 * 18    (A > B) (A < C) (B < C)   B < C < A
	 * 19    (A > B) (A < C) (B = C)    invalid
	 * 20    (A > B) (A < C) (B > C)    invalid
	 * 21    (A > B) (A = C) (B < C)   B < (A|C)
	 * 22    (A > B) (A = C) (B = C)    invalid
	 * 23    (A > B) (A = C) (B > C)    invalid
	 * 24    (A > B) (A > C) (B < C)   B < C < A
	 * 25    (A > B) (A > C) (B = C)   (B|C) < A
	 * 26    (A > B) (A > C) (B > C)   C < B < A
	 *
	 * It actually turns out to be quite simple:
	 */

	if (ab == 0) {
		if (ac != bc) {
			abort();
		}
	} else if (ab < 0) {
		if (ac >= 0 && bc <= 0) {
			abort();
		}
	} else {
		if (ac <= 0 && bc >= 0) {
			abort();
		}
	}

	return 0;
}