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