Quelle  unicode.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *   Some of the source code in this file came from fs/cifs/cifs_unicode.c
 *
 *   Copyright (c) International Business Machines  Corp., 2000,2009
 *   Modified by Steve French (sfrench@us.ibm.com)
 *   Modified by Namjae Jeon (linkinjeon@kernel.org)
 */
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/unaligned.h>
#include "glob.h"
#include "unicode.h"
#include "smb_common.h"

/*
 * cifs_mapchar() - convert a host-endian char to proper char in codepage
 * @target: where converted character should be copied
 * @from: host-endian source string
 * @cp:  codepage to which character should be converted
 * @mapchar: should character be mapped according to mapchars mount option?
 *
 * This function handles the conversion of a single character. It is the
 * responsibility of the caller to ensure that the target buffer is large
 * enough to hold the result of the conversion (at least NLS_MAX_CHARSET_SIZE).
 *
 * Return: string length after conversion
 */
static int
cifs_mapchar(char *target, const __u16 *from, const struct nls_table *cp,
      bool mapchar)
{
 int len = 1;
 __u16 src_char;

 src_char = *from;

 if (!mapchar)
  goto cp_convert;

 /*
  * BB: Cannot handle remapping UNI_SLASH until all the calls to
  *     build_path_from_dentry are modified, as they use slash as
  *     separator.
 */
 switch (src_char) {
 case UNI_COLON:
  *target = ':';
  break;
 case UNI_ASTERISK:
  *target = '*';
  break;
 case UNI_QUESTION:
  *target = '?';
  break;
 case UNI_PIPE:
  *target = '|';
  break;
 case UNI_GRTRTHAN:
  *target = '>';
  break;
 case UNI_LESSTHAN:
  *target = '<';
  break;
 default:
  goto cp_convert;
 }

out:
 return len;

cp_convert:
 len = cp->uni2char(src_char, target, NLS_MAX_CHARSET_SIZE);
 if (len <= 0)
  goto surrogate_pair;

 goto out;

surrogate_pair:
 /* convert SURROGATE_PAIR and IVS */
 if (strcmp(cp->charset, "utf8"))
  goto unknown;
 len = utf16s_to_utf8s(from, 3, UTF16_LITTLE_ENDIAN, target, 6);
 if (len <= 0)
  goto unknown;
 return len;

unknown:
 *target = '?';
 len = 1;
 goto out;
}

/*
 * smb_utf16_bytes() - compute converted string length
 * @from: pointer to input string
 * @maxbytes: input string length
 * @codepage: destination codepage
 *
 * Walk a utf16le string and return the number of bytes that the string will
 * be after being converted to the given charset, not including any null
 * termination required. Don't walk past maxbytes in the source buffer.
 *
 * Return: string length after conversion
 */
static int smb_utf16_bytes(const __le16 *from, int maxbytes,
      const struct nls_table *codepage)
{
 int i, j;
 int charlen, outlen = 0;
 int maxwords = maxbytes / 2;
 char tmp[NLS_MAX_CHARSET_SIZE];
 __u16 ftmp[3];

 for (i = 0; i < maxwords; i++) {
  ftmp[0] = get_unaligned_le16(&from[i]);
  if (ftmp[0] == 0)
   break;
  for (j = 1; j <= 2; j++) {
   if (i + j < maxwords)
    ftmp[j] = get_unaligned_le16(&from[i + j]);
   else
    ftmp[j] = 0;
  }

  charlen = cifs_mapchar(tmp, ftmp, codepage, 0);
  if (charlen > 0)
   outlen += charlen;
  else
   outlen++;
 }

 return outlen;
}

/*
 * smb_from_utf16() - convert utf16le string to local charset
 * @to:  destination buffer
 * @from: source buffer
 * @tolen: destination buffer size (in bytes)
 * @fromlen: source buffer size (in bytes)
 * @codepage: codepage to which characters should be converted
 * @mapchar: should characters be remapped according to the mapchars option?
 *
 * Convert a little-endian utf16le string (as sent by the server) to a string
 * in the provided codepage. The tolen and fromlen parameters are to ensure
 * that the code doesn't walk off of the end of the buffer (which is always
 * a danger if the alignment of the source buffer is off). The destination
 * string is always properly null terminated and fits in the destination
 * buffer. Returns the length of the destination string in bytes (including
 * null terminator).
 *
 * Note that some windows versions actually send multiword UTF-16 characters
 * instead of straight UTF16-2. The linux nls routines however aren't able to
 * deal with those characters properly. In the event that we get some of
 * those characters, they won't be translated properly.
 *
 * Return: string length after conversion
 */
static int smb_from_utf16(char *to, const __le16 *from, int tolen, int fromlen,
     const struct nls_table *codepage, bool mapchar)
{
 int i, j, charlen, safelen;
 int outlen = 0;
 int nullsize = nls_nullsize(codepage);
 int fromwords = fromlen / 2;
 char tmp[NLS_MAX_CHARSET_SIZE];
 __u16 ftmp[3]; /* ftmp[3] = 3array x 2bytes = 6bytes UTF-16 */

 /*
  * because the chars can be of varying widths, we need to take care
  * not to overflow the destination buffer when we get close to the
  * end of it. Until we get to this offset, we don't need to check
  * for overflow however.
 */
 safelen = tolen - (NLS_MAX_CHARSET_SIZE + nullsize);

 for (i = 0; i < fromwords; i++) {
  ftmp[0] = get_unaligned_le16(&from[i]);
  if (ftmp[0] == 0)
   break;
  for (j = 1; j <= 2; j++) {
   if (i + j < fromwords)
    ftmp[j] = get_unaligned_le16(&from[i + j]);
   else
    ftmp[j] = 0;
  }

  /*
   * check to see if converting this character might make the
   * conversion bleed into the null terminator
 */
  if (outlen >= safelen) {
   charlen = cifs_mapchar(tmp, ftmp, codepage, mapchar);
   if ((outlen + charlen) > (tolen - nullsize))
    break;
  }

  /* put converted char into 'to' buffer */
  charlen = cifs_mapchar(&to[outlen], ftmp, codepage, mapchar);
  outlen += charlen;

  /*
   * charlen (=bytes of UTF-8 for 1 character)
   * 4bytes UTF-8(surrogate pair) is charlen=4
   * (4bytes UTF-16 code)
   * 7-8bytes UTF-8(IVS) is charlen=3+4 or 4+4
   * (2 UTF-8 pairs divided to 2 UTF-16 pairs)
 */
  if (charlen == 4)
   i++;
  else if (charlen >= 5)
   /* 5-6bytes UTF-8 */
   i += 2;
 }

 /* properly null-terminate string */
 for (i = 0; i < nullsize; i++)
  to[outlen++] = 0;

 return outlen;
}

/*
 * smb_strtoUTF16() - Convert character string to unicode string
 * @to:  destination buffer
 * @from: source buffer
 * @len: destination buffer size (in bytes)
 * @codepage: codepage to which characters should be converted
 *
 * Return: string length after conversion
 */
int smb_strtoUTF16(__le16 *to, const char *from, int len,
     const struct nls_table *codepage)
{
 int charlen;
 int i;
 wchar_t wchar_to; /* needed to quiet sparse */

 /* special case for utf8 to handle no plane0 chars */
 if (!strcmp(codepage->charset, "utf8")) {
  /*
   * convert utf8 -> utf16, we assume we have enough space
   * as caller should have assumed conversion does not overflow
   * in destination len is length in wchar_t units (16bits)
 */
  i  = utf8s_to_utf16s(from, len, UTF16_LITTLE_ENDIAN,
         (wchar_t *)to, len);

  /* if success terminate and exit */
  if (i >= 0)
   goto success;
  /*
   * if fails fall back to UCS encoding as this
   * function should not return negative values
   * currently can fail only if source contains
   * invalid encoded characters
 */
 }

 for (i = 0; len > 0 && *from; i++, from += charlen, len -= charlen) {
  charlen = codepage->char2uni(from, len, &wchar_to);
  if (charlen < 1) {
   /* A question mark */
   wchar_to = 0x003f;
   charlen = 1;
  }
  put_unaligned_le16(wchar_to, &to[i]);
 }

success:
 put_unaligned_le16(0, &to[i]);
 return i;
}

/*
 * smb_strndup_from_utf16() - copy a string from wire format to the local
 *  codepage
 * @src: source string
 * @maxlen: don't walk past this many bytes in the source string
 * @is_unicode: is this a unicode string?
 * @codepage: destination codepage
 *
 * Take a string given by the server, convert it to the local codepage and
 * put it in a new buffer. Returns a pointer to the new string or NULL on
 * error.
 *
 * Return: destination string buffer or error ptr
 */
char *smb_strndup_from_utf16(const char *src, const int maxlen,
        const bool is_unicode,
        const struct nls_table *codepage)
{
 int len, ret;
 char *dst;

 if (is_unicode) {
  len = smb_utf16_bytes((__le16 *)src, maxlen, codepage);
  len += nls_nullsize(codepage);
  dst = kmalloc(len, KSMBD_DEFAULT_GFP);
  if (!dst)
   return ERR_PTR(-ENOMEM);
  ret = smb_from_utf16(dst, (__le16 *)src, len, maxlen, codepage,
         false);
  if (ret < 0) {
   kfree(dst);
   return ERR_PTR(-EINVAL);
  }
 } else {
  len = strnlen(src, maxlen);
  len++;
  dst = kmalloc(len, KSMBD_DEFAULT_GFP);
  if (!dst)
   return ERR_PTR(-ENOMEM);
  strscpy(dst, src, len);
 }

 return dst;
}

/*
 * Convert 16 bit Unicode pathname to wire format from string in current code
 * page. Conversion may involve remapping up the six characters that are
 * only legal in POSIX-like OS (if they are present in the string). Path
 * names are little endian 16 bit Unicode on the wire
 */
/*
 * smbConvertToUTF16() - convert string from local charset to utf16
 * @target: destination buffer
 * @source: source buffer
 * @srclen: source buffer size (in bytes)
 * @cp:  codepage to which characters should be converted
 * @mapchar: should characters be remapped according to the mapchars option?
 *
 * Convert 16 bit Unicode pathname to wire format from string in current code
 * page. Conversion may involve remapping up the six characters that are
 * only legal in POSIX-like OS (if they are present in the string). Path
 * names are little endian 16 bit Unicode on the wire
 *
 * Return: char length after conversion
 */
int smbConvertToUTF16(__le16 *target, const char *source, int srclen,
        const struct nls_table *cp, int mapchars)
{
 int i, j, charlen;
 char src_char;
 __le16 dst_char;
 wchar_t tmp;
 wchar_t wchar_to[6]; /* UTF-16 */
 int ret;
 unicode_t u;

 if (!mapchars)
  return smb_strtoUTF16(target, source, srclen, cp);

 for (i = 0, j = 0; i < srclen; j++) {
  src_char = source[i];
  charlen = 1;
  switch (src_char) {
  case 0:
   put_unaligned(0, &target[j]);
   return j;
  case ':':
   dst_char = cpu_to_le16(UNI_COLON);
   break;
  case '*':
   dst_char = cpu_to_le16(UNI_ASTERISK);
   break;
  case '?':
   dst_char = cpu_to_le16(UNI_QUESTION);
   break;
  case '<':
   dst_char = cpu_to_le16(UNI_LESSTHAN);
   break;
  case '>':
   dst_char = cpu_to_le16(UNI_GRTRTHAN);
   break;
  case '|':
   dst_char = cpu_to_le16(UNI_PIPE);
   break;
  /*
   * FIXME: We can not handle remapping backslash (UNI_SLASH)
   * until all the calls to build_path_from_dentry are modified,
   * as they use backslash as separator.
 */
  default:
   charlen = cp->char2uni(source + i, srclen - i, &tmp);
   dst_char = cpu_to_le16(tmp);

   /*
    * if no match, use question mark, which at least in
    * some cases serves as wild card
 */
   if (charlen > 0)
    goto ctoUTF16;

   /* convert SURROGATE_PAIR */
   if (strcmp(cp->charset, "utf8"))
    goto unknown;
   if (*(source + i) & 0x80) {
    charlen = utf8_to_utf32(source + i, 6, &u);
    if (charlen < 0)
     goto unknown;
   } else
    goto unknown;
   ret  = utf8s_to_utf16s(source + i, charlen,
     UTF16_LITTLE_ENDIAN,
     wchar_to, 6);
   if (ret < 0)
    goto unknown;

   i += charlen;
   dst_char = cpu_to_le16(*wchar_to);
   if (charlen <= 3)
    /* 1-3bytes UTF-8 to 2bytes UTF-16 */
    put_unaligned(dst_char, &target[j]);
   else if (charlen == 4) {
    /*
     * 4bytes UTF-8(surrogate pair) to 4bytes UTF-16
     * 7-8bytes UTF-8(IVS) divided to 2 UTF-16
     * (charlen=3+4 or 4+4)
 */
    put_unaligned(dst_char, &target[j]);
    dst_char = cpu_to_le16(*(wchar_to + 1));
    j++;
    put_unaligned(dst_char, &target[j]);
   } else if (charlen >= 5) {
    /* 5-6bytes UTF-8 to 6bytes UTF-16 */
    put_unaligned(dst_char, &target[j]);
    dst_char = cpu_to_le16(*(wchar_to + 1));
    j++;
    put_unaligned(dst_char, &target[j]);
    dst_char = cpu_to_le16(*(wchar_to + 2));
    j++;
    put_unaligned(dst_char, &target[j]);
   }
   continue;

unknown:
   dst_char = cpu_to_le16(0x003f);
   charlen = 1;
  }

ctoUTF16:
  /*
   * character may take more than one byte in the source string,
   * but will take exactly two bytes in the target string
 */
  i += charlen;
  put_unaligned(dst_char, &target[j]);
 }

 return j;
}