URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [fs/] [udf/] [unicode.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 * unicode.c
 *
 * PURPOSE
 *      Routines for converting between UTF-8 and OSTA Compressed Unicode.
 *      Also handles filename mangling
 *
 * DESCRIPTION
 *      OSTA Compressed Unicode is explained in the OSTA UDF specification.
 *              http://www.osta.org/
 *      UTF-8 is explained in the IETF RFC XXXX.
 *              ftp://ftp.internic.net/rfc/rfcxxxx.txt
 *
 * COPYRIGHT
 *      This file is distributed under the terms of the GNU General Public
 *      License (GPL). Copies of the GPL can be obtained from:
 *              ftp://prep.ai.mit.edu/pub/gnu/GPL
 *      Each contributing author retains all rights to their own work.
 */
 
#include "udfdecl.h"
 
#include <linux/kernel.h>
#include <linux/string.h>       /* for memset */
#include <linux/nls.h>
#include <linux/udf_fs.h>
 
#include "udf_sb.h"
 
static int udf_translate_to_linux(uint8_t *, uint8_t *, int, uint8_t *, int);
 
static int udf_char_to_ustr(struct ustr *dest, const uint8_t *src, int strlen)
{
        if ((!dest) || (!src) || (!strlen) || (strlen > UDF_NAME_LEN - 2))
                return 0;
 
        memset(dest, 0, sizeof(struct ustr));
        memcpy(dest->u_name, src, strlen);
        dest->u_cmpID = 0x08;
        dest->u_len = strlen;
 
        return strlen;
}
 
/*
 * udf_build_ustr
 */
int udf_build_ustr(struct ustr *dest, dstring *ptr, int size)
{
        int usesize;
 
        if ((!dest) || (!ptr) || (!size))
                return -1;
 
        memset(dest, 0, sizeof(struct ustr));
        usesize = (size > UDF_NAME_LEN) ? UDF_NAME_LEN : size;
        dest->u_cmpID = ptr[0];
        dest->u_len = ptr[size - 1];
        memcpy(dest->u_name, ptr + 1, usesize - 1);
 
        return 0;
}
 
/*
 * udf_build_ustr_exact
 */
static int udf_build_ustr_exact(struct ustr *dest, dstring *ptr, int exactsize)
{
        if ((!dest) || (!ptr) || (!exactsize))
                return -1;
 
        memset(dest, 0, sizeof(struct ustr));
        dest->u_cmpID = ptr[0];
        dest->u_len = exactsize - 1;
        memcpy(dest->u_name, ptr + 1, exactsize - 1);
 
        return 0;
}
 
/*
 * udf_ocu_to_utf8
 *
 * PURPOSE
 *      Convert OSTA Compressed Unicode to the UTF-8 equivalent.
 *
 * DESCRIPTION
 *      This routine is only called by udf_filldir().
 *
 * PRE-CONDITIONS
 *      utf                     Pointer to UTF-8 output buffer.
 *      ocu                     Pointer to OSTA Compressed Unicode input buffer
 *                              of size UDF_NAME_LEN bytes.
 *                              both of type "struct ustr *"
 *
 * POST-CONDITIONS
 *      <return>                Zero on success.
 *
 * HISTORY
 *      November 12, 1997 - Andrew E. Mileski
 *      Written, tested, and released.
 */
int udf_CS0toUTF8(struct ustr *utf_o, struct ustr *ocu_i)
{
        uint8_t *ocu;
        uint32_t c;
        uint8_t cmp_id, ocu_len;
        int i;
 
        ocu = ocu_i->u_name;
 
        ocu_len = ocu_i->u_len;
        cmp_id = ocu_i->u_cmpID;
        utf_o->u_len = 0;
 
        if (ocu_len == 0) {
                memset(utf_o, 0, sizeof(struct ustr));
                utf_o->u_cmpID = 0;
                utf_o->u_len = 0;
                return 0;
        }
 
        if ((cmp_id != 8) && (cmp_id != 16)) {
                printk(KERN_ERR "udf: unknown compression code (%d) stri=%s\n",
                       cmp_id, ocu_i->u_name);
                return 0;
        }
 
        for (i = 0; (i < ocu_len) && (utf_o->u_len <= (UDF_NAME_LEN - 3));) {
 
                /* Expand OSTA compressed Unicode to Unicode */
                c = ocu[i++];
                if (cmp_id == 16)
                        c = (c << 8) | ocu[i++];
 
                /* Compress Unicode to UTF-8 */
                if (c < 0x80U) {
                        utf_o->u_name[utf_o->u_len++] = (uint8_t)c;
                } else if (c < 0x800U) {
                        utf_o->u_name[utf_o->u_len++] = (uint8_t)(0xc0 | (c >> 6));
                        utf_o->u_name[utf_o->u_len++] = (uint8_t)(0x80 | (c & 0x3f));
                } else {
                        utf_o->u_name[utf_o->u_len++] = (uint8_t)(0xe0 | (c >> 12));
                        utf_o->u_name[utf_o->u_len++] = (uint8_t)(0x80 | ((c >> 6) & 0x3f));
                        utf_o->u_name[utf_o->u_len++] = (uint8_t)(0x80 | (c & 0x3f));
                }
        }
        utf_o->u_cmpID = 8;
 
        return utf_o->u_len;
}
 
/*
 *
 * udf_utf8_to_ocu
 *
 * PURPOSE
 *      Convert UTF-8 to the OSTA Compressed Unicode equivalent.
 *
 * DESCRIPTION
 *      This routine is only called by udf_lookup().
 *
 * PRE-CONDITIONS
 *      ocu                     Pointer to OSTA Compressed Unicode output
 *                              buffer of size UDF_NAME_LEN bytes.
 *      utf                     Pointer to UTF-8 input buffer.
 *      utf_len                 Length of UTF-8 input buffer in bytes.
 *
 * POST-CONDITIONS
 *      <return>                Zero on success.
 *
 * HISTORY
 *      November 12, 1997 - Andrew E. Mileski
 *      Written, tested, and released.
 */
static int udf_UTF8toCS0(dstring *ocu, struct ustr *utf, int length)
{
        unsigned c, i, max_val, utf_char;
        int utf_cnt, u_len;
 
        memset(ocu, 0, sizeof(dstring) * length);
        ocu[0] = 8;
        max_val = 0xffU;
 
try_again:
        u_len = 0U;
        utf_char = 0U;
        utf_cnt = 0U;
        for (i = 0U; i < utf->u_len; i++) {
                c = (uint8_t)utf->u_name[i];
 
                /* Complete a multi-byte UTF-8 character */
                if (utf_cnt) {
                        utf_char = (utf_char << 6) | (c & 0x3fU);
                        if (--utf_cnt)
                                continue;
                } else {
                        /* Check for a multi-byte UTF-8 character */
                        if (c & 0x80U) {
                                /* Start a multi-byte UTF-8 character */
                                if ((c & 0xe0U) == 0xc0U) {
                                        utf_char = c & 0x1fU;
                                        utf_cnt = 1;
                                } else if ((c & 0xf0U) == 0xe0U) {
                                        utf_char = c & 0x0fU;
                                        utf_cnt = 2;
                                } else if ((c & 0xf8U) == 0xf0U) {
                                        utf_char = c & 0x07U;
                                        utf_cnt = 3;
                                } else if ((c & 0xfcU) == 0xf8U) {
                                        utf_char = c & 0x03U;
                                        utf_cnt = 4;
                                } else if ((c & 0xfeU) == 0xfcU) {
                                        utf_char = c & 0x01U;
                                        utf_cnt = 5;
                                } else {
                                        goto error_out;
                                }
                                continue;
                        } else {
                                /* Single byte UTF-8 character (most common) */
                                utf_char = c;
                        }
                }
 
                /* Choose no compression if necessary */
                if (utf_char > max_val) {
                        if (max_val == 0xffU) {
                                max_val = 0xffffU;
                                ocu[0] = (uint8_t)0x10U;
                                goto try_again;
                        }
                        goto error_out;
                }
 
                if (max_val == 0xffffU) {
                        ocu[++u_len] = (uint8_t)(utf_char >> 8);
                }
                ocu[++u_len] = (uint8_t)(utf_char & 0xffU);
        }
 
        if (utf_cnt) {
error_out:
                ocu[++u_len] = '?';
                printk(KERN_DEBUG "udf: bad UTF-8 character\n");
        }
 
        ocu[length - 1] = (uint8_t)u_len + 1;
 
        return u_len + 1;
}
 
static int udf_CS0toNLS(struct nls_table *nls, struct ustr *utf_o,
                        struct ustr *ocu_i)
{
        uint8_t *ocu;
        uint32_t c;
        uint8_t cmp_id, ocu_len;
        int i;
 
        ocu = ocu_i->u_name;
 
        ocu_len = ocu_i->u_len;
        cmp_id = ocu_i->u_cmpID;
        utf_o->u_len = 0;
 
        if (ocu_len == 0) {
                memset(utf_o, 0, sizeof(struct ustr));
                utf_o->u_cmpID = 0;
                utf_o->u_len = 0;
                return 0;
        }
 
        if ((cmp_id != 8) && (cmp_id != 16)) {
                printk(KERN_ERR "udf: unknown compression code (%d) stri=%s\n",
                       cmp_id, ocu_i->u_name);
                return 0;
        }
 
        for (i = 0; (i < ocu_len) && (utf_o->u_len <= (UDF_NAME_LEN - 3));) {
                /* Expand OSTA compressed Unicode to Unicode */
                c = ocu[i++];
                if (cmp_id == 16)
                        c = (c << 8) | ocu[i++];
 
                utf_o->u_len += nls->uni2char(c, &utf_o->u_name[utf_o->u_len],
                                              UDF_NAME_LEN - utf_o->u_len);
        }
        utf_o->u_cmpID = 8;
 
        return utf_o->u_len;
}
 
static int udf_NLStoCS0(struct nls_table *nls, dstring *ocu, struct ustr *uni,
                        int length)
{
        unsigned len, i, max_val;
        uint16_t uni_char;
        int u_len;
 
        memset(ocu, 0, sizeof(dstring) * length);
        ocu[0] = 8;
        max_val = 0xffU;
 
try_again:
        u_len = 0U;
        for (i = 0U; i < uni->u_len; i++) {
                len = nls->char2uni(&uni->u_name[i], uni->u_len - i, &uni_char);
                if (len <= 0)
                        continue;
 
                if (uni_char > max_val) {
                        max_val = 0xffffU;
                        ocu[0] = (uint8_t)0x10U;
                        goto try_again;
                }
 
                if (max_val == 0xffffU)
                        ocu[++u_len] = (uint8_t)(uni_char >> 8);
                ocu[++u_len] = (uint8_t)(uni_char & 0xffU);
                i += len - 1;
        }
 
        ocu[length - 1] = (uint8_t)u_len + 1;
        return u_len + 1;
}
 
int udf_get_filename(struct super_block *sb, uint8_t *sname, uint8_t *dname,
                     int flen)
{
        struct ustr filename, unifilename;
        int len;
 
        if (udf_build_ustr_exact(&unifilename, sname, flen)) {
                return 0;
        }
 
        if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) {
                if (!udf_CS0toUTF8(&filename, &unifilename)) {
                        udf_debug("Failed in udf_get_filename: sname = %s\n", sname);
                        return 0;
                }
        } else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) {
                if (!udf_CS0toNLS(UDF_SB(sb)->s_nls_map, &filename, &unifilename)) {
                        udf_debug("Failed in udf_get_filename: sname = %s\n", sname);
                        return 0;
                }
        } else {
                return 0;
        }
 
        len = udf_translate_to_linux(dname, filename.u_name, filename.u_len,
                                     unifilename.u_name, unifilename.u_len);
        if (len) {
                return len;
        }
 
        return 0;
}
 
int udf_put_filename(struct super_block *sb, const uint8_t *sname,
                     uint8_t *dname, int flen)
{
        struct ustr unifilename;
        int namelen;
 
        if (!(udf_char_to_ustr(&unifilename, sname, flen))) {
                return 0;
        }
 
        if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) {
                namelen = udf_UTF8toCS0(dname, &unifilename, UDF_NAME_LEN);
                if (!namelen) {
                        return 0;
                }
        } else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) {
                namelen = udf_NLStoCS0(UDF_SB(sb)->s_nls_map, dname, &unifilename, UDF_NAME_LEN);
                if (!namelen) {
                        return 0;
                }
        } else {
                return 0;
        }
 
        return namelen;
}
 
#define ILLEGAL_CHAR_MARK       '_'
#define EXT_MARK                '.'
#define CRC_MARK                '#'
#define EXT_SIZE                5
 
static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, int udfLen,
                                  uint8_t *fidName, int fidNameLen)
{
        int index, newIndex = 0, needsCRC = 0;
        int extIndex = 0, newExtIndex = 0, hasExt = 0;
        unsigned short valueCRC;
        uint8_t curr;
        const uint8_t hexChar[] = "0123456789ABCDEF";
 
        if (udfName[0] == '.' &&
            (udfLen == 1 || (udfLen == 2 && udfName[1] == '.'))) {
                needsCRC = 1;
                newIndex = udfLen;
                memcpy(newName, udfName, udfLen);
        } else {
                for (index = 0; index < udfLen; index++) {
                        curr = udfName[index];
                        if (curr == '/' || curr == 0) {
                                needsCRC = 1;
                                curr = ILLEGAL_CHAR_MARK;
                                while (index + 1 < udfLen && (udfName[index + 1] == '/' ||
                                                              udfName[index + 1] == 0))
                                        index++;
                        } if (curr == EXT_MARK && (udfLen - index - 1) <= EXT_SIZE) {
                                if (udfLen == index + 1) {
                                        hasExt = 0;
                                } else {
                                        hasExt = 1;
                                        extIndex = index;
                                        newExtIndex = newIndex;
                                }
                        }
                        if (newIndex < 256)
                                newName[newIndex++] = curr;
                        else
                                needsCRC = 1;
                }
        }
        if (needsCRC) {
                uint8_t ext[EXT_SIZE];
                int localExtIndex = 0;
 
                if (hasExt) {
                        int maxFilenameLen;
                        for(index = 0; index < EXT_SIZE && extIndex + index + 1 < udfLen; index++) {
                                curr = udfName[extIndex + index + 1];
 
                                if (curr == '/' || curr == 0) {
                                        needsCRC = 1;
                                        curr = ILLEGAL_CHAR_MARK;
                                        while(extIndex + index + 2 < udfLen &&
                                              (index + 1 < EXT_SIZE
                                               && (udfName[extIndex + index + 2] == '/' ||
                                                   udfName[extIndex + index + 2] == 0)))
                                                index++;
                                }
                                ext[localExtIndex++] = curr;
                        }
                        maxFilenameLen = 250 - localExtIndex;
                        if (newIndex > maxFilenameLen)
                                newIndex = maxFilenameLen;
                        else
                                newIndex = newExtIndex;
                } else if (newIndex > 250) {
                        newIndex = 250;
                }
                newName[newIndex++] = CRC_MARK;
                valueCRC = udf_crc(fidName, fidNameLen, 0);
                newName[newIndex++] = hexChar[(valueCRC & 0xf000) >> 12];
                newName[newIndex++] = hexChar[(valueCRC & 0x0f00) >> 8];
                newName[newIndex++] = hexChar[(valueCRC & 0x00f0) >> 4];
                newName[newIndex++] = hexChar[(valueCRC & 0x000f)];
 
                if (hasExt) {
                        newName[newIndex++] = EXT_MARK;
                        for (index = 0; index < localExtIndex; index++)
                                newName[newIndex++] = ext[index];
                }
        }
 
        return newIndex;
}

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [fs/] [udf/] [unicode.c] - Blame information for rev 62

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