Commit 484a10f4 authored by Andrew Gabbasov's avatar Andrew Gabbasov Committed by Jan Kara

udf: Merge linux specific translation into CS0 conversion function

Current implementation of udf_translate_to_linux function does not
support multi-bytes characters at all: it counts bytes while calculating
extension length, when inserting CRC inside the name it doesn't
take into account inter-character boundaries and can break into
the middle of the character.

The most efficient way to properly support multi-bytes characters is
merging of translation operations directly into conversion function.
This can help to avoid extra passes along the string or parsing
the multi-bytes character back into unicode to find out it's length.
Signed-off-by: default avatarAndrew Gabbasov <andrew_gabbasov@mentor.com>
Signed-off-by: default avatarJan Kara <jack@suse.cz>
parent 9293fcfb
...@@ -28,9 +28,6 @@ ...@@ -28,9 +28,6 @@
#include "udf_sb.h" #include "udf_sb.h"
static int udf_translate_to_linux(uint8_t *, int, const uint8_t *, int,
const uint8_t *, int);
static int udf_uni2char_utf8(wchar_t uni, static int udf_uni2char_utf8(wchar_t uni,
unsigned char *out, unsigned char *out,
int boundlen) int boundlen)
...@@ -114,13 +111,83 @@ static int udf_char2uni_utf8(const unsigned char *in, ...@@ -114,13 +111,83 @@ static int udf_char2uni_utf8(const unsigned char *in,
return u_len; return u_len;
} }
#define ILLEGAL_CHAR_MARK '_'
#define EXT_MARK '.'
#define CRC_MARK '#'
#define EXT_SIZE 5
/* Number of chars we need to store generated CRC to make filename unique */
#define CRC_LEN 5
static int udf_name_conv_char(uint8_t *str_o, int str_o_max_len,
int *str_o_idx,
const uint8_t *str_i, int str_i_max_len,
int *str_i_idx,
int u_ch, int *needsCRC,
int (*conv_f)(wchar_t, unsigned char *, int),
int translate)
{
uint32_t c;
int illChar = 0;
int len, gotch = 0;
for (; (!gotch) && (*str_i_idx < str_i_max_len); *str_i_idx += u_ch) {
if (*str_o_idx >= str_o_max_len) {
*needsCRC = 1;
return gotch;
}
/* Expand OSTA compressed Unicode to Unicode */
c = str_i[*str_i_idx];
if (u_ch > 1)
c = (c << 8) | str_i[*str_i_idx + 1];
if (translate && (c == '/' || c == 0))
illChar = 1;
else if (illChar)
break;
else
gotch = 1;
}
if (illChar) {
*needsCRC = 1;
c = ILLEGAL_CHAR_MARK;
gotch = 1;
}
if (gotch) {
len = conv_f(c, &str_o[*str_o_idx], str_o_max_len - *str_o_idx);
/* Valid character? */
if (len >= 0)
*str_o_idx += len;
else if (len == -ENAMETOOLONG) {
*needsCRC = 1;
gotch = 0;
} else {
str_o[(*str_o_idx)++] = '?';
*needsCRC = 1;
}
}
return gotch;
}
static int udf_name_from_CS0(uint8_t *str_o, int str_max_len, static int udf_name_from_CS0(uint8_t *str_o, int str_max_len,
const uint8_t *ocu, int ocu_len, const uint8_t *ocu, int ocu_len,
int (*conv_f)(wchar_t, unsigned char *, int)) int (*conv_f)(wchar_t, unsigned char *, int),
int translate)
{ {
uint32_t c;
uint8_t cmp_id; uint8_t cmp_id;
int i, len; int idx, len;
int str_o_len = 0; int u_ch;
int needsCRC = 0;
int ext_i_len, ext_max_len;
int str_o_len = 0; /* Length of resulting output */
int ext_o_len = 0; /* Extension output length */
int ext_crc_len = 0; /* Extension output length if used with CRC */
int i_ext = -1; /* Extension position in input buffer */
int o_crc = 0; /* Rightmost possible output pos for CRC+ext */
unsigned short valueCRC;
uint8_t ext[EXT_SIZE * NLS_MAX_CHARSET_SIZE + 1];
uint8_t crc[CRC_LEN];
if (str_max_len <= 0) if (str_max_len <= 0)
return 0; return 0;
...@@ -133,24 +200,88 @@ static int udf_name_from_CS0(uint8_t *str_o, int str_max_len, ...@@ -133,24 +200,88 @@ static int udf_name_from_CS0(uint8_t *str_o, int str_max_len,
cmp_id = ocu[0]; cmp_id = ocu[0];
if (cmp_id != 8 && cmp_id != 16) { if (cmp_id != 8 && cmp_id != 16) {
memset(str_o, 0, str_max_len); memset(str_o, 0, str_max_len);
pr_err("unknown compression code (%d) stri=%s\n", cmp_id, ocu); pr_err("unknown compression code (%d)\n", cmp_id);
return -EINVAL; return -EINVAL;
} }
u_ch = cmp_id >> 3;
for (i = 1; (i < ocu_len) && (str_o_len < str_max_len);) { ocu++;
/* Expand OSTA compressed Unicode to Unicode */ ocu_len--;
uint32_t c = ocu[i++];
if (cmp_id == 16)
c = (c << 8) | ocu[i++];
len = conv_f(c, &str_o[str_o_len], str_max_len - str_o_len); if (ocu_len % u_ch) {
/* Valid character? */ pr_err("incorrect filename length (%d)\n", ocu_len + 1);
if (len >= 0) return -EINVAL;
str_o_len += len; }
else if (len == -ENAMETOOLONG)
if (translate) {
/* Look for extension */
for (idx = ocu_len - u_ch, ext_i_len = 0;
(idx >= 0) && (ext_i_len < EXT_SIZE);
idx -= u_ch, ext_i_len++) {
c = ocu[idx];
if (u_ch > 1)
c = (c << 8) | ocu[idx + 1];
if (c == EXT_MARK) {
if (ext_i_len)
i_ext = idx;
break;
}
}
if (i_ext >= 0) {
/* Convert extension */
ext_max_len = min_t(int, sizeof(ext), str_max_len);
ext[ext_o_len++] = EXT_MARK;
idx = i_ext + u_ch;
while (udf_name_conv_char(ext, ext_max_len, &ext_o_len,
ocu, ocu_len, &idx,
u_ch, &needsCRC,
conv_f, translate)) {
if ((ext_o_len + CRC_LEN) < str_max_len)
ext_crc_len = ext_o_len;
}
}
}
idx = 0;
while (1) {
if (translate && (idx == i_ext)) {
if (str_o_len > (str_max_len - ext_o_len))
needsCRC = 1;
break; break;
else }
str_o[str_o_len++] = '?';
if (!udf_name_conv_char(str_o, str_max_len, &str_o_len,
ocu, ocu_len, &idx,
u_ch, &needsCRC, conv_f, translate))
break;
if (translate &&
(str_o_len <= (str_max_len - ext_o_len - CRC_LEN)))
o_crc = str_o_len;
}
if (translate) {
if (str_o_len <= 2 && str_o[0] == '.' &&
(str_o_len == 1 || str_o[1] == '.'))
needsCRC = 1;
if (needsCRC) {
str_o_len = o_crc;
valueCRC = crc_itu_t(0, ocu, ocu_len);
crc[0] = CRC_MARK;
crc[1] = hex_asc_upper_hi(valueCRC >> 8);
crc[2] = hex_asc_upper_lo(valueCRC >> 8);
crc[3] = hex_asc_upper_hi(valueCRC);
crc[4] = hex_asc_upper_lo(valueCRC);
len = min_t(int, CRC_LEN, str_max_len - str_o_len);
memcpy(&str_o[str_o_len], crc, len);
str_o_len += len;
ext_o_len = ext_crc_len;
}
if (ext_o_len > 0) {
memcpy(&str_o[str_o_len], ext, ext_o_len);
str_o_len += ext_o_len;
}
} }
return str_o_len; return str_o_len;
...@@ -207,13 +338,12 @@ static int udf_name_to_CS0(uint8_t *ocu, int ocu_max_len, ...@@ -207,13 +338,12 @@ static int udf_name_to_CS0(uint8_t *ocu, int ocu_max_len,
int udf_CS0toUTF8(uint8_t *utf_o, int o_len, const uint8_t *ocu_i, int i_len) int udf_CS0toUTF8(uint8_t *utf_o, int o_len, const uint8_t *ocu_i, int i_len)
{ {
return udf_name_from_CS0(utf_o, o_len, ocu_i, i_len, return udf_name_from_CS0(utf_o, o_len, ocu_i, i_len,
udf_uni2char_utf8); udf_uni2char_utf8, 0);
} }
int udf_get_filename(struct super_block *sb, const uint8_t *sname, int slen, int udf_get_filename(struct super_block *sb, const uint8_t *sname, int slen,
uint8_t *dname, int dlen) uint8_t *dname, int dlen)
{ {
uint8_t *filename;
int (*conv_f)(wchar_t, unsigned char *, int); int (*conv_f)(wchar_t, unsigned char *, int);
int ret; int ret;
...@@ -223,10 +353,6 @@ int udf_get_filename(struct super_block *sb, const uint8_t *sname, int slen, ...@@ -223,10 +353,6 @@ int udf_get_filename(struct super_block *sb, const uint8_t *sname, int slen,
if (dlen <= 0) if (dlen <= 0)
return 0; return 0;
filename = kmalloc(dlen, GFP_NOFS);
if (!filename)
return -ENOMEM;
if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) { if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) {
conv_f = udf_uni2char_utf8; conv_f = udf_uni2char_utf8;
} else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) { } else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) {
...@@ -234,19 +360,10 @@ int udf_get_filename(struct super_block *sb, const uint8_t *sname, int slen, ...@@ -234,19 +360,10 @@ int udf_get_filename(struct super_block *sb, const uint8_t *sname, int slen,
} else } else
BUG(); BUG();
ret = udf_name_from_CS0(filename, dlen, sname, slen, conv_f); ret = udf_name_from_CS0(dname, dlen, sname, slen, conv_f, 1);
if (ret < 0) {
udf_debug("Failed in udf_get_filename: sname = %s\n", sname);
goto out2;
}
ret = udf_translate_to_linux(dname, dlen, filename, dlen,
sname + 1, slen - 1);
/* Zero length filename isn't valid... */ /* Zero length filename isn't valid... */
if (ret == 0) if (ret == 0)
ret = -EINVAL; ret = -EINVAL;
out2:
kfree(filename);
return ret; return ret;
} }
...@@ -265,96 +382,3 @@ int udf_put_filename(struct super_block *sb, const uint8_t *sname, int slen, ...@@ -265,96 +382,3 @@ int udf_put_filename(struct super_block *sb, const uint8_t *sname, int slen,
return udf_name_to_CS0(dname, dlen, sname, slen, conv_f); return udf_name_to_CS0(dname, dlen, sname, slen, conv_f);
} }
#define ILLEGAL_CHAR_MARK '_'
#define EXT_MARK '.'
#define CRC_MARK '#'
#define EXT_SIZE 5
/* Number of chars we need to store generated CRC to make filename unique */
#define CRC_LEN 5
static int udf_translate_to_linux(uint8_t *newName, int newLen,
const uint8_t *udfName, int udfLen,
const uint8_t *fidName, int fidNameLen)
{
int index, newIndex = 0, needsCRC = 0;
int extIndex = 0, newExtIndex = 0, hasExt = 0;
unsigned short valueCRC;
uint8_t curr;
if (udfName[0] == '.' &&
(udfLen == 1 || (udfLen == 2 && udfName[1] == '.'))) {
needsCRC = 1;
newIndex = udfLen;
memcpy(newName, udfName, udfLen);
} else {
for (index = 0; index < udfLen; index++) {
curr = udfName[index];
if (curr == '/' || curr == 0) {
needsCRC = 1;
curr = ILLEGAL_CHAR_MARK;
while (index + 1 < udfLen &&
(udfName[index + 1] == '/' ||
udfName[index + 1] == 0))
index++;
}
if (curr == EXT_MARK &&
(udfLen - index - 1) <= EXT_SIZE) {
if (udfLen == index + 1)
hasExt = 0;
else {
hasExt = 1;
extIndex = index;
newExtIndex = newIndex;
}
}
if (newIndex < newLen)
newName[newIndex++] = curr;
else
needsCRC = 1;
}
}
if (needsCRC) {
uint8_t ext[EXT_SIZE];
int localExtIndex = 0;
if (hasExt) {
int maxFilenameLen;
for (index = 0;
index < EXT_SIZE && extIndex + index + 1 < udfLen;
index++) {
curr = udfName[extIndex + index + 1];
if (curr == '/' || curr == 0) {
needsCRC = 1;
curr = ILLEGAL_CHAR_MARK;
while (extIndex + index + 2 < udfLen &&
(index + 1 < EXT_SIZE &&
(udfName[extIndex + index + 2] == '/' ||
udfName[extIndex + index + 2] == 0)))
index++;
}
ext[localExtIndex++] = curr;
}
maxFilenameLen = newLen - CRC_LEN - localExtIndex;
if (newIndex > maxFilenameLen)
newIndex = maxFilenameLen;
else
newIndex = newExtIndex;
} else if (newIndex > newLen - CRC_LEN)
newIndex = newLen - CRC_LEN;
newName[newIndex++] = CRC_MARK;
valueCRC = crc_itu_t(0, fidName, fidNameLen);
newName[newIndex++] = hex_asc_upper_hi(valueCRC >> 8);
newName[newIndex++] = hex_asc_upper_lo(valueCRC >> 8);
newName[newIndex++] = hex_asc_upper_hi(valueCRC);
newName[newIndex++] = hex_asc_upper_lo(valueCRC);
if (hasExt) {
newName[newIndex++] = EXT_MARK;
for (index = 0; index < localExtIndex; index++)
newName[newIndex++] = ext[index];
}
}
return newIndex;
}
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment