1 files changed, 110 insertions, 148 deletions

diff --git a/fs/udf/unicode.c b/fs/udf/unicode.c
index 706c92e1dcc9..9e6099c26c27 100644
--- a/fs/udf/unicode.c
+++ b/fs/udf/unicode.c
@@ -31,12 +31,14 @@ 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) )
+        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;
 }
 
@@ -47,14 +49,15 @@ int udf_build_ustr(struct ustr *dest, dstring *ptr, int size)
 {
         int usesize;
 
-        if ( (!dest) || (!ptr) || (!size) )
+        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);
+        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;
 }
 
@@ -63,13 +66,14 @@ int udf_build_ustr(struct ustr *dest, dstring *ptr, int size)
  */
 static int udf_build_ustr_exact(struct ustr *dest, dstring *ptr, int exactsize)
 {
-        if ( (!dest) || (!ptr) || (!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);
+        dest->u_cmpID = ptr[0];
+        dest->u_len = exactsize - 1;
+        memcpy(dest->u_name, ptr + 1, exactsize - 1);
+
         return 0;
 }
 
@@ -108,22 +112,20 @@ int udf_CS0toUTF8(struct ustr *utf_o, struct ustr *ocu_i)
         cmp_id = ocu_i->u_cmpID;
         utf_o->u_len = 0;
 
-        if (ocu_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);
+        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)) ;)
-        {
+        for (i = 0; (i < ocu_len) && (utf_o->u_len <= (UDF_NAME_LEN - 3));) {
 
                 /* Expand OSTA compressed Unicode to Unicode */
                 c = ocu[i++];
@@ -131,21 +133,18 @@ int udf_CS0toUTF8(struct ustr *utf_o, struct ustr *ocu_i)
                         c = (c << 8) | ocu[i++];
 
                 /* Compress Unicode to UTF-8 */
-                if (c < 0x80U)
+                if (c < 0x80U) {
                         utf_o->u_name[utf_o->u_len++] = (uint8_t)c;
-                else if (c < 0x800U)
-                {
+                } 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
-                {
+                } 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;
+        utf_o->u_cmpID = 8;
 
         return utf_o->u_len;
 }
@@ -186,61 +185,46 @@ try_again:
         u_len = 0U;
         utf_char = 0U;
         utf_cnt = 0U;
-        for (i = 0U; i < utf->u_len; i++)
-        {
+        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)
-                {
+                if (utf_cnt) {
                         utf_char = (utf_char << 6) | (c & 0x3fU);
                         if (--utf_cnt)
                                 continue;
-                }
-                else
-                {
+                } else {
                         /* Check for a multi-byte UTF-8 character */
-                        if (c & 0x80U)
-                        {
+                        if (c & 0x80U) {
                                 /* Start a multi-byte UTF-8 character */
-                                if ((c & 0xe0U) == 0xc0U)
-                                {
+                                if ((c & 0xe0U) == 0xc0U) {
                                         utf_char = c & 0x1fU;
                                         utf_cnt = 1;
-                                }
-                                else if ((c & 0xf0U) == 0xe0U)
-                                {
+                                } else if ((c & 0xf0U) == 0xe0U) {
                                         utf_char = c & 0x0fU;
                                         utf_cnt = 2;
-                                }
-                                else if ((c & 0xf8U) == 0xf0U)
-                                {
+                                } else if ((c & 0xf8U) == 0xf0U) {
                                         utf_char = c & 0x07U;
                                         utf_cnt = 3;
-                                }
-                                else if ((c & 0xfcU) == 0xf8U)
-                                {
+                                } else if ((c & 0xfcU) == 0xf8U) {
                                         utf_char = c & 0x03U;
                                         utf_cnt = 4;
-                                }
-                                else if ((c & 0xfeU) == 0xfcU)
-                                {
+                                } else if ((c & 0xfeU) == 0xfcU) {
                                         utf_char = c & 0x01U;
                                         utf_cnt = 5;
-                                }
-                                else
+                                } else {
                                         goto error_out;
+                                }
                                 continue;
-                        } else
+                        } else {
                                 /* Single byte UTF-8 character (most common) */
                                 utf_char = c;
+                        }
                 }
 
                 /* Choose no compression if necessary */
-                if (utf_char > max_val)
-                {
-                        if ( 0xffU == max_val )
-                        {
+                if (utf_char > max_val) {
+                        if (max_val == 0xffU) {
                                 max_val = 0xffffU;
                                 ocu[0] = (uint8_t)0x10U;
                                 goto try_again;
@@ -248,26 +232,25 @@ try_again:
                         goto error_out;
                 }
 
-                if (max_val == 0xffffU)
-                {
+                if (max_val == 0xffffU) {
                         ocu[++u_len] = (uint8_t)(utf_char >> 8);
                 }
                 ocu[++u_len] = (uint8_t)(utf_char & 0xffU);
         }
 
-
-        if (utf_cnt)
-        {
+        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)
+static int udf_CS0toNLS(struct nls_table *nls, struct ustr *utf_o,
+                        struct ustr *ocu_i)
 {
         uint8_t *ocu;
         uint32_t c;
@@ -280,36 +263,35 @@ static int udf_CS0toNLS(struct nls_table *nls, struct ustr *utf_o, struct ustr *
         cmp_id = ocu_i->u_cmpID;
         utf_o->u_len = 0;
 
-        if (ocu_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);
+        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)) ;)
-        {
+        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_len += nls->uni2char(c, &utf_o->u_name[utf_o->u_len],
+                                              UDF_NAME_LEN - utf_o->u_len);
         }
-        utf_o->u_cmpID=8;
+        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)
+static int udf_NLStoCS0(struct nls_table *nls, dstring *ocu, struct ustr *uni,
+                        int length)
 {
         unsigned len, i, max_val;
         uint16_t uni_char;
@@ -321,19 +303,17 @@ static int udf_NLStoCS0(struct nls_table *nls, dstring *ocu, struct ustr *uni, i
 
 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);
+        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)
-                {
+                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);
@@ -344,112 +324,98 @@ try_again:
         return u_len + 1;
 }
 
-int udf_get_filename(struct super_block *sb, uint8_t *sname, uint8_t *dname, int flen)
+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))
-        {
+        if (udf_build_ustr_exact(&unifilename, sname, flen)) {
                 return 0;
         }
 
-        if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8))
-        {
-                if (!udf_CS0toUTF8(&filename, &unifilename) )
-                {
+        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) )
-                {
+        } 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
+        } else {
                 return 0;
+        }
 
-        if ((len = udf_translate_to_linux(dname, filename.u_name, filename.u_len,
-                unifilename.u_name, unifilename.u_len)))
-        {
+        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)
+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)) )
-        {
+        if (!(udf_char_to_ustr(&unifilename, sname, flen))) {
                 return 0;
         }
 
-        if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8))
-        {
-                if ( !(namelen = udf_UTF8toCS0(dname, &unifilename, UDF_NAME_LEN)) )
-                {
+        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))
-        {
-                if ( !(namelen = udf_NLStoCS0(UDF_SB(sb)->s_nls_map, dname, &unifilename, UDF_NAME_LEN)) )
-                {
+        } 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
+        } else {
                 return 0;
+        }
 
         return namelen;
 }
 
 #define ILLEGAL_CHAR_MARK       '_'
-#define EXT_MARK                        '.'
-#define CRC_MARK                        '#'
-#define EXT_SIZE                        5
+#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)
+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 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] == '.')))
-        {
+        if (udfName[0] == '.' &&
+            (udfLen == 1 || (udfLen == 2 && udfName[1] == '.'))) {
                 needsCRC = 1;
                 newIndex = udfLen;
                 memcpy(newName, udfName, udfLen);
-        }
-        else
-        {       
-                for (index = 0; index < udfLen; index++)
-                {
+        } else {
+                for (index = 0; index < udfLen; index++) {
                         curr = udfName[index];
-                        if (curr == '/' || curr == 0)
-                        {
+                        if (curr == '/' || curr == 0) {
                                 needsCRC = 1;
                                 curr = ILLEGAL_CHAR_MARK;
-                                while (index+1 < udfLen && (udfName[index+1] == '/' ||
-                                        udfName[index+1] == 0))
+                                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)
+                        } if (curr == EXT_MARK && (udfLen - index - 1) <= EXT_SIZE) {
+                                if (udfLen == index + 1) {
                                         hasExt = 0;
-                                else
-                                {
+                                } else {
                                         hasExt = 1;
                                         extIndex = index;
                                         newExtIndex = newIndex;
@@ -461,26 +427,22 @@ static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, int udfLen
                                 needsCRC = 1;
                 }
         }
-        if (needsCRC)
-        {
+        if (needsCRC) {
                 uint8_t ext[EXT_SIZE];
                 int localExtIndex = 0;
 
-                if (hasExt)
-                {
+                if (hasExt) {
                         int maxFilenameLen;
-                        for(index = 0; index<EXT_SIZE && extIndex + index +1 < udfLen;
-                                index++ )
-                        {
+                        for(index = 0; index < EXT_SIZE && extIndex + index + 1 < udfLen; index++) {
                                 curr = udfName[extIndex + index + 1];
 
-                                if (curr == '/' || curr == 0)
-                                {
+                                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)))
+                                        while(extIndex + index + 2 < udfLen &&
+                                              (index + 1 < EXT_SIZE
+                                               && (udfName[extIndex + index + 2] == '/' ||
+                                                   udfName[extIndex + index + 2] == 0)))
                                                 index++;
                                 }
                                 ext[localExtIndex++] = curr;
@@ -490,9 +452,9 @@ static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, int udfLen
                                 newIndex = maxFilenameLen;
                         else
                                 newIndex = newExtIndex;
-                }
-                else if (newIndex > 250)
+                } else if (newIndex > 250) {
                         newIndex = 250;
+                }
                 newName[newIndex++] = CRC_MARK;
                 valueCRC = udf_crc(fidName, fidNameLen, 0);
                 newName[newIndex++] = hexChar[(valueCRC & 0xf000) >> 12];
@@ -500,12 +462,12 @@ static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, int udfLen
                 newName[newIndex++] = hexChar[(valueCRC & 0x00f0) >> 4];
                 newName[newIndex++] = hexChar[(valueCRC & 0x000f)];
 
-                if (hasExt)
-                {
+                if (hasExt) {
                         newName[newIndex++] = EXT_MARK;
-                        for (index = 0;index < localExtIndex ;index++ )
+                        for (index = 0; index < localExtIndex; index++)
                                 newName[newIndex++] = ext[index];
                 }
         }
+
         return newIndex;
 }