/*
   Unix SMB/CIFS implementation.
   Samba utility functions
   Copyright (C) Andrew Tridgell 1992-2001
   Copyright (C) Simo Sorce 2001

   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 "replace.h"
#include "system/locale.h"
#include "charset.h"
#include "lib/util/byteorder.h"
#include "lib/util/fault.h"
#include "lib/util/tsort.h"

/**
 String replace.
 NOTE: oldc and newc must be 7 bit characters
**/
_PUBLIC_ void string_replace_m(char *s, char oldc, char newc)
{
	struct smb_iconv_handle *ic = get_iconv_handle();
	while (s && *s) {
		size_t size;
		codepoint_t c = next_codepoint_handle(ic, s, &size);
		if (c == oldc) {
			*s = newc;
		}
		s += size;
	}
}

/**
 Convert a string to lower case, allocated with talloc
**/
_PUBLIC_ char *strlower_talloc_handle(struct smb_iconv_handle *iconv_handle,
				      TALLOC_CTX *ctx, const char *src)
{
	size_t size=0;
	char *dest;

	if(src == NULL) {
		return NULL;
	}

	/* this takes advantage of the fact that upper/lower can't
	   change the length of a character by more than 1 byte */
	dest = talloc_array(ctx, char, 2*(strlen(src))+1);
	if (dest == NULL) {
		return NULL;
	}

	while (*src) {
		size_t c_size;
		codepoint_t c = next_codepoint_handle(iconv_handle, src, &c_size);
		src += c_size;

		c = tolower_m(c);

		c_size = push_codepoint_handle(iconv_handle, dest+size, c);
		if (c_size == -1) {
			talloc_free(dest);
			return NULL;
		}
		size += c_size;
	}

	dest[size] = 0;

	/* trim it so talloc_append_string() works */
	dest = talloc_realloc(ctx, dest, char, size+1);

	talloc_set_name_const(dest, dest);

	return dest;
}

_PUBLIC_ char *strlower_talloc(TALLOC_CTX *ctx, const char *src)
{
	struct smb_iconv_handle *iconv_handle = get_iconv_handle();
	return strlower_talloc_handle(iconv_handle, ctx, src);
}

/**
 Convert a string to UPPER case, allocated with talloc
 source length limited to n bytes, iconv handle supplied
**/
_PUBLIC_ char *strupper_talloc_n_handle(struct smb_iconv_handle *iconv_handle,
					TALLOC_CTX *ctx, const char *src, size_t n)
{
	size_t size=0;
	char *dest;

	if (!src) {
		return NULL;
	}

	/* this takes advantage of the fact that upper/lower can't
	   change the length of a character by more than 1 byte */
	dest = talloc_array(ctx, char, 2*(n+1));
	if (dest == NULL) {
		return NULL;
	}

	while (n && *src) {
		size_t c_size;
		codepoint_t c = next_codepoint_handle_ext(iconv_handle, src, n,
							  CH_UNIX, &c_size);
		src += c_size;
		n -= c_size;

		c = toupper_m(c);

		c_size = push_codepoint_handle(iconv_handle, dest+size, c);
		if (c_size == -1) {
			talloc_free(dest);
			return NULL;
		}
		size += c_size;
	}

	dest[size] = 0;

	/* trim it so talloc_append_string() works */
	dest = talloc_realloc(ctx, dest, char, size+1);

	talloc_set_name_const(dest, dest);

	return dest;
}

/**
 Convert a string to UPPER case, allocated with talloc
 source length limited to n bytes
**/
_PUBLIC_ char *strupper_talloc_n(TALLOC_CTX *ctx, const char *src, size_t n)
{
	struct smb_iconv_handle *iconv_handle = get_iconv_handle();
	return strupper_talloc_n_handle(iconv_handle, ctx, src, n);
}
/**
 Convert a string to UPPER case, allocated with talloc
**/
_PUBLIC_ char *strupper_talloc(TALLOC_CTX *ctx, const char *src)
{
	return strupper_talloc_n(ctx, src, src?strlen(src):0);
}

/**
 talloc_strdup() a unix string to upper case.
**/
_PUBLIC_ char *talloc_strdup_upper(TALLOC_CTX *ctx, const char *src)
{
	return strupper_talloc(ctx, src);
}


/*
 * strncasecmp_ldb() works like a *bit* like strncasecmp, with various
 * tricks to suit the way LDB compares strings. The differences are:
 *
 * 0. each string has it's own length.
 *
 * 1. consecutive spaces are collapsed down to one space, so that
 *    "a  b" equals "a b". (this is why each string needs its own
 *    length). Leading and trailing spaces are removed altogether.
 *
 * 2. Comparisons are done in UPPER CASE, as Windows does, not in
 *    lowercase as POSIX would have it.
 *
 * 3. An invalid byte compares higher than any real character. For example,
 *    "hello\xc2\xff" would sort higher than "hello\xcd\xb6", because CD
 *    B6 is a valid sequence and C2 FF is not.
 *
 * 4. If two strings become invalid on the same character, the rest
 *    of the string is compared via ldb ASCII case fold rules.
 *
 *    For example, "hellō\xC2\xFFworld" < " hElLŌ\xFE ", because the the
 *    strings are equal up to 'ō' by utf-8 casefold, but the "\xc2\xff" and
 *    "\xfe" are invalid sequences. At that point, we skip to the byte-by-byte
 *    (but space-eating, casefolding) comparison, and 0xc2 < 0xff.
 */

#define EAT_SPACE(s, len, ends_in_space)			 \
	do {							 \
		while (len) {					 \
			if (*s != ' ') {			 \
				break;				 \
			}					 \
			s++;					 \
			len--;					 \
		}						 \
		ends_in_space = (len == 0 || *s == '\0');	 \
	} while(0)


_PUBLIC_ int strncasecmp_ldb(const char *s1,
			     size_t len1,
			     const char *s2,
			     size_t len2)
{
	struct smb_iconv_handle *iconv_handle = get_iconv_handle();
	codepoint_t c1, c2;
	size_t cs1, cs2;
	bool ends_in_space1, ends_in_space2;
	int ret;
	bool end1, end2;

	EAT_SPACE(s1, len1, ends_in_space1);
	EAT_SPACE(s2, len2, ends_in_space2);
	/*
	 * if ends_in_space was set, the string was empty or only
	 * spaces (which we treat as equivalent).
	 */
	if (ends_in_space1 && ends_in_space2) {
		return 0;
	}
	if (ends_in_space1) {
		return -1;
	}
	if (ends_in_space2) {
		return 1;
	}

	while (true) {
		/*
		 * If the next byte is a space, we eat all the spaces,
		 * and say we found a single codepoint. If the spaces
		 * were at the end of the string, the codepoint is 0,
		 * as if there were no spaces. Otherwise it is 0x20,
		 * as if there was one space.
		 *
		 * Setting the codepoint to 0 will break the loop, but
		 * only after codepoints have been found in both strings.
		 */
		if (len1 == 0 || *s1 == 0) {
			c1 = 0;
		} else if (*s1 == ' ') {
			EAT_SPACE(s1, len1, ends_in_space1);
			c1 = ends_in_space1 ? 0 : ' ';
		} else if ((*s1 & 0x80) == 0) {
			c1 = *s1;
			s1++;
			len1--;
		} else {
			c1 = next_codepoint_handle_ext(iconv_handle, s1, len1,
						       CH_UNIX, &cs1);
			if (c1 != INVALID_CODEPOINT) {
				s1 += cs1;
				len1 -= cs1;
			}
		}

		if (len2 == 0 || *s2 == 0) {
			c2 = 0;
		} else if (*s2 == ' ') {
			EAT_SPACE(s2, len2, ends_in_space2);
			c2 = ends_in_space2 ? 0 : ' ';
		} else if ((*s2 & 0x80) == 0) {
			c2 = *s2;
			s2++;
			len2--;
		} else {
			c2 = next_codepoint_handle_ext(iconv_handle, s2, len2,
						       CH_UNIX, &cs2);
			if (c2 != INVALID_CODEPOINT) {
				s2 += cs2;
				len2 -= cs2;
			}
		}

		if (c1 == 0 || c2 == 0 ||
		    c1 == INVALID_CODEPOINT || c2 == INVALID_CODEPOINT) {
			break;
		}

		if (c1 == c2) {
			continue;
		}
		c1 = toupper_m(c1);
		c2 = toupper_m(c2);
		if (c1 != c2) {
			break;
		}
	}

	/*
	 * Either a difference has been found, or one or both strings have
	 * ended or hit invalid codepoints.
	 */
	ret = NUMERIC_CMP(c1, c2);

	if (ret != 0) {
		return ret;
	}
	/*
	 * the strings are equal up to here, but one might be longer.
	 */
	end1 = len1 == 0 || *s1 == 0;
	end2 = len2 == 0 || *s2 == 0;

	if (end1 && end2) {
		return 0;
	}
	if (end1) {
		return -1;
	}
	if (end2) {
		return -1;
	}

	/*
	 * By elimination, if we got here, we have INVALID_CODEPOINT on both
	 * sides.
	 *
	 * THere is no perfect option, but what we choose to do is continue on
	 * with ascii case fold (as if calling ldb_comparison_fold_ascii()
	 * which is private to ldb, so we can't just defer to it).
	 */
	while (true) {
		if (len1 == 0 || *s1 == 0) {
			c1 = 0;
		} else if (*s1 == ' ') {
			EAT_SPACE(s1, len1, ends_in_space1);
			c1 = ends_in_space1 ? 0 : ' ';
		} else {
			c1 = *s1;
			s1++;
			len1--;
			c1 = ('a' <= c1 && c1 <= 'z') ? c1 ^ 0x20 : c1;
		}

		if (len2 == 0 || *s2 == 0) {
			c2 = 0;
		} else if (*s2 == ' ') {
			EAT_SPACE(s2, len2, ends_in_space2);
			c2 = ends_in_space2 ? 0 : ' ';
		} else {
			c2 = *s2;
			s2++;
			len2--;
			c2 = ('a' <= c2 && c2 <= 'z') ? c2 ^ 0x20 : c2;
		}

		if (c1 == 0 || c2 == 0 || c1 != c2) {
			break;
		}
	}
	return NUMERIC_CMP(c1, c2);
}

#undef EAT_SPACE


/**
 Find the number of 'c' chars in a string
**/
_PUBLIC_ size_t count_chars_m(const char *s, char c)
{
	struct smb_iconv_handle *ic = get_iconv_handle();
	size_t count = 0;

	while (*s) {
		size_t size;
		codepoint_t c2 = next_codepoint_handle(ic, s, &size);
		if (c2 == c) count++;
		s += size;
	}

	return count;
}

size_t ucs2_align(const void *base_ptr, const void *p, int flags)
{
	if (flags & (STR_NOALIGN|STR_ASCII)) {
		return 0;
	}
	return PTR_DIFF(p, base_ptr) & 1;
}

/**
return the number of bytes occupied by a buffer in CH_UTF16 format
**/
size_t utf16_len(const void *buf)
{
	size_t len;

	for (len = 0; PULL_LE_U16(buf,len); len += 2) ;

	return len;
}

/**
return the number of bytes occupied by a buffer in CH_UTF16 format
the result includes the null termination
**/
size_t utf16_null_terminated_len(const void *buf)
{
	return utf16_len(buf) + 2;
}

/**
return the number of bytes occupied by a buffer in CH_UTF16 format
limited by 'n' bytes
**/
size_t utf16_len_n(const void *src, size_t n)
{
	size_t len;

	for (len = 0; (len+2 <= n) && PULL_LE_U16(src, len); len += 2) ;

	return len;
}

/**
return the number of bytes occupied by a buffer in CH_UTF16 format
the result includes the null termination
limited by 'n' bytes
**/
size_t utf16_null_terminated_len_n(const void *src, size_t n)
{
	size_t len;

	len = utf16_len_n(src, n);

	if (len+2 <= n) {
		len += 2;
	}

	return len;
}

unsigned char *talloc_utf16_strlendup(TALLOC_CTX *mem_ctx, const char *str, size_t len)
{
	unsigned char *new_str = NULL;

	/* Check for overflow. */
	if (len > SIZE_MAX - 2) {
		return NULL;
	}

	/*
	 * Allocate the new string, including space for the
	 * UTF‐16 null terminator.
	 */
	new_str = talloc_size(mem_ctx, len + 2);
	if (new_str == NULL) {
		return NULL;
	}

	memcpy(new_str, str, len);

	/*
	 * Ensure that the UTF‐16 string is
	 * null‐terminated.
	 */
	new_str[len] = '\0';
	new_str[len + 1] = '\0';

	return new_str;
}

unsigned char *talloc_utf16_strdup(TALLOC_CTX *mem_ctx, const char *str)
{
	if (str == NULL) {
		return NULL;
	}
	return talloc_utf16_strlendup(mem_ctx, str, utf16_len(str));
}

unsigned char *talloc_utf16_strndup(TALLOC_CTX *mem_ctx, const char *str, size_t n)
{
	if (str == NULL) {
		return NULL;
	}
	return talloc_utf16_strlendup(mem_ctx, str, utf16_len_n(str, n));
}

/**
 * Determine the length and validity of a utf-8 string.
 *
 * @param input the string pointer
 * @param maxlen maximum size of the string
 * @param byte_len receives the length of the valid section
 * @param char_len receives the number of unicode characters in the valid section
 * @param utf16_len receives the number of bytes the string would need in UTF16 encoding.
 *
 * @return true if the input is valid up to maxlen, or a '\0' byte, otherwise false.
 */
bool utf8_check(const char *input, size_t maxlen,
		size_t *byte_len,
		size_t *char_len,
		size_t *utf16_len)
{
	const uint8_t *s = (const uint8_t *)input;
	size_t i;
	size_t chars = 0;
	size_t long_chars = 0;
	uint32_t codepoint;
	uint8_t a, b, c, d;
	for (i = 0; i < maxlen; i++, chars++) {
		if (s[i] == 0) {
			break;
		}
		if (s[i] < 0x80) {
			continue;
		}
		if ((s[i] & 0xe0) == 0xc0) {
			/* 110xxxxx 10xxxxxx */
			a = s[i];
			if (maxlen - i < 2) {
				goto error;
			}
			b = s[i + 1];
			if ((b & 0xc0) != 0x80) {
				goto error;
			}
			codepoint = (a & 31) << 6 | (b & 63);
			if (codepoint < 0x80) {
				goto error;
			}
			i++;
			continue;
		}
		if ((s[i] & 0xf0) == 0xe0) {
			/* 1110xxxx 10xxxxxx 10xxxxxx */
			if (maxlen - i < 3) {
				goto error;
			}
			a = s[i];
			b = s[i + 1];
			c = s[i + 2];
			if ((b & 0xc0) != 0x80 || (c & 0xc0) != 0x80) {
				goto error;
			}
			codepoint = (c & 63) | (b & 63) << 6 | (a & 15) << 12;

			if (codepoint < 0x800) {
				goto error;
			}
			if (codepoint >= 0xd800 && codepoint <= 0xdfff) {
				/*
				 * This is an invalid codepoint, per
				 * RFC3629, as it encodes part of a
				 * UTF-16 surrogate pair for a
				 * character over U+10000, which ought
				 * to have been encoded as a four byte
				 * utf-8 sequence.
				 */
				goto error;
			}
			i += 2;
			continue;
		}

		if ((s[i] & 0xf8) == 0xf0) {
			/* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
			if (maxlen - i < 4) {
				goto error;
			}
			a = s[i];
			b = s[i + 1];
			c = s[i + 2];
			d = s[i + 3];

			if ((b & 0xc0) != 0x80 ||
			    (c & 0xc0) != 0x80 ||
			    (d & 0xc0) != 0x80) {
				goto error;
			}
			codepoint = (d & 63) | (c & 63) << 6 | (b & 63) << 12 | (a & 7) << 18;

			if (codepoint < 0x10000 || codepoint > 0x10ffff) {
				goto error;
			}
			/* this one will need two UTF16 characters */
			long_chars++;
			i += 3;
			continue;
		}
		/*
		 * If it wasn't handled yet, it's wrong.
		 */
		goto error;
	}
	*byte_len = i;
	*char_len = chars;
	*utf16_len = chars + long_chars;
	return true;

error:
	*byte_len = i;
	*char_len = chars;
	*utf16_len = chars + long_chars;
	return false;
}


/**
 * Copy a string from a char* unix src to a dos codepage string destination.
 *
 * @converted_size the number of bytes occupied by the string in the destination.
 * @return bool true if success.
 *
 * @param flags can include
 * <dl>
 * <dt>STR_TERMINATE</dt> <dd>means include the null termination</dd>
 * <dt>STR_UPPER</dt> <dd>means uppercase in the destination</dd>
 * </dl>
 *
 * @param dest_len the maximum length in bytes allowed in the
 * destination.  If @p dest_len is -1 then no maximum is used.
 **/
static bool push_ascii_string(void *dest, const char *src, size_t dest_len, int flags, size_t *converted_size)
{
	size_t src_len;
	bool ret;

	if (flags & STR_UPPER) {
		char *tmpbuf = strupper_talloc(NULL, src);
		if (tmpbuf == NULL) {
			return false;
		}
		ret = push_ascii_string(dest, tmpbuf, dest_len, flags & ~STR_UPPER, converted_size);
		talloc_free(tmpbuf);
		return ret;
	}

	src_len = strlen(src);

	if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII))
		src_len++;

	return convert_string(CH_UNIX, CH_DOS, src, src_len, dest, dest_len, converted_size);
}

/**
 * Copy a string from a dos codepage source to a unix char* destination.
 *
 * The resulting string in "dest" is always null terminated.
 *
 * @param flags can have:
 * <dl>
 * <dt>STR_TERMINATE</dt>
 * <dd>STR_TERMINATE means the string in @p src
 * is null terminated, and src_len is ignored.</dd>
 * </dl>
 *
 * @param src_len is the length of the source area in bytes.
 * @returns the number of bytes occupied by the string in @p src.
 **/
static ssize_t pull_ascii_string(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
{
	size_t size = 0;

	if (flags & (STR_TERMINATE | STR_TERMINATE_ASCII)) {
		if (src_len == (size_t)-1) {
			src_len = strlen((const char *)src) + 1;
		} else {
			size_t len = strnlen((const char *)src, src_len);
			if (len < src_len)
				len++;
			src_len = len;
		}
	}

	/* We're ignoring the return here.. */
	(void)convert_string(CH_DOS, CH_UNIX, src, src_len, dest, dest_len, &size);

	if (dest_len)
		dest[MIN(size, dest_len-1)] = 0;

	return src_len;
}

/**
 * Copy a string from a char* src to a unicode destination.
 *
 * @returns the number of bytes occupied by the string in the destination.
 *
 * @param flags can have:
 *
 * <dl>
 * <dt>STR_TERMINATE <dd>means include the null termination.
 * <dt>STR_UPPER     <dd>means uppercase in the destination.
 * <dt>STR_NOALIGN   <dd>means don't do alignment.
 * </dl>
 *
 * @param dest_len is the maximum length allowed in the
 * destination. If dest_len is -1 then no maximum is used.
 **/
static ssize_t push_ucs2(void *dest, const char *src, size_t dest_len, int flags)
{
	size_t len=0;
	size_t src_len = strlen(src);
	size_t size = 0;
	bool ret;

	if (flags & STR_UPPER) {
		char *tmpbuf = strupper_talloc(NULL, src);
		ssize_t retval;
		if (tmpbuf == NULL) {
			return -1;
		}
		retval = push_ucs2(dest, tmpbuf, dest_len, flags & ~STR_UPPER);
		talloc_free(tmpbuf);
		return retval;
	}

	if (flags & STR_TERMINATE)
		src_len++;

	if (ucs2_align(NULL, dest, flags)) {
		*(char *)dest = 0;
		dest = (void *)((char *)dest + 1);
		if (dest_len) dest_len--;
		len++;
	}

	/* ucs2 is always a multiple of 2 bytes */
	dest_len &= ~1;

	ret = convert_string(CH_UNIX, CH_UTF16, src, src_len, dest, dest_len, &size);
	if (ret == false) {
		return 0;
	}

	len += size;

	return (ssize_t)len;
}


/**
 Copy a string from a ucs2 source to a unix char* destination.
 Flags can have:
  STR_TERMINATE means the string in src is null terminated.
  STR_NOALIGN   means don't try to align.
 if STR_TERMINATE is set then src_len is ignored if it is -1.
 src_len is the length of the source area in bytes
 Return the number of bytes occupied by the string in src.
 The resulting string in "dest" is always null terminated.
**/

static size_t pull_ucs2(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
{
	size_t size = 0;

	if (ucs2_align(NULL, src, flags)) {
		src = (const void *)((const char *)src + 1);
		if (src_len > 0)
			src_len--;
	}

	if (flags & STR_TERMINATE) {
		if (src_len == (size_t)-1) {
			src_len = utf16_null_terminated_len(src);
		} else {
			src_len = utf16_null_terminated_len_n(src, src_len);
		}
	}

	/* ucs2 is always a multiple of 2 bytes */
	if (src_len != (size_t)-1)
		src_len &= ~1;

	/* We're ignoring the return here.. */
	(void)convert_string(CH_UTF16, CH_UNIX, src, src_len, dest, dest_len, &size);
	if (dest_len)
		dest[MIN(size, dest_len-1)] = 0;

	return src_len;
}

/**
 Copy a string from a char* src to a unicode or ascii
 dos codepage destination choosing unicode or ascii based on the
 flags in the SMB buffer starting at base_ptr.
 Return the number of bytes occupied by the string in the destination.
 flags can have:
  STR_TERMINATE means include the null termination.
  STR_UPPER     means uppercase in the destination.
  STR_ASCII     use ascii even with unicode packet.
  STR_NOALIGN   means don't do alignment.
 dest_len is the maximum length allowed in the destination. If dest_len
 is -1 then no maximum is used.
**/

_PUBLIC_ ssize_t push_string(void *dest, const char *src, size_t dest_len, int flags)
{
	if (flags & STR_ASCII) {
		size_t size = 0;
		if (push_ascii_string(dest, src, dest_len, flags, &size)) {
			return (ssize_t)size;
		} else {
			return (ssize_t)-1;
		}
	} else if (flags & STR_UNICODE) {
		return push_ucs2(dest, src, dest_len, flags);
	} else {
		smb_panic("push_string requires either STR_ASCII or STR_UNICODE flag to be set");
		return -1;
	}
}


/**
 Copy a string from a unicode or ascii source (depending on
 the packet flags) to a char* destination.
 Flags can have:
  STR_TERMINATE means the string in src is null terminated.
  STR_UNICODE   means to force as unicode.
  STR_ASCII     use ascii even with unicode packet.
  STR_NOALIGN   means don't do alignment.
 if STR_TERMINATE is set then src_len is ignored is it is -1
 src_len is the length of the source area in bytes.
 Return the number of bytes occupied by the string in src.
 The resulting string in "dest" is always null terminated.
**/

_PUBLIC_ ssize_t pull_string(char *dest, const void *src, size_t dest_len, size_t src_len, int flags)
{
	if (flags & STR_ASCII) {
		return pull_ascii_string(dest, src, dest_len, src_len, flags);
	} else if (flags & STR_UNICODE) {
		return pull_ucs2(dest, src, dest_len, src_len, flags);
	} else {
		smb_panic("pull_string requires either STR_ASCII or STR_UNICODE flag to be set");
		return -1;
	}
}