fs/ntfs/collate.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * NTFS kernel collation handling.
 *
 * Copyright (c) 2004 Anton Altaparmakov
 *
 * Part of this file is based on code from the NTFS-3G.
 * and is copyrighted by the respective authors below:
 * Copyright (c) 2004 Anton Altaparmakov
 * Copyright (c) 2005 Yura Pakhuchiy
 */

#include "collate.h"
#include "debug.h"
#include "ntfs.h"

#include <linux/sort.h>

static int ntfs_collate_binary(struct ntfs_volume *vol,
		const void *data1, const u32 data1_len,
		const void *data2, const u32 data2_len)
{
	int rc;

	rc = memcmp(data1, data2, min(data1_len, data2_len));
	if (!rc && (data1_len != data2_len)) {
		if (data1_len < data2_len)
			rc = -1;
		else
			rc = 1;
	}
	return rc;
}

static int ntfs_collate_ntofs_ulong(struct ntfs_volume *vol,
		const void *data1, const u32 data1_len,
		const void *data2, const u32 data2_len)
{
	int rc;
	u32 d1 = le32_to_cpup(data1), d2 = le32_to_cpup(data2);

	if (data1_len != data2_len || data1_len != 4)
		return -EINVAL;

	if (d1 < d2)
		rc = -1;
	else {
		if (d1 == d2)
			rc = 0;
		else
			rc = 1;
	}
	return rc;
}

/*
 * ntfs_collate_ntofs_ulongs - Which of two le32 arrays should be listed first
 * @vol: ntfs volume
 * @data1: first ulong array to collate
 * @data1_len: length in bytes of @data1
 * @data2: second ulong array to collate
 * @data2_len: length in bytes of @data2
 *
 * Returns: -1, 0 or 1 depending of how the arrays compare
 */
static int ntfs_collate_ntofs_ulongs(struct ntfs_volume *vol,
		const void *data1, const u32 data1_len,
		const void *data2, const u32 data2_len)
{
	int len;
	const __le32 *p1 = data1, *p2 = data2;
	u32 d1, d2;

	if (data1_len != data2_len || data1_len & 3) {
		ntfs_error(vol->sb, "data1_len or data2_len not valid\n");
		return -1;
	}

	len = data1_len;
	do {
		d1 = le32_to_cpup(p1);
		p1++;
		d2 = le32_to_cpup(p2);
		p2++;
	} while (d1 == d2 && (len -= 4) > 0);
	return cmp_int(d1, d2);
}

/*
 * ntfs_collate_file_name - Which of two filenames should be listed first
 * @vol: ntfs volume
 * @data1: first filename to collate
 * @data1_len: length in bytes of @data1(unused)
 * @data2: second filename to collate
 * @data2_len: length in bytes of @data2(unused)
 */
static int ntfs_collate_file_name(struct ntfs_volume *vol,
		const void *data1, const u32 data1_len,
		const void *data2, const u32 data2_len)
{
	int rc;

	rc = ntfs_file_compare_values(data1, data2, -EINVAL,
			IGNORE_CASE, vol->upcase, vol->upcase_len);
	if (!rc)
		rc = ntfs_file_compare_values(data1, data2,
			-EINVAL, CASE_SENSITIVE, vol->upcase, vol->upcase_len);
	return rc;
}

/*
 * ntfs_collate - collate two data items using a specified collation rule
 * @vol:	ntfs volume to which the data items belong
 * @cr:		collation rule to use when comparing the items
 * @data1:	first data item to collate
 * @data1_len:	length in bytes of @data1
 * @data2:	second data item to collate
 * @data2_len:	length in bytes of @data2
 *
 * Collate the two data items @data1 and @data2 using the collation rule @cr
 * and return -1, 0, ir 1 if @data1 is found, respectively, to collate before,
 * to match, or to collate after @data2. return -EINVAL if an error occurred.
 */
int ntfs_collate(struct ntfs_volume *vol, __le32 cr,
		const void *data1, const u32 data1_len,
		const void *data2, const u32 data2_len)
{
	switch (le32_to_cpu(cr)) {
	case le32_to_cpu(COLLATION_BINARY):
		return ntfs_collate_binary(vol, data1, data1_len,
					   data2, data2_len);
	case le32_to_cpu(COLLATION_FILE_NAME):
		return ntfs_collate_file_name(vol, data1, data1_len,
					      data2, data2_len);
	case le32_to_cpu(COLLATION_NTOFS_ULONG):
		return ntfs_collate_ntofs_ulong(vol, data1, data1_len,
						data2, data2_len);
	case le32_to_cpu(COLLATION_NTOFS_ULONGS):
		return ntfs_collate_ntofs_ulongs(vol, data1, data1_len,
						 data2, data2_len);
	default:
		ntfs_error(vol->sb, "Unknown collation rule 0x%x",
			   le32_to_cpu(cr));
		return -EINVAL;
	}
}