unicode.c 11 KB

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