cifs: change cifs_get_name_from_search_buf to use new unicode helper

...and remove cifs_convertUCSpath. There are no more callers. Also add a
#define for the buffer used in the readdir path so that we don't have so
many magic numbers floating around.

Signed-off-by: Jeff Layton <jlayton@redhat.com>
Acked-by: Suresh Jayaraman <sjayaraman@suse.de>
Signed-off-by: Steve French <sfrench@us.ibm.com>

diff --git a/fs/cifs/cifsproto.h b/fs/cifs/cifsproto.h
index 7d54a5a..fae0839 100644 (file)
--- a/fs/cifs/cifsproto.h
+++ b/fs/cifs/cifsproto.h
@@ -306,8 +306,6 @@ extern int CIFSGetSrvInodeNumber(const int xid, struct cifsTconInfo *tcon,
                        const unsigned char *searchName, __u64 *inode_number,
                        const struct nls_table *nls_codepage,
                        int remap_special_chars);
-extern int cifs_convertUCSpath(char *target, const __le16 *source, int maxlen,
-                       const struct nls_table *codepage);
 extern int cifsConvertToUCS(__le16 *target, const char *source, int maxlen,
                        const struct nls_table *cp, int mapChars);
 

diff --git a/fs/cifs/misc.c b/fs/cifs/misc.c
index bb81c8a..e079a91 100644 (file)
--- a/fs/cifs/misc.c
+++ b/fs/cifs/misc.c
@@ -635,66 +635,6 @@ dump_smb(struct smb_hdr *smb_buf, int smb_buf_length)
        return;
 }
 
-/* Convert 16 bit Unicode pathname from wire format to string in current code
-   page.  Conversion may involve remapping up the seven characters that are
-   only legal in POSIX-like OS (if they are present in the string). Path
-   names are little endian 16 bit Unicode on the wire */
-int
-cifs_convertUCSpath(char *target, const __le16 *source, int maxlen,
-                   const struct nls_table *cp)
-{
-       int i, j, len;
-       __u16 src_char;
-
-       for (i = 0, j = 0; i < maxlen; i++) {
-               src_char = le16_to_cpu(source[i]);
-               switch (src_char) {
-                       case 0:
-                               goto cUCS_out; /* BB check this BB */
-                       case UNI_COLON:
-                               target[j] = ':';
-                               break;
-                       case UNI_ASTERIK:
-                               target[j] = '*';
-                               break;
-                       case UNI_QUESTION:
-                               target[j] = '?';
-                               break;
-                       /* BB We can not handle remapping slash until
-                          all the calls to build_path_from_dentry
-                          are modified, as they use slash as separator BB */
-                       /* case UNI_SLASH:
-                               target[j] = '\\';
-                               break;*/
-                       case UNI_PIPE:
-                               target[j] = '|';
-                               break;
-                       case UNI_GRTRTHAN:
-                               target[j] = '>';
-                               break;
-                       case UNI_LESSTHAN:
-                               target[j] = '<';
-                               break;
-                       default:
-                               len = cp->uni2char(src_char, &target[j],
-                                               NLS_MAX_CHARSET_SIZE);
-                               if (len > 0) {
-                                       j += len;
-                                       continue;
-                               } else {
-                                       target[j] = '?';
-                               }
-               }
-               j++;
-               /* make sure we do not overrun callers allocated temp buffer */
-               if (j >= (2 * NAME_MAX))
-                       break;
-       }
-cUCS_out:
-       target[j] = 0;
-       return j;
-}
-
 /* Convert 16 bit Unicode pathname to wire format from string in current code
    page.  Conversion may involve remapping up the seven characters that are
    only legal in POSIX-like OS (if they are present in the string). Path

diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index ebd0da7..e1351fe 100644 (file)
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -31,6 +31,13 @@
 #include "cifs_fs_sb.h"
 #include "cifsfs.h"
 
+/*
+ * To be safe - for UCS to UTF-8 with strings loaded with the rare long
+ * characters alloc more to account for such multibyte target UTF-8
+ * characters.
+ */
+#define UNICODE_NAME_MAX ((4 * NAME_MAX) + 2)
+
 #ifdef CONFIG_CIFS_DEBUG2
 static void dump_cifs_file_struct(struct file *file, char *label)
 {
@@ -881,14 +888,11 @@ static int cifs_get_name_from_search_buf(struct qstr *pqst,
        }
 
        if (unicode) {
-               /* BB fixme - test with long names */
-               /* Note converted filename can be longer than in unicode */
-               if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
-                       pqst->len = cifs_convertUCSpath((char *)pqst->name,
-                                       (__le16 *)filename, len/2, nlt);
-               else
-                       pqst->len = cifs_strfromUCS_le((char *)pqst->name,
-                                       (__le16 *)filename, len/2, nlt);
+               pqst->len = cifs_from_ucs2((char *) pqst->name,
+                                          (__le16 *) filename,
+                                          UNICODE_NAME_MAX, max_len, nlt,
+                                          cifs_sb->mnt_cifs_flags &
+                                               CIFS_MOUNT_MAP_SPECIAL_CHR);
        } else {
                pqst->name = filename;
                pqst->len = len;
@@ -1070,11 +1074,7 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
                                cifsFile->srch_inf.ntwrk_buf_start);
                end_of_smb = cifsFile->srch_inf.ntwrk_buf_start + max_len;
 
-               /* To be safe - for UCS to UTF-8 with strings loaded
-               with the rare long characters alloc more to account for
-               such multibyte target UTF-8 characters. cifs_unicode.c,
-               which actually does the conversion, has the same limit */
-               tmp_buf = kmalloc((4 * NAME_MAX) + 2, GFP_KERNEL);
+               tmp_buf = kmalloc(UNICODE_NAME_MAX, GFP_KERNEL);
                for (i = 0; (i < num_to_fill) && (rc == 0); i++) {
                        if (current_entry == NULL) {
                                /* evaluate whether this case is an error */