/src/samba/lib/util/charset/util_unistr.c

Source
/*
   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
 *    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;
  }
}

Coverage Report

Created: 2025-12-31 06:20