[IA64] Minimize per_cpu reservations.
[linux-2.6] / fs / udf / unicode.c
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 }