1 /* 2 * unicode.c 3 * 4 * PURPOSE 5 * Routines for converting between UTF-8 and OSTA Compressed Unicode. 6 * Also handles filename mangling 7 * 8 * DESCRIPTION 9 * OSTA Compressed Unicode is explained in the OSTA UDF specification. 10 * http://www.osta.org/ 11 * UTF-8 is explained in the IETF RFC XXXX. 12 * ftp://ftp.internic.net/rfc/rfcxxxx.txt 13 * 14 * COPYRIGHT 15 * This file is distributed under the terms of the GNU General Public 16 * License (GPL). Copies of the GPL can be obtained from: 17 * ftp://prep.ai.mit.edu/pub/gnu/GPL 18 * Each contributing author retains all rights to their own work. 19 */ 20 21 #include "udfdecl.h" 22 23 #include <linux/kernel.h> 24 #include <linux/string.h> /* for memset */ 25 #include <linux/nls.h> 26 #include <linux/crc-itu-t.h> 27 #include <linux/slab.h> 28 29 #include "udf_sb.h" 30 31 static int udf_translate_to_linux(uint8_t *, int, uint8_t *, int, uint8_t *, 32 int); 33 34 static int udf_char_to_ustr(struct ustr *dest, const uint8_t *src, int strlen) 35 { 36 if ((!dest) || (!src) || (!strlen) || (strlen > UDF_NAME_LEN - 2)) 37 return 0; 38 39 memset(dest, 0, sizeof(struct ustr)); 40 memcpy(dest->u_name, src, strlen); 41 dest->u_cmpID = 0x08; 42 dest->u_len = strlen; 43 44 return strlen; 45 } 46 47 /* 48 * udf_build_ustr 49 */ 50 int udf_build_ustr(struct ustr *dest, dstring *ptr, int size) 51 { 52 int usesize; 53 54 if (!dest || !ptr || !size) 55 return -1; 56 BUG_ON(size < 2); 57 58 usesize = min_t(size_t, ptr[size - 1], sizeof(dest->u_name)); 59 usesize = min(usesize, size - 2); 60 dest->u_cmpID = ptr[0]; 61 dest->u_len = usesize; 62 memcpy(dest->u_name, ptr + 1, usesize); 63 memset(dest->u_name + usesize, 0, sizeof(dest->u_name) - usesize); 64 65 return 0; 66 } 67 68 /* 69 * udf_build_ustr_exact 70 */ 71 static void udf_build_ustr_exact(struct ustr *dest, dstring *ptr, int exactsize) 72 { 73 memset(dest, 0, sizeof(struct ustr)); 74 dest->u_cmpID = ptr[0]; 75 dest->u_len = exactsize - 1; 76 memcpy(dest->u_name, ptr + 1, exactsize - 1); 77 } 78 79 /* 80 * udf_CS0toUTF8 81 * 82 * PURPOSE 83 * Convert OSTA Compressed Unicode to the UTF-8 equivalent. 84 * 85 * PRE-CONDITIONS 86 * utf Pointer to UTF-8 output buffer. 87 * ocu Pointer to OSTA Compressed Unicode input buffer 88 * of size UDF_NAME_LEN bytes. 89 * both of type "struct ustr *" 90 * 91 * POST-CONDITIONS 92 * <return> >= 0 on success. 93 * 94 * HISTORY 95 * November 12, 1997 - Andrew E. Mileski 96 * Written, tested, and released. 97 */ 98 int udf_CS0toUTF8(struct ustr *utf_o, const struct ustr *ocu_i) 99 { 100 const uint8_t *ocu; 101 uint8_t cmp_id, ocu_len; 102 int i; 103 104 ocu_len = ocu_i->u_len; 105 if (ocu_len == 0) { 106 memset(utf_o, 0, sizeof(struct ustr)); 107 return 0; 108 } 109 110 cmp_id = ocu_i->u_cmpID; 111 if (cmp_id != 8 && cmp_id != 16) { 112 memset(utf_o, 0, sizeof(struct ustr)); 113 pr_err("unknown compression code (%d) stri=%s\n", 114 cmp_id, ocu_i->u_name); 115 return -EINVAL; 116 } 117 118 ocu = ocu_i->u_name; 119 utf_o->u_len = 0; 120 for (i = 0; (i < ocu_len) && (utf_o->u_len <= (UDF_NAME_LEN - 3));) { 121 122 /* Expand OSTA compressed Unicode to Unicode */ 123 uint32_t c = ocu[i++]; 124 if (cmp_id == 16) 125 c = (c << 8) | ocu[i++]; 126 127 /* Compress Unicode to UTF-8 */ 128 if (c < 0x80U) 129 utf_o->u_name[utf_o->u_len++] = (uint8_t)c; 130 else if (c < 0x800U) { 131 if (utf_o->u_len > (UDF_NAME_LEN - 4)) 132 break; 133 utf_o->u_name[utf_o->u_len++] = 134 (uint8_t)(0xc0 | (c >> 6)); 135 utf_o->u_name[utf_o->u_len++] = 136 (uint8_t)(0x80 | (c & 0x3f)); 137 } else { 138 if (utf_o->u_len > (UDF_NAME_LEN - 5)) 139 break; 140 utf_o->u_name[utf_o->u_len++] = 141 (uint8_t)(0xe0 | (c >> 12)); 142 utf_o->u_name[utf_o->u_len++] = 143 (uint8_t)(0x80 | 144 ((c >> 6) & 0x3f)); 145 utf_o->u_name[utf_o->u_len++] = 146 (uint8_t)(0x80 | (c & 0x3f)); 147 } 148 } 149 utf_o->u_cmpID = 8; 150 151 return utf_o->u_len; 152 } 153 154 /* 155 * 156 * udf_UTF8toCS0 157 * 158 * PURPOSE 159 * Convert UTF-8 to the OSTA Compressed Unicode equivalent. 160 * 161 * DESCRIPTION 162 * This routine is only called by udf_lookup(). 163 * 164 * PRE-CONDITIONS 165 * ocu Pointer to OSTA Compressed Unicode output 166 * buffer of size UDF_NAME_LEN bytes. 167 * utf Pointer to UTF-8 input buffer. 168 * utf_len Length of UTF-8 input buffer in bytes. 169 * 170 * POST-CONDITIONS 171 * <return> Zero on success. 172 * 173 * HISTORY 174 * November 12, 1997 - Andrew E. Mileski 175 * Written, tested, and released. 176 */ 177 static int udf_UTF8toCS0(dstring *ocu, struct ustr *utf, int length) 178 { 179 unsigned c, i, max_val, utf_char; 180 int utf_cnt, u_len, u_ch; 181 182 memset(ocu, 0, sizeof(dstring) * length); 183 ocu[0] = 8; 184 max_val = 0xffU; 185 u_ch = 1; 186 187 try_again: 188 u_len = 0U; 189 utf_char = 0U; 190 utf_cnt = 0U; 191 for (i = 0U; i < utf->u_len; i++) { 192 /* Name didn't fit? */ 193 if (u_len + 1 + u_ch >= length) 194 return 0; 195 196 c = (uint8_t)utf->u_name[i]; 197 198 /* Complete a multi-byte UTF-8 character */ 199 if (utf_cnt) { 200 utf_char = (utf_char << 6) | (c & 0x3fU); 201 if (--utf_cnt) 202 continue; 203 } else { 204 /* Check for a multi-byte UTF-8 character */ 205 if (c & 0x80U) { 206 /* Start a multi-byte UTF-8 character */ 207 if ((c & 0xe0U) == 0xc0U) { 208 utf_char = c & 0x1fU; 209 utf_cnt = 1; 210 } else if ((c & 0xf0U) == 0xe0U) { 211 utf_char = c & 0x0fU; 212 utf_cnt = 2; 213 } else if ((c & 0xf8U) == 0xf0U) { 214 utf_char = c & 0x07U; 215 utf_cnt = 3; 216 } else if ((c & 0xfcU) == 0xf8U) { 217 utf_char = c & 0x03U; 218 utf_cnt = 4; 219 } else if ((c & 0xfeU) == 0xfcU) { 220 utf_char = c & 0x01U; 221 utf_cnt = 5; 222 } else { 223 goto error_out; 224 } 225 continue; 226 } else { 227 /* Single byte UTF-8 character (most common) */ 228 utf_char = c; 229 } 230 } 231 232 /* Choose no compression if necessary */ 233 if (utf_char > max_val) { 234 if (max_val == 0xffU) { 235 max_val = 0xffffU; 236 ocu[0] = (uint8_t)0x10U; 237 u_ch = 2; 238 goto try_again; 239 } 240 goto error_out; 241 } 242 243 if (max_val == 0xffffU) 244 ocu[++u_len] = (uint8_t)(utf_char >> 8); 245 ocu[++u_len] = (uint8_t)(utf_char & 0xffU); 246 } 247 248 if (utf_cnt) { 249 error_out: 250 ocu[++u_len] = '?'; 251 printk(KERN_DEBUG pr_fmt("bad UTF-8 character\n")); 252 } 253 254 ocu[length - 1] = (uint8_t)u_len + 1; 255 256 return u_len + 1; 257 } 258 259 static int udf_CS0toNLS(struct nls_table *nls, struct ustr *utf_o, 260 const struct ustr *ocu_i) 261 { 262 const uint8_t *ocu; 263 uint8_t cmp_id, ocu_len; 264 int i, len; 265 266 267 ocu_len = ocu_i->u_len; 268 if (ocu_len == 0) { 269 memset(utf_o, 0, sizeof(struct ustr)); 270 return 0; 271 } 272 273 cmp_id = ocu_i->u_cmpID; 274 if (cmp_id != 8 && cmp_id != 16) { 275 memset(utf_o, 0, sizeof(struct ustr)); 276 pr_err("unknown compression code (%d) stri=%s\n", 277 cmp_id, ocu_i->u_name); 278 return -EINVAL; 279 } 280 281 ocu = ocu_i->u_name; 282 utf_o->u_len = 0; 283 for (i = 0; (i < ocu_len) && (utf_o->u_len <= (UDF_NAME_LEN - 3));) { 284 /* Expand OSTA compressed Unicode to Unicode */ 285 uint32_t c = ocu[i++]; 286 if (cmp_id == 16) 287 c = (c << 8) | ocu[i++]; 288 289 len = nls->uni2char(c, &utf_o->u_name[utf_o->u_len], 290 UDF_NAME_LEN - 2 - utf_o->u_len); 291 /* Valid character? */ 292 if (len >= 0) 293 utf_o->u_len += len; 294 else 295 utf_o->u_name[utf_o->u_len++] = '?'; 296 } 297 utf_o->u_cmpID = 8; 298 299 return utf_o->u_len; 300 } 301 302 static int udf_NLStoCS0(struct nls_table *nls, dstring *ocu, struct ustr *uni, 303 int length) 304 { 305 int len; 306 unsigned i, max_val; 307 uint16_t uni_char; 308 int u_len, u_ch; 309 310 memset(ocu, 0, sizeof(dstring) * length); 311 ocu[0] = 8; 312 max_val = 0xffU; 313 u_ch = 1; 314 315 try_again: 316 u_len = 0U; 317 for (i = 0U; i < uni->u_len; i++) { 318 /* Name didn't fit? */ 319 if (u_len + 1 + u_ch >= length) 320 return 0; 321 len = nls->char2uni(&uni->u_name[i], uni->u_len - i, &uni_char); 322 if (!len) 323 continue; 324 /* Invalid character, deal with it */ 325 if (len < 0) { 326 len = 1; 327 uni_char = '?'; 328 } 329 330 if (uni_char > max_val) { 331 max_val = 0xffffU; 332 ocu[0] = (uint8_t)0x10U; 333 u_ch = 2; 334 goto try_again; 335 } 336 337 if (max_val == 0xffffU) 338 ocu[++u_len] = (uint8_t)(uni_char >> 8); 339 ocu[++u_len] = (uint8_t)(uni_char & 0xffU); 340 i += len - 1; 341 } 342 343 ocu[length - 1] = (uint8_t)u_len + 1; 344 return u_len + 1; 345 } 346 347 int udf_get_filename(struct super_block *sb, uint8_t *sname, int slen, 348 uint8_t *dname, int dlen) 349 { 350 struct ustr *filename, *unifilename; 351 int ret; 352 353 if (!slen) 354 return -EIO; 355 356 filename = kmalloc(sizeof(struct ustr), GFP_NOFS); 357 if (!filename) 358 return -ENOMEM; 359 360 unifilename = kmalloc(sizeof(struct ustr), GFP_NOFS); 361 if (!unifilename) { 362 ret = -ENOMEM; 363 goto out1; 364 } 365 366 udf_build_ustr_exact(unifilename, sname, slen); 367 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) { 368 ret = udf_CS0toUTF8(filename, unifilename); 369 if (ret < 0) { 370 udf_debug("Failed in udf_get_filename: sname = %s\n", 371 sname); 372 goto out2; 373 } 374 } else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) { 375 ret = udf_CS0toNLS(UDF_SB(sb)->s_nls_map, filename, 376 unifilename); 377 if (ret < 0) { 378 udf_debug("Failed in udf_get_filename: sname = %s\n", 379 sname); 380 goto out2; 381 } 382 } else 383 BUG(); 384 385 ret = udf_translate_to_linux(dname, dlen, 386 filename->u_name, filename->u_len, 387 unifilename->u_name, unifilename->u_len); 388 /* Zero length filename isn't valid... */ 389 if (ret == 0) 390 ret = -EINVAL; 391 out2: 392 kfree(unifilename); 393 out1: 394 kfree(filename); 395 return ret; 396 } 397 398 int udf_put_filename(struct super_block *sb, const uint8_t *sname, int slen, 399 uint8_t *dname, int dlen) 400 { 401 struct ustr unifilename; 402 int namelen; 403 404 if (!udf_char_to_ustr(&unifilename, sname, slen)) 405 return 0; 406 407 if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) { 408 namelen = udf_UTF8toCS0(dname, &unifilename, dlen); 409 if (!namelen) 410 return 0; 411 } else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) { 412 namelen = udf_NLStoCS0(UDF_SB(sb)->s_nls_map, dname, 413 &unifilename, dlen); 414 if (!namelen) 415 return 0; 416 } else 417 return 0; 418 419 return namelen; 420 } 421 422 #define ILLEGAL_CHAR_MARK '_' 423 #define EXT_MARK '.' 424 #define CRC_MARK '#' 425 #define EXT_SIZE 5 426 /* Number of chars we need to store generated CRC to make filename unique */ 427 #define CRC_LEN 5 428 429 static int udf_translate_to_linux(uint8_t *newName, int newLen, 430 uint8_t *udfName, int udfLen, 431 uint8_t *fidName, int fidNameLen) 432 { 433 int index, newIndex = 0, needsCRC = 0; 434 int extIndex = 0, newExtIndex = 0, hasExt = 0; 435 unsigned short valueCRC; 436 uint8_t curr; 437 438 if (udfName[0] == '.' && 439 (udfLen == 1 || (udfLen == 2 && udfName[1] == '.'))) { 440 needsCRC = 1; 441 newIndex = udfLen; 442 memcpy(newName, udfName, udfLen); 443 } else { 444 for (index = 0; index < udfLen; index++) { 445 curr = udfName[index]; 446 if (curr == '/' || curr == 0) { 447 needsCRC = 1; 448 curr = ILLEGAL_CHAR_MARK; 449 while (index + 1 < udfLen && 450 (udfName[index + 1] == '/' || 451 udfName[index + 1] == 0)) 452 index++; 453 } 454 if (curr == EXT_MARK && 455 (udfLen - index - 1) <= EXT_SIZE) { 456 if (udfLen == index + 1) 457 hasExt = 0; 458 else { 459 hasExt = 1; 460 extIndex = index; 461 newExtIndex = newIndex; 462 } 463 } 464 if (newIndex < newLen) 465 newName[newIndex++] = curr; 466 else 467 needsCRC = 1; 468 } 469 } 470 if (needsCRC) { 471 uint8_t ext[EXT_SIZE]; 472 int localExtIndex = 0; 473 474 if (hasExt) { 475 int maxFilenameLen; 476 for (index = 0; 477 index < EXT_SIZE && extIndex + index + 1 < udfLen; 478 index++) { 479 curr = udfName[extIndex + index + 1]; 480 481 if (curr == '/' || curr == 0) { 482 needsCRC = 1; 483 curr = ILLEGAL_CHAR_MARK; 484 while (extIndex + index + 2 < udfLen && 485 (index + 1 < EXT_SIZE && 486 (udfName[extIndex + index + 2] == '/' || 487 udfName[extIndex + index + 2] == 0))) 488 index++; 489 } 490 ext[localExtIndex++] = curr; 491 } 492 maxFilenameLen = newLen - CRC_LEN - localExtIndex; 493 if (newIndex > maxFilenameLen) 494 newIndex = maxFilenameLen; 495 else 496 newIndex = newExtIndex; 497 } else if (newIndex > newLen - CRC_LEN) 498 newIndex = newLen - CRC_LEN; 499 newName[newIndex++] = CRC_MARK; 500 valueCRC = crc_itu_t(0, fidName, fidNameLen); 501 newName[newIndex++] = hex_asc_upper_hi(valueCRC >> 8); 502 newName[newIndex++] = hex_asc_upper_lo(valueCRC >> 8); 503 newName[newIndex++] = hex_asc_upper_hi(valueCRC); 504 newName[newIndex++] = hex_asc_upper_lo(valueCRC); 505 506 if (hasExt) { 507 newName[newIndex++] = EXT_MARK; 508 for (index = 0; index < localExtIndex; index++) 509 newName[newIndex++] = ext[index]; 510 } 511 } 512 513 return newIndex; 514 } 515