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